Thread: [Bigdata-commit] SF.net SVN: bigdata:[3521] branches/maven_scaleout/bigdata-core

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 3521
          http://bigdata.svn.sourceforge.net/bigdata/?rev=3521&view=rev
Author:   fkoliver
Date:     2010-09-08 20:09:11 +0000 (Wed, 08 Sep 2010)

Log Message:
-----------

Remove dependency on cweb-junit-*.jar by copying the sources into this
project. This is a temporary step: the extensions should be eventually
be removed as we move to junit 4.x.

Modified Paths:
--------------
    branches/maven_scaleout/bigdata-core/pom.xml
    branches/maven_scaleout/bigdata-core/src/test/deploy/testing/conf/standalone/ServerStarter.config
    branches/maven_scaleout/bigdata-core/thirdparty/maven.xml

Added Paths:
-----------
    branches/maven_scaleout/bigdata-core/src/test/java/junit/
    branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/
    branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/
    branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/IProxyTest.java
    branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/ProxyTestSuite.java
    branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/package.html
    branches/maven_scaleout/bigdata-core/src/test/java/junit/framework/
    branches/maven_scaleout/bigdata-core/src/test/java/junit/framework/TestCase2.java
    branches/maven_scaleout/bigdata-core/src/test/java/junit/framework/package.html

Removed Paths:
-------------
    branches/maven_scaleout/bigdata-core/thirdparty/lib/cweb-junit-ext-1.1-b3-dev.jar

Property Changed:
----------------
    branches/maven_scaleout/bigdata-core/


Property changes on: branches/maven_scaleout/bigdata-core
___________________________________________________________________
Added: svn:ignore
   + target


Modified: branches/maven_scaleout/bigdata-core/pom.xml
===================================================================

--- branches/maven_scaleout/bigdata-core/pom.xml	2010-09-08 14:52:29 UTC (rev 3520)
+++ branches/maven_scaleout/bigdata-core/pom.xml	2010-09-08 20:09:11 UTC (rev 3521)
@@ -216,12 +216,6 @@
         </dependency>
         <dependency>
             <groupId>${thirdParty.groupId}</groupId>
-            <artifactId>cweb-junit-ext</artifactId>
-            <version>1.1.0-b3-dev</version>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>${thirdParty.groupId}</groupId>
             <artifactId>cweb-commons</artifactId>
             <version>1.1.0-b2-dev</version>
         </dependency>

Modified: branches/maven_scaleout/bigdata-core/src/test/deploy/testing/conf/standalone/ServerStarter.config
===================================================================
--- branches/maven_scaleout/bigdata-core/src/test/deploy/testing/conf/standalone/ServerStarter.config	2010-09-08 14:52:29 UTC (rev 3520)
+++ branches/maven_scaleout/bigdata-core/src/test/deploy/testing/conf/standalone/ServerStarter.config	2010-09-08 20:09:11 UTC (rev 3521)
@@ -59,7 +59,6 @@
 	libdir+"icu4j-3_6.jar"+File.pathSeparator+
 	// test suites only!
 	libdir+"junit-3.8.1.jar"+File.pathSeparator+
-	libdir+"cweb-junit-ext-1.1-b2-dev.jar"+File.pathSeparator+
 	// main bigdata JAR.
 	//libdir+
 	"bigdata-core.jar"

Added: branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/IProxyTest.java
===================================================================
--- branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/IProxyTest.java	                        (rev 0)
+++ branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/IProxyTest.java	2010-09-08 20:09:11 UTC (rev 3521)
@@ -0,0 +1,77 @@
+/**
+
+The Notice below must appear in each file of the Source Code of any
+copy you distribute of the Licensed Product.  Contributors to any
+Modifications may add their own copyright notices to identify their
+own contributions.
+
+License:
+
+The contents of this file are subject to the CognitiveWeb Open Source
+License Version 1.1 (the License).  You may not copy or use this file,
+in either source code or executable form, except in compliance with
+the License.  You may obtain a copy of the License from
+
+  http://www.CognitiveWeb.org/legal/license/
+
+Software distributed under the License is distributed on an AS IS
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+the License for the specific language governing rights and limitations
+under the License.
+
+Copyrights:
+
+Portions created by or assigned to CognitiveWeb are Copyright
+(c) 2003-2003 CognitiveWeb.  All Rights Reserved.  Contact
+information for CognitiveWeb is available at
+
+  http://www.CognitiveWeb.org
+
+Portions Copyright (c) 2002-2003 Bryan Thompson.
+
+Acknowledgements:
+
+Special thanks to the developers of the Jabber Open Source License 1.0
+(JOSL), from which this License was derived.  This License contains
+terms that differ from JOSL.
+
+Special thanks to the CognitiveWeb Open Source Contributors for their
+suggestions and support of the Cognitive Web.
+
+Modifications:
+
+*/
+
+package junit.extensions.proxy;
+
+import junit.framework.*;
+
+/**
+ * A {@link Test} that holds a reference to a delegate.  Normally the
+ * delegate will extend {@link TestCase} to provide, possibly
+ * persistent, implementation specific logic for establishing test
+ * fixtures.  The delegate is normally an instance of your concrete
+ * implementation specific test harness with access to any required
+ * configuration data, e.g., a properties file.
+ */
+
+public interface IProxyTest
+    extends Test
+{
+
+    /**
+     * Sets the delegate.  {@link ProxyTestSuite} uses this method to
+     * set the delegate on each test class instance that it creates
+     * that implements the {@link IProxyTest} interface.
+     */
+
+    public void setDelegate( Test delegate );
+
+    /**
+     * Returns the reference to the delegate or <code>null</code> if
+     * the delegate was not established.
+     */
+
+    public Test getDelegate();
+
+}


Property changes on: branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/IProxyTest.java
___________________________________________________________________
Added: svn:keywords
   + Id Date Revision Author HeadURL

