1 /*

     2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 package test.rowset;

    24 

    25 import java.sql.ResultSetMetaData;

    26 import java.sql.SQLException;

    27 import java.sql.Types;

    28 import javax.sql.RowSetMetaData;

    29 import javax.sql.rowset.RowSetMetaDataImpl;

    30 import static org.testng.Assert.*;

    31 import org.testng.annotations.BeforeMethod;

    32 import org.testng.annotations.DataProvider;

    33 import org.testng.annotations.Test;

    34 import util.BaseTest;

    35 

    36 public class RowSetMetaDataTests extends BaseTest {

    37 

    38     // Max columns used in the tests

    39     private final int MAX_COLUMNS = 5;

    40     // Instance to be used within the tests

    41     private RowSetMetaDataImpl rsmd;

    42 

    43     @BeforeMethod

    44     public void setUpMethod() throws Exception {

    45         rsmd = new RowSetMetaDataImpl();

    46         rsmd.setColumnCount(MAX_COLUMNS);

    47     }

    48 

    49     /*

    50      * Validate a SQLException is thrown for an invalid column index

    51      */

    52     @Test(dataProvider = "invalidColumnRanges",

    53             expectedExceptions = SQLException.class)

    54     public void test(Integer col) throws Exception {

    55         rsmd.getCatalogName(col);

    56     }

    57 

    58     /*

    59      * Validate a SQLException is thrown for an invalid column index

    60      */

    61     @Test(dataProvider = "invalidColumnRanges",

    62             expectedExceptions = SQLException.class)

    63     public void test01(Integer col) throws Exception {

    64         rsmd.getColumnClassName(col);

    65     }

    66 

    67     /*

    68      * Validate a SQLException is thrown for an invalid column index

    69      */

    70     @Test(dataProvider = "invalidColumnRanges",

    71             expectedExceptions = SQLException.class)

    72     public void test02(Integer col) throws Exception {

    73         rsmd.getColumnDisplaySize(col);

    74     }

    75 

    76     /*

    77      * Validate a SQLException is thrown for an invalid column index

    78      */

    79     @Test(dataProvider = "invalidColumnRanges",

    80             expectedExceptions = SQLException.class)

    81     public void test03(Integer col) throws Exception {

    82         rsmd.getColumnLabel(col);

    83     }

    84 

    85     /*

    86      * Validate a SQLException is thrown for an invalid column index

    87      */

    88     @Test(dataProvider = "invalidColumnRanges",

    89             expectedExceptions = SQLException.class)

    90     public void test04(Integer col) throws Exception {

    91         rsmd.getColumnName(col);

    92     }

    93 

    94     /*

    95      * Validate a SQLException is thrown for an invalid column index

    96      */

    97     @Test(dataProvider = "invalidColumnRanges",

    98             expectedExceptions = SQLException.class)

    99     public void test05(Integer col) throws Exception {

   100         rsmd.getColumnType(col);

   101     }

   102 

   103     /*

   104      * Validate a SQLException is thrown for an invalid column index

   105      */

   106     @Test(dataProvider = "invalidColumnRanges",

   107             expectedExceptions = SQLException.class)

   108     public void test06(Integer col) throws Exception {

   109         rsmd.getColumnTypeName(col);

   110     }

   111 

   112     /*

   113      * Validate a SQLException is thrown for an invalid column index

   114      */

   115     @Test(dataProvider = "invalidColumnRanges",

   116             expectedExceptions = SQLException.class)

   117     public void test07(Integer col) throws Exception {

   118         rsmd.getPrecision(col);

   119     }

   120 

   121     /*

   122      * Validate a SQLException is thrown for an invalid column index

   123      */

   124     @Test(dataProvider = "invalidColumnRanges",

   125             expectedExceptions = SQLException.class)

   126     public void test08(Integer col) throws Exception {

   127         rsmd.getScale(col);

   128     }

   129 

   130     /*

   131      * Validate a SQLException is thrown for an invalid column index

   132      */

   133     @Test(dataProvider = "invalidColumnRanges",

   134             expectedExceptions = SQLException.class)

   135     public void test09(Integer col) throws Exception {

   136         rsmd.getSchemaName(col);

   137     }

   138 

   139     /*

   140      * Validate a SQLException is thrown for an invalid column index

   141      */

   142     @Test(dataProvider = "invalidColumnRanges",

   143             expectedExceptions = SQLException.class)

   144     public void test10(Integer col) throws Exception {

   145         rsmd.getTableName(col);

   146     }

   147 

   148     /*

   149      * Validate a SQLException is thrown for an invalid column index

   150      */

   151     @Test(dataProvider = "invalidColumnRanges",

   152             expectedExceptions = SQLException.class)

   153     public void test11(Integer col) throws Exception {

   154         rsmd.isAutoIncrement(col);

   155     }

   156 

   157     /*

   158      * Validate a SQLException is thrown for an invalid column index

   159      */

   160     @Test(dataProvider = "invalidColumnRanges",

   161             expectedExceptions = SQLException.class)

   162     public void test12(Integer col) throws Exception {

   163         rsmd.isCaseSensitive(col);

   164     }

   165 

   166     /*

   167      * Validate a SQLException is thrown for an invalid column index

   168      */

   169     @Test(dataProvider = "invalidColumnRanges",

   170             expectedExceptions = SQLException.class)

   171     public void test13(Integer col) throws Exception {

   172         rsmd.isCurrency(col);

   173     }

   174 

   175     /*

   176      * Validate a SQLException is thrown for an invalid column index

   177      */

   178     @Test(dataProvider = "invalidColumnRanges",

   179             expectedExceptions = SQLException.class)

   180     public void test14(Integer col) throws Exception {

   181         rsmd.isDefinitelyWritable(col);

   182     }

   183 

   184     /*

   185      * Validate a SQLException is thrown for an invalid column index

   186      */

   187     @Test(dataProvider = "invalidColumnRanges",

   188             expectedExceptions = SQLException.class)

   189     public void test15(Integer col) throws Exception {

   190         rsmd.isNullable(col);

   191     }

   192 

   193     /*

   194      * Validate a SQLException is thrown for an invalid column index

   195      */

   196     @Test(dataProvider = "invalidColumnRanges",

   197             expectedExceptions = SQLException.class)

   198     public void test16(Integer col) throws Exception {

   199         rsmd.isReadOnly(col);

   200     }

   201 

   202     /*

   203      * Validate a SQLException is thrown for an invalid column index

   204      */

   205     @Test(dataProvider = "invalidColumnRanges",

   206             expectedExceptions = SQLException.class)

   207     public void test17(Integer col) throws Exception {

   208         rsmd.isSearchable(col);

   209     }

   210 

   211     /*

   212      * Validate a SQLException is thrown for an invalid column index

   213      */

   214     @Test(dataProvider = "invalidColumnRanges",

   215             expectedExceptions = SQLException.class)

   216     public void test18(Integer col) throws Exception {

   217         rsmd.isSigned(col);

   218     }

   219 

   220     /*

   221      * Validate a SQLException is thrown for an invalid column index

   222      */

   223     @Test(dataProvider = "invalidColumnRanges",

   224             expectedExceptions = SQLException.class)

   225     public void test19(Integer col) throws Exception {

   226         rsmd.isWritable(col);

   227     }

   228 

   229     /*

   230      * Validate a SQLException is thrown for an invalid column index

   231      */

   232     @Test(dataProvider = "invalidColumnRanges",

   233             expectedExceptions = SQLException.class)

   234     public void test20(Integer col) throws Exception {

   235         rsmd.setAutoIncrement(col, true);

   236     }

   237 

   238     /*

   239      * Validate a SQLException is thrown for an invalid column index

   240      */

   241     @Test(dataProvider = "invalidColumnRanges",

   242             expectedExceptions = SQLException.class)

   243     public void test21(Integer col) throws Exception {

   244         rsmd.setCaseSensitive(col, true);

   245     }

   246 

   247     /*

   248      * Validate a SQLException is thrown for an invalid column index

   249      */

   250     @Test(dataProvider = "invalidColumnRanges",

   251             expectedExceptions = SQLException.class)

   252     public void test22(Integer col) throws Exception {

   253         rsmd.setCatalogName(col, null);

   254     }

   255 

   256     /*

   257      * Validate a SQLException is thrown for an invalid column index

   258      */

   259     @Test(dataProvider = "invalidColumnRanges",

   260             expectedExceptions = SQLException.class)

   261     public void test23(Integer col) throws Exception {

   262         rsmd.setColumnDisplaySize(col, 5);

   263     }

   264 

   265     /*

   266      * Validate a SQLException is thrown for an invalid column index

   267      */

   268     @Test(dataProvider = "invalidColumnRanges",

   269             expectedExceptions = SQLException.class)

   270     public void test24(Integer col) throws Exception {

   271         rsmd.setColumnLabel(col, "label");

   272     }

   273 

   274     /*

   275      * Validate a SQLException is thrown for an invalid column index

   276      */

   277     @Test(dataProvider = "invalidColumnRanges",

   278             expectedExceptions = SQLException.class)

   279     public void test25(Integer col) throws Exception {

   280         rsmd.setColumnName(col, "F1");

   281     }

   282 

   283     /*

   284      * Validate a SQLException is thrown for an invalid column index

   285      */

   286     @Test(dataProvider = "invalidColumnRanges",

   287             expectedExceptions = SQLException.class)

   288     public void test26(Integer col) throws Exception {

   289         rsmd.setColumnType(col, Types.CHAR);

   290     }

   291 

   292     /*

   293      * Validate a SQLException is thrown for an invalid column index

   294      */

   295     @Test(dataProvider = "invalidColumnRanges",

   296             expectedExceptions = SQLException.class)

   297     public void test27(Integer col) throws Exception {

   298         rsmd.setColumnTypeName(col, "F1");

   299     }

   300 

   301     /*

   302      * Validate a SQLException is thrown for an invalid column index

   303      */

   304     @Test(dataProvider = "invalidColumnRanges",

   305             expectedExceptions = SQLException.class)

   306     public void test28(Integer col) throws Exception {

   307         rsmd.setCurrency(col, true);

   308     }

   309 

   310     /*

   311      * Validate a SQLException is thrown for an invalid column index

   312      */

   313     @Test(dataProvider = "invalidColumnRanges",

   314             expectedExceptions = SQLException.class)

   315     public void test29(Integer col) throws Exception {

   316         rsmd.setNullable(col, ResultSetMetaData.columnNoNulls);

   317     }

   318 

   319     /*

   320      * Validate a SQLException is thrown for an invalid column index

   321      */

   322     @Test(dataProvider = "invalidColumnRanges",

   323             expectedExceptions = SQLException.class)

   324     public void test30(Integer col) throws Exception {

   325         rsmd.setPrecision(col, 2);

   326     }

   327 

   328     /*

   329      * Validate a SQLException is thrown for an invalid column index

   330      */

   331     @Test(dataProvider = "invalidColumnRanges",

   332             expectedExceptions = SQLException.class)

   333     public void test31(Integer col) throws Exception {

   334         rsmd.setScale(col, 2);

   335     }

   336 

   337     /*

   338      * Validate a SQLException is thrown for an invalid column index

   339      */

   340     @Test(dataProvider = "invalidColumnRanges",

   341             expectedExceptions = SQLException.class)

   342     public void test32(Integer col) throws Exception {

   343         rsmd.setSchemaName(col, "Gotham");

   344     }

   345 

   346     /*

   347      * Validate a SQLException is thrown for an invalid column index

   348      */

   349     @Test(dataProvider = "invalidColumnRanges",

   350             expectedExceptions = SQLException.class)

   351     public void test33(Integer col) throws Exception {

   352         rsmd.setSearchable(col, false);

   353     }

   354 

   355     /*

   356      * Validate a SQLException is thrown for an invalid column index

   357      */

   358     @Test(dataProvider = "invalidColumnRanges",

   359             expectedExceptions = SQLException.class)

   360     public void test34(Integer col) throws Exception {

   361         rsmd.setSigned(col, false);

   362     }

   363 

   364     /*

   365      * Validate a SQLException is thrown for an invalid column index

   366      */

   367     @Test(dataProvider = "invalidColumnRanges",

   368             expectedExceptions = SQLException.class)

   369     public void test35(Integer col) throws Exception {

   370         rsmd.setTableName(col, "SUPERHEROS");

   371     }

   372 

   373     /*

   374      * Validate that the correct class name is returned for the column

   375      * Note:  Once setColumnClassName is added to RowSetMetaData, this

   376      * method will need to change.

   377      */

   378     @Test(dataProvider = "columnClassNames")

   379     public void test36(Integer type, String name) throws Exception {

   380         rsmd.setColumnType(1, type);

   381         assertTrue(rsmd.getColumnClassName(1).equals(name));

   382     }

   383 

   384     /*

   385      * Validate that all of the methods are accessible and the correct value

   386      * is returned for each column

   387      */

   388     @Test(dataProvider = "columnRanges")

   389     public void test37(Integer col) throws Exception {

   390         rsmd.setAutoIncrement(col, true);

   391         assertTrue(rsmd.isAutoIncrement(col));

   392         rsmd.setCaseSensitive(col, true);

   393         assertTrue(rsmd.isCaseSensitive(col));

   394         rsmd.setCatalogName(col, "Gotham");

   395         assertTrue(rsmd.getCatalogName(col).equals("Gotham"));

   396         rsmd.setColumnDisplaySize(col, 20);

   397         assertTrue(rsmd.getColumnDisplaySize(col) == 20);

   398         rsmd.setColumnLabel(col, "F1");

   399         assertTrue(rsmd.getColumnLabel(col).equals("F1"));

   400         rsmd.setColumnName(col, "F1");

   401         assertTrue(rsmd.getColumnName(col).equals("F1"));

   402         rsmd.setColumnType(col, Types.INTEGER);

   403         assertTrue(rsmd.getColumnType(col) == Types.INTEGER);

   404         assertTrue(rsmd.getColumnClassName(col).equals(Integer.class.getName()));

   405         rsmd.setColumnTypeName(col, "INTEGER");

   406         assertTrue(rsmd.getColumnTypeName(col).equals("INTEGER"));

   407         rsmd.setCurrency(col, true);

   408         assertTrue(rsmd.isCurrency(col));

   409         rsmd.setNullable(col, ResultSetMetaData.columnNoNulls);

   410         assertTrue(rsmd.isNullable(col) == ResultSetMetaData.columnNoNulls);

   411         rsmd.setPrecision(col, 2);

   412         assertTrue(rsmd.getPrecision(col) == 2);

   413         rsmd.setScale(col, 2);

   414         assertTrue(rsmd.getScale(col) == 2);

   415         rsmd.setSchemaName(col, "GOTHAM");

   416         assertTrue(rsmd.getSchemaName(col).equals("GOTHAM"));

   417         rsmd.setSearchable(col, false);

   418         assertFalse(rsmd.isSearchable(col));

   419         rsmd.setSigned(col, false);

   420         assertFalse(rsmd.isSigned(col));

   421         rsmd.setTableName(col, "SUPERHEROS");

   422         assertTrue(rsmd.getTableName(col).equals("SUPERHEROS"));

   423         rsmd.isReadOnly(col);

   424         rsmd.isDefinitelyWritable(col);

   425         rsmd.isWritable(col);

   426 

   427     }

   428 

   429     /*

   430      * Validate that the proper values are accepted by setNullable

   431      */

   432     @Test(dataProvider = "validSetNullableValues")

   433     public void test38(Integer val) throws Exception {

   434         rsmd.setNullable(1, val);

   435     }

   436 

   437     /*

   438      * Validate that the correct type is returned for the column

   439      */

   440     @Test(dataProvider = "jdbcTypes")

   441     public void test39(Integer type) throws Exception {

   442         rsmd.setColumnType(1, type);

   443         assertTrue(type == rsmd.getColumnType(1));

   444     }

   445 

   446     /*

   447      * Validate that the correct value is returned from the isXXX methods

   448      */

   449     @Test(dataProvider = "trueFalse")

   450     public void test40(Boolean b) throws Exception {

   451         rsmd.setAutoIncrement(1, b);

   452         rsmd.setCaseSensitive(1, b);

   453         rsmd.setCurrency(1, b);

   454         rsmd.setSearchable(1, b);

   455         rsmd.setSigned(1, b);

   456         assertTrue(rsmd.isAutoIncrement(1) == b);

   457         assertTrue(rsmd.isCaseSensitive(1) == b);

   458         assertTrue(rsmd.isCurrency(1) == b);

   459         assertTrue(rsmd.isSearchable(1) == b);

   460         assertTrue(rsmd.isSigned(1) == b);

   461     }

   462 

   463     /*

   464      * Validate isWrapperFor and unwrap work correctly

   465      */

   466     @SuppressWarnings("unchecked")

   467     @Test

   468     public void test99() throws Exception {

   469         RowSetMetaData rsmd1 = rsmd;

   470         ResultSetMetaData rsmd2 = rsmd;

   471         Class clzz = rsmd.getClass();

   472         assertTrue(rsmd1.isWrapperFor(clzz));

   473         assertTrue(rsmd2.isWrapperFor(clzz));

   474         RowSetMetaDataImpl rsmdi = (RowSetMetaDataImpl) rsmd2.unwrap(clzz);

   475 

   476         // False should be returned

   477         assertFalse(rsmd1.isWrapperFor(this.getClass()));

   478         assertFalse(rsmd2.isWrapperFor(this.getClass()));

   479     }

   480 

   481     /*

   482      * DataProvider used to provide Date which are not valid and are used

   483      * to validate that an IllegalArgumentException will be thrown from the

   484      * valueOf method

   485      */

   486     @DataProvider(name = "validSetNullableValues")

   487     private Object[][] validSetNullableValues() {

   488         return new Object[][]{

   489             {ResultSetMetaData.columnNoNulls},

   490             {ResultSetMetaData.columnNullable},

   491             {ResultSetMetaData.columnNullableUnknown}

   492         };

   493     }

   494 

   495     /*

   496      * DataProvider used to provide column indexes that are out of range so that

   497      * SQLException is thrown

   498      */

   499     @DataProvider(name = "invalidColumnRanges")

   500     private Object[][] invalidColumnRanges() {

   501         return new Object[][]{

   502             {-1},

   503             {0},

   504             {MAX_COLUMNS + 1}

   505         };

   506     }

   507 

   508     /*

   509      * DataProvider used to provide the valid column ranges for the

   510      * RowSetMetaDataImpl object

   511      */

   512     @DataProvider(name = "columnRanges")

   513     private Object[][] columnRanges() {

   514         Object[][] o = new Object[MAX_COLUMNS][1];

   515         for (int i = 1; i <= MAX_COLUMNS; i++) {

   516             o[i - 1][0] = i;

   517         }

   518         return o;

   519     }

   520 

   521     /*

   522      * DataProvider used to specify the value to set via setColumnType and

   523      * the expected value to be returned from getColumnClassName

   524      */

   525     @DataProvider(name = "columnClassNames")

   526     private Object[][] columnClassNames() {

   527         return new Object[][]{

   528             {Types.CHAR, "java.lang.String"},

   529             {Types.NCHAR, "java.lang.String"},

   530             {Types.VARCHAR, "java.lang.String"},

   531             {Types.NVARCHAR, "java.lang.String"},

   532             {Types.LONGVARCHAR, "java.lang.String"},

   533             {Types.LONGNVARCHAR, "java.lang.String"},

   534             {Types.NUMERIC, "java.math.BigDecimal"},

   535             {Types.DECIMAL, "java.math.BigDecimal"},

   536             {Types.BIT, "java.lang.Boolean"},

   537             {Types.TINYINT, "java.lang.Byte"},

   538             {Types.SMALLINT, "java.lang.Short"},

   539             {Types.INTEGER, "java.lang.Integer"},

   540             {Types.FLOAT, "java.lang.Double"},

   541             {Types.DOUBLE, "java.lang.Double"},

   542             {Types.BINARY, "byte[]"},

   543             {Types.VARBINARY, "byte[]"},

   544             {Types.LONGVARBINARY, "byte[]"},

   545             {Types.DATE, "java.sql.Date"},

   546             {Types.TIME, "java.sql.Time"},

   547             {Types.TIMESTAMP, "java.sql.Timestamp"},

   548             {Types.CLOB, "java.sql.Clob"},

   549             {Types.BLOB, "java.sql.Blob"}

   550 

   551         };

   552 

   553     }

   554 

   555 }