Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleClass.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleClass.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleClass.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleClass.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,1089 @@ +/* + * 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; + +public class FieldsOfSimpleClass { + public int identifier; + private SimpleClass SimpleClass0; + private SimpleClass SimpleClass1; + private SimpleClass SimpleClass2; + private SimpleClass SimpleClass3; + private SimpleClass SimpleClass4; + private SimpleClass SimpleClass5; + private SimpleClass SimpleClass6; + private SimpleClass SimpleClass7; + private static SimpleClass SimpleClass8; + private transient SimpleClass SimpleClass9; + private transient SimpleClass SimpleClass10; + private transient SimpleClass SimpleClass11; + private transient SimpleClass SimpleClass12; + private transient SimpleClass SimpleClass13; + private transient SimpleClass SimpleClass14; + private final SimpleClass SimpleClass15 = new SimpleClass(); + private volatile SimpleClass SimpleClass16; + private volatile SimpleClass SimpleClass17; + private volatile SimpleClass SimpleClass18; + private volatile SimpleClass SimpleClass19; + private volatile SimpleClass SimpleClass20; + private volatile SimpleClass SimpleClass21; + private volatile SimpleClass SimpleClass22; + private volatile SimpleClass SimpleClass23; + private static transient SimpleClass SimpleClass24; + private static final SimpleClass SimpleClass25 = new SimpleClass(); + private static volatile SimpleClass SimpleClass26; + private transient final SimpleClass SimpleClass27 = new SimpleClass(); + private transient volatile SimpleClass SimpleClass28; + private transient volatile SimpleClass SimpleClass29; + private transient volatile SimpleClass SimpleClass30; + private transient volatile SimpleClass SimpleClass31; + private transient volatile SimpleClass SimpleClass32; + private transient volatile SimpleClass SimpleClass33; + private static transient final SimpleClass SimpleClass34 = new SimpleClass(); + private static transient volatile SimpleClass SimpleClass35; + public SimpleClass SimpleClass36; + public SimpleClass SimpleClass37; + public SimpleClass SimpleClass38; + public SimpleClass SimpleClass39; + public SimpleClass SimpleClass40; + public SimpleClass SimpleClass41; + public SimpleClass SimpleClass42; + public SimpleClass SimpleClass43; + public static SimpleClass SimpleClass44; + public transient SimpleClass SimpleClass45; + public transient SimpleClass SimpleClass46; + public transient SimpleClass SimpleClass47; + public transient SimpleClass SimpleClass48; + public transient SimpleClass SimpleClass49; + public transient SimpleClass SimpleClass50; + public final SimpleClass SimpleClass51 = new SimpleClass(); + public volatile SimpleClass SimpleClass52; + public volatile SimpleClass SimpleClass53; + public volatile SimpleClass SimpleClass54; + public volatile SimpleClass SimpleClass55; + public volatile SimpleClass SimpleClass56; + public volatile SimpleClass SimpleClass57; + public volatile SimpleClass SimpleClass58; + public volatile SimpleClass SimpleClass59; + public static transient SimpleClass SimpleClass60; + public static final SimpleClass SimpleClass61 = new SimpleClass(); + public static volatile SimpleClass SimpleClass62; + public transient final SimpleClass SimpleClass63 = new SimpleClass(); + public transient volatile SimpleClass SimpleClass64; + public transient volatile SimpleClass SimpleClass65; + public transient volatile SimpleClass SimpleClass66; + public transient volatile SimpleClass SimpleClass67; + public transient volatile SimpleClass SimpleClass68; + public transient volatile SimpleClass SimpleClass69; + public static transient final SimpleClass SimpleClass70 = new SimpleClass(); + public static transient volatile SimpleClass SimpleClass71; + protected SimpleClass SimpleClass72; + protected SimpleClass SimpleClass73; + protected SimpleClass SimpleClass74; + protected SimpleClass SimpleClass75; + protected SimpleClass SimpleClass76; + protected SimpleClass SimpleClass77; + protected SimpleClass SimpleClass78; + protected SimpleClass SimpleClass79; + protected static SimpleClass SimpleClass80; + protected transient SimpleClass SimpleClass81; + protected transient SimpleClass SimpleClass82; + protected transient SimpleClass SimpleClass83; + protected transient SimpleClass SimpleClass84; + protected transient SimpleClass SimpleClass85; + protected transient SimpleClass SimpleClass86; + protected final SimpleClass SimpleClass87 = new SimpleClass(); + protected volatile SimpleClass SimpleClass88; + protected volatile SimpleClass SimpleClass89; + protected volatile SimpleClass SimpleClass90; + protected volatile SimpleClass SimpleClass91; + protected volatile SimpleClass SimpleClass92; + protected volatile SimpleClass SimpleClass93; + protected volatile SimpleClass SimpleClass94; + protected volatile SimpleClass SimpleClass95; + protected static transient SimpleClass SimpleClass96; + protected static final SimpleClass SimpleClass97 = new SimpleClass(); + protected static volatile SimpleClass SimpleClass98; + protected transient final SimpleClass SimpleClass99 = new SimpleClass(); + protected transient volatile SimpleClass SimpleClass100; + protected transient volatile SimpleClass SimpleClass101; + protected transient volatile SimpleClass SimpleClass102; + protected transient volatile SimpleClass SimpleClass103; + protected transient volatile SimpleClass SimpleClass104; + protected transient volatile SimpleClass SimpleClass105; + protected static transient final SimpleClass SimpleClass106 = new SimpleClass(); + protected static transient volatile SimpleClass SimpleClass107; + SimpleClass SimpleClass108; + SimpleClass SimpleClass109; + SimpleClass SimpleClass110; + SimpleClass SimpleClass111; + SimpleClass SimpleClass112; + SimpleClass SimpleClass113; + SimpleClass SimpleClass114; + SimpleClass SimpleClass115; + static SimpleClass SimpleClass116; + transient SimpleClass SimpleClass117; + transient SimpleClass SimpleClass118; + transient SimpleClass SimpleClass119; + transient SimpleClass SimpleClass120; + transient SimpleClass SimpleClass121; + transient SimpleClass SimpleClass122; + final SimpleClass SimpleClass123 = new SimpleClass(); + volatile SimpleClass SimpleClass124; + volatile SimpleClass SimpleClass125; + volatile SimpleClass SimpleClass126; + volatile SimpleClass SimpleClass127; + volatile SimpleClass SimpleClass128; + volatile SimpleClass SimpleClass129; + volatile SimpleClass SimpleClass130; + volatile SimpleClass SimpleClass131; + static transient SimpleClass SimpleClass132; + static final SimpleClass SimpleClass133 = new SimpleClass(); + static volatile SimpleClass SimpleClass134; + transient final SimpleClass SimpleClass135 = new SimpleClass(); + transient volatile SimpleClass SimpleClass136; + transient volatile SimpleClass SimpleClass137; + transient volatile SimpleClass SimpleClass138; + transient volatile SimpleClass SimpleClass139; + transient volatile SimpleClass SimpleClass140; + transient volatile SimpleClass SimpleClass141; + static transient final SimpleClass SimpleClass142 = new SimpleClass(); + static transient volatile SimpleClass SimpleClass143; + +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 SimpleClass SimpleClass0", + "embedded= true private SimpleClass SimpleClass1", + "embedded= false private SimpleClass SimpleClass2", + "persistence-modifier= none private SimpleClass SimpleClass3", + "persistence-modifier= persistent private SimpleClass SimpleClass4", + "persistence-modifier= persistent embedded= true private SimpleClass SimpleClass5", + "persistence-modifier= persistent embedded= false private SimpleClass SimpleClass6", + "persistence-modifier= transactional private SimpleClass SimpleClass7", + "private static SimpleClass SimpleClass8", + "private transient SimpleClass SimpleClass9", + "persistence-modifier= none private transient SimpleClass SimpleClass10", + "persistence-modifier= persistent private transient SimpleClass SimpleClass11", + "persistence-modifier= persistent embedded= true private transient SimpleClass SimpleClass12", + "persistence-modifier= persistent embedded= false private transient SimpleClass SimpleClass13", + "persistence-modifier= transactional private transient SimpleClass SimpleClass14", + "private final SimpleClass SimpleClass15", + "private volatile SimpleClass SimpleClass16", + "embedded= true private volatile SimpleClass SimpleClass17", + "embedded= false private volatile SimpleClass SimpleClass18", + "persistence-modifier= none private volatile SimpleClass SimpleClass19", + "persistence-modifier= persistent private volatile SimpleClass SimpleClass20", + "persistence-modifier= persistent embedded= true private volatile SimpleClass SimpleClass21", + "persistence-modifier= persistent embedded= false private volatile SimpleClass SimpleClass22", + "persistence-modifier= transactional private volatile SimpleClass SimpleClass23", + "private static transient SimpleClass SimpleClass24", + "private static final SimpleClass SimpleClass25", + "private static volatile SimpleClass SimpleClass26", + "private transient final SimpleClass SimpleClass27", + "private transient volatile SimpleClass SimpleClass28", + "persistence-modifier= none private transient volatile SimpleClass SimpleClass29", + "persistence-modifier= persistent private transient volatile SimpleClass SimpleClass30", + "persistence-modifier= persistent embedded= true private transient volatile SimpleClass SimpleClass31", + "persistence-modifier= persistent embedded= false private transient volatile SimpleClass SimpleClass32", + "persistence-modifier= transactional private transient volatile SimpleClass SimpleClass33", + "private static transient final SimpleClass SimpleClass34", + "private static transient volatile SimpleClass SimpleClass35", + "public SimpleClass SimpleClass36", + "embedded= true public SimpleClass SimpleClass37", + "embedded= false public SimpleClass SimpleClass38", + "persistence-modifier= none public SimpleClass SimpleClass39", + "persistence-modifier= persistent public SimpleClass SimpleClass40", + "persistence-modifier= persistent embedded= true public SimpleClass SimpleClass41", + "persistence-modifier= persistent embedded= false public SimpleClass SimpleClass42", + "persistence-modifier= transactional public SimpleClass SimpleClass43", + "public static SimpleClass SimpleClass44", + "public transient SimpleClass SimpleClass45", + "persistence-modifier= none public transient SimpleClass SimpleClass46", + "persistence-modifier= persistent public transient SimpleClass SimpleClass47", + "persistence-modifier= persistent embedded= true public transient SimpleClass SimpleClass48", + "persistence-modifier= persistent embedded= false public transient SimpleClass SimpleClass49", + "persistence-modifier= transactional public transient SimpleClass SimpleClass50", + "public final SimpleClass SimpleClass51", + "public volatile SimpleClass SimpleClass52", + "embedded= true public volatile SimpleClass SimpleClass53", + "embedded= false public volatile SimpleClass SimpleClass54", + "persistence-modifier= none public volatile SimpleClass SimpleClass55", + "persistence-modifier= persistent public volatile SimpleClass SimpleClass56", + "persistence-modifier= persistent embedded= true public volatile SimpleClass SimpleClass57", + "persistence-modifier= persistent embedded= false public volatile SimpleClass SimpleClass58", + "persistence-modifier= transactional public volatile SimpleClass SimpleClass59", + "public static transient SimpleClass SimpleClass60", + "public static final SimpleClass SimpleClass61", + "public static volatile SimpleClass SimpleClass62", + "public transient final SimpleClass SimpleClass63", + "public transient volatile SimpleClass SimpleClass64", + "persistence-modifier= none public transient volatile SimpleClass SimpleClass65", + "persistence-modifier= persistent public transient volatile SimpleClass SimpleClass66", + "persistence-modifier= persistent embedded= true public transient volatile SimpleClass SimpleClass67", + "persistence-modifier= persistent embedded= false public transient volatile SimpleClass SimpleClass68", + "persistence-modifier= transactional public transient volatile SimpleClass SimpleClass69", + "public static transient final SimpleClass SimpleClass70", + "public static transient volatile SimpleClass SimpleClass71", + "protected SimpleClass SimpleClass72", + "embedded= true protected SimpleClass SimpleClass73", + "embedded= false protected SimpleClass SimpleClass74", + "persistence-modifier= none protected SimpleClass SimpleClass75", + "persistence-modifier= persistent protected SimpleClass SimpleClass76", + "persistence-modifier= persistent embedded= true protected SimpleClass SimpleClass77", + "persistence-modifier= persistent embedded= false protected SimpleClass SimpleClass78", + "persistence-modifier= transactional protected SimpleClass SimpleClass79", + "protected static SimpleClass SimpleClass80", + "protected transient SimpleClass SimpleClass81", + "persistence-modifier= none protected transient SimpleClass SimpleClass82", + "persistence-modifier= persistent protected transient SimpleClass SimpleClass83", + "persistence-modifier= persistent embedded= true protected transient SimpleClass SimpleClass84", + "persistence-modifier= persistent embedded= false protected transient SimpleClass SimpleClass85", + "persistence-modifier= transactional protected transient SimpleClass SimpleClass86", + "protected final SimpleClass SimpleClass87", + "protected volatile SimpleClass SimpleClass88", + "embedded= true protected volatile SimpleClass SimpleClass89", + "embedded= false protected volatile SimpleClass SimpleClass90", + "persistence-modifier= none protected volatile SimpleClass SimpleClass91", + "persistence-modifier= persistent protected volatile SimpleClass SimpleClass92", + "persistence-modifier= persistent embedded= true protected volatile SimpleClass SimpleClass93", + "persistence-modifier= persistent embedded= false protected volatile SimpleClass SimpleClass94", + "persistence-modifier= transactional protected volatile SimpleClass SimpleClass95", + "protected static transient SimpleClass SimpleClass96", + "protected static final SimpleClass SimpleClass97", + "protected static volatile SimpleClass SimpleClass98", + "protected transient final SimpleClass SimpleClass99", + "protected transient volatile SimpleClass SimpleClass100", + "persistence-modifier= none protected transient volatile SimpleClass SimpleClass101", + "persistence-modifier= persistent protected transient volatile SimpleClass SimpleClass102", + "persistence-modifier= persistent embedded= true protected transient volatile SimpleClass SimpleClass103", + "persistence-modifier= persistent embedded= false protected transient volatile SimpleClass SimpleClass104", + "persistence-modifier= transactional protected transient volatile SimpleClass SimpleClass105", + "protected static transient final SimpleClass SimpleClass106", + "protected static transient volatile SimpleClass SimpleClass107", + "SimpleClass SimpleClass108", + "embedded= true SimpleClass SimpleClass109", + "embedded= false SimpleClass SimpleClass110", + "persistence-modifier= none SimpleClass SimpleClass111", + "persistence-modifier= persistent SimpleClass SimpleClass112", + "persistence-modifier= persistent embedded= true SimpleClass SimpleClass113", + "persistence-modifier= persistent embedded= false SimpleClass SimpleClass114", + "persistence-modifier= transactional SimpleClass SimpleClass115", + "static SimpleClass SimpleClass116", + "transient SimpleClass SimpleClass117", + "persistence-modifier= none transient SimpleClass SimpleClass118", + "persistence-modifier= persistent transient SimpleClass SimpleClass119", + "persistence-modifier= persistent embedded= true transient SimpleClass SimpleClass120", + "persistence-modifier= persistent embedded= false transient SimpleClass SimpleClass121", + "persistence-modifier= transactional transient SimpleClass SimpleClass122", + "final SimpleClass SimpleClass123", + "volatile SimpleClass SimpleClass124", + "embedded= true volatile SimpleClass SimpleClass125", + "embedded= false volatile SimpleClass SimpleClass126", + "persistence-modifier= none volatile SimpleClass SimpleClass127", + "persistence-modifier= persistent volatile SimpleClass SimpleClass128", + "persistence-modifier= persistent embedded= true volatile SimpleClass SimpleClass129", + "persistence-modifier= persistent embedded= false volatile SimpleClass SimpleClass130", + "persistence-modifier= transactional volatile SimpleClass SimpleClass131", + "static transient SimpleClass SimpleClass132", + "static final SimpleClass SimpleClass133", + "static volatile SimpleClass SimpleClass134", + "transient final SimpleClass SimpleClass135", + "transient volatile SimpleClass SimpleClass136", + "persistence-modifier= none transient volatile SimpleClass SimpleClass137", + "persistence-modifier= persistent transient volatile SimpleClass SimpleClass138", + "persistence-modifier= persistent embedded= true transient volatile SimpleClass SimpleClass139", + "persistence-modifier= persistent embedded= false transient volatile SimpleClass SimpleClass140", + "persistence-modifier= transactional transient volatile SimpleClass SimpleClass141", + "static transient final SimpleClass SimpleClass142", + "static transient volatile SimpleClass SimpleClass143" + }; + public int getLength() + { + return fieldSpecs.length; + } + public SimpleClass get(int index) + { + switch (index) + { + case(0): + return SimpleClass0; + case(1): + return SimpleClass1; + case(2): + return SimpleClass2; + case(3): + return SimpleClass3; + case(4): + return SimpleClass4; + case(5): + return SimpleClass5; + case(6): + return SimpleClass6; + case(7): + return SimpleClass7; + case(8): + return SimpleClass8; + case(9): + return SimpleClass9; + case(10): + return SimpleClass10; + case(11): + return SimpleClass11; + case(12): + return SimpleClass12; + case(13): + return SimpleClass13; + case(14): + return SimpleClass14; + case(15): + return SimpleClass15; + case(16): + return SimpleClass16; + case(17): + return SimpleClass17; + case(18): + return SimpleClass18; + case(19): + return SimpleClass19; + case(20): + return SimpleClass20; + case(21): + return SimpleClass21; + case(22): + return SimpleClass22; + case(23): + return SimpleClass23; + case(24): + return SimpleClass24; + case(25): + return SimpleClass25; + case(26): + return SimpleClass26; + case(27): + return SimpleClass27; + case(28): + return SimpleClass28; + case(29): + return SimpleClass29; + case(30): + return SimpleClass30; + case(31): + return SimpleClass31; + case(32): + return SimpleClass32; + case(33): + return SimpleClass33; + case(34): + return SimpleClass34; + case(35): + return SimpleClass35; + case(36): + return SimpleClass36; + case(37): + return SimpleClass37; + case(38): + return SimpleClass38; + case(39): + return SimpleClass39; + case(40): + return SimpleClass40; + case(41): + return SimpleClass41; + case(42): + return SimpleClass42; + case(43): + return SimpleClass43; + case(44): + return SimpleClass44; + case(45): + return SimpleClass45; + case(46): + return SimpleClass46; + case(47): + return SimpleClass47; + case(48): + return SimpleClass48; + case(49): + return SimpleClass49; + case(50): + return SimpleClass50; + case(51): + return SimpleClass51; + case(52): + return SimpleClass52; + case(53): + return SimpleClass53; + case(54): + return SimpleClass54; + case(55): + return SimpleClass55; + case(56): + return SimpleClass56; + case(57): + return SimpleClass57; + case(58): + return SimpleClass58; + case(59): + return SimpleClass59; + case(60): + return SimpleClass60; + case(61): + return SimpleClass61; + case(62): + return SimpleClass62; + case(63): + return SimpleClass63; + case(64): + return SimpleClass64; + case(65): + return SimpleClass65; + case(66): + return SimpleClass66; + case(67): + return SimpleClass67; + case(68): + return SimpleClass68; + case(69): + return SimpleClass69; + case(70): + return SimpleClass70; + case(71): + return SimpleClass71; + case(72): + return SimpleClass72; + case(73): + return SimpleClass73; + case(74): + return SimpleClass74; + case(75): + return SimpleClass75; + case(76): + return SimpleClass76; + case(77): + return SimpleClass77; + case(78): + return SimpleClass78; + case(79): + return SimpleClass79; + case(80): + return SimpleClass80; + case(81): + return SimpleClass81; + case(82): + return SimpleClass82; + case(83): + return SimpleClass83; + case(84): + return SimpleClass84; + case(85): + return SimpleClass85; + case(86): + return SimpleClass86; + case(87): + return SimpleClass87; + case(88): + return SimpleClass88; + case(89): + return SimpleClass89; + case(90): + return SimpleClass90; + case(91): + return SimpleClass91; + case(92): + return SimpleClass92; + case(93): + return SimpleClass93; + case(94): + return SimpleClass94; + case(95): + return SimpleClass95; + case(96): + return SimpleClass96; + case(97): + return SimpleClass97; + case(98): + return SimpleClass98; + case(99): + return SimpleClass99; + case(100): + return SimpleClass100; + case(101): + return SimpleClass101; + case(102): + return SimpleClass102; + case(103): + return SimpleClass103; + case(104): + return SimpleClass104; + case(105): + return SimpleClass105; + case(106): + return SimpleClass106; + case(107): + return SimpleClass107; + case(108): + return SimpleClass108; + case(109): + return SimpleClass109; + case(110): + return SimpleClass110; + case(111): + return SimpleClass111; + case(112): + return SimpleClass112; + case(113): + return SimpleClass113; + case(114): + return SimpleClass114; + case(115): + return SimpleClass115; + case(116): + return SimpleClass116; + case(117): + return SimpleClass117; + case(118): + return SimpleClass118; + case(119): + return SimpleClass119; + case(120): + return SimpleClass120; + case(121): + return SimpleClass121; + case(122): + return SimpleClass122; + case(123): + return SimpleClass123; + case(124): + return SimpleClass124; + case(125): + return SimpleClass125; + case(126): + return SimpleClass126; + case(127): + return SimpleClass127; + case(128): + return SimpleClass128; + case(129): + return SimpleClass129; + case(130): + return SimpleClass130; + case(131): + return SimpleClass131; + case(132): + return SimpleClass132; + case(133): + return SimpleClass133; + case(134): + return SimpleClass134; + case(135): + return SimpleClass135; + case(136): + return SimpleClass136; + case(137): + return SimpleClass137; + case(138): + return SimpleClass138; + case(139): + return SimpleClass139; + case(140): + return SimpleClass140; + case(141): + return SimpleClass141; + case(142): + return SimpleClass142; + case(143): + return SimpleClass143; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,SimpleClass value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + SimpleClass0= value; + break; + case(1): + SimpleClass1= value; + break; + case(2): + SimpleClass2= value; + break; + case(3): + SimpleClass3= value; + break; + case(4): + SimpleClass4= value; + break; + case(5): + SimpleClass5= value; + break; + case(6): + SimpleClass6= value; + break; + case(7): + SimpleClass7= value; + break; + case(8): + SimpleClass8= value; + break; + case(9): + SimpleClass9= value; + break; + case(10): + SimpleClass10= value; + break; + case(11): + SimpleClass11= value; + break; + case(12): + SimpleClass12= value; + break; + case(13): + SimpleClass13= value; + break; + case(14): + SimpleClass14= value; + break; + case(16): + SimpleClass16= value; + break; + case(17): + SimpleClass17= value; + break; + case(18): + SimpleClass18= value; + break; + case(19): + SimpleClass19= value; + break; + case(20): + SimpleClass20= value; + break; + case(21): + SimpleClass21= value; + break; + case(22): + SimpleClass22= value; + break; + case(23): + SimpleClass23= value; + break; + case(24): + SimpleClass24= value; + break; + case(26): + SimpleClass26= value; + break; + case(28): + SimpleClass28= value; + break; + case(29): + SimpleClass29= value; + break; + case(30): + SimpleClass30= value; + break; + case(31): + SimpleClass31= value; + break; + case(32): + SimpleClass32= value; + break; + case(33): + SimpleClass33= value; + break; + case(35): + SimpleClass35= value; + break; + case(36): + SimpleClass36= value; + break; + case(37): + SimpleClass37= value; + break; + case(38): + SimpleClass38= value; + break; + case(39): + SimpleClass39= value; + break; + case(40): + SimpleClass40= value; + break; + case(41): + SimpleClass41= value; + break; + case(42): + SimpleClass42= value; + break; + case(43): + SimpleClass43= value; + break; + case(44): + SimpleClass44= value; + break; + case(45): + SimpleClass45= value; + break; + case(46): + SimpleClass46= value; + break; + case(47): + SimpleClass47= value; + break; + case(48): + SimpleClass48= value; + break; + case(49): + SimpleClass49= value; + break; + case(50): + SimpleClass50= value; + break; + case(52): + SimpleClass52= value; + break; + case(53): + SimpleClass53= value; + break; + case(54): + SimpleClass54= value; + break; + case(55): + SimpleClass55= value; + break; + case(56): + SimpleClass56= value; + break; + case(57): + SimpleClass57= value; + break; + case(58): + SimpleClass58= value; + break; + case(59): + SimpleClass59= value; + break; + case(60): + SimpleClass60= value; + break; + case(62): + SimpleClass62= value; + break; + case(64): + SimpleClass64= value; + break; + case(65): + SimpleClass65= value; + break; + case(66): + SimpleClass66= value; + break; + case(67): + SimpleClass67= value; + break; + case(68): + SimpleClass68= value; + break; + case(69): + SimpleClass69= value; + break; + case(71): + SimpleClass71= value; + break; + case(72): + SimpleClass72= value; + break; + case(73): + SimpleClass73= value; + break; + case(74): + SimpleClass74= value; + break; + case(75): + SimpleClass75= value; + break; + case(76): + SimpleClass76= value; + break; + case(77): + SimpleClass77= value; + break; + case(78): + SimpleClass78= value; + break; + case(79): + SimpleClass79= value; + break; + case(80): + SimpleClass80= value; + break; + case(81): + SimpleClass81= value; + break; + case(82): + SimpleClass82= value; + break; + case(83): + SimpleClass83= value; + break; + case(84): + SimpleClass84= value; + break; + case(85): + SimpleClass85= value; + break; + case(86): + SimpleClass86= value; + break; + case(88): + SimpleClass88= value; + break; + case(89): + SimpleClass89= value; + break; + case(90): + SimpleClass90= value; + break; + case(91): + SimpleClass91= value; + break; + case(92): + SimpleClass92= value; + break; + case(93): + SimpleClass93= value; + break; + case(94): + SimpleClass94= value; + break; + case(95): + SimpleClass95= value; + break; + case(96): + SimpleClass96= value; + break; + case(98): + SimpleClass98= value; + break; + case(100): + SimpleClass100= value; + break; + case(101): + SimpleClass101= value; + break; + case(102): + SimpleClass102= value; + break; + case(103): + SimpleClass103= value; + break; + case(104): + SimpleClass104= value; + break; + case(105): + SimpleClass105= value; + break; + case(107): + SimpleClass107= value; + break; + case(108): + SimpleClass108= value; + break; + case(109): + SimpleClass109= value; + break; + case(110): + SimpleClass110= value; + break; + case(111): + SimpleClass111= value; + break; + case(112): + SimpleClass112= value; + break; + case(113): + SimpleClass113= value; + break; + case(114): + SimpleClass114= value; + break; + case(115): + SimpleClass115= value; + break; + case(116): + SimpleClass116= value; + break; + case(117): + SimpleClass117= value; + break; + case(118): + SimpleClass118= value; + break; + case(119): + SimpleClass119= value; + break; + case(120): + SimpleClass120= value; + break; + case(121): + SimpleClass121= value; + break; + case(122): + SimpleClass122= value; + break; + case(124): + SimpleClass124= value; + break; + case(125): + SimpleClass125= value; + break; + case(126): + SimpleClass126= value; + break; + case(127): + SimpleClass127= value; + break; + case(128): + SimpleClass128= value; + break; + case(129): + SimpleClass129= value; + break; + case(130): + SimpleClass130= value; + break; + case(131): + SimpleClass131= value; + break; + case(132): + SimpleClass132= value; + break; + case(134): + SimpleClass134= value; + break; + case(136): + SimpleClass136= value; + break; + case(137): + SimpleClass137= value; + break; + case(138): + SimpleClass138= value; + break; + case(139): + SimpleClass139= value; + break; + case(140): + SimpleClass140= value; + break; + case(141): + SimpleClass141= value; + break; + case(143): + SimpleClass143= 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/FieldsOfSimpleClass.java ------------------------------------------------------------------------------ svn:executable = * Added: incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleInterface.java URL: http://svn.apache.org/viewcvs/incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleInterface.java?view=auto&rev=160090 ============================================================================== --- incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleInterface.java (added) +++ incubator/jdo/trunk/tck20/test/java/org/apache/jdo/tck/pc/fieldtypes/FieldsOfSimpleInterface.java Mon Apr 4 12:41:23 2005 @@ -0,0 +1,1089 @@ +/* + * 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; + +public class FieldsOfSimpleInterface { + public int identifier; + private SimpleInterface SimpleInterface0; + private SimpleInterface SimpleInterface1; + private SimpleInterface SimpleInterface2; + private SimpleInterface SimpleInterface3; + private SimpleInterface SimpleInterface4; + private SimpleInterface SimpleInterface5; + private SimpleInterface SimpleInterface6; + private SimpleInterface SimpleInterface7; + private static SimpleInterface SimpleInterface8; + private transient SimpleInterface SimpleInterface9; + private transient SimpleInterface SimpleInterface10; + private transient SimpleInterface SimpleInterface11; + private transient SimpleInterface SimpleInterface12; + private transient SimpleInterface SimpleInterface13; + private transient SimpleInterface SimpleInterface14; + private final SimpleInterface SimpleInterface15 = new SimpleClass(); + private volatile SimpleInterface SimpleInterface16; + private volatile SimpleInterface SimpleInterface17; + private volatile SimpleInterface SimpleInterface18; + private volatile SimpleInterface SimpleInterface19; + private volatile SimpleInterface SimpleInterface20; + private volatile SimpleInterface SimpleInterface21; + private volatile SimpleInterface SimpleInterface22; + private volatile SimpleInterface SimpleInterface23; + private static transient SimpleInterface SimpleInterface24; + private static final SimpleInterface SimpleInterface25 = new SimpleClass(); + private static volatile SimpleInterface SimpleInterface26; + private transient final SimpleInterface SimpleInterface27 = new SimpleClass(); + private transient volatile SimpleInterface SimpleInterface28; + private transient volatile SimpleInterface SimpleInterface29; + private transient volatile SimpleInterface SimpleInterface30; + private transient volatile SimpleInterface SimpleInterface31; + private transient volatile SimpleInterface SimpleInterface32; + private transient volatile SimpleInterface SimpleInterface33; + private static transient final SimpleInterface SimpleInterface34 = new SimpleClass(); + private static transient volatile SimpleInterface SimpleInterface35; + public SimpleInterface SimpleInterface36; + public SimpleInterface SimpleInterface37; + public SimpleInterface SimpleInterface38; + public SimpleInterface SimpleInterface39; + public SimpleInterface SimpleInterface40; + public SimpleInterface SimpleInterface41; + public SimpleInterface SimpleInterface42; + public SimpleInterface SimpleInterface43; + public static SimpleInterface SimpleInterface44; + public transient SimpleInterface SimpleInterface45; + public transient SimpleInterface SimpleInterface46; + public transient SimpleInterface SimpleInterface47; + public transient SimpleInterface SimpleInterface48; + public transient SimpleInterface SimpleInterface49; + public transient SimpleInterface SimpleInterface50; + public final SimpleInterface SimpleInterface51 = new SimpleClass(); + public volatile SimpleInterface SimpleInterface52; + public volatile SimpleInterface SimpleInterface53; + public volatile SimpleInterface SimpleInterface54; + public volatile SimpleInterface SimpleInterface55; + public volatile SimpleInterface SimpleInterface56; + public volatile SimpleInterface SimpleInterface57; + public volatile SimpleInterface SimpleInterface58; + public volatile SimpleInterface SimpleInterface59; + public static transient SimpleInterface SimpleInterface60; + public static final SimpleInterface SimpleInterface61 = new SimpleClass(); + public static volatile SimpleInterface SimpleInterface62; + public transient final SimpleInterface SimpleInterface63 = new SimpleClass(); + public transient volatile SimpleInterface SimpleInterface64; + public transient volatile SimpleInterface SimpleInterface65; + public transient volatile SimpleInterface SimpleInterface66; + public transient volatile SimpleInterface SimpleInterface67; + public transient volatile SimpleInterface SimpleInterface68; + public transient volatile SimpleInterface SimpleInterface69; + public static transient final SimpleInterface SimpleInterface70 = new SimpleClass(); + public static transient volatile SimpleInterface SimpleInterface71; + protected SimpleInterface SimpleInterface72; + protected SimpleInterface SimpleInterface73; + protected SimpleInterface SimpleInterface74; + protected SimpleInterface SimpleInterface75; + protected SimpleInterface SimpleInterface76; + protected SimpleInterface SimpleInterface77; + protected SimpleInterface SimpleInterface78; + protected SimpleInterface SimpleInterface79; + protected static SimpleInterface SimpleInterface80; + protected transient SimpleInterface SimpleInterface81; + protected transient SimpleInterface SimpleInterface82; + protected transient SimpleInterface SimpleInterface83; + protected transient SimpleInterface SimpleInterface84; + protected transient SimpleInterface SimpleInterface85; + protected transient SimpleInterface SimpleInterface86; + protected final SimpleInterface SimpleInterface87 = new SimpleClass(); + protected volatile SimpleInterface SimpleInterface88; + protected volatile SimpleInterface SimpleInterface89; + protected volatile SimpleInterface SimpleInterface90; + protected volatile SimpleInterface SimpleInterface91; + protected volatile SimpleInterface SimpleInterface92; + protected volatile SimpleInterface SimpleInterface93; + protected volatile SimpleInterface SimpleInterface94; + protected volatile SimpleInterface SimpleInterface95; + protected static transient SimpleInterface SimpleInterface96; + protected static final SimpleInterface SimpleInterface97 = new SimpleClass(); + protected static volatile SimpleInterface SimpleInterface98; + protected transient final SimpleInterface SimpleInterface99 = new SimpleClass(); + protected transient volatile SimpleInterface SimpleInterface100; + protected transient volatile SimpleInterface SimpleInterface101; + protected transient volatile SimpleInterface SimpleInterface102; + protected transient volatile SimpleInterface SimpleInterface103; + protected transient volatile SimpleInterface SimpleInterface104; + protected transient volatile SimpleInterface SimpleInterface105; + protected static transient final SimpleInterface SimpleInterface106 = new SimpleClass(); + protected static transient volatile SimpleInterface SimpleInterface107; + SimpleInterface SimpleInterface108; + SimpleInterface SimpleInterface109; + SimpleInterface SimpleInterface110; + SimpleInterface SimpleInterface111; + SimpleInterface SimpleInterface112; + SimpleInterface SimpleInterface113; + SimpleInterface SimpleInterface114; + SimpleInterface SimpleInterface115; + static SimpleInterface SimpleInterface116; + transient SimpleInterface SimpleInterface117; + transient SimpleInterface SimpleInterface118; + transient SimpleInterface SimpleInterface119; + transient SimpleInterface SimpleInterface120; + transient SimpleInterface SimpleInterface121; + transient SimpleInterface SimpleInterface122; + final SimpleInterface SimpleInterface123 = new SimpleClass(); + volatile SimpleInterface SimpleInterface124; + volatile SimpleInterface SimpleInterface125; + volatile SimpleInterface SimpleInterface126; + volatile SimpleInterface SimpleInterface127; + volatile SimpleInterface SimpleInterface128; + volatile SimpleInterface SimpleInterface129; + volatile SimpleInterface SimpleInterface130; + volatile SimpleInterface SimpleInterface131; + static transient SimpleInterface SimpleInterface132; + static final SimpleInterface SimpleInterface133 = new SimpleClass(); + static volatile SimpleInterface SimpleInterface134; + transient final SimpleInterface SimpleInterface135 = new SimpleClass(); + transient volatile SimpleInterface SimpleInterface136; + transient volatile SimpleInterface SimpleInterface137; + transient volatile SimpleInterface SimpleInterface138; + transient volatile SimpleInterface SimpleInterface139; + transient volatile SimpleInterface SimpleInterface140; + transient volatile SimpleInterface SimpleInterface141; + static transient final SimpleInterface SimpleInterface142 = new SimpleClass(); + static transient volatile SimpleInterface SimpleInterface143; + +public static final boolean [] isPersistent = { +false,true,true,false,true,true,true,false,false,false, +false,true,true,true,false,false,false,true,true,false, +true,true,true,false,false,false,false,false,false,false, +true,true,true,false,false,false,false,true,true,false, +true,true,true,false,false,false,false,true,true,true, +false,false,false,true,true,false,true,true,true,false, +false,false,false,false,false,false,true,true,true,false, +false,false,false,true,true,false,true,true,true,false, +false,false,false,true,true,true,false,false,false,true, +true,false,true,true,true,false,false,false,false,false, +false,false,true,true,true,false,false,false,false,true, +true,false,true,true,true,false,false,false,false,true, +true,true,false,false,false,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 SimpleInterface SimpleInterface0", + "embedded= true private SimpleInterface SimpleInterface1", + "embedded= false private SimpleInterface SimpleInterface2", + "persistence-modifier= none private SimpleInterface SimpleInterface3", + "persistence-modifier= persistent private SimpleInterface SimpleInterface4", + "persistence-modifier= persistent embedded= true private SimpleInterface SimpleInterface5", + "persistence-modifier= persistent embedded= false private SimpleInterface SimpleInterface6", + "persistence-modifier= transactional private SimpleInterface SimpleInterface7", + "private static SimpleInterface SimpleInterface8", + "private transient SimpleInterface SimpleInterface9", + "persistence-modifier= none private transient SimpleInterface SimpleInterface10", + "persistence-modifier= persistent private transient SimpleInterface SimpleInterface11", + "persistence-modifier= persistent embedded= true private transient SimpleInterface SimpleInterface12", + "persistence-modifier= persistent embedded= false private transient SimpleInterface SimpleInterface13", + "persistence-modifier= transactional private transient SimpleInterface SimpleInterface14", + "private final SimpleInterface SimpleInterface15", + "private volatile SimpleInterface SimpleInterface16", + "embedded= true private volatile SimpleInterface SimpleInterface17", + "embedded= false private volatile SimpleInterface SimpleInterface18", + "persistence-modifier= none private volatile SimpleInterface SimpleInterface19", + "persistence-modifier= persistent private volatile SimpleInterface SimpleInterface20", + "persistence-modifier= persistent embedded= true private volatile SimpleInterface SimpleInterface21", + "persistence-modifier= persistent embedded= false private volatile SimpleInterface SimpleInterface22", + "persistence-modifier= transactional private volatile SimpleInterface SimpleInterface23", + "private static transient SimpleInterface SimpleInterface24", + "private static final SimpleInterface SimpleInterface25", + "private static volatile SimpleInterface SimpleInterface26", + "private transient final SimpleInterface SimpleInterface27", + "private transient volatile SimpleInterface SimpleInterface28", + "persistence-modifier= none private transient volatile SimpleInterface SimpleInterface29", + "persistence-modifier= persistent private transient volatile SimpleInterface SimpleInterface30", + "persistence-modifier= persistent embedded= true private transient volatile SimpleInterface SimpleInterface31", + "persistence-modifier= persistent embedded= false private transient volatile SimpleInterface SimpleInterface32", + "persistence-modifier= transactional private transient volatile SimpleInterface SimpleInterface33", + "private static transient final SimpleInterface SimpleInterface34", + "private static transient volatile SimpleInterface SimpleInterface35", + "public SimpleInterface SimpleInterface36", + "embedded= true public SimpleInterface SimpleInterface37", + "embedded= false public SimpleInterface SimpleInterface38", + "persistence-modifier= none public SimpleInterface SimpleInterface39", + "persistence-modifier= persistent public SimpleInterface SimpleInterface40", + "persistence-modifier= persistent embedded= true public SimpleInterface SimpleInterface41", + "persistence-modifier= persistent embedded= false public SimpleInterface SimpleInterface42", + "persistence-modifier= transactional public SimpleInterface SimpleInterface43", + "public static SimpleInterface SimpleInterface44", + "public transient SimpleInterface SimpleInterface45", + "persistence-modifier= none public transient SimpleInterface SimpleInterface46", + "persistence-modifier= persistent public transient SimpleInterface SimpleInterface47", + "persistence-modifier= persistent embedded= true public transient SimpleInterface SimpleInterface48", + "persistence-modifier= persistent embedded= false public transient SimpleInterface SimpleInterface49", + "persistence-modifier= transactional public transient SimpleInterface SimpleInterface50", + "public final SimpleInterface SimpleInterface51", + "public volatile SimpleInterface SimpleInterface52", + "embedded= true public volatile SimpleInterface SimpleInterface53", + "embedded= false public volatile SimpleInterface SimpleInterface54", + "persistence-modifier= none public volatile SimpleInterface SimpleInterface55", + "persistence-modifier= persistent public volatile SimpleInterface SimpleInterface56", + "persistence-modifier= persistent embedded= true public volatile SimpleInterface SimpleInterface57", + "persistence-modifier= persistent embedded= false public volatile SimpleInterface SimpleInterface58", + "persistence-modifier= transactional public volatile SimpleInterface SimpleInterface59", + "public static transient SimpleInterface SimpleInterface60", + "public static final SimpleInterface SimpleInterface61", + "public static volatile SimpleInterface SimpleInterface62", + "public transient final SimpleInterface SimpleInterface63", + "public transient volatile SimpleInterface SimpleInterface64", + "persistence-modifier= none public transient volatile SimpleInterface SimpleInterface65", + "persistence-modifier= persistent public transient volatile SimpleInterface SimpleInterface66", + "persistence-modifier= persistent embedded= true public transient volatile SimpleInterface SimpleInterface67", + "persistence-modifier= persistent embedded= false public transient volatile SimpleInterface SimpleInterface68", + "persistence-modifier= transactional public transient volatile SimpleInterface SimpleInterface69", + "public static transient final SimpleInterface SimpleInterface70", + "public static transient volatile SimpleInterface SimpleInterface71", + "protected SimpleInterface SimpleInterface72", + "embedded= true protected SimpleInterface SimpleInterface73", + "embedded= false protected SimpleInterface SimpleInterface74", + "persistence-modifier= none protected SimpleInterface SimpleInterface75", + "persistence-modifier= persistent protected SimpleInterface SimpleInterface76", + "persistence-modifier= persistent embedded= true protected SimpleInterface SimpleInterface77", + "persistence-modifier= persistent embedded= false protected SimpleInterface SimpleInterface78", + "persistence-modifier= transactional protected SimpleInterface SimpleInterface79", + "protected static SimpleInterface SimpleInterface80", + "protected transient SimpleInterface SimpleInterface81", + "persistence-modifier= none protected transient SimpleInterface SimpleInterface82", + "persistence-modifier= persistent protected transient SimpleInterface SimpleInterface83", + "persistence-modifier= persistent embedded= true protected transient SimpleInterface SimpleInterface84", + "persistence-modifier= persistent embedded= false protected transient SimpleInterface SimpleInterface85", + "persistence-modifier= transactional protected transient SimpleInterface SimpleInterface86", + "protected final SimpleInterface SimpleInterface87", + "protected volatile SimpleInterface SimpleInterface88", + "embedded= true protected volatile SimpleInterface SimpleInterface89", + "embedded= false protected volatile SimpleInterface SimpleInterface90", + "persistence-modifier= none protected volatile SimpleInterface SimpleInterface91", + "persistence-modifier= persistent protected volatile SimpleInterface SimpleInterface92", + "persistence-modifier= persistent embedded= true protected volatile SimpleInterface SimpleInterface93", + "persistence-modifier= persistent embedded= false protected volatile SimpleInterface SimpleInterface94", + "persistence-modifier= transactional protected volatile SimpleInterface SimpleInterface95", + "protected static transient SimpleInterface SimpleInterface96", + "protected static final SimpleInterface SimpleInterface97", + "protected static volatile SimpleInterface SimpleInterface98", + "protected transient final SimpleInterface SimpleInterface99", + "protected transient volatile SimpleInterface SimpleInterface100", + "persistence-modifier= none protected transient volatile SimpleInterface SimpleInterface101", + "persistence-modifier= persistent protected transient volatile SimpleInterface SimpleInterface102", + "persistence-modifier= persistent embedded= true protected transient volatile SimpleInterface SimpleInterface103", + "persistence-modifier= persistent embedded= false protected transient volatile SimpleInterface SimpleInterface104", + "persistence-modifier= transactional protected transient volatile SimpleInterface SimpleInterface105", + "protected static transient final SimpleInterface SimpleInterface106", + "protected static transient volatile SimpleInterface SimpleInterface107", + "SimpleInterface SimpleInterface108", + "embedded= true SimpleInterface SimpleInterface109", + "embedded= false SimpleInterface SimpleInterface110", + "persistence-modifier= none SimpleInterface SimpleInterface111", + "persistence-modifier= persistent SimpleInterface SimpleInterface112", + "persistence-modifier= persistent embedded= true SimpleInterface SimpleInterface113", + "persistence-modifier= persistent embedded= false SimpleInterface SimpleInterface114", + "persistence-modifier= transactional SimpleInterface SimpleInterface115", + "static SimpleInterface SimpleInterface116", + "transient SimpleInterface SimpleInterface117", + "persistence-modifier= none transient SimpleInterface SimpleInterface118", + "persistence-modifier= persistent transient SimpleInterface SimpleInterface119", + "persistence-modifier= persistent embedded= true transient SimpleInterface SimpleInterface120", + "persistence-modifier= persistent embedded= false transient SimpleInterface SimpleInterface121", + "persistence-modifier= transactional transient SimpleInterface SimpleInterface122", + "final SimpleInterface SimpleInterface123", + "volatile SimpleInterface SimpleInterface124", + "embedded= true volatile SimpleInterface SimpleInterface125", + "embedded= false volatile SimpleInterface SimpleInterface126", + "persistence-modifier= none volatile SimpleInterface SimpleInterface127", + "persistence-modifier= persistent volatile SimpleInterface SimpleInterface128", + "persistence-modifier= persistent embedded= true volatile SimpleInterface SimpleInterface129", + "persistence-modifier= persistent embedded= false volatile SimpleInterface SimpleInterface130", + "persistence-modifier= transactional volatile SimpleInterface SimpleInterface131", + "static transient SimpleInterface SimpleInterface132", + "static final SimpleInterface SimpleInterface133", + "static volatile SimpleInterface SimpleInterface134", + "transient final SimpleInterface SimpleInterface135", + "transient volatile SimpleInterface SimpleInterface136", + "persistence-modifier= none transient volatile SimpleInterface SimpleInterface137", + "persistence-modifier= persistent transient volatile SimpleInterface SimpleInterface138", + "persistence-modifier= persistent embedded= true transient volatile SimpleInterface SimpleInterface139", + "persistence-modifier= persistent embedded= false transient volatile SimpleInterface SimpleInterface140", + "persistence-modifier= transactional transient volatile SimpleInterface SimpleInterface141", + "static transient final SimpleInterface SimpleInterface142", + "static transient volatile SimpleInterface SimpleInterface143" + }; + public int getLength() + { + return fieldSpecs.length; + } + public SimpleInterface get(int index) + { + switch (index) + { + case(0): + return SimpleInterface0; + case(1): + return SimpleInterface1; + case(2): + return SimpleInterface2; + case(3): + return SimpleInterface3; + case(4): + return SimpleInterface4; + case(5): + return SimpleInterface5; + case(6): + return SimpleInterface6; + case(7): + return SimpleInterface7; + case(8): + return SimpleInterface8; + case(9): + return SimpleInterface9; + case(10): + return SimpleInterface10; + case(11): + return SimpleInterface11; + case(12): + return SimpleInterface12; + case(13): + return SimpleInterface13; + case(14): + return SimpleInterface14; + case(15): + return SimpleInterface15; + case(16): + return SimpleInterface16; + case(17): + return SimpleInterface17; + case(18): + return SimpleInterface18; + case(19): + return SimpleInterface19; + case(20): + return SimpleInterface20; + case(21): + return SimpleInterface21; + case(22): + return SimpleInterface22; + case(23): + return SimpleInterface23; + case(24): + return SimpleInterface24; + case(25): + return SimpleInterface25; + case(26): + return SimpleInterface26; + case(27): + return SimpleInterface27; + case(28): + return SimpleInterface28; + case(29): + return SimpleInterface29; + case(30): + return SimpleInterface30; + case(31): + return SimpleInterface31; + case(32): + return SimpleInterface32; + case(33): + return SimpleInterface33; + case(34): + return SimpleInterface34; + case(35): + return SimpleInterface35; + case(36): + return SimpleInterface36; + case(37): + return SimpleInterface37; + case(38): + return SimpleInterface38; + case(39): + return SimpleInterface39; + case(40): + return SimpleInterface40; + case(41): + return SimpleInterface41; + case(42): + return SimpleInterface42; + case(43): + return SimpleInterface43; + case(44): + return SimpleInterface44; + case(45): + return SimpleInterface45; + case(46): + return SimpleInterface46; + case(47): + return SimpleInterface47; + case(48): + return SimpleInterface48; + case(49): + return SimpleInterface49; + case(50): + return SimpleInterface50; + case(51): + return SimpleInterface51; + case(52): + return SimpleInterface52; + case(53): + return SimpleInterface53; + case(54): + return SimpleInterface54; + case(55): + return SimpleInterface55; + case(56): + return SimpleInterface56; + case(57): + return SimpleInterface57; + case(58): + return SimpleInterface58; + case(59): + return SimpleInterface59; + case(60): + return SimpleInterface60; + case(61): + return SimpleInterface61; + case(62): + return SimpleInterface62; + case(63): + return SimpleInterface63; + case(64): + return SimpleInterface64; + case(65): + return SimpleInterface65; + case(66): + return SimpleInterface66; + case(67): + return SimpleInterface67; + case(68): + return SimpleInterface68; + case(69): + return SimpleInterface69; + case(70): + return SimpleInterface70; + case(71): + return SimpleInterface71; + case(72): + return SimpleInterface72; + case(73): + return SimpleInterface73; + case(74): + return SimpleInterface74; + case(75): + return SimpleInterface75; + case(76): + return SimpleInterface76; + case(77): + return SimpleInterface77; + case(78): + return SimpleInterface78; + case(79): + return SimpleInterface79; + case(80): + return SimpleInterface80; + case(81): + return SimpleInterface81; + case(82): + return SimpleInterface82; + case(83): + return SimpleInterface83; + case(84): + return SimpleInterface84; + case(85): + return SimpleInterface85; + case(86): + return SimpleInterface86; + case(87): + return SimpleInterface87; + case(88): + return SimpleInterface88; + case(89): + return SimpleInterface89; + case(90): + return SimpleInterface90; + case(91): + return SimpleInterface91; + case(92): + return SimpleInterface92; + case(93): + return SimpleInterface93; + case(94): + return SimpleInterface94; + case(95): + return SimpleInterface95; + case(96): + return SimpleInterface96; + case(97): + return SimpleInterface97; + case(98): + return SimpleInterface98; + case(99): + return SimpleInterface99; + case(100): + return SimpleInterface100; + case(101): + return SimpleInterface101; + case(102): + return SimpleInterface102; + case(103): + return SimpleInterface103; + case(104): + return SimpleInterface104; + case(105): + return SimpleInterface105; + case(106): + return SimpleInterface106; + case(107): + return SimpleInterface107; + case(108): + return SimpleInterface108; + case(109): + return SimpleInterface109; + case(110): + return SimpleInterface110; + case(111): + return SimpleInterface111; + case(112): + return SimpleInterface112; + case(113): + return SimpleInterface113; + case(114): + return SimpleInterface114; + case(115): + return SimpleInterface115; + case(116): + return SimpleInterface116; + case(117): + return SimpleInterface117; + case(118): + return SimpleInterface118; + case(119): + return SimpleInterface119; + case(120): + return SimpleInterface120; + case(121): + return SimpleInterface121; + case(122): + return SimpleInterface122; + case(123): + return SimpleInterface123; + case(124): + return SimpleInterface124; + case(125): + return SimpleInterface125; + case(126): + return SimpleInterface126; + case(127): + return SimpleInterface127; + case(128): + return SimpleInterface128; + case(129): + return SimpleInterface129; + case(130): + return SimpleInterface130; + case(131): + return SimpleInterface131; + case(132): + return SimpleInterface132; + case(133): + return SimpleInterface133; + case(134): + return SimpleInterface134; + case(135): + return SimpleInterface135; + case(136): + return SimpleInterface136; + case(137): + return SimpleInterface137; + case(138): + return SimpleInterface138; + case(139): + return SimpleInterface139; + case(140): + return SimpleInterface140; + case(141): + return SimpleInterface141; + case(142): + return SimpleInterface142; + case(143): + return SimpleInterface143; + default: + throw new IndexOutOfBoundsException(); + } + } + public boolean set(int index,SimpleInterface value) + { + if(fieldSpecs[index].indexOf("final") != -1) + return false; + switch (index) + { + case(0): + SimpleInterface0= value; + break; + case(1): + SimpleInterface1= value; + break; + case(2): + SimpleInterface2= value; + break; + case(3): + SimpleInterface3= value; + break; + case(4): + SimpleInterface4= value; + break; + case(5): + SimpleInterface5= value; + break; + case(6): + SimpleInterface6= value; + break; + case(7): + SimpleInterface7= value; + break; + case(8): + SimpleInterface8= value; + break; + case(9): + SimpleInterface9= value; + break; + case(10): + SimpleInterface10= value; + break; + case(11): + SimpleInterface11= value; + break; + case(12): + SimpleInterface12= value; + break; + case(13): + SimpleInterface13= value; + break; + case(14): + SimpleInterface14= value; + break; + case(16): + SimpleInterface16= value; + break; + case(17): + SimpleInterface17= value; + break; + case(18): + SimpleInterface18= value; + break; + case(19): + SimpleInterface19= value; + break; + case(20): + SimpleInterface20= value; + break; + case(21): + SimpleInterface21= value; + break; + case(22): + SimpleInterface22= value; + break; + case(23): + SimpleInterface23= value; + break; + case(24): + SimpleInterface24= value; + break; + case(26): + SimpleInterface26= value; + break; + case(28): + SimpleInterface28= value; + break; + case(29): + SimpleInterface29= value; + break; + case(30): + SimpleInterface30= value; + break; + case(31): + SimpleInterface31= value; + break; + case(32): + SimpleInterface32= value; + break; + case(33): + SimpleInterface33= value; + break; + case(35): + SimpleInterface35= value; + break; + case(36): + SimpleInterface36= value; + break; + case(37): + SimpleInterface37= value; + break; + case(38): + SimpleInterface38= value; + break; + case(39): + SimpleInterface39= value; + break; + case(40): + SimpleInterface40= value; + break; + case(41): + SimpleInterface41= value; + break; + case(42): + SimpleInterface42= value; + break; + case(43): + SimpleInterface43= value; + break; + case(44): + SimpleInterface44= value; + break; + case(45): + SimpleInterface45= value; + break; + case(46): + SimpleInterface46= value; + break; + case(47): + SimpleInterface47= value; + break; + case(48): + SimpleInterface48= value; + break; + case(49): + SimpleInterface49= value; + break; + case(50): + SimpleInterface50= value; + break; + case(52): + SimpleInterface52= value; + break; + case(53): + SimpleInterface53= value; + break; + case(54): + SimpleInterface54= value; + break; + case(55): + SimpleInterface55= value; + break; + case(56): + SimpleInterface56= value; + break; + case(57): + SimpleInterface57= value; + break; + case(58): + SimpleInterface58= value; + break; + case(59): + SimpleInterface59= value; + break; + case(60): + SimpleInterface60= value; + break; + case(62): + SimpleInterface62= value; + break; + case(64): + SimpleInterface64= value; + break; + case(65): + SimpleInterface65= value; + break; + case(66): + SimpleInterface66= value; + break; + case(67): + SimpleInterface67= value; + break; + case(68): + SimpleInterface68= value; + break; + case(69): + SimpleInterface69= value; + break; + case(71): + SimpleInterface71= value; + break; + case(72): + SimpleInterface72= value; + break; + case(73): + SimpleInterface73= value; + break; + case(74): + SimpleInterface74= value; + break; + case(75): + SimpleInterface75= value; + break; + case(76): + SimpleInterface76= value; + break; + case(77): + SimpleInterface77= value; + break; + case(78): + SimpleInterface78= value; + break; + case(79): + SimpleInterface79= value; + break; + case(80): + SimpleInterface80= value; + break; + case(81): + SimpleInterface81= value; + break; + case(82): + SimpleInterface82= value; + break; + case(83): + SimpleInterface83= value; + break; + case(84): + SimpleInterface84= value; + break; + case(85): + SimpleInterface85= value; + break; + case(86): + SimpleInterface86= value; + break; + case(88): + SimpleInterface88= value; + break; + case(89): + SimpleInterface89= value; + break; + case(90): + SimpleInterface90= value; + break; + case(91): + SimpleInterface91= value; + break; + case(92): + SimpleInterface92= value; + break; + case(93): + SimpleInterface93= value; + break; + case(94): + SimpleInterface94= value; + break; + case(95): + SimpleInterface95= value; + break; + case(96): + SimpleInterface96= value; + break; + case(98): + SimpleInterface98= value; + break; + case(100): + SimpleInterface100= value; + break; + case(101): + SimpleInterface101= value; + break; + case(102): + SimpleInterface102= value; + break; + case(103): + SimpleInterface103= value; + break; + case(104): + SimpleInterface104= value; + break; + case(105): + SimpleInterface105= value; + break; + case(107): + SimpleInterface107= value; + break; + case(108): + SimpleInterface108= value; + break; + case(109): + SimpleInterface109= value; + break; + case(110): + SimpleInterface110= value; + break; + case(111): + SimpleInterface111= value; + break; + case(112): + SimpleInterface112= value; + break; + case(113): + SimpleInterface113= value; + break; + case(114): + SimpleInterface114= value; + break; + case(115): + SimpleInterface115= value; + break; + case(116): + SimpleInterface116= value; + break; + case(117): + SimpleInterface117= value; + break; + case(118): + SimpleInterface118= value; + break; + case(119): + SimpleInterface119= value; + break; + case(120): + SimpleInterface120= value; + break; + case(121): + SimpleInterface121= value; + break; + case(122): + SimpleInterface122= value; + break; + case(124): + SimpleInterface124= value; + break; + case(125): + SimpleInterface125= value; + break; + case(126): + SimpleInterface126= value; + break; + case(127): + SimpleInterface127= value; + break; + case(128): + SimpleInterface128= value; + break; + case(129): + SimpleInterface129= value; + break; + case(130): + SimpleInterface130= value; + break; + case(131): + SimpleInterface131= value; + break; + case(132): + SimpleInterface132= value; + break; + case(134): + SimpleInterface134= value; + break; + case(136): + SimpleInterface136= value; + break; + case(137): + SimpleInterface137= value; + break; + case(138): + SimpleInterface138= value; + break; + case(139): + SimpleInterface139= value; + break; + case(140): + SimpleInterface140= value; + break; + case(141): + SimpleInterface141= value; + break; + case(143): + SimpleInterface143= 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/FieldsOfSimpleInterface.java ------------------------------------------------------------------------------ svn:executable = *