Added: branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/ProxyTestSuite.java
===================================================================
--- branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/ProxyTestSuite.java	                        (rev 0)
+++ branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/ProxyTestSuite.java	2010-09-08 20:09:11 UTC (rev 3521)
@@ -0,0 +1,395 @@
+/**
+
+The Notice below must appear in each file of the Source Code of any
+copy you distribute of the Licensed Product.  Contributors to any
+Modifications may add their own copyright notices to identify their
+own contributions.
+
+License:
+
+The contents of this file are subject to the CognitiveWeb Open Source
+License Version 1.1 (the License).  You may not copy or use this file,
+in either source code or executable form, except in compliance with
+the License.  You may obtain a copy of the License from
+
+  http://www.CognitiveWeb.org/legal/license/
+
+Software distributed under the License is distributed on an AS IS
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+the License for the specific language governing rights and limitations
+under the License.
+
+Copyrights:
+
+Portions created by or assigned to CognitiveWeb are Copyright
+(c) 2003-2003 CognitiveWeb.  All Rights Reserved.  Contact
+information for CognitiveWeb is available at
+
+  http://www.CognitiveWeb.org
+
+Portions Copyright (c) 2002-2003 Bryan Thompson.
+
+Acknowledgements:
+
+Special thanks to the developers of the Jabber Open Source License 1.0
+(JOSL), from which this License was derived.  This License contains
+terms that differ from JOSL.
+
+Special thanks to the CognitiveWeb Open Source Contributors for their
+suggestions and support of the Cognitive Web.
+
+Modifications:
+
+*/
+
+package junit.extensions.proxy;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.apache.log4j.Logger;
+
+/**
+ * <p>
+ * A simple wrapper around {@link TestSuite} that permits the caller to specify
+ * the delegate {@link Test} for either directly or recursively contained
+ * {@link IProxyTest}s added to a {@link ProxyTestSuite}. There are three cases
+ * for junit:
+ * <ol>
+ * <li>An instantiated test. This is an instance of some class that extends
+ * {@link TestCase}. If the class implements {@link IProxyTest} then the
+ * <i>delegate </i> will be set on the test instance and will be available when
+ * that test runs.</li>
+ * <li>A test case. This is a class named to
+ * {@link TestSuite#addTestSuite(java.lang.Class)}. That method scans the test
+ * case class and generates an instantiated test for each conforming test method
+ * identified in the test case. The delegate is then set per above.</li>
+ * <li>A test suite. The delegate declared in a {@link ProxyTestSuite}
+ * constructor will be flowed down to each test added either directly or
+ * indirectly to that {@link ProxyTestSuite}. The various constructors all
+ * invoke this method to flow down the delegate. In addition, the
+ * {@link #addTest(Test)} and {@link #addTestSuite(Class)} methods also
+ * invoke this method to flow down the delegate to instantiated tests that
+ * implement {@link IProxyTest}.</li>
+ * </ol>
+ * </p>
+ * <p>
+ * The only case when flow down does not occur is when you have created a
+ * standard test suite, addeded it to a proxy test suite, and <em>then</em>
+ * you add additional tests to the standard test suite. There is no event
+ * notification model in junit and this action is not noticed by the {@link
+ * ProxyTestSuite}.
+ * </p>
+ */
+
+public class ProxyTestSuite
+    extends TestSuite
+{
+
+    /**
+     * The {@link Logger} is named for this class.
+     */
+
+    protected static final Logger log = Logger.getLogger
+	( ProxyTestSuite.class
+	  );
+
+    /**
+     * The delegate that will be used by each {@link IProxyTest}added to this
+     * {@link ProxyTestSuite}.
+     */
+
+    private final Test m_delegate;
+
+    /**
+     * <p>
+     * Invoked automatically by the constructors.
+     * </p>
+     * 
+     * @exception IllegalArgumentException
+     *                if the <i>delegate </i> is <code>null</code>.
+     */
+
+    final private void checkDelegate( Test delegate )
+    {
+
+	if (delegate == null) {
+
+	    throw new IllegalArgumentException("The delegate is null.");
+
+        }
+
+//        if (m_delegate != null) {
+//
+//            throw new IllegalStateException("The delegate is already set.");
+//
+//        }
+
+	log.debug
+	    ( "Delegate is "+delegate.getClass().getName()
+	      );
+	
+    }
+
+    /**
+     * Returns the <i>delegate </i> supplied to the constructor.
+     */
+
+    public Test getDelegate() {
+
+        return m_delegate;
+
+    }
+
+    /**
+     * Creates an empty unnamed test suite. The <i>delegate </i> will be
+     * assigned to tests added to this test suite that implement
+     * {@link IProxyTest}.
+     * 
+     * @param delegate
+     *            The delegate (non-null).
+     */
+
+    public ProxyTestSuite( Test delegate )
+    {
+	
+        super();
+
+	checkDelegate( delegate );
+	
+	m_delegate = delegate;
+
+    }
+
+    /**
+     * Creates a named test suite and populates it with test instances
+     * identified by scanning the <i>testClass </i>. The <i>delegate </i> will
+     * be assigned to tests added to this test suite that implement
+     * {@link IProxyTest}, including those created from <i>testClass </i>.
+     * 
+     * @param delegate
+     *            The delegate (non-null).
+     * @param testClass
+     *            A class containing one or more tests.
+     * @param name
+     *            The name of the test suite (optional).
+     */
+
+    public ProxyTestSuite( Test delegate, Class testClass, String name )
+    {
+	
+	/*
+	 * Let the super class do all the heavy lifting. Note that it can not set
+	 * the delegate for us since we can not set our private fields until after
+	 * we have invoked the super class constructor.
+	 */
+
+	super( testClass, name );
+
+	checkDelegate( delegate );
+	
+	m_delegate = delegate;
+
+	/*
+	 * Apply delegate to all instantiated tests that were created by
+	 * junit from testClass and which implement IProxyTest.
+	 */
+	flowDown(this);
+	
+    }
+
+    /**
+     * Creates an unnamed test suite and populates it with test instances
+     * identified by scanning the <i>testClass </i>. The <i>delegate </i> will
+     * be assigned to tests added to this test suite that implement
+     * {@link IProxyTest}, including those created from <i>testClass </i>.
+     * 
+     * @param delegate
+     *            The delegate (non-null).
+     * @param testClass
+     *            A class containing one or more tests.
+     */
+
+    public ProxyTestSuite( Test delegate, Class testClass )
+    {
+
+	/*
+	 * Let the super class do all the heavy lifting. Note that it can not set
+	 * the delegate for us since we can not set our private fields until after
+	 * we have invoked the super class constructor.
+	 */
+
+	super( testClass );
+
+	// Remember the delegate.
+
+	checkDelegate( delegate );
+	
+	m_delegate = delegate;
+
+	/*
+	 * Apply delegate to all instantiated tests that were created by
+	 * junit from testClass and which implement IProxyTest.
+	 */
+	flowDown(this);
+
+    }
+
+    /**
+     * Creates an empty named test suite. The declared will be assigned to tests
+     * added to this test suite that implement {@link IProxyTest}.
+     * 
+     * @param delegate
+     *            The delegate (non-null).
+     * @param name
+     *            The test suite name (optional).
+     */
+    public ProxyTestSuite( Test delegate, String name )
+    {
+
+        super( name );
+
+	checkDelegate( delegate );
+	
+	m_delegate = delegate;
+
+    }
+
+    /**
+     * We override the implementation of {@link
+     * TestSuite#addTestSuite( Class theClass )} to wrap the
+     * <i>testClass</i> in another instance of this {@link
+     * ProxyTestSuite} class using the same delegate that was provided
+     * to our constructor.  This causes the delegation to be inherited
+     * by any recursively contained <i>testClass</i> which implements
+     * {@link IProxyTest}.
+     */     
+
+    public void addTestSuite( Class testClass )
+    {
+
+        if( m_delegate == null ) {
+            
+            /*
+             * The delegate will be null if this method gets invoked from the
+             * super class constructor since that will happen before we have a
+             * chance to set the [m_delegate] field. The constructors handle
+             * this situation by explictly flowing down the delegate after the
+             * super class constructor has been invoked.
+             */
+            
+            super.addTestSuite( testClass );
+            
+            return;
+            
+        }
+        
+	// This is the default implementation from TestSuite:
+	//
+	// addTest(new TestSuite(testClass));
+	//
+	// Our implementation just substitutes new ProxyTestSuite(
+	// delegate, testClass ) for new TestSuite( testClass ).
+	//
+
+	ProxyTestSuite proxyTestSuite = new ProxyTestSuite
+	    ( m_delegate,
+	      testClass
+	      );
+
+	addTest( proxyTestSuite );
+	
+    }
+
+    /**
+     * If the suite is not a {@link ProxyTestSuite}, then the tests in the
+     * suite are recursively enumerated and a proxy test suite is created with
+     * the same name and tests. This ensures that the common delegate flows down
+     * through all tests even when using the traditional
+     * <code>static Test suite() {...}</code> construction.
+     * 
+     * @param test
+     *            A test.
+     */
+    public void addTest(Test test) {
+
+        if( m_delegate == null ) {
+            
+            /*
+             * The delegate will be null if this method gets invoked from the
+             * super class constructor since that will happen before we have a
+             * chance to set the [m_delegate] field.  The constructors handle
+             * this situation by explictly flowing down the delegate after the
+             * super class constructor has been invoked.
+             */
+            
+            super.addTest( test );
+            
+            return;
+            
+        }
+
+        if ( ! (test instanceof ProxyTestSuite)) {
+            
+            /*
+             * Flow down the delegate to any container IProxyTest instances.
+             */
+            
+            flowDown( test );
+            
+        }
+
+        super.addTest( test );
+        
+    }
+    
+    protected void flowDown(Test t) {
+
+        if (m_delegate == null) {
+
+            throw new AssertionError("delegate is not set.");
+
+        }
+        
+        if ( t instanceof TestSuite ) {
+            
+            flowDown( (TestSuite) t );
+            
+        } else if (t instanceof IProxyTest) {
+
+            log.debug("Setting delegate on " + t.getClass() + " to "
+                    + m_delegate.getClass());
+
+            ((IProxyTest) t).setDelegate(m_delegate);
+
+        }
+
+    }
+    
+    /**
+     * <p>
+     * Sets the delegate on each instantiated {@link Test} that implements
+     * {@link IProxyTest}.
+     * </p>
+     */
+
+    protected void flowDown( TestSuite suite ) {
+        
+        if( m_delegate == null ) {
+        
+            throw new AssertionError("delegate is not set.");
+            
+        }
+        
+	for( java.util.Enumeration e= suite.tests(); e.hasMoreElements(); ) {
+
+ 	    Test t = (Test)e.nextElement();
+
+ 	    flowDown( t );
+ 	    
+	}
+
+    }
+    
+}


