Index: test/java/org/apache/jdo/tck/models/fieldtypes/TestUtil.java =================================================================== --- test/java/org/apache/jdo/tck/models/fieldtypes/TestUtil.java (revision 290793) +++ test/java/org/apache/jdo/tck/models/fieldtypes/TestUtil.java (working copy) @@ -18,8 +18,12 @@ package org.apache.jdo.tck.models.fieldtypes; -import java.util.Vector; +import java.util.*; +import java.math.*; +import org.apache.jdo.tck.pc.fieldtypes.AllTypes; +import org.apache.jdo.tck.pc.fieldtypes.SimpleClass; + public class TestUtil { public TestUtil() { @@ -65,7 +69,8 @@ int indexOfUnderScore = fieldTypeWithValueType.indexOf("_"); fieldType = fieldTypeWithValueType.substring(0, indexOfUnderScore); - String valueTypeWithNumber = fieldTypeWithValueType.substring(indexOfUnderScore + 1); + String valueTypeWithNumber = + fieldTypeWithValueType.substring(indexOfUnderScore + 1); int lastIndexOfValueType = 0; for (int i=valueTypeWithNumber.length() -1; i>=0; i--) { if (Character.isDigit(valueTypeWithNumber.charAt(i))) { @@ -84,5 +89,235 @@ return fieldSpecs; } + public static String [] elementTypes = new String[] + {"Object", "SimpleClass", "SimpleInterface", + "String", "Date", "Locale", "BigDecimal", + "BigInteger", "Byte", "Double", "Float", + "Integer", "Long", "Short"}; + private static int getIndexOf(String type) { + for (int i=0; i < elementTypes.length; i++) { + if (type.equals(elementTypes[i])) + return i; + } + return 9999; + } + + public static Vector makeNewVectorInstance(String type, int order) { + + Vector vec = new Vector(); + + switch (order) { + case(1): + switch (getIndexOf(type)) { + case(0): + vec.add(0, new SimpleClass(1, "Hello World")); + vec.add(1, new SimpleClass(2, "Java Data Objects")); + vec.add(2, new SimpleClass(2, "Java")); + vec.add(3, new SimpleClass(4, "Origami")); + vec.add(4, new SimpleClass(5, "watch")); + break; + case(1): + case(2): + vec.add(0, new SimpleClass(1, "Welcome")); + vec.add(1, new SimpleClass(2, "To")); + vec.add(2, new SimpleClass(3, "The")); + vec.add(3, new SimpleClass(4, "Beautiful")); + vec.add(4, new SimpleClass(5, "World")); + break; + case(3): + vec.add(0, new String("Hello")); + vec.add(1, new String("Welcome")); + vec.add(2, new String("To The")); + vec.add(3, new String("Beautiful")); + vec.add(4, new String("World")); + break; + case(4): + vec.add(0, new Date(2007908)); + vec.add(1, new Date(89067382l)); + vec.add(2, new Date(890673822)); + vec.add(3, new Date(890673823)); + vec.add(4, new Date(890673824)); + break; + case(5): + vec.add(0, Locale.CHINA); + vec.add(1, Locale.FRANCE); + vec.add(2, Locale.GERMANY); + vec.add(3, Locale.JAPAN); + vec.add(4, Locale.ITALY); + break; + case(6): + vec.add(0, new BigDecimal("2007908.54548")); + vec.add(1, new BigDecimal("0.544")); + vec.add(2, new BigDecimal("3002323232.545454")); + vec.add(3, new BigDecimal("64564645656.78657")); + vec.add(4, new BigDecimal("4564565465.2342")); + break; + case(7): + vec.add(0, new BigInteger("2007908")); + vec.add(1, new BigInteger("767575")); + vec.add(2, new BigInteger("3002323232")); + vec.add(3, new BigInteger("64564645656")); + vec.add(4, new BigInteger("456445645")); + break; + case(8): + vec.add(0, new Byte((byte)Byte.MIN_VALUE)); + vec.add(1, new Byte((byte)Byte.MAX_VALUE)); + vec.add(2, new Byte((byte)(Byte.MAX_VALUE- 20))); + vec.add(3, new Byte((byte)(Byte.MAX_VALUE - 50))); + vec.add(4, new Byte((byte)(Byte.MAX_VALUE - 75))); + break; + case(9): + vec.add(0, new Double(AllTypes.DOUBLE_SMALLEST)); + vec.add(1, new Double(AllTypes.DOUBLE_LARGEST)); + vec.add(2, new Double(AllTypes.DOUBLE_LARGEST - 20000)); + vec.add(3, new Double(AllTypes.DOUBLE_LARGEST + - 454545.436664)); + vec.add(4, new Double(AllTypes.DOUBLE_LARGEST + - 2323235.76764677)); + break; + case(10): + vec.add(0, new Float(AllTypes.FLOAT_SMALLEST)); + vec.add(1, new Float(AllTypes.FLOAT_LARGEST)); + vec.add(2, new Float(AllTypes.FLOAT_LARGEST - 20000)); + vec.add(3, new Float(AllTypes.FLOAT_LARGEST + - 454545.434)); + vec.add(4, new Float(AllTypes.FLOAT_LARGEST + - 565656.43434)); + break; + case(11): + vec.add(0, new Integer(Integer.MIN_VALUE)); + vec.add(1, new Integer(Integer.MAX_VALUE)); + vec.add(2, new Integer(Integer.MAX_VALUE - 20000)); + vec.add(3, new Integer(Integer.MAX_VALUE - 343434343)); + vec.add(4, new Integer(Integer.MAX_VALUE - 565656)); + break; + case(12): + vec.add(0, new Long(Long.MIN_VALUE)); + vec.add(1, new Long(Long.MAX_VALUE)); + vec.add(2, new Long(Long.MAX_VALUE - 20000)); + vec.add(3, new Long(Long.MAX_VALUE - 343434343)); + vec.add(4, new Long(Long.MAX_VALUE - 565656)); + break; + case(13): + vec.add(0, new Short(Short.MIN_VALUE)); + vec.add(1, new Short(Short.MAX_VALUE)); + vec.add(2, new Short((short)(Short.MAX_VALUE - 20000))); + vec.add(3, new Short((short)(Short.MAX_VALUE - 343))); + vec.add(4, new Short((short)(Short.MAX_VALUE - 5656))); + break; + default: + throw new IndexOutOfBoundsException(); + } + return vec; + case(2): + switch (getIndexOf(type)) { + case(0): + vec.add(0, new SimpleClass(1, "Hi There")); + vec.add(1, new SimpleClass(1, "Hi")); + vec.add(2, new SimpleClass(2, "Object")); + vec.add(3, new SimpleClass(0, "Relational")); + vec.add(4, new SimpleClass(3, "Hi There")); + break; + case(1): + vec.add(0, new SimpleClass(1, "Peaches")); + vec.add(1, new SimpleClass(2, "Oranges")); + vec.add(2, new SimpleClass(3, "Blue Berries")); + vec.add(3, new SimpleClass(4, "Apples")); + vec.add(4, new SimpleClass(5, "Strawberries")); + break; + case(2): + vec.add(0, new SimpleClass(1, "Peaches")); + vec.add(1, new SimpleClass(2, "Oranges")); + vec.add(2, new SimpleClass(3, "Blue Berries")); + vec.add(3, new SimpleClass(4, "Apples")); + vec.add(4, new SimpleClass(5, "Strawberries")); + break; + case(3): + vec.add(0, new String("Peaches")); + vec.add(1, new String("Oranges")); + vec.add(2, new String("Blue Berries")); + vec.add(3, new String("Apples")); + vec.add(4, new String("Strawberries")); + break; + case(4): + vec.add(0, new Date(54545)); + vec.add(1, new Date(8905454l)); + vec.add(2, new Date(323545445)); + vec.add(3, new Date(890748967382l)); + vec.add(4, new Date(954545)); + break; + case(5): + vec.add(0, Locale.ENGLISH); + vec.add(1, Locale.JAPANESE); + vec.add(2, Locale.CANADA_FRENCH); + vec.add(3, Locale.KOREA); + vec.add(4, Locale.UK); + break; + case(6): + vec.add(0, new BigDecimal("434238.5454898989")); + vec.add(1, new BigDecimal("6.544")); + vec.add(2, new BigDecimal("55552323232.545454")); + vec.add(3, new BigDecimal("6456456.7543543534865785")); + vec.add(4, new BigDecimal("456456.4353452342")); + break; + case(7): + vec.add(0, new BigInteger("345345345")); + vec.add(1, new BigInteger("543543543543544")); + vec.add(2, new BigInteger("65323423432423423")); + vec.add(3, new BigInteger("87845634534543")); + vec.add(4, new BigInteger("53452567766657567")); + break; + case(8): + vec.add(0, new Byte((byte)(Byte.MAX_VALUE-34))); + vec.add(1, new Byte((byte)Byte.MIN_VALUE)); + vec.add(2, new Byte((byte)(Byte.MAX_VALUE- 76))); + vec.add(3, new Byte((byte)Byte.MAX_VALUE)); + vec.add(4, new Byte((byte)(Byte.MAX_VALUE - 12))); + break; + case(9): + vec.add(0, new Double(AllTypes.DOUBLE_LARGEST - 343434)); + vec.add(1, new Double(AllTypes.DOUBLE_SMALLEST)); + vec.add(2, new Double(AllTypes.DOUBLE_LARGEST)); + vec.add(3, new Double(AllTypes.DOUBLE_LARGEST + - 65423445.436664)); + vec.add(4, new Double(AllTypes.DOUBLE_LARGEST + - 7235.236764677)); + break; + case(10): + vec.add(0, new Float(AllTypes.FLOAT_LARGEST - 5452)); + vec.add(1, new Float(AllTypes.FLOAT_SMALLEST)); + vec.add(2, new Float(AllTypes.FLOAT_LARGEST - 6564560.54)); + vec.add(3, new Float(AllTypes.FLOAT_LARGEST)); + vec.add(4, new Float(AllTypes.FLOAT_LARGEST - 9756.634)); + break; + case(11): + vec.add(0, new Integer(Integer.MAX_VALUE - 54454)); + vec.add(1, new Integer(Integer.MIN_VALUE)); + vec.add(2, new Integer(Integer.MAX_VALUE)); + vec.add(3, new Integer(Integer.MAX_VALUE - 767234)); + vec.add(4, new Integer(Integer.MAX_VALUE - 23673446)); + break; + case(12): + vec.add(0, new Long(Long.MAX_VALUE - 545345454)); + vec.add(1, new Long(Long.MIN_VALUE)); + vec.add(2, new Long(Long.MAX_VALUE)); + vec.add(3, new Long(Long.MAX_VALUE - 3543343)); + vec.add(4, new Long(Long.MAX_VALUE - 556)); + break; + case(13): + vec.add(0, new Short((short)(Short.MAX_VALUE - 3434))); + vec.add(1, new Short(Short.MIN_VALUE)); + vec.add(2, new Short((short)(Short.MAX_VALUE))); + vec.add(3, new Short((short)(Short.MAX_VALUE - 23344))); + vec.add(4, new Short((short)(Short.MAX_VALUE - 723))); + break; + default: + throw new IndexOutOfBoundsException(); + } + return vec; + default: + throw new IndexOutOfBoundsException(); + } + } } Index: test/java/org/apache/jdo/tck/models/fieldtypes/TestCollectionCollections.java =================================================================== --- test/java/org/apache/jdo/tck/models/fieldtypes/TestCollectionCollections.java (revision 290793) +++ test/java/org/apache/jdo/tck/models/fieldtypes/TestCollectionCollections.java (working copy) @@ -17,6 +17,7 @@ package org.apache.jdo.tck.models.fieldtypes; import java.util.Collection; +import java.util.Vector; import java.util.Hashtable; import javax.jdo.PersistenceManager; @@ -76,76 +77,80 @@ void runTest(PersistenceManager pm) { Transaction tx = pm.currentTransaction(); - try { - int i, n; - FirstSetOfTestValuesForCollection firstValue = new FirstSetOfTestValuesForCollection(); - SecondSetOfTestValuesForCollection secondValue = new SecondSetOfTestValuesForCollection(); + CollectionCollections expectedValue = new CollectionCollections(); - // turn on datastore transactions - tx.setOptimistic(false); - tx.begin(); - CollectionCollections pi = new CollectionCollections(); - pi.identifier = 1; - pm.makePersistent(pi); - Object oid = pm.getObjectId(pi); - n = pi.getLength(); - // Provide initial set of values - for(i = 0; i < n; ++i){ - String valueType = TestUtil.getFieldSpecs(CollectionCollections.fieldSpecs[i]); - pi.set( i, (Collection)firstValue.get(valueType)); - } - tx.commit(); - // cache will be flushed - pi = null; - System.gc(); - - tx.begin(); - - checkValues(oid, firstValue); // check if persistent fields have values set - pi = (CollectionCollections) pm.getObjectById(oid, true); - - // Provide new set of values - for( i = 0; i < n; ++i){ - String valueType = TestUtil.getFieldSpecs(CollectionCollections.fieldSpecs[i]); - pi.set( i, (Collection)secondValue.get(valueType)); - - } - tx.commit(); - // cache will be flushed - pi = null; - System.gc(); - - tx.begin(); - // check new values - checkValues(oid, secondValue); - pi = (CollectionCollections) pm.getObjectById(oid, true); - pm.deletePersistent(pi); - tx.commit(); - tx = null; + // turn on datastore transactions + tx.setOptimistic(false); + tx.begin(); + CollectionCollections pi = new CollectionCollections(); + pi.identifier = 1; + pm.makePersistent(pi); + Object oid = pm.getObjectId(pi); + // Provide initial set of values + setValues(pi, 1); + tx.commit(); + + // cache will be flushed + pi = null; + System.gc(); + + tx.begin(); + setValues(expectedValue, 1); + checkValues(oid, expectedValue); // check if persistent fields have values set + pi = (CollectionCollections) pm.getObjectById(oid, true); + // Provide new set of values + setValues(pi, 2); + tx.commit(); + + // cache will be flushed + pi = null; + System.gc(); + + tx.begin(); + // check new values + setValues(expectedValue, 2); + checkValues(oid, expectedValue); + pi = (CollectionCollections) pm.getObjectById(oid, true); + tx.commit(); + } + + /** */ + private void setValues(CollectionCollections colcol, int order) + { + Vector value; + int n = colcol.getLength(); + for(int i = 0; i < n; ++i){ + String valueType = TestUtil.getFieldSpecs(CollectionCollections.fieldSpecs[i]); + value = TestUtil.makeNewVectorInstance(valueType, order); + colcol.set( i, value); } - finally { - if ((tx != null) && tx.isActive()) - tx.rollback(); - } } /** */ - private void checkValues(Object oid, Hashtable startValue) + private void checkValues(Object oid, CollectionCollections expectedValue) { int ret = 0; int i; - Collection value; + StringBuffer sbuf = new StringBuffer(); CollectionCollections pi = (CollectionCollections) pm.getObjectById(oid, true); int n = pi.getLength(); - for( i = 0; i < n; ++i){ - String valueType = TestUtil.getFieldSpecs(CollectionCollections.fieldSpecs[i]); - Collection compareWith = (Collection)startValue.get(valueType); - + for(i = 0; i < n; ++i) { + Collection compareWith = expectedValue.get(i); Collection val = pi.get(i); - if(! val.equals(compareWith) ){ - fail(ASSERTION_FAILED, - "Incorrect value for " + CollectionCollections.fieldSpecs[i]); + if( val.size() != compareWith.size()) { + sbuf.append("\nFor element " + i + ", expected size = " + + compareWith.size() + ", actual size = " + val.size() + + " . "); + continue; } + if(! val.equals(compareWith)) { + sbuf.append("\nFor element " + i + ", expected = " + + compareWith + ", actual = " + val + " . "); + } } + if(sbuf.length() > 0) { + fail(ASSERTION_FAILED, + "Expected and observed do not match!!" + sbuf.toString()); + } } }