1 21 package net.sf.hajdbc.sql; 22 23 import java.io.ByteArrayInputStream ; 24 import java.io.File ; 25 import java.io.InputStream ; 26 import java.io.Reader ; 27 import java.io.StringReader ; 28 import java.math.BigDecimal ; 29 import java.net.MalformedURLException ; 30 import java.net.URL ; 31 import java.sql.Array ; 32 import java.sql.Blob ; 33 import java.sql.Clob ; 34 import java.sql.Date ; 35 import java.sql.Ref ; 36 import java.sql.ResultSetMetaData ; 37 import java.sql.SQLException ; 38 import java.sql.SQLWarning ; 39 import java.sql.Time ; 40 import java.sql.Timestamp ; 41 import java.sql.Types ; 42 import java.util.Calendar ; 43 import java.util.Collections ; 44 import java.util.List ; 45 import java.util.Map ; 46 import java.util.concurrent.ExecutorService ; 47 import java.util.concurrent.Executors ; 48 import java.util.concurrent.locks.Lock ; 49 50 import net.sf.hajdbc.Balancer; 51 import net.sf.hajdbc.Database; 52 import net.sf.hajdbc.DatabaseCluster; 53 import net.sf.hajdbc.MockDatabase; 54 import net.sf.hajdbc.Operation; 55 56 import org.easymock.EasyMock; 57 import org.easymock.IMocksControl; 58 import org.testng.annotations.AfterMethod; 59 import org.testng.annotations.BeforeClass; 60 import org.testng.annotations.Test; 61 62 66 @Test 67 public class TestResultSet 68 { 69 private IMocksControl control = EasyMock.createStrictControl(); 70 71 private DatabaseCluster databaseCluster = this.control.createMock(DatabaseCluster.class); 72 73 protected java.sql.Connection sqlConnection = this.control.createMock(java.sql.Connection .class); 74 75 protected java.sql.Statement sqlStatement = this.control.createMock(java.sql.Statement .class); 76 77 protected java.sql.ResultSet sqlResultSet = this.control.createMock(java.sql.ResultSet .class); 78 79 private Database database = new MockDatabase(); 80 81 private Balancer balancer = this.control.createMock(Balancer.class); 82 83 private FileSupport fileSupport = this.control.createMock(FileSupport.class); 84 85 private Lock lock = this.control.createMock(Lock .class); 86 87 private Statement statement; 88 private ResultSet resultSet; 89 private List <Database> databaseList = Collections.singletonList(this.database); 90 private ExecutorService executor = Executors.newSingleThreadExecutor(); 91 92 @BeforeClass 93 protected void setUp() throws Exception 94 { 95 Map map = Collections.singletonMap(this.database, new Object ()); 96 97 EasyMock.expect(this.databaseCluster.getConnectionFactoryMap()).andReturn(map); 98 99 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor); 100 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 101 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 102 103 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor); 104 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 105 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 106 107 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor); 108 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 109 this.lock.lock(); 110 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 111 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 112 this.lock.unlock(); 113 114 this.control.replay(); 115 116 ConnectionFactory<Object > connectionFactory = new ConnectionFactory<Object >(this.databaseCluster, Object .class); 117 118 Operation<Object , java.sql.Connection > operation = new Operation<Object , java.sql.Connection >() 119 { 120 public java.sql.Connection execute(Database database, Object sqlObject) throws SQLException 121 { 122 return TestResultSet.this.sqlConnection; 123 } 124 }; 125 126 Connection<Object > connection = new Connection<Object >(connectionFactory, operation, this.fileSupport); 127 128 Operation<java.sql.Connection , java.sql.Statement > connectionOperation = new Operation<java.sql.Connection , java.sql.Statement >() 129 { 130 public java.sql.Statement execute(Database database, java.sql.Connection connection) throws SQLException 131 { 132 return TestResultSet.this.sqlStatement; 133 } 134 }; 135 136 this.statement = new Statement(connection, connectionOperation); 137 138 Operation<java.sql.Statement , java.sql.ResultSet > statementOperation = new Operation<java.sql.Statement , java.sql.ResultSet >() 139 { 140 public java.sql.ResultSet execute(Database database, java.sql.Statement statement) throws SQLException 141 { 142 return TestResultSet.this.sqlResultSet; 143 } 144 }; 145 146 this.resultSet = new ResultSet(this.statement, statementOperation); 147 148 this.control.verify(); 149 this.control.reset(); 150 } 151 152 @AfterMethod 153 public void reset() 154 { 155 this.control.reset(); 156 } 157 158 161 public void testGetObject() 162 { 163 this.control.replay(); 164 165 Object resultSet = this.resultSet.getObject(this.database); 166 167 this.control.verify(); 168 169 assert resultSet == this.sqlResultSet; 170 } 171 172 175 public void testGetDatabaseCluster() 176 { 177 this.control.replay(); 178 179 DatabaseCluster databaseCluster = this.resultSet.getDatabaseCluster(); 180 181 this.control.verify(); 182 183 assert databaseCluster == this.databaseCluster; 184 } 185 186 189 public void testHandleException() 190 { 191 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 192 EasyMock.expect(this.balancer.first()).andReturn(this.database); 193 194 try 195 { 196 EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(true); 197 198 EasyMock.expect(this.databaseCluster.deactivate(this.database)).andReturn(false); 199 200 this.control.replay(); 201 202 this.resultSet.handleExceptions(Collections.singletonMap(this.database, new SQLException ())); 203 204 this.control.verify(); 205 } 206 catch (SQLException e) 207 { 208 assert false : e; 209 } 210 } 211 212 215 public void testAutoCommitOffHandleException() 216 { 217 SQLException exception = new SQLException (); 218 219 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 220 EasyMock.expect(this.balancer.first()).andReturn(this.database); 221 222 try 223 { 224 EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(false); 225 226 this.databaseCluster.handleFailure(this.database, exception); 227 228 this.control.replay(); 229 230 this.resultSet.handleExceptions(Collections.singletonMap(this.database, exception)); 231 232 this.control.verify(); 233 } 234 catch (SQLException e) 235 { 236 assert false : e; 237 } 238 } 239 240 243 public void testAbsolute() 244 { 245 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 246 247 this.lock.lock(); 248 249 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 250 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 251 252 try 253 { 254 EasyMock.expect(this.sqlResultSet.absolute(10)).andReturn(true); 255 256 this.lock.unlock(); 257 258 this.control.replay(); 259 260 boolean valid = this.resultSet.absolute(10); 261 262 this.control.verify(); 263 264 assert valid; 265 } 266 catch (SQLException e) 267 { 268 assert false : e; 269 } 270 } 271 272 275 public void testAfterLast() 276 { 277 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 278 279 this.lock.lock(); 280 281 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 282 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 283 284 try 285 { 286 this.sqlResultSet.afterLast(); 287 288 this.lock.unlock(); 289 290 this.control.replay(); 291 292 this.resultSet.afterLast(); 293 294 this.control.verify(); 295 } 296 catch (SQLException e) 297 { 298 assert false : e; 299 } 300 } 301 302 305 public void testBeforeFirst() 306 { 307 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 308 309 this.lock.lock(); 310 311 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 312 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 313 314 try 315 { 316 this.sqlResultSet.beforeFirst(); 317 318 this.lock.unlock(); 319 320 this.control.replay(); 321 322 this.resultSet.beforeFirst(); 323 324 this.control.verify(); 325 } 326 catch (SQLException e) 327 { 328 assert false : e; 329 } 330 } 331 332 335 public void testCancelRowUpdates() 336 { 337 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 338 339 this.lock.lock(); 340 341 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 342 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 343 344 try 345 { 346 this.sqlResultSet.cancelRowUpdates(); 347 348 this.lock.unlock(); 349 350 this.control.replay(); 351 352 this.resultSet.cancelRowUpdates(); 353 354 this.control.verify(); 355 } 356 catch (SQLException e) 357 { 358 assert false : e; 359 } 360 } 361 362 365 public void testClearWarnings() 366 { 367 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 368 369 this.lock.lock(); 370 371 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 372 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 373 374 try 375 { 376 this.sqlResultSet.clearWarnings(); 377 378 this.lock.unlock(); 379 380 this.control.replay(); 381 382 this.resultSet.clearWarnings(); 383 384 this.control.verify(); 385 } 386 catch (SQLException e) 387 { 388 assert false : e; 389 } 390 } 391 392 395 public void testClose() 396 { 397 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor); 398 399 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 400 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 401 402 try 403 { 404 this.sqlResultSet.close(); 405 406 this.control.replay(); 407 408 this.resultSet.close(); 409 410 this.control.verify(); 411 } 412 catch (SQLException e) 413 { 414 assert false : e; 415 } 416 } 417 418 421 public void testDeleteRow() 422 { 423 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor); 424 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 425 426 this.lock.lock(); 427 428 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 429 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 430 431 try 432 { 433 this.sqlResultSet.deleteRow(); 434 435 this.lock.unlock(); 436 437 this.control.replay(); 438 439 this.resultSet.deleteRow(); 440 441 this.control.verify(); 442 } 443 catch (SQLException e) 444 { 445 assert false : e; 446 } 447 } 448 449 452 public void testFindColumn() 453 { 454 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 455 EasyMock.expect(this.balancer.first()).andReturn(this.database); 456 457 try 458 { 459 EasyMock.expect(this.sqlResultSet.findColumn("test")).andReturn(1); 460 461 this.control.replay(); 462 463 int column = this.resultSet.findColumn("test"); 464 465 this.control.verify(); 466 467 assert column == 1 : column; 468 } 469 catch (SQLException e) 470 { 471 assert false : e; 472 } 473 } 474 475 478 public void testFirst() 479 { 480 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 481 EasyMock.expect(this.balancer.first()).andReturn(this.database); 482 483 try 484 { 485 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 486 487 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 488 489 this.lock.lock(); 490 491 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 492 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 493 494 EasyMock.expect(this.sqlResultSet.first()).andReturn(true); 495 496 this.lock.unlock(); 497 498 this.control.replay(); 499 500 boolean valid = this.resultSet.first(); 501 502 this.control.verify(); 503 504 assert valid; 505 } 506 catch (SQLException e) 507 { 508 assert false : e; 509 } 510 } 511 512 515 public void testGetArrayInt() 516 { 517 Array array = EasyMock.createMock(Array .class); 518 519 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 520 EasyMock.expect(this.balancer.first()).andReturn(this.database); 521 522 try 523 { 524 EasyMock.expect(this.sqlResultSet.getArray(1)).andReturn(array); 525 526 this.control.replay(); 527 528 Array value = this.resultSet.getArray(1); 529 530 this.control.verify(); 531 532 assert value == array; 533 } 534 catch (SQLException e) 535 { 536 assert false : e; 537 } 538 } 539 540 543 public void testGetArrayString() 544 { 545 Array array = EasyMock.createMock(Array .class); 546 547 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 548 EasyMock.expect(this.balancer.first()).andReturn(this.database); 549 550 try 551 { 552 EasyMock.expect(this.sqlResultSet.getArray("column")).andReturn(array); 553 554 this.control.replay(); 555 556 Array value = this.resultSet.getArray("column"); 557 558 this.control.verify(); 559 560 assert value == array; 561 } 562 catch (SQLException e) 563 { 564 assert false : e; 565 } 566 } 567 568 571 public void testGetAsciiStreamInt() 572 { 573 InputStream inputStream = new ByteArrayInputStream (new byte[0]); 574 575 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 576 EasyMock.expect(this.balancer.first()).andReturn(this.database); 577 578 try 579 { 580 EasyMock.expect(this.sqlResultSet.getAsciiStream(1)).andReturn(inputStream); 581 582 this.control.replay(); 583 584 InputStream value = this.resultSet.getAsciiStream(1); 585 586 this.control.verify(); 587 588 assert value == inputStream; 589 } 590 catch (SQLException e) 591 { 592 assert false : e; 593 } 594 } 595 596 599 public void testGetAsciiStreamString() 600 { 601 InputStream inputStream = new ByteArrayInputStream (new byte[0]); 602 603 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 604 EasyMock.expect(this.balancer.first()).andReturn(this.database); 605 606 try 607 { 608 EasyMock.expect(this.sqlResultSet.getAsciiStream("column")).andReturn(inputStream); 609 610 this.control.replay(); 611 612 InputStream value = this.resultSet.getAsciiStream("column"); 613 614 this.control.verify(); 615 616 assert value == inputStream; 617 } 618 catch (SQLException e) 619 { 620 assert false : e; 621 } 622 } 623 624 627 public void testGetBigDecimalInt() 628 { 629 BigDecimal decimal = new BigDecimal (1.0); 630 631 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 632 EasyMock.expect(this.balancer.first()).andReturn(this.database); 633 634 try 635 { 636 EasyMock.expect(this.sqlResultSet.getBigDecimal(1)).andReturn(decimal); 637 638 this.control.replay(); 639 640 BigDecimal value = this.resultSet.getBigDecimal(1); 641 642 this.control.verify(); 643 644 assert value == decimal; 645 } 646 catch (SQLException e) 647 { 648 assert false : e; 649 } 650 } 651 652 656 public void testGetBigDecimalIntInt() 657 { 658 BigDecimal decimal = new BigDecimal (1.0); 659 660 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 661 EasyMock.expect(this.balancer.first()).andReturn(this.database); 662 663 try 664 { 665 EasyMock.expect(this.sqlResultSet.getBigDecimal(1, 0)).andReturn(decimal); 666 667 this.control.replay(); 668 669 BigDecimal value = this.resultSet.getBigDecimal(1, 0); 670 671 this.control.verify(); 672 673 assert value == decimal; 674 } 675 catch (SQLException e) 676 { 677 assert false : e; 678 } 679 } 680 681 684 public void testGetBigDecimalString() 685 { 686 BigDecimal decimal = new BigDecimal (1.0); 687 688 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 689 EasyMock.expect(this.balancer.first()).andReturn(this.database); 690 691 try 692 { 693 EasyMock.expect(this.sqlResultSet.getBigDecimal("column")).andReturn(decimal); 694 695 this.control.replay(); 696 697 BigDecimal value = this.resultSet.getBigDecimal("column"); 698 699 this.control.verify(); 700 701 assert value == decimal; 702 } 703 catch (SQLException e) 704 { 705 assert false : e; 706 } 707 } 708 709 713 public void testGetBigDecimalStringInt() 714 { 715 BigDecimal decimal = new BigDecimal (1.0); 716 717 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 718 EasyMock.expect(this.balancer.first()).andReturn(this.database); 719 720 try 721 { 722 EasyMock.expect(this.sqlResultSet.getBigDecimal("column", 0)).andReturn(decimal); 723 724 this.control.replay(); 725 726 BigDecimal value = this.resultSet.getBigDecimal("column", 0); 727 728 this.control.verify(); 729 730 assert value == decimal; 731 } 732 catch (SQLException e) 733 { 734 assert false : e; 735 } 736 } 737 738 741 public void testGetBinaryStreamInt() 742 { 743 InputStream inputStream = new ByteArrayInputStream (new byte[0]); 744 745 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 746 EasyMock.expect(this.balancer.first()).andReturn(this.database); 747 748 try 749 { 750 EasyMock.expect(this.sqlResultSet.getBinaryStream(1)).andReturn(inputStream); 751 752 this.control.replay(); 753 754 InputStream value = this.resultSet.getBinaryStream(1); 755 756 this.control.verify(); 757 758 assert value == inputStream; 759 } 760 catch (SQLException e) 761 { 762 assert false : e; 763 } 764 } 765 766 769 public void testGetBinaryStreamString() 770 { 771 InputStream inputStream = new ByteArrayInputStream (new byte[0]); 772 773 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 774 EasyMock.expect(this.balancer.first()).andReturn(this.database); 775 776 try 777 { 778 EasyMock.expect(this.sqlResultSet.getBinaryStream("column")).andReturn(inputStream); 779 780 this.control.replay(); 781 782 InputStream value = this.resultSet.getBinaryStream("column"); 783 784 this.control.verify(); 785 786 assert value == inputStream; 787 } 788 catch (SQLException e) 789 { 790 assert false : e; 791 } 792 } 793 794 797 public void testGetBlobInt() 798 { 799 Blob blob = EasyMock.createMock(Blob .class); 800 801 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 802 EasyMock.expect(this.balancer.first()).andReturn(this.database); 803 804 try 805 { 806 EasyMock.expect(this.sqlResultSet.getBlob(1)).andReturn(blob); 807 808 this.control.replay(); 809 810 Blob value = this.resultSet.getBlob(1); 811 812 this.control.verify(); 813 814 assert value == blob; 815 } 816 catch (SQLException e) 817 { 818 assert false : e; 819 } 820 } 821 822 825 public void testGetBlobString() 826 { 827 Blob blob = EasyMock.createMock(Blob .class); 828 829 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 830 EasyMock.expect(this.balancer.first()).andReturn(this.database); 831 832 try 833 { 834 EasyMock.expect(this.sqlResultSet.getBlob("column")).andReturn(blob); 835 836 this.control.replay(); 837 838 Blob value = this.resultSet.getBlob("column"); 839 840 this.control.verify(); 841 842 assert value == blob; 843 } 844 catch (SQLException e) 845 { 846 assert false : e; 847 } 848 } 849 850 853 public void testGetBooleanInt() 854 { 855 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 856 EasyMock.expect(this.balancer.first()).andReturn(this.database); 857 858 try 859 { 860 EasyMock.expect(this.sqlResultSet.getBoolean(1)).andReturn(true); 861 862 this.control.replay(); 863 864 boolean value = this.resultSet.getBoolean(1); 865 866 this.control.verify(); 867 868 assert value; 869 } 870 catch (SQLException e) 871 { 872 assert false : e; 873 } 874 } 875 876 879 public void testGetBooleanString() 880 { 881 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 882 EasyMock.expect(this.balancer.first()).andReturn(this.database); 883 884 try 885 { 886 EasyMock.expect(this.sqlResultSet.getBoolean("column")).andReturn(true); 887 888 this.control.replay(); 889 890 boolean value = this.resultSet.getBoolean("column"); 891 892 this.control.verify(); 893 894 assert value; 895 } 896 catch (SQLException e) 897 { 898 assert false : e; 899 } 900 } 901 902 905 public void testGetByteInt() 906 { 907 byte b = 1; 908 909 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 910 EasyMock.expect(this.balancer.first()).andReturn(this.database); 911 912 try 913 { 914 EasyMock.expect(this.sqlResultSet.getByte(1)).andReturn(b); 915 916 this.control.replay(); 917 918 byte value = this.resultSet.getByte(1); 919 920 this.control.verify(); 921 922 assert value == b; 923 } 924 catch (SQLException e) 925 { 926 assert false : e; 927 } 928 } 929 930 933 public void testGetByteString() 934 { 935 byte b = 1; 936 937 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 938 EasyMock.expect(this.balancer.first()).andReturn(this.database); 939 940 try 941 { 942 EasyMock.expect(this.sqlResultSet.getByte("column")).andReturn(b); 943 944 this.control.replay(); 945 946 byte value = this.resultSet.getByte("column"); 947 948 this.control.verify(); 949 950 assert value == b; 951 } 952 catch (SQLException e) 953 { 954 assert false : e; 955 } 956 } 957 958 961 public void testGetBytesInt() 962 { 963 byte[] bytes = new byte[] { 1 }; 964 965 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 966 EasyMock.expect(this.balancer.first()).andReturn(this.database); 967 968 try 969 { 970 EasyMock.expect(this.sqlResultSet.getBytes(1)).andReturn(bytes); 971 972 this.control.replay(); 973 974 byte[] value = this.resultSet.getBytes(1); 975 976 this.control.verify(); 977 978 assert value == bytes; 979 } 980 catch (SQLException e) 981 { 982 assert false : e; 983 } 984 } 985 986 989 public void testGetBytesString() 990 { 991 byte[] bytes = new byte[] { 1 }; 992 993 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 994 EasyMock.expect(this.balancer.first()).andReturn(this.database); 995 996 try 997 { 998 EasyMock.expect(this.sqlResultSet.getBytes("column")).andReturn(bytes); 999 1000 this.control.replay(); 1001 1002 byte[] value = this.resultSet.getBytes("column"); 1003 1004 this.control.verify(); 1005 1006 assert value == bytes; 1007 } 1008 catch (SQLException e) 1009 { 1010 assert false : e; 1011 } 1012 } 1013 1014 1017 public void testGetCharacterStreamInt() 1018 { 1019 Reader reader = new StringReader (""); 1020 1021 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1022 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1023 1024 try 1025 { 1026 EasyMock.expect(this.sqlResultSet.getCharacterStream(1)).andReturn(reader); 1027 1028 this.control.replay(); 1029 1030 Reader value = this.resultSet.getCharacterStream(1); 1031 1032 this.control.verify(); 1033 1034 assert value == reader; 1035 } 1036 catch (SQLException e) 1037 { 1038 assert false : e; 1039 } 1040 } 1041 1042 1045 public void testGetCharacterStreamString() 1046 { 1047 Reader reader = new StringReader (""); 1048 1049 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1050 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1051 1052 try 1053 { 1054 EasyMock.expect(this.sqlResultSet.getCharacterStream("column")).andReturn(reader); 1055 1056 this.control.replay(); 1057 1058 Reader value = this.resultSet.getCharacterStream("column"); 1059 1060 this.control.verify(); 1061 1062 assert value == reader; 1063 } 1064 catch (SQLException e) 1065 { 1066 assert false : e; 1067 } 1068 } 1069 1070 1073 public void testGetClobInt() 1074 { 1075 Clob clob = EasyMock.createMock(Clob .class); 1076 1077 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1078 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1079 1080 try 1081 { 1082 EasyMock.expect(this.sqlResultSet.getClob(1)).andReturn(clob); 1083 1084 this.control.replay(); 1085 1086 Clob value = this.resultSet.getClob(1); 1087 1088 this.control.verify(); 1089 1090 assert value == clob; 1091 } 1092 catch (SQLException e) 1093 { 1094 assert false : e; 1095 } 1096 } 1097 1098 1101 public void testGetClobString() 1102 { 1103 Clob clob = EasyMock.createMock(Clob .class); 1104 1105 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1106 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1107 1108 try 1109 { 1110 EasyMock.expect(this.sqlResultSet.getClob("column")).andReturn(clob); 1111 1112 this.control.replay(); 1113 1114 Clob value = this.resultSet.getClob("column"); 1115 1116 this.control.verify(); 1117 1118 assert value == clob; 1119 } 1120 catch (SQLException e) 1121 { 1122 assert false : e; 1123 } 1124 } 1125 1126 1129 public void testGetConcurrency() 1130 { 1131 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1132 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1133 1134 try 1135 { 1136 EasyMock.expect(this.sqlResultSet.getConcurrency()).andReturn(ResultSet.CONCUR_UPDATABLE); 1137 1138 this.control.replay(); 1139 1140 int concurrency = this.resultSet.getConcurrency(); 1141 1142 this.control.verify(); 1143 1144 assert concurrency == ResultSet.CONCUR_UPDATABLE : concurrency; 1145 } 1146 catch (SQLException e) 1147 { 1148 assert false : e; 1149 } 1150 } 1151 1152 1155 public void testGetCursorName() 1156 { 1157 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1158 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1159 1160 try 1161 { 1162 EasyMock.expect(this.sqlResultSet.getCursorName()).andReturn("test"); 1163 1164 this.control.replay(); 1165 1166 String cursor = this.resultSet.getCursorName(); 1167 1168 this.control.verify(); 1169 1170 assert cursor == "test"; 1171 } 1172 catch (SQLException e) 1173 { 1174 assert false : e; 1175 } 1176 } 1177 1178 1181 public void testGetDateInt() 1182 { 1183 Date date = new Date (System.currentTimeMillis()); 1184 1185 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1186 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1187 1188 try 1189 { 1190 EasyMock.expect(this.sqlResultSet.getDate(1)).andReturn(date); 1191 1192 this.control.replay(); 1193 1194 Date value = this.resultSet.getDate(1); 1195 1196 this.control.verify(); 1197 1198 assert value == date; 1199 } 1200 catch (SQLException e) 1201 { 1202 assert false : e; 1203 } 1204 } 1205 1206 1209 public void testGetDateIntCalendar() 1210 { 1211 Date date = new Date (System.currentTimeMillis()); 1212 Calendar calendar = Calendar.getInstance(); 1213 1214 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1215 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1216 1217 try 1218 { 1219 EasyMock.expect(this.sqlResultSet.getDate(1, calendar)).andReturn(date); 1220 1221 this.control.replay(); 1222 1223 Date value = this.resultSet.getDate(1, calendar); 1224 1225 this.control.verify(); 1226 1227 assert value == date; 1228 } 1229 catch (SQLException e) 1230 { 1231 assert false : e; 1232 } 1233 } 1234 1235 1238 public void testGetDateString() 1239 { 1240 Date date = new Date (System.currentTimeMillis()); 1241 1242 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1243 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1244 1245 try 1246 { 1247 EasyMock.expect(this.sqlResultSet.getDate("column")).andReturn(date); 1248 1249 this.control.replay(); 1250 1251 Date value = this.resultSet.getDate("column"); 1252 1253 this.control.verify(); 1254 1255 assert value == date; 1256 } 1257 catch (SQLException e) 1258 { 1259 assert false : e; 1260 } 1261 } 1262 1263 1266 public void testGetDateStringCalendar() 1267 { 1268 Date date = new Date (System.currentTimeMillis()); 1269 Calendar calendar = Calendar.getInstance(); 1270 1271 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1272 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1273 1274 try 1275 { 1276 EasyMock.expect(this.sqlResultSet.getDate("column", calendar)).andReturn(date); 1277 1278 this.control.replay(); 1279 1280 Date value = this.resultSet.getDate("column", calendar); 1281 1282 this.control.verify(); 1283 1284 assert value == date; 1285 } 1286 catch (SQLException e) 1287 { 1288 assert false : e; 1289 } 1290 } 1291 1292 1295 public void testGetDoubleInt() 1296 { 1297 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1298 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1299 1300 try 1301 { 1302 EasyMock.expect(this.sqlResultSet.getDouble(1)).andReturn(1.0); 1303 1304 this.control.replay(); 1305 1306 double value = this.resultSet.getDouble(1); 1307 1308 this.control.verify(); 1309 1310 assert value == 1.0; 1311 } 1312 catch (SQLException e) 1313 { 1314 assert false : e; 1315 } 1316 } 1317 1318 1321 public void testGetDoubleString() 1322 { 1323 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1324 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1325 1326 try 1327 { 1328 EasyMock.expect(this.sqlResultSet.getDouble("column")).andReturn(1.0); 1329 1330 this.control.replay(); 1331 1332 double value = this.resultSet.getDouble("column"); 1333 1334 this.control.verify(); 1335 1336 assert value == 1.0; 1337 } 1338 catch (SQLException e) 1339 { 1340 assert false : e; 1341 } 1342 } 1343 1344 1347 public void testGetFetchDirection() 1348 { 1349 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1350 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1351 1352 try 1353 { 1354 EasyMock.expect(this.sqlResultSet.getFetchDirection()).andReturn(ResultSet.FETCH_REVERSE); 1355 1356 this.control.replay(); 1357 1358 int direction = this.resultSet.getFetchDirection(); 1359 1360 this.control.verify(); 1361 1362 assert direction == ResultSet.FETCH_REVERSE : direction; 1363 } 1364 catch (SQLException e) 1365 { 1366 assert false : e; 1367 } 1368 } 1369 1370 1373 public void testGetFetchSize() 1374 { 1375 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1376 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1377 1378 try 1379 { 1380 EasyMock.expect(this.sqlResultSet.getFetchSize()).andReturn(100); 1381 1382 this.control.replay(); 1383 1384 int size = this.resultSet.getFetchSize(); 1385 1386 this.control.verify(); 1387 1388 assert size == 100 : size; 1389 } 1390 catch (SQLException e) 1391 { 1392 assert false : e; 1393 } 1394 } 1395 1396 1399 public void testGetFloatInt() 1400 { 1401 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1402 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1403 1404 try 1405 { 1406 EasyMock.expect(this.sqlResultSet.getFloat(1)).andReturn(1.0f); 1407 1408 this.control.replay(); 1409 1410 float value = this.resultSet.getFloat(1); 1411 1412 this.control.verify(); 1413 1414 assert value == 1.0f; 1415 } 1416 catch (SQLException e) 1417 { 1418 assert false : e; 1419 } 1420 } 1421 1422 1425 public void testGetFloatString() 1426 { 1427 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1428 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1429 1430 try 1431 { 1432 EasyMock.expect(this.sqlResultSet.getFloat("column")).andReturn(1.0f); 1433 1434 this.control.replay(); 1435 1436 float value = this.resultSet.getFloat("column"); 1437 1438 this.control.verify(); 1439 1440 assert value == 1.0f; 1441 } 1442 catch (SQLException e) 1443 { 1444 assert false : e; 1445 } 1446 } 1447 1448 1451 public void testGetIntInt() 1452 { 1453 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1454 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1455 1456 try 1457 { 1458 EasyMock.expect(this.sqlResultSet.getInt(1)).andReturn(1); 1459 1460 this.control.replay(); 1461 1462 int value = this.resultSet.getInt(1); 1463 1464 this.control.verify(); 1465 1466 assert value == 1; 1467 } 1468 catch (SQLException e) 1469 { 1470 assert false : e; 1471 } 1472 } 1473 1474 1477 public void testGetIntString() 1478 { 1479 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1480 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1481 1482 try 1483 { 1484 EasyMock.expect(this.sqlResultSet.getInt("column")).andReturn(1); 1485 1486 this.control.replay(); 1487 1488 int value = this.resultSet.getInt("column"); 1489 1490 this.control.verify(); 1491 1492 assert value == 1; 1493 } 1494 catch (SQLException e) 1495 { 1496 assert false : e; 1497 } 1498 } 1499 1500 1503 public void testGetLongInt() 1504 { 1505 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1506 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1507 1508 try 1509 { 1510 EasyMock.expect(this.sqlResultSet.getLong(1)).andReturn(100L); 1511 1512 this.control.replay(); 1513 1514 long value = this.resultSet.getLong(1); 1515 1516 this.control.verify(); 1517 1518 assert value == 100L; 1519 } 1520 catch (SQLException e) 1521 { 1522 assert false : e; 1523 } 1524 } 1525 1526 1529 public void testGetLongString() 1530 { 1531 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1532 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1533 1534 try 1535 { 1536 EasyMock.expect(this.sqlResultSet.getLong("column")).andReturn(100L); 1537 1538 this.control.replay(); 1539 1540 long value = this.resultSet.getLong("column"); 1541 1542 this.control.verify(); 1543 1544 assert value == 100L; 1545 } 1546 catch (SQLException e) 1547 { 1548 assert false : e; 1549 } 1550 } 1551 1552 1555 public void testGetMetaData() 1556 { 1557 ResultSetMetaData resultSetMetaData = EasyMock.createMock(ResultSetMetaData .class); 1558 1559 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1560 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1561 1562 try 1563 { 1564 EasyMock.expect(this.sqlResultSet.getMetaData()).andReturn(resultSetMetaData); 1565 1566 this.control.replay(); 1567 1568 ResultSetMetaData metaData = this.resultSet.getMetaData(); 1569 1570 this.control.verify(); 1571 1572 assert metaData == resultSetMetaData; 1573 } 1574 catch (SQLException e) 1575 { 1576 assert false : e; 1577 } 1578 } 1579 1580 1583 public void testGetObjectInt() 1584 { 1585 Object object = new Object (); 1586 1587 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1588 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1589 1590 try 1591 { 1592 EasyMock.expect(this.sqlResultSet.getObject(1)).andReturn(object); 1593 1594 this.control.replay(); 1595 1596 Object value = this.resultSet.getObject(1); 1597 1598 this.control.verify(); 1599 1600 assert value == object; 1601 } 1602 catch (SQLException e) 1603 { 1604 assert false : e; 1605 } 1606 } 1607 1608 1611 public void testGetObjectIntMap() 1612 { 1613 Object object = new Object (); 1614 1615 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1616 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1617 1618 try 1619 { 1620 EasyMock.expect(this.sqlResultSet.getObject(1, Collections.EMPTY_MAP)).andReturn(object); 1621 1622 this.control.replay(); 1623 1624 Object value = this.resultSet.getObject(1, Collections.EMPTY_MAP); 1625 1626 this.control.verify(); 1627 1628 assert value == object; 1629 } 1630 catch (SQLException e) 1631 { 1632 assert false : e; 1633 } 1634 } 1635 1636 1639 public void testGetObjectString() 1640 { 1641 Object object = new Object (); 1642 1643 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1644 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1645 1646 try 1647 { 1648 EasyMock.expect(this.sqlResultSet.getObject("column")).andReturn(object); 1649 1650 this.control.replay(); 1651 1652 Object value = this.resultSet.getObject("column"); 1653 1654 this.control.verify(); 1655 1656 assert value == object; 1657 } 1658 catch (SQLException e) 1659 { 1660 assert false : e; 1661 } 1662 } 1663 1664 1667 public void testGetObjectStringMap() 1668 { 1669 Object object = new Object (); 1670 1671 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1672 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1673 1674 try 1675 { 1676 EasyMock.expect(this.sqlResultSet.getObject("column", Collections.EMPTY_MAP)).andReturn(object); 1677 1678 this.control.replay(); 1679 1680 Object value = this.resultSet.getObject("column", Collections.EMPTY_MAP); 1681 1682 this.control.verify(); 1683 1684 assert value == object; 1685 } 1686 catch (SQLException e) 1687 { 1688 assert false : e; 1689 } 1690 } 1691 1692 1695 public void testGetRefInt() 1696 { 1697 Ref ref = EasyMock.createMock(Ref .class); 1698 1699 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1700 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1701 1702 try 1703 { 1704 EasyMock.expect(this.sqlResultSet.getRef(1)).andReturn(ref); 1705 1706 this.control.replay(); 1707 1708 Ref value = this.resultSet.getRef(1); 1709 1710 this.control.verify(); 1711 1712 assert value == ref; 1713 } 1714 catch (SQLException e) 1715 { 1716 assert false : e; 1717 } 1718 } 1719 1720 1723 public void testGetRefString() 1724 { 1725 Ref ref = EasyMock.createMock(Ref .class); 1726 1727 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1728 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1729 1730 try 1731 { 1732 EasyMock.expect(this.sqlResultSet.getRef("column")).andReturn(ref); 1733 1734 this.control.replay(); 1735 1736 Ref value = this.resultSet.getRef("column"); 1737 1738 this.control.verify(); 1739 1740 assert value == ref; 1741 } 1742 catch (SQLException e) 1743 { 1744 assert false : e; 1745 } 1746 } 1747 1748 1751 public void testGetRow() 1752 { 1753 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1754 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1755 1756 try 1757 { 1758 EasyMock.expect(this.sqlResultSet.getRow()).andReturn(10); 1759 1760 this.control.replay(); 1761 1762 int row = this.resultSet.getRow(); 1763 1764 this.control.verify(); 1765 1766 assert row == 10 : row; 1767 } 1768 catch (SQLException e) 1769 { 1770 assert false : e; 1771 } 1772 } 1773 1774 1777 public void testGetShortInt() 1778 { 1779 short s = Integer.valueOf(1).shortValue(); 1780 1781 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1782 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1783 1784 try 1785 { 1786 EasyMock.expect(this.sqlResultSet.getShort(1)).andReturn(s); 1787 1788 this.control.replay(); 1789 1790 short value = this.resultSet.getShort(1); 1791 1792 this.control.verify(); 1793 1794 assert value == s; 1795 } 1796 catch (SQLException e) 1797 { 1798 assert false : e; 1799 } 1800 } 1801 1802 1805 public void testGetShortString() 1806 { 1807 short s = Integer.valueOf(1).shortValue(); 1808 1809 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1810 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1811 1812 try 1813 { 1814 EasyMock.expect(this.sqlResultSet.getShort("column")).andReturn(s); 1815 1816 this.control.replay(); 1817 1818 short value = this.resultSet.getShort("column"); 1819 1820 this.control.verify(); 1821 1822 assert value == s; 1823 } 1824 catch (SQLException e) 1825 { 1826 assert false : e; 1827 } 1828 } 1829 1830 1833 public void testGetStatement() 1834 { 1835 java.sql.Statement statement = this.resultSet.getStatement(); 1836 1837 assert statement == this.statement; 1838 } 1839 1840 1843 public void testGetStringInt() 1844 { 1845 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1846 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1847 1848 try 1849 { 1850 EasyMock.expect(this.sqlResultSet.getString(1)).andReturn("test"); 1851 1852 this.control.replay(); 1853 1854 String value = this.resultSet.getString(1); 1855 1856 this.control.verify(); 1857 1858 assert value == "test"; 1859 } 1860 catch (SQLException e) 1861 { 1862 assert false : e; 1863 } 1864 } 1865 1866 1869 public void testGetStringString() 1870 { 1871 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1872 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1873 1874 try 1875 { 1876 EasyMock.expect(this.sqlResultSet.getString("column")).andReturn("test"); 1877 1878 this.control.replay(); 1879 1880 String value = this.resultSet.getString("column"); 1881 1882 this.control.verify(); 1883 1884 assert value == "test"; 1885 } 1886 catch (SQLException e) 1887 { 1888 assert false : e; 1889 } 1890 } 1891 1892 1895 public void testGetTimeInt() 1896 { 1897 Time time = new Time (System.currentTimeMillis()); 1898 1899 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1900 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1901 1902 try 1903 { 1904 EasyMock.expect(this.sqlResultSet.getTime(1)).andReturn(time); 1905 1906 this.control.replay(); 1907 1908 Time value = this.resultSet.getTime(1); 1909 1910 this.control.verify(); 1911 1912 assert value == time; 1913 } 1914 catch (SQLException e) 1915 { 1916 assert false : e; 1917 } 1918 } 1919 1920 1923 public void testGetTimeIntCalendar() 1924 { 1925 Time time = new Time (System.currentTimeMillis()); 1926 Calendar calendar = Calendar.getInstance(); 1927 1928 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1929 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1930 1931 try 1932 { 1933 EasyMock.expect(this.sqlResultSet.getTime(1, calendar)).andReturn(time); 1934 1935 this.control.replay(); 1936 1937 Time value = this.resultSet.getTime(1, calendar); 1938 1939 this.control.verify(); 1940 1941 assert value == time; 1942 } 1943 catch (SQLException e) 1944 { 1945 assert false : e; 1946 } 1947 } 1948 1949 1952 public void testGetTimeString() 1953 { 1954 Time time = new Time (System.currentTimeMillis()); 1955 1956 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1957 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1958 1959 try 1960 { 1961 EasyMock.expect(this.sqlResultSet.getTime("column")).andReturn(time); 1962 1963 this.control.replay(); 1964 1965 Time value = this.resultSet.getTime("column"); 1966 1967 this.control.verify(); 1968 1969 assert value == time; 1970 } 1971 catch (SQLException e) 1972 { 1973 assert false : e; 1974 } 1975 } 1976 1977 1980 public void testGetTimeStringCalendar() 1981 { 1982 Time time = new Time (System.currentTimeMillis()); 1983 Calendar calendar = Calendar.getInstance(); 1984 1985 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 1986 EasyMock.expect(this.balancer.first()).andReturn(this.database); 1987 1988 try 1989 { 1990 EasyMock.expect(this.sqlResultSet.getTime("column", calendar)).andReturn(time); 1991 1992 this.control.replay(); 1993 1994 Time value = this.resultSet.getTime("column", calendar); 1995 1996 this.control.verify(); 1997 1998 assert value == time; 1999 } 2000 catch (SQLException e) 2001 { 2002 assert false : e; 2003 } 2004 } 2005 2006 2009 public void testGetTimestampInt() 2010 { 2011 Timestamp timestamp = new Timestamp (System.currentTimeMillis()); 2012 2013 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2014 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2015 2016 try 2017 { 2018 EasyMock.expect(this.sqlResultSet.getTimestamp(1)).andReturn(timestamp); 2019 2020 this.control.replay(); 2021 2022 Timestamp value = this.resultSet.getTimestamp(1); 2023 2024 this.control.verify(); 2025 2026 assert value == timestamp; 2027 } 2028 catch (SQLException e) 2029 { 2030 assert false : e; 2031 } 2032 } 2033 2034 2037 public void testGetTimestampIntCalendar() 2038 { 2039 Timestamp timestamp = new Timestamp (System.currentTimeMillis()); 2040 Calendar calendar = Calendar.getInstance(); 2041 2042 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2043 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2044 2045 try 2046 { 2047 EasyMock.expect(this.sqlResultSet.getTimestamp(1, calendar)).andReturn(timestamp); 2048 2049 this.control.replay(); 2050 2051 Timestamp value = this.resultSet.getTimestamp(1, calendar); 2052 2053 this.control.verify(); 2054 2055 assert value == timestamp; 2056 } 2057 catch (SQLException e) 2058 { 2059 assert false : e; 2060 } 2061 } 2062 2063 2066 public void testGetTimestampString() 2067 { 2068 Timestamp timestamp = new Timestamp (System.currentTimeMillis()); 2069 2070 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2071 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2072 2073 try 2074 { 2075 EasyMock.expect(this.sqlResultSet.getTimestamp("column")).andReturn(timestamp); 2076 2077 this.control.replay(); 2078 2079 Timestamp value = this.resultSet.getTimestamp("column"); 2080 2081 this.control.verify(); 2082 2083 assert value == timestamp; 2084 } 2085 catch (SQLException e) 2086 { 2087 assert false : e; 2088 } 2089 } 2090 2091 2094 public void testGetTimestampStringCalendar() 2095 { 2096 Timestamp timestamp = new Timestamp (System.currentTimeMillis()); 2097 Calendar calendar = Calendar.getInstance(); 2098 2099 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2100 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2101 2102 try 2103 { 2104 EasyMock.expect(this.sqlResultSet.getTimestamp("column", calendar)).andReturn(timestamp); 2105 2106 this.control.replay(); 2107 2108 Timestamp value = this.resultSet.getTimestamp("column", calendar); 2109 2110 this.control.verify(); 2111 2112 assert value == timestamp; 2113 } 2114 catch (SQLException e) 2115 { 2116 assert false : e; 2117 } 2118 } 2119 2120 2123 public void testGetType() 2124 { 2125 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2126 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2127 2128 try 2129 { 2130 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_SCROLL_INSENSITIVE); 2131 2132 this.control.replay(); 2133 2134 int type = this.resultSet.getType(); 2135 2136 this.control.verify(); 2137 2138 assert type == ResultSet.TYPE_SCROLL_INSENSITIVE : type; 2139 } 2140 catch (SQLException e) 2141 { 2142 assert false : e; 2143 } 2144 } 2145 2146 2150 public void testGetUnicodeStreamInt() 2151 { 2152 InputStream inputStream = new ByteArrayInputStream (new byte[0]); 2153 2154 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2155 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2156 2157 try 2158 { 2159 EasyMock.expect(this.sqlResultSet.getUnicodeStream(1)).andReturn(inputStream); 2160 2161 this.control.replay(); 2162 2163 InputStream value = this.resultSet.getUnicodeStream(1); 2164 2165 this.control.verify(); 2166 2167 assert value == inputStream; 2168 } 2169 catch (SQLException e) 2170 { 2171 assert false : e; 2172 } 2173 } 2174 2175 2179 public void testGetUnicodeStreamString() 2180 { 2181 InputStream inputStream = new ByteArrayInputStream (new byte[0]); 2182 2183 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2184 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2185 2186 try 2187 { 2188 EasyMock.expect(this.sqlResultSet.getUnicodeStream("column")).andReturn(inputStream); 2189 2190 this.control.replay(); 2191 2192 InputStream value = this.resultSet.getUnicodeStream("column"); 2193 2194 this.control.verify(); 2195 2196 assert value == inputStream; 2197 } 2198 catch (SQLException e) 2199 { 2200 assert false : e; 2201 } 2202 } 2203 2204 2207 public void testGetURLInt() 2208 { 2209 try 2210 { 2211 URL url = new URL ("http://www.google.com"); 2212 2213 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2214 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2215 2216 EasyMock.expect(this.sqlResultSet.getURL(1)).andReturn(url); 2217 2218 this.control.replay(); 2219 2220 URL value = this.resultSet.getURL(1); 2221 2222 this.control.verify(); 2223 2224 assert value == url; 2225 } 2226 catch (SQLException e) 2227 { 2228 assert false : e; 2229 } 2230 catch (MalformedURLException e) 2231 { 2232 assert false : e; 2233 } 2234 } 2235 2236 2239 public void testGetURLString() 2240 { 2241 try 2242 { 2243 URL url = new URL ("http://www.google.com"); 2244 2245 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2246 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2247 2248 EasyMock.expect(this.sqlResultSet.getURL("column")).andReturn(url); 2249 2250 this.control.replay(); 2251 2252 URL value = this.resultSet.getURL("column"); 2253 2254 this.control.verify(); 2255 2256 assert value == url; 2257 } 2258 catch (SQLException e) 2259 { 2260 assert false : e; 2261 } 2262 catch (MalformedURLException e) 2263 { 2264 assert false : e; 2265 } 2266 } 2267 2268 2271 public void testGetWarnings() 2272 { 2273 SQLWarning warnings = new SQLWarning (); 2274 2275 try 2276 { 2277 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2278 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2279 2280 EasyMock.expect(this.sqlResultSet.getWarnings()).andReturn(warnings); 2281 2282 this.control.replay(); 2283 2284 SQLWarning value = this.resultSet.getWarnings(); 2285 2286 this.control.verify(); 2287 2288 assert value == warnings; 2289 } 2290 catch (SQLException e) 2291 { 2292 assert false : e; 2293 } 2294 } 2295 2296 2299 public void testInsertRow() 2300 { 2301 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor); 2302 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2303 2304 this.lock.lock(); 2305 2306 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2307 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2308 2309 try 2310 { 2311 this.sqlResultSet.insertRow(); 2312 2313 this.lock.unlock(); 2314 2315 this.control.replay(); 2316 2317 this.resultSet.insertRow(); 2318 2319 this.control.verify(); 2320 } 2321 catch (SQLException e) 2322 { 2323 assert false : e; 2324 } 2325 } 2326 2327 2330 public void testIsAfterLast() 2331 { 2332 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2333 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2334 2335 try 2336 { 2337 EasyMock.expect(this.sqlResultSet.isAfterLast()).andReturn(true); 2338 2339 this.control.replay(); 2340 2341 boolean afterLast = this.resultSet.isAfterLast(); 2342 2343 this.control.verify(); 2344 2345 assert afterLast; 2346 } 2347 catch (SQLException e) 2348 { 2349 assert false : e; 2350 } 2351 } 2352 2353 2356 public void testIsBeforeFirst() 2357 { 2358 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2359 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2360 2361 try 2362 { 2363 EasyMock.expect(this.sqlResultSet.isBeforeFirst()).andReturn(true); 2364 2365 this.control.replay(); 2366 2367 boolean beforeFirst = this.resultSet.isBeforeFirst(); 2368 2369 this.control.verify(); 2370 2371 assert beforeFirst; 2372 } 2373 catch (SQLException e) 2374 { 2375 assert false : e; 2376 } 2377 } 2378 2379 2382 public void testIsFirst() 2383 { 2384 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2385 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2386 2387 try 2388 { 2389 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 2390 2391 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2392 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2393 2394 EasyMock.expect(this.sqlResultSet.isFirst()).andReturn(true); 2395 2396 this.control.replay(); 2397 2398 boolean first = this.resultSet.isFirst(); 2399 2400 this.control.verify(); 2401 2402 assert first; 2403 } 2404 catch (SQLException e) 2405 { 2406 assert false : e; 2407 } 2408 } 2409 2410 2413 public void testScrollSensitiveIsFirst() 2414 { 2415 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2416 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2417 2418 try 2419 { 2420 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_SCROLL_SENSITIVE); 2421 2422 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2423 EasyMock.expect(this.balancer.next()).andReturn(this.database); 2424 2425 this.balancer.beforeOperation(this.database); 2426 2427 EasyMock.expect(this.sqlResultSet.isFirst()).andReturn(true); 2428 2429 this.balancer.afterOperation(this.database); 2430 2431 this.control.replay(); 2432 2433 boolean first = this.resultSet.isFirst(); 2434 2435 this.control.verify(); 2436 2437 assert first; 2438 } 2439 catch (SQLException e) 2440 { 2441 assert false : e; 2442 } 2443 } 2444 2445 2448 public void testIsLast() 2449 { 2450 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2451 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2452 2453 try 2454 { 2455 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 2456 2457 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2458 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2459 2460 EasyMock.expect(this.sqlResultSet.isLast()).andReturn(true); 2461 2462 this.control.replay(); 2463 2464 boolean last = this.resultSet.isLast(); 2465 2466 this.control.verify(); 2467 2468 assert last; 2469 } 2470 catch (SQLException e) 2471 { 2472 assert false : e; 2473 } 2474 } 2475 2476 2479 public void testScrollSensitiveIsLast() 2480 { 2481 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2482 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2483 2484 try 2485 { 2486 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_SCROLL_SENSITIVE); 2487 2488 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2489 EasyMock.expect(this.balancer.next()).andReturn(this.database); 2490 2491 this.balancer.beforeOperation(this.database); 2492 2493 EasyMock.expect(this.sqlResultSet.isLast()).andReturn(true); 2494 2495 this.balancer.afterOperation(this.database); 2496 2497 this.control.replay(); 2498 2499 boolean last = this.resultSet.isLast(); 2500 2501 this.control.verify(); 2502 2503 assert last; 2504 } 2505 catch (SQLException e) 2506 { 2507 assert false : e; 2508 } 2509 } 2510 2511 2514 public void testLast() 2515 { 2516 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2517 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2518 2519 try 2520 { 2521 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 2522 2523 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2524 2525 this.lock.lock(); 2526 2527 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2528 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2529 2530 EasyMock.expect(this.sqlResultSet.last()).andReturn(true); 2531 2532 this.lock.unlock(); 2533 2534 this.control.replay(); 2535 2536 boolean valid = this.resultSet.last(); 2537 2538 this.control.verify(); 2539 2540 assert valid; 2541 } 2542 catch (SQLException e) 2543 { 2544 assert false : e; 2545 } 2546 } 2547 2548 2551 public void testMoveToCurrentRow() 2552 { 2553 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2554 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2555 2556 try 2557 { 2558 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 2559 2560 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2561 2562 this.lock.lock(); 2563 2564 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2565 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2566 2567 this.sqlResultSet.moveToCurrentRow(); 2568 2569 this.lock.unlock(); 2570 2571 this.control.replay(); 2572 2573 this.resultSet.moveToCurrentRow(); 2574 2575 this.control.verify(); 2576 } 2577 catch (SQLException e) 2578 { 2579 assert false : e; 2580 } 2581 } 2582 2583 2586 public void testMoveToInsertRow() 2587 { 2588 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2589 2590 this.lock.lock(); 2591 2592 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2593 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2594 2595 try 2596 { 2597 this.sqlResultSet.moveToInsertRow(); 2598 2599 this.lock.unlock(); 2600 2601 this.control.replay(); 2602 2603 this.resultSet.moveToInsertRow(); 2604 2605 this.control.verify(); 2606 } 2607 catch (SQLException e) 2608 { 2609 assert false : e; 2610 } 2611 } 2612 2613 2616 public void testNext() 2617 { 2618 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2619 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2620 2621 try 2622 { 2623 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 2624 2625 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2626 2627 this.lock.lock(); 2628 2629 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2630 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2631 2632 EasyMock.expect(this.sqlResultSet.next()).andReturn(true); 2633 2634 this.lock.unlock(); 2635 2636 this.control.replay(); 2637 2638 boolean valid = this.resultSet.next(); 2639 2640 this.control.verify(); 2641 2642 assert valid; 2643 } 2644 catch (SQLException e) 2645 { 2646 assert false : e; 2647 } 2648 } 2649 2650 2653 public void testPrevious() 2654 { 2655 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2656 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2657 2658 try 2659 { 2660 EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY); 2661 2662 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2663 2664 this.lock.lock(); 2665 2666 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2667 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2668 2669 EasyMock.expect(this.sqlResultSet.previous()).andReturn(true); 2670 2671 this.lock.unlock(); 2672 2673 this.control.replay(); 2674 2675 boolean valid = this.resultSet.previous(); 2676 2677 this.control.verify(); 2678 2679 assert valid; 2680 } 2681 catch (SQLException e) 2682 { 2683 assert false : e; 2684 } 2685 } 2686 2687 2690 public void testRefreshRow() 2691 { 2692 EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor); 2693 2694 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2695 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2696 2697 try 2698 { 2699 this.sqlResultSet.refreshRow(); 2700 2701 this.control.replay(); 2702 2703 this.resultSet.refreshRow(); 2704 2705 this.control.verify(); 2706 } 2707 catch (SQLException e) 2708 { 2709 assert false : e; 2710 } 2711 } 2712 2713 2716 public void testRelative() 2717 { 2718 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2719 2720 this.lock.lock(); 2721 2722 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2723 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2724 2725 try 2726 { 2727 EasyMock.expect(this.sqlResultSet.relative(10)).andReturn(true); 2728 2729 this.lock.unlock(); 2730 2731 this.control.replay(); 2732 2733 boolean valid = this.resultSet.relative(10); 2734 2735 this.control.verify(); 2736 2737 assert valid; 2738 } 2739 catch (SQLException e) 2740 { 2741 assert false : e; 2742 } 2743 } 2744 2745 2748 public void testRowDeleted() 2749 { 2750 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2751 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2752 2753 try 2754 { 2755 EasyMock.expect(this.sqlResultSet.rowDeleted()).andReturn(true); 2756 2757 this.control.replay(); 2758 2759 boolean deleted = this.resultSet.rowDeleted(); 2760 2761 this.control.verify(); 2762 2763 assert deleted; 2764 } 2765 catch (SQLException e) 2766 { 2767 assert false : e; 2768 } 2769 } 2770 2771 2774 public void testRowInserted() 2775 { 2776 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2777 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2778 2779 try 2780 { 2781 EasyMock.expect(this.sqlResultSet.rowUpdated()).andReturn(true); 2782 2783 this.control.replay(); 2784 2785 boolean updated = this.resultSet.rowUpdated(); 2786 2787 this.control.verify(); 2788 2789 assert updated; 2790 } 2791 catch (SQLException e) 2792 { 2793 assert false : e; 2794 } 2795 } 2796 2797 2800 public void testRowUpdated() 2801 { 2802 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2803 EasyMock.expect(this.balancer.first()).andReturn(this.database); 2804 2805 try 2806 { 2807 EasyMock.expect(this.sqlResultSet.rowInserted()).andReturn(true); 2808 2809 this.control.replay(); 2810 2811 boolean inserted = this.resultSet.rowInserted(); 2812 2813 this.control.verify(); 2814 2815 assert inserted; 2816 } 2817 catch (SQLException e) 2818 { 2819 assert false : e; 2820 } 2821 } 2822 2823 2826 public void testSetFetchDirection() 2827 { 2828 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2829 2830 this.lock.lock(); 2831 2832 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2833 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2834 2835 try 2836 { 2837 this.sqlResultSet.setFetchDirection(ResultSet.FETCH_REVERSE); 2838 2839 this.lock.unlock(); 2840 2841 this.control.replay(); 2842 2843 this.resultSet.setFetchDirection(ResultSet.FETCH_REVERSE); 2844 2845 this.control.verify(); 2846 } 2847 catch (SQLException e) 2848 { 2849 assert false : e; 2850 } 2851 } 2852 2853 2856 public void testSetFetchSize() 2857 { 2858 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2859 2860 this.lock.lock(); 2861 2862 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2863 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2864 2865 try 2866 { 2867 this.sqlResultSet.setFetchSize(100); 2868 2869 this.lock.unlock(); 2870 2871 this.control.replay(); 2872 2873 this.resultSet.setFetchSize(100); 2874 2875 this.control.verify(); 2876 } 2877 catch (SQLException e) 2878 { 2879 assert false : e; 2880 } 2881 } 2882 2883 2886 public void testUpdateArrayIntArray() 2887 { 2888 Array array = EasyMock.createMock(Array .class); 2889 2890 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2891 2892 this.lock.lock(); 2893 2894 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2895 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2896 2897 try 2898 { 2899 this.sqlResultSet.updateArray(1, array); 2900 2901 this.lock.unlock(); 2902 2903 this.control.replay(); 2904 2905 this.resultSet.updateArray(1, array); 2906 2907 this.control.verify(); 2908 } 2909 catch (SQLException e) 2910 { 2911 assert false : e; 2912 } 2913 } 2914 2915 2918 public void testUpdateArrayStringArray() 2919 { 2920 Array array = EasyMock.createMock(Array .class); 2921 2922 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2923 2924 this.lock.lock(); 2925 2926 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2927 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2928 2929 try 2930 { 2931 this.sqlResultSet.updateArray("column", array); 2932 2933 this.lock.unlock(); 2934 2935 this.control.replay(); 2936 2937 this.resultSet.updateArray("column", array); 2938 2939 this.control.verify(); 2940 } 2941 catch (SQLException e) 2942 { 2943 assert false : e; 2944 } 2945 } 2946 2947 2950 public void testUpdateAsciiStreamIntInputStreamInt() 2951 { 2952 InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 }); 2953 File file = new File (""); 2954 2955 try 2956 { 2957 EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file); 2958 2959 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2960 2961 this.lock.lock(); 2962 2963 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 2964 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 2965 2966 EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream); 2967 2968 this.sqlResultSet.updateAsciiStream(1, inputStream, 100); 2969 2970 this.lock.unlock(); 2971 2972 this.control.replay(); 2973 2974 this.resultSet.updateAsciiStream(1, inputStream, 100); 2975 2976 this.control.verify(); 2977 } 2978 catch (SQLException e) 2979 { 2980 assert false : e; 2981 } 2982 } 2983 2984 2987 public void testUpdateAsciiStreamStringInputStreamInt() 2988 { 2989 InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 }); 2990 File file = new File (""); 2991 2992 try 2993 { 2994 EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file); 2995 2996 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 2997 2998 this.lock.lock(); 2999 3000 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3001 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3002 3003 EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream); 3004 3005 this.sqlResultSet.updateAsciiStream("column", inputStream, 100); 3006 3007 this.lock.unlock(); 3008 3009 this.control.replay(); 3010 3011 this.resultSet.updateAsciiStream("column", inputStream, 100); 3012 3013 this.control.verify(); 3014 } 3015 catch (SQLException e) 3016 { 3017 assert false : e; 3018 } 3019 } 3020 3021 3024 public void testUpdateBigDecimalIntBigDecimal() 3025 { 3026 BigDecimal decimal = new BigDecimal (1.0); 3027 3028 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3029 3030 this.lock.lock(); 3031 3032 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3033 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3034 3035 try 3036 { 3037 this.sqlResultSet.updateBigDecimal(1, decimal); 3038 3039 this.lock.unlock(); 3040 3041 this.control.replay(); 3042 3043 this.resultSet.updateBigDecimal(1, decimal); 3044 3045 this.control.verify(); 3046 } 3047 catch (SQLException e) 3048 { 3049 assert false : e; 3050 } 3051 } 3052 3053 3056 public void testUpdateBigDecimalStringBigDecimal() 3057 { 3058 BigDecimal decimal = new BigDecimal (1.0); 3059 3060 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3061 3062 this.lock.lock(); 3063 3064 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3065 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3066 3067 try 3068 { 3069 this.sqlResultSet.updateBigDecimal("column", decimal); 3070 3071 this.lock.unlock(); 3072 3073 this.control.replay(); 3074 3075 this.resultSet.updateBigDecimal("column", decimal); 3076 3077 this.control.verify(); 3078 } 3079 catch (SQLException e) 3080 { 3081 assert false : e; 3082 } 3083 } 3084 3085 3088 public void testUpdateBinaryStreamIntInputStreamInt() 3089 { 3090 InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 }); 3091 File file = new File (""); 3092 3093 try 3094 { 3095 EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file); 3096 3097 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3098 3099 this.lock.lock(); 3100 3101 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3102 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3103 3104 EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream); 3105 3106 this.sqlResultSet.updateBinaryStream(1, inputStream, 100); 3107 3108 this.lock.unlock(); 3109 3110 this.control.replay(); 3111 3112 this.resultSet.updateBinaryStream(1, inputStream, 100); 3113 3114 this.control.verify(); 3115 } 3116 catch (SQLException e) 3117 { 3118 assert false : e; 3119 } 3120 } 3121 3122 3125 public void testUpdateBinaryStreamStringInputStreamInt() 3126 { 3127 InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 }); 3128 File file = new File (""); 3129 3130 try 3131 { 3132 EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file); 3133 3134 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3135 3136 this.lock.lock(); 3137 3138 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3139 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3140 3141 EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream); 3142 3143 this.sqlResultSet.updateBinaryStream("column", inputStream, 100); 3144 3145 this.lock.unlock(); 3146 3147 this.control.replay(); 3148 3149 this.resultSet.updateBinaryStream("column", inputStream, 100); 3150 3151 this.control.verify(); 3152 } 3153 catch (SQLException e) 3154 { 3155 assert false : e; 3156 } 3157 } 3158 3159 3162 public void testUpdateBlobIntBlob() 3163 { 3164 Blob blob = EasyMock.createMock(Blob .class); 3165 File file = new File (""); 3166 3167 try 3168 { 3169 EasyMock.expect(this.fileSupport.createFile(blob)).andReturn(file); 3170 3171 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3172 3173 this.lock.lock(); 3174 3175 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3176 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3177 3178 EasyMock.expect(this.fileSupport.getBlob(file)).andReturn(blob); 3179 3180 this.sqlResultSet.updateBlob(1, blob); 3181 3182 this.lock.unlock(); 3183 3184 this.control.replay(); 3185 3186 this.resultSet.updateBlob(1, blob); 3187 3188 this.control.verify(); 3189 } 3190 catch (SQLException e) 3191 { 3192 assert false : e; 3193 } 3194 } 3195 3196 3199 public void testUpdateBlobStringBlob() 3200 { 3201 Blob blob = EasyMock.createMock(Blob .class); 3202 File file = new File (""); 3203 3204 try 3205 { 3206 EasyMock.expect(this.fileSupport.createFile(blob)).andReturn(file); 3207 3208 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3209 3210 this.lock.lock(); 3211 3212 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3213 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3214 3215 EasyMock.expect(this.fileSupport.getBlob(file)).andReturn(blob); 3216 3217 this.sqlResultSet.updateBlob("column", blob); 3218 3219 this.lock.unlock(); 3220 3221 this.control.replay(); 3222 3223 this.resultSet.updateBlob("column", blob); 3224 3225 this.control.verify(); 3226 } 3227 catch (SQLException e) 3228 { 3229 assert false : e; 3230 } 3231 } 3232 3233 3236 public void testUpdateBooleanIntBoolean() 3237 { 3238 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3239 3240 this.lock.lock(); 3241 3242 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3243 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3244 3245 try 3246 { 3247 this.sqlResultSet.updateBoolean(1, true); 3248 3249 this.lock.unlock(); 3250 3251 this.control.replay(); 3252 3253 this.resultSet.updateBoolean(1, true); 3254 3255 this.control.verify(); 3256 } 3257 catch (SQLException e) 3258 { 3259 assert false : e; 3260 } 3261 } 3262 3263 3266 public void testUpdateBooleanStringBoolean() 3267 { 3268 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3269 3270 this.lock.lock(); 3271 3272 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3273 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3274 3275 try 3276 { 3277 this.sqlResultSet.updateBoolean("column", true); 3278 3279 this.lock.unlock(); 3280 3281 this.control.replay(); 3282 3283 this.resultSet.updateBoolean("column", true); 3284 3285 this.control.verify(); 3286 } 3287 catch (SQLException e) 3288 { 3289 assert false : e; 3290 } 3291 } 3292 3293 3296 public void testUpdateByteIntByte() 3297 { 3298 byte value = 1; 3299 3300 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3301 3302 this.lock.lock(); 3303 3304 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3305 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3306 3307 try 3308 { 3309 this.sqlResultSet.updateByte(1, value); 3310 3311 this.lock.unlock(); 3312 3313 this.control.replay(); 3314 3315 this.resultSet.updateByte(1, value); 3316 3317 this.control.verify(); 3318 } 3319 catch (SQLException e) 3320 { 3321 assert false : e; 3322 } 3323 } 3324 3325 3328 public void testUpdateByteStringByte() 3329 { 3330 byte value = 1; 3331 3332 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3333 3334 this.lock.lock(); 3335 3336 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3337 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3338 3339 try 3340 { 3341 this.sqlResultSet.updateByte("column", value); 3342 3343 this.lock.unlock(); 3344 3345 this.control.replay(); 3346 3347 this.resultSet.updateByte("column", value); 3348 3349 this.control.verify(); 3350 } 3351 catch (SQLException e) 3352 { 3353 assert false : e; 3354 } 3355 } 3356 3357 3360 public void testUpdateBytesIntByteArray() 3361 { 3362 byte[] value = new byte[] { 1 }; 3363 3364 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3365 3366 this.lock.lock(); 3367 3368 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3369 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3370 3371 try 3372 { 3373 this.sqlResultSet.updateBytes(1, value); 3374 3375 this.lock.unlock(); 3376 3377 this.control.replay(); 3378 3379 this.resultSet.updateBytes(1, value); 3380 3381 this.control.verify(); 3382 } 3383 catch (SQLException e) 3384 { 3385 assert false : e; 3386 } 3387 } 3388 3389 3392 public void testUpdateBytesStringByteArray() 3393 { 3394 byte[] value = new byte[] { 1 }; 3395 3396 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3397 3398 this.lock.lock(); 3399 3400 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3401 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3402 3403 try 3404 { 3405 this.sqlResultSet.updateBytes("column", value); 3406 3407 this.lock.unlock(); 3408 3409 this.control.replay(); 3410 3411 this.resultSet.updateBytes("column", value); 3412 3413 this.control.verify(); 3414 } 3415 catch (SQLException e) 3416 { 3417 assert false : e; 3418 } 3419 } 3420 3421 3424 public void testUpdateCharacterStreamIntReaderInt() 3425 { 3426 Reader reader = new StringReader ("test"); 3427 File file = new File (""); 3428 3429 try 3430 { 3431 EasyMock.expect(this.fileSupport.createFile(reader)).andReturn(file); 3432 3433 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3434 3435 this.lock.lock(); 3436 3437 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3438 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3439 3440 EasyMock.expect(this.fileSupport.getReader(file)).andReturn(reader); 3441 3442 this.sqlResultSet.updateCharacterStream(1, reader, 100); 3443 3444 this.lock.unlock(); 3445 3446 this.control.replay(); 3447 3448 this.resultSet.updateCharacterStream(1, reader, 100); 3449 3450 this.control.verify(); 3451 } 3452 catch (SQLException e) 3453 { 3454 assert false : e; 3455 } 3456 } 3457 3458 3461 public void testUpdateCharacterStreamStringReaderInt() 3462 { 3463 Reader reader = new StringReader ("test"); 3464 File file = new File (""); 3465 3466 try 3467 { 3468 EasyMock.expect(this.fileSupport.createFile(reader)).andReturn(file); 3469 3470 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3471 3472 this.lock.lock(); 3473 3474 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3475 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3476 3477 EasyMock.expect(this.fileSupport.getReader(file)).andReturn(reader); 3478 3479 this.sqlResultSet.updateCharacterStream("column", reader, 100); 3480 3481 this.lock.unlock(); 3482 3483 this.control.replay(); 3484 3485 this.resultSet.updateCharacterStream("column", reader, 100); 3486 3487 this.control.verify(); 3488 } 3489 catch (SQLException e) 3490 { 3491 assert false : e; 3492 } 3493 } 3494 3495 3498 public void testUpdateClobIntClob() 3499 { 3500 Clob clob = EasyMock.createMock(Clob .class); 3501 File file = new File (""); 3502 3503 try 3504 { 3505 EasyMock.expect(this.fileSupport.createFile(clob)).andReturn(file); 3506 3507 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3508 3509 this.lock.lock(); 3510 3511 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3512 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3513 3514 EasyMock.expect(this.fileSupport.getClob(file)).andReturn(clob); 3515 3516 this.sqlResultSet.updateClob(1, clob); 3517 3518 this.lock.unlock(); 3519 3520 this.control.replay(); 3521 3522 this.resultSet.updateClob(1, clob); 3523 3524 this.control.verify(); 3525 } 3526 catch (SQLException e) 3527 { 3528 assert false : e; 3529 } 3530 } 3531 3532 3535 public void testUpdateClobStringClob() 3536 { 3537 Clob clob = EasyMock.createMock(Clob .class); 3538 File file = new File (""); 3539 3540 try 3541 { 3542 EasyMock.expect(this.fileSupport.createFile(clob)).andReturn(file); 3543 3544 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3545 3546 this.lock.lock(); 3547 3548 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3549 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3550 3551 EasyMock.expect(this.fileSupport.getClob(file)).andReturn(clob); 3552 3553 this.sqlResultSet.updateClob("column", clob); 3554 3555 this.lock.unlock(); 3556 3557 this.control.replay(); 3558 3559 this.resultSet.updateClob("column", clob); 3560 3561 this.control.verify(); 3562 } 3563 catch (SQLException e) 3564 { 3565 assert false : e; 3566 } 3567 } 3568 3569 3572 public void testUpdateDateIntDate() 3573 { 3574 Date date = new Date (System.currentTimeMillis()); 3575 3576 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3577 3578 this.lock.lock(); 3579 3580 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3581 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3582 3583 try 3584 { 3585 this.sqlResultSet.updateDate(1, date); 3586 3587 this.lock.unlock(); 3588 3589 this.control.replay(); 3590 3591 this.resultSet.updateDate(1, date); 3592 3593 this.control.verify(); 3594 } 3595 catch (SQLException e) 3596 { 3597 assert false : e; 3598 } 3599 } 3600 3601 3604 public void testUpdateDateStringDate() 3605 { 3606 Date date = new Date (System.currentTimeMillis()); 3607 3608 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3609 3610 this.lock.lock(); 3611 3612 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3613 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3614 3615 try 3616 { 3617 this.sqlResultSet.updateDate("column", date); 3618 3619 this.lock.unlock(); 3620 3621 this.control.replay(); 3622 3623 this.resultSet.updateDate("column", date); 3624 3625 this.control.verify(); 3626 } 3627 catch (SQLException e) 3628 { 3629 assert false : e; 3630 } 3631 } 3632 3633 3636 public void testUpdateDoubleIntDouble() 3637 { 3638 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3639 3640 this.lock.lock(); 3641 3642 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3643 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3644 3645 try 3646 { 3647 this.sqlResultSet.updateDouble(1, 1.1); 3648 3649 this.lock.unlock(); 3650 3651 this.control.replay(); 3652 3653 this.resultSet.updateDouble(1, 1.1); 3654 3655 this.control.verify(); 3656 } 3657 catch (SQLException e) 3658 { 3659 assert false : e; 3660 } 3661 } 3662 3663 3666 public void testUpdateDoubleStringDouble() 3667 { 3668 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3669 3670 this.lock.lock(); 3671 3672 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3673 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3674 3675 try 3676 { 3677 this.sqlResultSet.updateDouble("column", 1.1); 3678 3679 this.lock.unlock(); 3680 3681 this.control.replay(); 3682 3683 this.resultSet.updateDouble("column", 1.1); 3684 3685 this.control.verify(); 3686 } 3687 catch (SQLException e) 3688 { 3689 assert false : e; 3690 } 3691 } 3692 3693 3696 public void testUpdateFloatIntFloat() 3697 { 3698 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3699 3700 this.lock.lock(); 3701 3702 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3703 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3704 3705 try 3706 { 3707 this.sqlResultSet.updateFloat(1, 1.1f); 3708 3709 this.lock.unlock(); 3710 3711 this.control.replay(); 3712 3713 this.resultSet.updateFloat(1, 1.1f); 3714 3715 this.control.verify(); 3716 } 3717 catch (SQLException e) 3718 { 3719 assert false : e; 3720 } 3721 } 3722 3723 3726 public void testUpdateFloatStringFloat() 3727 { 3728 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3729 3730 this.lock.lock(); 3731 3732 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3733 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3734 3735 try 3736 { 3737 this.sqlResultSet.updateFloat("column", 1.1f); 3738 3739 this.lock.unlock(); 3740 3741 this.control.replay(); 3742 3743 this.resultSet.updateFloat("column", 1.1f); 3744 3745 this.control.verify(); 3746 } 3747 catch (SQLException e) 3748 { 3749 assert false : e; 3750 } 3751 } 3752 3753 3756 public void testUpdateIntIntInt() 3757 { 3758 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3759 3760 this.lock.lock(); 3761 3762 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3763 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3764 3765 try 3766 { 3767 this.sqlResultSet.updateInt(1, 1); 3768 3769 this.lock.unlock(); 3770 3771 this.control.replay(); 3772 3773 this.resultSet.updateInt(1, 1); 3774 3775 this.control.verify(); 3776 } 3777 catch (SQLException e) 3778 { 3779 assert false : e; 3780 } 3781 } 3782 3783 3786 public void testUpdateIntStringInt() 3787 { 3788 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3789 3790 this.lock.lock(); 3791 3792 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3793 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3794 3795 try 3796 { 3797 this.sqlResultSet.updateInt("column", 1);; 3798 3799 this.lock.unlock(); 3800 3801 this.control.replay(); 3802 3803 this.resultSet.updateInt("column", 1); 3804 3805 this.control.verify(); 3806 } 3807 catch (SQLException e) 3808 { 3809 assert false : e; 3810 } 3811 } 3812 3813 3816 public void testUpdateLongIntLong() 3817 { 3818 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3819 3820 this.lock.lock(); 3821 3822 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3823 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3824 3825 try 3826 { 3827 this.sqlResultSet.updateLong(1, 1); 3828 3829 this.lock.unlock(); 3830 3831 this.control.replay(); 3832 3833 this.resultSet.updateLong(1, 1); 3834 3835 this.control.verify(); 3836 } 3837 catch (SQLException e) 3838 { 3839 assert false : e; 3840 } 3841 } 3842 3843 3846 public void testUpdateLongStringLong() 3847 { 3848 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3849 3850 this.lock.lock(); 3851 3852 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3853 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3854 3855 try 3856 { 3857 this.sqlResultSet.updateLong("column", 1); 3858 3859 this.lock.unlock(); 3860 3861 this.control.replay(); 3862 3863 this.resultSet.updateLong("column", 1); 3864 3865 this.control.verify(); 3866 } 3867 catch (SQLException e) 3868 { 3869 assert false : e; 3870 } 3871 } 3872 3873 3876 public void testUpdateNullInt() 3877 { 3878 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3879 3880 this.lock.lock(); 3881 3882 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3883 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3884 3885 try 3886 { 3887 this.sqlResultSet.updateNull(1); 3888 3889 this.lock.unlock(); 3890 3891 this.control.replay(); 3892 3893 this.resultSet.updateNull(1); 3894 3895 this.control.verify(); 3896 } 3897 catch (SQLException e) 3898 { 3899 assert false : e; 3900 } 3901 } 3902 3903 3906 public void testUpdateNullString() 3907 { 3908 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3909 3910 this.lock.lock(); 3911 3912 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3913 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3914 3915 try 3916 { 3917 this.sqlResultSet.updateNull("column"); 3918 3919 this.lock.unlock(); 3920 3921 this.control.replay(); 3922 3923 this.resultSet.updateNull("column"); 3924 3925 this.control.verify(); 3926 } 3927 catch (SQLException e) 3928 { 3929 assert false : e; 3930 } 3931 } 3932 3933 3936 public void testUpdateObjectIntObject() 3937 { 3938 Object object = new Object (); 3939 3940 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3941 3942 this.lock.lock(); 3943 3944 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3945 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3946 3947 try 3948 { 3949 this.sqlResultSet.updateObject(1, object); 3950 3951 this.lock.unlock(); 3952 3953 this.control.replay(); 3954 3955 this.resultSet.updateObject(1, object); 3956 3957 this.control.verify(); 3958 } 3959 catch (SQLException e) 3960 { 3961 assert false : e; 3962 } 3963 } 3964 3965 3968 public void testUpdateObjectIntObjectInt() 3969 { 3970 Object object = new Object (); 3971 3972 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 3973 3974 this.lock.lock(); 3975 3976 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 3977 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 3978 3979 try 3980 { 3981 this.sqlResultSet.updateObject(1, object, Types.ARRAY); 3982 3983 this.lock.unlock(); 3984 3985 this.control.replay(); 3986 3987 this.resultSet.updateObject(1, object, Types.ARRAY); 3988 3989 this.control.verify(); 3990 } 3991 catch (SQLException e) 3992 { 3993 assert false : e; 3994 } 3995 } 3996 3997 4000 public void testUpdateObjectStringObject() 4001 { 4002 Object object = new Object (); 4003 4004 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4005 4006 this.lock.lock(); 4007 4008 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4009 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4010 4011 try 4012 { 4013 this.sqlResultSet.updateObject("column", object); 4014 4015 this.lock.unlock(); 4016 4017 this.control.replay(); 4018 4019 this.resultSet.updateObject("column", object); 4020 4021 this.control.verify(); 4022 } 4023 catch (SQLException e) 4024 { 4025 assert false : e; 4026 } 4027 } 4028 4029 4032 public void testUpdateObjectStringObjectInt() 4033 { 4034 Object object = new Object (); 4035 4036 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4037 4038 this.lock.lock(); 4039 4040 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4041 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4042 4043 try 4044 { 4045 this.sqlResultSet.updateObject("column", object, Types.ARRAY); 4046 4047 this.lock.unlock(); 4048 4049 this.control.replay(); 4050 4051 this.resultSet.updateObject("column", object, Types.ARRAY); 4052 4053 this.control.verify(); 4054 } 4055 catch (SQLException e) 4056 { 4057 assert false : e; 4058 } 4059 } 4060 4061 4064 public void testUpdateRefIntRef() 4065 { 4066 Ref ref = EasyMock.createMock(Ref .class); 4067 4068 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4069 4070 this.lock.lock(); 4071 4072 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4073 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4074 4075 try 4076 { 4077 this.sqlResultSet.updateObject(1, ref); 4078 4079 this.lock.unlock(); 4080 4081 this.control.replay(); 4082 4083 this.resultSet.updateObject(1, ref); 4084 4085 this.control.verify(); 4086 } 4087 catch (SQLException e) 4088 { 4089 assert false : e; 4090 } 4091 } 4092 4093 4096 public void testUpdateRefStringRef() 4097 { 4098 Ref ref = EasyMock.createMock(Ref .class); 4099 4100 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4101 4102 this.lock.lock(); 4103 4104 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4105 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4106 4107 try 4108 { 4109 this.sqlResultSet.updateObject("column", ref); 4110 4111 this.lock.unlock(); 4112 4113 this.control.replay(); 4114 4115 this.resultSet.updateObject("column", ref); 4116 4117 this.control.verify(); 4118 } 4119 catch (SQLException e) 4120 { 4121 assert false : e; 4122 } 4123 } 4124 4125 4128 public void testUpdateRow() 4129 { 4130 EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor); 4131 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4132 4133 this.lock.lock(); 4134 4135 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4136 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4137 4138 try 4139 { 4140 this.sqlResultSet.updateRow(); 4141 4142 this.lock.unlock(); 4143 4144 this.control.replay(); 4145 4146 this.resultSet.updateRow(); 4147 4148 this.control.verify(); 4149 } 4150 catch (SQLException e) 4151 { 4152 assert false : e; 4153 } 4154 } 4155 4156 4159 public void testUpdateShortIntShort() 4160 { 4161 short s = Integer.valueOf(1).shortValue(); 4162 4163 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4164 4165 this.lock.lock(); 4166 4167 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4168 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4169 4170 try 4171 { 4172 this.sqlResultSet.updateShort(1, s); 4173 4174 this.lock.unlock(); 4175 4176 this.control.replay(); 4177 4178 this.resultSet.updateShort(1, s); 4179 4180 this.control.verify(); 4181 } 4182 catch (SQLException e) 4183 { 4184 assert false : e; 4185 } 4186 } 4187 4188 4191 public void testUpdateShortStringShort() 4192 { 4193 short s = Integer.valueOf(1).shortValue(); 4194 4195 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4196 4197 this.lock.lock(); 4198 4199 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4200 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4201 4202 try 4203 { 4204 this.sqlResultSet.updateShort("column", s); 4205 4206 this.lock.unlock(); 4207 4208 this.control.replay(); 4209 4210 this.resultSet.updateShort("column", s); 4211 4212 this.control.verify(); 4213 } 4214 catch (SQLException e) 4215 { 4216 assert false : e; 4217 } 4218 } 4219 4220 4223 public void testUpdateStringIntString() 4224 { 4225 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4226 4227 this.lock.lock(); 4228 4229 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4230 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4231 4232 try 4233 { 4234 this.sqlResultSet.updateString(1, "test"); 4235 4236 this.lock.unlock(); 4237 4238 this.control.replay(); 4239 4240 this.resultSet.updateString(1, "test"); 4241 4242 this.control.verify(); 4243 } 4244 catch (SQLException e) 4245 { 4246 assert false : e; 4247 } 4248 } 4249 4250 4253 public void testUpdateStringStringString() 4254 { 4255 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4256 4257 this.lock.lock(); 4258 4259 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4260 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4261 4262 try 4263 { 4264 this.sqlResultSet.updateString("column", "test"); 4265 4266 this.lock.unlock(); 4267 4268 this.control.replay(); 4269 4270 this.resultSet.updateString("column", "test"); 4271 4272 this.control.verify(); 4273 } 4274 catch (SQLException e) 4275 { 4276 assert false : e; 4277 } 4278 } 4279 4280 4283 public void testUpdateTimeIntTime() 4284 { 4285 Time time = new Time (System.currentTimeMillis()); 4286 4287 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4288 4289 this.lock.lock(); 4290 4291 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4292 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4293 4294 try 4295 { 4296 this.sqlResultSet.updateTime(1, time); 4297 4298 this.lock.unlock(); 4299 4300 this.control.replay(); 4301 4302 this.resultSet.updateTime(1, time); 4303 4304 this.control.verify(); 4305 } 4306 catch (SQLException e) 4307 { 4308 assert false : e; 4309 } 4310 } 4311 4312 4315 public void testUpdateTimeStringTime() 4316 { 4317 Time time = new Time (System.currentTimeMillis()); 4318 4319 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4320 4321 this.lock.lock(); 4322 4323 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4324 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4325 4326 try 4327 { 4328 this.sqlResultSet.updateTime("column", time); 4329 4330 this.lock.unlock(); 4331 4332 this.control.replay(); 4333 4334 this.resultSet.updateTime("column", time); 4335 4336 this.control.verify(); 4337 } 4338 catch (SQLException e) 4339 { 4340 assert false : e; 4341 } 4342 } 4343 4344 4347 public void testUpdateTimestampIntTimestamp() 4348 { 4349 Timestamp timestamp = new Timestamp (System.currentTimeMillis()); 4350 4351 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4352 4353 this.lock.lock(); 4354 4355 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4356 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4357 4358 try 4359 { 4360 this.sqlResultSet.updateTimestamp(1, timestamp); 4361 4362 this.lock.unlock(); 4363 4364 this.control.replay(); 4365 4366 this.resultSet.updateTimestamp(1, timestamp); 4367 4368 this.control.verify(); 4369 } 4370 catch (SQLException e) 4371 { 4372 assert false : e; 4373 } 4374 } 4375 4376 4379 public void testUpdateTimestampStringTimestamp() 4380 { 4381 Timestamp timestamp = new Timestamp (System.currentTimeMillis()); 4382 4383 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock); 4384 4385 this.lock.lock(); 4386 4387 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4388 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList); 4389 4390 try 4391 { 4392 this.sqlResultSet.updateTimestamp("column", timestamp); 4393 4394 this.lock.unlock(); 4395 4396 this.control.replay(); 4397 4398 this.resultSet.updateTimestamp("column", timestamp); 4399 4400 this.control.verify(); 4401 } 4402 catch (SQLException e) 4403 { 4404 assert false : e; 4405 } 4406 } 4407 4408 4411 public void testWasNull() 4412 { 4413 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer); 4414 EasyMock.expect(this.balancer.first()).andReturn(this.database); 4415 4416 try 4417 { 4418 EasyMock.expect(this.sqlResultSet.wasNull()).andReturn(true); 4419 4420 this.control.replay(); 4421 4422 boolean wasNull = this.resultSet.wasNull(); 4423 4424 this.control.verify(); 4425 4426 assert wasNull; 4427 } 4428 catch (SQLException e) 4429 { 4430 assert false : e; 4431 } 4432 } 4433} 4434 | Popular Tags |