openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/jdbc/TestJDBCEnumToKernelConstantMappings.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 org.apache.openjpa.persistence.jdbc;

import java.sql.ResultSet;

import org.apache.openjpa.jdbc.kernel.EagerFetchModes;
import org.apache.openjpa.jdbc.kernel.LRSSizes;
import org.apache.openjpa.jdbc.sql.JoinSyntaxes;

import junit.framework.TestCase;

public class TestJDBCEnumToKernelConstantMappings
    extends TestCase {

    public void testEagerFetchModes() {
        assertEquals(EagerFetchModes.EAGER_NONE,
            FetchMode.NONE.toKernelConstant());
        assertEquals(FetchMode.NONE,
            FetchMode.fromKernelConstant(
                EagerFetchModes.EAGER_NONE));
        assertEquals(FetchMode.NONE.toKernelConstant(),
            FetchMode.NONE.ordinal());

        assertEquals(EagerFetchModes.EAGER_JOIN,
            FetchMode.JOIN.toKernelConstant());
        assertEquals(FetchMode.JOIN,
            FetchMode.fromKernelConstant(
                EagerFetchModes.EAGER_JOIN));
        assertEquals(FetchMode.JOIN.toKernelConstant(),
            FetchMode.JOIN.ordinal());

        assertEquals(EagerFetchModes.EAGER_PARALLEL,
            FetchMode.PARALLEL.toKernelConstant());
        assertEquals(FetchMode.PARALLEL,
            FetchMode.fromKernelConstant(
                EagerFetchModes.EAGER_PARALLEL));
        assertEquals(FetchMode.PARALLEL.toKernelConstant(),
            FetchMode.PARALLEL.ordinal());

        assertEquals(getConstantCount(EagerFetchModes.class),
            FetchMode.values().length);
    }

    public void testLRSSizeType() {
        assertEquals(LRSSizes.SIZE_UNKNOWN,
            LRSSizeAlgorithm.UNKNOWN.toKernelConstant());
        assertEquals(LRSSizeAlgorithm.UNKNOWN,
            LRSSizeAlgorithm.fromKernelConstant(
                LRSSizes.SIZE_UNKNOWN));
        assertEquals(LRSSizeAlgorithm.UNKNOWN.toKernelConstant(),
            LRSSizeAlgorithm.UNKNOWN.ordinal());

        assertEquals(LRSSizes.SIZE_LAST,
            LRSSizeAlgorithm.LAST.toKernelConstant());
        assertEquals(LRSSizeAlgorithm.LAST,
            LRSSizeAlgorithm.fromKernelConstant(
                LRSSizes.SIZE_LAST));
        assertEquals(LRSSizeAlgorithm.LAST.toKernelConstant(),
            LRSSizeAlgorithm.LAST.ordinal());

        assertEquals(LRSSizes.SIZE_QUERY,
            LRSSizeAlgorithm.QUERY.toKernelConstant());
        assertEquals(LRSSizeAlgorithm.QUERY,
            LRSSizeAlgorithm.fromKernelConstant(
                LRSSizes.SIZE_QUERY));
        assertEquals(LRSSizeAlgorithm.QUERY.toKernelConstant(),
            LRSSizeAlgorithm.QUERY.ordinal());

        assertEquals(getConstantCount(LRSSizes.class),
            LRSSizeAlgorithm.values().length);
    }

    public void testJoinSyntaxType() {
        assertEquals(JoinSyntaxes.SYNTAX_SQL92,
            JoinSyntax.SQL92.toKernelConstant());
        assertEquals(JoinSyntax.SQL92,
            JoinSyntax.fromKernelConstant(
                JoinSyntaxes.SYNTAX_SQL92));
        assertEquals(JoinSyntax.SQL92.toKernelConstant(),
            JoinSyntax.SQL92.ordinal());

        assertEquals(JoinSyntaxes.SYNTAX_TRADITIONAL,
            JoinSyntax.TRADITIONAL.toKernelConstant());
        assertEquals(JoinSyntax.TRADITIONAL,
            JoinSyntax.fromKernelConstant(
                JoinSyntaxes.SYNTAX_TRADITIONAL));
        assertEquals(JoinSyntax.TRADITIONAL.toKernelConstant(),
            JoinSyntax.TRADITIONAL.ordinal());

        assertEquals(JoinSyntaxes.SYNTAX_DATABASE,
            JoinSyntax.DATABASE.toKernelConstant());
        assertEquals(JoinSyntax.DATABASE,
            JoinSyntax.fromKernelConstant(
                JoinSyntaxes.SYNTAX_DATABASE));
        assertEquals(JoinSyntax.DATABASE.toKernelConstant(),
            JoinSyntax.DATABASE.ordinal());

        assertEquals(getConstantCount(JoinSyntaxes.class),
            JoinSyntax.values().length);
    }

    public void testResultSetType() {
        assertEquals(ResultSet.TYPE_FORWARD_ONLY,
            ResultSetType.FORWARD_ONLY.toKernelConstant());
        assertEquals(ResultSetType.FORWARD_ONLY,
            ResultSetType.fromKernelConstant(
                ResultSet.TYPE_FORWARD_ONLY));

        assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSetType.SCROLL_INSENSITIVE.toKernelConstant());
        assertEquals(ResultSetType.SCROLL_INSENSITIVE,
            ResultSetType.fromKernelConstant(
                ResultSet.TYPE_SCROLL_INSENSITIVE));

        assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE,
            ResultSetType.SCROLL_SENSITIVE.toKernelConstant());
        assertEquals(ResultSetType.SCROLL_SENSITIVE,
            ResultSetType.fromKernelConstant(
                ResultSet.TYPE_SCROLL_SENSITIVE));

        assertEquals(3, ResultSetType.values().length);
    }

    public void testFetchDirection() {
        assertEquals(ResultSet.FETCH_FORWARD,
            FetchDirection.FORWARD.toKernelConstant());
        assertEquals(FetchDirection.FORWARD,
            FetchDirection.fromKernelConstant(
                ResultSet.FETCH_FORWARD));

        assertEquals(ResultSet.FETCH_REVERSE,
            FetchDirection.REVERSE.toKernelConstant());
        assertEquals(FetchDirection.REVERSE,
            FetchDirection.fromKernelConstant(
                ResultSet.FETCH_REVERSE));

        assertEquals(ResultSet.FETCH_UNKNOWN,
            FetchDirection.UNKNOWN.toKernelConstant());
        assertEquals(FetchDirection.UNKNOWN,
            FetchDirection.fromKernelConstant(
                ResultSet.FETCH_UNKNOWN));

        assertEquals(3, FetchDirection.values().length);
    }


    private int getConstantCount(Class cls) {
        return cls.getDeclaredFields().length;
    }
}