· 9 years ago · Dec 15, 2016, 07:56 PM
1package test;
2import java.io.File;
3import java.io.IOException;
4import java.sql.Connection;
5import java.sql.Driver;
6import java.sql.ResultSet;
7import java.sql.SQLException;
8import java.sql.Statement;
9import java.util.Properties;
10
11import org.junit.Assert;
12import org.junit.Test;
13
14/**
15 * Notes:
16 1- Any test with "xmldb" can be replaced with "jsondb".
17
18 2- You can manipulate this file as much as you can, add more tests, change these tests ... etc.
19
20 3- This file does not cover all the required test cases but that does not mean that these test cases will be forgotten, the SanityTest
21 will have many of them.
22 **/
23public class SmokeTest {
24
25 private static String protocol = "xmldb";
26 private static String tmp = System.getProperty("java.io.tmpdir");
27
28 public static Class<?> getSpecifications() {
29 return Driver.class;
30 }
31
32 private Connection createUseDatabase(String databaseName) throws SQLException {
33 Driver driver = (Driver) TestRunner.getImplementationInstance();
34 Properties info = new Properties();
35 File dbDir = new File(tmp + File.separator + "jdbc" + File.separator + Math.round((((float) Math.random()) * 100000)));
36 info.put("path", dbDir.getAbsoluteFile());
37
38 Connection connection = driver.connect("jdbc:" + protocol + "://localhost", info); // Establish
39 // connection
40 // (really,
41 // just
42 // make
43 // sure
44 // that the dbDir exists, and create it if it
45 // doesn't), and just record the protocol.
46
47 Statement statement = connection.createStatement(); // create a
48 // statement object
49 // to execute next
50 // statements.
51 statement.execute("CREATE DATABASE " + databaseName+" ;"); // you should now
52 // create a
53 // folder for
54 // that database
55 // within dbDir.
56 statement.execute("USE " + databaseName +" ;"); // Set the state of your
57 // connection to use
58 // "databaseName", all next
59 // created statements
60 // (like selects and inserts) should be applied to this database.
61 statement.close();
62 return connection;
63 }
64
65// @Test
66// public void testCreateAndOpenAndDropDatabase() throws SQLException {
67// File dummy = null;
68// Driver driver = (Driver) TestRunner.getImplementationInstance();
69// Properties info = new Properties();
70// File dbDir = new File(tmp + File.separator + "jdbc" + File.separator + Math.round((((float) Math.random()) * 100000)));
71// info.put("path", dbDir.getAbsoluteFile());
72// Connection connection = driver.connect("jdbc:" + protocol + "://localhost", info);
73//
74// {
75// Statement statement = connection.createStatement();
76//// statement.execute("DROP DATABASE SaMpLe;");
77// statement.execute("CREATE DATABASE SaMpLe;");
78// statement.execute("USE SaMpLe;");
79// String files[] = dbDir.list();
80// Assert.assertFalse("Databases directory is empty!", files == null || files.length == 0);
81// dummy = new File(dbDir, "dummy");
82// try {
83// boolean created = dummy.createNewFile();
84// Assert.assertTrue("Failed to create file into DB", created && dummy.exists());
85// } catch (IOException e) {
86// TestRunner.fail("Failed to create file into DB", e);
87// }
88// statement.close();
89// }
90//
91// {
92// Statement statement = connection.createStatement();
93// statement.execute("CREATE DATABASE sAmPlE;");
94// statement.execute("USE SaMpLe;");
95// String files[] = dbDir.list();
96// Assert.assertTrue("Database directory is empty after opening!", files.length > 0);
97// Assert.assertTrue("Failed to create find a previously created file into DB", dummy.exists());
98// statement.close();
99// }
100// connection.close();
101// }
102
103// @Test
104// public void testCreateTable() throws SQLException {
105// Connection connection = createUseDatabase("TestDB_Create");
106// try {
107// Statement statement = connection.createStatement();
108// statement.execute("CREATE TABLE table_name1(column_name1 varchar, column_name2 int, column_name3 date);");
109// statement.close();
110// } catch (Throwable e) {
111// TestRunner.fail("Failed to create table", e);
112// }
113// try {
114// Statement statement = connection.createStatement();
115// boolean created = statement
116// .execute("CREATE TABLE table_name1(column_name1 varchar, column_name2 int, column_name3 date);");
117// Assert.assertFalse("Create table succeed when table already exists;", created);
118// } catch (Throwable e) {
119// TestRunner.fail("Failed to create existing table", e);
120// }
121// try {
122// Statement statement = connection.createStatement();
123// statement.execute("CREATE TABLE incomplete_table_name1;");
124// Assert.fail("Create invalid table succeed");
125// } catch (SQLException e) {
126// } catch (Throwable e) {
127// TestRunner.fail("Unknown Exception thrown", e);
128// }
129// connection.close();
130// }
131
132// @Test
133// public void testInsertWithoutColumnNames() throws SQLException {
134// Connection connection = createUseDatabase("TestDB_Create");
135// try {
136// Statement statement = connection.createStatement();
137// statement.execute("CREATE TABLE table_name3(column_name1 varchar, column_name2 int, column_name3 float);");
138// int count = statement.executeUpdate("INSERT INTO table_name3 VALUES ('value1', 3, 1.3);");
139// Assert.assertNotEquals("Insert returned zero rows", 0, count);
140// statement.close();
141// } catch (Throwable e) {
142// TestRunner.fail("Failed to insert into table;", e);
143// }
144// connection.close();
145// }
146
147 @Test
148 public void testInsertWithColumnNames() throws SQLException {
149 Connection connection = createUseDatabase("TestDB_Create");
150 try {
151 Statement statement = connection.createStatement();
152 statement.execute("CREATE TABLE table_name4(column_name1 varchar, column_name2 int, column_name3 date);");
153 int count = statement.executeUpdate(
154 "INSERT INTO table_name4(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', '2011-01-25', 4);");
155 Assert.assertNotEquals("Insert returned zero rows", 0, count);
156 statement.close();
157 } catch (Throwable e) {
158 TestRunner.fail("Failed to insert into table", e);
159 }
160 connection.close();
161 }
162
163// @Test
164// public void testInsertWithWrongColumnNames() throws SQLException {
165// Connection connection = createUseDatabase("TestDB_Create");
166// try {
167// Statement statement = connection.createStatement();
168// statement.execute("CREATE TABLE table_name5(column_name1 varchar, column_name2 int, column_name3 varchar)");
169// statement.executeUpdate(
170// "INSERT INTO table_name5(invalid_column_name1, column_name3, column_name2) VALUES ('value1', 'value3', 4)");
171// Assert.fail("Inserted with invalid column name!!");
172// statement.close();
173// } catch (Throwable e) {
174// }
175// connection.close();
176// }
177//
178// @Test
179// public void testInsertWithWrongColumnCount() throws SQLException {
180// Connection connection = createUseDatabase("TestDB_Create");
181// try {
182// Statement statement = connection.createStatement();
183// statement.execute("CREATE TABLE table_name6(column_name1 varchar, column_name2 int, column_name3 varchar)");
184// statement.executeUpdate("INSERT INTO table_name6(column_name1, column_name2) VALUES ('value1', 4)");
185// Assert.fail("Inserted with invalid column count!!");
186// statement.close();
187// } catch (Throwable e) {
188// }
189// connection.close();
190// }
191//
192// @Test
193// public void testUpdate() throws SQLException {
194// Connection connection = createUseDatabase("TestDB_Create");
195// try {
196// Statement statement = connection.createStatement();
197// statement.execute("CREATE TABLE table_name7(column_name1 varchar, column_name2 int, column_name3 varchar)");
198// int count1 = statement.executeUpdate(
199// "INSERT INTO table_name7(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
200// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
201// int count2 = statement.executeUpdate(
202// "INSERT INTO table_name7(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
203// Assert.assertNotEquals("Insert returned zero rows", 0, count2);
204// int count3 = statement.executeUpdate(
205// "INSERT INTO table_name7(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
206// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
207// int count4 = statement.executeUpdate(
208// "UPDATE table_name7 SET column_name1='1111111111', COLUMN_NAME2=2222222, column_name3='333333333'");
209// Assert.assertEquals("Updated returned wrong number", count1 + count2 + count3, count4);
210// statement.close();
211// } catch (Throwable e) {
212// TestRunner.fail("Failed to update table", e);
213// }
214// connection.close();
215// }
216//
217// @Test
218// public void testConditionalUpdate() throws SQLException {
219// Connection connection = createUseDatabase("TestDB_Create");
220// try {
221// Statement statement = connection.createStatement();
222// statement.execute(
223// "CREATE TABLE table_name8(column_name1 varchar, column_name2 int, column_name3 date, column_name4 float)");
224//
225// int count1 = statement.executeUpdate(
226// "INSERT INTO table_name8(column_NAME1, COLUMN_name3, column_name2, column_name4) VALUES ('value1', '2011-01-25', 3, 1.3)");
227// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
228//
229// int count2 = statement.executeUpdate(
230// "INSERT INTO table_name8(column_NAME1, COLUMN_name3, column_name2, column_name4) VALUES ('value1', '2011-01-28', 3456, 1.01)");
231// Assert.assertNotEquals("Insert returned zero rows", 0, count2);
232//
233// int count3 = statement.executeUpdate(
234// "INSERT INTO table_name8(column_NAME1, COLUMN_name3, column_name2, column_name4) VALUES ('value2', '2011-02-11', -123, 3.14159)");
235// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
236//
237// int count4 = statement.executeUpdate(
238// "UPDATE table_name8 SET COLUMN_NAME2=222222, column_name3='1993-10-03' WHERE coLUmn_NAME1='value1'");
239// Assert.assertEquals("Updated returned wrong number", count1 + count2, count4);
240//
241// statement.close();
242// } catch (Throwable e) {
243// TestRunner.fail("Failed to update table", e);
244// }
245// connection.close();
246// }
247//
248// @Test
249// public void testUpdateEmptyOrInvalidTable() throws SQLException {
250// Connection connection = createUseDatabase("TestDB_Create");
251// try {
252// Statement statement = connection.createStatement();
253// statement.execute("CREATE TABLE table_name9(column_name1 varchar, column_name2 int, column_name3 varchar)");
254// int count = statement.executeUpdate(
255// "UPDATE table_name9 SET column_name1='value1', column_name2=15, column_name3='value2'");
256// Assert.assertEquals("Updated empty table retruned non-zero count!", 0, count);
257// statement.close();
258// } catch (Throwable e) {
259// TestRunner.fail("Failed to update table", e);
260// }
261// try {
262// Statement statement = connection.createStatement();
263// statement.executeUpdate(
264// "UPDATE wrong_table_name9 SET column_name1='value1', column_name2=15, column_name3='value2'");
265// Assert.fail("Updated empty table retruned non-zero count!");
266// statement.close();
267// } catch (SQLException e) {
268// } catch (Throwable e) {
269// TestRunner.fail("Invalid exception was thrown", e);
270// }
271// connection.close();
272// }
273//
274// @Test
275// public void testDelete() throws SQLException {
276// Connection connection = createUseDatabase("TestDB_Create");
277// try {
278// Statement statement = connection.createStatement();
279// statement.execute("CREATE TABLE table_name10(column_name1 varchar, column_name2 int, column_name3 date)");
280// int count1 = statement.executeUpdate(
281// "INSERT INTO table_name10(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', '2011-01-25', 4)");
282// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
283// int count2 = statement.executeUpdate(
284// "INSERT INTO table_name10(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', '2011-01-28', 4)");
285// Assert.assertNotEquals("Insert returned zero rows", 0, count2);
286// int count3 = statement.executeUpdate(
287// "INSERT INTO table_name10(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', '2011-02-11', 5)");
288// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
289// int count4 = statement.executeUpdate("DELETE From table_name10");
290// Assert.assertEquals("Delete returned wrong number", 3, count4);
291// statement.close();
292// } catch (Throwable e) {
293// TestRunner.fail("Failed to delete from table", e);
294// }
295// connection.close();
296// }
297//
298// @Test
299// public void testConditionalDelete() throws SQLException {
300// Connection connection = createUseDatabase("TestDB_Create");
301// try {
302// Statement statement = connection.createStatement();
303// statement.execute("CREATE TABLE table_name11(column_name1 varchar, column_name2 int, column_name3 DATE)");
304// int count1 = statement.executeUpdate(
305// "INSERT INTO table_name11(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', '2011-01-25', 4)");
306// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
307// int count2 = statement.executeUpdate(
308// "INSERT INTO table_name11(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', '2013-06-30', 4)");
309// Assert.assertNotEquals("Insert returned zero rows", 0, count2);
310// int count3 = statement.executeUpdate(
311// "INSERT INTO table_name11(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', '2013-07-03', 5)");
312// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
313// int count4 = statement.executeUpdate("DELETE From table_name11 WHERE coLUmn_NAME3>'2011-01-25'");
314// Assert.assertEquals("Delete returned wrong number", 2, count4);
315// statement.close();
316// } catch (Throwable e) {
317// TestRunner.fail("Failed to delete from table", e);
318// }
319// connection.close();
320// }
321//
322// @Test
323// public void testSelect() throws SQLException {
324// Connection connection = createUseDatabase("TestDB_Create");
325// try {
326// Statement statement = connection.createStatement();
327// statement
328// .execute("CREATE TABLE table_name12(column_name1 varchar, column_name2 int, column_name3 varchar)");
329// int count1 = statement.executeUpdate(
330// "INSERT INTO table_name12(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
331// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
332// int count2 = statement.executeUpdate(
333// "INSERT INTO table_name12(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
334// Assert.assertNotEquals("Insert returned zero rows", 0, count2);
335// int count3 = statement.executeUpdate(
336// "INSERT INTO table_name12(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
337// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
338// int count4 = statement.executeUpdate(
339// "INSERT INTO table_name12(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
340// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
341// ResultSet result = statement.executeQuery("SELECT * From table_name12");
342// int rows = 0;
343// while (result.next())
344// rows++;
345// Assert.assertNotNull("Null result retruned", result);
346// Assert.assertEquals("Wrong number of rows", 4, rows);
347// Assert.assertEquals("Wrong number of columns", 3, result.getMetaData().getColumnCount());
348// statement.close();
349// } catch (Throwable e) {
350// TestRunner.fail("Failed to select from table", e);
351// }
352// connection.close();
353// }
354//
355// @Test
356// public void testConditionalSelect() throws SQLException {
357// Connection connection = createUseDatabase("TestDB_Create");
358// try {
359// Statement statement = connection.createStatement();
360// statement
361// .execute("CREATE TABLE table_name13(column_name1 varchar, column_name2 int, column_name3 varchar)");
362// int count1 = statement.executeUpdate(
363// "INSERT INTO table_name13(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
364// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
365// int count2 = statement.executeUpdate(
366// "INSERT INTO table_name13(column_NAME1, column_name2, COLUMN_name3) VALUES ('value1', 4, 'value3')");
367// Assert.assertNotEquals("Insert returned zero rows", 0, count2);
368// int count3 = statement.executeUpdate(
369// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
370// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
371// int count4 = statement.executeUpdate(
372// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
373// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
374// ResultSet result = statement.executeQuery("SELECT column_name1 FROM table_name13 WHERE coluMN_NAME2 < 5");
375// int rows = 0;
376// while (result.next())
377// rows++;
378// Assert.assertNotNull("Null result retruned", result);
379// Assert.assertEquals("Wrong number of rows", 2, rows);
380// Assert.assertEquals("Wrong number of columns", 1, result.getMetaData().getColumnCount());
381// statement.close();
382// } catch (Throwable e) {
383// TestRunner.fail("Failed to select from table", e);
384// }
385// connection.close();
386// }
387//
388// @Test
389// public void testExecute() throws SQLException {
390// Connection connection = createUseDatabase("TestDB_Create");
391// try {
392// Statement statement = connection.createStatement();
393// statement
394// .execute("CREATE TABLE table_name13(column_name1 varchar, column_name2 int, column_name3 varchar)");
395// int count1 = statement.executeUpdate(
396// "INSERT INTO table_name13(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
397// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
398// boolean result1 = statement.execute(
399// "INSERT INTO table_name13(column_NAME1, column_name2, COLUMN_name3) VALUES ('value1', 8, 'value3')");
400// Assert.assertFalse("Wrong return for insert record", result1);
401// int count3 = statement.executeUpdate(
402// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
403// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
404// int count4 = statement.executeUpdate(
405// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
406// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
407// boolean result2 = statement.execute("SELECT column_name1 FROM table_name13 WHERE coluMN_NAME2 = 8");
408// Assert.assertTrue("Wrong return for select existing records", result2);
409// boolean result3 = statement.execute("SELECT column_name1 FROM table_name13 WHERE coluMN_NAME2 > 100");
410// Assert.assertFalse("Wrong return for select non existing records", result3);
411// statement.close();
412// } catch (Throwable e) {
413// TestRunner.fail("Failed to select from table", e);
414// }
415// connection.close();
416// }
417//
418// @Test
419// public void testDistinct() throws SQLException {
420// Connection connection = createUseDatabase("TestDB_Create");
421// try {
422// Statement statement = connection.createStatement();
423// statement
424// .execute("CREATE TABLE table_name13(column_name1 varchar, column_name2 int, column_name3 varchar)");
425// int count1 = statement.executeUpdate(
426// "INSERT INTO table_name13(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
427// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
428// boolean result1 = statement.execute(
429// "INSERT INTO table_name13(column_NAME1, column_name2, COLUMN_name3) VALUES ('value1', 4, 'value5')");
430// Assert.assertFalse("Wrong return for insert record", result1);
431// int count3 = statement.executeUpdate(
432// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
433// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
434// int count4 = statement.executeUpdate(
435// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
436// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
437//
438// boolean result2 = statement.execute("SELECT DISTINCT column_name2 FROM table_name13");
439// Assert.assertTrue("Wrong return for select existing records", result2);
440// ResultSet res1 = statement.getResultSet();
441//
442// int rows = 0;
443// while (res1.next())
444// rows++;
445// Assert.assertEquals("Wrong number of rows", 3, rows);
446//
447// boolean result3 = statement
448// .execute("SELECT DISTINCT column_name2, column_name3 FROM table_name13 WHERE coluMN_NAME2 < 5");
449// Assert.assertTrue("Wrong return for select existing records", result3);
450// ResultSet res2 = statement.getResultSet();
451//
452// int rows2 = 0;
453// while (res2.next())
454// rows2++;
455// Assert.assertEquals("Wrong number of rows", 2, rows2);
456//
457// statement.close();
458// } catch (Throwable e) {
459// TestRunner.fail("Failed to select distinct from table", e);
460// }
461// connection.close();
462// }
463//
464// @Test
465// public void testAlterTable() throws SQLException {
466// Connection connection = createUseDatabase("TestDB_Create");
467// try {
468// Statement statement = connection.createStatement();
469// statement
470// .execute("CREATE TABLE table_name13(column_name1 varchar, column_name2 int, column_name3 varchar)");
471// int count1 = statement.executeUpdate(
472// "INSERT INTO table_name13(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
473// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
474// boolean result1 = statement.execute(
475// "INSERT INTO table_name13(column_NAME1, column_name2, COLUMN_name3) VALUES ('value1', 4, 'value5')");
476// Assert.assertFalse("Wrong return for insert record", result1);
477// int count3 = statement.executeUpdate(
478// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
479// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
480// int count4 = statement.executeUpdate(
481// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
482// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
483//
484// boolean result2 = statement.execute("ALTER TABLE table_name13 ADD COLUMN column_name4 date");
485// Assert.assertFalse("Wrong return for ALTER TABLE", result2);
486//
487// boolean result3 = statement.execute("SELECT column_name4 FROM table_name13 WHERE coluMN_NAME2 = 5");
488// Assert.assertTrue("Wrong return for select existing records", result3);
489// ResultSet res2 = statement.getResultSet();
490// int rows2 = 0;
491// while (res2.next())
492// rows2++;
493// Assert.assertEquals("Wrong number of rows", 1, rows2);
494//
495// while (res2.previous())
496// ;
497// res2.next();
498//
499// Assert.assertNull("Retrieved date is not null", res2.getDate("column_name4"));
500//
501// statement.close();
502// } catch (Throwable e) {
503// TestRunner.fail("Failed to test ALTER TABLE from table", e);
504// }
505// connection.close();
506// }
507//
508// @Test
509// public void testUnion() throws SQLException {
510// Connection connection = createUseDatabase("TestDB_Create");
511// try {
512// Statement statement = connection.createStatement();
513// statement
514// .execute("CREATE TABLE table_name13(column_name1 varchar, column_name2 int, column_name3 varchar)");
515// int count1 = statement.executeUpdate(
516// "INSERT INTO table_name13(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
517// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
518// boolean result1 = statement.execute(
519// "INSERT INTO table_name13(column_NAME1, column_name2, COLUMN_name3) VALUES ('value1', 4, 'value5')");
520// Assert.assertFalse("Wrong return for insert record", result1);
521// int count3 = statement.executeUpdate(
522// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
523// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
524// int count4 = statement.executeUpdate(
525// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
526// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
527//
528// boolean result3 = statement.execute(
529// "SELECT * FROM table_name13 WHERE coluMN_NAME2 = 4 UNION SELECT * FROM table_name13 WHERE coluMN_NAME3 < 'value6'");
530// Assert.assertTrue("Wrong return for select UNION existing records", result3);
531// ResultSet res2 = statement.getResultSet();
532// int rows2 = 0;
533// while (res2.next())
534// rows2++;
535// Assert.assertEquals("Wrong number of rows", 3, rows2);
536//
537// statement.close();
538// } catch (Throwable e) {
539// TestRunner.fail("Failed to test SELECT from table UNION", e);
540// }
541// connection.close();
542// }
543//
544// @Test
545// public void testOrderBy() throws SQLException {
546// Connection connection = createUseDatabase("TestDB_Create");
547// try {
548// Statement statement = connection.createStatement();
549// statement
550// .execute("CREATE TABLE table_name13(column_name1 varchar, column_name2 int, column_name3 varchar)");
551// int count1 = statement.executeUpdate(
552// "INSERT INTO table_name13(column_NAME1, COLUMN_name3, column_name2) VALUES ('value1', 'value3', 4)");
553// Assert.assertNotEquals("Insert returned zero rows", 0, count1);
554// boolean result1 = statement.execute(
555// "INSERT INTO table_name13(column_NAME1, column_name2, COLUMN_name3) VALUES ('value1', 4, 'value5')");
556// Assert.assertFalse("Wrong return for insert record", result1);
557// int count3 = statement.executeUpdate(
558// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value2', 'value4', 5)");
559// Assert.assertNotEquals("Insert returned zero rows", 0, count3);
560// int count4 = statement.executeUpdate(
561// "INSERT INTO table_name13(column_name1, COLUMN_NAME3, column_NAME2) VALUES ('value5', 'value6', 6)");
562// Assert.assertNotEquals("Insert returned zero rows", 0, count4);
563//
564// boolean result3 = statement
565// .execute("SELECT * FROM table_name13 ORDER BY column_name2 ASC, COLUMN_name3 DESC");
566// Assert.assertTrue("Wrong return for select UNION existing records", result3);
567// ResultSet res2 = statement.getResultSet();
568// int rows2 = 0;
569// while (res2.next())
570// rows2++;
571// Assert.assertEquals("Wrong number of rows", 4, rows2);
572//
573// while (res2.previous())
574// ;
575//
576// res2.next();
577// Assert.assertEquals("Wrong order of rows", 4, res2.getInt("column_name2"));
578// Assert.assertEquals("Wrong order of rows", "value5", res2.getString("column_name3"));
579//
580// res2.next();
581// Assert.assertEquals("Wrong order of rows", 4, res2.getInt("column_name2"));
582// Assert.assertEquals("Wrong order of rows", "value3", res2.getString("column_name3"));
583//
584// res2.next();
585// Assert.assertEquals("Wrong order of rows", 5, res2.getInt("column_name2"));
586//
587// statement.close();
588// } catch (Throwable e) {
589// TestRunner.fail("Failed to test ORDER By", e);
590// }
591// connection.close();
592// }
593
594}