1 files changed, 195 insertions, 0 deletions
diff --git a/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/ConsistencyTestTemplate.java b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/ConsistencyTestTemplate.java
new file mode 100644
index 0000000000..d37686a4bf
--- /dev/null
+++ b/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/ConsistencyTestTemplate.java
@@ -0,0 +1,195 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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.
+ *  
+ *  $Rev$  $Date$
+ */
+package test.sdo21.tests;
+
+// static imports simply allow you to call assertTrue rather than
+// Assert.assertTrue
+import static org.junit.Assert.assertEquals;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import test.sdo21.tests.TestData.StandardDynamicFactory;
+import test.sdo21.tests.TestData.StandardXSDFactory;
+import test.sdo21.tests.TestData.TestDataFactory;
+import test.sdo21.tests.api.CTSConsistencyBase;
+
+import commonj.sdo.DataObject;
+
+/**
+ * Example test class to be used as a template for SDO test cases which apply
+ * the same set of tests to a number of data sets of the same shape, but backed
+ * by metadata created in different ways, e.g. from and xsd, using the dynamic API,
+ * or, in the case of vendor specific tests, using statically generated classes.
+ * 
+ * This class extends {@link CTSConsistencyBase}
+ * which requires a concrete derived class to provide a factory which will be used to
+ * populate a DataObject called testSDO.  The concrete test can be written to conform
+ * to the expected shape of test data created by the factory it chooses to instantiate <br>
+ * <br>
+ * The test case can be run using Junit within eclipse, from normal command line
+ * junit, or within a WebSphere build environment by adding an target such as
+ * sampleTestTarget that is contained within the build.xml file of the
+ * WAS.soa.sdo.cts component. <br>
+ * <br>
+ * Once a test case has been completed and reviewed it can be added into the
+ * appropiate CTS Suite.<br>
+ * <br>
+ * Tests class must only use methods that are defined
+ * within the current SDO Specification. If utility methods are required they
+ * should be added to {@link test.sdo21.framework.TestHelper}. <br>
+ * <br>
+ * Please Document the overall intention of the test case and provide detailed
+ * javadoc for each test method. Please create modular test methods rather than
+ * single large test methods. Please use provide links back to the Main class under test
+ * and to the page in the specification as demonstrated below<br>
+ * <br>
+ * Resources:
+ * <UL>
+ * <LI><a href="http://www.junit.org/">Junit Foundation</a>
+ * </UL>
+ * 
+ * @see DataObject
+ * @see <a href="http://osoa.org/download/attachments/36/Java-SDO-Spec-v2.1.0-FINAL.pdf?version=1#page=45">2.1 spec section 3.11</a>
+ */
+public abstract class ConsistencyTestTemplate extends CTSConsistencyBase {
+
+    public ConsistencyTestTemplate() {
+    } 
+    
+
+    /**
+     * A concrete class which provides a factory that creates appropriate metadata for the
+     * test case using the SDO dynamic API.  This can be referenced as a class to be tested
+     * from within a junit suite declaration. Additional derived classes creating alternative
+     * factories may be supplied ellsewhere and referenced by other junit suite declarations,
+     * for example, in a vendor specific extension that uses statically generated classes.
+     */
+    public static class DynamicMetadata extends ConsistencyTestTemplate {
+      public DynamicMetadata() {
+        
+      }
+      public TestDataFactory createTestDataFactory() {
+  
+        return new StandardDynamicFactory();
+      }
+    }
+
+    /**
+     * A concrete class which provides a factory that creates appropriate metadata for the
+     * test case using an XML schema.  This can be referenced as a class to be tested
+     * from within a junit suite declaration. Additional derived classes creating alternative
+     * factories may be supplied ellsewhere and referenced by other junit suite declarations,
+     * for example, in a vendor specific extension that uses statically generated classes.
+     */
+    public static class XSDMetadata extends ConsistencyTestTemplate {
+      
+      public XSDMetadata() {
+      }
+      
+      public TestDataFactory createTestDataFactory() {
+  
+        return new StandardXSDFactory();
+      }
+    }
+    
+    
+    @Before
+    public void setUp () throws Exception {
+      super.setUp();
+    }
+    
+    @After
+    public void tearDown() throws Exception {
+      super.tearDown();
+    }
+    /**
+     * Example test method. Please provide good description of the test case in
+     * javadoc including the intention, reference to the specification, etc.
+     */
+    @Test
+    public void myTestMethod() {
+
+        String expected = new String("bla bla bla");
+        String actual = new String("bla bla bla");
+        assertEquals("Your Message", expected, actual);
+    }
+
+    /**
+     * Sometimes you want to temporarily disable a test. Methods annotated with
+     * {@link org.junit.Test} that are also annotated with <code>@Ignore</code> will not be executed as tests. Native JUnit 4 test
+     *         runners should report the number of ignored tests along with the
+     *         number of tests that ran and the number of tests that failed.
+     *         <code>@Ignore</code> takes an optional default parameter if you want to record
+     *         why a test is being ignored:<br>
+     */
+    @Test
+    @Ignore("Function Foo is not clearly defined within the SDO 2.1 specification and is currently being defined as a part of the x.x specification.")
+    public void exampleIngoredTestCase() {
+        // test method here
+    }
+
+    /**
+     * Sometimes you may not have the resources to implement a test case. If is
+     * very very valuable to create method signatures in the appropiate classes
+     * for test cases that are currently not covered. In cases such as these
+     * please define and checkin method signatures with the following ignore
+     * message. <br>
+     * <br>
+     * In this case you should ensure that the class that contains the test
+     * method is added to a testSuite such as
+     * {@link test.sdo21.UnderReviewSuite} so that it will
+     * be completed, or open a defect/JIRA to complete the test case.
+     */
+    @Test
+    @Ignore("This test method requires implementation")
+    public void exampleUnimplementedTestCase() {
+    }
+
+    /**
+     * When writing tests, it is common to find that several tests need similar
+     * objects created before they can run. Annotating a
+     * <code>public void</code> method with <code>@Before</code> causes that method to be run before the
+     *         {@link org.junit.Test} method. The <code>@Before</code> methods of superclasses will be run before those of the
+     *         current class. There is also an <code>@After</code> annotation
+     */
+    @Before
+    public void testCaseInit() {
+        // initMethod
+    }
+
+    /**
+     * Sometimes several tests need to share computationally expensive setup
+     * (like logging into a database). While this can compromise the
+     * independence of tests, sometimes it is a necessary optimization.
+     * Annotating a <code>public static void</code> no-arg method with
+     * <code>@BeforeClass</code> causes it to be run once before any of the test
+     *              methods in the class. The <code>@BeforeClass</code> methods of superclasses will be run before those the
+     *              current class.
+     */
+    @BeforeClass
+    public static void init() {
+        // init
+    }
+}