diff options
author | lresende <lresende@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-10 21:17:39 +0000 |
---|---|---|
committer | lresende <lresende@13f79535-47bb-0310-9956-ffa450edef68> | 2009-11-10 21:17:39 +0000 |
commit | eb11fd83f7908876fe6041086d6025c9468de672 (patch) | |
tree | 7475c93a5adceca4829d5c7bf6631d4b09749f4b /sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/ConsistencyTestTemplate.java | |
parent | 39a3e278e786438a92428fe13646d09f3441d2e6 (diff) |
Moving SDO CTS
git-svn-id: http://svn.us.apache.org/repos/asf/tuscany@834672 13f79535-47bb-0310-9956-ffa450edef68
Diffstat (limited to 'sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/ConsistencyTestTemplate.java')
-rw-r--r-- | sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/ConsistencyTestTemplate.java | 195 |
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 + } +} |