GroboUtils is a large package of various Java utilities. It attempts to
have both JDK 1.1 and 1.2 compatiblity for most of the packages.
JUnit helpers and extentions
JUnit extentions for easing test making.
Similar to the Assert class in JUnit, but allows for testing
objects and classes for the existence of different
Creates Test objects that execute a single assert. Used to
create 'soft' (sub) tests during integration testing.
Subclass of TestCase that allows for a test to dynamically
register a sub-test, which will be run after the owning test
finishes, and in new tests.
Subclass of TestCase designed for integration tests, which
generally need 'soft' failures - a failure which does not need
to stop the execution of the test.
A utility class which executes a collection of small test
methods in parallel. Capable of specifying a maximum run time
to prevent dead-locks or infinite loops from hanging the test
execution. Propigates all errors to the owning class.
Utility that allows for easy setting and reseting of System
properties. Some classes that need testing may depend upon a
System property setting, and this class will help testing that.
This is JDK 1.1 and above compatible.
Updates to MultiThreadedTestRunner allow for monitors to check
the status of runners without needing to quit, and added the
ability to kill wild threads. The documentation for this has
been updated as well.
Test Class Parsing
Extracted the functionality used by
junit.framework.TestSuite to parse the Test classes, and
enabled it for easy exension to support different construction
This is fairly stable, but the code coverage reports show that
it needs a bit more testing in some areas.
Hierarchial Unit Tests
JUnit extention for helping in the creation of hierarchial test
cases, also known as 'contract' or 'interface' test-cases.
Found and fixed a minor bug with passing the message on an
assert in IntegrationTestCase.
AutoDoc allows for JUnit tests to generate documentation for
themselves. Pluggable to allow user-defined extensions for each
Need to expand testing and update documents before this can enter
The Problem Management Tracker Interface. A framework for
interfacing with Problem Management Trackers (a.k.a. bug
trackers). Includes SPI connectors for the AutoDoc framework.
Looking at moving the location of the tracking numbers from
code to XDoclet. If so, this will be a major change and
Still need example implementations for Sourceforge (web-based) and
Complete the documentation. As the system is in flux, this
is an on-going task.
Test Procedure generation classes. Includes SPI connectors for the
Currently examining the viability of the sub-project, as to whether
it is the right application of technology.
There are several commercially available code coverage tools for
Java, but they all require a large fee to use. This is a 100% Pure
Java implementation of a Code Coverage tool. It uses Jakarta's
BCEL platform to post-compile class files to add logging statements
for tracking coverage.
Final changes to the documentation before release of the next
A UI capture program for Java. Allows for capture and playback
ability in any graphical application running on the local system.
Able to capture and play-back UI interactions, but capturing has
issues with the underlying UIs being interacted with: due to the
glass pane manipulation and click pass-through implementation,
UI components such as menus disappear.
Utilities that allow for easy access to Classes and instantiating
them. Includes helper utilities for the Service Provider Interface
(SPI), as presented in JDK 1.3. This package is JDK 1.1
compatible, but will use JDK 1.2+ methods when allowed.
Documentation still needs a bit of work, but this has been moved
up to RC1.
Utilities that aid in creating exceptions with causes (a la JDK
1.4), and for parsing exceptions. This package is JDK 1.1
compatible, but will use the JDK 1.4-introduced exception methods
May remove this
project in favor of Jakarta Commons Lang 1.0.
Utilities for converting standard text into XML-escaped strings,
without the need for DOM heavyweight libraries.
Entered version 1.0.0rc1. Need to complete documentation.
Groups of JDK 1.1 and 1.2 I/O helper classes.
- File Filters:
Helper classes for generating filters for the java.io.File
- Input Stream Generators:
Classes which generate new IO Stream from a given relative URL.
Example implementations are provided, including File, URL,
Classpath Resource, and Hashtable.
- Mime Encoding Streams:
Input and Output streams for Mime encoded text.
- Read Stream:
Utilities for reading an entire stream in different formats.
The basic JDK has classes which convert from an OutputStream to
a Writer, but does not provide any implementation for the
reverse. This class fills that gap.
Has a concept of pre-defined properties, and user-defined
properties. As many "internal" properties may be added to the
database, but any properties the user sets will be stored in
their own property file.
Need to finish up tests and documentation before entering RC 1.
Contains various data structures, all JDK 1.1 compatible.
A tree structure which allows for elements to be registered,
deregistered, and accessed. Tree elements can define themselves
as case sensitive or insensitive. They may also define that all
sub-nodes should return the current parent node. Nodes are
accessed through a single String, which is parsed internally.
The path separator may be any character.
A Queue (first-in, first-out) which allows for waiting
indefinitely or for a specific period of time for a new
element to be added to the Queue. Useful for passing data
between threads. This has been optimized for synchronization.
A store of reserved objects to prevent the Garbage Collector
from working overtime on commonly used objects. It has options
for setting the maximum and minimum sizes for the number of
Just entered RC 1. The documentation will need to be completed
before this goes gold.
Collection of utilities to help with thread and process management.
Class which allows for better interaction with a spawned
Process. It forks the process's output streams to other
A thread which pulls data from an input stream and pushes it
into an output stream.
Implements safe pause, resume, and stop for threads which loop
over the same function endlessly. Allows for a sleep period
between loop iterations.
Thread-safe implementation of pulling objects from a
SynchQueue, and passing them to a listening object.
A pool of QueueThread instances, which handles menial tasks
such as growing the thread pool if the number of waiting
objects is above a threshold number, up to a maximum number of
threads, finding the thread with the fewest number of waiting
objects, and optimization of determining which thread to pass
Need to finish up tests and documentation before entering RC 1.