/*
 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package test.rowset;

import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
import javax.sql.RowSetMetaData;
import javax.sql.rowset.RowSetMetaDataImpl;
import static org.testng.Assert.*;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import util.BaseTest;

public class RowSetMetaDataTests extends BaseTest {

    // Max columns used in the tests
    private final int MAX_COLUMNS = 5;
    // Instance to be used within the tests
    private RowSetMetaDataImpl rsmd;

    @BeforeMethod
    public void setUpMethod() throws Exception {
        rsmd = new RowSetMetaDataImpl();
        rsmd.setColumnCount(MAX_COLUMNS);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test(Integer col) throws Exception {
        rsmd.getCatalogName(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test01(Integer col) throws Exception {
        rsmd.getColumnClassName(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test02(Integer col) throws Exception {
        rsmd.getColumnDisplaySize(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test03(Integer col) throws Exception {
        rsmd.getColumnLabel(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test04(Integer col) throws Exception {
        rsmd.getColumnName(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test05(Integer col) throws Exception {
        rsmd.getColumnType(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test06(Integer col) throws Exception {
        rsmd.getColumnTypeName(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test07(Integer col) throws Exception {
        rsmd.getPrecision(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test08(Integer col) throws Exception {
        rsmd.getScale(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test09(Integer col) throws Exception {
        rsmd.getSchemaName(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test10(Integer col) throws Exception {
        rsmd.getTableName(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test11(Integer col) throws Exception {
        rsmd.isAutoIncrement(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test12(Integer col) throws Exception {
        rsmd.isCaseSensitive(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test13(Integer col) throws Exception {
        rsmd.isCurrency(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test14(Integer col) throws Exception {
        rsmd.isDefinitelyWritable(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test15(Integer col) throws Exception {
        rsmd.isNullable(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test16(Integer col) throws Exception {
        rsmd.isReadOnly(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test17(Integer col) throws Exception {
        rsmd.isSearchable(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test18(Integer col) throws Exception {
        rsmd.isSigned(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test19(Integer col) throws Exception {
        rsmd.isWritable(col);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test20(Integer col) throws Exception {
        rsmd.setAutoIncrement(col, true);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test21(Integer col) throws Exception {
        rsmd.setCaseSensitive(col, true);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test22(Integer col) throws Exception {
        rsmd.setCatalogName(col, null);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test23(Integer col) throws Exception {
        rsmd.setColumnDisplaySize(col, 5);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test24(Integer col) throws Exception {
        rsmd.setColumnLabel(col, "label");
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test25(Integer col) throws Exception {
        rsmd.setColumnName(col, "F1");
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test26(Integer col) throws Exception {
        rsmd.setColumnType(col, Types.CHAR);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test27(Integer col) throws Exception {
        rsmd.setColumnTypeName(col, "F1");
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test28(Integer col) throws Exception {
        rsmd.setCurrency(col, true);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test29(Integer col) throws Exception {
        rsmd.setNullable(col, ResultSetMetaData.columnNoNulls);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test30(Integer col) throws Exception {
        rsmd.setPrecision(col, 2);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test31(Integer col) throws Exception {
        rsmd.setScale(col, 2);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test32(Integer col) throws Exception {
        rsmd.setSchemaName(col, "Gotham");
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test33(Integer col) throws Exception {
        rsmd.setSearchable(col, false);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test34(Integer col) throws Exception {
        rsmd.setSigned(col, false);
    }

    /*
     * Validate a SQLException is thrown for an invalid column index
     */
    @Test(dataProvider = "invalidColumnRanges",
            expectedExceptions = SQLException.class)
    public void test35(Integer col) throws Exception {
        rsmd.setTableName(col, "SUPERHEROS");
    }

    /*
     * Validate that the correct class name is returned for the column
     * Note:  Once setColumnClassName is added to RowSetMetaData, this
     * method will need to change.
     */
    @Test(dataProvider = "columnClassNames")
    public void test36(Integer type, String name) throws Exception {
        rsmd.setColumnType(1, type);
        assertTrue(rsmd.getColumnClassName(1).equals(name));
    }

    /*
     * Validate that all of the methods are accessible and the correct value
     * is returned for each column
     */
    @Test(dataProvider = "columnRanges")
    public void test37(Integer col) throws Exception {
        rsmd.setAutoIncrement(col, true);
        assertTrue(rsmd.isAutoIncrement(col));
        rsmd.setCaseSensitive(col, true);
        assertTrue(rsmd.isCaseSensitive(col));
        rsmd.setCatalogName(col, "Gotham");
        assertTrue(rsmd.getCatalogName(col).equals("Gotham"));
        rsmd.setColumnDisplaySize(col, 20);
        assertTrue(rsmd.getColumnDisplaySize(col) == 20);
        rsmd.setColumnLabel(col, "F1");
        assertTrue(rsmd.getColumnLabel(col).equals("F1"));
        rsmd.setColumnName(col, "F1");
        assertTrue(rsmd.getColumnName(col).equals("F1"));
        rsmd.setColumnType(col, Types.INTEGER);
        assertTrue(rsmd.getColumnType(col) == Types.INTEGER);
        assertTrue(rsmd.getColumnClassName(col).equals(Integer.class.getName()));
        rsmd.setColumnTypeName(col, "INTEGER");
        assertTrue(rsmd.getColumnTypeName(col).equals("INTEGER"));
        rsmd.setCurrency(col, true);
        assertTrue(rsmd.isCurrency(col));
        rsmd.setNullable(col, ResultSetMetaData.columnNoNulls);
        assertTrue(rsmd.isNullable(col) == ResultSetMetaData.columnNoNulls);
        rsmd.setPrecision(col, 2);
        assertTrue(rsmd.getPrecision(col) == 2);
        rsmd.setScale(col, 2);
        assertTrue(rsmd.getScale(col) == 2);
        rsmd.setSchemaName(col, "GOTHAM");
        assertTrue(rsmd.getSchemaName(col).equals("GOTHAM"));
        rsmd.setSearchable(col, false);
        assertFalse(rsmd.isSearchable(col));
        rsmd.setSigned(col, false);
        assertFalse(rsmd.isSigned(col));
        rsmd.setTableName(col, "SUPERHEROS");
        assertTrue(rsmd.getTableName(col).equals("SUPERHEROS"));
        rsmd.isReadOnly(col);
        rsmd.isDefinitelyWritable(col);
        rsmd.isWritable(col);

    }

    /*
     * Validate that the proper values are accepted by setNullable
     */
    @Test(dataProvider = "validSetNullableValues")
    public void test38(Integer val) throws Exception {
        rsmd.setNullable(1, val);
    }

    /*
     * Validate that the correct type is returned for the column
     */
    @Test(dataProvider = "jdbcTypes")
    public void test39(Integer type) throws Exception {
        rsmd.setColumnType(1, type);
        assertTrue(type == rsmd.getColumnType(1));
    }

    /*
     * Validate that the correct value is returned from the isXXX methods
     */
    @Test(dataProvider = "trueFalse")
    public void test40(Boolean b) throws Exception {
        rsmd.setAutoIncrement(1, b);
        rsmd.setCaseSensitive(1, b);
        rsmd.setCurrency(1, b);
        rsmd.setSearchable(1, b);
        rsmd.setSigned(1, b);
        assertTrue(rsmd.isAutoIncrement(1) == b);
        assertTrue(rsmd.isCaseSensitive(1) == b);
        assertTrue(rsmd.isCurrency(1) == b);
        assertTrue(rsmd.isSearchable(1) == b);
        assertTrue(rsmd.isSigned(1) == b);
    }

    /*
     * Validate isWrapperFor and unwrap work correctly
     */
    @SuppressWarnings("unchecked")
    @Test
    public void test99() throws Exception {
        RowSetMetaData rsmd1 = rsmd;
        ResultSetMetaData rsmd2 = rsmd;
        Class clzz = rsmd.getClass();
        assertTrue(rsmd1.isWrapperFor(clzz));
        assertTrue(rsmd2.isWrapperFor(clzz));
        RowSetMetaDataImpl rsmdi = (RowSetMetaDataImpl) rsmd2.unwrap(clzz);

        // False should be returned
        assertFalse(rsmd1.isWrapperFor(this.getClass()));
        assertFalse(rsmd2.isWrapperFor(this.getClass()));
    }

    /*
     * DataProvider used to provide Date which are not valid and are used
     * to validate that an IllegalArgumentException will be thrown from the
     * valueOf method
     */
    @DataProvider(name = "validSetNullableValues")
    private Object[][] validSetNullableValues() {
        return new Object[][]{
            {ResultSetMetaData.columnNoNulls},
            {ResultSetMetaData.columnNullable},
            {ResultSetMetaData.columnNullableUnknown}
        };
    }

    /*
     * DataProvider used to provide column indexes that are out of range so that
     * SQLException is thrown
     */
    @DataProvider(name = "invalidColumnRanges")
    private Object[][] invalidColumnRanges() {
        return new Object[][]{
            {-1},
            {0},
            {MAX_COLUMNS + 1}
        };
    }

    /*
     * DataProvider used to provide the valid column ranges for the
     * RowSetMetaDataImpl object
     */
    @DataProvider(name = "columnRanges")
    private Object[][] columnRanges() {
        Object[][] o = new Object[MAX_COLUMNS][1];
        for (int i = 1; i <= MAX_COLUMNS; i++) {
            o[i - 1][0] = i;
        }
        return o;
    }

    /*
     * DataProvider used to specify the value to set via setColumnType and
     * the expected value to be returned from getColumnClassName
     */
    @DataProvider(name = "columnClassNames")
    private Object[][] columnClassNames() {
        return new Object[][]{
            {Types.CHAR, "java.lang.String"},
            {Types.NCHAR, "java.lang.String"},
            {Types.VARCHAR, "java.lang.String"},
            {Types.NVARCHAR, "java.lang.String"},
            {Types.LONGVARCHAR, "java.lang.String"},
            {Types.LONGNVARCHAR, "java.lang.String"},
            {Types.NUMERIC, "java.math.BigDecimal"},
            {Types.DECIMAL, "java.math.BigDecimal"},
            {Types.BIT, "java.lang.Boolean"},
            {Types.TINYINT, "java.lang.Byte"},
            {Types.SMALLINT, "java.lang.Short"},
            {Types.INTEGER, "java.lang.Integer"},
            {Types.FLOAT, "java.lang.Double"},
            {Types.DOUBLE, "java.lang.Double"},
            {Types.BINARY, "byte[]"},
            {Types.VARBINARY, "byte[]"},
            {Types.LONGVARBINARY, "byte[]"},
            {Types.DATE, "java.sql.Date"},
            {Types.TIME, "java.sql.Time"},
            {Types.TIMESTAMP, "java.sql.Timestamp"},
            {Types.CLOB, "java.sql.Clob"},
            {Types.BLOB, "java.sql.Blob"}

        };

    }

}