/*
 *  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
    }
}