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
setUpMethod()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)
test(Integer col)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)
test01(Integer col)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)
test02(Integer col)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)
test03(Integer col)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)
test04(Integer col)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)
test05(Integer col)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)
test06(Integer col)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)
test07(Integer col)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)
test08(Integer col)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)
test09(Integer col)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)
test10(Integer col)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)
test11(Integer col)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)
test12(Integer col)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)
test13(Integer col)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)
test14(Integer col)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)
test15(Integer col)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)
test16(Integer col)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)
test17(Integer col)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)
test18(Integer col)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)
test19(Integer col)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)
test20(Integer col)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)
test21(Integer col)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)
test22(Integer col)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)
test23(Integer col)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)
test24(Integer col)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)
test25(Integer col)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)
test26(Integer col)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)
test27(Integer col)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)
test28(Integer col)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)
test29(Integer col)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)
test30(Integer col)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)
test31(Integer col)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)
test32(Integer col)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)
test33(Integer col)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)
test34(Integer col)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)
test35(Integer col)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")
test36(Integer type, String name)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")
test37(Integer col)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")
test38(Integer val)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")
test39(Integer type)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")
test40(Boolean b)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
test99()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")
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")
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")
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")
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 }
556