1 /*
2  * Copyright (C) 2007 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package libcore.java.sql;
18 
19 import java.sql.ResultSet;
20 import java.sql.ResultSetMetaData;
21 import java.sql.SQLException;
22 import java.sql.Statement;
23 import java.sql.Types;
24 
25 public final class OldResultSetMetaDataTest extends OldSQLTest {
26 
27     ResultSetMetaData rsmd = null;
28     Statement st = null;
29     ResultSet rs = null;
30 
31     @Override
setUp()32     public void setUp() throws Exception {
33         super.setUp();
34         try {
35             conn.setAutoCommit(false);
36             assertFalse(conn.getAutoCommit());
37             String query = "select * from zoo";
38             st = conn.createStatement();
39             st.execute(query);
40             rs = st.getResultSet();
41             rsmd = rs.getMetaData();
42         } catch (SQLException e) {
43             fail("Couldn't get ResultSetMetaData object");
44         }
45     }
46 
47     @Override
tearDown()48     public void tearDown() throws SQLException {
49         try {
50             rs.close();
51             st.close();
52         } catch (SQLException e) {
53             fail("Couldn't close Statement object");
54         }
55         super.tearDown();
56     }
57 
58     // not supported
testGetCatalogName()59     public void testGetCatalogName() throws SQLException {
60         try {
61             assertNotNull(rsmd.getCatalogName(1));
62         } catch (SQLException e) {
63             fail("SQLException is thrown: " + e.getMessage());
64         }
65 
66         try {
67             conn.close();
68             rsmd.getCatalogName(0);
69             fail("Exception expected");
70         } catch (SQLException e) {
71             //ok
72         }
73     }
74 
testGetColumnClassName()75     public void testGetColumnClassName() {
76         try {
77             assertNotNull(rsmd);
78             assertEquals(Short.class.getName(), rsmd.getColumnClassName(1));
79             assertEquals(String.class.getName(), rsmd.getColumnClassName(2));
80             assertEquals(String.class.getName(), rsmd.getColumnClassName(3));
81         } catch (SQLException e) {
82             fail("SQLException is thrown: " + e.getMessage());
83         }
84 
85         try {
86             String name  = rsmd.getColumnClassName(0);
87             assertNull(name);
88         } catch (SQLException e) {
89             fail("SQLException is thrown");
90         }
91 
92         try {
93             String name  = rsmd.getColumnClassName(4);
94             assertNull(name);
95         } catch (SQLException e) {
96             fail("SQLException is thrown");
97         }
98     }
99 
100     // SQLException checking test fails
testGetColumnCount()101     public void testGetColumnCount() {
102         try {
103             assertEquals(3, rsmd.getColumnCount());
104         } catch (SQLException e) {
105             fail("SQLException is thrown: " + e.getMessage());
106         }
107 
108         try {
109             rs.close();
110             rsmd.getColumnCount();
111             fail("Exception expected");
112         } catch (SQLException e) {
113             //ok
114         }
115 
116     }
117 
118     // Column label has format TABLE.COLUMN expected: COLUMN
testGetColumnLabel()119     public void testGetColumnLabel() {
120         String[] labels = { "id", "name", "family" };
121         try {
122             for (int i = 0; i < rsmd.getColumnCount(); i++) {
123                 String label = rsmd.getColumnLabel(i + 1);
124                 assertTrue("expected "+labels[i] + "got "+label,labels[i].contains(label));
125             }
126         } catch (SQLException e) {
127             fail("SQLException is thrown: " + e.getMessage());
128         }
129 
130         try {
131             String label = rsmd.getColumnLabel(0);
132             fail("SQLException expected");
133         } catch (SQLException e) {
134             //ok
135         }
136 
137         try {
138             String label = rsmd.getColumnLabel(5);
139             fail("SQLException expected");
140         } catch (SQLException e) {
141             //ok
142         }
143     }
144 
145     // Column label has format TABLE.COLUMN expected: COLUMN
testGetColumnName()146     public void testGetColumnName() {
147         String[] labels = { "id", "name", "family" };
148         try {
149             for (int i = 0; i < rsmd.getColumnCount(); i++) {
150                 String name = rsmd.getColumnName(i + 1);
151                 assertEquals(labels[i], name);
152             }
153         } catch (SQLException e) {
154             fail("SQLException is thrown: " + e.getMessage());
155         }
156 
157         try {
158             String label = rsmd.getColumnName(0);
159             fail("SQLException is not thrown");
160         } catch (SQLException e) {
161             //ok
162         }
163 
164         try {
165             String label = rsmd.getColumnName(5);
166             fail("SQLException is not thrown");
167         } catch (SQLException e) {
168             //ok
169         }
170     }
171 
172     /**
173      * For extensive tests see: ResultSetGetterTest.testGetMetaData
174      */
testGetColumnType()175     public void testGetColumnType() {
176         int[] types = { Types.SMALLINT, Types.VARCHAR, Types.VARCHAR};
177         try {
178             for (int i = 0; i < rsmd.getColumnCount(); i++) {
179                 int type = rsmd.getColumnType(i + 1);
180                 assertEquals(types[i], type);
181             }
182         } catch (SQLException e) {
183             fail("SQLException is thrown: " + e.getMessage());
184         }
185 
186         try {
187             rsmd.getColumnType(0);
188             fail("SQLException is not thrown");
189         } catch (SQLException e) {
190             // expected
191         }
192         try {
193             rsmd.getColumnType(5);
194             fail("SQLException is not thrown");
195         } catch (SQLException e) {
196             // expected
197         }
198     }
199 
200     /**
201      * for extensive tests see: ResultSetGetterTest.testGetMetaData
202      */
testGetColumnTypeName()203     public void testGetColumnTypeName() {
204         try {
205             assertTrue("smallint".equalsIgnoreCase(rsmd.getColumnTypeName(1)));
206             assertTrue("varchar".equalsIgnoreCase(rsmd.getColumnTypeName(2)));
207             assertTrue("varchar".equalsIgnoreCase(rsmd.getColumnTypeName(3)));
208         } catch (SQLException e) {
209             fail("SQLException is thrown: " + e.getMessage());
210         }
211 
212         try {
213             rsmd.getColumnTypeName(0);
214             fail("SQLException is not thrown");
215         } catch (SQLException e) {
216             // expected
217         }
218         try {
219             rsmd.getColumnTypeName(5);
220             fail("SQLException is not thrown");
221         } catch (SQLException e) {
222             // expected
223         }
224     }
225 
226     // For int = 0, exception expected
testGetTableName()227     public void testGetTableName() throws SQLException {
228         try {
229             assertEquals("zoo", rsmd.getTableName(1));
230         } catch (SQLException e) {
231             fail("SQLException is thrown: " + e.getMessage());
232         }
233         Statement st1 = null;
234         ResultSet rs1 = null;
235         try {
236 
237             String create = "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));";
238             String insert1 = "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');";
239             String insert2 = "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');";
240             String query = "select name, animal_id from hutch, zoo where zoo.id = 1" ;
241             st1 = conn.createStatement();
242             st1.executeUpdate(create);
243             st1.executeUpdate(insert1);
244             st1.executeUpdate(insert2);
245 
246             rs1 = st1.executeQuery(query);
247             assertNotNull(rs1);
248             ResultSetMetaData rsmd1 = rs1.getMetaData();
249             assertEquals("zoo", rsmd1.getTableName(1));
250             assertEquals("hutch", rsmd1.getTableName(2));
251         } catch (SQLException e) {
252             fail("SQLException is thrown: " + e.getMessage());
253         } finally {
254             try {
255                 if (rs1 != null) rs1.close();
256                 if (st1 != null) {
257                     st1.executeUpdate("drop table if exists hutch");
258                     st1.close();
259                 }
260             } catch (SQLException sqle) {
261             }
262         }
263         //Exception Text
264         try {
265             String name = rsmd.getTableName(0);
266             fail("SQLException Expected");
267         } catch (SQLException e) {
268             // ok
269         }
270     }
271 
272     // not supported
testGetPrecision()273     public void testGetPrecision() throws SQLException {
274         Statement st2 = null;
275         Statement st3 = null;
276         ResultSetMetaData rsmd2 = null;
277         try {
278         int precisionNum = 10;
279         int scale = 3;
280         int precicisionReal = 10;
281         String createTable = "create table DecimalNumbers ( valueDouble DOUBLE,"+
282         "valueFloat FLOAT , scaleTest NUMERIC("+precisionNum+","+scale+"),"+
283         " valueReal REAL("+precicisionReal+")  );";
284         String insert = "insert into DecimalNumbers values (1.5, 20.55, 30.666, 100000);";
285         String select = "select * from DecimalNumbers;";
286         st2 = conn.createStatement();
287         st2.executeUpdate(createTable);
288         st2.executeUpdate(insert);
289 
290         st2.close();
291 
292         st3 = conn.createStatement();
293         rs = st3.executeQuery(select);
294         assertTrue(rs.next());
295         rsmd2 = rs.getMetaData();
296 
297         assertNotNull(rsmd2);
298         assertEquals(precicisionReal, rsmd2.getPrecision(4));
299         assertEquals(precisionNum,rsmd2.getPrecision(3));
300         assertTrue(rsmd2.getPrecision(2) > 0);
301         assertTrue(rsmd2.getPrecision(1) > 0);
302 
303         // non numeric field
304         try {
305             rsmd.getPrecision(3);
306         } catch (SQLException e1) {
307             System.out.println("ResultSetMetaDataTest.testGetPrecision()"+e1.getMessage());
308             e1.printStackTrace();
309         }
310 
311 
312         try {
313             rsmd.getPrecision(0);
314             fail("SQLException is not thrown");
315         } catch (SQLException e) {
316             // expected
317         }
318         try {
319             rsmd.getPrecision(5);
320             fail("SQLException is not thrown");
321         } catch (SQLException e) {
322             // expected
323         }
324 
325         try {
326             rs.close();
327             rsmd.getPrecision(1);
328             fail("Exception expected");
329         } catch (SQLException e) {
330             //ok
331         }
332         } finally  {
333             if (st2 != null) st2.close();
334             if (st3 != null) st3.close();
335         }
336     }
337 
338     /**
339      * Always returns 0, exception tests fail no positive test case for
340      * black-box test possible: no default value indicated.
341      *
342      * Not supported
343      */
testGetScale()344     public void testGetScale() throws SQLException {
345         try {
346         int scale = 3;
347         String createTable = "create table DecimalNumbers ( valueDouble DOUBLE,"+
348         "valueFloat FLOAT , scaleTest NUMERIC(10,"+scale+")  );";
349         String insert = "insert into DecimalNumbers values (1.5, 20.55, 30.666);";
350         String select = "select * from DecimalNumbers;";
351 
352         Statement st = conn.createStatement();
353         st.executeUpdate(createTable);
354         st.executeUpdate(insert);
355 
356         rs = st.executeQuery(select);
357         ResultSetMetaData rsmd2 = rs.getMetaData();
358 
359         assertNotNull(rsmd2);
360         assertEquals(scale,rsmd2.getScale(3));
361         assertTrue(rsmd2.getScale(1) > 0);
362         assertTrue(rsmd2.getScale(2) > 0);
363 
364         try {
365             rsmd.getScale(0);
366             fail("SQLException is not thrown");
367         } catch (SQLException e) {
368             // expected
369         }
370         try {
371             rsmd.getScale(5);
372             fail("SQLException is not thrown");
373         } catch (SQLException e) {
374             // expected
375         }
376 
377 
378         try {
379             conn.close();
380             rsmd.getScale(1);
381             fail("Exception expected");
382         } catch (SQLException e) {
383             //ok
384         }
385         } finally  {
386             st.cancel();
387         }
388     }
389 
390     // not supported
testGetSchema()391     public void testGetSchema() {
392         try {
393             assertNull("Functionality is now supported. Change test",rsmd.getSchemaName(2));
394         } catch (SQLException e1) {
395             fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
396             e1.printStackTrace();
397         }
398 
399         try {
400             rsmd.getSchemaName(0);
401             fail("SQLException is not thrown");
402         } catch (SQLException e) {
403             // expected
404         }
405         try {
406             rsmd.getSchemaName(5);
407             fail("SQLException is not thrown");
408         } catch (SQLException e) {
409             // expected
410         }
411 
412         try {
413             conn.close();
414             rsmd.getSchemaName(2);
415             fail("Exception expected");
416         } catch (SQLException e) {
417             //ok
418         }
419 
420     }
421 
422     /**
423      * Tests fail: always returns false, failing statements commented out.
424      * Feature only partially implemented.Missing: Test positive case
425      *
426      * Not supported.
427      */
testisAutoIncrement()428     public void testisAutoIncrement() {
429         try {
430             assertFalse(rsmd.isAutoIncrement(1));
431         } catch (SQLException e1) {
432             fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
433             e1.printStackTrace();
434         }
435 
436         /*
437         // Exception testing
438 
439         try {
440             rsmd.isAutoIncrement(0);
441             fail("SQLException is not thrown");
442         } catch (SQLException e) {
443             // expected
444         }
445         try {
446             rsmd.isAutoIncrement(5);
447             fail("SQLException is not thrown");
448         } catch (SQLException e) {
449             // expected
450         }
451         */
452 
453         try {
454             conn.close();
455             rsmd.getSchemaName(2);
456             fail("Exception expected");
457         } catch (SQLException e) {
458             //ok
459         }
460 
461     }
462 
463     // not supported
testIsCaseSensitive()464     public void testIsCaseSensitive() {
465         try {
466             assertFalse(rsmd.isCaseSensitive(1));
467             assertFalse(rsmd.isCaseSensitive(2));
468             assertFalse(rsmd.isCaseSensitive(3));
469         } catch (SQLException e1) {
470             fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
471             e1.printStackTrace();
472         }
473 
474         /*
475         // Exception testing
476 
477         try {
478             rsmd.isCaseSensitive(0);
479             fail("SQLException is not thrown");
480         } catch (SQLException e) {
481             // expected
482         }
483         try {
484             rsmd.isCaseSensitive(5);
485             fail("SQLException is not thrown");
486         } catch (SQLException e) {
487             // expected
488         }
489         */
490 
491         try {
492             conn.close();
493             rsmd.isCaseSensitive(1);
494             fail("Exception expected");
495         } catch (SQLException e) {
496             //ok
497         }
498     }
499 
500     /**
501      * Tests fail: always returns false. Exceptions and tests non Numeric fields
502      * fail, failing statements commented out. Feature only partially
503      * implemented. May be an optional feature.
504      *
505      * Not supported.
506      */
testIsCurrency()507     public void testIsCurrency() {
508         try {
509             assertFalse(rsmd.isCurrency(1));
510         } catch (SQLException e1) {
511             fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
512             e1.printStackTrace();
513         }
514 
515         // Exception testing
516         try {
517             rsmd.isCurrency(0);
518             fail("SQLException is not thrown");
519         } catch (SQLException e) {
520             // expected
521         }
522         try {
523             rsmd.isCurrency(5);
524             fail("SQLException is not thrown");
525         } catch (SQLException e) {
526             // expected
527         }
528 
529         try {
530             rs.close();
531             rsmd.isCurrency(1);
532             fail("Exception expected");
533         } catch (SQLException e) {
534             //ok
535         }
536     }
537 
538     // not supported
testIsDefinitlyWritable()539     public void testIsDefinitlyWritable() {
540         try {
541             assertTrue(rsmd.isDefinitelyWritable(1));
542         } catch (SQLException e1) {
543             fail("ResultSetMetaDataTest.testisDefinitelyWritable()"
544                     + e1.getMessage());
545             e1.printStackTrace();
546         }
547 
548         // Exception testing
549 
550         try {
551             rsmd.isDefinitelyWritable(0);
552             fail("SQLException is not thrown");
553         } catch (SQLException e) {
554             // expected
555         }
556         try {
557             rsmd.isDefinitelyWritable(5);
558             fail("SQLException is not thrown");
559         } catch (SQLException e) {
560             // expected
561         }
562     }
563 
564     /**
565      * Tests fail: always returns ResultSetMetaData.columnNullableUnknown.
566      * Exceptions fail, failing statements commented out. Feature only
567      * partially implemented. May be an optional feature.
568      *
569      * Not supported.
570      */
testIsNullable()571     public void testIsNullable() {
572         try {
573             assertEquals(ResultSetMetaData.columnNullable, rsmd
574                     .isNullable(1));
575             assertEquals(ResultSetMetaData.columnNullable, rsmd
576                     .isNullable(2));
577             assertEquals(ResultSetMetaData.columnNullable, rsmd
578                     .isNullable(3));
579         } catch (SQLException e1) {
580             fail("ResultSetMetaDataTest.isNullable()" + e1.getMessage());
581             e1.printStackTrace();
582         }
583 
584         /*
585         // Exception testing
586 
587         try {
588             rsmd.isNullable(0);
589             fail("SQLException is not thrown");
590         } catch (SQLException e) {
591             // expected
592         }
593         try {
594             rsmd.isNullable(5);
595             fail("SQLException is not thrown");
596         } catch (SQLException e) {
597             // expected
598         }
599         */
600 
601     }
602 
603     /**
604      * Cannot know from blackbox test if readonly or writable. Exceptions fail,
605      * Feature only partially implemented.
606      */
testIsReadOnly()607     public void testIsReadOnly() {
608         try {
609             assertFalse(rsmd.isReadOnly(1));
610         } catch (SQLException e1) {
611             fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
612             e1.printStackTrace();
613         }
614 
615         // Exception testing
616 
617         try {
618             rsmd.isReadOnly(0);
619             fail("SQLException is not thrown");
620         } catch (SQLException e) {
621             // expected
622         }
623     }
624 
625     /**
626      * Tests fail: always returns false. Exceptions fail, Feature only partially
627      * implemented. Missing: test for searchable field.
628      */
testIsSearchable()629     public void testIsSearchable() {
630         try {
631             assertTrue(rsmd.isSearchable(1));
632             assertTrue(rsmd.isSearchable(2));
633             assertTrue(rsmd.isSearchable(3));
634         } catch (SQLException e1) {
635             fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
636             e1.printStackTrace();
637         }
638 
639         // Exception testing
640 
641         try {
642             rsmd.isSearchable(0);
643             fail("SQLException is not thrown");
644         } catch (SQLException e) {
645             // expected
646         }
647     }
648 
649     /**
650      * Tests fail: always returns false. Exceptions and tests on non numeric
651      * fields fail, Feature only partially implemented. Missing: test positive
652      * result
653      */
testIsSigned()654     public void testIsSigned() {
655         try {
656             assertFalse(rsmd.isSigned(1));
657         } catch (SQLException e1) {
658             fail("ResultSetMetaDataTest.isSigned" + e1.getMessage());
659             e1.printStackTrace();
660         }
661 
662         // Exception testing
663 
664         try {
665             rsmd.isSigned(0);
666             fail("SQLException is not thrown");
667         } catch (SQLException e) {
668             // expected
669         }
670     }
671 
672     /**
673      * Analogous to is Readonly.  Exceptions and tests on non numeric fields
674      * fail, Failing statements commented out. Feature only partially
675      * implemented.
676      */
testIsWritable()677     public void testIsWritable() {
678         try {
679             assertTrue(rsmd.isWritable(1));
680             assertTrue(rsmd.isWritable(2));
681             assertTrue(rsmd.isWritable(3));
682         } catch (SQLException e1) {
683             fail("ResultSetMetaDataTest.isWritable" + e1.getMessage());
684             e1.printStackTrace();
685         }
686 
687         // Exception testing
688 
689         try {
690             rsmd.isWritable(0);
691             fail("SQLException is not thrown");
692         } catch (SQLException e) {
693             // expected
694         }
695     }
696 
697 
698     /**
699      * Tests fail. always returns 0. Missing case where display size greater than 0
700      */
testGetColumnDisplaySize()701     public void testGetColumnDisplaySize() {
702         try {
703             for (int i = 0; i < rsmd.getColumnCount(); i++) {
704                 int size = rsmd.getColumnDisplaySize(i + 1);
705                 assertTrue(size > 0);
706             }
707         } catch (SQLException e) {
708             fail("SQLException is thrown: " + e.getMessage());
709         }
710 
711         // Exception testing
712 
713         try {
714             rsmd.getColumnDisplaySize(0);
715             fail("SQLException is not thrown");
716         } catch (SQLException e) {
717             // expected
718         }
719         try {
720             rsmd.getColumnDisplaySize(5);
721             fail("SQLException is not thrown");
722         } catch (SQLException e) {
723             // expected
724         }
725     }
726 
727 }
728