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