1 /* 2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 package test.sql; 24 25 import java.sql.Date; 26 import java.sql.Time; 27 import java.sql.Timestamp; 28 import java.time.Instant; 29 import java.time.LocalDateTime; 30 import java.util.Calendar; 31 import static org.testng.Assert.*; 32 import org.testng.annotations.DataProvider; 33 import org.testng.annotations.Test; 34 import util.BaseTest; 35 36 public class TimestampTests extends BaseTest { 37 38 /* 39 * Validate an IllegalArgumentException is thrown for an invalid Timestamp 40 */ 41 @Test(dataProvider = "invalidTimestampValues", 42 expectedExceptions = IllegalArgumentException.class) 43 public void test(String ts) throws Exception { 44 Timestamp.valueOf(ts); 45 } 46 47 /* 48 * Validate that two Timestamp are equal when the leading 0 in seconds is 49 * omitted 50 */ 51 @Test 52 public void test01() throws Exception { 53 String testTS = "2009-01-01 10:50:00"; 54 String ExpectedTS = "2009-01-01 10:50:0"; 55 Timestamp ts = Timestamp.valueOf(testTS); 56 Timestamp ts2 = Timestamp.valueOf(ExpectedTS); 57 assertEquals(ts, ts2, "Error ts1 != ts2"); 58 } 59 60 /* 61 * Validate two Timestamps created from the same string are equal 62 */ 63 @Test 64 public void test02() throws Exception { 65 String testTS = "2009-01-01 10:50:0"; 66 Timestamp ts = Timestamp.valueOf(testTS); 67 Timestamp ts2 = Timestamp.valueOf(testTS); 68 assertEquals(ts, ts2, "Error ts1 != ts2"); 69 } 70 71 /* 72 * Validate that two Timestamp values one with leading 0s for month and day 73 * equals same string without the leading 0s. 74 */ 75 @Test 76 public void test03() throws Exception { 77 String testTS = "2009-1-1 10:50:0"; 78 String ExpectedTS = "2009-01-01 10:50:0"; 79 Timestamp ts = Timestamp.valueOf(testTS); 80 Timestamp ts2 = Timestamp.valueOf(ExpectedTS); 81 assertEquals(ts, ts2, "Error ts1 != ts2"); 82 } 83 84 /* 85 * Validate that two Timestamp values one with leading 0s for day omitted 86 * are equal 87 */ 88 @Test 89 public void test04() throws Exception { 90 String testTS = "2009-01-1 10:50:0"; 91 String ExpectedTS = "2009-01-01 10:50:0"; 92 Timestamp ts = Timestamp.valueOf(testTS); 93 Timestamp ts2 = Timestamp.valueOf(ExpectedTS); 94 assertEquals(ts, ts2, "Error ts1 != ts2"); 95 } 96 97 /* 98 * Validate that two Timestamp values one with leading 0s for month omitted 99 * and both with leading 0s for seconds omitted are equal 100 */ 101 @Test 102 public void test05() throws Exception { 103 String testTS = "2009-1-01 10:50:0"; 104 String ExpectedTS = "2009-01-01 10:50:0"; 105 Timestamp ts = Timestamp.valueOf(testTS); 106 Timestamp ts2 = Timestamp.valueOf(ExpectedTS); 107 assertEquals(ts, ts2, "Error ts1 != ts2"); 108 } 109 110 /* 111 * Validate that two Timestamp values one with leading 0s for month omitted 112 */ 113 @Test 114 public void test06() throws Exception { 115 String testTS = "2005-1-01 10:20:50.00"; 116 String ExpectedTS = "2005-01-01 10:20:50.00"; 117 Timestamp ts = Timestamp.valueOf(testTS); 118 Timestamp ts2 = Timestamp.valueOf(ExpectedTS); 119 assertEquals(ts, ts2, "Error ts1 != ts2"); 120 } 121 122 /* 123 * Validate that two Timestamp values one created using valueOf and another 124 * via a constructor are equal 125 */ 126 @Test 127 public void test07() { 128 129 Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.001"); 130 Timestamp ts2 = new Timestamp(96, 11, 13, 14, 15, 25, 1000000); 131 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 132 } 133 134 /* 135 * Validate that two Timestamp values one created using valueOf and another 136 * via a constructor are equal 137 */ 138 @Test 139 public void test08() { 140 Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.001"); 141 Timestamp ts2 = new Timestamp(ts1.getTime()); 142 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 143 } 144 145 /* 146 * Validate that two Timestamp values one created using valueOf and another 147 * via a constructor are equal 148 */ 149 @Test 150 public void test09() { 151 152 Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.0"); 153 Timestamp ts2 = new Timestamp(96, 11, 13, 14, 15, 25, 0); 154 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 155 } 156 157 /* 158 * Validate that a Timestamp cannot be equal to null 159 */ 160 @Test 161 public void test10() { 162 163 Timestamp ts1 = Timestamp.valueOf("1961-08-30 14:15:25.745634"); 164 Timestamp ts2 = null; 165 assertFalse(ts1.equals(ts2), "Error ts1 == null"); 166 } 167 168 /* 169 * Validate that a Timestamp is equal to another timestamp created with the 170 * using the same value but not equal to a Timestamp which is one day later 171 */ 172 @Test 173 public void test11() { 174 175 Timestamp ts1 = Timestamp.valueOf("1996-12-10 12:26:19.12"); 176 Timestamp ts2 = Timestamp.valueOf("1996-12-10 12:26:19.12"); 177 Timestamp ts3 = Timestamp.valueOf("1996-12-11 12:24:19.12"); 178 assertTrue(ts1.equals(ts2) && ts2.equals(ts1), "Error ts1 != ts2"); 179 assertFalse(ts1.equals(ts3) && ts3.equals(ts1), "Error ts1 == ts3"); 180 181 } 182 183 /* 184 * Validate that a Timestamp is equal to itself 185 */ 186 @Test 187 public void test12() { 188 Timestamp ts1 = Timestamp.valueOf("1996-10-15 12:26:19.12"); 189 assertTrue(ts1.equals(ts1), "Error ts1 != ts1"); 190 } 191 192 /* 193 * Validate that two Timestamps are equal when one is created from the 194 * toString() of the other 195 */ 196 @Test(dataProvider = "validTimestampValues") 197 public void test13(String ts, String expectedTS) { 198 Timestamp ts1 = Timestamp.valueOf(ts); 199 Timestamp ts2 = Timestamp.valueOf(ts1.toString()); 200 assertTrue(ts1.equals(ts2) && ts2.equals(ts1) 201 && ts1.toString().equals(expectedTS), "Error ts1 != ts2"); 202 } 203 204 // Before Tests 205 /* 206 * Validate that Timestamp ts1 is before Timestamp ts2 207 */ 208 @Test 209 public void test14() { 210 Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); 211 Timestamp ts2 = Timestamp.valueOf("1996-12-13 15:15:25.645634"); 212 assertTrue(ts1.before(ts2), "Error ts1 not before ts2"); 213 } 214 215 /* 216 * Validate that Timestamp ts1 is before Timestamp ts2 217 */ 218 @Test 219 public void test15() { 220 Timestamp ts1 = Timestamp.valueOf("1961-08-30 14:15:25"); 221 Timestamp ts2 = Timestamp.valueOf("1999-12-13 15:15:25"); 222 assertTrue(ts1.before(ts2), "Error ts1 not before ts2"); 223 } 224 225 /* 226 * Validate that Timestamp ts1 is before Timestamp ts2 227 */ 228 @Test 229 public void test16() { 230 231 Timestamp ts1 = Timestamp.valueOf("1999-12-13 14:15:25.745634"); 232 Timestamp ts2 = Timestamp.valueOf("1999-11-13 15:15:25.645634"); 233 assertFalse(ts1.before(ts2), "Error ts1 before ts2"); 234 } 235 236 /* 237 * Validate that a NullPointerException is thrown if a null is passed to 238 * the before method 239 */ 240 @Test(expectedExceptions = NullPointerException.class) 241 public void test17() throws Exception { 242 Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); 243 ts1.before(null); 244 } 245 246 /* 247 * Validate a Timestamp cannot be before itself 248 */ 249 @Test 250 public void test18() { 251 Timestamp ts1 = Timestamp.valueOf("1999-11-10 12:26:19.3456543"); 252 assertFalse(ts1.before(ts1), "Error ts1 before ts1!"); 253 } 254 255 /* 256 * Create 3 Timestamps and make sure the 1st is before the other two 257 * Timestamps which are each greater than the one before it 258 */ 259 @Test 260 public void test19() { 261 262 Timestamp ts1 = new Timestamp(1234560000); 263 Timestamp ts2 = new Timestamp(1234567000); 264 Timestamp ts3 = new Timestamp(1234569000); 265 assertTrue(ts1.before(ts2) && ts2.before(ts3) && ts1.before(ts3)); 266 } 267 268 /* 269 * Validate that Timestamp ts1 is not after Timestamp ts2 270 */ 271 @Test 272 public void test20() { 273 Timestamp ts1 = Timestamp.valueOf("1999-12-13 14:15:25.745634"); 274 Timestamp ts2 = Timestamp.valueOf("1999-12-13 15:15:25.645634"); 275 assertFalse(ts1.after(ts2), "Error ts1 is after ts2"); 276 277 } 278 279 /* 280 * Validate that Timestamp ts1 is after Timestamp ts2 281 */ 282 @Test 283 public void test21() { 284 Timestamp ts1 = Timestamp.valueOf("1996-12-13 14:15:25.745634"); 285 Timestamp ts2 = Timestamp.valueOf("1996-11-13 15:15:25.645634"); 286 assertTrue(ts1.after(ts2), "Error ts1 not after ts2"); 287 } 288 289 /* 290 * Validate that a NullPointerException is thrown if a null is passed to the 291 * after method 292 */ 293 @Test(expectedExceptions = NullPointerException.class) 294 public void test22() throws Exception { 295 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 296 ts1.after(null); 297 } 298 299 /* 300 * Validate that a Timestamp cannot be after itself 301 */ 302 @Test 303 public void test23() { 304 Timestamp ts1 = Timestamp.valueOf("1999-11-10 12:26:19.3456543"); 305 assertFalse(ts1.after(ts1), "Error ts1 is after itself"); 306 } 307 308 /* 309 * Validate that a Timestamp after() works correctly with Timestamp created 310 * using milliseconds 311 */ 312 @Test 313 public void test24() { 314 315 Timestamp ts1 = new Timestamp(1234568000); 316 Timestamp ts2 = new Timestamp(1234565000); 317 Timestamp ts3 = new Timestamp(1234562000); 318 assertTrue(ts1.after(ts2) && ts2.after(ts3) && ts1.after(ts3)); 319 } 320 321 /* 322 * Validate compareTo returns 0 for Timestamps that are the same 323 */ 324 @Test 325 public void test25() { 326 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 327 Timestamp ts2 = new Timestamp(ts1.getTime()); 328 assertTrue(ts1.compareTo(ts2) == 0, "Error ts1 != ts2"); 329 } 330 331 /* 332 * Validate compareTo returns -1 for when the 1st Timestamp is earlier than 333 * the 2nd Timestamp 334 */ 335 @Test 336 public void test26() { 337 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 338 Timestamp ts2 = new Timestamp(ts1.getTime() + 1000); 339 assertTrue(ts1.compareTo(ts2) == -1, "Error ts1 not before ts2"); 340 assertTrue(ts2.compareTo(ts1) == 1, "Error ts1 is not before ts2"); 341 } 342 343 /* 344 * Validate compareTo returns 1 for when the 1st Timestamp is later than the 345 * 2nd Timestamp 346 */ 347 @Test 348 public void test27() { 349 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 350 Timestamp ts2 = new Timestamp(ts1.getTime() - 1000); 351 assertTrue(ts1.compareTo(ts2) == 1, "Error ts1 not after ts2"); 352 assertTrue(ts2.compareTo(ts1) == -1, "Error ts1 not after ts2"); 353 } 354 355 /* 356 * Validate compareTo returns 0 for Timestamps that are the same 357 */ 358 @Test 359 public void test28() { 360 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 361 java.util.Date ts2 = new java.util.Date(ts1.getTime()); 362 assertTrue(ts1.compareTo(ts2) == 0, "Error ts1 != ts2"); 363 } 364 365 /* 366 * Validate compareTo returns 0 for Timestamps that are the same 367 */ 368 @Test 369 public void test29() { 370 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 371 java.util.Date d = new java.util.Date(ts1.getTime()); 372 assertFalse(ts1.equals(d), "Error ts1 == d"); 373 } 374 375 /* 376 * Validate compareTo returns 0 for Timestamps that are the same 377 */ 378 @Test 379 public void test30() { 380 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 381 java.util.Date d = new Timestamp(ts1.getTime()); 382 assertTrue(ts1.equals(d), "Error ts1 != d"); 383 } 384 385 /* 386 * Validate equals returns false when a Date object is passed to equals 387 */ 388 @Test 389 public void test31() { 390 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 391 Date d = new Date(ts1.getTime()); 392 assertFalse(ts1.equals(d), "Error ts1 != d"); 393 } 394 395 /* 396 * Validate equals returns false when a Date object is passed to equals 397 */ 398 @Test 399 public void test32() { 400 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 401 java.util.Date d = new Date(ts1.getTime()); 402 assertFalse(ts1.equals(d), "Error ts1 != d"); 403 } 404 405 /* 406 * Validate equals returns false when a Time object is passed to equals 407 */ 408 @Test 409 public void test33() { 410 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 411 Time t1 = new Time(ts1.getTime()); 412 assertFalse(ts1.equals(t1), "Error ts1 == t1"); 413 } 414 415 /* 416 * Validate equals returns false when a String object is passed to equals 417 */ 418 @Test 419 public void test34() { 420 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 421 assertFalse(ts1.equals("1966-08-30 08:08:08"), "Error ts1 == a String"); 422 } 423 424 /* 425 * Validate getTime() returns the same value from 2 timeStamps created by 426 */ 427 @Test 428 public void test35() { 429 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 430 Timestamp ts2 = Timestamp.valueOf("1966-08-30 08:08:08"); 431 assertTrue(ts2.getTime() == ts1.getTime(), 432 "ts1.getTime() != ts2.getTime()"); 433 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 434 } 435 436 /* 437 * Validate getTime() returns the same value from 2 timeStamps when 438 * setTime() is used to specify the same value for both Timestamps 439 */ 440 @Test 441 public void test36() { 442 Timestamp ts1 = Timestamp.valueOf("1966-08-30 08:08:08"); 443 Timestamp ts2 = Timestamp.valueOf("1961-08-30 00:00:00"); 444 ts2.setTime(ts1.getTime()); 445 assertTrue(ts2.getTime() == ts1.getTime(), 446 "ts1.getTime() != ts2.getTime()"); 447 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 448 } 449 450 /* 451 * Validate an IllegalArgumentException is thrown for an invalid nanos value 452 */ 453 @Test(expectedExceptions = IllegalArgumentException.class) 454 public void test38() throws Exception { 455 Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); 456 ts1.setNanos(-1); 457 458 } 459 460 /* 461 * Validate an IllegalArgumentException is thrown for an invalid nanos value 462 */ 463 @Test(expectedExceptions = IllegalArgumentException.class) 464 public void test39() throws Exception { 465 int nanos = 999999999; 466 Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); 467 ts1.setNanos(nanos + 1); 468 } 469 470 /* 471 * Validate you can set nanos to 999999999 472 */ 473 @Test 474 public void test40() throws Exception { 475 int nanos = 999999999; 476 Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); 477 ts1.setNanos(nanos); 478 assertTrue(ts1.getNanos() == nanos, "Error Invalid Nanos value"); 479 } 480 481 /* 482 * Validate you can set nanos to 0 483 */ 484 @Test 485 public void test41() throws Exception { 486 int nanos = 0; 487 Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); 488 ts1.setNanos(nanos); 489 assertTrue(ts1.getNanos() == nanos, "Error Invalid Nanos value"); 490 } 491 492 /* 493 * Validate that a Timestamp made from a LocalDateTime are equal 494 */ 495 @Test 496 public void test42() throws Exception { 497 Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); 498 LocalDateTime ldt = ts1.toLocalDateTime(); 499 Timestamp ts2 = Timestamp.valueOf(ldt); 500 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 501 } 502 503 /* 504 * Validate that a Timestamp LocalDateTime value, made from a LocalDateTime 505 * are equal 506 */ 507 @Test 508 public void test43() throws Exception { 509 LocalDateTime ldt = LocalDateTime.now(); 510 Timestamp ts2 = Timestamp.valueOf(ldt); 511 assertTrue(ldt.equals(ts2.toLocalDateTime()), 512 "Error LocalDateTime values are not equal"); 513 } 514 515 /* 516 * Validate an NPE occurs when a null LocalDateTime is passed to valueOF 517 */ 518 @Test(expectedExceptions = NullPointerException.class) 519 public void test44() throws Exception { 520 LocalDateTime ldt = null; 521 Timestamp.valueOf(ldt); 522 } 523 524 /* 525 * Validate that a Timestamp made from a Instant are equal 526 */ 527 @Test 528 public void test45() throws Exception { 529 Timestamp ts1 = Timestamp.valueOf("1961-08-30 00:00:00"); 530 Instant instant = ts1.toInstant(); 531 Timestamp ts2 = Timestamp.from(instant); 532 assertTrue(ts1.equals(ts2), "Error ts1 != ts2"); 533 } 534 535 /* 536 * Validate that a Timestamp made from a Instant are equal 537 */ 538 @Test 539 public void test46() throws Exception { 540 Instant instant = Instant.now(); 541 Timestamp ts2 = Timestamp.from(instant); 542 assertTrue(instant.equals(ts2.toInstant()), 543 "Error Instant values do not match"); 544 } 545 546 /* 547 * Validate an NPE occurs when a null instant is passed to from 548 */ 549 @Test(expectedExceptions = NullPointerException.class) 550 public void test47() throws Exception { 551 Instant instant = null; 552 Timestamp.from(instant); 553 } 554 555 // Added SQE tests 556 /* 557 * Create a Timestamp and a 2nd Timestamp that is 1 month earlier and 558 * validate that it is not before or after the original Timestamp 559 */ 560 @Test 561 public void test48() { 562 Calendar cal = Calendar.getInstance(); 563 Timestamp ts1 = new Timestamp(System.currentTimeMillis()); 564 cal.setTimeInMillis(ts1.getTime()); 565 cal.add(Calendar.MONTH, -1); 566 cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); 567 Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); 568 assertFalse(ts1.before(ts2) || ts2.after(ts1)); 569 } 570 571 /* 572 * Create two Timestamps and validate that compareTo returns 1 to indicate 573 * the 1st Timestamp is greater than the 2nd Timestamp 574 */ 575 @Test 576 public void test49() { 577 Calendar cal = Calendar.getInstance(); 578 Timestamp ts1 = new Timestamp(System.currentTimeMillis()); 579 cal.setTimeInMillis(ts1.getTime()); 580 cal.add(Calendar.MONTH, -1); 581 cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); 582 Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); 583 assertTrue(ts1.compareTo(ts2) == 1); 584 } 585 586 /* 587 * Create two Timestamps and validate that the 1st Timestamp is not equal to 588 * the 2nd Timestamp but equal to itself 589 */ 590 @Test 591 public void test50() { 592 Calendar cal = Calendar.getInstance(); 593 Timestamp ts1 = new Timestamp(System.currentTimeMillis()); 594 cal.setTimeInMillis(ts1.getTime()); 595 cal.add(Calendar.MONTH, -1); 596 cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH)); 597 Timestamp ts2 = new Timestamp(cal.getTimeInMillis()); 598 assertTrue(!ts1.equals(ts2) && ts1.equals(ts1)); 599 } 600 601 /* 602 * Validate that two Timestamps are equal when one is created from the 603 * toString() of the other 604 */ 605 @Test(dataProvider = "validateNanos") 606 public void test51(String ts, int nanos) { 607 Timestamp ts1 = Timestamp.valueOf(ts); 608 Timestamp ts2 = Timestamp.valueOf(ts1.toString()); 609 assertTrue(ts1.getNanos() == nanos && ts1.equals(ts2), 610 "Error with Nanos"); 611 } 612 613 /* 614 * DataProvider used to provide Timestamps which are not valid and are used 615 * to validate that an IllegalArgumentException will be thrown from the 616 * valueOf method 617 */ 618 @DataProvider(name = "invalidTimestampValues") 619 private Object[][] invalidTimestampValues() { 620 return new Object[][]{ 621 {"2009-11-01-01 10:50:01"}, 622 {"aaaa-11-01-01 10:50"}, 623 {"aaaa-11-01 10:50"}, 624 {"1961--30 00:00:00"}, 625 {"--30 00:00:00"}, 626 {"-- 00:00:00"}, 627 {"1961-1- 00:00:00"}, 628 {"2009-11-01"}, 629 {"10:50:01"}, 630 {"1961-a-30 00:00:00"}, 631 {"1961-01-bb 00:00:00"}, 632 {"1961-08-30 00:00:00."}, 633 {"1961-08-30 :00:00"}, 634 {"1961-08-30 00::00"}, 635 {"1961-08-30 00:00:"}, 636 {"1961-08-30 ::"}, 637 {"1961-08-30 0a:00:00"}, 638 {"1961-08-30 00:bb:00"}, 639 {"1961-08-30 00:01:cc"}, 640 {"1961-08-30 00:00:00.01a"}, 641 {"1961-08-30 00:00:00.a"}, 642 {"1996-12-10 12:26:19.1234567890"}, 643 {null} 644 }; 645 } 646 647 /* 648 * DataProvider used to provide Timestamps which are valid and are used 649 * to validate that an IllegalArgumentException will not be thrown from the 650 * valueOf method and the corect value from toString() is returned 651 */ 652 @DataProvider(name = "validTimestampValues") 653 private Object[][] validTimestampValues() { 654 return new Object[][]{ 655 {"1961-08-30 00:00:00", "1961-08-30 00:00:00.0"}, 656 {"1961-08-30 11:22:33", "1961-08-30 11:22:33.0"}, 657 {"1961-8-30 00:00:00", "1961-08-30 00:00:00.0"}, 658 {"1966-08-1 00:00:00", "1966-08-01 00:00:00.0"}, 659 {"1996-12-10 12:26:19.1", "1996-12-10 12:26:19.1"}, 660 {"1996-12-10 12:26:19.12", "1996-12-10 12:26:19.12"}, 661 {"1996-12-10 12:26:19.123", "1996-12-10 12:26:19.123"}, 662 {"1996-12-10 12:26:19.1234", "1996-12-10 12:26:19.1234"}, 663 {"1996-12-10 12:26:19.12345", "1996-12-10 12:26:19.12345"}, 664 {"1996-12-10 12:26:19.123456", "1996-12-10 12:26:19.123456"}, 665 {"1996-12-10 12:26:19.1234567", "1996-12-10 12:26:19.1234567"}, 666 {"1996-12-10 12:26:19.12345678", "1996-12-10 12:26:19.12345678"}, 667 {"1996-12-10 12:26:19.123456789", "1996-12-10 12:26:19.123456789"}, 668 {"1996-12-10 12:26:19.000000001", "1996-12-10 12:26:19.000000001"}, 669 {"1996-12-10 12:26:19.000000012", "1996-12-10 12:26:19.000000012"}, 670 {"1996-12-10 12:26:19.000000123", "1996-12-10 12:26:19.000000123"}, 671 {"1996-12-10 12:26:19.000001234", "1996-12-10 12:26:19.000001234"}, 672 {"1996-12-10 12:26:19.000012345", "1996-12-10 12:26:19.000012345"}, 673 {"1996-12-10 12:26:19.000123456", "1996-12-10 12:26:19.000123456"}, 674 {"1996-12-10 12:26:19.001234567", "1996-12-10 12:26:19.001234567"}, 675 {"1996-12-10 12:26:19.12345678", "1996-12-10 12:26:19.12345678"}, 676 {"1996-12-10 12:26:19.0", "1996-12-10 12:26:19.0"}, 677 {"1996-12-10 12:26:19.01230", "1996-12-10 12:26:19.0123"} 678 }; 679 } 680 681 /* 682 * DataProvider used to provide Timestamp and Nanos values in order to 683 * validate that the correct Nanos value is generated from the specified 684 * Timestamp 685 */ 686 @DataProvider(name = "validateNanos") 687 private Object[][] validateNanos() { 688 return new Object[][]{ 689 {"1961-08-30 00:00:00", 0}, 690 {"1996-12-10 12:26:19.1", 100000000}, 691 {"1996-12-10 12:26:19.12", 120000000}, 692 {"1996-12-10 12:26:19.123", 123000000}, 693 {"1996-12-10 12:26:19.1234", 123400000}, 694 {"1996-12-10 12:26:19.12345", 123450000}, 695 {"1996-12-10 12:26:19.123456", 123456000}, 696 {"1996-12-10 12:26:19.1234567", 123456700}, 697 {"1996-12-10 12:26:19.12345678", 123456780}, 698 {"1996-12-10 12:26:19.123456789", 123456789}, 699 {"1996-12-10 12:26:19.000000001", 1}, 700 {"1996-12-10 12:26:19.000000012", 12}, 701 {"1996-12-10 12:26:19.000000123", 123}, 702 {"1996-12-10 12:26:19.000001234", 1234}, 703 {"1996-12-10 12:26:19.000012345", 12345}, 704 {"1996-12-10 12:26:19.000123456", 123456}, 705 {"1996-12-10 12:26:19.001234567", 1234567}, 706 {"1996-12-10 12:26:19.012345678", 12345678}, 707 {"1996-12-10 12:26:19.0", 0}, 708 {"1996-12-10 12:26:19.01230", 12300000} 709 }; 710 } 711 }