--- old/test/javax/sql/testng/TEST.properties 2014-10-28 10:29:41.000000000 -0400 +++ new/test/javax/sql/testng/TEST.properties 2014-10-28 10:29:41.000000000 -0400 @@ -1,4 +1,4 @@ # JDBC unit tests uses TestNG TestNG.dirs= . othervm.dirs= . -lib.dirs = /java/sql/ +lib.dirs = /java/sql/testng --- /dev/null 2014-10-28 10:29:43.000000000 -0400 +++ new/test/java/sql/testng/TEST.properties 2014-10-28 10:29:42.000000000 -0400 @@ -0,0 +1,3 @@ +# JDBC unit tests uses TestNG +TestNG.dirs = . + --- /dev/null 2014-10-28 10:29:44.000000000 -0400 +++ new/test/java/sql/testng/test/sql/BatchUpdateExceptionTests.java 2014-10-28 10:29:43.000000000 -0400 @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.io.ByteArrayInputStream; +import java.io.File; +import java.io.ObjectInputStream; +import java.sql.BatchUpdateException; +import java.sql.SQLException; +import java.util.Arrays; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.SerializedBatchUpdateException; +import util.BaseTest; + +public class BatchUpdateExceptionTests extends BaseTest { + + private final int[] uc = {1, 2, 3}; + private final long[] luc = {1, 2, 3}; + + private final String testSrcDir = System.getProperty("test.src", ".") + + File.separatorChar; + + /** + * Create BatchUpdateException and setting all objects to null + */ + @Test + public void test() { + BatchUpdateException be = new BatchUpdateException(null, + null, errorCode, (int[]) null, null); + assertTrue(be.getMessage() == null && be.getSQLState() == null + && be.getUpdateCounts() == null && be.getCause() == null + && be.getLargeUpdateCounts() == null + && be.getErrorCode() == errorCode); + } + + /** + * Create BatchUpdateException with no-arg constructor + */ + @Test + public void test1() { + BatchUpdateException ex = new BatchUpdateException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getUpdateCounts() == null + && ex.getLargeUpdateCounts() == null); + } + + /** + * Create BatchUpdateException with null Throwable + */ + @Test + public void test2() { + BatchUpdateException ex = new BatchUpdateException((Throwable) null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getUpdateCounts() == null + && ex.getLargeUpdateCounts() == null); + } + + /** + * Create BatchUpdateException with message and update counts + */ + @Test + public void test3() { + + BatchUpdateException ex = new BatchUpdateException(reason, uc); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Create BatchUpdateException with update counts + */ + @Test + public void test4() { + BatchUpdateException ex = new BatchUpdateException(uc); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Create BatchUpdateException with Throwable and update counts + */ + @Test + public void test5() { + BatchUpdateException ex = new BatchUpdateException(uc, t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0 + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Create BatchUpdateException with message, Throwable, and update counts + */ + @Test + public void test6() { + BatchUpdateException ex = new BatchUpdateException(reason, uc, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0 + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Create BatchUpdateException with message, SQLState, Throwable, and update + * counts + */ + @Test + public void test7() { + BatchUpdateException ex = new BatchUpdateException(reason, state, uc, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0 + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Create BatchUpdateException with message, SQLState, errorCode code + * Throwable, and update counts + */ + @Test + public void test8() { + BatchUpdateException ex = new BatchUpdateException(reason, state, errorCode, + uc, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Create BatchUpdateException with message, SQLState, errorCode code + * Throwable, and long [] update counts + */ + @Test + public void test9() { + BatchUpdateException ex = new BatchUpdateException(reason, state, errorCode, + luc, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode + && Arrays.equals(ex.getUpdateCounts(), uc) + && Arrays.equals(ex.getLargeUpdateCounts(), luc) + ); + } + + /** + * Validate that a copy of the update counts array is made + */ + @Test + public void test10() { + int[] uc1 = {1, 2}; + BatchUpdateException ex = new BatchUpdateException(uc1); + assertTrue(Arrays.equals(ex.getUpdateCounts(), uc1)); + uc1[0] = 6689; + assertFalse(Arrays.equals(ex.getUpdateCounts(), uc1)); + } + + /** + * Validate that if null is specified for the update count, it is returned + * as null + */ + @Test + public void test11() { + BatchUpdateException ex = new BatchUpdateException((int[]) null); + assertTrue(ex.getMessage() == null && ex.getSQLState() == null + && ex.getErrorCode() == 0 && ex.getUpdateCounts() == null + && ex.getLargeUpdateCounts() == null); + } + + /** + * Serialize a BatchUpdateException and make sure you can read it back + * properly + */ + @Test + public void test12() throws Exception { + BatchUpdateException be = new BatchUpdateException(reason, state, errorCode, + uc, t); + BatchUpdateException bue + = createSerializedException(be); + assertTrue(reason.equals(bue.getMessage()) + && bue.getSQLState().equals(state) + && cause.equals(bue.getCause().toString()) + && bue.getErrorCode() == errorCode + && Arrays.equals(bue.getLargeUpdateCounts(), luc) + && Arrays.equals(bue.getUpdateCounts(), uc)); + } + + + + /** + * De-Serialize a BatchUpdateException from JDBC 4.0 and make sure you can + * read it back properly + */ + @Test + public void test13() throws Exception { + String reason1 = "This was the error msg"; + String state1 = "user defined sqlState"; + String cause1 = "java.lang.Throwable: throw 1"; + int errorCode1 = 99999; + Throwable t = new Throwable("throw 1"); + int[] uc1 = {1, 2, 21}; + long[] luc1 = {1, 2, 21}; + + ObjectInputStream ois = new ObjectInputStream( + new ByteArrayInputStream(SerializedBatchUpdateException.DATA)); + BatchUpdateException bue = (BatchUpdateException) ois.readObject(); + assertTrue(reason1.equals(bue.getMessage()) + && bue.getSQLState().equals(state1) + && bue.getErrorCode() == errorCode1 + && cause1.equals(bue.getCause().toString()) + && Arrays.equals(bue.getLargeUpdateCounts(), luc1) + && Arrays.equals(bue.getUpdateCounts(), uc1)); + } + + /** + * Serialize a BatchUpdateException with an Integer.MAX_VALUE + 1 and + * validate you can read it back properly + */ + @Test + public void test14() throws Exception { + int[] uc1 = {Integer.MAX_VALUE, Integer.MAX_VALUE + 1}; + long[] luc1 = {Integer.MAX_VALUE, Integer.MAX_VALUE + 1}; + BatchUpdateException be = new BatchUpdateException(reason, state, errorCode, + luc1, t); + BatchUpdateException bue + = createSerializedException(be); + assertTrue(reason.equals(bue.getMessage()) + && bue.getSQLState().equals(state) + && cause.equals(bue.getCause().toString()) + && bue.getErrorCode() == errorCode + && Arrays.equals(bue.getLargeUpdateCounts(), luc1) + && Arrays.equals(bue.getUpdateCounts(), uc1)); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test15() { + BatchUpdateException ex = new BatchUpdateException("Exception 1", uc, t1); + BatchUpdateException ex1 = new BatchUpdateException("Exception 2", uc); + BatchUpdateException ex2 = new BatchUpdateException("Exception 3", uc, t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test16() { + BatchUpdateException ex = new BatchUpdateException("Exception 1", uc, t1); + BatchUpdateException ex1 = new BatchUpdateException("Exception 2", uc); + BatchUpdateException ex2 = new BatchUpdateException("Exception 3", uc, t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + SQLException sqe = ex; + int num = 0; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + +} --- /dev/null 2014-10-28 10:29:45.000000000 -0400 +++ new/test/java/sql/testng/test/sql/DataTruncationTests.java 2014-10-28 10:29:44.000000000 -0400 @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.DataTruncation; +import java.sql.SQLException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class DataTruncationTests extends BaseTest { + + private final String READ_TRUNCATION = "01004"; + private final String WRITE_TRUNCATION = "22001"; + private final String dtReason = "Data truncation"; + private final int dterrorCode = 0; + private final String[] dtmsgs = {dtReason, "cause 1", dtReason, + dtReason, "cause 2"}; + private boolean onRead = false; + private final boolean parameter = false; + private final int index = 21; + private final int dataSize = 25; + private final int transferSize = 10; + + /** + * Create DataTruncation object indicating a truncation on read + */ + @Test + public void test() { + onRead = true; + DataTruncation e = new DataTruncation(index, parameter, onRead, + dataSize, transferSize); + assertTrue(e.getMessage().equals(dtReason) + && e.getSQLState().equals(READ_TRUNCATION) + && e.getCause() == null + && e.getErrorCode() == dterrorCode + && e.getParameter() == parameter + && e.getRead() == onRead + && e.getDataSize() == dataSize + && e.getTransferSize() == transferSize + && e.getIndex() == index); + } + + /** + * Create DataTruncation object indicating a truncation on write + */ + @Test + public void test1() { + onRead = false; + DataTruncation e = new DataTruncation(index, parameter, onRead, + dataSize, transferSize); + assertTrue(e.getMessage().equals(dtReason) + && e.getSQLState().equals(WRITE_TRUNCATION) + && e.getCause() == null + && e.getErrorCode() == dterrorCode + && e.getParameter() == parameter + && e.getRead() == onRead + && e.getDataSize() == dataSize + && e.getTransferSize() == transferSize + && e.getIndex() == index); + } + + /** + * Create DataTruncation object indicating a truncation on read with a + * Throwable + */ + @Test + public void test2() { + onRead = true; + DataTruncation e = new DataTruncation(index, parameter, onRead, + dataSize, transferSize, t); + assertTrue(e.getMessage().equals(dtReason) + && e.getSQLState().equals(READ_TRUNCATION) + && cause.equals(e.getCause().toString()) + && e.getErrorCode() == dterrorCode + && e.getParameter() == parameter + && e.getRead() == onRead + && e.getDataSize() == dataSize + && e.getTransferSize() == transferSize + && e.getIndex() == index); + } + + /** + * Create DataTruncation object indicating a truncation on read with null + * specified for the Throwable + */ + @Test + public void test3() { + onRead = true;; + DataTruncation e = new DataTruncation(index, parameter, onRead, + dataSize, transferSize, null); + assertTrue(e.getMessage().equals(dtReason) + && e.getSQLState().equals(READ_TRUNCATION) + && e.getCause() == null + && e.getErrorCode() == dterrorCode + && e.getParameter() == parameter + && e.getRead() == onRead + && e.getDataSize() == dataSize + && e.getTransferSize() == transferSize + && e.getIndex() == index); + } + + /** + * Create DataTruncation object indicating a truncation on read and you can + * pass a -1 for the index + */ + @Test + public void test4() { + onRead = true; + int negIndex = -1; + DataTruncation e = new DataTruncation(negIndex, parameter, onRead, + dataSize, transferSize); + assertTrue(e.getMessage().equals(dtReason) + && e.getSQLState().equals(READ_TRUNCATION) + && e.getCause() == null + && e.getErrorCode() == dterrorCode + && e.getParameter() == parameter + && e.getRead() == onRead + && e.getDataSize() == dataSize + && e.getTransferSize() == transferSize + && e.getIndex() == negIndex); + } + + /** + * Serialize a DataTruncation and make sure you can read it back properly + */ + @Test + public void test5() throws Exception { + DataTruncation e = new DataTruncation(index, parameter, onRead, + dataSize, transferSize); + DataTruncation ex1 = createSerializedException(e); + assertTrue(e.getMessage().equals(dtReason) + && e.getSQLState().equals(READ_TRUNCATION) + && e.getCause() == null + && e.getErrorCode() == dterrorCode + && e.getParameter() == parameter + && e.getRead() == onRead + && e.getDataSize() == dataSize + && e.getTransferSize() == transferSize + && e.getIndex() == index); + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * for-each loop + */ + @Test + public void test11() { + DataTruncation ex = new DataTruncation(index, parameter, onRead, + dataSize, transferSize, t1); + DataTruncation ex1 = new DataTruncation(index, parameter, onRead, + dataSize, transferSize); + DataTruncation ex2 = new DataTruncation(index, parameter, onRead, + dataSize, transferSize, t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(dtmsgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * traditional while loop + */ + @Test + public void test12() { + DataTruncation ex = new DataTruncation(index, parameter, onRead, + dataSize, transferSize, t1); + DataTruncation ex1 = new DataTruncation(index, parameter, onRead, + dataSize, transferSize); + DataTruncation ex2 = new DataTruncation(index, parameter, onRead, + dataSize, transferSize, t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(dtmsgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(dtmsgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } +} --- /dev/null 2014-10-28 10:29:46.000000000 -0400 +++ new/test/java/sql/testng/test/sql/DateTests.java 2014-10-28 10:29:45.000000000 -0400 @@ -0,0 +1,373 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.Date; +import java.time.Instant; +import java.time.LocalDate; +import static org.testng.Assert.*; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; +import util.BaseTest; + +public class DateTests extends BaseTest { + + /* + * Validate an IllegalArgumentException is thrown for an invalid Date string + */ + @Test(dataProvider = "invalidDateValues", + expectedExceptions = IllegalArgumentException.class) + public void test(String d) throws Exception { + Date.valueOf(d); + } + + /* + * Test that a date created from a date string is equal to the value + * returned from toString() + */ + @Test(dataProvider = "validDateValues") + public void test00(String d, String expectedD) { + Date d1 = Date.valueOf(d); + Date d2 = Date.valueOf(expectedD); + assertTrue(d1.equals(d2) && d2.equals(d1) + && d1.toString().equals(expectedD), "Error d1 != d2"); + } + + /* + * Validate that a Date.after() returns false when same date is compared + */ + @Test + public void test01() { + Date d = Date.valueOf("1961-08-30"); + assertFalse(d.after(d), "Error d.after(d) = true"); + } + + /* + * Validate that a Date.after() returns true when later date is compared to + * earlier date + */ + @Test + public void test2() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(System.currentTimeMillis()); + assertTrue(d2.after(d), "Error d2.after(d) = false"); + } + + /* + * Validate that a Date.after() returns false when earlier date is compared + * to later date + */ + @Test + public void test3() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(d.getTime()); + assertFalse(d.after(d2), "Error d.after(d2) = true"); + } + + /* + * Validate that a Date.after() returns false when date compared to another + * date created from the original date + */ + @Test + public void test4() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(d.getTime()); + assertFalse(d.after(d2), "Error d.after(d2) = true"); + assertFalse(d2.after(d), "Error d2.after(d) = true"); + } + + /* + * Validate that a Date.before() returns false when same date is compared + */ + @Test + public void test5() { + Date d = Date.valueOf("1961-08-30"); + assertFalse(d.before(d), "Error d.before(d) = true"); + } + + /* + * Validate that a Date.before() returns true when earlier date is compared + * to later date + */ + @Test + public void test6() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(System.currentTimeMillis()); + assertTrue(d.before(d2), "Error d.before(d2) = false"); + } + + /* + * Validate that a Date.before() returns false when later date is compared + * to earlier date + */ + @Test + public void test7() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(d.getTime()); + assertFalse(d2.before(d), "Error d2.before(d) = true"); + } + + /* + * Validate that a Date.before() returns false when date compared to another + * date created from the original date + */ + @Test + public void test8() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(d.getTime()); + assertFalse(d.before(d2), "Error d.before(d2) = true"); + assertFalse(d2.before(d), "Error d2.before(d) = true"); + } + + /* + * Validate that a Date.compareTo returns 0 when both Date objects are the + * same + */ + @Test + public void test9() { + Date d = Date.valueOf("1961-08-30"); + assertTrue(d.compareTo(d) == 0, "Error d.compareTo(d) !=0"); + } + + /* + * Validate that a Date.compareTo returns 0 when both Date objects represent + * the same date + */ + @Test + public void test10() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(d.getTime()); + assertTrue(d.compareTo(d2) == 0, "Error d.compareTo(d2) !=0"); + } + + /* + * Validate that a Date.compareTo returns -1 when comparing a date to a + * later date + */ + @Test + public void test11() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(System.currentTimeMillis()); + assertTrue(d.compareTo(d2) == -1, "Error d.compareTo(d2) != -1"); + } + + /* + * Validate that a Date.compareTo returns 1 when comparing a date to an + * earlier date + */ + @Test + public void test12() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(System.currentTimeMillis()); + assertTrue(d2.compareTo(d) == 1, "Error d.compareTo(d2) != 1"); + } + + /* + * Validate that a Date made from a LocalDate are equal + */ + @Test + public void test13() { + Date d = Date.valueOf("1961-08-30"); + LocalDate ldt = d.toLocalDate(); + Date d2 = Date.valueOf(ldt); + assertTrue(d.equals(d2), "Error d != d2"); + } + + /* + * Validate that a Date LocalDate value, made from a LocalDate are equal + */ + @Test + public void test14() { + LocalDate ldt = LocalDate.now(); + Date d = Date.valueOf(ldt); + assertTrue(ldt.equals(d.toLocalDate()), + "Error LocalDate values are not equal"); + } + + /* + * Validate an NPE occurs when a null LocalDate is passed to valueOf + */ + @Test(expectedExceptions = NullPointerException.class) + public void test15() throws Exception { + LocalDate ld = null; + Date.valueOf(ld); + } + + /* + * Validate an UnsupportedOperationException occurs when toInstant() is + * called + */ + @Test(expectedExceptions = UnsupportedOperationException.class) + public void test16() throws Exception { + Date d = Date.valueOf("1961-08-30"); + Instant instant = d.toInstant(); + } + + /* + * Validate that two Date objects are equal when one is created from the + * toString() of the other + */ + @Test + public void test17() { + Date d = Date.valueOf("1961-08-30"); + Date d2 = Date.valueOf(d.toString()); + assertTrue(d.equals(d2) && d2.equals(d), "Error d != d2"); + } + + /* + * Validate that two Date values one created using valueOf and another via a + * constructor are equal + */ + @Test + public void test18() { + + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(61, 7, 30); + assertTrue(d.equals(d2), "Error d != d2"); + } + + /* + * Validate that two Date values one created using getTime() of the other + * are equal + */ + @Test + public void test19() { + + Date d = Date.valueOf("1961-08-30"); + Date d2 = new Date(d.getTime()); + assertTrue(d.equals(d2), "Error d != d2"); + } + + /* + * Validate that a Date value is equal to itself + */ + @Test + public void test20() { + + Date d = Date.valueOf("1961-08-30"); + assertTrue(d.equals(d), "Error d != d"); + } + + /* + * Validate an IllegalArgumentException is thrown for calling getHours + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test21() throws Exception { + Date d = Date.valueOf("1961-08-30"); + d.getHours(); + } + + /* + * Validate an IllegalArgumentException is thrown for calling getMinutes + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test22() throws Exception { + Date d = Date.valueOf("1961-08-30"); + d.getMinutes(); + } + + /* + * Validate an IllegalArgumentException is thrown for calling getSeconds + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test23() throws Exception { + Date d = Date.valueOf("1961-08-30"); + d.getSeconds(); + } + + /* + * Validate an IllegalArgumentException is thrown for calling setHours + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test24() throws Exception { + Date d = Date.valueOf("1961-08-30"); + d.setHours(8); + } + + /* + * Validate an IllegalArgumentException is thrown for calling setMinutes + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test25() throws Exception { + Date d = Date.valueOf("1961-08-30"); + d.setMinutes(0); + } + + /* + * Validate an IllegalArgumentException is thrown for calling setSeconds + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test26() throws Exception { + Date d = Date.valueOf("1961-08-30"); + d.setSeconds(0); + } + + /* + * DataProvider used to provide Date which are not valid and are used + * to validate that an IllegalArgumentException will be thrown from the + * valueOf method + */ + @DataProvider(name = "invalidDateValues") + private Object[][] invalidDateValues() { + return new Object[][]{ + {"20009-11-01"}, + {"09-11-01"}, + {"-11-01"}, + {"2009-111-01"}, + {"2009--01"}, + {"2009-13-01"}, + {"2009-11-011"}, + {"2009-11-"}, + {"2009-11-00"}, + {"2009-11-33"}, + {"--"}, + {""}, + {null}, + {"-"}, + {"2009"}, + {"2009-01"}, + {"---"}, + {"2009-13--1"}, + {"1900-1-0"}, + {"2009-01-01 10:50:01"}, + {"1996-12-10 12:26:19.1"}, + {"10:50:01"} + }; + } + + /* + * DataProvider used to provide Dates which are valid and are used + * to validate that an IllegalArgumentException will not be thrown from the + * valueOf method and the corect value from toString() is returned + */ + @DataProvider(name = "validDateValues") + private Object[][] validDateValues() { + return new Object[][]{ + {"2009-08-30", "2009-08-30"}, + {"2009-01-8", "2009-01-08"}, + {"2009-1-01", "2009-01-01"}, + {"2009-1-1", "2009-01-01"} + + }; + } +} --- /dev/null 2014-10-28 10:29:47.000000000 -0400 +++ new/test/java/sql/testng/test/sql/DriverManagerPermissionsTests.java 2014-10-28 10:29:46.000000000 -0400 @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.security.AccessControlException; +import java.security.Policy; +import java.sql.DriverManager; +import java.sql.SQLException; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.Test; +import util.BaseTest; +import util.StubDriver; +import util.TestPolicy; + +public class DriverManagerPermissionsTests extends BaseTest { + + private static Policy policy; + private static SecurityManager sm; + + /* + * Install a SecurityManager along with a base Policy to allow testNG to run + */ + @BeforeClass + public static void setUpClass() throws Exception { + setPolicy(new TestPolicy()); + System.setSecurityManager(new SecurityManager()); + } + + /* + * Install the original Policy and SecurityManager + */ + @AfterClass + public static void tearDownClass() throws Exception { + System.setSecurityManager(sm); + setPolicy(policy); + } + + /* + * Save off the original Policy and SecurityManager + */ + public DriverManagerPermissionsTests() { + policy = Policy.getPolicy(); + sm = System.getSecurityManager(); + } + + /* + * Validate that AccessControlException is thrown if SQLPermission("setLog") + * has not been granted + */ + @Test(expectedExceptions = AccessControlException.class) + public void test() { + setPolicy(new TestPolicy()); + DriverManager.setLogStream(null); + } + + /* + * Validate that setLogStream succeeds if SQLPermission("setLog") has been + * granted + */ + @Test + public void test1() { + Policy.setPolicy(new TestPolicy("setLog")); + DriverManager.setLogStream(null); + } + + /* + * Validate that setLogStream succeeds if AllPermissions has been granted + */ + @Test + public void test2() { + setPolicy(new TestPolicy("all")); + DriverManager.setLogStream(null); + } + + /* + * Validate that AccessControlException is thrown if SQLPermission("setLog") + * has not been granted + */ + @Test(expectedExceptions = AccessControlException.class) + public void test4() { + setPolicy(new TestPolicy()); + DriverManager.setLogWriter(null); + } + + /* + * Validate that setLogWriter succeeds if SQLPermission("setLog") has been + * granted + */ + @Test + public void test5() { + setPolicy(new TestPolicy("setLog")); + DriverManager.setLogWriter(null); + } + + /* + * Validate that setLogWriter succeeds if AllPermissions has been granted + */ + @Test + public void test6() { + setPolicy(new TestPolicy("all")); + DriverManager.setLogWriter(null); + } + + /* + * Validate that AccessControlException is thrown if + * SQLPermission("deregisterDriver") has not been granted + */ + @Test(expectedExceptions = AccessControlException.class) + public void test7() throws SQLException { + setPolicy(new TestPolicy()); + DriverManager.deregisterDriver(new StubDriver()); + } + + /* + * Validate that deregisterDriver succeeds if + * SQLPermission("deregisterDriver") has been granted + */ + @Test + public void test8() throws SQLException { + setPolicy(new TestPolicy("deregisterDriver")); + DriverManager.deregisterDriver(new StubDriver()); + } + + /* + * Validate that deregisterDriver succeeds if AllPermissions has been + * granted + */ + @Test + public void test9() throws SQLException { + setPolicy(new TestPolicy("all")); + DriverManager.deregisterDriver(new StubDriver()); + } +} --- /dev/null 2014-10-28 10:29:48.000000000 -0400 +++ new/test/java/sql/testng/test/sql/DriverManagerTests.java 2014-10-28 10:29:47.000000000 -0400 @@ -0,0 +1,354 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.io.BufferedReader; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.CharArrayReader; +import java.io.CharArrayWriter; +import java.io.File; +import java.io.InputStreamReader; +import java.io.PrintStream; +import java.io.PrintWriter; +import java.sql.Driver; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Properties; +import static org.testng.Assert.*; +import org.testng.annotations.AfterClass; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; +import util.StubDriver; + +public class DriverManagerTests { + + private final String StubDriverURL = "jdbc:tennis:boy"; + private final String StubDriverDAURL = "jdbc:luckydog:tennis"; + private final String InvalidURL = "jdbc:cardio:tennis"; + private String[] results = {"output", "more output", "and more", "the end"}; + private String noOutput = "should not find this"; + + public DriverManagerTests() { + } + + @BeforeClass + public static void setUpClass() throws Exception { + } + + @AfterClass + public static void tearDownClass() throws Exception { + } + + @BeforeMethod + public void setUpMethod() throws Exception { + removeAllDrivers(); + } + + @AfterMethod + public void tearDownMethod() throws Exception { + } + + /** + * Utility method to remove all registered drivers + */ + private static void removeAllDrivers() { + java.util.Enumeration e = DriverManager.getDrivers(); + while (e.hasMoreElements()) { + try { + DriverManager.deregisterDriver((Driver) (e.nextElement())); + } catch (SQLException ex) { + System.out.print(ex.getMessage()); + } + } + } + + /** + * Utility method to see if a driver is registered + */ + private boolean isDriverRegistered(Driver d) { + boolean foundDriver = false; + java.util.Enumeration e = DriverManager.getDrivers(); + while (e.hasMoreElements()) { + if (d == (Driver) e.nextElement()) { + foundDriver = true; + break; + } + } + return foundDriver; + } + + /** + * Validate that values set using setLoginTimeout will be returned by + * getLoginTimeout + */ + @Test + public void test() { + int[] vals = {-1, 0, 5}; + for (int val : vals) { + DriverManager.setLoginTimeout(val); + assertEquals(val, DriverManager.getLoginTimeout()); + } + } + + /** + * Validate that NullPointerException is thrown when null is passed to + * registerDriver + */ + @Test(expectedExceptions = NullPointerException.class) + public void test1() throws Exception { + Driver d = null; + DriverManager.registerDriver(d); + } + + /** + * Validate that NullPointerException is thrown when null is passed to + * registerDriver + */ + @Test(expectedExceptions = NullPointerException.class) + public void test2() throws Exception { + Driver d = null; + DriverManager.registerDriver(d, null); + } + + /** + * Validate that a null value allows for deRegisterDriver to return + */ + @Test + public void test3() throws Exception { + DriverManager.deregisterDriver(null); + + } + + /** + * Validate that SQLException is thrown when there is no Driver to service + * the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test4() throws Exception { + DriverManager.getConnection(InvalidURL); + } + + /** + * Validate that SQLException is thrown when there is no Driver to service + * the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test5() throws Exception { + DriverManager.getConnection(InvalidURL, new Properties()); + } + + /** + * Validate that SQLException is thrown when there is no Driver to service + * the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test6() throws Exception { + DriverManager.getConnection(InvalidURL, "LuckyDog", "tennisanyone"); + } + + /** + * Validate that SQLException is thrown when null is passed for the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test7() throws Exception { + DriverManager.getConnection(null); + } + + /** + * Validate that SQLException is thrown when null is passed for the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test8() throws Exception { + DriverManager.getConnection(null, new Properties()); + } + + /** + * Validate that SQLException is thrown when null is passed for the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test9() throws Exception { + DriverManager.getConnection(null, "LuckyDog", "tennisanyone"); + } + + /** + * Validate that SQLException is thrown when there is no Driver to service + * the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test10() throws Exception { + DriverManager.getDriver(InvalidURL); + } + + /** + * Validate that SQLException is thrown when null is passed for the URL + */ + @Test(expectedExceptions = SQLException.class) + public void test11() throws Exception { + DriverManager.getDriver(null); + } + + /** + * Validate that a non-null Driver is returned by getDriver when a valid URL + * is specified + */ + @Test + public void test12() throws Exception { + + DriverManager.registerDriver(new StubDriver()); + assertTrue(DriverManager.getDriver(StubDriverURL) != null); + } + + /** + * Validate that SQLException is thrown when the URL is not valid for any of + * the registered drivers + */ + @Test(expectedExceptions = SQLException.class) + public void test13() throws Exception { + DriverManager.registerDriver(new StubDriver()); + DriverManager.getDriver(InvalidURL); + } + + /** + * Validate that a Connection object is returned when a valid URL is + * specified to getConnection + * + */ + @Test + public void test14() throws Exception { + + DriverManager.registerDriver(new StubDriver()); + assertTrue( + DriverManager.getConnection(StubDriverURL) != null); + assertTrue(DriverManager.getConnection(StubDriverURL, + "LuckyDog", "tennisanyone") != null); + Properties props = new Properties(); + props.put("user", "LuckyDog"); + props.put("password", "tennisanyone"); + assertTrue( + DriverManager.getConnection(StubDriverURL, + props) != null); + } + + /** + * Register a driver and make sure you find it via its URL. Deregister the + * driver and validate it is not longer registered + * + * @throws Exception + */ + @Test() + public void test15() throws Exception { + DriverManager.registerDriver(new StubDriver()); + Driver d = DriverManager.getDriver(StubDriverURL); + assertTrue(d != null); + assertTrue(isDriverRegistered(d)); + DriverManager.deregisterDriver(d); + assertFalse(isDriverRegistered(d)); + } + + /** + * Validate that DriverAction.release is called when a driver is registered + * via registerDriver(Driver, DriverAction) + * + * @throws Exception + */ + @Test + public void test16() throws Exception { + File file = new File(util.StubDriverDA.DriverActionCalled); + file.delete(); + assertFalse(file.exists()); + Driver d = null; + Class.forName("util.StubDriverDA"); + d = DriverManager.getDriver(StubDriverDAURL); + DriverManager.deregisterDriver(d); + assertFalse(isDriverRegistered(d), "Driver is registered"); + assertTrue(file.exists()); + } + + /** + * Create a PrintStream and use to send output via DriverManager.println + * Validate that if you disable the stream, the output sent is not present + */ + @Test + public void tests17() throws Exception { + ByteArrayOutputStream os = new ByteArrayOutputStream(); + PrintStream ps = new PrintStream(os); + DriverManager.setLogStream(ps); + assertTrue(DriverManager.getLogStream() == ps); + + DriverManager.println(results[0]); + DriverManager.setLogStream((PrintStream) null); + assertTrue(DriverManager.getLogStream() == null); + DriverManager.println(noOutput); + DriverManager.setLogStream(ps); + DriverManager.println(results[1]); + DriverManager.println(results[2]); + DriverManager.println(results[3]); + DriverManager.setLogStream((PrintStream) null); + DriverManager.println(noOutput); + + /* + * Check we do not get the output when the stream is disabled + */ + InputStreamReader is + = new InputStreamReader(new ByteArrayInputStream(os.toByteArray())); + BufferedReader reader = new BufferedReader(is); + for (String result : results) { + assertTrue(result.equals(reader.readLine())); + } + } + + /** + * Create a PrintWriter and use to to send output via DriverManager.println + * Validate that if you disable the writer, the output sent is not present + */ + @Test + public void tests18() throws Exception { + CharArrayWriter cw = new CharArrayWriter(); + PrintWriter pw = new PrintWriter(cw); + DriverManager.setLogWriter(pw); + assertTrue(DriverManager.getLogWriter() == pw); + + DriverManager.println(results[0]); + DriverManager.setLogWriter(null); + assertTrue(DriverManager.getLogWriter() == null); + DriverManager.println(noOutput); + DriverManager.setLogWriter(pw); + DriverManager.println(results[1]); + DriverManager.println(results[2]); + DriverManager.println(results[3]); + DriverManager.setLogWriter(null); + DriverManager.println(noOutput); + + /* + * Check we do not get the output when the stream is disabled + */ + BufferedReader reader + = new BufferedReader(new CharArrayReader(cw.toCharArray())); + for (String result : results) { + assertTrue(result.equals(reader.readLine())); + } + } +} --- /dev/null 2014-10-28 10:29:48.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLClientInfoExceptionTests.java 2014-10-28 10:29:48.000000000 -0400 @@ -0,0 +1,227 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.ClientInfoStatus; +import java.sql.SQLClientInfoException; +import java.sql.SQLException; +import java.util.HashMap; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLClientInfoExceptionTests extends BaseTest { + + private final HashMap map = new HashMap<>(); + + public SQLClientInfoExceptionTests() { + map.put("1", ClientInfoStatus.REASON_UNKNOWN_PROPERTY); + map.put("21", ClientInfoStatus.REASON_UNKNOWN_PROPERTY); + } + + /** + * Create SQLClientInfoException and setting all objects to null + */ + @Test + public void test() { + SQLClientInfoException e = new SQLClientInfoException(null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == 0 + && e.getFailedProperties() == null); + } + + /** + * Create SQLClientInfoException with no-arg constructor + */ + @Test + public void test1() { + SQLClientInfoException ex = new SQLClientInfoException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getFailedProperties() == null); + } + + /** + * Create SQLClientInfoException with null Throwable + */ + @Test + public void test2() { + + SQLClientInfoException ex = new SQLClientInfoException(map, null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getFailedProperties().equals(map)); + } + + /** + * Create SQLClientInfoException with message + */ + @Test + public void test3() { + SQLClientInfoException ex = new SQLClientInfoException(reason, map); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getFailedProperties().equals(map)); + } + + /** + * Create SQLClientInfoException with null Throwable + */ + @Test + public void test4() { + SQLClientInfoException ex = new SQLClientInfoException(reason, map, null); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getFailedProperties().equals(map)); + } + + /** + * Create SQLClientInfoException with message, and SQLState + */ + @Test + public void test5() { + SQLClientInfoException ex = new SQLClientInfoException(reason, state, + map); + + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0 + && ex.getFailedProperties().equals(map)); + } + + /** + * Create SQLClientInfoException with message, and SQLState + */ + @Test + public void test6() { + SQLClientInfoException ex = new SQLClientInfoException(reason, state, + map, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0 + && ex.getFailedProperties().equals(map)); + } + + /** + * Create SQLClientInfoException with message, SQLState, errorCode, and + * Throwable + */ + @Test + public void test7() { + SQLClientInfoException ex = new SQLClientInfoException(reason, state, + errorCode, map); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode + && ex.getFailedProperties().equals(map)); + } + + /** + * Create SQLClientInfoException with message, SQLState, and error code + */ + @Test + public void test8() { + SQLClientInfoException ex = new SQLClientInfoException(reason, state, + errorCode, map, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode + && ex.getFailedProperties().equals(map)); + } + + /** + * Serialize a SQLClientInfoException and make sure you can read it back + * properly + */ + @Test + public void test10() throws Exception { + SQLClientInfoException e = new SQLClientInfoException(reason, state, + errorCode, map, t); + SQLClientInfoException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode + && ex1.getFailedProperties().equals(map)); + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * for-each loop + */ + @Test + public void test11() { + SQLClientInfoException ex = new SQLClientInfoException("Exception 1", + map, t1); + SQLClientInfoException ex1 = new SQLClientInfoException("Exception 2", + map); + SQLClientInfoException ex2 = new SQLClientInfoException("Exception 3", + map, t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * traditional while loop + */ + @Test + public void test12() { + SQLClientInfoException ex = new SQLClientInfoException("Exception 1", + map, t1); + SQLClientInfoException ex1 = new SQLClientInfoException("Exception 2", + map); + SQLClientInfoException ex2 = new SQLClientInfoException("Exception 3", + map, t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } +} --- /dev/null 2014-10-28 10:29:49.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLDataExceptionTests.java 2014-10-28 10:29:49.000000000 -0400 @@ -0,0 +1,215 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLDataException; +import java.sql.SQLException; +import java.sql.SQLNonTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLDataExceptionTests extends BaseTest { + + /** + * Create SQLDataException and setting all objects to null + */ + @Test + public void test() { + SQLDataException e = new SQLDataException(null, null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLDataException with no-arg constructor + */ + @Test + public void test1() { + SQLDataException ex = new SQLDataException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLDataException with message + */ + @Test + public void test2() { + SQLDataException ex = new SQLDataException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLDataException with message, and SQLState + */ + @Test + public void test3() { + SQLDataException ex = new SQLDataException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLDataException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLDataException ex = new SQLDataException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLDataException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLDataException ex = new SQLDataException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLDataException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLDataException ex = new SQLDataException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLDataException with message, and Throwable + */ + @Test + public void test7() { + SQLDataException ex = new SQLDataException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLDataException with null Throwable + */ + @Test + public void test8() { + SQLDataException ex = new SQLDataException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLDataException with Throwable + */ + @Test + public void test9() { + SQLDataException ex = new SQLDataException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLDataException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLDataException e = new SQLDataException(reason, state, errorCode, t); + SQLDataException ex1 = createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLDataException ex = new SQLDataException("Exception 1", t1); + SQLDataException ex1 = new SQLDataException("Exception 2"); + SQLDataException ex2 = new SQLDataException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLDataException ex = new SQLDataException("Exception 1", t1); + SQLDataException ex1 = new SQLDataException("Exception 2"); + SQLDataException ex2 = new SQLDataException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLDataException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLDataException(); + assertTrue(ex instanceof SQLNonTransientException); + } +} --- /dev/null 2014-10-28 10:29:50.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLExceptionTests.java 2014-10-28 10:29:50.000000000 -0400 @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLExceptionTests extends BaseTest { + + /** + * Create SQLException and setting all objects to null + */ + @Test + public void test() { + SQLException e = new SQLException(null, null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLException with no-arg constructor + */ + @Test + public void test1() { + SQLException ex = new SQLException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLException with message + */ + @Test + public void test2() { + SQLException ex = new SQLException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLException with message, and SQLState + */ + @Test + public void test3() { + SQLException ex = new SQLException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLException ex = new SQLException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLException ex = new SQLException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLException ex = new SQLException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLException with message, and Throwable + */ + @Test + public void test7() { + SQLException ex = new SQLException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLException with null Throwable + */ + @Test + public void test8() { + SQLException ex = new SQLException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLException with Throwable + */ + @Test + public void test9() { + SQLException ex = new SQLException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLException e = new SQLException(reason, state, errorCode, t); + SQLException ex1 = createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLException ex = new SQLException("Exception 1", t1); + SQLException ex1 = new SQLException("Exception 2"); + SQLException ex2 = new SQLException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLException ex = new SQLException("Exception 1", t1); + SQLException ex1 = new SQLException("Exception 2"); + SQLException ex2 = new SQLException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + while (ex != null) { + assertTrue(msgs[num++].equals(ex.getMessage())); + Throwable c = ex.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + ex = ex.getNextException(); + } + } +} --- /dev/null 2014-10-28 10:29:51.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLFeatureNotSupportedExceptionTests.java 2014-10-28 10:29:51.000000000 -0400 @@ -0,0 +1,232 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; +import java.sql.SQLNonTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLFeatureNotSupportedExceptionTests extends BaseTest { + + /** + * Create SQLFeatureNotSupportedException and setting all objects to null + */ + @Test + public void test() { + SQLFeatureNotSupportedException e = + new SQLFeatureNotSupportedException(null, null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLFeatureNotSupportedException with no-arg constructor + */ + @Test + public void test1() { + SQLFeatureNotSupportedException ex = new SQLFeatureNotSupportedException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLFeatureNotSupportedException with message + */ + @Test + public void test2() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLFeatureNotSupportedException with message, and SQLState + */ + @Test + public void test3() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLFeatureNotSupportedException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLFeatureNotSupportedException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLFeatureNotSupportedException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLFeatureNotSupportedException with message, and Throwable + */ + @Test + public void test7() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLFeatureNotSupportedException with null Throwable + */ + @Test + public void test8() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException((Throwable) null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLFeatureNotSupportedException with Throwable + */ + @Test + public void test9() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLFeatureNotSupportedException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLFeatureNotSupportedException e = + new SQLFeatureNotSupportedException(reason, state, errorCode, t); + SQLFeatureNotSupportedException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException("Exception 1", t1); + SQLFeatureNotSupportedException ex1 = + new SQLFeatureNotSupportedException("Exception 2"); + SQLFeatureNotSupportedException ex2 = + new SQLFeatureNotSupportedException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLFeatureNotSupportedException ex = + new SQLFeatureNotSupportedException("Exception 1", t1); + SQLFeatureNotSupportedException ex1 = + new SQLFeatureNotSupportedException("Exception 2"); + SQLFeatureNotSupportedException ex2 = + new SQLFeatureNotSupportedException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLFeatureNotSupportedException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLFeatureNotSupportedException(); + assertTrue(ex instanceof SQLNonTransientException); + } +} --- /dev/null 2014-10-28 10:29:52.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLIntegrityConstraintViolationExceptionTests.java 2014-10-28 10:29:52.000000000 -0400 @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLIntegrityConstraintViolationException; +import java.sql.SQLNonTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLIntegrityConstraintViolationExceptionTests extends BaseTest { + + /** + * Create SQLIntegrityConstraintViolationException and setting all objects to null + */ + @Test + public void test() { + SQLIntegrityConstraintViolationException e = + new SQLIntegrityConstraintViolationException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLIntegrityConstraintViolationException with no-arg constructor + */ + @Test + public void test1() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLIntegrityConstraintViolationException with message + */ + @Test + public void test2() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLIntegrityConstraintViolationException with message, and SQLState + */ + @Test + public void test3() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLIntegrityConstraintViolationException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLIntegrityConstraintViolationException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLIntegrityConstraintViolationException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLIntegrityConstraintViolationException with message, and Throwable + */ + @Test + public void test7() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLIntegrityConstraintViolationException with null Throwable + */ + @Test + public void test8() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLIntegrityConstraintViolationException with Throwable + */ + @Test + public void test9() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLIntegrityConstraintViolationException and make sure + * you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLIntegrityConstraintViolationException e = + new SQLIntegrityConstraintViolationException(reason, state, errorCode, t); + SQLIntegrityConstraintViolationException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException("Exception 1", t1); + SQLIntegrityConstraintViolationException ex1 = + new SQLIntegrityConstraintViolationException("Exception 2"); + SQLIntegrityConstraintViolationException ex2 = + new SQLIntegrityConstraintViolationException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLIntegrityConstraintViolationException ex = + new SQLIntegrityConstraintViolationException("Exception 1", t1); + SQLIntegrityConstraintViolationException ex1 = + new SQLIntegrityConstraintViolationException("Exception 2"); + SQLIntegrityConstraintViolationException ex2 = + new SQLIntegrityConstraintViolationException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLIntegrityConstraintViolationException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLIntegrityConstraintViolationException(); + assertTrue(ex instanceof SQLNonTransientException); + } +} --- /dev/null 2014-10-28 10:29:53.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLInvalidAuthorizationSpecExceptionTests.java 2014-10-28 10:29:53.000000000 -0400 @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLInvalidAuthorizationSpecException; +import java.sql.SQLNonTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLInvalidAuthorizationSpecExceptionTests extends BaseTest { + + /** + * Create SQLInvalidAuthorizationSpecException and setting all objects to + * null + */ + @Test + public void test() { + SQLInvalidAuthorizationSpecException e + = new SQLInvalidAuthorizationSpecException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLInvalidAuthorizationSpecException with no-arg constructor + */ + @Test + public void test1() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLInvalidAuthorizationSpecException with message + */ + @Test + public void test2() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLInvalidAuthorizationSpecException with message, and SQLState + */ + @Test + public void test3() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLInvalidAuthorizationSpecException with message, SQLState, and + * error code + */ + @Test + public void test4() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLInvalidAuthorizationSpecException with message, SQLState, + * errorCode, and Throwable + */ + @Test + public void test5() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLInvalidAuthorizationSpecException with message, SQLState, and + * Throwable + */ + @Test + public void test6() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLInvalidAuthorizationSpecException with message, and Throwable + */ + @Test + public void test7() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLInvalidAuthorizationSpecException with null Throwable + */ + @Test + public void test8() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException((Throwable) null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLInvalidAuthorizationSpecException with Throwable + */ + @Test + public void test9() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLInvalidAuthorizationSpecException and make sure you can + * read it back properly + */ + @Test + public void test10() throws Exception { + SQLInvalidAuthorizationSpecException e + = new SQLInvalidAuthorizationSpecException(reason, state, errorCode, t); + SQLInvalidAuthorizationSpecException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * for-each loop + */ + @Test + public void test11() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException("Exception 1", t1); + SQLInvalidAuthorizationSpecException ex1 + = new SQLInvalidAuthorizationSpecException("Exception 2"); + SQLInvalidAuthorizationSpecException ex2 + = new SQLInvalidAuthorizationSpecException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * traditional while loop + */ + @Test + public void test12() { + SQLInvalidAuthorizationSpecException ex + = new SQLInvalidAuthorizationSpecException("Exception 1", t1); + SQLInvalidAuthorizationSpecException ex1 + = new SQLInvalidAuthorizationSpecException("Exception 2"); + SQLInvalidAuthorizationSpecException ex2 + = new SQLInvalidAuthorizationSpecException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLInvalidAuthorizationSpecException and validate it is an + * instance of SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLInvalidAuthorizationSpecException(); + assertTrue(ex instanceof SQLNonTransientException); + } +} --- /dev/null 2014-10-28 10:29:54.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLNonTransientConnectionExceptionTests.java 2014-10-28 10:29:54.000000000 -0400 @@ -0,0 +1,235 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLNonTransientConnectionException; +import java.sql.SQLNonTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLNonTransientConnectionExceptionTests extends BaseTest { + + /** + * Create SQLNonTransientConnectionException and setting all objects to null + */ + @Test + public void test() { + SQLNonTransientConnectionException e = + new SQLNonTransientConnectionException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLNonTransientConnectionException with no-arg constructor + */ + @Test + public void test1() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientConnectionException with message + */ + @Test + public void test2() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientConnectionException with message, and SQLState + */ + @Test + public void test3() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientConnectionException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLNonTransientConnectionException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLNonTransientConnectionException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientConnectionException with message, and Throwable + */ + @Test + public void test7() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientConnectionException with null Throwable + */ + @Test + public void test8() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientConnectionException with Throwable + */ + @Test + public void test9() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLNonTransientConnectionException and make sure you can + * read it back properly + */ + @Test + public void test10() throws Exception { + SQLNonTransientConnectionException e = + new SQLNonTransientConnectionException(reason, state, errorCode, t); + SQLNonTransientConnectionException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException("Exception 1", t1); + SQLNonTransientConnectionException ex1 = + new SQLNonTransientConnectionException("Exception 2"); + SQLNonTransientConnectionException ex2 = + new SQLNonTransientConnectionException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLNonTransientConnectionException ex = + new SQLNonTransientConnectionException("Exception 1", t1); + SQLNonTransientConnectionException ex1 = + new SQLNonTransientConnectionException("Exception 2"); + SQLNonTransientConnectionException ex2 = + new SQLNonTransientConnectionException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLNonTransientConnectionException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLNonTransientConnectionException(); + assertTrue(ex instanceof SQLNonTransientException); + } +} --- /dev/null 2014-10-28 10:29:55.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLNonTransientExceptionTests.java 2014-10-28 10:29:55.000000000 -0400 @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLNonTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLNonTransientExceptionTests extends BaseTest { + + /** + * Create SQLNonTransientException and setting all objects to null + */ + @Test + public void test() { + SQLNonTransientException e = new SQLNonTransientException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLNonTransientException with no-arg constructor + */ + @Test + public void test1() { + SQLNonTransientException ex = new SQLNonTransientException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientException with message + */ + @Test + public void test2() { + SQLNonTransientException ex = new SQLNonTransientException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientException with message, and SQLState + */ + @Test + public void test3() { + SQLNonTransientException ex = new SQLNonTransientException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientException with message, SQLState, and error code + */ + @Test + public void test4() {; + SQLNonTransientException ex = + new SQLNonTransientException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLNonTransientException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLNonTransientException ex = + new SQLNonTransientException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLNonTransientException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLNonTransientException ex = new SQLNonTransientException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientException with message, and Throwable + */ + @Test + public void test7() { + SQLNonTransientException ex = new SQLNonTransientException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientException with null Throwable + */ + @Test + public void test8() { + SQLNonTransientException ex = new SQLNonTransientException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLNonTransientException with Throwable + */ + @Test + public void test9() { + SQLNonTransientException ex = new SQLNonTransientException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLNonTransientException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLNonTransientException e = + new SQLNonTransientException(reason, state, errorCode, t); + SQLNonTransientException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLNonTransientException ex = new SQLNonTransientException("Exception 1", t1); + SQLNonTransientException ex1 = new SQLNonTransientException("Exception 2"); + SQLNonTransientException ex2 = new SQLNonTransientException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLNonTransientException ex = new SQLNonTransientException("Exception 1", t1); + SQLNonTransientException ex1 = new SQLNonTransientException("Exception 2"); + SQLNonTransientException ex2 = new SQLNonTransientException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } +} --- /dev/null 2014-10-28 10:29:56.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLRecoverableExceptionTests.java 2014-10-28 10:29:56.000000000 -0400 @@ -0,0 +1,209 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLRecoverableException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLRecoverableExceptionTests extends BaseTest { + + /** + * Create SQLRecoverableException and setting all objects to null + */ + @Test + public void test() { + SQLRecoverableException e = new SQLRecoverableException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLRecoverableException with no-arg constructor + */ + @Test + public void test1() { + SQLRecoverableException ex = new SQLRecoverableException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLRecoverableException with message + */ + @Test + public void test2() { + SQLRecoverableException ex = new SQLRecoverableException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLRecoverableException with message, and SQLState + */ + @Test + public void test3() { + SQLRecoverableException ex = new SQLRecoverableException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLRecoverableException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLRecoverableException ex = + new SQLRecoverableException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLRecoverableException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLRecoverableException ex = + new SQLRecoverableException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLRecoverableException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLRecoverableException ex = new SQLRecoverableException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLRecoverableException with message, and Throwable + */ + @Test + public void test7() { + SQLRecoverableException ex = new SQLRecoverableException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLRecoverableException with null Throwable + */ + @Test + public void test8() { + SQLRecoverableException ex = new SQLRecoverableException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLRecoverableException with Throwable + */ + @Test + public void test9() { + SQLRecoverableException ex = new SQLRecoverableException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLRecoverableException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLRecoverableException e = + new SQLRecoverableException(reason, state, errorCode, t); + SQLRecoverableException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLRecoverableException ex = new SQLRecoverableException("Exception 1", t1); + SQLRecoverableException ex1 = new SQLRecoverableException("Exception 2"); + SQLRecoverableException ex2 = new SQLRecoverableException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLRecoverableException ex = new SQLRecoverableException("Exception 1", t1); + SQLRecoverableException ex1 = new SQLRecoverableException("Exception 2"); + SQLRecoverableException ex2 = new SQLRecoverableException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } +} --- /dev/null 2014-10-28 10:29:57.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLSyntaxErrorExceptionTests.java 2014-10-28 10:29:57.000000000 -0400 @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLNonTransientException; +import java.sql.SQLSyntaxErrorException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLSyntaxErrorExceptionTests extends BaseTest { + + /** + * Create SQLSyntaxErrorException and setting all objects to null + */ + @Test + public void test() { + SQLSyntaxErrorException e = new SQLSyntaxErrorException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLSyntaxErrorException with no-arg constructor + */ + @Test + public void test1() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLSyntaxErrorException with message + */ + @Test + public void test2() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLSyntaxErrorException with message, and SQLState + */ + @Test + public void test3() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLSyntaxErrorException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLSyntaxErrorException ex = + new SQLSyntaxErrorException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLSyntaxErrorException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLSyntaxErrorException ex = + new SQLSyntaxErrorException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLSyntaxErrorException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLSyntaxErrorException with message, and Throwable + */ + @Test + public void test7() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLSyntaxErrorException with null Throwable + */ + @Test + public void test8() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLSyntaxErrorException with Throwable + */ + @Test + public void test9() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLSyntaxErrorException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + + SQLSyntaxErrorException e = + new SQLSyntaxErrorException(reason, state, errorCode, t); + SQLSyntaxErrorException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1); + SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2"); + SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1); + SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2"); + SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLSyntaxErrorException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLSyntaxErrorException(); + assertTrue(ex instanceof SQLNonTransientException); + } +} --- /dev/null 2014-10-28 10:29:58.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLTimeoutExceptionTests.java 2014-10-28 10:29:58.000000000 -0400 @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLTimeoutException; +import java.sql.SQLTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLTimeoutExceptionTests extends BaseTest { + + /** + * Create SQLTimeoutException and setting all objects to null + */ + @Test + public void test() { + SQLTimeoutException e = new SQLTimeoutException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLTimeoutException with no-arg constructor + */ + @Test + public void test1() { + SQLTimeoutException ex = new SQLTimeoutException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTimeoutException with message + */ + @Test + public void test2() { + SQLTimeoutException ex = new SQLTimeoutException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTimeoutException with message, and SQLState + */ + @Test + public void test3() { + SQLTimeoutException ex = new SQLTimeoutException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTimeoutException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLTimeoutException ex = new SQLTimeoutException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTimeoutException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLTimeoutException ex = new SQLTimeoutException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTimeoutException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLTimeoutException ex = new SQLTimeoutException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTimeoutException with message, and Throwable + */ + @Test + public void test7() { + SQLTimeoutException ex = new SQLTimeoutException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTimeoutException with null Throwable + */ + @Test + public void test8() { + SQLTimeoutException ex = new SQLTimeoutException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTimeoutException with Throwable + */ + @Test + public void test9() { + SQLTimeoutException ex = new SQLTimeoutException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLTimeoutException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLTimeoutException e = + new SQLTimeoutException(reason, state, errorCode, t); + SQLTimeoutException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLTimeoutException ex = new SQLTimeoutException("Exception 1", t1); + SQLTimeoutException ex1 = new SQLTimeoutException("Exception 2"); + SQLTimeoutException ex2 = new SQLTimeoutException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLTimeoutException ex = new SQLTimeoutException("Exception 1", t1); + SQLTimeoutException ex1 = new SQLTimeoutException("Exception 2"); + SQLTimeoutException ex2 = new SQLTimeoutException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLTimeoutException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLTimeoutException(); + assertTrue(ex instanceof SQLTransientException); + } +} --- /dev/null 2014-10-28 10:29:59.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLTransactionRollbackExceptionTests.java 2014-10-28 10:29:58.000000000 -0400 @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLTransactionRollbackException; +import java.sql.SQLTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLTransactionRollbackExceptionTests extends BaseTest { + + /** + * Create SQLTransactionRollbackException and setting all objects to null + */ + @Test + public void test() { + SQLTransactionRollbackException e = + new SQLTransactionRollbackException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLTransactionRollbackException with no-arg constructor + */ + @Test + public void test1() { + SQLTransactionRollbackException ex = new SQLTransactionRollbackException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransactionRollbackException with message + */ + @Test + public void test2() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransactionRollbackException with message, and SQLState + */ + @Test + public void test3() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransactionRollbackException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTransactionRollbackException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTransactionRollbackException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransactionRollbackException with message, and Throwable + */ + @Test + public void test7() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransactionRollbackException with null Throwable + */ + @Test + public void test8() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransactionRollbackException with Throwable + */ + @Test + public void test9() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLTransactionRollbackException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLTransactionRollbackException e = + new SQLTransactionRollbackException(reason, state, errorCode, t); + SQLTransactionRollbackException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException("Exception 1", t1); + SQLTransactionRollbackException ex1 = + new SQLTransactionRollbackException("Exception 2"); + SQLTransactionRollbackException ex2 = + new SQLTransactionRollbackException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLTransactionRollbackException ex = + new SQLTransactionRollbackException("Exception 1", t1); + SQLTransactionRollbackException ex1 = + new SQLTransactionRollbackException("Exception 2"); + SQLTransactionRollbackException ex2 = + new SQLTransactionRollbackException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLTransactionRollbackException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLTransactionRollbackException(); + assertTrue(ex instanceof SQLTransientException); + } +} --- /dev/null 2014-10-28 10:30:00.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLTransientConnectionExceptionTests.java 2014-10-28 10:29:59.000000000 -0400 @@ -0,0 +1,233 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLTransientConnectionException; +import java.sql.SQLTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLTransientConnectionExceptionTests extends BaseTest { + + /** + * Create SQLTransientConnectionException and setting all objects to null + */ + @Test + public void test() { + SQLTransientConnectionException e = + new SQLTransientConnectionException( null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLTransientConnectionException with no-arg constructor + */ + @Test + public void test1() { + SQLTransientConnectionException ex = new SQLTransientConnectionException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientConnectionException with message + */ + @Test + public void test2() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientConnectionException with message, and SQLState + */ + @Test + public void test3() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientConnectionException with message, SQLState, and error code + */ + @Test + public void test4() {; + SQLTransientConnectionException ex = + new SQLTransientConnectionException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTransientConnectionException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTransientConnectionException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientConnectionException with message, and Throwable + */ + @Test + public void test7() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientConnectionException with null Throwable + */ + @Test + public void test8() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientConnectionException with Throwable + */ + @Test + public void test9() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLTransientConnectionException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLTransientConnectionException e = + new SQLTransientConnectionException(reason, state, errorCode, t); + SQLTransientConnectionException ex1 = + createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException("Exception 1", t1); + SQLTransientConnectionException ex1 = + new SQLTransientConnectionException("Exception 2"); + SQLTransientConnectionException ex2 = + new SQLTransientConnectionException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLTransientConnectionException ex = + new SQLTransientConnectionException("Exception 1", t1); + SQLTransientConnectionException ex1 = + new SQLTransientConnectionException("Exception 2"); + SQLTransientConnectionException ex2 = + new SQLTransientConnectionException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Create SQLTransientConnectionException and validate it is an instance of + * SQLNonTransientException + */ + @Test + public void test13() { + Exception ex = new SQLTransientConnectionException(); + assertTrue(ex instanceof SQLTransientException); + } +} --- /dev/null 2014-10-28 10:30:00.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLTransientExceptionTests.java 2014-10-28 10:30:00.000000000 -0400 @@ -0,0 +1,207 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLTransientException; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLTransientExceptionTests extends BaseTest { + + /** + * Create SQLTransientException and setting all objects to null + */ + @Test + public void test() { + SQLTransientException e = new SQLTransientException(null, + null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLTransientException with no-arg constructor + */ + @Test + public void test1() { + SQLTransientException ex = new SQLTransientException(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientException with message + */ + @Test + public void test2() { + SQLTransientException ex = new SQLTransientException(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientException with message, and SQLState + */ + @Test + public void test3() { + SQLTransientException ex = new SQLTransientException(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientException with message, SQLState, and error code + */ + @Test + public void test4() { + SQLTransientException ex = new SQLTransientException(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTransientException with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLTransientException ex = + new SQLTransientException(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLTransientException with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLTransientException ex = new SQLTransientException(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientException with message, and Throwable + */ + @Test + public void test7() { + SQLTransientException ex = new SQLTransientException(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientException with null Throwable + */ + @Test + public void test8() { + SQLTransientException ex = new SQLTransientException((Throwable)null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLTransientException with Throwable + */ + @Test + public void test9() { + SQLTransientException ex = new SQLTransientException(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLTransientException and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLTransientException e = + new SQLTransientException(reason, state, errorCode, t); + SQLTransientException ex1 = createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using for-each loop + */ + @Test + public void test11() { + SQLTransientException ex = new SQLTransientException("Exception 1", t1); + SQLTransientException ex1 = new SQLTransientException("Exception 2"); + SQLTransientException ex2 = new SQLTransientException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct + * using traditional while loop + */ + @Test + public void test12() { + SQLTransientException ex = new SQLTransientException("Exception 1", t1); + SQLTransientException ex1 = new SQLTransientException("Exception 2"); + SQLTransientException ex2 = new SQLTransientException("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } +} --- /dev/null 2014-10-28 10:30:01.000000000 -0400 +++ new/test/java/sql/testng/test/sql/SQLWarningTests.java 2014-10-28 10:30:01.000000000 -0400 @@ -0,0 +1,249 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.SQLException; +import java.sql.SQLWarning; +import static org.testng.Assert.*; +import org.testng.annotations.Test; +import util.BaseTest; + +public class SQLWarningTests extends BaseTest { + + private final String[] warnings = {"Warning 1", "cause 1", "Warning 2", + "Warning 3", "cause 2"}; + + /** + * Create SQLWarning and setting all objects to null + */ + @Test + public void test() { + SQLWarning e = new SQLWarning(null, null, errorCode, null); + assertTrue(e.getMessage() == null && e.getSQLState() == null + && e.getCause() == null && e.getErrorCode() == errorCode); + } + + /** + * Create SQLWarning with no-arg constructor + */ + @Test + public void test1() { + SQLWarning ex = new SQLWarning(); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLWarning with message + */ + @Test + public void test2() { + SQLWarning ex = new SQLWarning(reason); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLWarning with message, and SQLState + */ + @Test + public void test3() { + + SQLWarning ex = new SQLWarning(reason, state); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLWarning with message, SQLState, and error code + */ + @Test + public void test4() { + SQLWarning ex = new SQLWarning(reason, state, errorCode); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && ex.getCause() == null + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLWarning with message, SQLState, errorCode, and Throwable + */ + @Test + public void test5() { + SQLWarning ex = new SQLWarning(reason, state, errorCode, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == errorCode); + } + + /** + * Create SQLWarning with message, SQLState, and Throwable + */ + @Test + public void test6() { + SQLWarning ex = new SQLWarning(reason, state, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState().equals(state) + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLWarning with message, and Throwable + */ + @Test + public void test7() { + SQLWarning ex = new SQLWarning(reason, t); + assertTrue(ex.getMessage().equals(reason) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Create SQLWarning with null Throwable + */ + @Test + public void test8() { + SQLWarning ex = new SQLWarning((Throwable) null); + assertTrue(ex.getMessage() == null + && ex.getSQLState() == null + && ex.getCause() == null + && ex.getErrorCode() == 0); + } + + /** + * Create SQLWarning with Throwable + */ + @Test + public void test9() { + SQLWarning ex = new SQLWarning(t); + assertTrue(ex.getMessage().equals(cause) + && ex.getSQLState() == null + && cause.equals(ex.getCause().toString()) + && ex.getErrorCode() == 0); + } + + /** + * Serialize a SQLWarning and make sure you can read it back properly + */ + @Test + public void test10() throws Exception { + SQLWarning e = new SQLWarning(reason, state, errorCode, t); + SQLWarning ex1 = createSerializedException(e); + assertTrue(reason.equals(ex1.getMessage()) + && ex1.getSQLState().equals(state) + && cause.equals(ex1.getCause().toString()) + && ex1.getErrorCode() == errorCode); + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * for-each loop + */ + @Test + public void test11() { + SQLWarning ex = new SQLWarning("Exception 1", t1); + SQLWarning ex1 = new SQLWarning("Exception 2"); + SQLWarning ex2 = new SQLWarning("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(msgs[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned Exceptions is correct using + * traditional while loop + */ + @Test + public void test12() { + SQLWarning ex = new SQLWarning("Exception 1", t1); + SQLWarning ex1 = new SQLWarning("Exception 2"); + SQLWarning ex2 = new SQLWarning("Exception 3", t2); + ex.setNextException(ex1); + ex.setNextException(ex2); + int num = 0; + SQLException sqe = ex; + while (sqe != null) { + assertTrue(msgs[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextException(); + } + } + + /** + * Validate that the ordering of the returned SQLWarning is correct using + * for-each loop + */ + @Test + public void test13() { + SQLWarning ex = new SQLWarning("Warning 1", t1); + SQLWarning ex1 = new SQLWarning("Warning 2"); + SQLWarning ex2 = new SQLWarning("Warning 3", t2); + ex.setNextWarning(ex1); + ex.setNextWarning(ex2); + int num = 0; + for (Throwable e : ex) { + assertTrue(warnings[num++].equals(e.getMessage())); + } + } + + /** + * Validate that the ordering of the returned SQLWarning is correct using + * traditional while loop + */ + @Test + public void test14() { + SQLWarning ex = new SQLWarning("Warning 1", t1); + SQLWarning ex1 = new SQLWarning("Warning 2"); + SQLWarning ex2 = new SQLWarning("Warning 3", t2); + ex.setNextWarning(ex1); + ex.setNextWarning(ex2); + int num = 0; + SQLWarning sqe = ex; + while (sqe != null) { + assertTrue(warnings[num++].equals(sqe.getMessage())); + Throwable c = sqe.getCause(); + while (c != null) { + assertTrue(msgs[num++].equals(c.getMessage())); + c = c.getCause(); + } + sqe = sqe.getNextWarning(); + } + } +} --- /dev/null 2014-10-28 10:30:02.000000000 -0400 +++ new/test/java/sql/testng/test/sql/TimeTests.java 2014-10-28 10:30:02.000000000 -0400 @@ -0,0 +1,348 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.Time; +import java.time.LocalTime; +import static org.testng.Assert.*; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; +import util.BaseTest; + +public class TimeTests extends BaseTest { + + /* + * Validate an IllegalArgumentException is thrown for calling getYear + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test01() { + Time t = Time.valueOf("08:30:59"); + t.getYear(); + } + + /* + * Validate an IllegalArgumentException is thrown for calling getMonth + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test02() { + Time t = Time.valueOf("08:30:59"); + t.getMonth(); + } + + /* + * Validate an IllegalArgumentException is thrown for calling getDay + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test03() { + Time t = Time.valueOf("08:30:59"); + t.getDay(); + } + + /** + * Validate an IllegalArgumentException is thrown for calling getDate + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test04() { + Time t = Time.valueOf("08:30:59"); + t.getDate(); + } + + /* + * Validate an IllegalArgumentException is thrown for calling setYear + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test05() { + Time t = Time.valueOf("08:30:59"); + t.setYear(8); + } + + /* + * Validate an IllegalArgumentException is thrown for calling setMonth + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test06() { + Time t = Time.valueOf("08:30:59"); + t.setMonth(8); + } + + /* + * Validate an IllegalArgumentException is thrown for calling setDate + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test07() { + Time t = Time.valueOf("08:30:59"); + t.setDate(30); + } + + /* + * Validate an IllegalArgumentException is thrown for calling getDate + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test08() { + Time t = Time.valueOf("08:30:59"); + t.getDate(); + } + + /* + * Validate that a Time made from a toLocalTime() LocalTime are equal + */ + @Test + public void test09() { + Time t = Time.valueOf("08:30:59"); + Time t2 = Time.valueOf(t.toLocalTime()); + assertTrue(t.equals(t2), "Error t != t2"); + } + + /* + * Validate that a Time LocalTime value, made from a LocalTime are equal + */ + @Test + public void test10() { + LocalTime lt = LocalTime.of(8, 30, 59); + Time t = Time.valueOf(lt); + System.out.println("lt=" + lt + ",t=" + t.toLocalTime()); + assertTrue(lt.equals(t.toLocalTime()), + "Error LocalTime values are not equal"); + } + + /* + * Validate an NPE occurs when a null LocalDate is passed to valueOf + */ + @Test(expectedExceptions = NullPointerException.class) + public void test11() throws Exception { + LocalTime ld = null; + Time.valueOf(ld); + } + + /* + * Validate an UnsupportedOperationException occurs when toInstant() is + * called + */ + @Test(expectedExceptions = UnsupportedOperationException.class) + public void test12() throws Exception { + Time t = new Time(System.currentTimeMillis()); + t.toInstant(); + } + + /* + * Validate that two Time objects are equal when one is created from the + * toString() of the other and that the correct value is returned from + * toString() + */ + @Test(dataProvider = "validTimeValues") + public void test13(String time, String expected) { + Time t1 = Time.valueOf(time); + Time t2 = Time.valueOf(t1.toString()); + assertTrue(t1.equals(t2) && t2.equals(t1) + && t1.toString().equals(expected), "Error t1 != t2"); + } + + /* + * Validate that two Time values one created using valueOf and another via a + * constructor are equal + */ + @Test + public void test14() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(8, 30, 59); + assertTrue(t.equals(t2) && t2.equals(t), "Error t != t2"); + } + + /* + * Validate that two Time values one created using valueOf and another via a + * constructor are equal + */ + @Test + public void test15() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(t.getTime()); + assertTrue(t.equals(t2) && t2.equals(t), "Error t != t2"); + } + + /* + * Validate an IllegalArgumentException is thrown for an invalid Time string + */ + @Test(dataProvider = "invalidTimeValues", + expectedExceptions = IllegalArgumentException.class) + public void test16(String time) throws Exception { + Time.valueOf(time); + } + + /* + * Validate that Time.after() returns false when same date is compared + */ + @Test + public void test17() { + Time t = Time.valueOf("08:30:59"); + assertFalse(t.after(t), "Error t.after(t) = true"); + } + + /* + * Validate that Time.after() returns true when later date is compared to + * earlier date + */ + @Test + public void test18() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(System.currentTimeMillis()); + assertTrue(t2.after(t), "Error t2.after(t) = false"); + } + + /* + * Validate that Time.after() returns false when earlier date is compared to + * itself + */ + @Test + public void test19() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(t.getTime()); + assertFalse(t.after(t2), "Error t.after(t2) = true"); + assertFalse(t2.after(t), "Error t2.after(t) = true"); + } + + /* + * Validate that Time.before() returns false when same date is compared + */ + @Test + public void test20() { + Time t = Time.valueOf("08:30:59"); + assertFalse(t.before(t), "Error t.before(t) = true"); + } + + /* + * Validate that Time.before() returns true when earlier date is compared to + * later date + */ + @Test + public void test21() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(System.currentTimeMillis()); + assertTrue(t.before(t2), "Error t.before(t2) = false"); + } + + /* + * Validate that Time.before() returns false when earlier date is compared + * to itself + */ + @Test + public void test22() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(t.getTime()); + assertFalse(t.before(t2), "Error t.after(t2) = true"); + assertFalse(t2.before(t), "Error t2.after(t) = true"); + } + + /* + * Validate that Time.compareTo returns 0 when both Date objects are the + * same + */ + @Test + public void test23() { + Time t = Time.valueOf("08:30:59"); + assertTrue(t.compareTo(t) == 0, "Error t.compareTo(t) !=0"); + } + + /* + * Validate thatTime.compareTo returns 0 when both Time objects are the same + */ + @Test + public void test24() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(t.getTime()); + assertTrue(t.compareTo(t2) == 0, "Error t.compareTo(t2) !=0"); + } + + /* + * Validate that Time.compareTo returns 1 when comparing a later Time to an + * earlier Time + */ + @Test + public void test25() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(t.getTime() + 1); + assertTrue(t2.compareTo(t) == 1, "Error t2.compareTo(t) !=1"); + } + + /* + * Validate thatTime.compareTo returns 1 when comparing a later Time to an + * earlier Time + */ + @Test + public void test26() { + Time t = Time.valueOf("08:30:59"); + Time t2 = new Time(t.getTime() + 1); + assertTrue(t.compareTo(t2) == -1, "Error t.compareTo(t2) != -1"); + } + + /* + * DataProvider used to provide Time values which are not valid and are used + * to validate that an IllegalArgumentException will be thrown from the + * valueOf method + */ + @DataProvider(name = "invalidTimeValues") + private Object[][] invalidTimeValues() { + return new Object[][]{ + {"2009-11-01 10:50:01"}, + {"1961-08-30 10:50:01.1"}, + {"1961-08-30"}, + {"00:00:00."}, + {"10:50:0.1"}, + {":00:00"}, + {"00::00"}, + {"00:00:"}, + {"::"}, + {" : : "}, + {"0a:00:00"}, + {"00:bb:00"}, + {"00:01:cc"}, + {"08:10:Batman"}, + {"08:10:10:10"}, + {"08:10"}, + {"a:b:c"}, + {null}, + {"8:"} + }; + } + + /* + * DataProvider used to provide Time values which are valid and are used + * to validate that an IllegalArgumentException will not be thrown from the + * valueOf method. It also contains the expected return value from + * toString() + */ + @DataProvider(name = "validTimeValues") + private Object[][] validTimeValues() { + return new Object[][]{ + {"10:50:01", "10:50:01"}, + {"01:1:1", "01:01:01"}, + {"01:01:1", "01:01:01"}, + {"1:01:1", "01:01:01"}, + {"2:02:02", "02:02:02"}, + {"2:02:2", "02:02:02"}, + {"10:50:1", "10:50:01"}, + {"00:00:00", "00:00:00"}, + {"08:30:59", "08:30:59"}, + {"9:0:1", "09:00:01"} + }; + } +} --- /dev/null 2014-10-28 10:30:03.000000000 -0400 +++ new/test/java/sql/testng/test/sql/TimestampTests.java 2014-10-28 10:30:03.000000000 -0400 @@ -0,0 +1,777 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package test.sql; + +import java.sql.Date; +import java.sql.Time; +import java.sql.Timestamp; +import java.time.Instant; +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.util.Calendar; +import java.util.TimeZone; +import static org.testng.Assert.*; +import org.testng.annotations.AfterClass; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.DataProvider; +import org.testng.annotations.Test; +import util.BaseTest; + +public class TimestampTests extends BaseTest { + + private static TimeZone defaultTimeZone = null; + + /* + * Need to set and use a custom TimeZone which does not + * observe daylight savings time for this test. + */ + @BeforeClass + public static void setUpClass() throws Exception { + defaultTimeZone = TimeZone.getDefault(); + TimeZone tzone = TimeZone.getTimeZone("GMT+01"); + assertFalse(tzone.observesDaylightTime()); + TimeZone.setDefault(tzone); + } + + /* + * Conservatively reset the default time zone after test. + */ + @AfterClass + public static void tearDownClass() throws Exception { + TimeZone.setDefault(defaultTimeZone); + } + + /* + * Validate an IllegalArgumentException is thrown for an invalid Timestamp + */ + @Test(dataProvider = "invalidTimestampValues", + expectedExceptions = IllegalArgumentException.class) + public void test(String ts) throws Exception { + Timestamp.valueOf(ts); + } + + /* + * Validate that two Timestamp are equal when the leading 0 in seconds is + * omitted + */ + @Test + public void test01() throws Exception { + String testTS = "2009-01-01 10:50:00"; + String ExpectedTS = "2009-01-01 10:50:0"; + Timestamp ts = Timestamp.valueOf(testTS); + Timestamp ts2 = Timestamp.valueOf(ExpectedTS); + assertEquals(ts, ts2, "Error ts1 != ts2"); + } + + /* + * Validate two Timestamps created from the same string are equal + */ + @Test + public void test02() throws Exception { + String testTS = "2009-01-01 10:50:0"; + Timestamp ts = Timestamp.valueOf(testTS); + Timestamp ts2 = Timestamp.valueOf(testTS); + assertEquals(ts, ts2, "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one with leading 0s for month and day + * equals same string without the leading 0s. + */ + @Test + public void test03() throws Exception { + String testTS = "2009-1-1 10:50:0"; + String ExpectedTS = "2009-01-01 10:50:0"; + Timestamp ts = Timestamp.valueOf(testTS); + Timestamp ts2 = Timestamp.valueOf(ExpectedTS); + assertEquals(ts, ts2, "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one with leading 0s for day omitted + * are equal + */ + @Test + public void test04() throws Exception { + String testTS = "2009-01-1 10:50:0"; + String ExpectedTS = "2009-01-01 10:50:0"; + Timestamp ts = Timestamp.valueOf(testTS); + Timestamp ts2 = Timestamp.valueOf(ExpectedTS); + assertEquals(ts, ts2, "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one with leading 0s for month omitted + * and both with leading 0s for seconds omitted are equal + */ + @Test + public void test05() throws Exception { + String testTS = "2009-1-01 10:50:0"; + String ExpectedTS = "2009-01-01 10:50:0"; + Timestamp ts = Timestamp.valueOf(testTS); + Timestamp ts2 = Timestamp.valueOf(ExpectedTS); + assertEquals(ts, ts2, "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one with leading 0s for month omitted + */ + @Test + public void test06() throws Exception { + String testTS = "2005-1-01 10:20:50.00"; + String ExpectedTS = "2005-01-01 10:20:50.00"; + Timestamp ts = Timestamp.valueOf(testTS); + Timestamp ts2 = Timestamp.valueOf(ExpectedTS); + assertEquals(ts, ts2, "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one created using valueOf and another + * via a constructor are equal + */ + @Test + public void test07() { + + Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.001"); + Timestamp ts2 = new Timestamp(96, 11, 13, 14, 15, 25, 1000000); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one created using valueOf and another + * via a constructor are equal + */ + @Test + public void test08() { + Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.001"); + Timestamp ts2 = new Timestamp(ts1.getTime()); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate that two Timestamp values one created using valueOf and another + * via a constructor are equal + */ + @Test + public void test09() { + + Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.0"); + Timestamp ts2 = new Timestamp(96, 11, 13, 14, 15, 25, 0); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate that a Timestamp cannot be equal to null + */ + @Test + public void test10() { + + Timestamp ts1 = Timestamp.valueOf("1961-08-30 14:15:25.745634"); + Timestamp ts2 = null; + assertFalse(ts1.equals(ts2), "Error ts1 == null"); + } + + /* + * Validate that a Timestamp is equal to another timestamp created with the + * using the same value but not equal to a Timestamp which is one day later + */ + @Test + public void test11() { + + Timestamp ts1 = Timestamp.valueOf("1996-12-10 12:26:19.12"); + Timestamp ts2 = Timestamp.valueOf("1996-12-10 12:26:19.12"); + Timestamp ts3 = Timestamp.valueOf("1996-12-11 12:24:19.12"); + assertTrue(ts1.equals(ts2) && ts2.equals(ts1), "Error ts1 != ts2"); + assertFalse(ts1.equals(ts3) && ts3.equals(ts1), "Error ts1 == ts3"); + + } + + /* + * Validate that a Timestamp is equal to itself + */ + @Test + public void test12() { + Timestamp ts1 = Timestamp.valueOf("1996-10-15 12:26:19.12"); + assertTrue(ts1.equals(ts1), "Error ts1 != ts1"); + } + + /* + * Validate that two Timestamps are equal when one is created from the + * toString() of the other + */ + @Test(dataProvider = "validTimestampValues") + public void test13(String ts, String expectedTS) { + Timestamp ts1 = Timestamp.valueOf(ts); + Timestamp ts2 = Timestamp.valueOf(ts1.toString()); + assertTrue(ts1.equals(ts2) && ts2.equals(ts1) + && ts1.toString().equals(expectedTS), "Error ts1 != ts2"); + } + + // Before Tests + /* + * Validate that Timestamp ts1 is before Timestamp ts2 + */ + @Test + public void test14() { + Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); + Timestamp ts2 = Timestamp.valueOf("1996-12-13 15:15:25.645634"); + assertTrue(ts1.before(ts2), "Error ts1 not before ts2"); + } + + /* + * Validate that Timestamp ts1 is before Timestamp ts2 + */ + @Test + public void test15() { + Timestamp ts1 = Timestamp.valueOf("1961-08-30 14:15:25"); + Timestamp ts2 = Timestamp.valueOf("1999-12-13 15:15:25"); + assertTrue(ts1.before(ts2), "Error ts1 not before ts2"); + } + + /* + * Validate that Timestamp ts1 is before Timestamp ts2 + */ + @Test + public void test16() { + + Timestamp ts1 = Timestamp.valueOf("1999-12-13 14:15:25.745634"); + Timestamp ts2 = Timestamp.valueOf("1999-11-13 15:15:25.645634"); + assertFalse(ts1.before(ts2), "Error ts1 before ts2"); + } + + /* + * Validate that a NullPointerException is thrown if a null is passed to + * the before method + */ + @Test(expectedExceptions = NullPointerException.class) + public void test17() throws Exception { + Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); + ts1.before(null); + } + + /* + * Validate a Timestamp cannot be before itself + */ + @Test + public void test18() { + Timestamp ts1 = Timestamp.valueOf("1999-11-10 12:26:19.3456543"); + assertFalse(ts1.before(ts1), "Error ts1 before ts1!"); + } + + /* + * Create 3 Timestamps and make sure the 1st is before the other two + * Timestamps which are each greater than the one before it + */ + @Test + public void test19() { + + Timestamp ts1 = new Timestamp(1234560000); + Timestamp ts2 = new Timestamp(1234567000); + Timestamp ts3 = new Timestamp(1234569000); + assertTrue(ts1.before(ts2) && ts2.before(ts3) && ts1.before(ts3)); + } + + /* + * Validate that Timestamp ts1 is not after Timestamp ts2 + */ + @Test + public void test20() { + Timestamp ts1 = Timestamp.valueOf("1999-12-13 14:15:25.745634"); + Timestamp ts2 = Timestamp.valueOf("1999-12-13 15:15:25.645634"); + assertFalse(ts1.after(ts2), "Error ts1 is after ts2"); + + } + + /* + * Validate that Timestamp ts1 is after Timestamp ts2 + */ + @Test + public void test21() { + Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); + Timestamp ts2 = Timestamp.valueOf("1996-11-13 15:15:25.645634"); + assertTrue(ts1.after(ts2), "Error ts1 not after ts2"); + } + + /* + * Validate that a NullPointerException is thrown if a null is passed to the + * after method + */ + @Test(expectedExceptions = NullPointerException.class) + public void test22() throws Exception { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + ts1.after(null); + } + + /* + * Validate that a Timestamp cannot be after itself + */ + @Test + public void test23() { + Timestamp ts1 = Timestamp.valueOf("1999-11-10 12:26:19.3456543"); + assertFalse(ts1.after(ts1), "Error ts1 is after itself"); + } + + /* + * Validate that a Timestamp after() works correctly with Timestamp created + * using milliseconds + */ + @Test + public void test24() { + + Timestamp ts1 = new Timestamp(1234568000); + Timestamp ts2 = new Timestamp(1234565000); + Timestamp ts3 = new Timestamp(1234562000); + assertTrue(ts1.after(ts2) && ts2.after(ts3) && ts1.after(ts3)); + } + + /* + * Validate compareTo returns 0 for Timestamps that are the same + */ + @Test + public void test25() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Timestamp ts2 = new Timestamp(ts1.getTime()); + assertTrue(ts1.compareTo(ts2) == 0, "Error ts1 != ts2"); + } + + /* + * Validate compareTo returns -1 for when the 1st Timestamp is earlier than + * the 2nd Timestamp + */ + @Test + public void test26() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Timestamp ts2 = new Timestamp(ts1.getTime() + 1000); + assertTrue(ts1.compareTo(ts2) == -1, "Error ts1 not before ts2"); + assertTrue(ts2.compareTo(ts1) == 1, "Error ts1 is not before ts2"); + } + + /* + * Validate compareTo returns 1 for when the 1st Timestamp is later than the + * 2nd Timestamp + */ + @Test + public void test27() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Timestamp ts2 = new Timestamp(ts1.getTime() - 1000); + assertTrue(ts1.compareTo(ts2) == 1, "Error ts1 not after ts2"); + assertTrue(ts2.compareTo(ts1) == -1, "Error ts1 not after ts2"); + } + + /* + * Validate compareTo returns 0 for Timestamps that are the same + */ + @Test + public void test28() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + java.util.Date ts2 = new java.util.Date(ts1.getTime()); + assertTrue(ts1.compareTo(ts2) == 0, "Error ts1 != ts2"); + } + + /* + * Validate compareTo returns 0 for Timestamps that are the same + */ + @Test + public void test29() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + java.util.Date d = new java.util.Date(ts1.getTime()); + assertFalse(ts1.equals(d), "Error ts1 == d"); + } + + /* + * Validate compareTo returns 0 for Timestamps that are the same + */ + @Test + public void test30() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + java.util.Date d = new Timestamp(ts1.getTime()); + assertTrue(ts1.equals(d), "Error ts1 != d"); + } + + /* + * Validate equals returns false when a Date object is passed to equals + */ + @Test + public void test31() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Date d = new Date(ts1.getTime()); + assertFalse(ts1.equals(d), "Error ts1 != d"); + } + + /* + * Validate equals returns false when a Date object is passed to equals + */ + @Test + public void test32() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + java.util.Date d = new Date(ts1.getTime()); + assertFalse(ts1.equals(d), "Error ts1 != d"); + } + + /* + * Validate equals returns false when a Time object is passed to equals + */ + @Test + public void test33() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Time t1 = new Time(ts1.getTime()); + assertFalse(ts1.equals(t1), "Error ts1 == t1"); + } + + /* + * Validate equals returns false when a String object is passed to equals + */ + @Test + public void test34() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + assertFalse(ts1.equals("1966-08-30 08:08:08"), "Error ts1 == a String"); + } + + /* + * Validate getTime() returns the same value from 2 timeStamps created by + */ + @Test + public void test35() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Timestamp ts2 = Timestamp.valueOf("1966-08-30 08:08:08"); + assertTrue(ts2.getTime() == ts1.getTime(), + "ts1.getTime() != ts2.getTime()"); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate getTime() returns the same value from 2 timeStamps when + * setTime() is used to specify the same value for both Timestamps + */ + @Test + public void test36() { + Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); + Timestamp ts2 = Timestamp.valueOf("1961-08-30 00:00:00"); + ts2.setTime(ts1.getTime()); + assertTrue(ts2.getTime() == ts1.getTime(), + "ts1.getTime() != ts2.getTime()"); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate an IllegalArgumentException is thrown for an invalid nanos value + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test38() throws Exception { + Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); + ts1.setNanos(-1); + + } + + /* + * Validate an IllegalArgumentException is thrown for an invalid nanos value + */ + @Test(expectedExceptions = IllegalArgumentException.class) + public void test39() throws Exception { + int nanos = 999999999; + Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); + ts1.setNanos(nanos + 1); + } + + /* + * Validate you can set nanos to 999999999 + */ + @Test + public void test40() throws Exception { + int nanos = 999999999; + Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); + ts1.setNanos(nanos); + assertTrue(ts1.getNanos() == nanos, "Error Invalid Nanos value"); + } + + /* + * Validate you can set nanos to 0 + */ + @Test + public void test41() throws Exception { + int nanos = 0; + Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); + ts1.setNanos(nanos); + assertTrue(ts1.getNanos() == nanos, "Error Invalid Nanos value"); + } + + /* + * Validate that a Timestamp made from a LocalDateTime are equal + */ + @Test + public void test42() throws Exception { + Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); + LocalDateTime ldt = ts1.toLocalDateTime(); + Timestamp ts2 = Timestamp.valueOf(ldt); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate that a Timestamp LocalDateTime value, made from a LocalDateTime + * are equal + */ + @Test + public void test43() throws Exception { + LocalDateTime ldt = LocalDateTime.now(); + Timestamp ts2 = Timestamp.valueOf(ldt); + assertTrue(ldt.equals(ts2.toLocalDateTime()), + "Error LocalDateTime values are not equal"); + } + + /* + * Validate an NPE occurs when a null LocalDateTime is passed to valueOF + */ + @Test(expectedExceptions = NullPointerException.class) + public void test44() throws Exception { + LocalDateTime ldt = null; + Timestamp.valueOf(ldt); + } + + /* + * Validate that a Timestamp made from a Instant are equal + */ + @Test + public void test45() throws Exception { + Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); + Instant instant = ts1.toInstant(); + Timestamp ts2 = Timestamp.from(instant); + assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); + } + + /* + * Validate that a Timestamp made from a Instant are equal + */ + @Test + public void test46() throws Exception { + Instant instant = Instant.now(); + Timestamp ts2 = Timestamp.from(instant); + assertTrue(instant.equals(ts2.toInstant()), + "Error Instant values do not match"); + } + + /* + * Validate an NPE occurs when a null instant is passed to from + */ + @Test(expectedExceptions = NullPointerException.class) + public void test47() throws Exception { + Instant instant = null; + Timestamp.from(instant); + } + + // Added SQE tests + /* + * Create a Timestamp and a 2nd Timestamp that is 1 month earlier and + * validate that it is not before or after the original Timestamp + */ + @Test + public void test48() { + Calendar cal = Calendar.getInstance(); + Timestamp ts1 = new Timestamp(System.currentTimeMillis()); + cal.setTimeInMillis(ts1.getTime()); + cal.add(Calendar.MONTH, -1); + cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); + Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); + assertFalse(ts1.before(ts2) || ts2.after(ts1)); + } + + /* + * Create two Timestamps and validate that compareTo returns 1 to indicate + * the 1st Timestamp is greater than the 2nd Timestamp + */ + @Test + public void test49() { + Calendar cal = Calendar.getInstance(); + Timestamp ts1 = new Timestamp(System.currentTimeMillis()); + cal.setTimeInMillis(ts1.getTime()); + cal.add(Calendar.MONTH, -1); + cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); + Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); + assertTrue(ts1.compareTo(ts2) == 1); + } + + /* + * Create two Timestamps and validate that the 1st Timestamp is not equal to + * the 2nd Timestamp but equal to itself + */ + @Test + public void test50() { + Calendar cal = Calendar.getInstance(); + Timestamp ts1 = new Timestamp(System.currentTimeMillis()); + cal.setTimeInMillis(ts1.getTime()); + cal.add(Calendar.MONTH, -1); + cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); + Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); + assertTrue(!ts1.equals(ts2) && ts1.equals(ts1)); + } + + /* + * Validate that two Timestamps are equal when one is created from the + * toString() of the other + */ + @Test(dataProvider = "validateNanos") + public void test51(String ts, int nanos) { + Timestamp ts1 = Timestamp.valueOf(ts); + Timestamp ts2 = Timestamp.valueOf(ts1.toString()); + assertTrue(ts1.getNanos() == nanos && ts1.equals(ts2), + "Error with Nanos"); + } + + @Test(dataProvider = "validTimestampLongValues") + public void test52(long value, String ts) { + Timestamp ts1 = new Timestamp(value); + assertEquals(ts1.toString(), ts, "ts1.toString() != ts"); + } + + /* + * DataProvider used to provide Timestamps which are not valid and are used + * to validate that an IllegalArgumentException will be thrown from the + * valueOf method + */ + @DataProvider(name = "invalidTimestampValues") + private Object[][] invalidTimestampValues() { + return new Object[][]{ + {"2009-11-01-01 10:50:01"}, + {"aaaa-11-01-01 10:50"}, + {"aaaa-11-01 10:50"}, + {"1961--30 00:00:00"}, + {"--30 00:00:00"}, + {"-- 00:00:00"}, + {"1961-1- 00:00:00"}, + {"2009-11-01"}, + {"10:50:01"}, + {"1961-a-30 00:00:00"}, + {"1961-01-bb 00:00:00"}, + {"1961-08-30 00:00:00."}, + {"1961-08-30 :00:00"}, + {"1961-08-30 00::00"}, + {"1961-08-30 00:00:"}, + {"1961-08-30 ::"}, + {"1961-08-30 0a:00:00"}, + {"1961-08-30 00:bb:00"}, + {"1961-08-30 00:01:cc"}, + {"1961-08-30 00:00:00.01a"}, + {"1961-08-30 00:00:00.a"}, + {"1996-12-10 12:26:19.1234567890"}, + {null} + }; + } + + /* + * DataProvider used to provide Timestamps which are valid and are used + * to validate that an IllegalArgumentException will not be thrown from the + * valueOf method and the corect value from toString() is returned + */ + @DataProvider(name = "validTimestampValues") + private Object[][] validTimestampValues() { + return new Object[][]{ + {"1961-08-30 00:00:00", "1961-08-30 00:00:00.0"}, + {"1961-08-30 11:22:33", "1961-08-30 11:22:33.0"}, + {"1961-8-30 00:00:00", "1961-08-30 00:00:00.0"}, + {"1966-08-1 00:00:00", "1966-08-01 00:00:00.0"}, + {"1996-12-10 12:26:19.1", "1996-12-10 12:26:19.1"}, + {"1996-12-10 12:26:19.12", "1996-12-10 12:26:19.12"}, + {"1996-12-10 12:26:19.123", "1996-12-10 12:26:19.123"}, + {"1996-12-10 12:26:19.1234", "1996-12-10 12:26:19.1234"}, + {"1996-12-10 12:26:19.12345", "1996-12-10 12:26:19.12345"}, + {"1996-12-10 12:26:19.123456", "1996-12-10 12:26:19.123456"}, + {"1996-12-10 12:26:19.1234567", "1996-12-10 12:26:19.1234567"}, + {"1996-12-10 12:26:19.12345678", "1996-12-10 12:26:19.12345678"}, + {"1996-12-10 12:26:19.123456789", "1996-12-10 12:26:19.123456789"}, + {"1996-12-10 12:26:19.000000001", "1996-12-10 12:26:19.000000001"}, + {"1996-12-10 12:26:19.000000012", "1996-12-10 12:26:19.000000012"}, + {"1996-12-10 12:26:19.000000123", "1996-12-10 12:26:19.000000123"}, + {"1996-12-10 12:26:19.000001234", "1996-12-10 12:26:19.000001234"}, + {"1996-12-10 12:26:19.000012345", "1996-12-10 12:26:19.000012345"}, + {"1996-12-10 12:26:19.000123456", "1996-12-10 12:26:19.000123456"}, + {"1996-12-10 12:26:19.001234567", "1996-12-10 12:26:19.001234567"}, + {"1996-12-10 12:26:19.12345678", "1996-12-10 12:26:19.12345678"}, + {"1996-12-10 12:26:19.0", "1996-12-10 12:26:19.0"}, + {"1996-12-10 12:26:19.01230", "1996-12-10 12:26:19.0123"} + }; + } + + @DataProvider(name = "validTimestampLongValues") + private Object[][] validTimestampLongValues() { + return new Object[][]{ + {1L, "1970-01-01 01:00:00.001"}, + {-3600*1000L - 1, "1969-12-31 23:59:59.999"}, + {-(20000L*365*24*60*60*1000), "18018-08-28 01:00:00.0"}, + {Timestamp.valueOf("1961-08-30 11:22:33").getTime(), "1961-08-30 11:22:33.0"}, + {Timestamp.valueOf("1961-08-30 11:22:33.54321000").getTime(), "1961-08-30 11:22:33.543"}, // nanoprecision lost + {new Timestamp(114, 10, 10, 10, 10, 10, 100000000).getTime(), "2014-11-10 10:10:10.1"}, + {new Timestamp(0, 10, 10, 10, 10, 10, 100000).getTime(), "1900-11-10 10:10:10.0"}, // nanoprecision lost + {new Date(114, 10, 10).getTime(), "2014-11-10 00:00:00.0"}, + {new Date(0, 10, 10).getTime(), "1900-11-10 00:00:00.0"}, + {LocalDateTime.of(1960, 10, 10, 10, 10, 10, 50000).atZone(ZoneId.of("America/Los_Angeles")) + .toInstant().toEpochMilli(), "1960-10-10 19:10:10.0"}, + + // millisecond timestamps wraps around at year 1, so Long.MIN_VALUE looks similar + // Long.MAX_VALUE, while actually representing 292278994 BCE + {Long.MIN_VALUE, "292278994-08-17 08:12:55.192"}, + {Long.MAX_VALUE + 1, "292278994-08-17 08:12:55.192"}, + {Long.MAX_VALUE, "292278994-08-17 08:12:55.807"}, + {Long.MIN_VALUE - 1, "292278994-08-17 08:12:55.807"}, + + // wrap around point near 0001-01-01, test that we never get a negative year: + {-(1970L*365*24*60*60*1000), "0001-04-25 01:00:00.0"}, + {-(1970L*365*24*60*60*1000 + 115*24*60*60*1000L), "0001-12-31 01:00:00.0"}, + {-(1970L*365*24*60*60*1000 + 115*24*60*60*1000L - 23*60*60*1000L), "0001-01-01 00:00:00.0"}, + + {LocalDateTime.of(0, 1, 1, 10, 10, 10, 50000).atZone(ZoneId.of("America/Los_Angeles")) + .toInstant().toEpochMilli() - 2*24*60*60*1000L, "0001-01-01 19:03:08.0"}, // 1 BCE + {LocalDateTime.of(0, 1, 1, 10, 10, 10, 50000).atZone(ZoneId.of("America/Los_Angeles")) + .toInstant().toEpochMilli() - 3*24*60*60*1000L, "0002-12-31 19:03:08.0"} // 2 BCE + }; + } + + /* + * DataProvider used to provide Timestamp and Nanos values in order to + * validate that the correct Nanos value is generated from the specified + * Timestamp + */ + @DataProvider(name = "validateNanos") + private Object[][] validateNanos() { + return new Object[][]{ + {"1961-08-30 00:00:00", 0}, + {"1996-12-10 12:26:19.1", 100000000}, + {"1996-12-10 12:26:19.12", 120000000}, + {"1996-12-10 12:26:19.123", 123000000}, + {"1996-12-10 12:26:19.1234", 123400000}, + {"1996-12-10 12:26:19.12345", 123450000}, + {"1996-12-10 12:26:19.123456", 123456000}, + {"1996-12-10 12:26:19.1234567", 123456700}, + {"1996-12-10 12:26:19.12345678", 123456780}, + {"1996-12-10 12:26:19.123456789", 123456789}, + {"1996-12-10 12:26:19.000000001", 1}, + {"1996-12-10 12:26:19.000000012", 12}, + {"1996-12-10 12:26:19.000000123", 123}, + {"1996-12-10 12:26:19.000001234", 1234}, + {"1996-12-10 12:26:19.000012345", 12345}, + {"1996-12-10 12:26:19.000123456", 123456}, + {"1996-12-10 12:26:19.001234567", 1234567}, + {"1996-12-10 12:26:19.012345678", 12345678}, + {"1996-12-10 12:26:19.0", 0}, + {"1996-12-10 12:26:19.01230", 12300000} + }; + } +} --- /dev/null 2014-10-28 10:30:04.000000000 -0400 +++ new/test/java/sql/testng/util/BaseTest.java 2014-10-28 10:30:04.000000000 -0400 @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.security.Policy; +import java.sql.JDBCType; +import java.sql.SQLException; +import org.testng.annotations.AfterClass; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeClass; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.DataProvider; + +public class BaseTest { + + protected final String reason = "reason"; + protected final String state = "SQLState"; + protected final String cause = "java.lang.Throwable: cause"; + protected final Throwable t = new Throwable("cause"); + protected final Throwable t1 = new Throwable("cause 1"); + protected final Throwable t2 = new Throwable("cause 2"); + protected final int errorCode = 21; + protected final String[] msgs = {"Exception 1", "cause 1", "Exception 2", + "Exception 3", "cause 2"}; + + @BeforeClass + public static void setUpClass() throws Exception { + } + + @AfterClass + public static void tearDownClass() throws Exception { + } + + @BeforeMethod + public void setUpMethod() throws Exception { + } + + @AfterMethod + public void tearDownMethod() throws Exception { + } + + /* + * Take some form of SQLException, serialize and deserialize it + */ + @SuppressWarnings("unchecked") + protected T + createSerializedException(T ex) + throws IOException, ClassNotFoundException { + return (T) serializeDeserializeObject(ex); + } + + /* + * Utility method to serialize and deserialize an object + */ + @SuppressWarnings("unchecked") + protected T serializeDeserializeObject(T o) + throws IOException, ClassNotFoundException { + T o1; + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { + oos.writeObject(o); + } + try (ObjectInputStream ois + = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()))) { + o1 = (T) ois.readObject(); + } + return o1; + } + + /* + * Utility Method used to set the current Policy + */ + protected static void setPolicy(Policy p) { + Policy.setPolicy(p); + } + + /* + * DataProvider used to specify the value to set and check for + * methods using boolean values + */ + @DataProvider(name = "trueFalse") + protected Object[][] trueFalse() { + return new Object[][]{ + {true}, + {false} + }; + } + + /* + * DataProvider used to specify the standard JDBC Types + */ + @DataProvider(name = "jdbcTypes") + protected Object[][] jdbcTypes() { + Object[][] o = new Object[JDBCType.values().length][1]; + int pos = 0; + for (JDBCType c : JDBCType.values()) { + o[pos++][0] = c.getVendorTypeNumber(); + } + return o; + } +} --- /dev/null 2014-10-28 10:30:05.000000000 -0400 +++ new/test/java/sql/testng/util/DriverActionImpl.java 2014-10-28 10:30:05.000000000 -0400 @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +import java.sql.DriverAction; + +/** + * Simple implementation of DriverAction which calls back into the Driver when + * release is called. + */ +class DriverActionImpl implements DriverAction { + + public DriverActionImpl(StubDriverDA d) { + driver = d; + } + + private final StubDriverDA driver; + + @Override + public void deregister() { + driver.release(); + } +} --- /dev/null 2014-10-28 10:30:06.000000000 -0400 +++ new/test/java/sql/testng/util/SerializedBatchUpdateException.java 2014-10-28 10:30:06.000000000 -0400 @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +public class SerializedBatchUpdateException { + /** + * Serialized BatchUpdateException from JDBC 4.0 with the following values + * reason = "This was the error msg" + * SQLState = "user defined sqlState" + * vendor Code = 99999 + * Update Counts = {1, 2, 21} + * cause = = "java.lang.Throwable: throw 1" + */ + public static byte[] DATA = { + (byte) 0xac, (byte) 0xed, (byte) 0x0, (byte) 0x5, (byte) 0x73, (byte) 0x72, (byte) 0x0, (byte) 0x1d, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x73, (byte) 0x71, (byte) 0x6c, (byte) 0x2e, (byte) 0x42, (byte) 0x61, (byte) 0x74, (byte) 0x63, (byte) 0x68, (byte) 0x55, (byte) 0x70, (byte) 0x64, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, + (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x52, (byte) 0xf4, (byte) 0x73, (byte) 0xc0, (byte) 0xc1, (byte) 0x8b, (byte) 0xe, (byte) 0x5d, (byte) 0x3, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x0, (byte) 0x10, (byte) 0x6c, (byte) 0x6f, (byte) 0x6e, (byte) 0x67, (byte) 0x55, (byte) 0x70, (byte) 0x64, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x43, (byte) 0x6f, (byte) 0x75, + (byte) 0x6e, (byte) 0x74, (byte) 0x73, (byte) 0x74, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x4a, (byte) 0x5b, (byte) 0x0, (byte) 0xc, (byte) 0x75, (byte) 0x70, (byte) 0x64, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x43, (byte) 0x6f, (byte) 0x75, (byte) 0x6e, (byte) 0x74, (byte) 0x73, (byte) 0x74, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x49, (byte) 0x78, (byte) 0x72, (byte) 0x0, (byte) 0x15, + (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x73, (byte) 0x71, (byte) 0x6c, (byte) 0x2e, (byte) 0x53, (byte) 0x51, (byte) 0x4c, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x1d, (byte) 0xa1, (byte) 0xe9, (byte) 0x30, (byte) 0xdb, (byte) 0x3e, (byte) 0x75, (byte) 0xdc, (byte) 0x2, (byte) 0x0, (byte) 0x3, + (byte) 0x49, (byte) 0x0, (byte) 0xa, (byte) 0x76, (byte) 0x65, (byte) 0x6e, (byte) 0x64, (byte) 0x6f, (byte) 0x72, (byte) 0x43, (byte) 0x6f, (byte) 0x64, (byte) 0x65, (byte) 0x4c, (byte) 0x0, (byte) 0x8, (byte) 0x53, (byte) 0x51, (byte) 0x4c, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x74, (byte) 0x0, (byte) 0x12, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, + (byte) 0x2f, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2f, (byte) 0x53, (byte) 0x74, (byte) 0x72, (byte) 0x69, (byte) 0x6e, (byte) 0x67, (byte) 0x3b, (byte) 0x4c, (byte) 0x0, (byte) 0x4, (byte) 0x6e, (byte) 0x65, (byte) 0x78, (byte) 0x74, (byte) 0x74, (byte) 0x0, (byte) 0x17, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x73, (byte) 0x71, (byte) 0x6c, + (byte) 0x2f, (byte) 0x53, (byte) 0x51, (byte) 0x4c, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x3b, (byte) 0x78, (byte) 0x72, (byte) 0x0, (byte) 0x13, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, + (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0xd0, (byte) 0xfd, (byte) 0x1f, (byte) 0x3e, (byte) 0x1a, (byte) 0x3b, (byte) 0x1c, (byte) 0xc4, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x72, (byte) 0x0, (byte) 0x13, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x54, (byte) 0x68, + (byte) 0x72, (byte) 0x6f, (byte) 0x77, (byte) 0x61, (byte) 0x62, (byte) 0x6c, (byte) 0x65, (byte) 0xd5, (byte) 0xc6, (byte) 0x35, (byte) 0x27, (byte) 0x39, (byte) 0x77, (byte) 0xb8, (byte) 0xcb, (byte) 0x3, (byte) 0x0, (byte) 0x4, (byte) 0x4c, (byte) 0x0, (byte) 0x5, (byte) 0x63, (byte) 0x61, (byte) 0x75, (byte) 0x73, (byte) 0x65, (byte) 0x74, (byte) 0x0, (byte) 0x15, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, + (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2f, (byte) 0x54, (byte) 0x68, (byte) 0x72, (byte) 0x6f, (byte) 0x77, (byte) 0x61, (byte) 0x62, (byte) 0x6c, (byte) 0x65, (byte) 0x3b, (byte) 0x4c, (byte) 0x0, (byte) 0xd, (byte) 0x64, (byte) 0x65, (byte) 0x74, (byte) 0x61, (byte) 0x69, (byte) 0x6c, (byte) 0x4d, (byte) 0x65, (byte) 0x73, (byte) 0x73, (byte) 0x61, + (byte) 0x67, (byte) 0x65, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x5b, (byte) 0x0, (byte) 0xa, (byte) 0x73, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, (byte) 0x65, (byte) 0x74, (byte) 0x0, (byte) 0x1e, (byte) 0x5b, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x6c, (byte) 0x61, + (byte) 0x6e, (byte) 0x67, (byte) 0x2f, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, (byte) 0x65, (byte) 0x45, (byte) 0x6c, (byte) 0x65, (byte) 0x6d, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x3b, (byte) 0x4c, (byte) 0x0, (byte) 0x14, (byte) 0x73, (byte) 0x75, (byte) 0x70, (byte) 0x70, (byte) 0x72, (byte) 0x65, (byte) 0x73, (byte) 0x73, + (byte) 0x65, (byte) 0x64, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x73, (byte) 0x74, (byte) 0x0, (byte) 0x10, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x75, (byte) 0x74, (byte) 0x69, (byte) 0x6c, (byte) 0x2f, (byte) 0x4c, (byte) 0x69, (byte) 0x73, (byte) 0x74, (byte) 0x3b, (byte) 0x78, + (byte) 0x70, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x7, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0xc, (byte) 0x74, (byte) 0x0, (byte) 0x7, (byte) 0x74, (byte) 0x68, (byte) 0x72, (byte) 0x6f, (byte) 0x77, (byte) 0x20, (byte) 0x31, (byte) 0x75, (byte) 0x72, (byte) 0x0, (byte) 0x1e, (byte) 0x5b, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, + (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, (byte) 0x65, (byte) 0x45, (byte) 0x6c, (byte) 0x65, (byte) 0x6d, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x3b, (byte) 0x2, (byte) 0x46, (byte) 0x2a, (byte) 0x3c, (byte) 0x3c, (byte) 0xfd, (byte) 0x22, (byte) 0x39, + (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x73, (byte) 0x72, (byte) 0x0, (byte) 0x1b, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, + (byte) 0x65, (byte) 0x45, (byte) 0x6c, (byte) 0x65, (byte) 0x6d, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x61, (byte) 0x9, (byte) 0xc5, (byte) 0x9a, (byte) 0x26, (byte) 0x36, (byte) 0xdd, (byte) 0x85, (byte) 0x2, (byte) 0x0, (byte) 0x4, (byte) 0x49, (byte) 0x0, (byte) 0xa, (byte) 0x6c, (byte) 0x69, (byte) 0x6e, (byte) 0x65, (byte) 0x4e, (byte) 0x75, (byte) 0x6d, (byte) 0x62, (byte) 0x65, (byte) 0x72, + (byte) 0x4c, (byte) 0x0, (byte) 0xe, (byte) 0x64, (byte) 0x65, (byte) 0x63, (byte) 0x6c, (byte) 0x61, (byte) 0x72, (byte) 0x69, (byte) 0x6e, (byte) 0x67, (byte) 0x43, (byte) 0x6c, (byte) 0x61, (byte) 0x73, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x4c, (byte) 0x0, (byte) 0x8, (byte) 0x66, (byte) 0x69, (byte) 0x6c, (byte) 0x65, (byte) 0x4e, (byte) 0x61, (byte) 0x6d, + (byte) 0x65, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x4c, (byte) 0x0, (byte) 0xa, (byte) 0x6d, (byte) 0x65, (byte) 0x74, (byte) 0x68, (byte) 0x6f, (byte) 0x64, (byte) 0x4e, (byte) 0x61, (byte) 0x6d, (byte) 0x65, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x23, (byte) 0x74, (byte) 0x0, + (byte) 0x17, (byte) 0x43, (byte) 0x72, (byte) 0x65, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x42, (byte) 0x61, (byte) 0x74, (byte) 0x63, (byte) 0x68, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x53, (byte) 0x65, (byte) 0x72, (byte) 0x74, (byte) 0x0, (byte) 0x1c, (byte) 0x43, (byte) 0x72, (byte) 0x65, (byte) 0x61, (byte) 0x74, + (byte) 0x65, (byte) 0x42, (byte) 0x61, (byte) 0x74, (byte) 0x63, (byte) 0x68, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x53, (byte) 0x65, (byte) 0x72, (byte) 0x2e, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x74, (byte) 0x0, (byte) 0x9, (byte) 0x77, (byte) 0x72, (byte) 0x69, (byte) 0x74, (byte) 0x65, (byte) 0x54, + (byte) 0x65, (byte) 0x73, (byte) 0x74, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1a, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x12, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x13, (byte) 0x74, (byte) 0x0, (byte) 0x4, (byte) 0x6d, (byte) 0x61, (byte) 0x69, (byte) 0x6e, (byte) 0x70, (byte) 0x78, + (byte) 0x74, (byte) 0x0, (byte) 0x16, (byte) 0x54, (byte) 0x68, (byte) 0x69, (byte) 0x73, (byte) 0x20, (byte) 0x77, (byte) 0x61, (byte) 0x73, (byte) 0x20, (byte) 0x74, (byte) 0x68, (byte) 0x65, (byte) 0x20, (byte) 0x65, (byte) 0x72, (byte) 0x72, (byte) 0x6f, (byte) 0x72, (byte) 0x20, (byte) 0x6d, (byte) 0x73, (byte) 0x67, (byte) 0x75, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0xe, (byte) 0x0, + (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x28, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x12, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x13, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x14, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, + (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1a, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x12, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x13, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x16, (byte) 0x70, (byte) 0x78, (byte) 0x0, (byte) 0x1, (byte) 0x86, (byte) 0x9f, (byte) 0x74, (byte) 0x0, (byte) 0x15, (byte) 0x75, (byte) 0x73, + (byte) 0x65, (byte) 0x72, (byte) 0x20, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x69, (byte) 0x6e, (byte) 0x65, (byte) 0x64, (byte) 0x20, (byte) 0x73, (byte) 0x71, (byte) 0x6c, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x70, (byte) 0x75, (byte) 0x72, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x4a, (byte) 0x78, (byte) 0x20, (byte) 0x4, (byte) 0xb5, (byte) 0x12, (byte) 0xb1, + (byte) 0x75, (byte) 0x93, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x3, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, + (byte) 0x0, (byte) 0x0, (byte) 0x15, (byte) 0x75, (byte) 0x72, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x49, (byte) 0x4d, (byte) 0xba, (byte) 0x60, (byte) 0x26, (byte) 0x76, (byte) 0xea, (byte) 0xb2, (byte) 0xa5, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x3, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1, (byte) 0x0, (byte) 0x0, + (byte) 0x0, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x15, (byte) 0x78 + }; +} --- /dev/null 2014-10-28 10:30:07.000000000 -0400 +++ new/test/java/sql/testng/util/StubConnection.java 2014-10-28 10:30:07.000000000 -0400 @@ -0,0 +1,315 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +import java.sql.Array; +import java.sql.Blob; +import java.sql.CallableStatement; +import java.sql.Clob; +import java.sql.Connection; +import java.sql.DatabaseMetaData; +import java.sql.NClob; +import java.sql.PreparedStatement; +import java.sql.SQLClientInfoException; +import java.sql.SQLException; +import java.sql.SQLWarning; +import java.sql.SQLXML; +import java.sql.Savepoint; +import java.sql.Statement; +import java.sql.Struct; +import java.util.Map; +import java.util.Properties; +import java.util.concurrent.Executor; + +public class StubConnection implements Connection { + + @Override + public Statement createStatement() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public PreparedStatement prepareStatement(String sql) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public CallableStatement prepareCall(String sql) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public String nativeSQL(String sql) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setAutoCommit(boolean autoCommit) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public boolean getAutoCommit() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void commit() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void rollback() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void close() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public boolean isClosed() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public DatabaseMetaData getMetaData() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setReadOnly(boolean readOnly) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public boolean isReadOnly() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setCatalog(String catalog) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public String getCatalog() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setTransactionIsolation(int level) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public int getTransactionIsolation() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public SQLWarning getWarnings() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void clearWarnings() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Map> getTypeMap() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setTypeMap(Map> map) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setHoldability(int holdability) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public int getHoldability() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Savepoint setSavepoint() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Savepoint setSavepoint(String name) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void rollback(Savepoint savepoint) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void releaseSavepoint(Savepoint savepoint) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Clob createClob() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Blob createBlob() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public NClob createNClob() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public SQLXML createSQLXML() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public boolean isValid(int timeout) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setClientInfo(String name, String value) throws SQLClientInfoException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setClientInfo(Properties properties) throws SQLClientInfoException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public String getClientInfo(String name) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Properties getClientInfo() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Array createArrayOf(String typeName, Object[] elements) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Struct createStruct(String typeName, Object[] attributes) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setSchema(String schema) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public String getSchema() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void abort(Executor executor) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public int getNetworkTimeout() throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public T unwrap(Class iface) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public boolean isWrapperFor(Class iface) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } +} --- /dev/null 2014-10-28 10:30:08.000000000 -0400 +++ new/test/java/sql/testng/util/StubDriver.java 2014-10-28 10:30:08.000000000 -0400 @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +import java.sql.Connection; +import java.sql.Driver; +import java.sql.DriverPropertyInfo; +import java.sql.SQLException; +import java.sql.SQLFeatureNotSupportedException; +import java.util.Properties; +import java.util.logging.Logger; + +public class StubDriver implements Driver { + + public StubDriver() { + } + + @Override + public Connection connect(String url, Properties info) throws SQLException { + if (acceptsURL(url)) { + return new StubConnection(); + } + return null; + } + + @Override + public boolean acceptsURL(String url) throws SQLException { + return url.matches("^jdbc:tennis:.*"); + } + + @Override + public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public int getMajorVersion() { + return 1; + } + + @Override + public int getMinorVersion() { + return 0; + } + + @Override + public boolean jdbcCompliant() { + return true; + } + + @Override + public Logger getParentLogger() throws SQLFeatureNotSupportedException { + throw new UnsupportedOperationException("Not supported yet."); + } +} --- /dev/null 2014-10-28 10:30:09.000000000 -0400 +++ new/test/java/sql/testng/util/StubDriverDA.java 2014-10-28 10:30:09.000000000 -0400 @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +import java.io.File; +import java.io.IOException; +import java.sql.DriverAction; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Simple java.sql.Driver stub class that registers the driver via a static + * block with a DriverAction Implementation + * @author ljanders + */ +public class StubDriverDA extends StubDriver { + + public static final String DriverActionCalled = "DriverActionCalled.txt"; + + static DriverAction da; + + static { + try { + DriverManager.registerDriver(new StubDriverDA(), da); + } catch (SQLException ex) { + Logger.getLogger(StubDriverDA.class.getName()).log(Level.SEVERE, null, ex); + } + } + + public StubDriverDA() { + da = new DriverActionImpl(this); + } + + @Override + public boolean acceptsURL(String url) throws SQLException { + return url.matches("^jdbc:luckydog:.*"); + } + + /** + * This method will write out a text file when called by the + * DriverActionImpl.release method when DriverManager.deregisterDriver + * is called. This is used by DriverManagerTests to validate that + * DriverAction.release was called + */ + protected void release() { + File file = new File(DriverActionCalled); + try { + file.createNewFile(); + } catch (IOException ex) { + throw new RuntimeException(ex); + } + } +} --- /dev/null 2014-10-28 10:30:10.000000000 -0400 +++ new/test/java/sql/testng/util/TestPolicy.java 2014-10-28 10:30:10.000000000 -0400 @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +package util; + +import java.io.FilePermission; +import java.security.AllPermission; +import java.security.CodeSource; +import java.security.Permission; +import java.security.PermissionCollection; +import java.security.Permissions; +import java.security.Policy; +import java.security.ProtectionDomain; +import java.security.SecurityPermission; +import java.sql.SQLPermission; +import java.util.Enumeration; +import java.util.PropertyPermission; +import java.util.StringJoiner; + +/* + * Simple Policy class that supports the required Permissions to validate the + * JDBC concrete classes + */ +public class TestPolicy extends Policy { + + final PermissionCollection permissions = new Permissions(); + + /** + * Constructor which sets the minimum permissions allowing testNG to work + * with a SecurityManager + */ + public TestPolicy() { + setMinimalPermissions(); + } + + /* + * Constructor which determines which permissions are defined for this + * Policy used by the JDBC tests Possible values are: all (ALLPermissions), + * setLog (SQLPemission("setLog"), deregisterDriver + * (SQLPermission("deregisterDriver") (SQLPermission("deregisterDriver"), + * and setSyncFactory(SQLPermission(setSyncFactory), + * + * @param policy Permissions to set + */ + public TestPolicy(String policy) { + + switch (policy) { + case "all": + permissions.add(new AllPermission()); + break; + case "setLog": + setMinimalPermissions(); + permissions.add(new SQLPermission("setLog")); + break; + case "deregisterDriver": + setMinimalPermissions(); + permissions.add(new SQLPermission("deregisterDriver")); + break; + case "setSyncFactory": + setMinimalPermissions(); + permissions.add(new SQLPermission("setSyncFactory")); + break; + default: + setMinimalPermissions(); + } + } + + /* + * Defines the minimal permissions required by testNG when running these + * tests + */ + private void setMinimalPermissions() { + permissions.add(new SecurityPermission("getPolicy")); + permissions.add(new SecurityPermission("setPolicy")); + permissions.add(new RuntimePermission("getClassLoader")); + permissions.add(new RuntimePermission("setSecurityManager")); + permissions.add(new RuntimePermission("createSecurityManager")); + permissions.add(new PropertyPermission("testng.show.stack.frames", + "read")); + permissions.add(new PropertyPermission("line.separator", "read")); + permissions.add(new PropertyPermission("fileStringBuffer", "read")); + permissions.add(new PropertyPermission("dataproviderthreadcount", "read")); + permissions.add(new PropertyPermission("java.io.tmpdir", "read")); + permissions.add(new FilePermission("<>", + "read, write, delete")); + } + + /* + * Overloaded methods from the Policy class + */ + @Override + public String toString() { + StringJoiner sj = new StringJoiner("\n", "policy: ", ""); + Enumeration perms = permissions.elements(); + while (perms.hasMoreElements()) { + sj.add(perms.nextElement().toString()); + } + return sj.toString(); + + } + + @Override + public PermissionCollection getPermissions(ProtectionDomain domain) { + return permissions; + } + + @Override + public PermissionCollection getPermissions(CodeSource codesource) { + return permissions; + } + + @Override + public boolean implies(ProtectionDomain domain, Permission perm) { + return permissions.implies(perm); + } +} --- old/test/java/sql/TEST.properties 2014-10-28 10:30:11.000000000 -0400 +++ /dev/null 2014-10-28 10:30:11.000000000 -0400 @@ -1,3 +0,0 @@ -# JDBC unit tests uses TestNG -TestNG.dirs = . - --- old/test/java/sql/test/sql/BatchUpdateExceptionTests.java 2014-10-28 10:30:12.000000000 -0400 +++ /dev/null 2014-10-28 10:30:12.000000000 -0400 @@ -1,326 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.io.ByteArrayInputStream; -import java.io.File; -import java.io.ObjectInputStream; -import java.sql.BatchUpdateException; -import java.sql.SQLException; -import java.util.Arrays; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.SerializedBatchUpdateException; -import util.BaseTest; - -public class BatchUpdateExceptionTests extends BaseTest { - - private final int[] uc = {1, 2, 3}; - private final long[] luc = {1, 2, 3}; - - private final String testSrcDir = System.getProperty("test.src", ".") - + File.separatorChar; - - /** - * Create BatchUpdateException and setting all objects to null - */ - @Test - public void test() { - BatchUpdateException be = new BatchUpdateException(null, - null, errorCode, (int[]) null, null); - assertTrue(be.getMessage() == null && be.getSQLState() == null - && be.getUpdateCounts() == null && be.getCause() == null - && be.getLargeUpdateCounts() == null - && be.getErrorCode() == errorCode); - } - - /** - * Create BatchUpdateException with no-arg constructor - */ - @Test - public void test1() { - BatchUpdateException ex = new BatchUpdateException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getUpdateCounts() == null - && ex.getLargeUpdateCounts() == null); - } - - /** - * Create BatchUpdateException with null Throwable - */ - @Test - public void test2() { - BatchUpdateException ex = new BatchUpdateException((Throwable) null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getUpdateCounts() == null - && ex.getLargeUpdateCounts() == null); - } - - /** - * Create BatchUpdateException with message and update counts - */ - @Test - public void test3() { - - BatchUpdateException ex = new BatchUpdateException(reason, uc); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Create BatchUpdateException with update counts - */ - @Test - public void test4() { - BatchUpdateException ex = new BatchUpdateException(uc); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Create BatchUpdateException with Throwable and update counts - */ - @Test - public void test5() { - BatchUpdateException ex = new BatchUpdateException(uc, t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0 - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Create BatchUpdateException with message, Throwable, and update counts - */ - @Test - public void test6() { - BatchUpdateException ex = new BatchUpdateException(reason, uc, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0 - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Create BatchUpdateException with message, SQLState, Throwable, and update - * counts - */ - @Test - public void test7() { - BatchUpdateException ex = new BatchUpdateException(reason, state, uc, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0 - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Create BatchUpdateException with message, SQLState, errorCode code - * Throwable, and update counts - */ - @Test - public void test8() { - BatchUpdateException ex = new BatchUpdateException(reason, state, errorCode, - uc, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Create BatchUpdateException with message, SQLState, errorCode code - * Throwable, and long [] update counts - */ - @Test - public void test9() { - BatchUpdateException ex = new BatchUpdateException(reason, state, errorCode, - luc, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode - && Arrays.equals(ex.getUpdateCounts(), uc) - && Arrays.equals(ex.getLargeUpdateCounts(), luc) - ); - } - - /** - * Validate that a copy of the update counts array is made - */ - @Test - public void test10() { - int[] uc1 = {1, 2}; - BatchUpdateException ex = new BatchUpdateException(uc1); - assertTrue(Arrays.equals(ex.getUpdateCounts(), uc1)); - uc1[0] = 6689; - assertFalse(Arrays.equals(ex.getUpdateCounts(), uc1)); - } - - /** - * Validate that if null is specified for the update count, it is returned - * as null - */ - @Test - public void test11() { - BatchUpdateException ex = new BatchUpdateException((int[]) null); - assertTrue(ex.getMessage() == null && ex.getSQLState() == null - && ex.getErrorCode() == 0 && ex.getUpdateCounts() == null - && ex.getLargeUpdateCounts() == null); - } - - /** - * Serialize a BatchUpdateException and make sure you can read it back - * properly - */ - @Test - public void test12() throws Exception { - BatchUpdateException be = new BatchUpdateException(reason, state, errorCode, - uc, t); - BatchUpdateException bue - = createSerializedException(be); - assertTrue(reason.equals(bue.getMessage()) - && bue.getSQLState().equals(state) - && cause.equals(bue.getCause().toString()) - && bue.getErrorCode() == errorCode - && Arrays.equals(bue.getLargeUpdateCounts(), luc) - && Arrays.equals(bue.getUpdateCounts(), uc)); - } - - - - /** - * De-Serialize a BatchUpdateException from JDBC 4.0 and make sure you can - * read it back properly - */ - @Test - public void test13() throws Exception { - String reason1 = "This was the error msg"; - String state1 = "user defined sqlState"; - String cause1 = "java.lang.Throwable: throw 1"; - int errorCode1 = 99999; - Throwable t = new Throwable("throw 1"); - int[] uc1 = {1, 2, 21}; - long[] luc1 = {1, 2, 21}; - - ObjectInputStream ois = new ObjectInputStream( - new ByteArrayInputStream(SerializedBatchUpdateException.DATA)); - BatchUpdateException bue = (BatchUpdateException) ois.readObject(); - assertTrue(reason1.equals(bue.getMessage()) - && bue.getSQLState().equals(state1) - && bue.getErrorCode() == errorCode1 - && cause1.equals(bue.getCause().toString()) - && Arrays.equals(bue.getLargeUpdateCounts(), luc1) - && Arrays.equals(bue.getUpdateCounts(), uc1)); - } - - /** - * Serialize a BatchUpdateException with an Integer.MAX_VALUE + 1 and - * validate you can read it back properly - */ - @Test - public void test14() throws Exception { - int[] uc1 = {Integer.MAX_VALUE, Integer.MAX_VALUE + 1}; - long[] luc1 = {Integer.MAX_VALUE, Integer.MAX_VALUE + 1}; - BatchUpdateException be = new BatchUpdateException(reason, state, errorCode, - luc1, t); - BatchUpdateException bue - = createSerializedException(be); - assertTrue(reason.equals(bue.getMessage()) - && bue.getSQLState().equals(state) - && cause.equals(bue.getCause().toString()) - && bue.getErrorCode() == errorCode - && Arrays.equals(bue.getLargeUpdateCounts(), luc1) - && Arrays.equals(bue.getUpdateCounts(), uc1)); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test15() { - BatchUpdateException ex = new BatchUpdateException("Exception 1", uc, t1); - BatchUpdateException ex1 = new BatchUpdateException("Exception 2", uc); - BatchUpdateException ex2 = new BatchUpdateException("Exception 3", uc, t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test16() { - BatchUpdateException ex = new BatchUpdateException("Exception 1", uc, t1); - BatchUpdateException ex1 = new BatchUpdateException("Exception 2", uc); - BatchUpdateException ex2 = new BatchUpdateException("Exception 3", uc, t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - SQLException sqe = ex; - int num = 0; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - -} --- old/test/java/sql/test/sql/DataTruncationTests.java 2014-10-28 10:30:13.000000000 -0400 +++ /dev/null 2014-10-28 10:30:13.000000000 -0400 @@ -1,209 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.DataTruncation; -import java.sql.SQLException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class DataTruncationTests extends BaseTest { - - private final String READ_TRUNCATION = "01004"; - private final String WRITE_TRUNCATION = "22001"; - private final String dtReason = "Data truncation"; - private final int dterrorCode = 0; - private final String[] dtmsgs = {dtReason, "cause 1", dtReason, - dtReason, "cause 2"}; - private boolean onRead = false; - private final boolean parameter = false; - private final int index = 21; - private final int dataSize = 25; - private final int transferSize = 10; - - /** - * Create DataTruncation object indicating a truncation on read - */ - @Test - public void test() { - onRead = true; - DataTruncation e = new DataTruncation(index, parameter, onRead, - dataSize, transferSize); - assertTrue(e.getMessage().equals(dtReason) - && e.getSQLState().equals(READ_TRUNCATION) - && e.getCause() == null - && e.getErrorCode() == dterrorCode - && e.getParameter() == parameter - && e.getRead() == onRead - && e.getDataSize() == dataSize - && e.getTransferSize() == transferSize - && e.getIndex() == index); - } - - /** - * Create DataTruncation object indicating a truncation on write - */ - @Test - public void test1() { - onRead = false; - DataTruncation e = new DataTruncation(index, parameter, onRead, - dataSize, transferSize); - assertTrue(e.getMessage().equals(dtReason) - && e.getSQLState().equals(WRITE_TRUNCATION) - && e.getCause() == null - && e.getErrorCode() == dterrorCode - && e.getParameter() == parameter - && e.getRead() == onRead - && e.getDataSize() == dataSize - && e.getTransferSize() == transferSize - && e.getIndex() == index); - } - - /** - * Create DataTruncation object indicating a truncation on read with a - * Throwable - */ - @Test - public void test2() { - onRead = true; - DataTruncation e = new DataTruncation(index, parameter, onRead, - dataSize, transferSize, t); - assertTrue(e.getMessage().equals(dtReason) - && e.getSQLState().equals(READ_TRUNCATION) - && cause.equals(e.getCause().toString()) - && e.getErrorCode() == dterrorCode - && e.getParameter() == parameter - && e.getRead() == onRead - && e.getDataSize() == dataSize - && e.getTransferSize() == transferSize - && e.getIndex() == index); - } - - /** - * Create DataTruncation object indicating a truncation on read with null - * specified for the Throwable - */ - @Test - public void test3() { - onRead = true;; - DataTruncation e = new DataTruncation(index, parameter, onRead, - dataSize, transferSize, null); - assertTrue(e.getMessage().equals(dtReason) - && e.getSQLState().equals(READ_TRUNCATION) - && e.getCause() == null - && e.getErrorCode() == dterrorCode - && e.getParameter() == parameter - && e.getRead() == onRead - && e.getDataSize() == dataSize - && e.getTransferSize() == transferSize - && e.getIndex() == index); - } - - /** - * Create DataTruncation object indicating a truncation on read and you can - * pass a -1 for the index - */ - @Test - public void test4() { - onRead = true; - int negIndex = -1; - DataTruncation e = new DataTruncation(negIndex, parameter, onRead, - dataSize, transferSize); - assertTrue(e.getMessage().equals(dtReason) - && e.getSQLState().equals(READ_TRUNCATION) - && e.getCause() == null - && e.getErrorCode() == dterrorCode - && e.getParameter() == parameter - && e.getRead() == onRead - && e.getDataSize() == dataSize - && e.getTransferSize() == transferSize - && e.getIndex() == negIndex); - } - - /** - * Serialize a DataTruncation and make sure you can read it back properly - */ - @Test - public void test5() throws Exception { - DataTruncation e = new DataTruncation(index, parameter, onRead, - dataSize, transferSize); - DataTruncation ex1 = createSerializedException(e); - assertTrue(e.getMessage().equals(dtReason) - && e.getSQLState().equals(READ_TRUNCATION) - && e.getCause() == null - && e.getErrorCode() == dterrorCode - && e.getParameter() == parameter - && e.getRead() == onRead - && e.getDataSize() == dataSize - && e.getTransferSize() == transferSize - && e.getIndex() == index); - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * for-each loop - */ - @Test - public void test11() { - DataTruncation ex = new DataTruncation(index, parameter, onRead, - dataSize, transferSize, t1); - DataTruncation ex1 = new DataTruncation(index, parameter, onRead, - dataSize, transferSize); - DataTruncation ex2 = new DataTruncation(index, parameter, onRead, - dataSize, transferSize, t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(dtmsgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * traditional while loop - */ - @Test - public void test12() { - DataTruncation ex = new DataTruncation(index, parameter, onRead, - dataSize, transferSize, t1); - DataTruncation ex1 = new DataTruncation(index, parameter, onRead, - dataSize, transferSize); - DataTruncation ex2 = new DataTruncation(index, parameter, onRead, - dataSize, transferSize, t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(dtmsgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(dtmsgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } -} --- old/test/java/sql/test/sql/DateTests.java 2014-10-28 10:30:13.000000000 -0400 +++ /dev/null 2014-10-28 10:30:13.000000000 -0400 @@ -1,373 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.Date; -import java.time.Instant; -import java.time.LocalDate; -import static org.testng.Assert.*; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import util.BaseTest; - -public class DateTests extends BaseTest { - - /* - * Validate an IllegalArgumentException is thrown for an invalid Date string - */ - @Test(dataProvider = "invalidDateValues", - expectedExceptions = IllegalArgumentException.class) - public void test(String d) throws Exception { - Date.valueOf(d); - } - - /* - * Test that a date created from a date string is equal to the value - * returned from toString() - */ - @Test(dataProvider = "validDateValues") - public void test00(String d, String expectedD) { - Date d1 = Date.valueOf(d); - Date d2 = Date.valueOf(expectedD); - assertTrue(d1.equals(d2) && d2.equals(d1) - && d1.toString().equals(expectedD), "Error d1 != d2"); - } - - /* - * Validate that a Date.after() returns false when same date is compared - */ - @Test - public void test01() { - Date d = Date.valueOf("1961-08-30"); - assertFalse(d.after(d), "Error d.after(d) = true"); - } - - /* - * Validate that a Date.after() returns true when later date is compared to - * earlier date - */ - @Test - public void test2() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(System.currentTimeMillis()); - assertTrue(d2.after(d), "Error d2.after(d) = false"); - } - - /* - * Validate that a Date.after() returns false when earlier date is compared - * to later date - */ - @Test - public void test3() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(d.getTime()); - assertFalse(d.after(d2), "Error d.after(d2) = true"); - } - - /* - * Validate that a Date.after() returns false when date compared to another - * date created from the original date - */ - @Test - public void test4() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(d.getTime()); - assertFalse(d.after(d2), "Error d.after(d2) = true"); - assertFalse(d2.after(d), "Error d2.after(d) = true"); - } - - /* - * Validate that a Date.before() returns false when same date is compared - */ - @Test - public void test5() { - Date d = Date.valueOf("1961-08-30"); - assertFalse(d.before(d), "Error d.before(d) = true"); - } - - /* - * Validate that a Date.before() returns true when earlier date is compared - * to later date - */ - @Test - public void test6() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(System.currentTimeMillis()); - assertTrue(d.before(d2), "Error d.before(d2) = false"); - } - - /* - * Validate that a Date.before() returns false when later date is compared - * to earlier date - */ - @Test - public void test7() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(d.getTime()); - assertFalse(d2.before(d), "Error d2.before(d) = true"); - } - - /* - * Validate that a Date.before() returns false when date compared to another - * date created from the original date - */ - @Test - public void test8() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(d.getTime()); - assertFalse(d.before(d2), "Error d.before(d2) = true"); - assertFalse(d2.before(d), "Error d2.before(d) = true"); - } - - /* - * Validate that a Date.compareTo returns 0 when both Date objects are the - * same - */ - @Test - public void test9() { - Date d = Date.valueOf("1961-08-30"); - assertTrue(d.compareTo(d) == 0, "Error d.compareTo(d) !=0"); - } - - /* - * Validate that a Date.compareTo returns 0 when both Date objects represent - * the same date - */ - @Test - public void test10() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(d.getTime()); - assertTrue(d.compareTo(d2) == 0, "Error d.compareTo(d2) !=0"); - } - - /* - * Validate that a Date.compareTo returns -1 when comparing a date to a - * later date - */ - @Test - public void test11() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(System.currentTimeMillis()); - assertTrue(d.compareTo(d2) == -1, "Error d.compareTo(d2) != -1"); - } - - /* - * Validate that a Date.compareTo returns 1 when comparing a date to an - * earlier date - */ - @Test - public void test12() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(System.currentTimeMillis()); - assertTrue(d2.compareTo(d) == 1, "Error d.compareTo(d2) != 1"); - } - - /* - * Validate that a Date made from a LocalDate are equal - */ - @Test - public void test13() { - Date d = Date.valueOf("1961-08-30"); - LocalDate ldt = d.toLocalDate(); - Date d2 = Date.valueOf(ldt); - assertTrue(d.equals(d2), "Error d != d2"); - } - - /* - * Validate that a Date LocalDate value, made from a LocalDate are equal - */ - @Test - public void test14() { - LocalDate ldt = LocalDate.now(); - Date d = Date.valueOf(ldt); - assertTrue(ldt.equals(d.toLocalDate()), - "Error LocalDate values are not equal"); - } - - /* - * Validate an NPE occurs when a null LocalDate is passed to valueOf - */ - @Test(expectedExceptions = NullPointerException.class) - public void test15() throws Exception { - LocalDate ld = null; - Date.valueOf(ld); - } - - /* - * Validate an UnsupportedOperationException occurs when toInstant() is - * called - */ - @Test(expectedExceptions = UnsupportedOperationException.class) - public void test16() throws Exception { - Date d = Date.valueOf("1961-08-30"); - Instant instant = d.toInstant(); - } - - /* - * Validate that two Date objects are equal when one is created from the - * toString() of the other - */ - @Test - public void test17() { - Date d = Date.valueOf("1961-08-30"); - Date d2 = Date.valueOf(d.toString()); - assertTrue(d.equals(d2) && d2.equals(d), "Error d != d2"); - } - - /* - * Validate that two Date values one created using valueOf and another via a - * constructor are equal - */ - @Test - public void test18() { - - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(61, 7, 30); - assertTrue(d.equals(d2), "Error d != d2"); - } - - /* - * Validate that two Date values one created using getTime() of the other - * are equal - */ - @Test - public void test19() { - - Date d = Date.valueOf("1961-08-30"); - Date d2 = new Date(d.getTime()); - assertTrue(d.equals(d2), "Error d != d2"); - } - - /* - * Validate that a Date value is equal to itself - */ - @Test - public void test20() { - - Date d = Date.valueOf("1961-08-30"); - assertTrue(d.equals(d), "Error d != d"); - } - - /* - * Validate an IllegalArgumentException is thrown for calling getHours - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test21() throws Exception { - Date d = Date.valueOf("1961-08-30"); - d.getHours(); - } - - /* - * Validate an IllegalArgumentException is thrown for calling getMinutes - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test22() throws Exception { - Date d = Date.valueOf("1961-08-30"); - d.getMinutes(); - } - - /* - * Validate an IllegalArgumentException is thrown for calling getSeconds - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test23() throws Exception { - Date d = Date.valueOf("1961-08-30"); - d.getSeconds(); - } - - /* - * Validate an IllegalArgumentException is thrown for calling setHours - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test24() throws Exception { - Date d = Date.valueOf("1961-08-30"); - d.setHours(8); - } - - /* - * Validate an IllegalArgumentException is thrown for calling setMinutes - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test25() throws Exception { - Date d = Date.valueOf("1961-08-30"); - d.setMinutes(0); - } - - /* - * Validate an IllegalArgumentException is thrown for calling setSeconds - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test26() throws Exception { - Date d = Date.valueOf("1961-08-30"); - d.setSeconds(0); - } - - /* - * DataProvider used to provide Date which are not valid and are used - * to validate that an IllegalArgumentException will be thrown from the - * valueOf method - */ - @DataProvider(name = "invalidDateValues") - private Object[][] invalidDateValues() { - return new Object[][]{ - {"20009-11-01"}, - {"09-11-01"}, - {"-11-01"}, - {"2009-111-01"}, - {"2009--01"}, - {"2009-13-01"}, - {"2009-11-011"}, - {"2009-11-"}, - {"2009-11-00"}, - {"2009-11-33"}, - {"--"}, - {""}, - {null}, - {"-"}, - {"2009"}, - {"2009-01"}, - {"---"}, - {"2009-13--1"}, - {"1900-1-0"}, - {"2009-01-01 10:50:01"}, - {"1996-12-10 12:26:19.1"}, - {"10:50:01"} - }; - } - - /* - * DataProvider used to provide Dates which are valid and are used - * to validate that an IllegalArgumentException will not be thrown from the - * valueOf method and the corect value from toString() is returned - */ - @DataProvider(name = "validDateValues") - private Object[][] validDateValues() { - return new Object[][]{ - {"2009-08-30", "2009-08-30"}, - {"2009-01-8", "2009-01-08"}, - {"2009-1-01", "2009-01-01"}, - {"2009-1-1", "2009-01-01"} - - }; - } -} --- old/test/java/sql/test/sql/DriverManagerPermissionsTests.java 2014-10-28 10:30:14.000000000 -0400 +++ /dev/null 2014-10-28 10:30:14.000000000 -0400 @@ -1,154 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.security.AccessControlException; -import java.security.Policy; -import java.sql.DriverManager; -import java.sql.SQLException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.Test; -import util.BaseTest; -import util.StubDriver; -import util.TestPolicy; - -public class DriverManagerPermissionsTests extends BaseTest { - - private static Policy policy; - private static SecurityManager sm; - - /* - * Install a SecurityManager along with a base Policy to allow testNG to run - */ - @BeforeClass - public static void setUpClass() throws Exception { - setPolicy(new TestPolicy()); - System.setSecurityManager(new SecurityManager()); - } - - /* - * Install the original Policy and SecurityManager - */ - @AfterClass - public static void tearDownClass() throws Exception { - System.setSecurityManager(sm); - setPolicy(policy); - } - - /* - * Save off the original Policy and SecurityManager - */ - public DriverManagerPermissionsTests() { - policy = Policy.getPolicy(); - sm = System.getSecurityManager(); - } - - /* - * Validate that AccessControlException is thrown if SQLPermission("setLog") - * has not been granted - */ - @Test(expectedExceptions = AccessControlException.class) - public void test() { - setPolicy(new TestPolicy()); - DriverManager.setLogStream(null); - } - - /* - * Validate that setLogStream succeeds if SQLPermission("setLog") has been - * granted - */ - @Test - public void test1() { - Policy.setPolicy(new TestPolicy("setLog")); - DriverManager.setLogStream(null); - } - - /* - * Validate that setLogStream succeeds if AllPermissions has been granted - */ - @Test - public void test2() { - setPolicy(new TestPolicy("all")); - DriverManager.setLogStream(null); - } - - /* - * Validate that AccessControlException is thrown if SQLPermission("setLog") - * has not been granted - */ - @Test(expectedExceptions = AccessControlException.class) - public void test4() { - setPolicy(new TestPolicy()); - DriverManager.setLogWriter(null); - } - - /* - * Validate that setLogWriter succeeds if SQLPermission("setLog") has been - * granted - */ - @Test - public void test5() { - setPolicy(new TestPolicy("setLog")); - DriverManager.setLogWriter(null); - } - - /* - * Validate that setLogWriter succeeds if AllPermissions has been granted - */ - @Test - public void test6() { - setPolicy(new TestPolicy("all")); - DriverManager.setLogWriter(null); - } - - /* - * Validate that AccessControlException is thrown if - * SQLPermission("deregisterDriver") has not been granted - */ - @Test(expectedExceptions = AccessControlException.class) - public void test7() throws SQLException { - setPolicy(new TestPolicy()); - DriverManager.deregisterDriver(new StubDriver()); - } - - /* - * Validate that deregisterDriver succeeds if - * SQLPermission("deregisterDriver") has been granted - */ - @Test - public void test8() throws SQLException { - setPolicy(new TestPolicy("deregisterDriver")); - DriverManager.deregisterDriver(new StubDriver()); - } - - /* - * Validate that deregisterDriver succeeds if AllPermissions has been - * granted - */ - @Test - public void test9() throws SQLException { - setPolicy(new TestPolicy("all")); - DriverManager.deregisterDriver(new StubDriver()); - } -} --- old/test/java/sql/test/sql/DriverManagerTests.java 2014-10-28 10:30:15.000000000 -0400 +++ /dev/null 2014-10-28 10:30:15.000000000 -0400 @@ -1,354 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.io.BufferedReader; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.CharArrayReader; -import java.io.CharArrayWriter; -import java.io.File; -import java.io.InputStreamReader; -import java.io.PrintStream; -import java.io.PrintWriter; -import java.sql.Driver; -import java.sql.DriverManager; -import java.sql.SQLException; -import java.util.Properties; -import static org.testng.Assert.*; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterMethod; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.Test; -import util.StubDriver; - -public class DriverManagerTests { - - private final String StubDriverURL = "jdbc:tennis:boy"; - private final String StubDriverDAURL = "jdbc:luckydog:tennis"; - private final String InvalidURL = "jdbc:cardio:tennis"; - private String[] results = {"output", "more output", "and more", "the end"}; - private String noOutput = "should not find this"; - - public DriverManagerTests() { - } - - @BeforeClass - public static void setUpClass() throws Exception { - } - - @AfterClass - public static void tearDownClass() throws Exception { - } - - @BeforeMethod - public void setUpMethod() throws Exception { - removeAllDrivers(); - } - - @AfterMethod - public void tearDownMethod() throws Exception { - } - - /** - * Utility method to remove all registered drivers - */ - private static void removeAllDrivers() { - java.util.Enumeration e = DriverManager.getDrivers(); - while (e.hasMoreElements()) { - try { - DriverManager.deregisterDriver((Driver) (e.nextElement())); - } catch (SQLException ex) { - System.out.print(ex.getMessage()); - } - } - } - - /** - * Utility method to see if a driver is registered - */ - private boolean isDriverRegistered(Driver d) { - boolean foundDriver = false; - java.util.Enumeration e = DriverManager.getDrivers(); - while (e.hasMoreElements()) { - if (d == (Driver) e.nextElement()) { - foundDriver = true; - break; - } - } - return foundDriver; - } - - /** - * Validate that values set using setLoginTimeout will be returned by - * getLoginTimeout - */ - @Test - public void test() { - int[] vals = {-1, 0, 5}; - for (int val : vals) { - DriverManager.setLoginTimeout(val); - assertEquals(val, DriverManager.getLoginTimeout()); - } - } - - /** - * Validate that NullPointerException is thrown when null is passed to - * registerDriver - */ - @Test(expectedExceptions = NullPointerException.class) - public void test1() throws Exception { - Driver d = null; - DriverManager.registerDriver(d); - } - - /** - * Validate that NullPointerException is thrown when null is passed to - * registerDriver - */ - @Test(expectedExceptions = NullPointerException.class) - public void test2() throws Exception { - Driver d = null; - DriverManager.registerDriver(d, null); - } - - /** - * Validate that a null value allows for deRegisterDriver to return - */ - @Test - public void test3() throws Exception { - DriverManager.deregisterDriver(null); - - } - - /** - * Validate that SQLException is thrown when there is no Driver to service - * the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test4() throws Exception { - DriverManager.getConnection(InvalidURL); - } - - /** - * Validate that SQLException is thrown when there is no Driver to service - * the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test5() throws Exception { - DriverManager.getConnection(InvalidURL, new Properties()); - } - - /** - * Validate that SQLException is thrown when there is no Driver to service - * the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test6() throws Exception { - DriverManager.getConnection(InvalidURL, "LuckyDog", "tennisanyone"); - } - - /** - * Validate that SQLException is thrown when null is passed for the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test7() throws Exception { - DriverManager.getConnection(null); - } - - /** - * Validate that SQLException is thrown when null is passed for the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test8() throws Exception { - DriverManager.getConnection(null, new Properties()); - } - - /** - * Validate that SQLException is thrown when null is passed for the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test9() throws Exception { - DriverManager.getConnection(null, "LuckyDog", "tennisanyone"); - } - - /** - * Validate that SQLException is thrown when there is no Driver to service - * the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test10() throws Exception { - DriverManager.getDriver(InvalidURL); - } - - /** - * Validate that SQLException is thrown when null is passed for the URL - */ - @Test(expectedExceptions = SQLException.class) - public void test11() throws Exception { - DriverManager.getDriver(null); - } - - /** - * Validate that a non-null Driver is returned by getDriver when a valid URL - * is specified - */ - @Test - public void test12() throws Exception { - - DriverManager.registerDriver(new StubDriver()); - assertTrue(DriverManager.getDriver(StubDriverURL) != null); - } - - /** - * Validate that SQLException is thrown when the URL is not valid for any of - * the registered drivers - */ - @Test(expectedExceptions = SQLException.class) - public void test13() throws Exception { - DriverManager.registerDriver(new StubDriver()); - DriverManager.getDriver(InvalidURL); - } - - /** - * Validate that a Connection object is returned when a valid URL is - * specified to getConnection - * - */ - @Test - public void test14() throws Exception { - - DriverManager.registerDriver(new StubDriver()); - assertTrue( - DriverManager.getConnection(StubDriverURL) != null); - assertTrue(DriverManager.getConnection(StubDriverURL, - "LuckyDog", "tennisanyone") != null); - Properties props = new Properties(); - props.put("user", "LuckyDog"); - props.put("password", "tennisanyone"); - assertTrue( - DriverManager.getConnection(StubDriverURL, - props) != null); - } - - /** - * Register a driver and make sure you find it via its URL. Deregister the - * driver and validate it is not longer registered - * - * @throws Exception - */ - @Test() - public void test15() throws Exception { - DriverManager.registerDriver(new StubDriver()); - Driver d = DriverManager.getDriver(StubDriverURL); - assertTrue(d != null); - assertTrue(isDriverRegistered(d)); - DriverManager.deregisterDriver(d); - assertFalse(isDriverRegistered(d)); - } - - /** - * Validate that DriverAction.release is called when a driver is registered - * via registerDriver(Driver, DriverAction) - * - * @throws Exception - */ - @Test - public void test16() throws Exception { - File file = new File(util.StubDriverDA.DriverActionCalled); - file.delete(); - assertFalse(file.exists()); - Driver d = null; - Class.forName("util.StubDriverDA"); - d = DriverManager.getDriver(StubDriverDAURL); - DriverManager.deregisterDriver(d); - assertFalse(isDriverRegistered(d), "Driver is registered"); - assertTrue(file.exists()); - } - - /** - * Create a PrintStream and use to send output via DriverManager.println - * Validate that if you disable the stream, the output sent is not present - */ - @Test - public void tests17() throws Exception { - ByteArrayOutputStream os = new ByteArrayOutputStream(); - PrintStream ps = new PrintStream(os); - DriverManager.setLogStream(ps); - assertTrue(DriverManager.getLogStream() == ps); - - DriverManager.println(results[0]); - DriverManager.setLogStream((PrintStream) null); - assertTrue(DriverManager.getLogStream() == null); - DriverManager.println(noOutput); - DriverManager.setLogStream(ps); - DriverManager.println(results[1]); - DriverManager.println(results[2]); - DriverManager.println(results[3]); - DriverManager.setLogStream((PrintStream) null); - DriverManager.println(noOutput); - - /* - * Check we do not get the output when the stream is disabled - */ - InputStreamReader is - = new InputStreamReader(new ByteArrayInputStream(os.toByteArray())); - BufferedReader reader = new BufferedReader(is); - for (String result : results) { - assertTrue(result.equals(reader.readLine())); - } - } - - /** - * Create a PrintWriter and use to to send output via DriverManager.println - * Validate that if you disable the writer, the output sent is not present - */ - @Test - public void tests18() throws Exception { - CharArrayWriter cw = new CharArrayWriter(); - PrintWriter pw = new PrintWriter(cw); - DriverManager.setLogWriter(pw); - assertTrue(DriverManager.getLogWriter() == pw); - - DriverManager.println(results[0]); - DriverManager.setLogWriter(null); - assertTrue(DriverManager.getLogWriter() == null); - DriverManager.println(noOutput); - DriverManager.setLogWriter(pw); - DriverManager.println(results[1]); - DriverManager.println(results[2]); - DriverManager.println(results[3]); - DriverManager.setLogWriter(null); - DriverManager.println(noOutput); - - /* - * Check we do not get the output when the stream is disabled - */ - BufferedReader reader - = new BufferedReader(new CharArrayReader(cw.toCharArray())); - for (String result : results) { - assertTrue(result.equals(reader.readLine())); - } - } -} --- old/test/java/sql/test/sql/SQLClientInfoExceptionTests.java 2014-10-28 10:30:15.000000000 -0400 +++ /dev/null 2014-10-28 10:30:15.000000000 -0400 @@ -1,227 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.ClientInfoStatus; -import java.sql.SQLClientInfoException; -import java.sql.SQLException; -import java.util.HashMap; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLClientInfoExceptionTests extends BaseTest { - - private final HashMap map = new HashMap<>(); - - public SQLClientInfoExceptionTests() { - map.put("1", ClientInfoStatus.REASON_UNKNOWN_PROPERTY); - map.put("21", ClientInfoStatus.REASON_UNKNOWN_PROPERTY); - } - - /** - * Create SQLClientInfoException and setting all objects to null - */ - @Test - public void test() { - SQLClientInfoException e = new SQLClientInfoException(null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == 0 - && e.getFailedProperties() == null); - } - - /** - * Create SQLClientInfoException with no-arg constructor - */ - @Test - public void test1() { - SQLClientInfoException ex = new SQLClientInfoException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getFailedProperties() == null); - } - - /** - * Create SQLClientInfoException with null Throwable - */ - @Test - public void test2() { - - SQLClientInfoException ex = new SQLClientInfoException(map, null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getFailedProperties().equals(map)); - } - - /** - * Create SQLClientInfoException with message - */ - @Test - public void test3() { - SQLClientInfoException ex = new SQLClientInfoException(reason, map); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getFailedProperties().equals(map)); - } - - /** - * Create SQLClientInfoException with null Throwable - */ - @Test - public void test4() { - SQLClientInfoException ex = new SQLClientInfoException(reason, map, null); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getFailedProperties().equals(map)); - } - - /** - * Create SQLClientInfoException with message, and SQLState - */ - @Test - public void test5() { - SQLClientInfoException ex = new SQLClientInfoException(reason, state, - map); - - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0 - && ex.getFailedProperties().equals(map)); - } - - /** - * Create SQLClientInfoException with message, and SQLState - */ - @Test - public void test6() { - SQLClientInfoException ex = new SQLClientInfoException(reason, state, - map, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0 - && ex.getFailedProperties().equals(map)); - } - - /** - * Create SQLClientInfoException with message, SQLState, errorCode, and - * Throwable - */ - @Test - public void test7() { - SQLClientInfoException ex = new SQLClientInfoException(reason, state, - errorCode, map); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode - && ex.getFailedProperties().equals(map)); - } - - /** - * Create SQLClientInfoException with message, SQLState, and error code - */ - @Test - public void test8() { - SQLClientInfoException ex = new SQLClientInfoException(reason, state, - errorCode, map, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode - && ex.getFailedProperties().equals(map)); - } - - /** - * Serialize a SQLClientInfoException and make sure you can read it back - * properly - */ - @Test - public void test10() throws Exception { - SQLClientInfoException e = new SQLClientInfoException(reason, state, - errorCode, map, t); - SQLClientInfoException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode - && ex1.getFailedProperties().equals(map)); - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * for-each loop - */ - @Test - public void test11() { - SQLClientInfoException ex = new SQLClientInfoException("Exception 1", - map, t1); - SQLClientInfoException ex1 = new SQLClientInfoException("Exception 2", - map); - SQLClientInfoException ex2 = new SQLClientInfoException("Exception 3", - map, t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * traditional while loop - */ - @Test - public void test12() { - SQLClientInfoException ex = new SQLClientInfoException("Exception 1", - map, t1); - SQLClientInfoException ex1 = new SQLClientInfoException("Exception 2", - map); - SQLClientInfoException ex2 = new SQLClientInfoException("Exception 3", - map, t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } -} --- old/test/java/sql/test/sql/SQLDataExceptionTests.java 2014-10-28 10:30:16.000000000 -0400 +++ /dev/null 2014-10-28 10:30:16.000000000 -0400 @@ -1,215 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLDataException; -import java.sql.SQLException; -import java.sql.SQLNonTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLDataExceptionTests extends BaseTest { - - /** - * Create SQLDataException and setting all objects to null - */ - @Test - public void test() { - SQLDataException e = new SQLDataException(null, null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLDataException with no-arg constructor - */ - @Test - public void test1() { - SQLDataException ex = new SQLDataException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLDataException with message - */ - @Test - public void test2() { - SQLDataException ex = new SQLDataException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLDataException with message, and SQLState - */ - @Test - public void test3() { - SQLDataException ex = new SQLDataException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLDataException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLDataException ex = new SQLDataException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLDataException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLDataException ex = new SQLDataException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLDataException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLDataException ex = new SQLDataException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLDataException with message, and Throwable - */ - @Test - public void test7() { - SQLDataException ex = new SQLDataException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLDataException with null Throwable - */ - @Test - public void test8() { - SQLDataException ex = new SQLDataException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLDataException with Throwable - */ - @Test - public void test9() { - SQLDataException ex = new SQLDataException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLDataException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLDataException e = new SQLDataException(reason, state, errorCode, t); - SQLDataException ex1 = createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLDataException ex = new SQLDataException("Exception 1", t1); - SQLDataException ex1 = new SQLDataException("Exception 2"); - SQLDataException ex2 = new SQLDataException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLDataException ex = new SQLDataException("Exception 1", t1); - SQLDataException ex1 = new SQLDataException("Exception 2"); - SQLDataException ex2 = new SQLDataException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLDataException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLDataException(); - assertTrue(ex instanceof SQLNonTransientException); - } -} --- old/test/java/sql/test/sql/SQLExceptionTests.java 2014-10-28 10:30:17.000000000 -0400 +++ /dev/null 2014-10-28 10:30:17.000000000 -0400 @@ -1,202 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLExceptionTests extends BaseTest { - - /** - * Create SQLException and setting all objects to null - */ - @Test - public void test() { - SQLException e = new SQLException(null, null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLException with no-arg constructor - */ - @Test - public void test1() { - SQLException ex = new SQLException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLException with message - */ - @Test - public void test2() { - SQLException ex = new SQLException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLException with message, and SQLState - */ - @Test - public void test3() { - SQLException ex = new SQLException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLException ex = new SQLException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLException ex = new SQLException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLException ex = new SQLException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLException with message, and Throwable - */ - @Test - public void test7() { - SQLException ex = new SQLException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLException with null Throwable - */ - @Test - public void test8() { - SQLException ex = new SQLException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLException with Throwable - */ - @Test - public void test9() { - SQLException ex = new SQLException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLException e = new SQLException(reason, state, errorCode, t); - SQLException ex1 = createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLException ex = new SQLException("Exception 1", t1); - SQLException ex1 = new SQLException("Exception 2"); - SQLException ex2 = new SQLException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLException ex = new SQLException("Exception 1", t1); - SQLException ex1 = new SQLException("Exception 2"); - SQLException ex2 = new SQLException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - while (ex != null) { - assertTrue(msgs[num++].equals(ex.getMessage())); - Throwable c = ex.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - ex = ex.getNextException(); - } - } -} --- old/test/java/sql/test/sql/SQLFeatureNotSupportedExceptionTests.java 2014-10-28 10:30:18.000000000 -0400 +++ /dev/null 2014-10-28 10:30:18.000000000 -0400 @@ -1,232 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLFeatureNotSupportedException; -import java.sql.SQLNonTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLFeatureNotSupportedExceptionTests extends BaseTest { - - /** - * Create SQLFeatureNotSupportedException and setting all objects to null - */ - @Test - public void test() { - SQLFeatureNotSupportedException e = - new SQLFeatureNotSupportedException(null, null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLFeatureNotSupportedException with no-arg constructor - */ - @Test - public void test1() { - SQLFeatureNotSupportedException ex = new SQLFeatureNotSupportedException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLFeatureNotSupportedException with message - */ - @Test - public void test2() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLFeatureNotSupportedException with message, and SQLState - */ - @Test - public void test3() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLFeatureNotSupportedException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLFeatureNotSupportedException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLFeatureNotSupportedException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLFeatureNotSupportedException with message, and Throwable - */ - @Test - public void test7() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLFeatureNotSupportedException with null Throwable - */ - @Test - public void test8() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException((Throwable) null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLFeatureNotSupportedException with Throwable - */ - @Test - public void test9() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLFeatureNotSupportedException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLFeatureNotSupportedException e = - new SQLFeatureNotSupportedException(reason, state, errorCode, t); - SQLFeatureNotSupportedException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException("Exception 1", t1); - SQLFeatureNotSupportedException ex1 = - new SQLFeatureNotSupportedException("Exception 2"); - SQLFeatureNotSupportedException ex2 = - new SQLFeatureNotSupportedException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLFeatureNotSupportedException ex = - new SQLFeatureNotSupportedException("Exception 1", t1); - SQLFeatureNotSupportedException ex1 = - new SQLFeatureNotSupportedException("Exception 2"); - SQLFeatureNotSupportedException ex2 = - new SQLFeatureNotSupportedException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLFeatureNotSupportedException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLFeatureNotSupportedException(); - assertTrue(ex instanceof SQLNonTransientException); - } -} --- old/test/java/sql/test/sql/SQLIntegrityConstraintViolationExceptionTests.java 2014-10-28 10:30:18.000000000 -0400 +++ /dev/null 2014-10-28 10:30:18.000000000 -0400 @@ -1,235 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLIntegrityConstraintViolationException; -import java.sql.SQLNonTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLIntegrityConstraintViolationExceptionTests extends BaseTest { - - /** - * Create SQLIntegrityConstraintViolationException and setting all objects to null - */ - @Test - public void test() { - SQLIntegrityConstraintViolationException e = - new SQLIntegrityConstraintViolationException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLIntegrityConstraintViolationException with no-arg constructor - */ - @Test - public void test1() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLIntegrityConstraintViolationException with message - */ - @Test - public void test2() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLIntegrityConstraintViolationException with message, and SQLState - */ - @Test - public void test3() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLIntegrityConstraintViolationException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLIntegrityConstraintViolationException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLIntegrityConstraintViolationException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLIntegrityConstraintViolationException with message, and Throwable - */ - @Test - public void test7() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLIntegrityConstraintViolationException with null Throwable - */ - @Test - public void test8() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLIntegrityConstraintViolationException with Throwable - */ - @Test - public void test9() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLIntegrityConstraintViolationException and make sure - * you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLIntegrityConstraintViolationException e = - new SQLIntegrityConstraintViolationException(reason, state, errorCode, t); - SQLIntegrityConstraintViolationException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException("Exception 1", t1); - SQLIntegrityConstraintViolationException ex1 = - new SQLIntegrityConstraintViolationException("Exception 2"); - SQLIntegrityConstraintViolationException ex2 = - new SQLIntegrityConstraintViolationException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLIntegrityConstraintViolationException ex = - new SQLIntegrityConstraintViolationException("Exception 1", t1); - SQLIntegrityConstraintViolationException ex1 = - new SQLIntegrityConstraintViolationException("Exception 2"); - SQLIntegrityConstraintViolationException ex2 = - new SQLIntegrityConstraintViolationException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLIntegrityConstraintViolationException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLIntegrityConstraintViolationException(); - assertTrue(ex instanceof SQLNonTransientException); - } -} --- old/test/java/sql/test/sql/SQLInvalidAuthorizationSpecExceptionTests.java 2014-10-28 10:30:19.000000000 -0400 +++ /dev/null 2014-10-28 10:30:19.000000000 -0400 @@ -1,239 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLInvalidAuthorizationSpecException; -import java.sql.SQLNonTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLInvalidAuthorizationSpecExceptionTests extends BaseTest { - - /** - * Create SQLInvalidAuthorizationSpecException and setting all objects to - * null - */ - @Test - public void test() { - SQLInvalidAuthorizationSpecException e - = new SQLInvalidAuthorizationSpecException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLInvalidAuthorizationSpecException with no-arg constructor - */ - @Test - public void test1() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLInvalidAuthorizationSpecException with message - */ - @Test - public void test2() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLInvalidAuthorizationSpecException with message, and SQLState - */ - @Test - public void test3() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLInvalidAuthorizationSpecException with message, SQLState, and - * error code - */ - @Test - public void test4() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLInvalidAuthorizationSpecException with message, SQLState, - * errorCode, and Throwable - */ - @Test - public void test5() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLInvalidAuthorizationSpecException with message, SQLState, and - * Throwable - */ - @Test - public void test6() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLInvalidAuthorizationSpecException with message, and Throwable - */ - @Test - public void test7() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLInvalidAuthorizationSpecException with null Throwable - */ - @Test - public void test8() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException((Throwable) null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLInvalidAuthorizationSpecException with Throwable - */ - @Test - public void test9() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLInvalidAuthorizationSpecException and make sure you can - * read it back properly - */ - @Test - public void test10() throws Exception { - SQLInvalidAuthorizationSpecException e - = new SQLInvalidAuthorizationSpecException(reason, state, errorCode, t); - SQLInvalidAuthorizationSpecException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * for-each loop - */ - @Test - public void test11() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException("Exception 1", t1); - SQLInvalidAuthorizationSpecException ex1 - = new SQLInvalidAuthorizationSpecException("Exception 2"); - SQLInvalidAuthorizationSpecException ex2 - = new SQLInvalidAuthorizationSpecException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * traditional while loop - */ - @Test - public void test12() { - SQLInvalidAuthorizationSpecException ex - = new SQLInvalidAuthorizationSpecException("Exception 1", t1); - SQLInvalidAuthorizationSpecException ex1 - = new SQLInvalidAuthorizationSpecException("Exception 2"); - SQLInvalidAuthorizationSpecException ex2 - = new SQLInvalidAuthorizationSpecException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLInvalidAuthorizationSpecException and validate it is an - * instance of SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLInvalidAuthorizationSpecException(); - assertTrue(ex instanceof SQLNonTransientException); - } -} --- old/test/java/sql/test/sql/SQLNonTransientConnectionExceptionTests.java 2014-10-28 10:30:20.000000000 -0400 +++ /dev/null 2014-10-28 10:30:20.000000000 -0400 @@ -1,235 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLNonTransientConnectionException; -import java.sql.SQLNonTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLNonTransientConnectionExceptionTests extends BaseTest { - - /** - * Create SQLNonTransientConnectionException and setting all objects to null - */ - @Test - public void test() { - SQLNonTransientConnectionException e = - new SQLNonTransientConnectionException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLNonTransientConnectionException with no-arg constructor - */ - @Test - public void test1() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientConnectionException with message - */ - @Test - public void test2() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientConnectionException with message, and SQLState - */ - @Test - public void test3() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientConnectionException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLNonTransientConnectionException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLNonTransientConnectionException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientConnectionException with message, and Throwable - */ - @Test - public void test7() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientConnectionException with null Throwable - */ - @Test - public void test8() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientConnectionException with Throwable - */ - @Test - public void test9() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLNonTransientConnectionException and make sure you can - * read it back properly - */ - @Test - public void test10() throws Exception { - SQLNonTransientConnectionException e = - new SQLNonTransientConnectionException(reason, state, errorCode, t); - SQLNonTransientConnectionException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException("Exception 1", t1); - SQLNonTransientConnectionException ex1 = - new SQLNonTransientConnectionException("Exception 2"); - SQLNonTransientConnectionException ex2 = - new SQLNonTransientConnectionException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLNonTransientConnectionException ex = - new SQLNonTransientConnectionException("Exception 1", t1); - SQLNonTransientConnectionException ex1 = - new SQLNonTransientConnectionException("Exception 2"); - SQLNonTransientConnectionException ex2 = - new SQLNonTransientConnectionException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLNonTransientConnectionException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLNonTransientConnectionException(); - assertTrue(ex instanceof SQLNonTransientException); - } -} --- old/test/java/sql/test/sql/SQLNonTransientExceptionTests.java 2014-10-28 10:30:20.000000000 -0400 +++ /dev/null 2014-10-28 10:30:20.000000000 -0400 @@ -1,209 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLNonTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLNonTransientExceptionTests extends BaseTest { - - /** - * Create SQLNonTransientException and setting all objects to null - */ - @Test - public void test() { - SQLNonTransientException e = new SQLNonTransientException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLNonTransientException with no-arg constructor - */ - @Test - public void test1() { - SQLNonTransientException ex = new SQLNonTransientException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientException with message - */ - @Test - public void test2() { - SQLNonTransientException ex = new SQLNonTransientException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientException with message, and SQLState - */ - @Test - public void test3() { - SQLNonTransientException ex = new SQLNonTransientException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientException with message, SQLState, and error code - */ - @Test - public void test4() {; - SQLNonTransientException ex = - new SQLNonTransientException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLNonTransientException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLNonTransientException ex = - new SQLNonTransientException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLNonTransientException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLNonTransientException ex = new SQLNonTransientException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientException with message, and Throwable - */ - @Test - public void test7() { - SQLNonTransientException ex = new SQLNonTransientException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientException with null Throwable - */ - @Test - public void test8() { - SQLNonTransientException ex = new SQLNonTransientException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLNonTransientException with Throwable - */ - @Test - public void test9() { - SQLNonTransientException ex = new SQLNonTransientException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLNonTransientException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLNonTransientException e = - new SQLNonTransientException(reason, state, errorCode, t); - SQLNonTransientException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLNonTransientException ex = new SQLNonTransientException("Exception 1", t1); - SQLNonTransientException ex1 = new SQLNonTransientException("Exception 2"); - SQLNonTransientException ex2 = new SQLNonTransientException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLNonTransientException ex = new SQLNonTransientException("Exception 1", t1); - SQLNonTransientException ex1 = new SQLNonTransientException("Exception 2"); - SQLNonTransientException ex2 = new SQLNonTransientException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } -} --- old/test/java/sql/test/sql/SQLRecoverableExceptionTests.java 2014-10-28 10:30:21.000000000 -0400 +++ /dev/null 2014-10-28 10:30:21.000000000 -0400 @@ -1,209 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLRecoverableException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLRecoverableExceptionTests extends BaseTest { - - /** - * Create SQLRecoverableException and setting all objects to null - */ - @Test - public void test() { - SQLRecoverableException e = new SQLRecoverableException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLRecoverableException with no-arg constructor - */ - @Test - public void test1() { - SQLRecoverableException ex = new SQLRecoverableException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLRecoverableException with message - */ - @Test - public void test2() { - SQLRecoverableException ex = new SQLRecoverableException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLRecoverableException with message, and SQLState - */ - @Test - public void test3() { - SQLRecoverableException ex = new SQLRecoverableException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLRecoverableException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLRecoverableException ex = - new SQLRecoverableException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLRecoverableException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLRecoverableException ex = - new SQLRecoverableException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLRecoverableException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLRecoverableException ex = new SQLRecoverableException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLRecoverableException with message, and Throwable - */ - @Test - public void test7() { - SQLRecoverableException ex = new SQLRecoverableException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLRecoverableException with null Throwable - */ - @Test - public void test8() { - SQLRecoverableException ex = new SQLRecoverableException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLRecoverableException with Throwable - */ - @Test - public void test9() { - SQLRecoverableException ex = new SQLRecoverableException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLRecoverableException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLRecoverableException e = - new SQLRecoverableException(reason, state, errorCode, t); - SQLRecoverableException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLRecoverableException ex = new SQLRecoverableException("Exception 1", t1); - SQLRecoverableException ex1 = new SQLRecoverableException("Exception 2"); - SQLRecoverableException ex2 = new SQLRecoverableException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLRecoverableException ex = new SQLRecoverableException("Exception 1", t1); - SQLRecoverableException ex1 = new SQLRecoverableException("Exception 2"); - SQLRecoverableException ex2 = new SQLRecoverableException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } -} --- old/test/java/sql/test/sql/SQLSyntaxErrorExceptionTests.java 2014-10-28 10:30:22.000000000 -0400 +++ /dev/null 2014-10-28 10:30:22.000000000 -0400 @@ -1,221 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLNonTransientException; -import java.sql.SQLSyntaxErrorException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLSyntaxErrorExceptionTests extends BaseTest { - - /** - * Create SQLSyntaxErrorException and setting all objects to null - */ - @Test - public void test() { - SQLSyntaxErrorException e = new SQLSyntaxErrorException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLSyntaxErrorException with no-arg constructor - */ - @Test - public void test1() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLSyntaxErrorException with message - */ - @Test - public void test2() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLSyntaxErrorException with message, and SQLState - */ - @Test - public void test3() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLSyntaxErrorException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLSyntaxErrorException ex = - new SQLSyntaxErrorException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLSyntaxErrorException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLSyntaxErrorException ex = - new SQLSyntaxErrorException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLSyntaxErrorException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLSyntaxErrorException with message, and Throwable - */ - @Test - public void test7() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLSyntaxErrorException with null Throwable - */ - @Test - public void test8() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLSyntaxErrorException with Throwable - */ - @Test - public void test9() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLSyntaxErrorException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - - SQLSyntaxErrorException e = - new SQLSyntaxErrorException(reason, state, errorCode, t); - SQLSyntaxErrorException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1); - SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2"); - SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLSyntaxErrorException ex = new SQLSyntaxErrorException("Exception 1", t1); - SQLSyntaxErrorException ex1 = new SQLSyntaxErrorException("Exception 2"); - SQLSyntaxErrorException ex2 = new SQLSyntaxErrorException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLSyntaxErrorException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLSyntaxErrorException(); - assertTrue(ex instanceof SQLNonTransientException); - } -} --- old/test/java/sql/test/sql/SQLTimeoutExceptionTests.java 2014-10-28 10:30:22.000000000 -0400 +++ /dev/null 2014-10-28 10:30:22.000000000 -0400 @@ -1,218 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLTimeoutException; -import java.sql.SQLTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLTimeoutExceptionTests extends BaseTest { - - /** - * Create SQLTimeoutException and setting all objects to null - */ - @Test - public void test() { - SQLTimeoutException e = new SQLTimeoutException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLTimeoutException with no-arg constructor - */ - @Test - public void test1() { - SQLTimeoutException ex = new SQLTimeoutException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTimeoutException with message - */ - @Test - public void test2() { - SQLTimeoutException ex = new SQLTimeoutException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTimeoutException with message, and SQLState - */ - @Test - public void test3() { - SQLTimeoutException ex = new SQLTimeoutException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTimeoutException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLTimeoutException ex = new SQLTimeoutException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTimeoutException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLTimeoutException ex = new SQLTimeoutException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTimeoutException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLTimeoutException ex = new SQLTimeoutException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTimeoutException with message, and Throwable - */ - @Test - public void test7() { - SQLTimeoutException ex = new SQLTimeoutException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTimeoutException with null Throwable - */ - @Test - public void test8() { - SQLTimeoutException ex = new SQLTimeoutException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTimeoutException with Throwable - */ - @Test - public void test9() { - SQLTimeoutException ex = new SQLTimeoutException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLTimeoutException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLTimeoutException e = - new SQLTimeoutException(reason, state, errorCode, t); - SQLTimeoutException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLTimeoutException ex = new SQLTimeoutException("Exception 1", t1); - SQLTimeoutException ex1 = new SQLTimeoutException("Exception 2"); - SQLTimeoutException ex2 = new SQLTimeoutException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLTimeoutException ex = new SQLTimeoutException("Exception 1", t1); - SQLTimeoutException ex1 = new SQLTimeoutException("Exception 2"); - SQLTimeoutException ex2 = new SQLTimeoutException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLTimeoutException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLTimeoutException(); - assertTrue(ex instanceof SQLTransientException); - } -} --- old/test/java/sql/test/sql/SQLTransactionRollbackExceptionTests.java 2014-10-28 10:30:23.000000000 -0400 +++ /dev/null 2014-10-28 10:30:23.000000000 -0400 @@ -1,233 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLTransactionRollbackException; -import java.sql.SQLTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLTransactionRollbackExceptionTests extends BaseTest { - - /** - * Create SQLTransactionRollbackException and setting all objects to null - */ - @Test - public void test() { - SQLTransactionRollbackException e = - new SQLTransactionRollbackException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLTransactionRollbackException with no-arg constructor - */ - @Test - public void test1() { - SQLTransactionRollbackException ex = new SQLTransactionRollbackException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransactionRollbackException with message - */ - @Test - public void test2() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransactionRollbackException with message, and SQLState - */ - @Test - public void test3() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransactionRollbackException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTransactionRollbackException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTransactionRollbackException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransactionRollbackException with message, and Throwable - */ - @Test - public void test7() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransactionRollbackException with null Throwable - */ - @Test - public void test8() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransactionRollbackException with Throwable - */ - @Test - public void test9() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLTransactionRollbackException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLTransactionRollbackException e = - new SQLTransactionRollbackException(reason, state, errorCode, t); - SQLTransactionRollbackException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException("Exception 1", t1); - SQLTransactionRollbackException ex1 = - new SQLTransactionRollbackException("Exception 2"); - SQLTransactionRollbackException ex2 = - new SQLTransactionRollbackException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLTransactionRollbackException ex = - new SQLTransactionRollbackException("Exception 1", t1); - SQLTransactionRollbackException ex1 = - new SQLTransactionRollbackException("Exception 2"); - SQLTransactionRollbackException ex2 = - new SQLTransactionRollbackException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLTransactionRollbackException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLTransactionRollbackException(); - assertTrue(ex instanceof SQLTransientException); - } -} --- old/test/java/sql/test/sql/SQLTransientConnectionExceptionTests.java 2014-10-28 10:30:23.000000000 -0400 +++ /dev/null 2014-10-28 10:30:23.000000000 -0400 @@ -1,233 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLTransientConnectionException; -import java.sql.SQLTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLTransientConnectionExceptionTests extends BaseTest { - - /** - * Create SQLTransientConnectionException and setting all objects to null - */ - @Test - public void test() { - SQLTransientConnectionException e = - new SQLTransientConnectionException( null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLTransientConnectionException with no-arg constructor - */ - @Test - public void test1() { - SQLTransientConnectionException ex = new SQLTransientConnectionException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientConnectionException with message - */ - @Test - public void test2() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientConnectionException with message, and SQLState - */ - @Test - public void test3() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientConnectionException with message, SQLState, and error code - */ - @Test - public void test4() {; - SQLTransientConnectionException ex = - new SQLTransientConnectionException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTransientConnectionException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTransientConnectionException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientConnectionException with message, and Throwable - */ - @Test - public void test7() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientConnectionException with null Throwable - */ - @Test - public void test8() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientConnectionException with Throwable - */ - @Test - public void test9() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLTransientConnectionException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLTransientConnectionException e = - new SQLTransientConnectionException(reason, state, errorCode, t); - SQLTransientConnectionException ex1 = - createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException("Exception 1", t1); - SQLTransientConnectionException ex1 = - new SQLTransientConnectionException("Exception 2"); - SQLTransientConnectionException ex2 = - new SQLTransientConnectionException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLTransientConnectionException ex = - new SQLTransientConnectionException("Exception 1", t1); - SQLTransientConnectionException ex1 = - new SQLTransientConnectionException("Exception 2"); - SQLTransientConnectionException ex2 = - new SQLTransientConnectionException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Create SQLTransientConnectionException and validate it is an instance of - * SQLNonTransientException - */ - @Test - public void test13() { - Exception ex = new SQLTransientConnectionException(); - assertTrue(ex instanceof SQLTransientException); - } -} --- old/test/java/sql/test/sql/SQLTransientExceptionTests.java 2014-10-28 10:30:24.000000000 -0400 +++ /dev/null 2014-10-28 10:30:24.000000000 -0400 @@ -1,207 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLTransientException; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLTransientExceptionTests extends BaseTest { - - /** - * Create SQLTransientException and setting all objects to null - */ - @Test - public void test() { - SQLTransientException e = new SQLTransientException(null, - null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLTransientException with no-arg constructor - */ - @Test - public void test1() { - SQLTransientException ex = new SQLTransientException(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientException with message - */ - @Test - public void test2() { - SQLTransientException ex = new SQLTransientException(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientException with message, and SQLState - */ - @Test - public void test3() { - SQLTransientException ex = new SQLTransientException(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientException with message, SQLState, and error code - */ - @Test - public void test4() { - SQLTransientException ex = new SQLTransientException(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTransientException with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLTransientException ex = - new SQLTransientException(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLTransientException with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLTransientException ex = new SQLTransientException(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientException with message, and Throwable - */ - @Test - public void test7() { - SQLTransientException ex = new SQLTransientException(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientException with null Throwable - */ - @Test - public void test8() { - SQLTransientException ex = new SQLTransientException((Throwable)null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLTransientException with Throwable - */ - @Test - public void test9() { - SQLTransientException ex = new SQLTransientException(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLTransientException and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLTransientException e = - new SQLTransientException(reason, state, errorCode, t); - SQLTransientException ex1 = createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using for-each loop - */ - @Test - public void test11() { - SQLTransientException ex = new SQLTransientException("Exception 1", t1); - SQLTransientException ex1 = new SQLTransientException("Exception 2"); - SQLTransientException ex2 = new SQLTransientException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct - * using traditional while loop - */ - @Test - public void test12() { - SQLTransientException ex = new SQLTransientException("Exception 1", t1); - SQLTransientException ex1 = new SQLTransientException("Exception 2"); - SQLTransientException ex2 = new SQLTransientException("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } -} --- old/test/java/sql/test/sql/SQLWarningTests.java 2014-10-28 10:30:25.000000000 -0400 +++ /dev/null 2014-10-28 10:30:25.000000000 -0400 @@ -1,249 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.SQLException; -import java.sql.SQLWarning; -import static org.testng.Assert.*; -import org.testng.annotations.Test; -import util.BaseTest; - -public class SQLWarningTests extends BaseTest { - - private final String[] warnings = {"Warning 1", "cause 1", "Warning 2", - "Warning 3", "cause 2"}; - - /** - * Create SQLWarning and setting all objects to null - */ - @Test - public void test() { - SQLWarning e = new SQLWarning(null, null, errorCode, null); - assertTrue(e.getMessage() == null && e.getSQLState() == null - && e.getCause() == null && e.getErrorCode() == errorCode); - } - - /** - * Create SQLWarning with no-arg constructor - */ - @Test - public void test1() { - SQLWarning ex = new SQLWarning(); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLWarning with message - */ - @Test - public void test2() { - SQLWarning ex = new SQLWarning(reason); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLWarning with message, and SQLState - */ - @Test - public void test3() { - - SQLWarning ex = new SQLWarning(reason, state); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLWarning with message, SQLState, and error code - */ - @Test - public void test4() { - SQLWarning ex = new SQLWarning(reason, state, errorCode); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && ex.getCause() == null - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLWarning with message, SQLState, errorCode, and Throwable - */ - @Test - public void test5() { - SQLWarning ex = new SQLWarning(reason, state, errorCode, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == errorCode); - } - - /** - * Create SQLWarning with message, SQLState, and Throwable - */ - @Test - public void test6() { - SQLWarning ex = new SQLWarning(reason, state, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState().equals(state) - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLWarning with message, and Throwable - */ - @Test - public void test7() { - SQLWarning ex = new SQLWarning(reason, t); - assertTrue(ex.getMessage().equals(reason) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Create SQLWarning with null Throwable - */ - @Test - public void test8() { - SQLWarning ex = new SQLWarning((Throwable) null); - assertTrue(ex.getMessage() == null - && ex.getSQLState() == null - && ex.getCause() == null - && ex.getErrorCode() == 0); - } - - /** - * Create SQLWarning with Throwable - */ - @Test - public void test9() { - SQLWarning ex = new SQLWarning(t); - assertTrue(ex.getMessage().equals(cause) - && ex.getSQLState() == null - && cause.equals(ex.getCause().toString()) - && ex.getErrorCode() == 0); - } - - /** - * Serialize a SQLWarning and make sure you can read it back properly - */ - @Test - public void test10() throws Exception { - SQLWarning e = new SQLWarning(reason, state, errorCode, t); - SQLWarning ex1 = createSerializedException(e); - assertTrue(reason.equals(ex1.getMessage()) - && ex1.getSQLState().equals(state) - && cause.equals(ex1.getCause().toString()) - && ex1.getErrorCode() == errorCode); - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * for-each loop - */ - @Test - public void test11() { - SQLWarning ex = new SQLWarning("Exception 1", t1); - SQLWarning ex1 = new SQLWarning("Exception 2"); - SQLWarning ex2 = new SQLWarning("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(msgs[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned Exceptions is correct using - * traditional while loop - */ - @Test - public void test12() { - SQLWarning ex = new SQLWarning("Exception 1", t1); - SQLWarning ex1 = new SQLWarning("Exception 2"); - SQLWarning ex2 = new SQLWarning("Exception 3", t2); - ex.setNextException(ex1); - ex.setNextException(ex2); - int num = 0; - SQLException sqe = ex; - while (sqe != null) { - assertTrue(msgs[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextException(); - } - } - - /** - * Validate that the ordering of the returned SQLWarning is correct using - * for-each loop - */ - @Test - public void test13() { - SQLWarning ex = new SQLWarning("Warning 1", t1); - SQLWarning ex1 = new SQLWarning("Warning 2"); - SQLWarning ex2 = new SQLWarning("Warning 3", t2); - ex.setNextWarning(ex1); - ex.setNextWarning(ex2); - int num = 0; - for (Throwable e : ex) { - assertTrue(warnings[num++].equals(e.getMessage())); - } - } - - /** - * Validate that the ordering of the returned SQLWarning is correct using - * traditional while loop - */ - @Test - public void test14() { - SQLWarning ex = new SQLWarning("Warning 1", t1); - SQLWarning ex1 = new SQLWarning("Warning 2"); - SQLWarning ex2 = new SQLWarning("Warning 3", t2); - ex.setNextWarning(ex1); - ex.setNextWarning(ex2); - int num = 0; - SQLWarning sqe = ex; - while (sqe != null) { - assertTrue(warnings[num++].equals(sqe.getMessage())); - Throwable c = sqe.getCause(); - while (c != null) { - assertTrue(msgs[num++].equals(c.getMessage())); - c = c.getCause(); - } - sqe = sqe.getNextWarning(); - } - } -} --- old/test/java/sql/test/sql/TimeTests.java 2014-10-28 10:30:26.000000000 -0400 +++ /dev/null 2014-10-28 10:30:26.000000000 -0400 @@ -1,348 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.Time; -import java.time.LocalTime; -import static org.testng.Assert.*; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import util.BaseTest; - -public class TimeTests extends BaseTest { - - /* - * Validate an IllegalArgumentException is thrown for calling getYear - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test01() { - Time t = Time.valueOf("08:30:59"); - t.getYear(); - } - - /* - * Validate an IllegalArgumentException is thrown for calling getMonth - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test02() { - Time t = Time.valueOf("08:30:59"); - t.getMonth(); - } - - /* - * Validate an IllegalArgumentException is thrown for calling getDay - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test03() { - Time t = Time.valueOf("08:30:59"); - t.getDay(); - } - - /** - * Validate an IllegalArgumentException is thrown for calling getDate - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test04() { - Time t = Time.valueOf("08:30:59"); - t.getDate(); - } - - /* - * Validate an IllegalArgumentException is thrown for calling setYear - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test05() { - Time t = Time.valueOf("08:30:59"); - t.setYear(8); - } - - /* - * Validate an IllegalArgumentException is thrown for calling setMonth - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test06() { - Time t = Time.valueOf("08:30:59"); - t.setMonth(8); - } - - /* - * Validate an IllegalArgumentException is thrown for calling setDate - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test07() { - Time t = Time.valueOf("08:30:59"); - t.setDate(30); - } - - /* - * Validate an IllegalArgumentException is thrown for calling getDate - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test08() { - Time t = Time.valueOf("08:30:59"); - t.getDate(); - } - - /* - * Validate that a Time made from a toLocalTime() LocalTime are equal - */ - @Test - public void test09() { - Time t = Time.valueOf("08:30:59"); - Time t2 = Time.valueOf(t.toLocalTime()); - assertTrue(t.equals(t2), "Error t != t2"); - } - - /* - * Validate that a Time LocalTime value, made from a LocalTime are equal - */ - @Test - public void test10() { - LocalTime lt = LocalTime.of(8, 30, 59); - Time t = Time.valueOf(lt); - System.out.println("lt=" + lt + ",t=" + t.toLocalTime()); - assertTrue(lt.equals(t.toLocalTime()), - "Error LocalTime values are not equal"); - } - - /* - * Validate an NPE occurs when a null LocalDate is passed to valueOf - */ - @Test(expectedExceptions = NullPointerException.class) - public void test11() throws Exception { - LocalTime ld = null; - Time.valueOf(ld); - } - - /* - * Validate an UnsupportedOperationException occurs when toInstant() is - * called - */ - @Test(expectedExceptions = UnsupportedOperationException.class) - public void test12() throws Exception { - Time t = new Time(System.currentTimeMillis()); - t.toInstant(); - } - - /* - * Validate that two Time objects are equal when one is created from the - * toString() of the other and that the correct value is returned from - * toString() - */ - @Test(dataProvider = "validTimeValues") - public void test13(String time, String expected) { - Time t1 = Time.valueOf(time); - Time t2 = Time.valueOf(t1.toString()); - assertTrue(t1.equals(t2) && t2.equals(t1) - && t1.toString().equals(expected), "Error t1 != t2"); - } - - /* - * Validate that two Time values one created using valueOf and another via a - * constructor are equal - */ - @Test - public void test14() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(8, 30, 59); - assertTrue(t.equals(t2) && t2.equals(t), "Error t != t2"); - } - - /* - * Validate that two Time values one created using valueOf and another via a - * constructor are equal - */ - @Test - public void test15() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(t.getTime()); - assertTrue(t.equals(t2) && t2.equals(t), "Error t != t2"); - } - - /* - * Validate an IllegalArgumentException is thrown for an invalid Time string - */ - @Test(dataProvider = "invalidTimeValues", - expectedExceptions = IllegalArgumentException.class) - public void test16(String time) throws Exception { - Time.valueOf(time); - } - - /* - * Validate that Time.after() returns false when same date is compared - */ - @Test - public void test17() { - Time t = Time.valueOf("08:30:59"); - assertFalse(t.after(t), "Error t.after(t) = true"); - } - - /* - * Validate that Time.after() returns true when later date is compared to - * earlier date - */ - @Test - public void test18() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(System.currentTimeMillis()); - assertTrue(t2.after(t), "Error t2.after(t) = false"); - } - - /* - * Validate that Time.after() returns false when earlier date is compared to - * itself - */ - @Test - public void test19() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(t.getTime()); - assertFalse(t.after(t2), "Error t.after(t2) = true"); - assertFalse(t2.after(t), "Error t2.after(t) = true"); - } - - /* - * Validate that Time.before() returns false when same date is compared - */ - @Test - public void test20() { - Time t = Time.valueOf("08:30:59"); - assertFalse(t.before(t), "Error t.before(t) = true"); - } - - /* - * Validate that Time.before() returns true when earlier date is compared to - * later date - */ - @Test - public void test21() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(System.currentTimeMillis()); - assertTrue(t.before(t2), "Error t.before(t2) = false"); - } - - /* - * Validate that Time.before() returns false when earlier date is compared - * to itself - */ - @Test - public void test22() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(t.getTime()); - assertFalse(t.before(t2), "Error t.after(t2) = true"); - assertFalse(t2.before(t), "Error t2.after(t) = true"); - } - - /* - * Validate that Time.compareTo returns 0 when both Date objects are the - * same - */ - @Test - public void test23() { - Time t = Time.valueOf("08:30:59"); - assertTrue(t.compareTo(t) == 0, "Error t.compareTo(t) !=0"); - } - - /* - * Validate thatTime.compareTo returns 0 when both Time objects are the same - */ - @Test - public void test24() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(t.getTime()); - assertTrue(t.compareTo(t2) == 0, "Error t.compareTo(t2) !=0"); - } - - /* - * Validate that Time.compareTo returns 1 when comparing a later Time to an - * earlier Time - */ - @Test - public void test25() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(t.getTime() + 1); - assertTrue(t2.compareTo(t) == 1, "Error t2.compareTo(t) !=1"); - } - - /* - * Validate thatTime.compareTo returns 1 when comparing a later Time to an - * earlier Time - */ - @Test - public void test26() { - Time t = Time.valueOf("08:30:59"); - Time t2 = new Time(t.getTime() + 1); - assertTrue(t.compareTo(t2) == -1, "Error t.compareTo(t2) != -1"); - } - - /* - * DataProvider used to provide Time values which are not valid and are used - * to validate that an IllegalArgumentException will be thrown from the - * valueOf method - */ - @DataProvider(name = "invalidTimeValues") - private Object[][] invalidTimeValues() { - return new Object[][]{ - {"2009-11-01 10:50:01"}, - {"1961-08-30 10:50:01.1"}, - {"1961-08-30"}, - {"00:00:00."}, - {"10:50:0.1"}, - {":00:00"}, - {"00::00"}, - {"00:00:"}, - {"::"}, - {" : : "}, - {"0a:00:00"}, - {"00:bb:00"}, - {"00:01:cc"}, - {"08:10:Batman"}, - {"08:10:10:10"}, - {"08:10"}, - {"a:b:c"}, - {null}, - {"8:"} - }; - } - - /* - * DataProvider used to provide Time values which are valid and are used - * to validate that an IllegalArgumentException will not be thrown from the - * valueOf method. It also contains the expected return value from - * toString() - */ - @DataProvider(name = "validTimeValues") - private Object[][] validTimeValues() { - return new Object[][]{ - {"10:50:01", "10:50:01"}, - {"01:1:1", "01:01:01"}, - {"01:01:1", "01:01:01"}, - {"1:01:1", "01:01:01"}, - {"2:02:02", "02:02:02"}, - {"2:02:2", "02:02:02"}, - {"10:50:1", "10:50:01"}, - {"00:00:00", "00:00:00"}, - {"08:30:59", "08:30:59"}, - {"9:0:1", "09:00:01"} - }; - } -} --- old/test/java/sql/test/sql/TimestampTests.java 2014-10-28 10:30:26.000000000 -0400 +++ /dev/null 2014-10-28 10:30:26.000000000 -0400 @@ -1,777 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package test.sql; - -import java.sql.Date; -import java.sql.Time; -import java.sql.Timestamp; -import java.time.Instant; -import java.time.LocalDateTime; -import java.time.ZoneId; -import java.util.Calendar; -import java.util.TimeZone; -import static org.testng.Assert.*; -import org.testng.annotations.AfterClass; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.DataProvider; -import org.testng.annotations.Test; -import util.BaseTest; - -public class TimestampTests extends BaseTest { - - private static TimeZone defaultTimeZone = null; - - /* - * Need to set and use a custom TimeZone which does not - * observe daylight savings time for this test. - */ - @BeforeClass - public static void setUpClass() throws Exception { - defaultTimeZone = TimeZone.getDefault(); - TimeZone tzone = TimeZone.getTimeZone("GMT+01"); - assertFalse(tzone.observesDaylightTime()); - TimeZone.setDefault(tzone); - } - - /* - * Conservatively reset the default time zone after test. - */ - @AfterClass - public static void tearDownClass() throws Exception { - TimeZone.setDefault(defaultTimeZone); - } - - /* - * Validate an IllegalArgumentException is thrown for an invalid Timestamp - */ - @Test(dataProvider = "invalidTimestampValues", - expectedExceptions = IllegalArgumentException.class) - public void test(String ts) throws Exception { - Timestamp.valueOf(ts); - } - - /* - * Validate that two Timestamp are equal when the leading 0 in seconds is - * omitted - */ - @Test - public void test01() throws Exception { - String testTS = "2009-01-01 10:50:00"; - String ExpectedTS = "2009-01-01 10:50:0"; - Timestamp ts = Timestamp.valueOf(testTS); - Timestamp ts2 = Timestamp.valueOf(ExpectedTS); - assertEquals(ts, ts2, "Error ts1 != ts2"); - } - - /* - * Validate two Timestamps created from the same string are equal - */ - @Test - public void test02() throws Exception { - String testTS = "2009-01-01 10:50:0"; - Timestamp ts = Timestamp.valueOf(testTS); - Timestamp ts2 = Timestamp.valueOf(testTS); - assertEquals(ts, ts2, "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one with leading 0s for month and day - * equals same string without the leading 0s. - */ - @Test - public void test03() throws Exception { - String testTS = "2009-1-1 10:50:0"; - String ExpectedTS = "2009-01-01 10:50:0"; - Timestamp ts = Timestamp.valueOf(testTS); - Timestamp ts2 = Timestamp.valueOf(ExpectedTS); - assertEquals(ts, ts2, "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one with leading 0s for day omitted - * are equal - */ - @Test - public void test04() throws Exception { - String testTS = "2009-01-1 10:50:0"; - String ExpectedTS = "2009-01-01 10:50:0"; - Timestamp ts = Timestamp.valueOf(testTS); - Timestamp ts2 = Timestamp.valueOf(ExpectedTS); - assertEquals(ts, ts2, "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one with leading 0s for month omitted - * and both with leading 0s for seconds omitted are equal - */ - @Test - public void test05() throws Exception { - String testTS = "2009-1-01 10:50:0"; - String ExpectedTS = "2009-01-01 10:50:0"; - Timestamp ts = Timestamp.valueOf(testTS); - Timestamp ts2 = Timestamp.valueOf(ExpectedTS); - assertEquals(ts, ts2, "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one with leading 0s for month omitted - */ - @Test - public void test06() throws Exception { - String testTS = "2005-1-01 10:20:50.00"; - String ExpectedTS = "2005-01-01 10:20:50.00"; - Timestamp ts = Timestamp.valueOf(testTS); - Timestamp ts2 = Timestamp.valueOf(ExpectedTS); - assertEquals(ts, ts2, "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one created using valueOf and another - * via a constructor are equal - */ - @Test - public void test07() { - - Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.001"); - Timestamp ts2 = new Timestamp(96, 11, 13, 14, 15, 25, 1000000); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one created using valueOf and another - * via a constructor are equal - */ - @Test - public void test08() { - Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.001"); - Timestamp ts2 = new Timestamp(ts1.getTime()); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate that two Timestamp values one created using valueOf and another - * via a constructor are equal - */ - @Test - public void test09() { - - Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.0"); - Timestamp ts2 = new Timestamp(96, 11, 13, 14, 15, 25, 0); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate that a Timestamp cannot be equal to null - */ - @Test - public void test10() { - - Timestamp ts1 = Timestamp.valueOf("1961-08-30 14:15:25.745634"); - Timestamp ts2 = null; - assertFalse(ts1.equals(ts2), "Error ts1 == null"); - } - - /* - * Validate that a Timestamp is equal to another timestamp created with the - * using the same value but not equal to a Timestamp which is one day later - */ - @Test - public void test11() { - - Timestamp ts1 = Timestamp.valueOf("1996-12-10 12:26:19.12"); - Timestamp ts2 = Timestamp.valueOf("1996-12-10 12:26:19.12"); - Timestamp ts3 = Timestamp.valueOf("1996-12-11 12:24:19.12"); - assertTrue(ts1.equals(ts2) && ts2.equals(ts1), "Error ts1 != ts2"); - assertFalse(ts1.equals(ts3) && ts3.equals(ts1), "Error ts1 == ts3"); - - } - - /* - * Validate that a Timestamp is equal to itself - */ - @Test - public void test12() { - Timestamp ts1 = Timestamp.valueOf("1996-10-15 12:26:19.12"); - assertTrue(ts1.equals(ts1), "Error ts1 != ts1"); - } - - /* - * Validate that two Timestamps are equal when one is created from the - * toString() of the other - */ - @Test(dataProvider = "validTimestampValues") - public void test13(String ts, String expectedTS) { - Timestamp ts1 = Timestamp.valueOf(ts); - Timestamp ts2 = Timestamp.valueOf(ts1.toString()); - assertTrue(ts1.equals(ts2) && ts2.equals(ts1) - && ts1.toString().equals(expectedTS), "Error ts1 != ts2"); - } - - // Before Tests - /* - * Validate that Timestamp ts1 is before Timestamp ts2 - */ - @Test - public void test14() { - Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); - Timestamp ts2 = Timestamp.valueOf("1996-12-13 15:15:25.645634"); - assertTrue(ts1.before(ts2), "Error ts1 not before ts2"); - } - - /* - * Validate that Timestamp ts1 is before Timestamp ts2 - */ - @Test - public void test15() { - Timestamp ts1 = Timestamp.valueOf("1961-08-30 14:15:25"); - Timestamp ts2 = Timestamp.valueOf("1999-12-13 15:15:25"); - assertTrue(ts1.before(ts2), "Error ts1 not before ts2"); - } - - /* - * Validate that Timestamp ts1 is before Timestamp ts2 - */ - @Test - public void test16() { - - Timestamp ts1 = Timestamp.valueOf("1999-12-13 14:15:25.745634"); - Timestamp ts2 = Timestamp.valueOf("1999-11-13 15:15:25.645634"); - assertFalse(ts1.before(ts2), "Error ts1 before ts2"); - } - - /* - * Validate that a NullPointerException is thrown if a null is passed to - * the before method - */ - @Test(expectedExceptions = NullPointerException.class) - public void test17() throws Exception { - Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); - ts1.before(null); - } - - /* - * Validate a Timestamp cannot be before itself - */ - @Test - public void test18() { - Timestamp ts1 = Timestamp.valueOf("1999-11-10 12:26:19.3456543"); - assertFalse(ts1.before(ts1), "Error ts1 before ts1!"); - } - - /* - * Create 3 Timestamps and make sure the 1st is before the other two - * Timestamps which are each greater than the one before it - */ - @Test - public void test19() { - - Timestamp ts1 = new Timestamp(1234560000); - Timestamp ts2 = new Timestamp(1234567000); - Timestamp ts3 = new Timestamp(1234569000); - assertTrue(ts1.before(ts2) && ts2.before(ts3) && ts1.before(ts3)); - } - - /* - * Validate that Timestamp ts1 is not after Timestamp ts2 - */ - @Test - public void test20() { - Timestamp ts1 = Timestamp.valueOf("1999-12-13 14:15:25.745634"); - Timestamp ts2 = Timestamp.valueOf("1999-12-13 15:15:25.645634"); - assertFalse(ts1.after(ts2), "Error ts1 is after ts2"); - - } - - /* - * Validate that Timestamp ts1 is after Timestamp ts2 - */ - @Test - public void test21() { - Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); - Timestamp ts2 = Timestamp.valueOf("1996-11-13 15:15:25.645634"); - assertTrue(ts1.after(ts2), "Error ts1 not after ts2"); - } - - /* - * Validate that a NullPointerException is thrown if a null is passed to the - * after method - */ - @Test(expectedExceptions = NullPointerException.class) - public void test22() throws Exception { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - ts1.after(null); - } - - /* - * Validate that a Timestamp cannot be after itself - */ - @Test - public void test23() { - Timestamp ts1 = Timestamp.valueOf("1999-11-10 12:26:19.3456543"); - assertFalse(ts1.after(ts1), "Error ts1 is after itself"); - } - - /* - * Validate that a Timestamp after() works correctly with Timestamp created - * using milliseconds - */ - @Test - public void test24() { - - Timestamp ts1 = new Timestamp(1234568000); - Timestamp ts2 = new Timestamp(1234565000); - Timestamp ts3 = new Timestamp(1234562000); - assertTrue(ts1.after(ts2) && ts2.after(ts3) && ts1.after(ts3)); - } - - /* - * Validate compareTo returns 0 for Timestamps that are the same - */ - @Test - public void test25() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Timestamp ts2 = new Timestamp(ts1.getTime()); - assertTrue(ts1.compareTo(ts2) == 0, "Error ts1 != ts2"); - } - - /* - * Validate compareTo returns -1 for when the 1st Timestamp is earlier than - * the 2nd Timestamp - */ - @Test - public void test26() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Timestamp ts2 = new Timestamp(ts1.getTime() + 1000); - assertTrue(ts1.compareTo(ts2) == -1, "Error ts1 not before ts2"); - assertTrue(ts2.compareTo(ts1) == 1, "Error ts1 is not before ts2"); - } - - /* - * Validate compareTo returns 1 for when the 1st Timestamp is later than the - * 2nd Timestamp - */ - @Test - public void test27() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Timestamp ts2 = new Timestamp(ts1.getTime() - 1000); - assertTrue(ts1.compareTo(ts2) == 1, "Error ts1 not after ts2"); - assertTrue(ts2.compareTo(ts1) == -1, "Error ts1 not after ts2"); - } - - /* - * Validate compareTo returns 0 for Timestamps that are the same - */ - @Test - public void test28() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - java.util.Date ts2 = new java.util.Date(ts1.getTime()); - assertTrue(ts1.compareTo(ts2) == 0, "Error ts1 != ts2"); - } - - /* - * Validate compareTo returns 0 for Timestamps that are the same - */ - @Test - public void test29() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - java.util.Date d = new java.util.Date(ts1.getTime()); - assertFalse(ts1.equals(d), "Error ts1 == d"); - } - - /* - * Validate compareTo returns 0 for Timestamps that are the same - */ - @Test - public void test30() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - java.util.Date d = new Timestamp(ts1.getTime()); - assertTrue(ts1.equals(d), "Error ts1 != d"); - } - - /* - * Validate equals returns false when a Date object is passed to equals - */ - @Test - public void test31() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Date d = new Date(ts1.getTime()); - assertFalse(ts1.equals(d), "Error ts1 != d"); - } - - /* - * Validate equals returns false when a Date object is passed to equals - */ - @Test - public void test32() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - java.util.Date d = new Date(ts1.getTime()); - assertFalse(ts1.equals(d), "Error ts1 != d"); - } - - /* - * Validate equals returns false when a Time object is passed to equals - */ - @Test - public void test33() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Time t1 = new Time(ts1.getTime()); - assertFalse(ts1.equals(t1), "Error ts1 == t1"); - } - - /* - * Validate equals returns false when a String object is passed to equals - */ - @Test - public void test34() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - assertFalse(ts1.equals("1966-08-30 08:08:08"), "Error ts1 == a String"); - } - - /* - * Validate getTime() returns the same value from 2 timeStamps created by - */ - @Test - public void test35() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Timestamp ts2 = Timestamp.valueOf("1966-08-30 08:08:08"); - assertTrue(ts2.getTime() == ts1.getTime(), - "ts1.getTime() != ts2.getTime()"); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate getTime() returns the same value from 2 timeStamps when - * setTime() is used to specify the same value for both Timestamps - */ - @Test - public void test36() { - Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); - Timestamp ts2 = Timestamp.valueOf("1961-08-30 00:00:00"); - ts2.setTime(ts1.getTime()); - assertTrue(ts2.getTime() == ts1.getTime(), - "ts1.getTime() != ts2.getTime()"); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate an IllegalArgumentException is thrown for an invalid nanos value - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test38() throws Exception { - Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); - ts1.setNanos(-1); - - } - - /* - * Validate an IllegalArgumentException is thrown for an invalid nanos value - */ - @Test(expectedExceptions = IllegalArgumentException.class) - public void test39() throws Exception { - int nanos = 999999999; - Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); - ts1.setNanos(nanos + 1); - } - - /* - * Validate you can set nanos to 999999999 - */ - @Test - public void test40() throws Exception { - int nanos = 999999999; - Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); - ts1.setNanos(nanos); - assertTrue(ts1.getNanos() == nanos, "Error Invalid Nanos value"); - } - - /* - * Validate you can set nanos to 0 - */ - @Test - public void test41() throws Exception { - int nanos = 0; - Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); - ts1.setNanos(nanos); - assertTrue(ts1.getNanos() == nanos, "Error Invalid Nanos value"); - } - - /* - * Validate that a Timestamp made from a LocalDateTime are equal - */ - @Test - public void test42() throws Exception { - Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); - LocalDateTime ldt = ts1.toLocalDateTime(); - Timestamp ts2 = Timestamp.valueOf(ldt); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate that a Timestamp LocalDateTime value, made from a LocalDateTime - * are equal - */ - @Test - public void test43() throws Exception { - LocalDateTime ldt = LocalDateTime.now(); - Timestamp ts2 = Timestamp.valueOf(ldt); - assertTrue(ldt.equals(ts2.toLocalDateTime()), - "Error LocalDateTime values are not equal"); - } - - /* - * Validate an NPE occurs when a null LocalDateTime is passed to valueOF - */ - @Test(expectedExceptions = NullPointerException.class) - public void test44() throws Exception { - LocalDateTime ldt = null; - Timestamp.valueOf(ldt); - } - - /* - * Validate that a Timestamp made from a Instant are equal - */ - @Test - public void test45() throws Exception { - Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); - Instant instant = ts1.toInstant(); - Timestamp ts2 = Timestamp.from(instant); - assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); - } - - /* - * Validate that a Timestamp made from a Instant are equal - */ - @Test - public void test46() throws Exception { - Instant instant = Instant.now(); - Timestamp ts2 = Timestamp.from(instant); - assertTrue(instant.equals(ts2.toInstant()), - "Error Instant values do not match"); - } - - /* - * Validate an NPE occurs when a null instant is passed to from - */ - @Test(expectedExceptions = NullPointerException.class) - public void test47() throws Exception { - Instant instant = null; - Timestamp.from(instant); - } - - // Added SQE tests - /* - * Create a Timestamp and a 2nd Timestamp that is 1 month earlier and - * validate that it is not before or after the original Timestamp - */ - @Test - public void test48() { - Calendar cal = Calendar.getInstance(); - Timestamp ts1 = new Timestamp(System.currentTimeMillis()); - cal.setTimeInMillis(ts1.getTime()); - cal.add(Calendar.MONTH, -1); - cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); - Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); - assertFalse(ts1.before(ts2) || ts2.after(ts1)); - } - - /* - * Create two Timestamps and validate that compareTo returns 1 to indicate - * the 1st Timestamp is greater than the 2nd Timestamp - */ - @Test - public void test49() { - Calendar cal = Calendar.getInstance(); - Timestamp ts1 = new Timestamp(System.currentTimeMillis()); - cal.setTimeInMillis(ts1.getTime()); - cal.add(Calendar.MONTH, -1); - cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); - Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); - assertTrue(ts1.compareTo(ts2) == 1); - } - - /* - * Create two Timestamps and validate that the 1st Timestamp is not equal to - * the 2nd Timestamp but equal to itself - */ - @Test - public void test50() { - Calendar cal = Calendar.getInstance(); - Timestamp ts1 = new Timestamp(System.currentTimeMillis()); - cal.setTimeInMillis(ts1.getTime()); - cal.add(Calendar.MONTH, -1); - cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); - Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); - assertTrue(!ts1.equals(ts2) && ts1.equals(ts1)); - } - - /* - * Validate that two Timestamps are equal when one is created from the - * toString() of the other - */ - @Test(dataProvider = "validateNanos") - public void test51(String ts, int nanos) { - Timestamp ts1 = Timestamp.valueOf(ts); - Timestamp ts2 = Timestamp.valueOf(ts1.toString()); - assertTrue(ts1.getNanos() == nanos && ts1.equals(ts2), - "Error with Nanos"); - } - - @Test(dataProvider = "validTimestampLongValues") - public void test52(long value, String ts) { - Timestamp ts1 = new Timestamp(value); - assertEquals(ts1.toString(), ts, "ts1.toString() != ts"); - } - - /* - * DataProvider used to provide Timestamps which are not valid and are used - * to validate that an IllegalArgumentException will be thrown from the - * valueOf method - */ - @DataProvider(name = "invalidTimestampValues") - private Object[][] invalidTimestampValues() { - return new Object[][]{ - {"2009-11-01-01 10:50:01"}, - {"aaaa-11-01-01 10:50"}, - {"aaaa-11-01 10:50"}, - {"1961--30 00:00:00"}, - {"--30 00:00:00"}, - {"-- 00:00:00"}, - {"1961-1- 00:00:00"}, - {"2009-11-01"}, - {"10:50:01"}, - {"1961-a-30 00:00:00"}, - {"1961-01-bb 00:00:00"}, - {"1961-08-30 00:00:00."}, - {"1961-08-30 :00:00"}, - {"1961-08-30 00::00"}, - {"1961-08-30 00:00:"}, - {"1961-08-30 ::"}, - {"1961-08-30 0a:00:00"}, - {"1961-08-30 00:bb:00"}, - {"1961-08-30 00:01:cc"}, - {"1961-08-30 00:00:00.01a"}, - {"1961-08-30 00:00:00.a"}, - {"1996-12-10 12:26:19.1234567890"}, - {null} - }; - } - - /* - * DataProvider used to provide Timestamps which are valid and are used - * to validate that an IllegalArgumentException will not be thrown from the - * valueOf method and the corect value from toString() is returned - */ - @DataProvider(name = "validTimestampValues") - private Object[][] validTimestampValues() { - return new Object[][]{ - {"1961-08-30 00:00:00", "1961-08-30 00:00:00.0"}, - {"1961-08-30 11:22:33", "1961-08-30 11:22:33.0"}, - {"1961-8-30 00:00:00", "1961-08-30 00:00:00.0"}, - {"1966-08-1 00:00:00", "1966-08-01 00:00:00.0"}, - {"1996-12-10 12:26:19.1", "1996-12-10 12:26:19.1"}, - {"1996-12-10 12:26:19.12", "1996-12-10 12:26:19.12"}, - {"1996-12-10 12:26:19.123", "1996-12-10 12:26:19.123"}, - {"1996-12-10 12:26:19.1234", "1996-12-10 12:26:19.1234"}, - {"1996-12-10 12:26:19.12345", "1996-12-10 12:26:19.12345"}, - {"1996-12-10 12:26:19.123456", "1996-12-10 12:26:19.123456"}, - {"1996-12-10 12:26:19.1234567", "1996-12-10 12:26:19.1234567"}, - {"1996-12-10 12:26:19.12345678", "1996-12-10 12:26:19.12345678"}, - {"1996-12-10 12:26:19.123456789", "1996-12-10 12:26:19.123456789"}, - {"1996-12-10 12:26:19.000000001", "1996-12-10 12:26:19.000000001"}, - {"1996-12-10 12:26:19.000000012", "1996-12-10 12:26:19.000000012"}, - {"1996-12-10 12:26:19.000000123", "1996-12-10 12:26:19.000000123"}, - {"1996-12-10 12:26:19.000001234", "1996-12-10 12:26:19.000001234"}, - {"1996-12-10 12:26:19.000012345", "1996-12-10 12:26:19.000012345"}, - {"1996-12-10 12:26:19.000123456", "1996-12-10 12:26:19.000123456"}, - {"1996-12-10 12:26:19.001234567", "1996-12-10 12:26:19.001234567"}, - {"1996-12-10 12:26:19.12345678", "1996-12-10 12:26:19.12345678"}, - {"1996-12-10 12:26:19.0", "1996-12-10 12:26:19.0"}, - {"1996-12-10 12:26:19.01230", "1996-12-10 12:26:19.0123"} - }; - } - - @DataProvider(name = "validTimestampLongValues") - private Object[][] validTimestampLongValues() { - return new Object[][]{ - {1L, "1970-01-01 01:00:00.001"}, - {-3600*1000L - 1, "1969-12-31 23:59:59.999"}, - {-(20000L*365*24*60*60*1000), "18018-08-28 01:00:00.0"}, - {Timestamp.valueOf("1961-08-30 11:22:33").getTime(), "1961-08-30 11:22:33.0"}, - {Timestamp.valueOf("1961-08-30 11:22:33.54321000").getTime(), "1961-08-30 11:22:33.543"}, // nanoprecision lost - {new Timestamp(114, 10, 10, 10, 10, 10, 100000000).getTime(), "2014-11-10 10:10:10.1"}, - {new Timestamp(0, 10, 10, 10, 10, 10, 100000).getTime(), "1900-11-10 10:10:10.0"}, // nanoprecision lost - {new Date(114, 10, 10).getTime(), "2014-11-10 00:00:00.0"}, - {new Date(0, 10, 10).getTime(), "1900-11-10 00:00:00.0"}, - {LocalDateTime.of(1960, 10, 10, 10, 10, 10, 50000).atZone(ZoneId.of("America/Los_Angeles")) - .toInstant().toEpochMilli(), "1960-10-10 19:10:10.0"}, - - // millisecond timestamps wraps around at year 1, so Long.MIN_VALUE looks similar - // Long.MAX_VALUE, while actually representing 292278994 BCE - {Long.MIN_VALUE, "292278994-08-17 08:12:55.192"}, - {Long.MAX_VALUE + 1, "292278994-08-17 08:12:55.192"}, - {Long.MAX_VALUE, "292278994-08-17 08:12:55.807"}, - {Long.MIN_VALUE - 1, "292278994-08-17 08:12:55.807"}, - - // wrap around point near 0001-01-01, test that we never get a negative year: - {-(1970L*365*24*60*60*1000), "0001-04-25 01:00:00.0"}, - {-(1970L*365*24*60*60*1000 + 115*24*60*60*1000L), "0001-12-31 01:00:00.0"}, - {-(1970L*365*24*60*60*1000 + 115*24*60*60*1000L - 23*60*60*1000L), "0001-01-01 00:00:00.0"}, - - {LocalDateTime.of(0, 1, 1, 10, 10, 10, 50000).atZone(ZoneId.of("America/Los_Angeles")) - .toInstant().toEpochMilli() - 2*24*60*60*1000L, "0001-01-01 19:03:08.0"}, // 1 BCE - {LocalDateTime.of(0, 1, 1, 10, 10, 10, 50000).atZone(ZoneId.of("America/Los_Angeles")) - .toInstant().toEpochMilli() - 3*24*60*60*1000L, "0002-12-31 19:03:08.0"} // 2 BCE - }; - } - - /* - * DataProvider used to provide Timestamp and Nanos values in order to - * validate that the correct Nanos value is generated from the specified - * Timestamp - */ - @DataProvider(name = "validateNanos") - private Object[][] validateNanos() { - return new Object[][]{ - {"1961-08-30 00:00:00", 0}, - {"1996-12-10 12:26:19.1", 100000000}, - {"1996-12-10 12:26:19.12", 120000000}, - {"1996-12-10 12:26:19.123", 123000000}, - {"1996-12-10 12:26:19.1234", 123400000}, - {"1996-12-10 12:26:19.12345", 123450000}, - {"1996-12-10 12:26:19.123456", 123456000}, - {"1996-12-10 12:26:19.1234567", 123456700}, - {"1996-12-10 12:26:19.12345678", 123456780}, - {"1996-12-10 12:26:19.123456789", 123456789}, - {"1996-12-10 12:26:19.000000001", 1}, - {"1996-12-10 12:26:19.000000012", 12}, - {"1996-12-10 12:26:19.000000123", 123}, - {"1996-12-10 12:26:19.000001234", 1234}, - {"1996-12-10 12:26:19.000012345", 12345}, - {"1996-12-10 12:26:19.000123456", 123456}, - {"1996-12-10 12:26:19.001234567", 1234567}, - {"1996-12-10 12:26:19.012345678", 12345678}, - {"1996-12-10 12:26:19.0", 0}, - {"1996-12-10 12:26:19.01230", 12300000} - }; - } -} --- old/test/java/sql/util/BaseTest.java 2014-10-28 10:30:27.000000000 -0400 +++ /dev/null 2014-10-28 10:30:27.000000000 -0400 @@ -1,126 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.ObjectInputStream; -import java.io.ObjectOutputStream; -import java.security.Policy; -import java.sql.JDBCType; -import java.sql.SQLException; -import org.testng.annotations.AfterClass; -import org.testng.annotations.AfterMethod; -import org.testng.annotations.BeforeClass; -import org.testng.annotations.BeforeMethod; -import org.testng.annotations.DataProvider; - -public class BaseTest { - - protected final String reason = "reason"; - protected final String state = "SQLState"; - protected final String cause = "java.lang.Throwable: cause"; - protected final Throwable t = new Throwable("cause"); - protected final Throwable t1 = new Throwable("cause 1"); - protected final Throwable t2 = new Throwable("cause 2"); - protected final int errorCode = 21; - protected final String[] msgs = {"Exception 1", "cause 1", "Exception 2", - "Exception 3", "cause 2"}; - - @BeforeClass - public static void setUpClass() throws Exception { - } - - @AfterClass - public static void tearDownClass() throws Exception { - } - - @BeforeMethod - public void setUpMethod() throws Exception { - } - - @AfterMethod - public void tearDownMethod() throws Exception { - } - - /* - * Take some form of SQLException, serialize and deserialize it - */ - @SuppressWarnings("unchecked") - protected T - createSerializedException(T ex) - throws IOException, ClassNotFoundException { - return (T) serializeDeserializeObject(ex); - } - - /* - * Utility method to serialize and deserialize an object - */ - @SuppressWarnings("unchecked") - protected T serializeDeserializeObject(T o) - throws IOException, ClassNotFoundException { - T o1; - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - try (ObjectOutputStream oos = new ObjectOutputStream(baos)) { - oos.writeObject(o); - } - try (ObjectInputStream ois - = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()))) { - o1 = (T) ois.readObject(); - } - return o1; - } - - /* - * Utility Method used to set the current Policy - */ - protected static void setPolicy(Policy p) { - Policy.setPolicy(p); - } - - /* - * DataProvider used to specify the value to set and check for - * methods using boolean values - */ - @DataProvider(name = "trueFalse") - protected Object[][] trueFalse() { - return new Object[][]{ - {true}, - {false} - }; - } - - /* - * DataProvider used to specify the standard JDBC Types - */ - @DataProvider(name = "jdbcTypes") - protected Object[][] jdbcTypes() { - Object[][] o = new Object[JDBCType.values().length][1]; - int pos = 0; - for (JDBCType c : JDBCType.values()) { - o[pos++][0] = c.getVendorTypeNumber(); - } - return o; - } -} --- old/test/java/sql/util/DriverActionImpl.java 2014-10-28 10:30:28.000000000 -0400 +++ /dev/null 2014-10-28 10:30:28.000000000 -0400 @@ -1,43 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -import java.sql.DriverAction; - -/** - * Simple implementation of DriverAction which calls back into the Driver when - * release is called. - */ -class DriverActionImpl implements DriverAction { - - public DriverActionImpl(StubDriverDA d) { - driver = d; - } - - private final StubDriverDA driver; - - @Override - public void deregister() { - driver.release(); - } -} --- old/test/java/sql/util/SerializedBatchUpdateException.java 2014-10-28 10:30:28.000000000 -0400 +++ /dev/null 2014-10-28 10:30:28.000000000 -0400 @@ -1,65 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -public class SerializedBatchUpdateException { - /** - * Serialized BatchUpdateException from JDBC 4.0 with the following values - * reason = "This was the error msg" - * SQLState = "user defined sqlState" - * vendor Code = 99999 - * Update Counts = {1, 2, 21} - * cause = = "java.lang.Throwable: throw 1" - */ - public static byte[] DATA = { - (byte) 0xac, (byte) 0xed, (byte) 0x0, (byte) 0x5, (byte) 0x73, (byte) 0x72, (byte) 0x0, (byte) 0x1d, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x73, (byte) 0x71, (byte) 0x6c, (byte) 0x2e, (byte) 0x42, (byte) 0x61, (byte) 0x74, (byte) 0x63, (byte) 0x68, (byte) 0x55, (byte) 0x70, (byte) 0x64, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, - (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x52, (byte) 0xf4, (byte) 0x73, (byte) 0xc0, (byte) 0xc1, (byte) 0x8b, (byte) 0xe, (byte) 0x5d, (byte) 0x3, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x0, (byte) 0x10, (byte) 0x6c, (byte) 0x6f, (byte) 0x6e, (byte) 0x67, (byte) 0x55, (byte) 0x70, (byte) 0x64, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x43, (byte) 0x6f, (byte) 0x75, - (byte) 0x6e, (byte) 0x74, (byte) 0x73, (byte) 0x74, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x4a, (byte) 0x5b, (byte) 0x0, (byte) 0xc, (byte) 0x75, (byte) 0x70, (byte) 0x64, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x43, (byte) 0x6f, (byte) 0x75, (byte) 0x6e, (byte) 0x74, (byte) 0x73, (byte) 0x74, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x49, (byte) 0x78, (byte) 0x72, (byte) 0x0, (byte) 0x15, - (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x73, (byte) 0x71, (byte) 0x6c, (byte) 0x2e, (byte) 0x53, (byte) 0x51, (byte) 0x4c, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x1d, (byte) 0xa1, (byte) 0xe9, (byte) 0x30, (byte) 0xdb, (byte) 0x3e, (byte) 0x75, (byte) 0xdc, (byte) 0x2, (byte) 0x0, (byte) 0x3, - (byte) 0x49, (byte) 0x0, (byte) 0xa, (byte) 0x76, (byte) 0x65, (byte) 0x6e, (byte) 0x64, (byte) 0x6f, (byte) 0x72, (byte) 0x43, (byte) 0x6f, (byte) 0x64, (byte) 0x65, (byte) 0x4c, (byte) 0x0, (byte) 0x8, (byte) 0x53, (byte) 0x51, (byte) 0x4c, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x74, (byte) 0x0, (byte) 0x12, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, - (byte) 0x2f, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2f, (byte) 0x53, (byte) 0x74, (byte) 0x72, (byte) 0x69, (byte) 0x6e, (byte) 0x67, (byte) 0x3b, (byte) 0x4c, (byte) 0x0, (byte) 0x4, (byte) 0x6e, (byte) 0x65, (byte) 0x78, (byte) 0x74, (byte) 0x74, (byte) 0x0, (byte) 0x17, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x73, (byte) 0x71, (byte) 0x6c, - (byte) 0x2f, (byte) 0x53, (byte) 0x51, (byte) 0x4c, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x3b, (byte) 0x78, (byte) 0x72, (byte) 0x0, (byte) 0x13, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, - (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0xd0, (byte) 0xfd, (byte) 0x1f, (byte) 0x3e, (byte) 0x1a, (byte) 0x3b, (byte) 0x1c, (byte) 0xc4, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x72, (byte) 0x0, (byte) 0x13, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x54, (byte) 0x68, - (byte) 0x72, (byte) 0x6f, (byte) 0x77, (byte) 0x61, (byte) 0x62, (byte) 0x6c, (byte) 0x65, (byte) 0xd5, (byte) 0xc6, (byte) 0x35, (byte) 0x27, (byte) 0x39, (byte) 0x77, (byte) 0xb8, (byte) 0xcb, (byte) 0x3, (byte) 0x0, (byte) 0x4, (byte) 0x4c, (byte) 0x0, (byte) 0x5, (byte) 0x63, (byte) 0x61, (byte) 0x75, (byte) 0x73, (byte) 0x65, (byte) 0x74, (byte) 0x0, (byte) 0x15, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, - (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2f, (byte) 0x54, (byte) 0x68, (byte) 0x72, (byte) 0x6f, (byte) 0x77, (byte) 0x61, (byte) 0x62, (byte) 0x6c, (byte) 0x65, (byte) 0x3b, (byte) 0x4c, (byte) 0x0, (byte) 0xd, (byte) 0x64, (byte) 0x65, (byte) 0x74, (byte) 0x61, (byte) 0x69, (byte) 0x6c, (byte) 0x4d, (byte) 0x65, (byte) 0x73, (byte) 0x73, (byte) 0x61, - (byte) 0x67, (byte) 0x65, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x5b, (byte) 0x0, (byte) 0xa, (byte) 0x73, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, (byte) 0x65, (byte) 0x74, (byte) 0x0, (byte) 0x1e, (byte) 0x5b, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x6c, (byte) 0x61, - (byte) 0x6e, (byte) 0x67, (byte) 0x2f, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, (byte) 0x65, (byte) 0x45, (byte) 0x6c, (byte) 0x65, (byte) 0x6d, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x3b, (byte) 0x4c, (byte) 0x0, (byte) 0x14, (byte) 0x73, (byte) 0x75, (byte) 0x70, (byte) 0x70, (byte) 0x72, (byte) 0x65, (byte) 0x73, (byte) 0x73, - (byte) 0x65, (byte) 0x64, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x73, (byte) 0x74, (byte) 0x0, (byte) 0x10, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2f, (byte) 0x75, (byte) 0x74, (byte) 0x69, (byte) 0x6c, (byte) 0x2f, (byte) 0x4c, (byte) 0x69, (byte) 0x73, (byte) 0x74, (byte) 0x3b, (byte) 0x78, - (byte) 0x70, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x7, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0xc, (byte) 0x74, (byte) 0x0, (byte) 0x7, (byte) 0x74, (byte) 0x68, (byte) 0x72, (byte) 0x6f, (byte) 0x77, (byte) 0x20, (byte) 0x31, (byte) 0x75, (byte) 0x72, (byte) 0x0, (byte) 0x1e, (byte) 0x5b, (byte) 0x4c, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, - (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, (byte) 0x65, (byte) 0x45, (byte) 0x6c, (byte) 0x65, (byte) 0x6d, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x3b, (byte) 0x2, (byte) 0x46, (byte) 0x2a, (byte) 0x3c, (byte) 0x3c, (byte) 0xfd, (byte) 0x22, (byte) 0x39, - (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x73, (byte) 0x72, (byte) 0x0, (byte) 0x1b, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x2e, (byte) 0x6c, (byte) 0x61, (byte) 0x6e, (byte) 0x67, (byte) 0x2e, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x63, (byte) 0x6b, (byte) 0x54, (byte) 0x72, (byte) 0x61, (byte) 0x63, - (byte) 0x65, (byte) 0x45, (byte) 0x6c, (byte) 0x65, (byte) 0x6d, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x61, (byte) 0x9, (byte) 0xc5, (byte) 0x9a, (byte) 0x26, (byte) 0x36, (byte) 0xdd, (byte) 0x85, (byte) 0x2, (byte) 0x0, (byte) 0x4, (byte) 0x49, (byte) 0x0, (byte) 0xa, (byte) 0x6c, (byte) 0x69, (byte) 0x6e, (byte) 0x65, (byte) 0x4e, (byte) 0x75, (byte) 0x6d, (byte) 0x62, (byte) 0x65, (byte) 0x72, - (byte) 0x4c, (byte) 0x0, (byte) 0xe, (byte) 0x64, (byte) 0x65, (byte) 0x63, (byte) 0x6c, (byte) 0x61, (byte) 0x72, (byte) 0x69, (byte) 0x6e, (byte) 0x67, (byte) 0x43, (byte) 0x6c, (byte) 0x61, (byte) 0x73, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x4c, (byte) 0x0, (byte) 0x8, (byte) 0x66, (byte) 0x69, (byte) 0x6c, (byte) 0x65, (byte) 0x4e, (byte) 0x61, (byte) 0x6d, - (byte) 0x65, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x4c, (byte) 0x0, (byte) 0xa, (byte) 0x6d, (byte) 0x65, (byte) 0x74, (byte) 0x68, (byte) 0x6f, (byte) 0x64, (byte) 0x4e, (byte) 0x61, (byte) 0x6d, (byte) 0x65, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x4, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x23, (byte) 0x74, (byte) 0x0, - (byte) 0x17, (byte) 0x43, (byte) 0x72, (byte) 0x65, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x42, (byte) 0x61, (byte) 0x74, (byte) 0x63, (byte) 0x68, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x53, (byte) 0x65, (byte) 0x72, (byte) 0x74, (byte) 0x0, (byte) 0x1c, (byte) 0x43, (byte) 0x72, (byte) 0x65, (byte) 0x61, (byte) 0x74, - (byte) 0x65, (byte) 0x42, (byte) 0x61, (byte) 0x74, (byte) 0x63, (byte) 0x68, (byte) 0x45, (byte) 0x78, (byte) 0x63, (byte) 0x65, (byte) 0x70, (byte) 0x74, (byte) 0x69, (byte) 0x6f, (byte) 0x6e, (byte) 0x53, (byte) 0x65, (byte) 0x72, (byte) 0x2e, (byte) 0x6a, (byte) 0x61, (byte) 0x76, (byte) 0x61, (byte) 0x74, (byte) 0x0, (byte) 0x9, (byte) 0x77, (byte) 0x72, (byte) 0x69, (byte) 0x74, (byte) 0x65, (byte) 0x54, - (byte) 0x65, (byte) 0x73, (byte) 0x74, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1a, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x12, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x13, (byte) 0x74, (byte) 0x0, (byte) 0x4, (byte) 0x6d, (byte) 0x61, (byte) 0x69, (byte) 0x6e, (byte) 0x70, (byte) 0x78, - (byte) 0x74, (byte) 0x0, (byte) 0x16, (byte) 0x54, (byte) 0x68, (byte) 0x69, (byte) 0x73, (byte) 0x20, (byte) 0x77, (byte) 0x61, (byte) 0x73, (byte) 0x20, (byte) 0x74, (byte) 0x68, (byte) 0x65, (byte) 0x20, (byte) 0x65, (byte) 0x72, (byte) 0x72, (byte) 0x6f, (byte) 0x72, (byte) 0x20, (byte) 0x6d, (byte) 0x73, (byte) 0x67, (byte) 0x75, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0xe, (byte) 0x0, - (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x28, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x12, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x13, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x14, (byte) 0x73, (byte) 0x71, (byte) 0x0, (byte) 0x7e, - (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1a, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x12, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x13, (byte) 0x71, (byte) 0x0, (byte) 0x7e, (byte) 0x0, (byte) 0x16, (byte) 0x70, (byte) 0x78, (byte) 0x0, (byte) 0x1, (byte) 0x86, (byte) 0x9f, (byte) 0x74, (byte) 0x0, (byte) 0x15, (byte) 0x75, (byte) 0x73, - (byte) 0x65, (byte) 0x72, (byte) 0x20, (byte) 0x64, (byte) 0x65, (byte) 0x66, (byte) 0x69, (byte) 0x6e, (byte) 0x65, (byte) 0x64, (byte) 0x20, (byte) 0x73, (byte) 0x71, (byte) 0x6c, (byte) 0x53, (byte) 0x74, (byte) 0x61, (byte) 0x74, (byte) 0x65, (byte) 0x70, (byte) 0x75, (byte) 0x72, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x4a, (byte) 0x78, (byte) 0x20, (byte) 0x4, (byte) 0xb5, (byte) 0x12, (byte) 0xb1, - (byte) 0x75, (byte) 0x93, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x3, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, - (byte) 0x0, (byte) 0x0, (byte) 0x15, (byte) 0x75, (byte) 0x72, (byte) 0x0, (byte) 0x2, (byte) 0x5b, (byte) 0x49, (byte) 0x4d, (byte) 0xba, (byte) 0x60, (byte) 0x26, (byte) 0x76, (byte) 0xea, (byte) 0xb2, (byte) 0xa5, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x78, (byte) 0x70, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x3, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x1, (byte) 0x0, (byte) 0x0, - (byte) 0x0, (byte) 0x2, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x15, (byte) 0x78 - }; -} --- old/test/java/sql/util/StubConnection.java 2014-10-28 10:30:29.000000000 -0400 +++ /dev/null 2014-10-28 10:30:29.000000000 -0400 @@ -1,315 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -import java.sql.Array; -import java.sql.Blob; -import java.sql.CallableStatement; -import java.sql.Clob; -import java.sql.Connection; -import java.sql.DatabaseMetaData; -import java.sql.NClob; -import java.sql.PreparedStatement; -import java.sql.SQLClientInfoException; -import java.sql.SQLException; -import java.sql.SQLWarning; -import java.sql.SQLXML; -import java.sql.Savepoint; -import java.sql.Statement; -import java.sql.Struct; -import java.util.Map; -import java.util.Properties; -import java.util.concurrent.Executor; - -public class StubConnection implements Connection { - - @Override - public Statement createStatement() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public PreparedStatement prepareStatement(String sql) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public CallableStatement prepareCall(String sql) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public String nativeSQL(String sql) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setAutoCommit(boolean autoCommit) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public boolean getAutoCommit() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void commit() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void rollback() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void close() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public boolean isClosed() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public DatabaseMetaData getMetaData() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setReadOnly(boolean readOnly) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public boolean isReadOnly() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setCatalog(String catalog) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public String getCatalog() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setTransactionIsolation(int level) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public int getTransactionIsolation() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public SQLWarning getWarnings() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void clearWarnings() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Map> getTypeMap() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setTypeMap(Map> map) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setHoldability(int holdability) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public int getHoldability() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Savepoint setSavepoint() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Savepoint setSavepoint(String name) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void rollback(Savepoint savepoint) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void releaseSavepoint(Savepoint savepoint) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Clob createClob() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Blob createBlob() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public NClob createNClob() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public SQLXML createSQLXML() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public boolean isValid(int timeout) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setClientInfo(String name, String value) throws SQLClientInfoException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setClientInfo(Properties properties) throws SQLClientInfoException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public String getClientInfo(String name) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Properties getClientInfo() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Array createArrayOf(String typeName, Object[] elements) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public Struct createStruct(String typeName, Object[] attributes) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setSchema(String schema) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public String getSchema() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void abort(Executor executor) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public void setNetworkTimeout(Executor executor, int milliseconds) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public int getNetworkTimeout() throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public T unwrap(Class iface) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public boolean isWrapperFor(Class iface) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } -} --- old/test/java/sql/util/StubDriver.java 2014-10-28 10:30:29.000000000 -0400 +++ /dev/null 2014-10-28 10:30:29.000000000 -0400 @@ -1,75 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -import java.sql.Connection; -import java.sql.Driver; -import java.sql.DriverPropertyInfo; -import java.sql.SQLException; -import java.sql.SQLFeatureNotSupportedException; -import java.util.Properties; -import java.util.logging.Logger; - -public class StubDriver implements Driver { - - public StubDriver() { - } - - @Override - public Connection connect(String url, Properties info) throws SQLException { - if (acceptsURL(url)) { - return new StubConnection(); - } - return null; - } - - @Override - public boolean acceptsURL(String url) throws SQLException { - return url.matches("^jdbc:tennis:.*"); - } - - @Override - public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException { - throw new UnsupportedOperationException("Not supported yet."); - } - - @Override - public int getMajorVersion() { - return 1; - } - - @Override - public int getMinorVersion() { - return 0; - } - - @Override - public boolean jdbcCompliant() { - return true; - } - - @Override - public Logger getParentLogger() throws SQLFeatureNotSupportedException { - throw new UnsupportedOperationException("Not supported yet."); - } -} --- old/test/java/sql/util/StubDriverDA.java 2014-10-28 10:30:30.000000000 -0400 +++ /dev/null 2014-10-28 10:30:30.000000000 -0400 @@ -1,75 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -import java.io.File; -import java.io.IOException; -import java.sql.DriverAction; -import java.sql.DriverManager; -import java.sql.SQLException; -import java.util.logging.Level; -import java.util.logging.Logger; - -/** - * Simple java.sql.Driver stub class that registers the driver via a static - * block with a DriverAction Implementation - * @author ljanders - */ -public class StubDriverDA extends StubDriver { - - public static final String DriverActionCalled = "DriverActionCalled.txt"; - - static DriverAction da; - - static { - try { - DriverManager.registerDriver(new StubDriverDA(), da); - } catch (SQLException ex) { - Logger.getLogger(StubDriverDA.class.getName()).log(Level.SEVERE, null, ex); - } - } - - public StubDriverDA() { - da = new DriverActionImpl(this); - } - - @Override - public boolean acceptsURL(String url) throws SQLException { - return url.matches("^jdbc:luckydog:.*"); - } - - /** - * This method will write out a text file when called by the - * DriverActionImpl.release method when DriverManager.deregisterDriver - * is called. This is used by DriverManagerTests to validate that - * DriverAction.release was called - */ - protected void release() { - File file = new File(DriverActionCalled); - try { - file.createNewFile(); - } catch (IOException ex) { - throw new RuntimeException(ex); - } - } -} --- old/test/java/sql/util/TestPolicy.java 2014-10-28 10:30:32.000000000 -0400 +++ /dev/null 2014-10-28 10:30:32.000000000 -0400 @@ -1,135 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ -package util; - -import java.io.FilePermission; -import java.security.AllPermission; -import java.security.CodeSource; -import java.security.Permission; -import java.security.PermissionCollection; -import java.security.Permissions; -import java.security.Policy; -import java.security.ProtectionDomain; -import java.security.SecurityPermission; -import java.sql.SQLPermission; -import java.util.Enumeration; -import java.util.PropertyPermission; -import java.util.StringJoiner; - -/* - * Simple Policy class that supports the required Permissions to validate the - * JDBC concrete classes - */ -public class TestPolicy extends Policy { - - final PermissionCollection permissions = new Permissions(); - - /** - * Constructor which sets the minimum permissions allowing testNG to work - * with a SecurityManager - */ - public TestPolicy() { - setMinimalPermissions(); - } - - /* - * Constructor which determines which permissions are defined for this - * Policy used by the JDBC tests Possible values are: all (ALLPermissions), - * setLog (SQLPemission("setLog"), deregisterDriver - * (SQLPermission("deregisterDriver") (SQLPermission("deregisterDriver"), - * and setSyncFactory(SQLPermission(setSyncFactory), - * - * @param policy Permissions to set - */ - public TestPolicy(String policy) { - - switch (policy) { - case "all": - permissions.add(new AllPermission()); - break; - case "setLog": - setMinimalPermissions(); - permissions.add(new SQLPermission("setLog")); - break; - case "deregisterDriver": - setMinimalPermissions(); - permissions.add(new SQLPermission("deregisterDriver")); - break; - case "setSyncFactory": - setMinimalPermissions(); - permissions.add(new SQLPermission("setSyncFactory")); - break; - default: - setMinimalPermissions(); - } - } - - /* - * Defines the minimal permissions required by testNG when running these - * tests - */ - private void setMinimalPermissions() { - permissions.add(new SecurityPermission("getPolicy")); - permissions.add(new SecurityPermission("setPolicy")); - permissions.add(new RuntimePermission("getClassLoader")); - permissions.add(new RuntimePermission("setSecurityManager")); - permissions.add(new RuntimePermission("createSecurityManager")); - permissions.add(new PropertyPermission("testng.show.stack.frames", - "read")); - permissions.add(new PropertyPermission("line.separator", "read")); - permissions.add(new PropertyPermission("fileStringBuffer", "read")); - permissions.add(new PropertyPermission("dataproviderthreadcount", "read")); - permissions.add(new PropertyPermission("java.io.tmpdir", "read")); - permissions.add(new FilePermission("<>", - "read, write, delete")); - } - - /* - * Overloaded methods from the Policy class - */ - @Override - public String toString() { - StringJoiner sj = new StringJoiner("\n", "policy: ", ""); - Enumeration perms = permissions.elements(); - while (perms.hasMoreElements()) { - sj.add(perms.nextElement().toString()); - } - return sj.toString(); - - } - - @Override - public PermissionCollection getPermissions(ProtectionDomain domain) { - return permissions; - } - - @Override - public PermissionCollection getPermissions(CodeSource codesource) { - return permissions; - } - - @Override - public boolean implies(ProtectionDomain domain, Permission perm) { - return permissions.implies(perm); - } -}