Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/AllTypes.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/AllTypes.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/AllTypes.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/AllTypes.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,320 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; +import java.util.Date; +import java.util.Locale; +import java.util.GregorianCalendar; +import java.util.Calendar; +import java.util.TimeZone; +import java.math.BigDecimal; +import java.math.BigInteger; + +import javax.jdo.*; + +public class AllTypes { + private int id; + private boolean fld_boolean; + private byte fld_byte; + private char fld_char; + private double fld_double; + private float fld_float; + private int fld_int; + private long fld_long; + private short fld_short; + + private Boolean fld_Boolean; + private Byte fld_Byte; + private Character fld_Character; + private Double fld_Double; + private Float fld_Float; + private Integer fld_Integer; + private Long fld_Long; + private Short fld_Short; + + private String fld_String; + private Locale fld_Locale; + private Date fld_Date; + private BigDecimal fld_BigDecimal; + private BigInteger fld_BigInteger; + + public static int veryLargePositiveInt = Integer.MAX_VALUE - 511; + public static int veryLargeNegativeInt = Integer.MIN_VALUE + 512; + + public static int NUM_VALUES = 10; // should equal number of elements in the following arrays + // DO NOT CHANGE THE FOLLOWING VALUES, OR MANY LINES OF CODE IN TESTS MUST CHANGE!!! + public static final boolean[] boolean_values = + { false, true, true, false, true, false, false, false, true, false }; + public static final byte[] byte_values = + { Byte.MIN_VALUE, Byte.MAX_VALUE, 0, -100, 100, -10, 10, 50, 50, 75 }; + public static final char[] char_values = + { Character.MIN_VALUE, Character.MAX_VALUE, ' ', 'A', 'z', 'B', 'F', 'z', 'M', 'M'}; + public static final double DOUBLE_SMALLEST = -9999999999999.9; + public static final double DOUBLE_LARGEST = 9999999999999.9; + public static final double[] double_values = + { DOUBLE_SMALLEST, DOUBLE_LARGEST, 0.0, 100.0, 100.0, + 50000000.0, -234234.234, 1000000000.0, 350.5, -25.5 }; + public static final float FLOAT_SMALLEST = -999999999999.9f; + public static final float FLOAT_LARGEST = 999999999999.9f; + public static final float[] float_values = + { FLOAT_SMALLEST, FLOAT_LARGEST, 0.0f, 100.0f, 100.0f, + 50000000.0f, -234.23f, 1000000000.0f, 350.5f, -25.5f }; + public static final int[] int_values = + { veryLargeNegativeInt, veryLargePositiveInt, 0, 100, 100, 1000, -1000, 1000000, -1000000, 10000}; + public static final long[] long_values = + { Long.MIN_VALUE, Long.MAX_VALUE, 0, 100, 100, 1000, -1000, 1000000, -1000, -1000000}; + public static final short[] short_values = + { Short.MIN_VALUE, Short.MAX_VALUE, 0, 100, 100, 1000, -1000, 10000, -10000, -500}; + + public static final Boolean[] Boolean_values = { + new Boolean(false), new Boolean(true), new Boolean(true), new Boolean(false), new Boolean(true), + new Boolean(false), new Boolean(false), new Boolean(false), new Boolean(true), new Boolean(false) + }; + public static final Byte[] Byte_values = { + new Byte(Byte.MIN_VALUE), new Byte(Byte.MAX_VALUE), new Byte((byte)0), new Byte((byte)-100), new Byte((byte)100), + new Byte((byte)-10), new Byte((byte)10), new Byte((byte)50), new Byte((byte)50), new Byte((byte)75) + }; + public static final Character[] Character_values = { + new Character(Character.MIN_VALUE), new Character(Character.MAX_VALUE), + new Character(' '), new Character('A'), + new Character('z'), new Character('B'), + new Character('F'), new Character('z'), + new Character('M'), new Character('M') + }; + public static final Double[] Double_values = { + new Double(DOUBLE_SMALLEST), new Double(DOUBLE_LARGEST), + new Double(0.0), new Double(100.0), + new Double(100.0), new Double(50000000.0), + new Double(-234234.234), new Double(1000000000.0), + new Double(350.5), new Double(-25.5) + }; + public static final Float[] Float_values = { + new Float(FLOAT_SMALLEST), new Float(FLOAT_LARGEST), + new Float(0.0f), new Float(100.0f), + new Float(100.0f), new Float(50000000.0f), + new Float(234234.234f), new Float(1000000000.0f), + new Float(350.5f), new Float(-25.5f) + }; + public static final Integer[] Integer_values = { + new Integer(veryLargeNegativeInt), new Integer(veryLargePositiveInt), + new Integer(0), new Integer(10000), + new Integer(100), new Integer(100), + new Integer(1000000), new Integer(-1000000), + new Integer(-1000), new Integer(1000) + }; + public static final Long[] Long_values = { + new Long(Long.MIN_VALUE), new Long(Long.MAX_VALUE), + new Long(0), new Long(100), + new Long(-1000), new Long(1000), + new Long(-1000), new Long(1000000), + new Long(100), new Long(-1000000) + }; + public static final Short[] Short_values = { + new Short(Short.MIN_VALUE), new Short(Short.MAX_VALUE), + new Short((short)0), new Short((short)100), + new Short((short)100), new Short((short)1000), + new Short((short)-1000), new Short((short)10000), + new Short((short)-10000), new Short((short)-500) + }; + + public static final String[] String_values = { + new String(""), new String("hello world"), + new String("JDO has a very nice persistence API"), new String("JDO"), + new String("Java"), new String("abcde"), + new String("abcdef"), new String("JDO is a breeze to use"), + new String("Java"), new String("Long-live JDO") + }; + public static final Locale[] Locale_values = { + Locale.US, Locale.UK, Locale.FRANCE, Locale.GERMANY, Locale.CANADA, + Locale.JAPAN, Locale.ITALY, Locale.CHINA, Locale.KOREA, Locale.TAIWAN + }; + + public static final BigDecimal[] BigDecimal_values = { + new BigDecimal("24323423423.234234"), new BigDecimal("-1123123.22"), + new BigDecimal("100.0"), new BigDecimal("100.0"), + new BigDecimal("0"), new BigDecimal("123232.22"), + new BigDecimal("-234234.23333"), new BigDecimal("98345983475.23"), + new BigDecimal("-23.000034"), new BigDecimal("989899.98889") + }; + public static final BigInteger[] BigInteger_values = { + new BigInteger("-999999999999999999"), new BigInteger("987034534985043985"), + new BigInteger("0"), new BigInteger("39582"), + new BigInteger("39582"), new BigInteger("1000000000"), + new BigInteger("-1000000000"), new BigInteger("153"), + new BigInteger("-27345"), new BigInteger("1333330") + }; + + public static final Date[] Date_values = new Date[10]; + static { + GregorianCalendar gc = new GregorianCalendar(TimeZone.getTimeZone("GMT"), Locale.UK); + gc.clear(); + gc.set(1999, Calendar.DECEMBER, 31, 9, 0, 0); + Date_values[0] = gc.getTime(); + gc.set(1957, Calendar.FEBRUARY, 1, 9, 0, 0); + Date_values[1] = gc.getTime(); + gc.set(2032, Calendar.MARCH, 15, 9, 0, 0); + Date_values[2] = gc.getTime(); + gc.set(1957, Calendar.FEBRUARY, 1, 9, 0, 0); + Date_values[3] = gc.getTime(); + gc.set(1995, Calendar.JUNE, 14, 9, 0, 0); + Date_values[4] = gc.getTime(); + gc.set(1992, Calendar.NOVEMBER, 22, 9, 0, 0); + Date_values[5] = gc.getTime(); + gc.set(1900, Calendar.JANUARY, 1, 9, 0, 0); + Date_values[6] = gc.getTime(); + gc.set(2015, Calendar.SEPTEMBER, 15, 9, 0, 0); + Date_values[7] = gc.getTime(); + gc.set(1979, Calendar.AUGUST, 12, 9, 0, 0); + Date_values[8] = gc.getTime(); + gc.set(1979, Calendar.AUGUST, 13, 9, 0, 0); + Date_values[9] = gc.getTime(); + } + +public AllTypes() +{ + id = 0; +} + +public AllTypes(int id) +{ + this.id = id; +} + +public void setId(int id) { this.id = id; } +public boolean getboolean() { return fld_boolean;} +public void setboolean(boolean b) { fld_boolean = b;} + +public byte getbyte() { return fld_byte;} +public void setbyte(byte b) { fld_byte = b;} + +public char getchar() { return fld_char;} +public void setchar(char c) { fld_char = c;} + +public double getdouble() { return fld_double;} +public void setdouble(double d) { fld_double = d;} + +public float getfloat() { return fld_float;} +public void setfloat(float f) { fld_float = f;} + +public int getint() { return fld_int;} +public void setint(int i) { fld_int = i;} + +public long getlong() { return fld_long;} +public void setlong(long l) { fld_long = l;} + +public short getshort() { return fld_short;} +public void setshort(short s) { fld_short = s;} + +public Boolean getBoolean() { return fld_Boolean;} +public void setBoolean(Boolean b) { fld_Boolean = b;} + +public Byte getByte() { return fld_Byte;} +public void setByte(Byte b) { fld_Byte = b;} + +public Character getCharacter() { return fld_Character;} +public void setCharacter(Character c){ fld_Character = c;} + +public Double getDouble() { return fld_Double;} +public void setDouble(Double d) { fld_Double = d;} + +public Float getFloat() { return fld_Float;} +public void setFloat(Float f) { fld_Float = f;} + +public Integer getInteger() { return fld_Integer;} +public void setInteger(Integer i) { fld_Integer = i;} + +public Long getLong() { return fld_Long;} +public void setLong(Long l) { fld_Long = l;} + +public Short getShort() { return fld_Short;} +public void setShort(Short s) { fld_Short = s;} + +public String getString() { return fld_String;} +public void setString(String s) { fld_String = s;} + +public Locale getLocale() { return fld_Locale;} +public void setLocale(Locale l) { fld_Locale = l;} + +public Date getDate() { return fld_Date;} +public void setDate(Date d) { fld_Date = d;} + +public BigDecimal getBigDecimal() { return fld_BigDecimal;} +public void setBigDecimal(BigDecimal bd) { fld_BigDecimal = bd;} + +public BigInteger getBigInteger() { return fld_BigInteger;} +public void setBigInteger(BigInteger bi) { fld_BigInteger = bi;} + + +public static void load(PersistenceManager pm) +{ + Transaction t = pm.currentTransaction(); + t.begin(); + for( int i = 0; i < NUM_VALUES; ++i){ + AllTypes o = new AllTypes(i); + pm.makePersistent(o); + o.setboolean(boolean_values[i]); + o.setBoolean(Boolean_values[i]); + o.setbyte(byte_values[i]); + o.setByte(Byte_values[i]); + o.setchar(char_values[i]); + o.setCharacter(Character_values[i]); + o.setdouble(double_values[i]); + o.setDouble(Double_values[i]); + o.setfloat(float_values[i]); + o.setFloat(Float_values[i]); + o.setint(int_values[i]); + o.setInteger(Integer_values[i]); + o.setlong(long_values[i]); + o.setLong(Long_values[i]); + o.setshort(short_values[i]); + o.setShort(Short_values[i]); + o.setString(String_values[i]); + o.setLocale(Locale_values[i]); + o.setDate(Date_values[i]); + o.setBigDecimal(BigDecimal_values[i]); + o.setBigInteger(BigInteger_values[i]); + } + t.commit(); +} + + public static class Oid implements Serializable { + public int id; + + public Oid() { + } + + public Oid(String s) { id = Integer.parseInt(justTheId(s)); } + + public String toString() { return this.getClass().getName() + ": " + id;} + + public int hashCode() { return (int)id ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.id == this.id; + } + return false; + } + + protected static String justTheId(String str) { + return str.substring(str.indexOf(':') + 1); + } + + } +}
Propchange: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/AllTypes.java ------------------------------------------------------------------------------ svn:executable = * Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayCollections.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayCollections.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayCollections.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayCollections.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,273 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; +import java.util.*; +import java.math.*; + +public class ArrayCollections { + public int identifier; + public Object [] ArrayOfObject0; + public Object [] ArrayOfObject1; + public SimpleClass [] ArrayOfSimpleClass2; + public SimpleClass [] ArrayOfSimpleClass3; + public SimpleInterface [] ArrayOfSimpleInterface4; + public SimpleInterface [] ArrayOfSimpleInterface5; + public String [] ArrayOfString6; + public String [] ArrayOfString7; + public Date [] ArrayOfDate8; + public Date [] ArrayOfDate9; + public Locale [] ArrayOfLocale10; + public Locale [] ArrayOfLocale11; + public BigDecimal [] ArrayOfBigDecimal12; + public BigDecimal [] ArrayOfBigDecimal13; + public BigInteger [] ArrayOfBigInteger14; + public BigInteger [] ArrayOfBigInteger15; + public Byte [] ArrayOfByte16; + public Byte [] ArrayOfByte17; + public Double [] ArrayOfDouble18; + public Double [] ArrayOfDouble19; + public Float [] ArrayOfFloat20; + public Float [] ArrayOfFloat21; + public Integer [] ArrayOfInteger22; + public Integer [] ArrayOfInteger23; + public Long [] ArrayOfLong24; + public Long [] ArrayOfLong25; + public Short [] ArrayOfShort26; + public Short [] ArrayOfShort27; + + public static final String [] fieldSpecs = { + "embedded-element=true public Object [] ArrayOfObject0", + "embedded-element=false public Object [] ArrayOfObject1", + "embedded-element=true public SimpleClass [] ArrayOfSimpleClass2", + "embedded-element=false public SimpleClass [] ArrayOfSimpleClass3", + "embedded-element=true public SimpleInterface [] ArrayOfSimpleInterface4", + "embedded-element=false public SimpleInterface [] ArrayOfSimpleInterface5", + "embedded-element=true public String [] ArrayOfString6", + "embedded-element=false public String [] ArrayOfString7", + "embedded-element=true public Date [] ArrayOfDate8", + "embedded-element=false public Date [] ArrayOfDate9", + "embedded-element=true public Locale [] ArrayOfLocale10", + "embedded-element=false public Locale [] ArrayOfLocale11", + "embedded-element=true public BigDecimal [] ArrayOfBigDecimal12", + "embedded-element=false public BigDecimal [] ArrayOfBigDecimal13", + "embedded-element=true public BigInteger [] ArrayOfBigInteger14", + "embedded-element=false public BigInteger [] ArrayOfBigInteger15", + "embedded-element=true public Byte [] ArrayOfByte16", + "embedded-element=false public Byte [] ArrayOfByte17", + "embedded-element=true public Double [] ArrayOfDouble18", + "embedded-element=false public Double [] ArrayOfDouble19", + "embedded-element=true public Float [] ArrayOfFloat20", + "embedded-element=false public Float [] ArrayOfFloat21", + "embedded-element=true public Integer [] ArrayOfInteger22", + "embedded-element=false public Integer [] ArrayOfInteger23", + "embedded-element=true public Long [] ArrayOfLong24", + "embedded-element=false public Long [] ArrayOfLong25", + "embedded-element=true public Short [] ArrayOfShort26", + "embedded-element=false public Short [] ArrayOfShort27" + }; + public int getLength() + { + return fieldSpecs.length; + } + public Object [] get(int index) + { + switch (index) + { + case(0): + return ArrayOfObject0; + case(1): + return ArrayOfObject1; + case(2): + return ArrayOfSimpleClass2; + case(3): + return ArrayOfSimpleClass3; + case(4): + return ArrayOfSimpleInterface4; + case(5): + return ArrayOfSimpleInterface5; + case(6): + return ArrayOfString6; + case(7): + return ArrayOfString7; + case(8): + return ArrayOfDate8; + case(9): + return ArrayOfDate9; + case(10): + return ArrayOfLocale10; + case(11): + return ArrayOfLocale11; + case(12): + return ArrayOfBigDecimal12; + case(13): + return ArrayOfBigDecimal13; + case(14): + return ArrayOfBigInteger14; + case(15): + return ArrayOfBigInteger15; + case(16): + return ArrayOfByte16; + case(17): + return ArrayOfByte17; + case(18): + return ArrayOfDouble18; + case(19): + return ArrayOfDouble19; + case(20): + return ArrayOfFloat20; + case(21): + return ArrayOfFloat21; + case(22): + return ArrayOfInteger22; + case(23): + return ArrayOfInteger23; + case(24): + return ArrayOfLong24; + case(25): + return ArrayOfLong25; + case(26): + return ArrayOfShort26; + case(27): + return ArrayOfShort27; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,Object [] value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + ArrayOfObject0= (Object []) value ; + break; + case(1): + ArrayOfObject1= (Object []) value ; + break; + case(2): + ArrayOfSimpleClass2= (SimpleClass []) value ; + break; + case(3): + ArrayOfSimpleClass3= (SimpleClass []) value ; + break; + case(4): + ArrayOfSimpleInterface4= (SimpleInterface []) value ; + break; + case(5): + ArrayOfSimpleInterface5= (SimpleInterface []) value ; + break; + case(6): + ArrayOfString6= (String []) value ; + break; + case(7): + ArrayOfString7= (String []) value ; + break; + case(8): + ArrayOfDate8= (Date []) value ; + break; + case(9): + ArrayOfDate9= (Date []) value ; + break; + case(10): + ArrayOfLocale10= (Locale []) value ; + break; + case(11): + ArrayOfLocale11= (Locale []) value ; + break; + case(12): + ArrayOfBigDecimal12= (BigDecimal []) value ; + break; + case(13): + ArrayOfBigDecimal13= (BigDecimal []) value ; + break; + case(14): + ArrayOfBigInteger14= (BigInteger []) value ; + break; + case(15): + ArrayOfBigInteger15= (BigInteger []) value ; + break; + case(16): + ArrayOfByte16= (Byte []) value ; + break; + case(17): + ArrayOfByte17= (Byte []) value ; + break; + case(18): + ArrayOfDouble18= (Double []) value ; + break; + case(19): + ArrayOfDouble19= (Double []) value ; + break; + case(20): + ArrayOfFloat20= (Float []) value ; + break; + case(21): + ArrayOfFloat21= (Float []) value ; + break; + case(22): + ArrayOfInteger22= (Integer []) value ; + break; + case(23): + ArrayOfInteger23= (Integer []) value ; + break; + case(24): + ArrayOfLong24= (Long []) value ; + break; + case(25): + ArrayOfLong25= (Long []) value ; + break; + case(26): + ArrayOfShort26= (Short []) value ; + break; + case(27): + ArrayOfShort27= (Short []) value ; + break; + default: + throw new IndexOutOfBoundsException(); + } + return true; + } + + public static class Oid implements Serializable { + public int identifier; + + public Oid() { + } + + public Oid(String s) { identifier = Integer.parseInt(justTheId(s)); } + + public String toString() { return this.getClass().getName() + ": " + identifier;} + + public int hashCode() { return (int)identifier ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.identifier == this.identifier; + } + return false; + } + + protected static String justTheId(String str) { + return str.substring(str.indexOf(':') + 1); + } + + } +} Propchange: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayCollections.java ------------------------------------------------------------------------------ svn:executable = * Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayListCollections.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayListCollections.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayListCollections.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayListCollections.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,370 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; +import java.util.ArrayList; + +public class ArrayListCollections { + public int identifier; + public ArrayList ArrayListOfObject0; + public ArrayList ArrayListOfObject1; + public ArrayList ArrayListOfObject2; + public ArrayList ArrayListOfSimpleClass3; + public ArrayList ArrayListOfSimpleClass4; + public ArrayList ArrayListOfSimpleClass5; + public ArrayList ArrayListOfSimpleInterface6; + public ArrayList ArrayListOfSimpleInterface7; + public ArrayList ArrayListOfSimpleInterface8; + public ArrayList ArrayListOfString9; + public ArrayList ArrayListOfString10; + public ArrayList ArrayListOfString11; + public ArrayList ArrayListOfDate12; + public ArrayList ArrayListOfDate13; + public ArrayList ArrayListOfDate14; + public ArrayList ArrayListOfLocale15; + public ArrayList ArrayListOfLocale16; + public ArrayList ArrayListOfLocale17; + public ArrayList ArrayListOfBigDecimal18; + public ArrayList ArrayListOfBigDecimal19; + public ArrayList ArrayListOfBigDecimal20; + public ArrayList ArrayListOfBigInteger21; + public ArrayList ArrayListOfBigInteger22; + public ArrayList ArrayListOfBigInteger23; + public ArrayList ArrayListOfByte24; + public ArrayList ArrayListOfByte25; + public ArrayList ArrayListOfByte26; + public ArrayList ArrayListOfDouble27; + public ArrayList ArrayListOfDouble28; + public ArrayList ArrayListOfDouble29; + public ArrayList ArrayListOfFloat30; + public ArrayList ArrayListOfFloat31; + public ArrayList ArrayListOfFloat32; + public ArrayList ArrayListOfInteger33; + public ArrayList ArrayListOfInteger34; + public ArrayList ArrayListOfInteger35; + public ArrayList ArrayListOfLong36; + public ArrayList ArrayListOfLong37; + public ArrayList ArrayListOfLong38; + public ArrayList ArrayListOfShort39; + public ArrayList ArrayListOfShort40; + public ArrayList ArrayListOfShort41; + + public static final String [] fieldSpecs = { + "public ArrayList ArrayListOfObject0", + "embedded-element=true public ArrayList ArrayListOfObject1", + "embedded-element=false public ArrayList ArrayListOfObject2", + "public ArrayList ArrayListOfSimpleClass3", + "embedded-element=true public ArrayList ArrayListOfSimpleClass4", + "embedded-element=false public ArrayList ArrayListOfSimpleClass5", + "public ArrayList ArrayListOfSimpleInterface6", + "embedded-element=true public ArrayList ArrayListOfSimpleInterface7", + "embedded-element=false public ArrayList ArrayListOfSimpleInterface8", + "public ArrayList ArrayListOfString9", + "embedded-element=true public ArrayList ArrayListOfString10", + "embedded-element=false public ArrayList ArrayListOfString11", + "public ArrayList ArrayListOfDate12", + "embedded-element=true public ArrayList ArrayListOfDate13", + "embedded-element=false public ArrayList ArrayListOfDate14", + "public ArrayList ArrayListOfLocale15", + "embedded-element=true public ArrayList ArrayListOfLocale16", + "embedded-element=false public ArrayList ArrayListOfLocale17", + "public ArrayList ArrayListOfBigDecimal18", + "embedded-element=true public ArrayList ArrayListOfBigDecimal19", + "embedded-element=false public ArrayList ArrayListOfBigDecimal20", + "public ArrayList ArrayListOfBigInteger21", + "embedded-element=true public ArrayList ArrayListOfBigInteger22", + "embedded-element=false public ArrayList ArrayListOfBigInteger23", + "public ArrayList ArrayListOfByte24", + "embedded-element=true public ArrayList ArrayListOfByte25", + "embedded-element=false public ArrayList ArrayListOfByte26", + "public ArrayList ArrayListOfDouble27", + "embedded-element=true public ArrayList ArrayListOfDouble28", + "embedded-element=false public ArrayList ArrayListOfDouble29", + "public ArrayList ArrayListOfFloat30", + "embedded-element=true public ArrayList ArrayListOfFloat31", + "embedded-element=false public ArrayList ArrayListOfFloat32", + "public ArrayList ArrayListOfInteger33", + "embedded-element=true public ArrayList ArrayListOfInteger34", + "embedded-element=false public ArrayList ArrayListOfInteger35", + "public ArrayList ArrayListOfLong36", + "embedded-element=true public ArrayList ArrayListOfLong37", + "embedded-element=false public ArrayList ArrayListOfLong38", + "public ArrayList ArrayListOfShort39", + "embedded-element=true public ArrayList ArrayListOfShort40", + "embedded-element=false public ArrayList ArrayListOfShort41" + }; + public int getLength() + { + return fieldSpecs.length; + } + public ArrayList get(int index) + { + switch (index) + { + case(0): + return ArrayListOfObject0; + case(1): + return ArrayListOfObject1; + case(2): + return ArrayListOfObject2; + case(3): + return ArrayListOfSimpleClass3; + case(4): + return ArrayListOfSimpleClass4; + case(5): + return ArrayListOfSimpleClass5; + case(6): + return ArrayListOfSimpleInterface6; + case(7): + return ArrayListOfSimpleInterface7; + case(8): + return ArrayListOfSimpleInterface8; + case(9): + return ArrayListOfString9; + case(10): + return ArrayListOfString10; + case(11): + return ArrayListOfString11; + case(12): + return ArrayListOfDate12; + case(13): + return ArrayListOfDate13; + case(14): + return ArrayListOfDate14; + case(15): + return ArrayListOfLocale15; + case(16): + return ArrayListOfLocale16; + case(17): + return ArrayListOfLocale17; + case(18): + return ArrayListOfBigDecimal18; + case(19): + return ArrayListOfBigDecimal19; + case(20): + return ArrayListOfBigDecimal20; + case(21): + return ArrayListOfBigInteger21; + case(22): + return ArrayListOfBigInteger22; + case(23): + return ArrayListOfBigInteger23; + case(24): + return ArrayListOfByte24; + case(25): + return ArrayListOfByte25; + case(26): + return ArrayListOfByte26; + case(27): + return ArrayListOfDouble27; + case(28): + return ArrayListOfDouble28; + case(29): + return ArrayListOfDouble29; + case(30): + return ArrayListOfFloat30; + case(31): + return ArrayListOfFloat31; + case(32): + return ArrayListOfFloat32; + case(33): + return ArrayListOfInteger33; + case(34): + return ArrayListOfInteger34; + case(35): + return ArrayListOfInteger35; + case(36): + return ArrayListOfLong36; + case(37): + return ArrayListOfLong37; + case(38): + return ArrayListOfLong38; + case(39): + return ArrayListOfShort39; + case(40): + return ArrayListOfShort40; + case(41): + return ArrayListOfShort41; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,ArrayList value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + ArrayListOfObject0= value; + break; + case(1): + ArrayListOfObject1= value; + break; + case(2): + ArrayListOfObject2= value; + break; + case(3): + ArrayListOfSimpleClass3= value; + break; + case(4): + ArrayListOfSimpleClass4= value; + break; + case(5): + ArrayListOfSimpleClass5= value; + break; + case(6): + ArrayListOfSimpleInterface6= value; + break; + case(7): + ArrayListOfSimpleInterface7= value; + break; + case(8): + ArrayListOfSimpleInterface8= value; + break; + case(9): + ArrayListOfString9= value; + break; + case(10): + ArrayListOfString10= value; + break; + case(11): + ArrayListOfString11= value; + break; + case(12): + ArrayListOfDate12= value; + break; + case(13): + ArrayListOfDate13= value; + break; + case(14): + ArrayListOfDate14= value; + break; + case(15): + ArrayListOfLocale15= value; + break; + case(16): + ArrayListOfLocale16= value; + break; + case(17): + ArrayListOfLocale17= value; + break; + case(18): + ArrayListOfBigDecimal18= value; + break; + case(19): + ArrayListOfBigDecimal19= value; + break; + case(20): + ArrayListOfBigDecimal20= value; + break; + case(21): + ArrayListOfBigInteger21= value; + break; + case(22): + ArrayListOfBigInteger22= value; + break; + case(23): + ArrayListOfBigInteger23= value; + break; + case(24): + ArrayListOfByte24= value; + break; + case(25): + ArrayListOfByte25= value; + break; + case(26): + ArrayListOfByte26= value; + break; + case(27): + ArrayListOfDouble27= value; + break; + case(28): + ArrayListOfDouble28= value; + break; + case(29): + ArrayListOfDouble29= value; + break; + case(30): + ArrayListOfFloat30= value; + break; + case(31): + ArrayListOfFloat31= value; + break; + case(32): + ArrayListOfFloat32= value; + break; + case(33): + ArrayListOfInteger33= value; + break; + case(34): + ArrayListOfInteger34= value; + break; + case(35): + ArrayListOfInteger35= value; + break; + case(36): + ArrayListOfLong36= value; + break; + case(37): + ArrayListOfLong37= value; + break; + case(38): + ArrayListOfLong38= value; + break; + case(39): + ArrayListOfShort39= value; + break; + case(40): + ArrayListOfShort40= value; + break; + case(41): + ArrayListOfShort41= value; + break; + default: + throw new IndexOutOfBoundsException(); + } + return true; + } + + public static class Oid implements Serializable { + public int identifier; + + public Oid() { + } + + public Oid(String s) { identifier = Integer.parseInt(justTheId(s)); } + + public String toString() { return this.getClass().getName() + ": " + identifier;} + + public int hashCode() { return (int)identifier ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.identifier == this.identifier; + } + return false; + } + + protected static String justTheId(String str) { + return str.substring(str.indexOf(':') + 1); + } + + } +} Propchange: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/ArrayListCollections.java ------------------------------------------------------------------------------ svn:executable = * Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/CollectionCollections.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/CollectionCollections.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/CollectionCollections.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/CollectionCollections.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,370 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; +import java.util.Collection; + +public class CollectionCollections { + public int identifier; + public Collection CollectionOfObject0; + public Collection CollectionOfObject1; + public Collection CollectionOfObject2; + public Collection CollectionOfSimpleClass3; + public Collection CollectionOfSimpleClass4; + public Collection CollectionOfSimpleClass5; + public Collection CollectionOfSimpleInterface6; + public Collection CollectionOfSimpleInterface7; + public Collection CollectionOfSimpleInterface8; + public Collection CollectionOfString9; + public Collection CollectionOfString10; + public Collection CollectionOfString11; + public Collection CollectionOfDate12; + public Collection CollectionOfDate13; + public Collection CollectionOfDate14; + public Collection CollectionOfLocale15; + public Collection CollectionOfLocale16; + public Collection CollectionOfLocale17; + public Collection CollectionOfBigDecimal18; + public Collection CollectionOfBigDecimal19; + public Collection CollectionOfBigDecimal20; + public Collection CollectionOfBigInteger21; + public Collection CollectionOfBigInteger22; + public Collection CollectionOfBigInteger23; + public Collection CollectionOfByte24; + public Collection CollectionOfByte25; + public Collection CollectionOfByte26; + public Collection CollectionOfDouble27; + public Collection CollectionOfDouble28; + public Collection CollectionOfDouble29; + public Collection CollectionOfFloat30; + public Collection CollectionOfFloat31; + public Collection CollectionOfFloat32; + public Collection CollectionOfInteger33; + public Collection CollectionOfInteger34; + public Collection CollectionOfInteger35; + public Collection CollectionOfLong36; + public Collection CollectionOfLong37; + public Collection CollectionOfLong38; + public Collection CollectionOfShort39; + public Collection CollectionOfShort40; + public Collection CollectionOfShort41; + + public static final String [] fieldSpecs = { + "public Collection CollectionOfObject0", + "embedded-element=true public Collection CollectionOfObject1", + "embedded-element=false public Collection CollectionOfObject2", + "public Collection CollectionOfSimpleClass3", + "embedded-element=true public Collection CollectionOfSimpleClass4", + "embedded-element=false public Collection CollectionOfSimpleClass5", + "public Collection CollectionOfSimpleInterface6", + "embedded-element=true public Collection CollectionOfSimpleInterface7", + "embedded-element=false public Collection CollectionOfSimpleInterface8", + "public Collection CollectionOfString9", + "embedded-element=true public Collection CollectionOfString10", + "embedded-element=false public Collection CollectionOfString11", + "public Collection CollectionOfDate12", + "embedded-element=true public Collection CollectionOfDate13", + "embedded-element=false public Collection CollectionOfDate14", + "public Collection CollectionOfLocale15", + "embedded-element=true public Collection CollectionOfLocale16", + "embedded-element=false public Collection CollectionOfLocale17", + "public Collection CollectionOfBigDecimal18", + "embedded-element=true public Collection CollectionOfBigDecimal19", + "embedded-element=false public Collection CollectionOfBigDecimal20", + "public Collection CollectionOfBigInteger21", + "embedded-element=true public Collection CollectionOfBigInteger22", + "embedded-element=false public Collection CollectionOfBigInteger23", + "public Collection CollectionOfByte24", + "embedded-element=true public Collection CollectionOfByte25", + "embedded-element=false public Collection CollectionOfByte26", + "public Collection CollectionOfDouble27", + "embedded-element=true public Collection CollectionOfDouble28", + "embedded-element=false public Collection CollectionOfDouble29", + "public Collection CollectionOfFloat30", + "embedded-element=true public Collection CollectionOfFloat31", + "embedded-element=false public Collection CollectionOfFloat32", + "public Collection CollectionOfInteger33", + "embedded-element=true public Collection CollectionOfInteger34", + "embedded-element=false public Collection CollectionOfInteger35", + "public Collection CollectionOfLong36", + "embedded-element=true public Collection CollectionOfLong37", + "embedded-element=false public Collection CollectionOfLong38", + "public Collection CollectionOfShort39", + "embedded-element=true public Collection CollectionOfShort40", + "embedded-element=false public Collection CollectionOfShort41" + }; + public int getLength() + { + return fieldSpecs.length; + } + public Collection get(int index) + { + switch (index) + { + case(0): + return CollectionOfObject0; + case(1): + return CollectionOfObject1; + case(2): + return CollectionOfObject2; + case(3): + return CollectionOfSimpleClass3; + case(4): + return CollectionOfSimpleClass4; + case(5): + return CollectionOfSimpleClass5; + case(6): + return CollectionOfSimpleInterface6; + case(7): + return CollectionOfSimpleInterface7; + case(8): + return CollectionOfSimpleInterface8; + case(9): + return CollectionOfString9; + case(10): + return CollectionOfString10; + case(11): + return CollectionOfString11; + case(12): + return CollectionOfDate12; + case(13): + return CollectionOfDate13; + case(14): + return CollectionOfDate14; + case(15): + return CollectionOfLocale15; + case(16): + return CollectionOfLocale16; + case(17): + return CollectionOfLocale17; + case(18): + return CollectionOfBigDecimal18; + case(19): + return CollectionOfBigDecimal19; + case(20): + return CollectionOfBigDecimal20; + case(21): + return CollectionOfBigInteger21; + case(22): + return CollectionOfBigInteger22; + case(23): + return CollectionOfBigInteger23; + case(24): + return CollectionOfByte24; + case(25): + return CollectionOfByte25; + case(26): + return CollectionOfByte26; + case(27): + return CollectionOfDouble27; + case(28): + return CollectionOfDouble28; + case(29): + return CollectionOfDouble29; + case(30): + return CollectionOfFloat30; + case(31): + return CollectionOfFloat31; + case(32): + return CollectionOfFloat32; + case(33): + return CollectionOfInteger33; + case(34): + return CollectionOfInteger34; + case(35): + return CollectionOfInteger35; + case(36): + return CollectionOfLong36; + case(37): + return CollectionOfLong37; + case(38): + return CollectionOfLong38; + case(39): + return CollectionOfShort39; + case(40): + return CollectionOfShort40; + case(41): + return CollectionOfShort41; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,Collection value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + CollectionOfObject0= value; + break; + case(1): + CollectionOfObject1= value; + break; + case(2): + CollectionOfObject2= value; + break; + case(3): + CollectionOfSimpleClass3= value; + break; + case(4): + CollectionOfSimpleClass4= value; + break; + case(5): + CollectionOfSimpleClass5= value; + break; + case(6): + CollectionOfSimpleInterface6= value; + break; + case(7): + CollectionOfSimpleInterface7= value; + break; + case(8): + CollectionOfSimpleInterface8= value; + break; + case(9): + CollectionOfString9= value; + break; + case(10): + CollectionOfString10= value; + break; + case(11): + CollectionOfString11= value; + break; + case(12): + CollectionOfDate12= value; + break; + case(13): + CollectionOfDate13= value; + break; + case(14): + CollectionOfDate14= value; + break; + case(15): + CollectionOfLocale15= value; + break; + case(16): + CollectionOfLocale16= value; + break; + case(17): + CollectionOfLocale17= value; + break; + case(18): + CollectionOfBigDecimal18= value; + break; + case(19): + CollectionOfBigDecimal19= value; + break; + case(20): + CollectionOfBigDecimal20= value; + break; + case(21): + CollectionOfBigInteger21= value; + break; + case(22): + CollectionOfBigInteger22= value; + break; + case(23): + CollectionOfBigInteger23= value; + break; + case(24): + CollectionOfByte24= value; + break; + case(25): + CollectionOfByte25= value; + break; + case(26): + CollectionOfByte26= value; + break; + case(27): + CollectionOfDouble27= value; + break; + case(28): + CollectionOfDouble28= value; + break; + case(29): + CollectionOfDouble29= value; + break; + case(30): + CollectionOfFloat30= value; + break; + case(31): + CollectionOfFloat31= value; + break; + case(32): + CollectionOfFloat32= value; + break; + case(33): + CollectionOfInteger33= value; + break; + case(34): + CollectionOfInteger34= value; + break; + case(35): + CollectionOfInteger35= value; + break; + case(36): + CollectionOfLong36= value; + break; + case(37): + CollectionOfLong37= value; + break; + case(38): + CollectionOfLong38= value; + break; + case(39): + CollectionOfShort39= value; + break; + case(40): + CollectionOfShort40= value; + break; + case(41): + CollectionOfShort41= value; + break; + default: + throw new IndexOutOfBoundsException(); + } + return true; + } + + public static class Oid implements Serializable { + public int identifier; + + public Oid() { + } + + public Oid(String s) { identifier = Integer.parseInt(justTheId(s)); } + + public String toString() { return this.getClass().getName() + ": " + identifier;} + + public int hashCode() { return (int)identifier ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.identifier == this.identifier; + } + return false; + } + + protected static String justTheId(String str) { + return str.substring(str.indexOf(':') + 1); + } + + } +} Propchange: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/CollectionCollections.java ------------------------------------------------------------------------------ svn:executable = * Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBigDecimal.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBigDecimal.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBigDecimal.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBigDecimal.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,1090 @@ +/* + * Copyright 2005 The Apache Software Foundation. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.jdo.tck.pc.fieldtypes; + +import java.io.Serializable; + +import java.math.*; +public class FieldsOfBigDecimal { + public int identifier; + private BigDecimal BigDecimal0; + private BigDecimal BigDecimal1; + private BigDecimal BigDecimal2; + private BigDecimal BigDecimal3; + private BigDecimal BigDecimal4; + private BigDecimal BigDecimal5; + private BigDecimal BigDecimal6; + private BigDecimal BigDecimal7; + private static BigDecimal BigDecimal8; + private transient BigDecimal BigDecimal9; + private transient BigDecimal BigDecimal10; + private transient BigDecimal BigDecimal11; + private transient BigDecimal BigDecimal12; + private transient BigDecimal BigDecimal13; + private transient BigDecimal BigDecimal14; + private final BigDecimal BigDecimal15 = new BigDecimal(100.15); + private volatile BigDecimal BigDecimal16; + private volatile BigDecimal BigDecimal17; + private volatile BigDecimal BigDecimal18; + private volatile BigDecimal BigDecimal19; + private volatile BigDecimal BigDecimal20; + private volatile BigDecimal BigDecimal21; + private volatile BigDecimal BigDecimal22; + private volatile BigDecimal BigDecimal23; + private static transient BigDecimal BigDecimal24; + private static final BigDecimal BigDecimal25 = new BigDecimal(100.15); + private static volatile BigDecimal BigDecimal26; + private transient final BigDecimal BigDecimal27 = new BigDecimal(100.15); + private transient volatile BigDecimal BigDecimal28; + private transient volatile BigDecimal BigDecimal29; + private transient volatile BigDecimal BigDecimal30; + private transient volatile BigDecimal BigDecimal31; + private transient volatile BigDecimal BigDecimal32; + private transient volatile BigDecimal BigDecimal33; + private static transient final BigDecimal BigDecimal34 = new BigDecimal(100.15); + private static transient volatile BigDecimal BigDecimal35; + public BigDecimal BigDecimal36; + public BigDecimal BigDecimal37; + public BigDecimal BigDecimal38; + public BigDecimal BigDecimal39; + public BigDecimal BigDecimal40; + public BigDecimal BigDecimal41; + public BigDecimal BigDecimal42; + public BigDecimal BigDecimal43; + public static BigDecimal BigDecimal44; + public transient BigDecimal BigDecimal45; + public transient BigDecimal BigDecimal46; + public transient BigDecimal BigDecimal47; + public transient BigDecimal BigDecimal48; + public transient BigDecimal BigDecimal49; + public transient BigDecimal BigDecimal50; + public final BigDecimal BigDecimal51 = new BigDecimal(100.15); + public volatile BigDecimal BigDecimal52; + public volatile BigDecimal BigDecimal53; + public volatile BigDecimal BigDecimal54; + public volatile BigDecimal BigDecimal55; + public volatile BigDecimal BigDecimal56; + public volatile BigDecimal BigDecimal57; + public volatile BigDecimal BigDecimal58; + public volatile BigDecimal BigDecimal59; + public static transient BigDecimal BigDecimal60; + public static final BigDecimal BigDecimal61 = new BigDecimal(100.15); + public static volatile BigDecimal BigDecimal62; + public transient final BigDecimal BigDecimal63 = new BigDecimal(100.15); + public transient volatile BigDecimal BigDecimal64; + public transient volatile BigDecimal BigDecimal65; + public transient volatile BigDecimal BigDecimal66; + public transient volatile BigDecimal BigDecimal67; + public transient volatile BigDecimal BigDecimal68; + public transient volatile BigDecimal BigDecimal69; + public static transient final BigDecimal BigDecimal70 = new BigDecimal(100.15); + public static transient volatile BigDecimal BigDecimal71; + protected BigDecimal BigDecimal72; + protected BigDecimal BigDecimal73; + protected BigDecimal BigDecimal74; + protected BigDecimal BigDecimal75; + protected BigDecimal BigDecimal76; + protected BigDecimal BigDecimal77; + protected BigDecimal BigDecimal78; + protected BigDecimal BigDecimal79; + protected static BigDecimal BigDecimal80; + protected transient BigDecimal BigDecimal81; + protected transient BigDecimal BigDecimal82; + protected transient BigDecimal BigDecimal83; + protected transient BigDecimal BigDecimal84; + protected transient BigDecimal BigDecimal85; + protected transient BigDecimal BigDecimal86; + protected final BigDecimal BigDecimal87 = new BigDecimal(100.15); + protected volatile BigDecimal BigDecimal88; + protected volatile BigDecimal BigDecimal89; + protected volatile BigDecimal BigDecimal90; + protected volatile BigDecimal BigDecimal91; + protected volatile BigDecimal BigDecimal92; + protected volatile BigDecimal BigDecimal93; + protected volatile BigDecimal BigDecimal94; + protected volatile BigDecimal BigDecimal95; + protected static transient BigDecimal BigDecimal96; + protected static final BigDecimal BigDecimal97 = new BigDecimal(100.15); + protected static volatile BigDecimal BigDecimal98; + protected transient final BigDecimal BigDecimal99 = new BigDecimal(100.15); + protected transient volatile BigDecimal BigDecimal100; + protected transient volatile BigDecimal BigDecimal101; + protected transient volatile BigDecimal BigDecimal102; + protected transient volatile BigDecimal BigDecimal103; + protected transient volatile BigDecimal BigDecimal104; + protected transient volatile BigDecimal BigDecimal105; + protected static transient final BigDecimal BigDecimal106 = new BigDecimal(100.15); + protected static transient volatile BigDecimal BigDecimal107; + BigDecimal BigDecimal108; + BigDecimal BigDecimal109; + BigDecimal BigDecimal110; + BigDecimal BigDecimal111; + BigDecimal BigDecimal112; + BigDecimal BigDecimal113; + BigDecimal BigDecimal114; + BigDecimal BigDecimal115; + static BigDecimal BigDecimal116; + transient BigDecimal BigDecimal117; + transient BigDecimal BigDecimal118; + transient BigDecimal BigDecimal119; + transient BigDecimal BigDecimal120; + transient BigDecimal BigDecimal121; + transient BigDecimal BigDecimal122; + final BigDecimal BigDecimal123 = new BigDecimal(100.15); + volatile BigDecimal BigDecimal124; + volatile BigDecimal BigDecimal125; + volatile BigDecimal BigDecimal126; + volatile BigDecimal BigDecimal127; + volatile BigDecimal BigDecimal128; + volatile BigDecimal BigDecimal129; + volatile BigDecimal BigDecimal130; + volatile BigDecimal BigDecimal131; + static transient BigDecimal BigDecimal132; + static final BigDecimal BigDecimal133 = new BigDecimal(100.15); + static volatile BigDecimal BigDecimal134; + transient final BigDecimal BigDecimal135 = new BigDecimal(100.15); + transient volatile BigDecimal BigDecimal136; + transient volatile BigDecimal BigDecimal137; + transient volatile BigDecimal BigDecimal138; + transient volatile BigDecimal BigDecimal139; + transient volatile BigDecimal BigDecimal140; + transient volatile BigDecimal BigDecimal141; + static transient final BigDecimal BigDecimal142 = new BigDecimal(100.15); + static transient volatile BigDecimal BigDecimal143; + +public static final boolean [] isPersistent = { +true,true,true,false,true,true,true,false,false,false, +false,true,true,true,false,false,true,true,true,false, +true,true,true,false,false,false,false,false,false,false, +true,true,true,false,false,false,true,true,true,false, +true,true,true,false,false,false,false,true,true,true, +false,false,true,true,true,false,true,true,true,false, +false,false,false,false,false,false,true,true,true,false, +false,false,true,true,true,false,true,true,true,false, +false,false,false,true,true,true,false,false,true,true, +true,false,true,true,true,false,false,false,false,false, +false,false,true,true,true,false,false,false,true,true, +true,false,true,true,true,false,false,false,false,true, +true,true,false,false,true,true,true,false,true,true, +true,false,false,false,false,false,false,false,true,true, +true,false,false,false + }; + +public static final boolean [] isStatic = { +false,false,false,false,false,false,false,false,true,false, +false,false,false,false,false,false,false,false,false,false, +false,false,false,false,true,true,true,false,false,false, +false,false,false,false,true,true,false,false,false,false, +false,false,false,false,true,false,false,false,false,false, +false,false,false,false,false,false,false,false,false,false, +true,true,true,false,false,false,false,false,false,false, +true,true,false,false,false,false,false,false,false,false, +true,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,false,true,true,true,false, +false,false,false,false,false,false,true,true,false,false, +false,false,false,false,false,false,true,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,false,true,true,true,false,false,false,false,false, +false,false,true,true + }; + +public static final boolean [] isFinal = { +false,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,true,false,false,false,false, +false,false,false,false,false,true,false,true,false,false, +false,false,false,false,true,false,false,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,true,false,false,false,false,false,false,false,false, +false,true,false,true,false,false,false,false,false,false, +true,false,false,false,false,false,false,false,false,false, +false,false,false,false,false,false,false,true,false,false, +false,false,false,false,false,false,false,true,false,true, +false,false,false,false,false,false,true,false,false,false, +false,false,false,false,false,false,false,false,false,false, +false,false,false,true,false,false,false,false,false,false, +false,false,false,true,false,true,false,false,false,false, +false,false,true,false + }; + + public static final String [] fieldSpecs = { + "private BigDecimal BigDecimal0", + "embedded= true private BigDecimal BigDecimal1", + "embedded= false private BigDecimal BigDecimal2", + "persistence-modifier= none private BigDecimal BigDecimal3", + "persistence-modifier= persistent private BigDecimal BigDecimal4", + "persistence-modifier= persistent embedded= true private BigDecimal BigDecimal5", + "persistence-modifier= persistent embedded= false private BigDecimal BigDecimal6", + "persistence-modifier= transactional private BigDecimal BigDecimal7", + "private static BigDecimal BigDecimal8", + "private transient BigDecimal BigDecimal9", + "persistence-modifier= none private transient BigDecimal BigDecimal10", + "persistence-modifier= persistent private transient BigDecimal BigDecimal11", + "persistence-modifier= persistent embedded= true private transient BigDecimal BigDecimal12", + "persistence-modifier= persistent embedded= false private transient BigDecimal BigDecimal13", + "persistence-modifier= transactional private transient BigDecimal BigDecimal14", + "private final BigDecimal BigDecimal15", + "private volatile BigDecimal BigDecimal16", + "embedded= true private volatile BigDecimal BigDecimal17", + "embedded= false private volatile BigDecimal BigDecimal18", + "persistence-modifier= none private volatile BigDecimal BigDecimal19", + "persistence-modifier= persistent private volatile BigDecimal BigDecimal20", + "persistence-modifier= persistent embedded= true private volatile BigDecimal BigDecimal21", + "persistence-modifier= persistent embedded= false private volatile BigDecimal BigDecimal22", + "persistence-modifier= transactional private volatile BigDecimal BigDecimal23", + "private static transient BigDecimal BigDecimal24", + "private static final BigDecimal BigDecimal25", + "private static volatile BigDecimal BigDecimal26", + "private transient final BigDecimal BigDecimal27", + "private transient volatile BigDecimal BigDecimal28", + "persistence-modifier= none private transient volatile BigDecimal BigDecimal29", + "persistence-modifier= persistent private transient volatile BigDecimal BigDecimal30", + "persistence-modifier= persistent embedded= true private transient volatile BigDecimal BigDecimal31", + "persistence-modifier= persistent embedded= false private transient volatile BigDecimal BigDecimal32", + "persistence-modifier= transactional private transient volatile BigDecimal BigDecimal33", + "private static transient final BigDecimal BigDecimal34", + "private static transient volatile BigDecimal BigDecimal35", + "public BigDecimal BigDecimal36", + "embedded= true public BigDecimal BigDecimal37", + "embedded= false public BigDecimal BigDecimal38", + "persistence-modifier= none public BigDecimal BigDecimal39", + "persistence-modifier= persistent public BigDecimal BigDecimal40", + "persistence-modifier= persistent embedded= true public BigDecimal BigDecimal41", + "persistence-modifier= persistent embedded= false public BigDecimal BigDecimal42", + "persistence-modifier= transactional public BigDecimal BigDecimal43", + "public static BigDecimal BigDecimal44", + "public transient BigDecimal BigDecimal45", + "persistence-modifier= none public transient BigDecimal BigDecimal46", + "persistence-modifier= persistent public transient BigDecimal BigDecimal47", + "persistence-modifier= persistent embedded= true public transient BigDecimal BigDecimal48", + "persistence-modifier= persistent embedded= false public transient BigDecimal BigDecimal49", + "persistence-modifier= transactional public transient BigDecimal BigDecimal50", + "public final BigDecimal BigDecimal51", + "public volatile BigDecimal BigDecimal52", + "embedded= true public volatile BigDecimal BigDecimal53", + "embedded= false public volatile BigDecimal BigDecimal54", + "persistence-modifier= none public volatile BigDecimal BigDecimal55", + "persistence-modifier= persistent public volatile BigDecimal BigDecimal56", + "persistence-modifier= persistent embedded= true public volatile BigDecimal BigDecimal57", + "persistence-modifier= persistent embedded= false public volatile BigDecimal BigDecimal58", + "persistence-modifier= transactional public volatile BigDecimal BigDecimal59", + "public static transient BigDecimal BigDecimal60", + "public static final BigDecimal BigDecimal61", + "public static volatile BigDecimal BigDecimal62", + "public transient final BigDecimal BigDecimal63", + "public transient volatile BigDecimal BigDecimal64", + "persistence-modifier= none public transient volatile BigDecimal BigDecimal65", + "persistence-modifier= persistent public transient volatile BigDecimal BigDecimal66", + "persistence-modifier= persistent embedded= true public transient volatile BigDecimal BigDecimal67", + "persistence-modifier= persistent embedded= false public transient volatile BigDecimal BigDecimal68", + "persistence-modifier= transactional public transient volatile BigDecimal BigDecimal69", + "public static transient final BigDecimal BigDecimal70", + "public static transient volatile BigDecimal BigDecimal71", + "protected BigDecimal BigDecimal72", + "embedded= true protected BigDecimal BigDecimal73", + "embedded= false protected BigDecimal BigDecimal74", + "persistence-modifier= none protected BigDecimal BigDecimal75", + "persistence-modifier= persistent protected BigDecimal BigDecimal76", + "persistence-modifier= persistent embedded= true protected BigDecimal BigDecimal77", + "persistence-modifier= persistent embedded= false protected BigDecimal BigDecimal78", + "persistence-modifier= transactional protected BigDecimal BigDecimal79", + "protected static BigDecimal BigDecimal80", + "protected transient BigDecimal BigDecimal81", + "persistence-modifier= none protected transient BigDecimal BigDecimal82", + "persistence-modifier= persistent protected transient BigDecimal BigDecimal83", + "persistence-modifier= persistent embedded= true protected transient BigDecimal BigDecimal84", + "persistence-modifier= persistent embedded= false protected transient BigDecimal BigDecimal85", + "persistence-modifier= transactional protected transient BigDecimal BigDecimal86", + "protected final BigDecimal BigDecimal87", + "protected volatile BigDecimal BigDecimal88", + "embedded= true protected volatile BigDecimal BigDecimal89", + "embedded= false protected volatile BigDecimal BigDecimal90", + "persistence-modifier= none protected volatile BigDecimal BigDecimal91", + "persistence-modifier= persistent protected volatile BigDecimal BigDecimal92", + "persistence-modifier= persistent embedded= true protected volatile BigDecimal BigDecimal93", + "persistence-modifier= persistent embedded= false protected volatile BigDecimal BigDecimal94", + "persistence-modifier= transactional protected volatile BigDecimal BigDecimal95", + "protected static transient BigDecimal BigDecimal96", + "protected static final BigDecimal BigDecimal97", + "protected static volatile BigDecimal BigDecimal98", + "protected transient final BigDecimal BigDecimal99", + "protected transient volatile BigDecimal BigDecimal100", + "persistence-modifier= none protected transient volatile BigDecimal BigDecimal101", + "persistence-modifier= persistent protected transient volatile BigDecimal BigDecimal102", + "persistence-modifier= persistent embedded= true protected transient volatile BigDecimal BigDecimal103", + "persistence-modifier= persistent embedded= false protected transient volatile BigDecimal BigDecimal104", + "persistence-modifier= transactional protected transient volatile BigDecimal BigDecimal105", + "protected static transient final BigDecimal BigDecimal106", + "protected static transient volatile BigDecimal BigDecimal107", + "BigDecimal BigDecimal108", + "embedded= true BigDecimal BigDecimal109", + "embedded= false BigDecimal BigDecimal110", + "persistence-modifier= none BigDecimal BigDecimal111", + "persistence-modifier= persistent BigDecimal BigDecimal112", + "persistence-modifier= persistent embedded= true BigDecimal BigDecimal113", + "persistence-modifier= persistent embedded= false BigDecimal BigDecimal114", + "persistence-modifier= transactional BigDecimal BigDecimal115", + "static BigDecimal BigDecimal116", + "transient BigDecimal BigDecimal117", + "persistence-modifier= none transient BigDecimal BigDecimal118", + "persistence-modifier= persistent transient BigDecimal BigDecimal119", + "persistence-modifier= persistent embedded= true transient BigDecimal BigDecimal120", + "persistence-modifier= persistent embedded= false transient BigDecimal BigDecimal121", + "persistence-modifier= transactional transient BigDecimal BigDecimal122", + "final BigDecimal BigDecimal123", + "volatile BigDecimal BigDecimal124", + "embedded= true volatile BigDecimal BigDecimal125", + "embedded= false volatile BigDecimal BigDecimal126", + "persistence-modifier= none volatile BigDecimal BigDecimal127", + "persistence-modifier= persistent volatile BigDecimal BigDecimal128", + "persistence-modifier= persistent embedded= true volatile BigDecimal BigDecimal129", + "persistence-modifier= persistent embedded= false volatile BigDecimal BigDecimal130", + "persistence-modifier= transactional volatile BigDecimal BigDecimal131", + "static transient BigDecimal BigDecimal132", + "static final BigDecimal BigDecimal133", + "static volatile BigDecimal BigDecimal134", + "transient final BigDecimal BigDecimal135", + "transient volatile BigDecimal BigDecimal136", + "persistence-modifier= none transient volatile BigDecimal BigDecimal137", + "persistence-modifier= persistent transient volatile BigDecimal BigDecimal138", + "persistence-modifier= persistent embedded= true transient volatile BigDecimal BigDecimal139", + "persistence-modifier= persistent embedded= false transient volatile BigDecimal BigDecimal140", + "persistence-modifier= transactional transient volatile BigDecimal BigDecimal141", + "static transient final BigDecimal BigDecimal142", + "static transient volatile BigDecimal BigDecimal143" + }; + public int getLength() + { + return fieldSpecs.length; + } + public BigDecimal get(int index) + { + switch (index) + { + case(0): + return BigDecimal0; + case(1): + return BigDecimal1; + case(2): + return BigDecimal2; + case(3): + return BigDecimal3; + case(4): + return BigDecimal4; + case(5): + return BigDecimal5; + case(6): + return BigDecimal6; + case(7): + return BigDecimal7; + case(8): + return BigDecimal8; + case(9): + return BigDecimal9; + case(10): + return BigDecimal10; + case(11): + return BigDecimal11; + case(12): + return BigDecimal12; + case(13): + return BigDecimal13; + case(14): + return BigDecimal14; + case(15): + return BigDecimal15; + case(16): + return BigDecimal16; + case(17): + return BigDecimal17; + case(18): + return BigDecimal18; + case(19): + return BigDecimal19; + case(20): + return BigDecimal20; + case(21): + return BigDecimal21; + case(22): + return BigDecimal22; + case(23): + return BigDecimal23; + case(24): + return BigDecimal24; + case(25): + return BigDecimal25; + case(26): + return BigDecimal26; + case(27): + return BigDecimal27; + case(28): + return BigDecimal28; + case(29): + return BigDecimal29; + case(30): + return BigDecimal30; + case(31): + return BigDecimal31; + case(32): + return BigDecimal32; + case(33): + return BigDecimal33; + case(34): + return BigDecimal34; + case(35): + return BigDecimal35; + case(36): + return BigDecimal36; + case(37): + return BigDecimal37; + case(38): + return BigDecimal38; + case(39): + return BigDecimal39; + case(40): + return BigDecimal40; + case(41): + return BigDecimal41; + case(42): + return BigDecimal42; + case(43): + return BigDecimal43; + case(44): + return BigDecimal44; + case(45): + return BigDecimal45; + case(46): + return BigDecimal46; + case(47): + return BigDecimal47; + case(48): + return BigDecimal48; + case(49): + return BigDecimal49; + case(50): + return BigDecimal50; + case(51): + return BigDecimal51; + case(52): + return BigDecimal52; + case(53): + return BigDecimal53; + case(54): + return BigDecimal54; + case(55): + return BigDecimal55; + case(56): + return BigDecimal56; + case(57): + return BigDecimal57; + case(58): + return BigDecimal58; + case(59): + return BigDecimal59; + case(60): + return BigDecimal60; + case(61): + return BigDecimal61; + case(62): + return BigDecimal62; + case(63): + return BigDecimal63; + case(64): + return BigDecimal64; + case(65): + return BigDecimal65; + case(66): + return BigDecimal66; + case(67): + return BigDecimal67; + case(68): + return BigDecimal68; + case(69): + return BigDecimal69; + case(70): + return BigDecimal70; + case(71): + return BigDecimal71; + case(72): + return BigDecimal72; + case(73): + return BigDecimal73; + case(74): + return BigDecimal74; + case(75): + return BigDecimal75; + case(76): + return BigDecimal76; + case(77): + return BigDecimal77; + case(78): + return BigDecimal78; + case(79): + return BigDecimal79; + case(80): + return BigDecimal80; + case(81): + return BigDecimal81; + case(82): + return BigDecimal82; + case(83): + return BigDecimal83; + case(84): + return BigDecimal84; + case(85): + return BigDecimal85; + case(86): + return BigDecimal86; + case(87): + return BigDecimal87; + case(88): + return BigDecimal88; + case(89): + return BigDecimal89; + case(90): + return BigDecimal90; + case(91): + return BigDecimal91; + case(92): + return BigDecimal92; + case(93): + return BigDecimal93; + case(94): + return BigDecimal94; + case(95): + return BigDecimal95; + case(96): + return BigDecimal96; + case(97): + return BigDecimal97; + case(98): + return BigDecimal98; + case(99): + return BigDecimal99; + case(100): + return BigDecimal100; + case(101): + return BigDecimal101; + case(102): + return BigDecimal102; + case(103): + return BigDecimal103; + case(104): + return BigDecimal104; + case(105): + return BigDecimal105; + case(106): + return BigDecimal106; + case(107): + return BigDecimal107; + case(108): + return BigDecimal108; + case(109): + return BigDecimal109; + case(110): + return BigDecimal110; + case(111): + return BigDecimal111; + case(112): + return BigDecimal112; + case(113): + return BigDecimal113; + case(114): + return BigDecimal114; + case(115): + return BigDecimal115; + case(116): + return BigDecimal116; + case(117): + return BigDecimal117; + case(118): + return BigDecimal118; + case(119): + return BigDecimal119; + case(120): + return BigDecimal120; + case(121): + return BigDecimal121; + case(122): + return BigDecimal122; + case(123): + return BigDecimal123; + case(124): + return BigDecimal124; + case(125): + return BigDecimal125; + case(126): + return BigDecimal126; + case(127): + return BigDecimal127; + case(128): + return BigDecimal128; + case(129): + return BigDecimal129; + case(130): + return BigDecimal130; + case(131): + return BigDecimal131; + case(132): + return BigDecimal132; + case(133): + return BigDecimal133; + case(134): + return BigDecimal134; + case(135): + return BigDecimal135; + case(136): + return BigDecimal136; + case(137): + return BigDecimal137; + case(138): + return BigDecimal138; + case(139): + return BigDecimal139; + case(140): + return BigDecimal140; + case(141): + return BigDecimal141; + case(142): + return BigDecimal142; + case(143): + return BigDecimal143; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,BigDecimal value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + BigDecimal0= value; + break; + case(1): + BigDecimal1= value; + break; + case(2): + BigDecimal2= value; + break; + case(3): + BigDecimal3= value; + break; + case(4): + BigDecimal4= value; + break; + case(5): + BigDecimal5= value; + break; + case(6): + BigDecimal6= value; + break; + case(7): + BigDecimal7= value; + break; + case(8): + BigDecimal8= value; + break; + case(9): + BigDecimal9= value; + break; + case(10): + BigDecimal10= value; + break; + case(11): + BigDecimal11= value; + break; + case(12): + BigDecimal12= value; + break; + case(13): + BigDecimal13= value; + break; + case(14): + BigDecimal14= value; + break; + case(16): + BigDecimal16= value; + break; + case(17): + BigDecimal17= value; + break; + case(18): + BigDecimal18= value; + break; + case(19): + BigDecimal19= value; + break; + case(20): + BigDecimal20= value; + break; + case(21): + BigDecimal21= value; + break; + case(22): + BigDecimal22= value; + break; + case(23): + BigDecimal23= value; + break; + case(24): + BigDecimal24= value; + break; + case(26): + BigDecimal26= value; + break; + case(28): + BigDecimal28= value; + break; + case(29): + BigDecimal29= value; + break; + case(30): + BigDecimal30= value; + break; + case(31): + BigDecimal31= value; + break; + case(32): + BigDecimal32= value; + break; + case(33): + BigDecimal33= value; + break; + case(35): + BigDecimal35= value; + break; + case(36): + BigDecimal36= value; + break; + case(37): + BigDecimal37= value; + break; + case(38): + BigDecimal38= value; + break; + case(39): + BigDecimal39= value; + break; + case(40): + BigDecimal40= value; + break; + case(41): + BigDecimal41= value; + break; + case(42): + BigDecimal42= value; + break; + case(43): + BigDecimal43= value; + break; + case(44): + BigDecimal44= value; + break; + case(45): + BigDecimal45= value; + break; + case(46): + BigDecimal46= value; + break; + case(47): + BigDecimal47= value; + break; + case(48): + BigDecimal48= value; + break; + case(49): + BigDecimal49= value; + break; + case(50): + BigDecimal50= value; + break; + case(52): + BigDecimal52= value; + break; + case(53): + BigDecimal53= value; + break; + case(54): + BigDecimal54= value; + break; + case(55): + BigDecimal55= value; + break; + case(56): + BigDecimal56= value; + break; + case(57): + BigDecimal57= value; + break; + case(58): + BigDecimal58= value; + break; + case(59): + BigDecimal59= value; + break; + case(60): + BigDecimal60= value; + break; + case(62): + BigDecimal62= value; + break; + case(64): + BigDecimal64= value; + break; + case(65): + BigDecimal65= value; + break; + case(66): + BigDecimal66= value; + break; + case(67): + BigDecimal67= value; + break; + case(68): + BigDecimal68= value; + break; + case(69): + BigDecimal69= value; + break; + case(71): + BigDecimal71= value; + break; + case(72): + BigDecimal72= value; + break; + case(73): + BigDecimal73= value; + break; + case(74): + BigDecimal74= value; + break; + case(75): + BigDecimal75= value; + break; + case(76): + BigDecimal76= value; + break; + case(77): + BigDecimal77= value; + break; + case(78): + BigDecimal78= value; + break; + case(79): + BigDecimal79= value; + break; + case(80): + BigDecimal80= value; + break; + case(81): + BigDecimal81= value; + break; + case(82): + BigDecimal82= value; + break; + case(83): + BigDecimal83= value; + break; + case(84): + BigDecimal84= value; + break; + case(85): + BigDecimal85= value; + break; + case(86): + BigDecimal86= value; + break; + case(88): + BigDecimal88= value; + break; + case(89): + BigDecimal89= value; + break; + case(90): + BigDecimal90= value; + break; + case(91): + BigDecimal91= value; + break; + case(92): + BigDecimal92= value; + break; + case(93): + BigDecimal93= value; + break; + case(94): + BigDecimal94= value; + break; + case(95): + BigDecimal95= value; + break; + case(96): + BigDecimal96= value; + break; + case(98): + BigDecimal98= value; + break; + case(100): + BigDecimal100= value; + break; + case(101): + BigDecimal101= value; + break; + case(102): + BigDecimal102= value; + break; + case(103): + BigDecimal103= value; + break; + case(104): + BigDecimal104= value; + break; + case(105): + BigDecimal105= value; + break; + case(107): + BigDecimal107= value; + break; + case(108): + BigDecimal108= value; + break; + case(109): + BigDecimal109= value; + break; + case(110): + BigDecimal110= value; + break; + case(111): + BigDecimal111= value; + break; + case(112): + BigDecimal112= value; + break; + case(113): + BigDecimal113= value; + break; + case(114): + BigDecimal114= value; + break; + case(115): + BigDecimal115= value; + break; + case(116): + BigDecimal116= value; + break; + case(117): + BigDecimal117= value; + break; + case(118): + BigDecimal118= value; + break; + case(119): + BigDecimal119= value; + break; + case(120): + BigDecimal120= value; + break; + case(121): + BigDecimal121= value; + break; + case(122): + BigDecimal122= value; + break; + case(124): + BigDecimal124= value; + break; + case(125): + BigDecimal125= value; + break; + case(126): + BigDecimal126= value; + break; + case(127): + BigDecimal127= value; + break; + case(128): + BigDecimal128= value; + break; + case(129): + BigDecimal129= value; + break; + case(130): + BigDecimal130= value; + break; + case(131): + BigDecimal131= value; + break; + case(132): + BigDecimal132= value; + break; + case(134): + BigDecimal134= value; + break; + case(136): + BigDecimal136= value; + break; + case(137): + BigDecimal137= value; + break; + case(138): + BigDecimal138= value; + break; + case(139): + BigDecimal139= value; + break; + case(140): + BigDecimal140= value; + break; + case(141): + BigDecimal141= value; + break; + case(143): + BigDecimal143= value; + break; + default: + throw new IndexOutOfBoundsException(); + } + return true; + } + + public static class Oid implements Serializable { + public int identifier; + + public Oid() { + } + + public Oid(String s) { identifier = Integer.parseInt(justTheId(s)); } + + public String toString() { return this.getClass().getName() + ": " + identifier;} + + public int hashCode() { return (int)identifier ; } + + public boolean equals(Object other) { + if (other != null && (other instanceof Oid)) { + Oid k = (Oid)other; + return k.identifier == this.identifier; + } + return false; + } + + protected static String justTheId(String str) { + return str.substring(str.indexOf(':') + 1); + } + + } +} Propchange: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfBigDecimal.java ------------------------------------------------------------------------------ svn:executable = *