/*
 *  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.framework.CTSTestCase;

/**
 * Example test class to be used as a template SDO test cases.
 * <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>
 * This test class should make every effort to 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<br>
 * <br>
 * Resources:
 * <UL>
 * <LI><a href="http://www.junit.org/">Junit Fondation</a>
 * Change History:
 * <UL>
 * <LI>Initial implementation
 * </UL>
 */
public class TestTemplate extends CTSTestCase {


    /**
     * 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<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
     * @throws Exception 
     */
    @Before
    public void setUp() throws Exception {
      super.setUp();
    }

    @After
    public void tearDown() throws Exception {
      super.tearDown();
    }

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