Property changes on: branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/ProxyTestSuite.java
___________________________________________________________________
Added: svn:keywords
   + Id Date Revision Author HeadURL

Added: branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/package.html
===================================================================
--- branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/package.html	                        (rev 0)
+++ branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/package.html	2010-09-08 20:09:11 UTC (rev 3521)
@@ -0,0 +1,146 @@
+<HTML>
+<HEAD>
+<TITLE>Proxy test suites</TITLE>
+</HEAD>
+<BODY>
+<H1>Integration testing with proxy test suites.</H1>
+<P>This package provides support for suites of <EM>proxy</EM> tests that
+share a common test <EM>delegate</EM>. Normally the proxy tests and the
+delegate will implement a common interface. The implementation of the
+interface on the proxy test base class should route the behaviors to the
+delegate test. This mechanism can be used to run an entire test suite
+against a specific configuration for integration testing. Since the same
+delegate instance is used for all tests in the suite, you can do things
+such as establish a shared database connection that is used for the
+entire test suite, i.e., you can do <EM>integration testing</EM>.</P>
+<H2>Defining a configuration using getProperties()</H2>
+<P>The pattern that I have found to be most useful for integration
+testing of different configurations is to define a <CODE>public
+Properties getProperties()</CODE> method that is implemented by the <EM>delegate</EM>
+and accessed by various integration test set up and tear down methods
+implemented by the delegate. For example:</P>
+<PRE>
+	public Properties getProperties() {
+		if( m_properties == null ) {
+			/*
+			 * Read and cache System properties.
+			 */
+			m_properties = System.getProperties();
+		}
+		/*
+		 * Wrap up the cached properties so that they are not modifable by the
+		 * caller (no side effects between calls).
+		 */
+		return new Properties( m_properties );
+	}
+</PRE>
+<p>This approach reads properties from the environement, so you can
+define property values using JVM command line arguments <CODE>-Dname=value</CODE>.
+You can also extend the {@link junit.framework.TestCase2} class and use
+its <CODE>getProperties()</CODE> method, in which case properties are
+read from a hierarchy of sources, including a file with a <CODE>.properties</CODE>
+extension and the same base name as the delegate test class.</p>
+<H2>Sharing a connection</H2>
+<P>In order to setup variables, such as a JDBC connection, that are
+reused by each test in the suite, you need to declare those variables as
+fields on the <EM>delegate</EM> implementation class and wrap the test
+suite in a {@link junit.framework.TestDecorator} as follows.</P>
+<pre>
+    public static Test suite() {
+
+		/*
+		 * Create the delegate instance that will be reused by all proxy tests in
+		 * the test suite.  The variable is declared as 'final' so that we can
+		 * access it from the anonymous TestDecorator class, below.
+		 */
+		final DefaultTestCase delegate = new DefaultTestCase(); // !!!! THIS CLASS !!!!
+
+	    /*
+		 * Use a proxy test suite and specify the delegate.
+		 */
+
+		ProxyTestSuite suite = new ProxyTestSuite(delegate);
+	    
+	    /* 
+	     * Add some tests to the test suite.  The setDelegate() method will be
+	     * called on each test that implements IProxyTest and passed the value
+	     * provided to the ProxyTestSuite constructor above.
+	     */
+	    suite.addTestCase( MyTestCase1.class );
+
+		// ... more tests.
+		
+		/*
+		 * Wrap up in decorator that connects to the database before the test
+		 * suite is run and then disconnects from the database afterwards.
+		 */
+		return new TestDecorator(suite) {
+
+			private boolean disconnectAfter = false;
+			
+			public void basicRun(TestResult result) {
+				if (!delegate.isConnected()) {
+					delegate.connect();
+					disconnectAfter = true;
+				}
+				super.basicRun(result);
+				if (disconnectAfter) {
+					delegate.disconnect();
+				}
+			}
+			
+		};
+</pre>
+<P>While the life span of the <EM>delegate</EM> spans that of the test
+suite, the <CODE>setUp</CODE> and <CODE>tearDown</CODE> methods of the
+delegate are invoked before and after each test <EM>implemented by the
+delegate</EM>. Since the delegate does not generally implement tests
+directly, those set up and tear down methods can not be used to perform
+integration testing.</P>
+<H2>Running or debugging a single test</H2>
+<P>By its nature, a test that implements {@link IProxyTest} requires a <em>delegate</em>
+in order to run. This works fine when you are running an entire test
+suite defined by the delegate, but you have to take an extra step in
+order to be able to run or debug a single test. The following code gives
+an example of how you can deal with this problem. It defines a property
+<em>testClass</em> whose value is the name of the delegate class. If the
+delegate was not set (as will be the case if you try to run a single
+test directly), then this property must be specified as a JVM argument
+using <code>-DtestClass=....</code> and an instance of your delegate
+will be created and used to run the proxy test.</P>
+<P>If you test relies on a shared variable such as a JDBC connection,
+then you still have to provide for that. One way to handle this is to
+delegate the <code>setUp</code> and <code>tearDown</code> methods on the
+proxy test. The delegate implementation of those methods would then
+establish and close the Connection iff the Connection was not already
+established.</P>
+
+<pre>
+    public Test getDelegate() {
+
+		if (m_delegate == null) {
+
+			/*
+			 * This property gives the class name of the concrete instance of
+			 * testClass that we need to instantiate so that we can run or debug
+			 * a single test at a time.
+			 */
+			String testClass = getProperties().getProperty("testClass");
+			if (testClass == null) {
+
+				throw new IllegalStateException(
+						"testClass: property not defined, could not configure delegate.");
+
+			}
+			try {
+				Class cl = Class.forName(testClass);
+				m_delegate = (Test) cl.newInstance();
+			} catch (Exception ex) {
+				throw new RuntimeException(ex);
+			}
+
+		}
+    }
+</pre>
+</BODY>
+</HTML>


Property changes on: branches/maven_scaleout/bigdata-core/src/test/java/junit/extensions/proxy/package.html
___________________________________________________________________
Added: svn:keywords
   + Id Date Revision Author HeadURL

Added: branches/maven_scaleout/bigdata-core/src/test/java/junit/framework/TestCase2.java
===================================================================
--- branches/maven_scaleout/bigdata-core/src/test/java/junit/framework/TestCase2.java	                        (rev 0)
+++ branches/maven_scaleout/bigdata-core/src/test/java/junit/framework/TestCase2.java	2010-09-08 20:09:11 UTC (rev 3521)
@@ -0,0 +1,2230 @@
+/**
+
+The Notice below must appear in each file of the Source Code of any
+copy you distribute of the Licensed Product.  Contributors to any
+Modifications may add their own copyright notices to identify their
+own contributions.
+
+License:
+
+The contents of this file are subject to the CognitiveWeb Open Source
+License Version 1.1 (the License).  You may not copy or use this file,
+in either source code or executable form, except in compliance with
+the License.  You may obtain a copy of the License from
+
+  http://www.CognitiveWeb.org/legal/license/
+
+Software distributed under the License is distributed on an AS IS
+basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
+the License for the specific language governing rights and limitations
+under the License.
+
+Copyrights:
+
+Portions created by or assigned to CognitiveWeb are Copyright
+(c) 2003-2003 CognitiveWeb.  All Rights Reserved.  Contact
+information for CognitiveWeb is available at
+
+  http://www.CognitiveWeb.org
+
+Portions Copyright (c) 2002-2003 Bryan Thompson.
+
+Acknowledgements:
+
+Special thanks to the developers of the Jabber Open Source License 1.0
+(JOSL), from which this License was derived.  This License contains
+terms that differ from JOSL.
+
+Special thanks to the CognitiveWeb Open Source Contributors for their
+suggestions and support of the Cognitive Web.
+
+Modifications:
+
+*/
+
+package junit.framework;
+
+// Test resource loader.
+import java.io.Externalizable;
+import java.io.Reader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.Serializable;
+
+// Properties hierarchy loader.
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.Properties;
+import java.util.Random;
+import java.util.TreeMap;
+import java.util.Map;
+import java.util.Iterator;
+
+// Logger.
+import org.CognitiveWeb.util.PropertyUtil;
+import org.apache.log4j.Logger;
+import org.apache.log4j.Level;
+
+/**
+ * Extension of {@link TestCase} that supports logging, loading test
+ * resources, and hierarchical properties.<p>
+ *
+ * Note: When using Maven (or Ant), you need to be aware that that
+ * your <code>project.xml</code> has an impact on which files are
+ * recognized as tests to be submitted to a test runner.  For example,
+ * it is common practice that all files beginning or ending with
+ * "Test" will be submitted to JUnit, though I suggest that the
+ * practice of naming things "FooTestCase" will serve you better.
+ * Also note that the maven test plugin explictly skips files whose
+ * name matches the pattern "*AbstractTestSuite".<p>
+ */
+
+abstract public class TestCase2
+    extends TestCase
+{
+
+    public TestCase2() {
+        super();
+    }
+    
+    public TestCase2(String name) {
+        super(name);
+    }
+
+    /**
+     * The default {@link Logger} for this class, which is named
+     * "junit.framework.Test".
+     */
+
+    protected static final Logger log = Logger.getLogger
+	( junit.framework.Test.class
+	  );
+
+    /**
+     * This convenience method provides a version of {@link #fail(
+     * String Message )} that also excepts a {@link Throwable} cause
+     * for the test failure.<p>
+     */
+
+    static public void fail
+	( String message,
+	  Throwable t
+	  )
+    {
+
+	AssertionFailedError ex = new AssertionFailedError
+	    ( message
+	      );
+
+	ex.initCause( t );
+
+	throw ex;
+
+    }
+
+    //************************************************************
+    //************************************************************ 
+    //************************************************************
+
+    static public void assertEquals( boolean[] expected, boolean[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+
+    /**
+     * Compares arrays of primitive values.
+     */
+
+    static public void assertEquals( String msg, boolean[] expected, boolean[] actual )
+    {
+    
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+    
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+            
+            if (expected[i] != actual[i]) {
+                /*
+                 * Only do message construction if we know that the assert will
+                 * fail.
+                 */
+                assertEquals(msg + "values differ: index=" + i, expected[i],
+                        actual[i]);
+            }
+            
+        }
+        
+    }
+
+    /**
+     * <p>
+	 * Compares byte[]s by value (not reference).
+	 * </p>
+	 * <p>
+	 * Note: This method will only be invoked if both arguments can be typed as
+	 * byte[] by the compiler. If either argument is not strongly typed, you
+	 * MUST case it to a byte[] or {@link #assertEquals(Object, Object)} will be
+	 * invoked instead.
+	 * </p>
+	 * 
+     * @param expected
+     * @param actual
+     */
+    static public void assertEquals( byte[] expected, byte[] actual )
+    {
+
+        assertEquals( null, expected, actual );
+        
+    }
+
+    /**
+	 * <p>
+	 * Compares byte[]s by value (not reference).
+	 * </p>
+	 * <p>
+	 * Note: This method will only be invoked if both arguments can be typed as
+	 * byte[] by the compiler. If either argument is not strongly typed, you
+	 * MUST case it to a byte[] or {@link #assertEquals(Object, Object)} will be
+	 * invoked instead.
+	 * </p>
+	 * 
+	 * @param msg
+	 * @param expected
+	 * @param actual
+	 */
+    static public void assertEquals( String msg, byte[] expected, byte[] actual )
+    {
+
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+    
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+            
+            if (expected[i] != actual[i]) {
+                /*
+                 * Only do the message construction if we know that the assert
+                 * will fail.
+                 */
+                assertEquals(msg + "values differ: index=" + i, expected[i],
+                        actual[i]);
+            }
+            
+        }
+        
+    }
+
+    static public void assertEquals( char[] expected, char[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+    
+    static public void assertEquals( String msg, char[] expected, char[] actual )
+    {
+    
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+        
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+            
+            if (expected[i] != actual[i]) {
+                /*
+                 * Only do the message construction if we know that the assert
+                 * will fail.
+                 */
+                assertEquals(msg + "values differ: index=" + i, expected[i],
+                        actual[i]);
+            }
+            
+        }
+        
+    }
+
+    static public void assertEquals( short[] expected, short[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+
+    static public void assertEquals( String msg, short[] expected, short[] actual )
+    {
+        
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+    
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+
+        for( int i=0; i<expected.length; i++ ) {
+            
+            if (expected[i] != actual[i]) {
+                /*
+                 * Only do the message construction if we know that the assert
+                 * will fail.
+                 */
+                assertEquals(msg + "values differ: index=" + i, expected[i],
+                        actual[i]);
+            }
+            
+        }
+        
+    }
+
+    static public void assertEquals( int[] expected, int[] actual )
+    {
+
+        assertEquals( null, expected, actual );
+        
+    }
+    
+    static public void assertEquals( String msg, int[] expected, int[] actual )
+    {
+
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+    
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+
+        for( int i=0; i<expected.length; i++ ) {
+            
+            if (expected[i] != actual[i]) {
+                /*
+                 * Only do the message construction if we know that the assert
+                 * will fail.
+                 */
+                assertEquals(msg + "values differ: index=" + i, expected[i],
+                        actual[i]);
+            }
+            
+        }
+        
+    }
+
+    static public void assertEquals( long[] expected, long[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+
+    static public void assertEquals( String msg, long[] expected, long[] actual )
+    {
+
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+        
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+            
+            if (expected[i] != actual[i]) {
+                /*
+                 * Only do the message construction if we know that the assert
+                 * will fail.
+                 */
+                assertEquals(msg + "values differ: index=" + i, expected[i],
+                        actual[i]);
+
+            }
+             
+        }
+        
+    }
+
+    static public void assertEquals( float[] expected, float[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+    
+    /**
+     * @todo Use smarter floating point comparison and offer parameter
+     * for controlling the floating point comparison.
+     */
+    static public void assertEquals( String msg, float[] expected, float[] actual )
+    {
+
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+    
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+     
+            float delta = 0f;
+            
+            try {
+
+                assertEquals(expected[i], actual[i], delta);
+                
+            } catch (AssertionFailedError ex) {
+
+                /*
+                 * Only do the message construction once the assertion is known
+                 * to fail.
+                 */
+                fail(msg + "values differ: index=" + i, ex);
+
+            }
+
+        }
+        
+    }
+    
+    static public void assertEquals( double[] expected, double[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+
+    /**
+     * @todo Use smarter floating point comparison and offer parameter
+     * for controlling the floating point comparison.
+     */
+    static public void assertEquals( String msg, double[] expected, double[] actual )
+    {
+    
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+            
+            double delta = 0.0d;
+
+            try {
+
+                assertEquals(expected[i], actual[i], delta);
+                
+            } catch (AssertionFailedError ex) {
+
+                /*
+                 * Only do the message construction once the assertion is known
+                 * to fail.
+                 */
+                fail(msg + "values differ: index=" + i, ex);
+
+            }
+
+        }
+        
+    }
+
+    static public void assertEquals( Object[] expected, Object[] actual )
+    {
+        assertEquals( null, expected, actual );
+    }
+    
+    /**
+     * Compares arrays of {@link Object}s.  The length of the arrays
+     * must agree, and each array element must agree.  However the 
+     * class of the arrays does NOT need to agree, e.g., an Object[]
+     * MAY compare as equals with a String[].
+     */
+
+    static public void assertEquals( String msg, Object[] expected, Object[] actual )
+    {
+    
+        if( msg == null ) {
+            msg = "";
+        } else {
+            msg = msg + " : ";
+        }
+
+        if( expected == null && actual == null ) {
+            
+            return;
+            
+        }
+        
+        if( expected == null && actual != null ) {
+            
+            fail( msg+"Expected a null array." );
+            
+        }
+        
+        if( expected != null && actual == null ) {
+            
+            fail( msg+"Not expecting a null array." );
+            
+        }
+        
+        if (expected.length != actual.length) {
+            /*
+             * Only do message construction if we know that the assert will
+             * fail.
+             */
+            assertEquals(msg + "length differs.", expected.length,
+                    actual.length);
+        }
+        
+        for( int i=0; i<expected.length; i++ ) {
+            
+            try {
+
+                assertEquals(expected[i], actual[i]);
+                
+            } catch (AssertionFailedError ex) {
+                
+                /*
+                 * Only do the message construction once the assertion is known
+                 * to fail.
+                 */
+                
+                fail(msg + "values differ: index=" + i, ex);
+                
+            }
+            
+        }
+        
+    }
+
+    //************************************************************
+    //************************************************************
+    //************************************************************
+
+    /**
+     * Test helper that can correctly compare arrays of primitives and
+     * arrays of objects as well as primitives and objects.
+     */
+    static public void assertSameValue( Object expected, Object actual )
+    {
+        assertSameValue( null, expected, actual );
+    }
+    
+    /**
+     * Test helper that can correctly compare arrays of primitives and
+     * arrays of objects as well as primitives and objects.
+     *
+     * @todo This will throw a {@link ClassCastException} if
+     * <i>actual</i> is of a different primitive array type.  Change
+     * the code to throw {@link AssertionFailedError} instead.
+     */
+    static public void assertSameValue( String msg, Object expected, Object actual )
+    {
+
+	if( expected != null && expected.getClass().isArray() ) {
+
+	    if( expected.getClass().getComponentType().isPrimitive() ) {
+
+		Class componentType = expected.getClass().getComponentType();
+
+		if( componentType.equals( Boolean.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (boolean[]) expected,
+			  (boolean[]) actual
+			  );
+		    
+		} else if( componentType.equals( Byte.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (byte[]) expected,
+			  (byte[]) actual
+			  );
+		
+		} else if( componentType.equals( Character.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (char[]) expected,
+			  (char[]) actual
+			  );
+		
+		} else if( componentType.equals( Short.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (short[]) expected,
+			  (short[]) actual
+			  );
+		
+		} else if( componentType.equals( Integer.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (int[]) expected,
+			  (int[]) actual
+			  );
+		
+		} else if( componentType.equals( Long.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (long[]) expected,
+			  (long[]) actual
+			  );
+		
+		} else if( componentType.equals( Float.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (float[]) expected,
+			  (float[]) actual
+			  );
+
+		} else if( componentType.equals( Double.TYPE ) ) {
+
+		    assertEquals
+			( msg,
+			  (double[]) expected,
+			  (double[]) actual
+			  );
+
+		} else {
+
+		    throw new AssertionError();
+
+		}
+
+	    } else {
+		
+		assertTrue
+		    ( msg,
+		      java.util.Arrays.equals
+		      ( (Object[]) expected,
+			(Object[]) actual
+	    	        )
+		      );
+
+	    }
+	    
+	} else {
+	    
+	assertEquals
+	   ( msg,
+	     expected,
+	     actual
+	     );
+
+	}
+
+    }
+
+    //************************************************************
+    //************************************************************
+    //************************************************************
+
+    /**
+     * Method verifies that the <i>actual</i> {@link Iterator}
+     * produces the expected objects in the expected order.  Objects
+     * are compared using {@link Object#equals( Object other )}.  Errors
+     * are reported if too few or too many objects are produced, etc.
+     */
+
+    static public void assertSameIterator
+	( Object[] expected,
+	  Iterator actual
+	  )
+    {
+        
+        assertSameIterator
+            ( "",
+              expected,
+              actual
+              );
+        
+    }
+
+    /**
+     * Method verifies that the <i>actual</i> {@link Iterator}
+     * produces the expected objects in the expected order.  Objects
+     * are compared using {@link Object#equals( Object other )}.  Errors
+     * are reported if too few or too many objects are produced, etc.
+     */
+
+    static public void assertSameIterator
+	( String msg,
+	  Object[] expected,
+	  Iterator actual
+	  )
+    {
+
+	int i = 0;
+
+	while( actual.hasNext() ) {
+
+	    if( i >= expected.length ) {
+
+		fail( msg+": The iterator is willing to visit more than "+
+		      expected.length+
+		      " objects."
+		      );
+
+	    }
+
+	    Object g = actual.next();
+
+//        if (!expected[i].equals(g)) {
+        try {
+            assertSameValue(expected[i],g);
+        } catch(AssertionFailedError ex) {
+                /*
+                 * Only do message construction if we know that the assert will
+                 * fail.
+                 */
+                fail(msg + ": Different objects at index=" + i + ": expected="
+                        + expected[i] + ", actual=" + g);
+            }
+
+	    i++;
+
+	}
+
+	if( i < expected.length ) {
+
+	    fail( msg+": The iterator SHOULD have visited "+expected.length+
+		  " objects, but only visited "+i+
+		  " objects."
+		  );
+
+	}
+
+    }
+
+    /**
+     * Verifies that the iterator visits the specified objects in some
+     * arbitrary ordering and that the iterator is exhausted once all
+     * expected objects have been visited.  The implementation uses a
+     * selection without replacement "pattern".
+     */
+
+    static public void assertSameIteratorAnyOrder
+	( Comparable[] expected,
+	  Iterator actual
+	  )
+    {
+        
+        assertSameIteratorAnyOrder
+           ( "",
+             expected,
+             actual
+             );
+        
+    }
+
+    /**
+     * Verifies that the iterator visits the specified objects in some
+     * arbitrary ordering and that the iterator is exhausted once all
+     * expected objects have been visited.  The implementation uses a
+     * selection without replacement "pattern".
+     * 
+     * FIXME Write test cases for this one.
+     * 
+     * FIXME Can we we this without requiring the objects to implement
+     * {@link Comparable}?
+     */
+
+    static public void assertSameIteratorAnyOrder
+	( String msg,
+	  Comparable[] expected,
+	  Iterator actual
+	  )
+    {
+
+	// Populate a map that we will use to realize the match and
+	// selection without replacement logic.
+
+	final int nrange = expected.length;
+	
+	java.util.Map range = new java.util.TreeMap();
+	
+	for( int j=0; j<nrange; j++ ) {
+	    
+	    range.put
+		( expected[ j ],
+		  expected[ j ]
+		  );
+	    
+	}
+	
+	// Do selection without replacement for the objects visited by
+	// iterator.
+	
+	for( int j=0; j<nrange; j++ ) {
+	    
+	    if( ! actual.hasNext() ) {
+		
+		fail( msg+": Index exhausted while expecting more object(s)"+
+		      ": index="+j
+		      );
+		
+	    }
+	    
+	    Object actualObject = actual.next();
+	    
+	    if( range.remove( actualObject ) == null ) {
+		
+		fail( "Object not expected"+
+		      ": index="+j+
+		      ", object="+actualObject
+		      );
+		
+	    }
+	    
+	}
+
+	if( actual.hasNext() ) {
+
+	    fail( "Iterator will deliver too many objects."
+		  );
+
+	}
+
+    }
+
+    //************************************************************
+    //************************************************************
+    //************************************************************
+
+    /**
+     * Test helper produces a random sequence of indices in the range [0:n-1]
+     * suitable for visiting the elements of an array of n elements in a random
+     * order. This is useful when you want to randomize the presentation of
+     * elements from two or more arrays. For example, known keys and values can
+     * be generated and their presentation order randomized by indexing with the
+     * returned array.
+     */
+    
+    public static int[] getRandomOrder( final int n )
+    {
+
+	final class Pair
+	    implements Comparable
+	{
+	    public double r = Math.random();
+	    public int val;
+	    public Pair( int val ) {this.val = val;}
+	    public int compareTo(Object other)
+	    {
+		if( this == other ) return 0;
+		if( this.r < ((Pair)other).r ) return -1;
+		else return 1;
+	    }
+
+	}
+
+	Pair[] pairs = new Pair[ n ];
+
+	for( int i=0; i<n; i++ ) {
+
+	    pairs[ i ] = new Pair( i );
+
+	}
+
+	java.util.Arrays.sort( pairs );
+
+	int order[] = new int[ n ];
+	
+	for( int i=0; i<n; i++ ) {
+
+	    order[ i ] = pairs[ i ].val;
+
+	}
+
+	return order;
+	
+    }
+
+    /**
+     * Random number generator used by {@link #getNormalInt( int range
+     * )}.
+     */
+
+    private Random m_random = new Random();
+
+    /**
+     * Returns a random integer normally distributed in [0:range].
+     */
+
+    public int getNormalInt( int range )
+    {
+
+	final double bound = 3d;        
+	
+	double rand = m_random.nextGaussian();
+	
+	if( rand < -bound ) rand = -bound;
+	else if( rand > bound ) rand = bound;
+	
+	rand = ( rand + bound ) / ( 2 * bound );
+				// normal distribution in [0:1].
+	
+	if( rand < 0d ) rand = 0d;
+				// make sure it is not slightly
+				// negative
+	
+	int r = (int)( rand * range );
+	
+	if( r > range ) {
+	    
+	    throw new AssertionError();
+	    
+	}
+	
+	return r;
+
+	// @todo develop a test case for this method based on the code
+	// in comments below and migrate into TestCase2 (junit-ext
+	// package).
+
+//        int[] r = new int[10000];
+
+//         for( int i=0; i<r.length; i++ ) {
+
+// 	    r[ i ] = getNormalInt( len );
+            
+//         }
+        
+//         java.util.Arrays.sort( r );
+        
+
+    }
+
+    /**
+     * Returns a random but unique string of Unicode characters with a
+     * maximum length of len and a minimum length.
+     *
+     * @param len The maximum length of the string.  Each generated
+     * literal will have a mean length of <code>len/2</code> and the
+     * lengths will be distributed using a normal distribution (bell
+     * curve).
+     *
+     * @param id A unique index used to obtain a unique string.
+     * Typically this is a one up identifier.
+     */
+
+    public String getRandomString( int len, int id )
+    {
+
+//	final String data = "0123456789!@#$%^&*()`~-_=+[{]}\\|;:'\",<.>/?QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
+	final String data = "0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
+
+	int[] order = getRandomOrder( data.length() );
+	
+	int n = getNormalInt( len );
+	
+	StringBuffer sb = new StringBuffer( n );
+
+	int index = 0;
+	
+	for( int i=0; i<n; i++ ) {
+
+	    sb.append( data.charAt( order[ index++ ] ) );
+
+	    if( index == order.length ) {
+	        
+	        index = 0;
+	        
+	    }
+	    
+	}
+ 	        
+	sb.append( id );
+
+	return sb.toString();
+
+    }
+    
+    /**
+     * Used to create objects of random type.
+     * 
+     * @todo support generation of random array types and dates.
+     * 
+     * @author thompsonbry
+     */
+    protected class RandomType
+    {
+
+        /**
+         * An explicit NULL property value.
+         */
+
+        final public static short NULL = 0;
+
+//        /**
+//         * A directed link to another generic object in the same store.
+//         *
+//         * @see LinkValue
+//         */
+//
+//        final public static short LINK = 1;
+//
+//        /**
+//         * A BLOB (metadata that supports access to very large binary
+//         * objects using a stream oriented API).
+//         */
+//
+//        final public static short BLOB = 2;
+        
+        /**
+         * The Java primitive type <em>boolean</em>.
+         *
+         * Note: Support for primitives recognizes the corresponding
+         * objects, e.g., {@link Boolean}, and special cases their
+         * serialization.  This significantly reduces their the storage
+         * requirements.
+         */
+
+        final public static short BOOLEAN = 20;
+        final public static short BYTE    = 21;
+        final public static short CHAR    = 22;
+        final public static short SHORT   = 23;
+        final public static short INT     = 24;
+        final public static short LONG    = 25;
+        final public static short FLOAT   = 26;
+        final public static short DOUBLE  = 27;
+
+        /**
+         * Java Object (must implement {@link Serializable} or {@link
+         * Externalizable}).
+         */
+
+        final public static short OBJECT  = 30;
+
+        /**
+         * Array of Java objects (but not Java primitives).
+         */
+
+        final public static short OBJECT_ARRAY   = 31;
+
+        /**
+         * Array of Java primitives.
+         */
+
+        final public static short BOOLEAN_ARRAY = 40;
+        final public static short BYTE_ARRAY    = 41;
+        final public static short CHAR_ARRAY    = 42;
+        final public static short SHORT_ARRAY   = 43;
+        final public static short INT_ARRAY     = 44;
+        final public static short LONG_ARRAY    = 45;
+        final public static short FLOAT_ARRAY   = 46;
+        final public static short DOUBLE_ARRAY  = 47;
+
+        final public int[] randomType = new int[] {
+//            LINK,
+//            BLOB,
+            BOOLEAN, BYTE, CHAR, SHORT, INT, LONG, FLOAT, DOUBLE,
+            OBJECT,
+//            OBJECT_ARRAY,
+//            BOOLEAN_ARRAY,
+//            BYTE_ARRAY,
+//            CHAR_ARRAY,
+//            SHORT_ARRAY,
+//            INT_ARRAY,
+//            LONG_ARRAY,
+//            FLOAT_ARRAY,
+//            DOUBLE_ARRAY,
+            NULL // Note: null at end to make easy to exclude.
+        };
+
+        /**
+         * For random characters.
+         */
+        static final private String alphabet = "0123456789QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm";
+        
+        /**
+         * Returns an object with a random type and random value.
+         * 
+         * @param rnd The random# generator to use.
+         * 
+         * @param allowNull When true, a null object reference may be
+         * returned.
+         * 
+         * @return The random object.
+         */
+        
+        public Object nextObject( Random rnd, boolean allowNull )
+        {
+
+            int[] types = randomType;
+            
+            int range = types.length;  
+            
+            if( ! allowNull ) range--; // exclude null from types.
+            
+            int type = types[ rnd.nextInt( range ) ];
+            
+            Object obj = null;
+            
+            switch( type ) {
+
+            case NULL: {
+                return null;
+            }
+            case BOOLEAN: {
+                obj = ( rnd.nextBoolean()
+                        ? Boolean.TRUE
+                        : Boolean.FALSE
+                        );
+                break;
+            }
+            case BYTE: {
+                obj = new Byte( (byte) ( rnd.nextInt( 255 ) - 127 ) );
+                break;
+            }
+            case CHAR: {
+                obj = new Character( alphabet.charAt( rnd.nextInt( alphabet.length() ) ) );
+                break;
+            }
+            case SHORT: {
+                obj = new Short( (short) rnd.nextInt() );
+                break;
+            }
+            case INT: {
+                obj = new Integer( rnd.nextInt() );
+                break;
+            }
+            case LONG: {
+                obj = new Long( rnd.nextLong() );
+                break;
+            }
+            case FLOAT: {
+                obj = new Float( rnd.nextFloat() );
+                break;
+            }
+            case DOUBLE: {
+                obj = new Double( rnd.nextDouble() );
+                break;
+            }
+            case OBJECT: {
+                obj = getRandomString( 40, rnd.nextInt() );
+                break;
+            }
+//            OBJECT_ARRAY,
+//                BOOLEAN_ARRAY,
+//                BYTE_ARRAY,
+//                CHAR_ARRAY,
+//                SHORT_ARRAY,
+//                INT_ARRAY,
+//                LONG_ARRAY,
+//                FLOAT_ARRAY,
+//                DOUBLE_ARRAY
+            default: {
+                throw new AssertionError( "unknown type="+type );
+            }
+            
+            }
+
+            return obj;
+        
+        }
+        
+    }
+
+    private RandomType _randomType = new RandomType();
+    
+    /**
+     * Returns an object with a random type and random value.
+     * 
+     * @param allowNull When true, a null object reference may be
+     * returned.
+     * 
+     * @return The random object.
+     */
+
+    public Object getRandomObject( boolean allowNull )
+    {
+
+        return _randomType.nextObject( m_random, allowNull );
+        
+    }
+
+    /**
+     * Returns an object with a random type and random value.
+     *
+     * @param rnd The random generator.
...
 
[truncated message content]

Thread: [Bigdata-commit] SF.net SVN: bigdata:[3521] branches/maven_scaleout/bigdata-core

Fast, scalable, robust graph database platform

bigdata-commit