1 /*
2  * Copyright (C) 2008 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 tests.java.sql;
18 
19 import dalvik.annotation.KnownFailure;
20 
21 import junit.extensions.TestSetup;
22 import junit.framework.Test;
23 import junit.framework.TestCase;
24 import junit.framework.TestSuite;
25 
26 import tests.support.DatabaseCreator;
27 import tests.support.Support_SQL;
28 
29 import java.sql.Connection;
30 import java.sql.DatabaseMetaData;
31 import java.sql.ResultSet;
32 import java.sql.ResultSetMetaData;
33 import java.sql.SQLException;
34 import java.sql.Statement;
35 import java.util.HashSet;
36 
37 public class DatabaseMetaDataNotSupportedTest extends TestCase {
38 
39     private static String VIEW_NAME = "myView";
40 
41     private static String CREATE_VIEW_QUERY = "CREATE VIEW " + VIEW_NAME
42             + " AS SELECT * FROM " + DatabaseCreator.TEST_TABLE1;
43 
44     private static String DROP_VIEW_QUERY = "DROP VIEW " + VIEW_NAME;
45 
46     protected static Connection conn;
47 
48     protected static DatabaseMetaData meta;
49 
50     protected static Statement statement;
51 
52     protected static Statement statementForward;
53 
54     private static int id = 1;
55 
setUp()56     public void setUp() throws Exception {
57         super.setUp();
58         Support_SQL.loadDriver();
59         try {
60             conn = Support_SQL.getConnection();
61             meta = conn.getMetaData();
62             statement = conn.createStatement();
63             createTestTables();
64         } catch (SQLException e) {
65             System.out.println("Error in test setup: "+e.getMessage());
66         }
67     }
68 
tearDown()69     public void tearDown() throws Exception {
70         try {
71             conn = Support_SQL.getConnection();
72             meta = conn.getMetaData();
73             statement = conn.createStatement();
74             deleteTestTables();
75         } catch (SQLException e) {
76             System.out.println("Error in teardown: "+e.getMessage());
77         } finally {
78             try {
79                 conn.close();
80             } catch (SQLException e) {
81             }
82         }
83         super.tearDown();
84     }
85 
createTestTables()86     private void createTestTables() {
87         try {
88             ResultSet userTab = meta.getTables(null, null, null, null);
89             while (userTab.next()) {
90                 String tableName = userTab.getString("TABLE_NAME");
91                 if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
92                     statement.execute(DatabaseCreator.DROP_TABLE1);
93                 } else if (tableName
94                         .equals(DatabaseCreator.TEST_TABLE3)) {
95                     statement.execute(DatabaseCreator.DROP_TABLE3);
96                 } else if (tableName.equals(VIEW_NAME)) {
97                     statement.execute(DROP_VIEW_QUERY);
98                 }
99             }
100             userTab.close();
101             statement.execute(DatabaseCreator.CREATE_TABLE3);
102             statement.execute(DatabaseCreator.CREATE_TABLE1);
103             statement.execute(CREATE_VIEW_QUERY);
104             meta = conn.getMetaData();
105         } catch (SQLException e) {
106             fail("Unexpected SQLException " + e.toString());
107         }
108     }
109 
deleteTestTables()110     private void deleteTestTables() {
111         try {
112             statement.execute(DatabaseCreator.DROP_TABLE1);
113             statement.execute(DatabaseCreator.DROP_TABLE3);
114             statement.execute(DROP_VIEW_QUERY);
115         } catch (SQLException e) {
116             fail("Unexpected SQLException " + e.toString());
117         } finally {
118             try {
119             if (! conn.isClosed()) {
120                 conn.close();
121             }
122             } catch (SQLException e) {
123 
124             }
125         }
126     }
127 
128     /**
129      * java.sql.DatabaseMetaData#allProceduresAreCallable()
130      */
test_allProceduresAreCallable()131     public void test_allProceduresAreCallable() throws SQLException {
132         assertFalse(meta.allProceduresAreCallable());
133     }
134 
135     @KnownFailure("Not supported ops applied")
test_allTablesAreSelectable()136     public void test_allTablesAreSelectable() throws SQLException {
137         // grant SELECT privileges
138 
139         String query = "GRANT CREATE, SELECT ON " + DatabaseCreator.TEST_TABLE1
140                 + " TO " + Support_SQL.sqlUser;
141         statement.execute(query);
142         Connection userConn = Support_SQL.getConnection(Support_SQL.sqlUrl,
143                 Support_SQL.sqlUser, Support_SQL.sqlUser);
144         DatabaseMetaData userMeta = userConn.getMetaData();
145         ResultSet userTab = userMeta.getTables(null, null, null, null);
146 
147         assertTrue("Tables are not obtained", userTab.next());
148         assertEquals("Incorrect name of obtained table",
149                 DatabaseCreator.TEST_TABLE1.toLowerCase(), userTab.getString(
150                         "TABLE_NAME").toLowerCase());
151         assertTrue("Not all of obtained tables are selectable", userMeta
152                 .allTablesAreSelectable());
153 
154         userTab.close();
155         // revoke SELECT privileges
156         query = "REVOKE SELECT ON " + DatabaseCreator.TEST_TABLE1 + " FROM "
157                 + Support_SQL.sqlUser;
158         statement.execute(query);
159 
160         userTab = userMeta.getTables(null, null, null, null);
161 
162         assertTrue("Tables are not obtained", userTab.next());
163         assertEquals("Incorrect name of obtained table",
164                 DatabaseCreator.TEST_TABLE1.toLowerCase(), userTab.getString(
165                         "TABLE_NAME").toLowerCase());
166         assertFalse("No SELECT privileges", userMeta.allTablesAreSelectable());
167 
168         userTab.close();
169         // revoke CREATE privileges
170         query = "REVOKE CREATE ON " + DatabaseCreator.TEST_TABLE1 + " FROM "
171                 + Support_SQL.sqlUser;
172         statement.execute(query);
173         userConn.close();
174     }
175 
176     /**
177      * java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()
178      */
test_dataDefinitionCausesTransactionCommit()179     public void test_dataDefinitionCausesTransactionCommit() throws SQLException {
180         // NOT_FEASIBLE: SQLITE does not implement this functionality
181     }
182 
183     /**
184      * java.sql.DatabaseMetaData#dataDefinitionIgnoredInTransactions()
185      */
test_dataDefinitionIgnoredInTransactions()186     public void test_dataDefinitionIgnoredInTransactions() throws SQLException {
187         assertFalse(meta.dataDefinitionIgnoredInTransactions());
188     }
189 
190     /**
191      * java.sql.DatabaseMetaData#deletesAreDetected(int)
192      */
test_deletesAreDetectedI()193     public void test_deletesAreDetectedI() throws SQLException {
194         assertFalse(meta.deletesAreDetected(0));
195     }
196 
197     /**
198      * java.sql.DatabaseMetaData#doesMaxRowSizeIncludeBlobs()
199      */
200     @KnownFailure("not supported")
test_doesMaxRowSizeIncludeBlobs()201     public void test_doesMaxRowSizeIncludeBlobs() throws SQLException {
202         assertFalse(meta.doesMaxRowSizeIncludeBlobs());
203     }
204 
205     /**
206      * java.sql.DatabaseMetaData #getAttributes(java.lang.String,
207      *        java.lang.String, java.lang.String, java.lang.String)
208      */
test_getAttributesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()209     public void test_getAttributesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
210             throws SQLException {
211     }
212 
test_getCatalogs()213     public void test_getCatalogs() throws SQLException {
214         ResultSet rs = meta.getCatalogs();
215         // NOT_FEASIBLE getCatalog is not supported
216 //        while (rs.next()) {
217             //if (rs.getString("TABLE_CAT").equalsIgnoreCase(conn.getCatalog())) {
218             //    rs.close();
219             //    return;
220             //}
221 //        }
222         rs.close();
223 //        fail("Incorrect a set of catalogs");
224     }
225 
226     /**
227      * java.sql.DatabaseMetaData#getCatalogSeparator()
228      */
test_getCatalogSeparator()229     public void test_getCatalogSeparator() throws SQLException {
230         assertTrue("Incorrect catalog separator", "".equals(meta
231                 .getCatalogSeparator().trim()));
232     }
233 
234     /**
235      * java.sql.DatabaseMetaData#getCatalogTerm()
236      */
test_getCatalogTerm()237     public void test_getCatalogTerm() throws SQLException {
238         assertTrue("Incorrect catalog term", "".equals(meta
239                 .getCatalogSeparator().trim()));
240     }
241 
242     /**
243      * java.sql.DatabaseMetaData#getExtraNameCharacters()
244      */
test_getExtraNameCharacters()245     public void test_getExtraNameCharacters() throws SQLException {
246         assertNotNull("Incorrect extra name characters", meta
247                 .getExtraNameCharacters());
248 
249     }
250 
251     @KnownFailure("not supported")
test_getIndexInfoLjava_lang_StringLjava_lang_StringLjava_lang_StringZZ()252     public void test_getIndexInfoLjava_lang_StringLjava_lang_StringLjava_lang_StringZZ()
253             throws SQLException {
254         boolean unique = false;
255         ResultSet rs = meta.getIndexInfo(conn.getCatalog(), null,
256                 DatabaseCreator.TEST_TABLE1, unique, true);
257         ResultSetMetaData rsmd = rs.getMetaData();
258         assertTrue("Rows do not obtained", rs.next());
259         int col = rsmd.getColumnCount();
260         assertEquals("Incorrect number of columns", 13, col);
261         String[] columnNames = { "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME",
262                 "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME", "TYPE",
263                 "ORDINAL_POSITION", "COLUMN_NAME", "ASC_OR_DESC",
264                 "CARDINALITY", "PAGES", "FILTER_CONDITION" };
265         for (int c = 1; c <= col; ++c) {
266             assertEquals("Incorrect column name", columnNames[c - 1], rsmd
267                     .getColumnName(c));
268         }
269 
270         assertEquals("Incorrect table catalog", conn.getCatalog(), rs
271                 .getString("TABLE_CAT"));
272         assertEquals("Incorrect table schema", null, rs
273                 .getString("TABLE_SCHEM"));
274         assertEquals("Incorrect table name", DatabaseCreator.TEST_TABLE1, rs
275                 .getString("TABLE_NAME"));
276         assertEquals("Incorrect state of uniquess", unique, rs
277                 .getBoolean("NON_UNIQUE"));
278         assertEquals("Incorrect index catalog", "", rs
279                 .getString("INDEX_QUALIFIER"));
280         assertEquals("Incorrect index name", "primary", rs.getString(
281                 "INDEX_NAME").toLowerCase());
282         assertEquals("Incorrect index type", DatabaseMetaData.tableIndexOther,
283                 rs.getShort("TYPE"));
284         assertEquals("Incorrect column sequence number within index", 1, rs
285                 .getShort("ORDINAL_POSITION"));
286         assertEquals("Incorrect column name", "id", rs.getString("COLUMN_NAME"));
287         assertEquals("Incorrect column sort sequence", "a", rs.getString(
288                 "ASC_OR_DESC").toLowerCase());
289         assertEquals("Incorrect cardinality", 1, rs.getInt("CARDINALITY"));
290         assertEquals("Incorrect value of pages", 0, rs.getInt("PAGES"));
291         assertEquals("Incorrect filter condition", null, rs
292                 .getString("FILTER_CONDITION"));
293         rs.close();
294     }
295 
296     @KnownFailure("not supported. Privileges are not supported.")
test_getColumnPrivilegesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()297      public void test_getColumnPrivilegesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
298             throws SQLException {
299         ResultSet rs = meta.getColumnPrivileges(conn.getCatalog(), null,
300                 DatabaseCreator.TEST_TABLE1, "id");
301         ResultSetMetaData rsmd = rs.getMetaData();
302         assertFalse("Rows are obtained", rs.next());
303         rs.close();
304 
305         String query = "GRANT REFERENCES(id) ON " + DatabaseCreator.TEST_TABLE1
306                 + " TO " + Support_SQL.sqlLogin;
307         statement.execute(query);
308 
309         rs = meta.getColumnPrivileges(conn.getCatalog(), null,
310                 DatabaseCreator.TEST_TABLE1, "id");
311         rsmd = rs.getMetaData();
312         assertTrue("Rows do not obtained", rs.next());
313         int col = rsmd.getColumnCount();
314         assertEquals("Incorrect number of columns", 8, col);
315         String[] columnNames = { "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME",
316                 "COLUMN_NAME", "GRANTOR", "GRANTEE", "PRIVILEGE",
317                 "IS_GRANTABLE" };
318         for (int c = 1; c <= col; ++c) {
319             assertEquals("Incorrect column name", columnNames[c - 1], rsmd
320                     .getColumnName(c));
321         }
322         assertEquals("Incorrect table catalogue", conn.getCatalog(), rs
323                 .getString("TABLE_CAT").toLowerCase());
324         assertEquals("Incorrect table schema", null, rs
325                 .getString("TABLE_SCHEM"));
326         assertEquals("Incorrect table name", DatabaseCreator.TEST_TABLE1, rs
327                 .getString("TABLE_NAME").toLowerCase());
328         assertEquals("Incorrect column name", "id", rs.getString("COLUMN_NAME")
329                 .toLowerCase());
330         assertEquals("Incorrect grantor", Support_SQL.sqlLogin + "@"
331                 + Support_SQL.sqlHost, rs.getString("GRANTOR").toLowerCase());
332         assertTrue("Incorrect grantee",
333                 rs.getString("GRANTEE").indexOf("root") != -1);
334         assertEquals("Incorrect privilege", "references", rs.getString(
335                 "PRIVILEGE").toLowerCase());
336 
337         query = "REVOKE REFERENCES(id) ON " + DatabaseCreator.TEST_TABLE1
338                 + " FROM " + Support_SQL.sqlLogin;
339         statement.execute(query);
340         rs.close();
341     }
342 
343 
344     @KnownFailure("not supported")
test_getExportedKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()345      public void test_getExportedKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
346             throws SQLException {
347         ResultSet rs = meta.getExportedKeys(conn.getCatalog(), null,
348                 DatabaseCreator.TEST_TABLE3);
349         ResultSetMetaData rsmd = rs.getMetaData();
350         assertTrue("Rows do not obtained", rs.next());
351         int col = rsmd.getColumnCount();
352         assertEquals("Incorrect number of columns", 14, col);
353         String[] columnNames = { "PKTABLE_CAT", "PKTABLE_SCHEM",
354                 "PKTABLE_NAME", "PKCOLUMN_NAME", "FKTABLE_CAT",
355                 "FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ",
356                 "UPDATE_RULE", "DELETE_RULE", "FK_NAME", "PK_NAME",
357                 "DEFERRABILITY" };
358         for (int c = 1; c <= col; ++c) {
359             assertEquals("Incorrect column name", columnNames[c - 1], rsmd
360                     .getColumnName(c));
361         }
362 
363         assertEquals("Incorrect primary key table catalog", conn.getCatalog(),
364                 rs.getString("PKTABLE_CAT"));
365         assertEquals("Incorrect primary key table schema", null, rs
366                 .getString("PKTABLE_SCHEM"));
367         assertEquals("Incorrect primary key table name",
368                 DatabaseCreator.TEST_TABLE3, rs.getString("PKTABLE_NAME"));
369         assertEquals("Incorrect primary key column name", "fk", rs
370                 .getString("PKCOLUMN_NAME"));
371         assertEquals("Incorrect foreign key table catalog", conn.getCatalog(),
372                 rs.getString("FKTABLE_CAT"));
373         assertEquals("Incorrect foreign key table schema", null, rs
374                 .getString("FKTABLE_SCHEM"));
375         assertEquals("Incorrect foreign key table name",
376                 DatabaseCreator.TEST_TABLE1, rs.getString("FKTABLE_NAME"));
377         assertEquals("Incorrect foreign key column name", "fkey", rs
378                 .getString("FKCOLUMN_NAME"));
379         assertEquals("Incorrect sequence number within foreign key", 1, rs
380                 .getShort("KEY_SEQ"));
381         assertEquals("Incorrect update rule value",
382                 DatabaseMetaData.importedKeyNoAction, rs
383                         .getShort("UPDATE_RULE"));
384         assertEquals("Incorrect delete rule value",
385                 DatabaseMetaData.importedKeyNoAction, rs
386                         .getShort("DELETE_RULE"));
387         assertNotNull("Incorrect foreign key name", rs.getString("FK_NAME"));
388         assertEquals("Incorrect primary key name", null, rs
389                 .getString("PK_NAME"));
390         assertEquals("Incorrect deferrability",
391                 DatabaseMetaData.importedKeyNotDeferrable, rs
392                         .getShort("DEFERRABILITY"));
393         rs.close();
394     }
395 
test_getProcedureColumnsLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()396     public void test_getProcedureColumnsLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
397             throws SQLException {
398         meta.getProcedureColumns("", "", "", "");
399     }
400 
test_getProceduresLjava_lang_StringLjava_lang_StringLjava_lang_String()401     public void test_getProceduresLjava_lang_StringLjava_lang_StringLjava_lang_String()
402             throws SQLException {
403         // NOT_FEASIBLE: SQLITE does not implement this functionality
404     }
405 
406     /**
407      * java.sql.DatabaseMetaData#getProcedureTerm()
408      */
409     @KnownFailure("Exception test fails")
test_getProcedureTerm()410     public void test_getProcedureTerm() throws SQLException {
411         assertTrue("Incorrect procedure term", "".equals(meta
412                 .getProcedureTerm().trim()));
413 
414       //Exception checking
415         conn.close();
416 
417          try {
418              meta.getProcedureTerm();
419              fail("SQLException not thrown");
420          } catch (SQLException e) {
421              //ok
422          }
423     }
424 
425     /**
426      * java.sql.DatabaseMetaData#getSchemaTerm()
427      */
428     @KnownFailure("Exception test fails")
test_getSchemaTerm()429     public void test_getSchemaTerm() throws SQLException {
430         String term = meta.getSchemaTerm();
431         assertNotNull("Incorrect schema term", term );
432 
433         assertTrue("".equals(term));
434 
435       //Exception checking
436         conn.close();
437 
438          try {
439              meta.getSchemaTerm();
440              fail("SQLException not thrown");
441          } catch (SQLException e) {
442              //ok
443          }
444     }
445 
test_getSuperTablesLjava_lang_StringLjava_lang_StringLjava_lang_String()446     public void test_getSuperTablesLjava_lang_StringLjava_lang_StringLjava_lang_String()
447             throws SQLException {
448         // NOT_FEASIBLE: SQLITE does not implement this functionality
449     }
450 
test_getSuperTypesLjava_lang_StringLjava_lang_StringLjava_lang_String()451     public void test_getSuperTypesLjava_lang_StringLjava_lang_StringLjava_lang_String()
452             throws SQLException {
453         // NOT_FEASIBLE: SQLITE does not implement this functionality
454     }
455 
456     @KnownFailure("not supported. Privileges are not supported.")
test_getTablePrivilegesLjava_lang_StringLjava_lang_StringLjava_lang_String()457     public void test_getTablePrivilegesLjava_lang_StringLjava_lang_StringLjava_lang_String()
458             throws SQLException {
459         // case 1. Get privileges when no privilegies exist for one table
460         ResultSet privileges = meta.getTablePrivileges(conn.getCatalog(), "%",
461                 DatabaseCreator.TEST_TABLE3);
462         assertFalse("Some privilegies exist", privileges.next());
463         privileges.close();
464 
465         // case 2. Get privileges when no privilegies exist for all tables
466         privileges = meta.getTablePrivileges(null, null, null);
467         assertFalse("Some privilegies exist", privileges.next());
468         privileges.close();
469 
470         // case 3. grant CREATE and SELECT privileges ang get them
471         HashSet<String> expectedPrivs = new HashSet<String>();
472         expectedPrivs.add("CREATE");
473         expectedPrivs.add("SELECT");
474 
475         String query = "GRANT CREATE, SELECT ON " + DatabaseCreator.TEST_TABLE3
476                 + " TO " + Support_SQL.sqlUser;
477         statement.execute(query);
478 
479         privileges = meta.getTablePrivileges(conn.getCatalog(), null,
480                 DatabaseCreator.TEST_TABLE3);
481 
482         while (privileges.next()) {
483             assertEquals("Wrong catalog name", Support_SQL.sqlCatalog,
484                     privileges.getString("TABLE_CAT"));
485             assertNull("Wrong schema", privileges.getString("TABLE_SCHEM"));
486             assertEquals("Wrong table name", DatabaseCreator.TEST_TABLE3,
487                     privileges.getString("TABLE_NAME"));
488             assertTrue("Wrong privilege " + privileges.getString("PRIVILEGE"),
489                     expectedPrivs.remove(privileges.getString("PRIVILEGE")));
490             assertEquals("Wrong grantor", Support_SQL.sqlLogin + "@"
491                     + Support_SQL.sqlHost, privileges.getString("GRANTOR"));
492             assertEquals("Wrong grantee", Support_SQL.sqlUser + "@%",
493                     privileges.getString("GRANTEE"));
494             assertNull("Wrong value of IS_GRANTABLE", privileges
495                     .getString("IS_GRANTABLE"));
496         }
497         privileges.close();
498         assertTrue("Wrong privileges were returned", expectedPrivs.isEmpty());
499 
500         query = "REVOKE CREATE, SELECT ON " + DatabaseCreator.TEST_TABLE3
501                 + " FROM " + Support_SQL.sqlUser;
502         statement.execute(query);
503 
504         // case 4. grant all privileges ang get them
505         String[] privs = new String[] { "ALTER", "CREATE", "CREATE VIEW",
506                 "DELETE", "DROP", "INDEX", "INSERT", "REFERENCES", "SELECT",
507                 "SHOW VIEW", "UPDATE" };
508         expectedPrivs = new HashSet<String>();
509         for (int i = 0; i < privs.length; i++) {
510             expectedPrivs.add(privs[i]);
511         }
512         query = "GRANT ALL ON " + DatabaseCreator.TEST_TABLE3 + " TO "
513                 + Support_SQL.sqlUser;
514         statement.execute(query);
515 
516         privileges = meta.getTablePrivileges(conn.getCatalog(), null,
517                 DatabaseCreator.TEST_TABLE3);
518 
519         while (privileges.next()) {
520             assertEquals("Wrong catalog name", Support_SQL.sqlCatalog,
521                     privileges.getString("TABLE_CAT"));
522             assertNull("Wrong schema", privileges.getString("TABLE_SCHEM"));
523             assertEquals("Wrong table name", DatabaseCreator.TEST_TABLE3,
524                     privileges.getString("TABLE_NAME"));
525             assertTrue("Wrong privilege " + privileges.getString("PRIVILEGE"),
526                     expectedPrivs.remove(privileges.getString("PRIVILEGE")));
527             assertEquals("Wrong grantor", Support_SQL.sqlLogin + "@"
528                     + Support_SQL.sqlHost, privileges.getString("GRANTOR"));
529             assertEquals("Wrong grantee", Support_SQL.sqlUser + "@%",
530                     privileges.getString("GRANTEE"));
531             assertNull("Wrong value of IS_GRANTABLE", privileges
532                     .getString("IS_GRANTABLE"));
533         }
534         privileges.close();
535         assertTrue("Wrong privileges were returned", expectedPrivs.isEmpty());
536 
537         query = "REVOKE ALL ON " + DatabaseCreator.TEST_TABLE3 + " FROM "
538                 + Support_SQL.sqlUser;
539         statement.execute(query);
540 
541         // case 5. check no privelegies after revoke
542         privileges = meta.getTablePrivileges(conn.getCatalog(), "%",
543                 DatabaseCreator.TEST_TABLE3);
544         assertFalse("Some privilegies exist", privileges.next());
545         privileges.close();
546 
547         privileges = meta.getTablePrivileges(null, null, null);
548         assertFalse("Some privilegies exist", privileges.next());
549         privileges.close();
550     }
551 
test_getUDTsLjava_lang_StringLjava_lang_StringLjava_lang_String$I()552     public void test_getUDTsLjava_lang_StringLjava_lang_StringLjava_lang_String$I()
553             throws SQLException {
554         // NOT_FEASIBLE: JDBC does not implement this functionality
555     }
556 
557     @KnownFailure("Not supported ops applied")
test_getVersionColumnsLjava_lang_StringLjava_lang_StringLjava_lang_String()558     public void test_getVersionColumnsLjava_lang_StringLjava_lang_StringLjava_lang_String()
559             throws SQLException {
560         DatabaseMetaDataTest.insertNewRecord();
561 
562         String triggerName = "updateTrigger";
563         String triggerQuery = "CREATE TRIGGER " + triggerName
564                 + " AFTER UPDATE ON " + DatabaseCreator.TEST_TABLE1
565                 + " FOR EACH ROW BEGIN INSERT INTO "
566                 + DatabaseCreator.TEST_TABLE3 + " SET fk = 10; END;";
567         statementForward.execute(triggerQuery);
568 
569         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
570                 + " SET field1='fffff' WHERE id=1";
571         statementForward.execute(updateQuery);
572 
573         ResultSet rs = meta.getVersionColumns(conn.getCatalog(), null,
574                 DatabaseCreator.TEST_TABLE1);
575         assertTrue("Result set is empty", rs.next());
576         rs.close();
577     }
578 
579     /**
580      * java.sql.DatabaseMetaData#isCatalogAtStart()
581      */
582     @KnownFailure("Exception test fails")
test_isCatalogAtStart()583     public void test_isCatalogAtStart() throws SQLException {
584         assertFalse(
585                 "catalog doesn't appear at the start of a fully qualified table name",
586                 meta.isCatalogAtStart());
587 
588       //Exception checking
589         conn.close();
590 
591          try {
592              meta.isCatalogAtStart();
593              fail("SQLException not thrown");
594          } catch (SQLException e) {
595              //ok
596          }
597     }
598 
599     @KnownFailure("not supported")
test_locatorsUpdateCopy()600     public void test_locatorsUpdateCopy() throws SQLException {
601         assertFalse(meta.locatorsUpdateCopy());
602     }
603 
test_nullPlusNonNullIsNull()604     public void test_nullPlusNonNullIsNull() throws SQLException {
605         assertFalse(meta.nullPlusNonNullIsNull());
606     }
607 
test_nullsAreSortedAtEnd()608     public void test_nullsAreSortedAtEnd() throws SQLException {
609         assertFalse(meta.nullsAreSortedAtEnd());
610     }
611 
test_nullsAreSortedAtStart()612     public void test_nullsAreSortedAtStart() throws SQLException {
613         assertFalse(meta.nullsAreSortedAtStart());
614     }
615 
test_nullsAreSortedHigh()616     public void test_nullsAreSortedHigh() throws SQLException {
617         assertFalse(meta.nullsAreSortedHigh());
618     }
619 
test_nullsAreSortedLow()620     public void test_nullsAreSortedLow() throws SQLException {
621         assertFalse(meta.nullsAreSortedLow());
622     }
623 
624     /**
625      * java.sql.DatabaseMetaData#ownDeletesAreVisible(int)
626      */
test_ownDeletesAreVisibleI()627     public void test_ownDeletesAreVisibleI() throws SQLException {
628         // NOT_FEASIBLE not supported
629 //        assertFalse(
630 //                "result set's own deletes are visible for TYPE_FORWARD_ONLY type",
631 //                meta.ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
632 //        assertFalse(
633 //                "result set's own deletes are visible for TYPE_SCROLL_INSENSITIVE type",
634 //               meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
635 //        assertFalse(
636 //                "result set's own deletes are visible for TYPE_SCROLL_SENSITIVE type",
637 //                meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
638         assertFalse("result set's own deletes are visible for unknown type",
639                 meta.ownDeletesAreVisible(100));
640     }
641 
642     /**
643      * java.sql.DatabaseMetaData#ownInsertsAreVisible(int)
644      */
test_ownInsertsAreVisibleI()645     public void test_ownInsertsAreVisibleI() throws SQLException {
646 //        assertFalse(
647 //                "result set's own inserts are visible for TYPE_FORWARD_ONLY type",
648 //                meta.ownInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
649 //        assertFalse(
650 //                "result set's own inserts are visible for TYPE_SCROLL_INSENSITIVE type",
651 //                meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
652 //        assertFalse(
653 //                "result set's own inserts are visible for TYPE_SCROLL_SENSITIVE type",
654 //                meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
655         assertFalse("result set's own inserts are visible for unknown type",
656                 meta.ownInsertsAreVisible(100));
657     }
658 
test_ownUpdatesAreVisibleI()659     public void test_ownUpdatesAreVisibleI() throws SQLException {
660         assertTrue(
661                 "result set's own updates are visible for TYPE_FORWARD_ONLY type",
662                 meta.ownUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
663         assertTrue(
664                 "result set's own updates are visible for TYPE_SCROLL_INSENSITIVE type",
665                 meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
666         assertTrue(
667                 "result set's own updates are visible for TYPE_SCROLL_SENSITIVE type",
668                 meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
669         assertFalse("result set's own updates are visible for unknown type",
670                 meta.ownUpdatesAreVisible(100));
671     }
672 
test_storesLowerCaseIdentifiers()673     public void test_storesLowerCaseIdentifiers() throws SQLException {
674         assertFalse(meta.storesLowerCaseIdentifiers());
675     }
676 
test_storesLowerCaseQuotedIdentifiers()677     public void test_storesLowerCaseQuotedIdentifiers() throws SQLException {
678         assertFalse(meta.storesLowerCaseQuotedIdentifiers());
679     }
680 
test_storesUpperCaseIdentifiers()681     public void test_storesUpperCaseIdentifiers() throws SQLException {
682         assertFalse(meta.storesUpperCaseIdentifiers());
683     }
684 
test_storesUpperCaseQuotedIdentifiers()685     public void test_storesUpperCaseQuotedIdentifiers() throws SQLException {
686         assertFalse(meta.storesUpperCaseQuotedIdentifiers());
687     }
688 
689     @KnownFailure("not supported")
test_supportsANSI92EntryLevelSQL()690     public void test_supportsANSI92EntryLevelSQL() throws SQLException {
691         assertFalse(meta.supportsANSI92EntryLevelSQL());
692     }
693 
test_supportsANSI92FullSQL()694     public void test_supportsANSI92FullSQL() throws SQLException {
695         assertFalse(meta.supportsANSI92FullSQL());
696     }
697 
test_supportsANSI92IntermediateSQL()698     public void test_supportsANSI92IntermediateSQL() throws SQLException {
699         assertFalse(meta.supportsANSI92IntermediateSQL());
700     }
701 
test_supportsAlterTableWithAddColumn()702     public void test_supportsAlterTableWithAddColumn() throws SQLException {
703         assertFalse(meta.supportsAlterTableWithAddColumn());
704     }
705 
test_supportsAlterTableWithDropColumn()706     public void test_supportsAlterTableWithDropColumn() throws SQLException {
707         assertFalse(meta.supportsAlterTableWithDropColumn());
708     }
709 
test_supportsBatchUpdates()710     public void test_supportsBatchUpdates() throws SQLException {
711         assertTrue(meta.supportsBatchUpdates());
712     }
713 
test_supportsCatalogsInDataManipulation()714     public void test_supportsCatalogsInDataManipulation() throws SQLException {
715         assertFalse(meta.supportsCatalogsInDataManipulation());
716     }
717 
test_supportsCatalogsInIndexDefinitions()718     public void test_supportsCatalogsInIndexDefinitions() throws SQLException {
719         assertFalse(meta.supportsCatalogsInIndexDefinitions());
720     }
721 
test_supportsCatalogsInPrivilegeDefinitions()722     public void test_supportsCatalogsInPrivilegeDefinitions() throws SQLException {
723         assertFalse(meta.supportsCatalogsInPrivilegeDefinitions());
724     }
725 
test_supportsCatalogsInProcedureCalls()726     public void test_supportsCatalogsInProcedureCalls() throws SQLException {
727         assertFalse(meta.supportsCatalogsInProcedureCalls());
728     }
729 
test_supportsCatalogsInTableDefinitions()730     public void test_supportsCatalogsInTableDefinitions() throws SQLException {
731         assertFalse(meta.supportsCatalogsInTableDefinitions());
732     }
733 
test_supportsConvert()734     public void test_supportsConvert() throws SQLException {
735         assertFalse(meta.supportsConvert());
736     }
737 
test_supportsConvertII()738     public void test_supportsConvertII() throws SQLException {
739         assertFalse(meta.supportsConvert());
740     }
741 
test_supportsCoreSQLGrammar()742     public void test_supportsCoreSQLGrammar() throws SQLException {
743         assertFalse(meta.supportsCoreSQLGrammar());
744     }
745 
test_supportsCorrelatedSubqueries()746     public void test_supportsCorrelatedSubqueries() throws SQLException {
747         assertFalse(meta.supportsCorrelatedSubqueries());
748     }
749 
750     @KnownFailure("not supported")
test_supportsDataDefinitionAndDataManipulationTransactions()751     public void test_supportsDataDefinitionAndDataManipulationTransactions() throws SQLException {
752         assertFalse(meta.supportsDataDefinitionAndDataManipulationTransactions());
753     }
754 
test_supportsDataManipulationTransactionsOnly()755     public void test_supportsDataManipulationTransactionsOnly() throws SQLException {
756         assertFalse(meta.supportsDataManipulationTransactionsOnly());
757     }
758 
test_supportsDifferentTableCorrelationNames()759     public void test_supportsDifferentTableCorrelationNames() throws SQLException {
760         assertFalse(meta.supportsDifferentTableCorrelationNames());
761     }
762 
test_supportsExtendedSQLGrammar()763     public void test_supportsExtendedSQLGrammar() throws SQLException {
764         assertFalse(meta.supportsExtendedSQLGrammar());
765     }
766 
test_supportsFullOuterJoins()767     public void test_supportsFullOuterJoins() throws SQLException {
768         assertFalse(meta.supportsFullOuterJoins());
769     }
770 
test_supportsGetGeneratedKeys()771     public void test_supportsGetGeneratedKeys() throws SQLException {
772         assertFalse(meta.supportsGetGeneratedKeys());
773     }
774 
test_supportsGroupByBeyondSelect()775     public void test_supportsGroupByBeyondSelect() throws SQLException {
776         assertFalse(meta.supportsGroupByBeyondSelect());
777     }
778 
test_supportsIntegrityEnhancementFacility()779     public void test_supportsIntegrityEnhancementFacility() throws SQLException {
780         assertFalse(meta.supportsIntegrityEnhancementFacility());
781     }
782 
test_supportsLikeEscapeClause()783     public void test_supportsLikeEscapeClause() throws SQLException {
784         assertFalse(meta.supportsLikeEscapeClause());
785     }
786 
test_supportsLimitedOuterJoins()787     public void test_supportsLimitedOuterJoins() throws SQLException {
788         assertFalse(meta.supportsLimitedOuterJoins());
789     }
790 
791     @KnownFailure("not supported")
test_supportsMinimumSQLGrammar()792     public void test_supportsMinimumSQLGrammar() throws SQLException {
793         assertFalse(meta.supportsMinimumSQLGrammar());
794     }
795 
test_supportsMixedCaseIdentifiers()796     public void test_supportsMixedCaseIdentifiers() throws SQLException {
797         assertFalse(meta.supportsMixedCaseIdentifiers());
798     }
799 
test_supportsMixedCaseQuotedIdentifiers()800     public void test_supportsMixedCaseQuotedIdentifiers() throws SQLException {
801         assertFalse(meta.supportsMixedCaseQuotedIdentifiers());
802     }
803 
test_supportsMultipleOpenResults()804     public void test_supportsMultipleOpenResults() throws SQLException {
805         assertFalse(meta.supportsMultipleOpenResults());
806     }
807 
test_supportsMultipleResultSets()808     public void test_supportsMultipleResultSets() throws SQLException {
809         assertFalse(meta.supportsMultipleResultSets());
810     }
811 
test_supportsMultipleTransactions()812     public void test_supportsMultipleTransactions() throws SQLException {
813         assertFalse(meta.supportsMultipleTransactions());
814     }
815 
test_supportsNamedParameters()816     public void test_supportsNamedParameters() throws SQLException {
817         assertFalse(meta.supportsNamedParameters());
818     }
819 
test_supportsOpenCursorsAcrossCommit()820     public void test_supportsOpenCursorsAcrossCommit() throws SQLException {
821         assertFalse(meta.supportsOpenCursorsAcrossCommit());
822     }
823 
test_supportsOpenCursorsAcrossRollback()824     public void test_supportsOpenCursorsAcrossRollback() throws SQLException {
825         assertFalse(meta.supportsOpenCursorsAcrossRollback());
826     }
827 
test_supportsOpenStatementsAcrossCommit()828     public void test_supportsOpenStatementsAcrossCommit() throws SQLException {
829         assertFalse(meta.supportsOpenStatementsAcrossCommit());
830     }
831 
test_supportsOpenStatementsAcrossRollback()832     public void test_supportsOpenStatementsAcrossRollback() throws SQLException {
833         assertFalse(meta.supportsOpenStatementsAcrossRollback());
834     }
835 
test_supportsOuterJoins()836     public void test_supportsOuterJoins() throws SQLException {
837         assertFalse(meta.supportsOuterJoins());
838     }
839 
test_supportsPositionedDelete()840     public void test_supportsPositionedDelete() throws SQLException {
841         assertFalse(meta.supportsPositionedDelete());
842     }
843 
test_supportsPositionedUpdate()844     public void test_supportsPositionedUpdate() throws SQLException {
845         assertFalse(meta.supportsPositionedUpdate());
846     }
847 
test_supportsResultSetConcurrencyII()848     public void test_supportsResultSetConcurrencyII() throws SQLException {
849         assertFalse(meta.supportsResultSetConcurrency(0,0));
850     }
851 
test_supportsResultSetHoldabilityI()852     public void test_supportsResultSetHoldabilityI() throws SQLException {
853         assertFalse(meta.supportsResultSetHoldability(0));
854     }
855 
856     @KnownFailure("not supported")
test_supportsResultSetTypeI()857     public void test_supportsResultSetTypeI() throws SQLException {
858         assertTrue("database supports TYPE_FORWARD_ONLY type", meta
859                 .supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY));
860         assertFalse("database doesn't support TYPE_SCROLL_INSENSITIVE type",
861                 meta.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
862         assertFalse("database supports TYPE_SCROLL_SENSITIVE type", meta
863                 .supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
864         assertFalse("database supports unknown type", meta
865                 .supportsResultSetType(100));
866     }
867 
test_supportsSavepoints()868     public void test_supportsSavepoints() throws SQLException {
869         assertFalse(meta.supportsSavepoints());
870     }
871 
test_supportsSchemasInDataManipulation()872     public void test_supportsSchemasInDataManipulation() throws SQLException {
873         assertFalse(meta.supportsSchemasInDataManipulation());
874     }
875 
test_supportsSchemasInIndexDefinitions()876     public void test_supportsSchemasInIndexDefinitions() throws SQLException {
877         assertFalse(meta.supportsSchemasInIndexDefinitions());
878     }
879 
test_supportsSchemasInPrivilegeDefinitions()880     public void test_supportsSchemasInPrivilegeDefinitions() throws SQLException {
881         // NOT_FEASIBLE: SQLITE does not implement this functionality
882     }
883 
test_supportsSchemasInProcedureCalls()884     public void test_supportsSchemasInProcedureCalls() throws SQLException {
885         assertFalse(meta.supportsSchemasInProcedureCalls());
886     }
887 
test_supportsSchemasInTableDefinitions()888     public void test_supportsSchemasInTableDefinitions() throws SQLException {
889         assertFalse(meta.supportsSchemasInTableDefinitions());
890     }
891 
test_supportsStatementPooling()892     public void test_supportsStatementPooling() throws SQLException {
893         assertFalse(meta.supportsStatementPooling());
894     }
895 
test_supportsStoredProcedures()896     public void test_supportsStoredProcedures() throws SQLException {
897         assertFalse(meta.supportsStoredProcedures());
898     }
899 
900     @KnownFailure("not supported")
test_supportsSubqueriesInComparisons()901     public void test_supportsSubqueriesInComparisons() throws SQLException {
902         assertFalse(meta.supportsSubqueriesInComparisons());
903     }
904 
905     @KnownFailure("not supported")
test_supportsSubqueriesInIns()906     public void test_supportsSubqueriesInIns() throws SQLException {
907         assertFalse(meta.supportsSubqueriesInIns());
908     }
909 
test_supportsSubqueriesInQuantifieds()910     public void test_supportsSubqueriesInQuantifieds() throws SQLException {
911         assertFalse(meta.supportsSubqueriesInQuantifieds());
912     }
913 
914     @KnownFailure("not supported")
test_supportsTransactions()915     public void test_supportsTransactions() throws SQLException {
916         assertFalse(meta.supportsTransactions());
917     }
918 
test_supportsUnion()919     public void test_supportsUnion() throws SQLException {
920         assertTrue(meta.supportsUnion());
921     }
922 
test_supportsUnionAll()923     public void test_supportsUnionAll() throws SQLException {
924         assertTrue(meta.supportsUnionAll());
925     }
926 
test_usesLocalFilePerTable()927     public void test_usesLocalFilePerTable() throws SQLException {
928         assertFalse(meta.usesLocalFilePerTable());
929     }
930 
931     @KnownFailure("not supported")
test_usesLocalFiles()932     public void test_usesLocalFiles() throws SQLException {
933         assertFalse(meta.usesLocalFiles());
934     }
935 
936     /**
937      * java.sql.DatabaseMetaData#getMaxBinaryLiteralLength()
938      */
test_getMaxBinaryLiteralLength()939     public void test_getMaxBinaryLiteralLength() throws SQLException {
940         assertTrue("Incorrect binary literal length", meta
941                 .getMaxBinaryLiteralLength() == 0);
942     }
943 
944     /**
945      * java.sql.DatabaseMetaData#getMaxCatalogNameLength()
946      */
test_getMaxCatalogNameLength()947     public void test_getMaxCatalogNameLength() throws SQLException {
948         assertTrue("Incorrect name length", meta.getMaxCatalogNameLength() == 0);
949     }
950 
951     /**
952      * java.sql.DatabaseMetaData#getMaxCharLiteralLength()
953      */
test_getMaxCharLiteralLength()954     public void test_getMaxCharLiteralLength() throws SQLException {
955         assertTrue("Incorrect char literal length", meta
956                 .getMaxCharLiteralLength() == 0);
957     }
958 
959     /**
960      * java.sql.DatabaseMetaData#getMaxColumnNameLength()
961      */
test_getMaxColumnNameLength()962     public void test_getMaxColumnNameLength() throws SQLException {
963         assertTrue("Incorrect column name length", meta
964                 .getMaxColumnNameLength() == 0);
965     }
966 
967     /**
968      * java.sql.DatabaseMetaData#getMaxColumnsInGroupBy()
969      */
test_getMaxColumnsInGroupBy()970     public void test_getMaxColumnsInGroupBy() throws SQLException {
971         assertTrue("Incorrect number of columns",
972                 meta.getMaxColumnsInGroupBy() == 0);
973     }
974 
975     /**
976      * java.sql.DatabaseMetaData#getMaxColumnsInIndex()
977      */
test_getMaxColumnsInIndex()978     public void test_getMaxColumnsInIndex() throws SQLException {
979         assertTrue("Incorrect number of columns",
980                 meta.getMaxColumnsInIndex() == 0);
981     }
982 
983     /**
984      * java.sql.DatabaseMetaData#getMaxColumnsInOrderBy()
985      */
test_getMaxColumnsInOrderBy()986     public void test_getMaxColumnsInOrderBy() throws SQLException {
987         assertTrue("Incorrect number of columns",
988                 meta.getMaxColumnsInOrderBy() == 0);
989     }
990 
991     /**
992      * java.sql.DatabaseMetaData#getMaxColumnsInSelect()
993      */
test_getMaxColumnsInSelect()994     public void test_getMaxColumnsInSelect() throws SQLException {
995         assertTrue("Incorrect number of columns",
996                 meta.getMaxColumnsInSelect() == 0);
997     }
998 
999     /**
1000      * java.sql.DatabaseMetaData#getMaxColumnsInTable()
1001      */
test_getMaxColumnsInTable()1002     public void test_getMaxColumnsInTable() throws SQLException {
1003         assertTrue("Incorrect number of columns",
1004                 meta.getMaxColumnsInTable() == 0);
1005     }
1006 
1007     /**
1008      * java.sql.DatabaseMetaData#getMaxConnections()
1009      */
test_getMaxConnections()1010     public void test_getMaxConnections() throws SQLException {
1011         assertTrue("Incorrect number of connections",
1012                 meta.getMaxConnections() == 0);
1013     }
1014 
1015     /**
1016      * java.sql.DatabaseMetaData#getMaxIndexLength()
1017      */
test_getMaxIndexLength()1018     public void test_getMaxIndexLength() throws SQLException {
1019         assertTrue("Incorrect length of index", meta.getMaxIndexLength() == 0);
1020     }
1021 
1022     /**
1023      * java.sql.DatabaseMetaData#getMaxProcedureNameLength()
1024      */
test_getMaxProcedureNameLength()1025     public void test_getMaxProcedureNameLength() throws SQLException {
1026         assertTrue("Incorrect length of procedure name", meta
1027                 .getMaxProcedureNameLength() == 0);
1028     }
1029 
1030     /**
1031      * java.sql.DatabaseMetaData#getMaxRowSize()
1032      */
test_getMaxRowSize()1033     public void test_getMaxRowSize() throws SQLException {
1034         assertTrue("Incorrect size of row", meta.getMaxRowSize() == 0);
1035     }
1036 
1037     /**
1038      * java.sql.DatabaseMetaData#getMaxSchemaNameLength()
1039      */
test_getMaxSchemaNameLength()1040     public void test_getMaxSchemaNameLength() throws SQLException {
1041         assertTrue("Incorrect length of schema name", meta
1042                 .getMaxSchemaNameLength() == 0);
1043     }
1044 
1045     /**
1046      * java.sql.DatabaseMetaData#getMaxStatementLength()
1047      */
test_getMaxStatementLength()1048     public void test_getMaxStatementLength() throws SQLException {
1049         assertTrue("Incorrect length of statement", meta
1050                 .getMaxStatementLength() == 0);
1051     }
1052 
1053     /**
1054      * java.sql.DatabaseMetaData#getMaxStatements()
1055      */
test_getMaxStatements()1056     public void test_getMaxStatements() throws SQLException {
1057         assertTrue("Incorrect number of statements",
1058                 meta.getMaxStatements() == 0);
1059     }
1060 
1061     /**
1062      * java.sql.DatabaseMetaData#getMaxTableNameLength()
1063      */
1064     @KnownFailure("Exception test fails")
test_getMaxTableNameLength()1065     public void test_getMaxTableNameLength() throws SQLException {
1066         assertTrue("Now supported", meta
1067                 .getMaxTableNameLength() == 0);
1068 
1069       //Exception checking
1070         conn.close();
1071 
1072          try {
1073              meta.getMaxTableNameLength();
1074              fail("SQLException not thrown");
1075          } catch (SQLException e) {
1076              //ok
1077          }
1078     }
1079 
1080     /**
1081      * java.sql.DatabaseMetaData#getMaxTablesInSelect()
1082      */
1083     @KnownFailure("Exception test fails")
test_getMaxTablesInSelect()1084     public void test_getMaxTablesInSelect() throws SQLException {
1085         assertTrue("Tables in select is now supported: change test implementation\"",
1086                 meta.getMaxTablesInSelect() == 0);
1087 
1088       //Exception checking
1089         conn.close();
1090 
1091          try {
1092              meta.getMaxTablesInSelect();
1093              fail("SQLException not thrown");
1094          } catch (SQLException e) {
1095              //ok
1096          }
1097     }
1098 
1099     /**
1100      * java.sql.DatabaseMetaData#getMaxUserNameLength()
1101      */
1102     @KnownFailure("Exception test fails")
test_getMaxUserNameLength()1103     public void test_getMaxUserNameLength() throws SQLException {
1104         assertTrue("Usernames are now supported: change test implementation",
1105                 meta.getMaxUserNameLength() == 0);
1106 
1107       //Excpetion checking
1108         conn.close();
1109 
1110          try {
1111              meta.getMaxUserNameLength();
1112              fail("SQLException not thrown");
1113          } catch (SQLException e) {
1114              //ok
1115          }
1116     }
1117 
1118 
1119 }
1120