path: root/sdo-java/trunk-cts/sdo2.1/src/main/java/test/sdo21/tests/conversion/ConversionBase.java

/**
 *
 *  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.
 */
package test.sdo21.tests.conversion;

import junit.framework.TestCase;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.TimeZone;
import java.util.Date;
import java.math.BigDecimal;
import java.math.BigInteger;

import test.sdo21.framework.TestHelper;
import test.sdo21.framework.junit3_8.CTSTestCase;
import test.sdo21.CTSSuite;
import commonj.sdo.DataObject;
import commonj.sdo.helper.TypeHelper;

/**
 * Base class for conversion tests.
 */
public class ConversionBase extends CTSTestCase {

    /**
     * This variable is used to create unique type names to avoid name clashes
     * in TypeHelper
     */
    protected static int unique = 0;

    /**
     * DateFormat is set up in the constructor as per the format in the
     * specification.
     */
    protected  DateFormat f;

    /**
     * The TestHelper interface provides access to SDO helper classes.
     */
    protected  TestHelper testHelper;

    /**
     * Message to use when an invalid type conversion does not throw a
     * ClassCastException
     */
    protected  static final String EXPECTED_CLASS_CAST_EXCEPTION =
        "ClassCastException should have been thrown (invalid conversion)";


    public ConversionBase(String string) {
        super(string);
    }

    /**
     * Sets up a time format and obtain a test helper.
     */
    public void setUp() throws Exception {
        super.setUp();

        // set up time format as per page 71 of SDO for Java 2.1.0 FINAL
        f = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'.'SSS'Z'");
        f.setTimeZone(TimeZone.getTimeZone("GMT"));

        // obtain TestHelper implementation
        testHelper = getTestHelper();
    }

    /**
     * Helper function for converions tests. Creates a DataObject with name
     * 'product' and data hold property
     *
     * @param strName the name of the data hold property in the created object.
     * @param strType the type of the data hold property in the created object.
     * @return the created DataObject.
     */
    private DataObject createTypeConversionObject(String strName, String strType) {

        // obtain a TypeHelper
        TypeHelper typeHelper = getScope().getTypeHelper();

        // create new DataType
        String uri = "http://example.com/TypeConversionTest/" + unique;
        String name = "TypeConversionTest" + unique;
        unique++;
        DataObject productType = getScope().getDataFactory().create("commonj.sdo", "Type");
        productType.set("uri", uri);
        productType.set("name", name);

        // define property
        DataObject dateValProperty = productType.createDataObject("property");
        dateValProperty.set("name", strName);
        dateValProperty.set("type", typeHelper.getType("commonj.sdo", strType));
        dateValProperty.setBoolean("containment", false);

        // define the type
        typeHelper.define(productType);

        // create DataObject using the new Type
        return getScope().getDataFactory().create(uri, name);
    }

    /**
     * Helper function for boolean converions tests. Created a DataObject with
     * 'boolVal' boolean property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createBooleanObject(boolean initialVal) {
        DataObject productType = createTypeConversionObject("boolVal", "Boolean");
        productType.setBoolean("boolVal", initialVal);
        return productType;
    }

    /**
     * Helper function for byte converions tests. Creates a DataObject with
     * 'byteVal' byte property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createByteObject(byte initialVal) {
        DataObject productType = createTypeConversionObject("byteVal", "Byte");
        productType.setByte("byteVal", initialVal);
        return productType;
    }

    /**
     * Helper function for char converions tests. Creates a DataObject with
     * 'charVal' char property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createCharObject(char initialVal) {
        DataObject productType = createTypeConversionObject("charVal", "Character");
        productType.setChar("charVal", initialVal);
        return productType;
    }

    /**
     * Helper function for Double converions tests. Creates a DataObject with
     * 'doubleVal' double property.
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createDoubleObject(double initialVal) {
        DataObject productType = createTypeConversionObject("doubleVal", "Double");
        productType.setDouble("doubleVal", initialVal);
        return productType;
    }

    /**
     * Helper function for Float converions tests. Creates a DataObject with
     * 'floatVal' float property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createFloatObject(float initialVal) {
        DataObject productType = createTypeConversionObject("floatVal", "Float");
        productType.setFloat("floatVal", initialVal);
        return productType;
    }

    /**
     * Helper function for int converions tests. Creates a DataObject with
     * 'intVal' int property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createIntObject(int initialVal) {
        DataObject productType = createTypeConversionObject("intVal", "Int");
        productType.setInt("intVal", initialVal);
        return productType;
    }

    /**
     * Helper function for Long converions tests. Creates a DataObject with
     * 'longVal' long property.
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createLongObject(long initialVal) {
        DataObject productType = createTypeConversionObject("longVal", "Long");
        productType.setLong("longVal", initialVal);
        return productType;
    }

    /**
     * Helper function for short converions tests. Creates a DataObject with
     * 'shortVal' short property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createShortObject(short initialVal) {
        DataObject productType = createTypeConversionObject("shortVal", "Short");
        productType.setShort("shortVal", initialVal);
        return productType;
    }

    /**
     * Helper function for short converions tests. Creates a DataObject with
     * 'stringVal' string property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createStringObject(String initialVal) {
        DataObject productType = createTypeConversionObject("stringVal", "String");
        productType.setString("stringVal", initialVal);
        return productType;
    }

    /**
     * Helper function for byte[] converions tests. Created a DataObject with
     * 'bytesVal' byte[] property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createBytesObject(byte[] initialVal) {
        DataObject productType = createTypeConversionObject("bytesVal", "Bytes");
        productType.setBytes("bytesVal", initialVal);
        return productType;
    }

    /**
     * Helper function for Decimal converions tests. creates a DataObject with
     * 'bigDecimalVal' BigDecimal property
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createBigDecimalObject(BigDecimal initialVal) {
        DataObject productType = createTypeConversionObject("bigDecimalVal", "Decimal");
        productType.setBigDecimal("bigDecimalVal", initialVal);
        return productType;
    }

    /**
     * Helper function for BigInteger converions tests. Creates a DataObject
     * with 'bigIntegerVal' BigInteger property.
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createBigIntegerObject(BigInteger initialVal) {
        DataObject productType = createTypeConversionObject("bigIntegerVal", "Integer");
        productType.setBigInteger("bigIntegerVal", initialVal);
        return productType;
    }

    /**
     * Helper function for Date converions tests. Creates a DataObject with
     * 'dateVal' date property.
     *
     * @param initialVal the initial value of the data hold property.
     * @return the initialized DataObject.
     */
    protected DataObject createDateObject(Date initialVal) {
        DataObject productType = createTypeConversionObject("dateVal", "Date");
        productType.setDate("dateVal", initialVal);
        return productType;
    }
}