1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package tests.sql; 18 19 import dalvik.annotation.TestLevel; 20 import dalvik.annotation.TestTargetClass; 21 import dalvik.annotation.TestTargetNew; 22 23 import junit.framework.TestCase; 24 25 import java.io.InputStream; 26 import java.io.Reader; 27 import java.math.BigDecimal; 28 import java.net.URL; 29 import java.sql.CallableStatement; 30 import java.sql.Date; 31 import java.sql.Time; 32 import java.sql.Timestamp; 33 import java.util.Calendar; 34 import java.util.Map; 35 36 /** 37 * @author andrea (at) google.com (Your Name Here) 38 * 39 */ 40 @TestTargetClass(CallableStatement.class) 41 public class CallableStatementTest extends TestCase { 42 43 /** 44 * Test method for {@link java.sql.CallableStatement#getArray(int)}. 45 */ 46 @TestTargetNew( 47 level = TestLevel.NOT_FEASIBLE, 48 notes = "", 49 method = "getArray", 50 args = {int.class} 51 ) 52 public void testGetArrayInt() { 53 fail("Not yet implemented"); 54 } 55 56 /** 57 * Test method for {@link java.sql.CallableStatement#getArray(java.lang.String)}. 58 */ 59 @TestTargetNew( 60 level = TestLevel.NOT_FEASIBLE, 61 notes = "", 62 method = "getArray", 63 args = {String.class} 64 ) 65 public void testGetArrayString() { 66 fail("Not yet implemented"); 67 } 68 69 /** 70 * Test method for {@link java.sql.CallableStatement#getBigDecimal(int)}. 71 */ 72 @TestTargetNew( 73 level = TestLevel.NOT_FEASIBLE, 74 notes = "", 75 method = "getBigDecimal", 76 args = {int.class} 77 ) 78 public void testGetBigDecimalInt() { 79 fail("Not yet implemented"); 80 } 81 82 /** 83 * Test method for {@link java.sql.CallableStatement#getBigDecimal(int, int)}. 84 */ 85 @TestTargetNew( 86 level = TestLevel.NOT_FEASIBLE, 87 notes = "", 88 method = "getBigDecimal", 89 args = {int.class, int.class} 90 ) 91 public void testGetBigDecimalIntInt() { 92 fail("Not yet implemented"); 93 } 94 95 /** 96 * Test method for {@link java.sql.CallableStatement#getBigDecimal(java.lang.String)}. 97 */ 98 @TestTargetNew( 99 level = TestLevel.NOT_FEASIBLE, 100 notes = "", 101 method = "getBigDecimal", 102 args = {String.class} 103 ) 104 public void testGetBigDecimalString() { 105 fail("Not yet implemented"); 106 } 107 108 /** 109 * Test method for {@link java.sql.CallableStatement#getBlob(int)}. 110 */ 111 @TestTargetNew( 112 level = TestLevel.NOT_FEASIBLE, 113 notes = "", 114 method = "getBlob", 115 args = {int.class} 116 ) 117 public void testGetBlobInt() { 118 fail("Not yet implemented"); 119 } 120 121 /** 122 * Test method for {@link java.sql.CallableStatement#getBlob(java.lang.String)}. 123 */ 124 @TestTargetNew( 125 level = TestLevel.NOT_FEASIBLE, 126 notes = "", 127 method = "getBlob", 128 args = {String.class} 129 ) 130 public void testGetBlobString() { 131 fail("Not yet implemented"); 132 } 133 134 /** 135 * Test method for {@link java.sql.CallableStatement#getBoolean(int)}. 136 */ 137 @TestTargetNew( 138 level = TestLevel.NOT_FEASIBLE, 139 notes = "", 140 method = "getBoolean", 141 args = {int.class} 142 ) 143 public void testGetBooleanInt() { 144 fail("Not yet implemented"); 145 } 146 147 /** 148 * Test method for {@link java.sql.CallableStatement#getBoolean(java.lang.String)}. 149 */ 150 @TestTargetNew( 151 level = TestLevel.NOT_FEASIBLE, 152 notes = "", 153 method = "getBoolean", 154 args = {String.class} 155 ) 156 public void testGetBooleanString() { 157 fail("Not yet implemented"); 158 } 159 160 /** 161 * Test method for {@link java.sql.CallableStatement#getByte(int)}. 162 */ 163 @TestTargetNew( 164 level = TestLevel.NOT_FEASIBLE, 165 notes = "", 166 method = "getByte", 167 args = {int.class} 168 ) 169 public void testGetByteInt() { 170 fail("Not yet implemented"); 171 } 172 173 /** 174 * Test method for {@link java.sql.CallableStatement#getByte(java.lang.String)}. 175 */ 176 @TestTargetNew( 177 level = TestLevel.NOT_FEASIBLE, 178 notes = "", 179 method = "getByte", 180 args = {String.class} 181 ) 182 public void testGetByteString() { 183 fail("Not yet implemented"); 184 } 185 186 /** 187 * Test method for {@link java.sql.CallableStatement#getBytes(int)}. 188 */ 189 @TestTargetNew( 190 level = TestLevel.NOT_FEASIBLE, 191 notes = "", 192 method = "getBytes", 193 args = {int.class} 194 ) 195 public void testGetBytesInt() { 196 fail("Not yet implemented"); 197 } 198 199 /** 200 * Test method for {@link java.sql.CallableStatement#getBytes(java.lang.String)}. 201 */ 202 @TestTargetNew( 203 level = TestLevel.NOT_FEASIBLE, 204 notes = "", 205 method = "getBytes", 206 args = {String.class} 207 ) 208 public void testGetBytesString() { 209 fail("Not yet implemented"); 210 } 211 212 /** 213 * Test method for {@link java.sql.CallableStatement#getClob(int)}. 214 */ 215 @TestTargetNew( 216 level = TestLevel.NOT_FEASIBLE, 217 notes = "", 218 method = "getClob", 219 args = {int.class} 220 ) 221 public void testGetClobInt() { 222 fail("Not yet implemented"); 223 } 224 225 /** 226 * Test method for {@link java.sql.CallableStatement#getClob(java.lang.String)}. 227 */ 228 @TestTargetNew( 229 level = TestLevel.NOT_FEASIBLE, 230 notes = "", 231 method = "getClob", 232 args = {String.class} 233 ) 234 public void testGetClobString() { 235 fail("Not yet implemented"); 236 } 237 238 /** 239 * Test method for {@link java.sql.CallableStatement#getDate(int)}. 240 */ 241 @TestTargetNew( 242 level = TestLevel.NOT_FEASIBLE, 243 notes = "", 244 method = "getDate", 245 args = {int.class} 246 ) 247 public void testGetDateInt() { 248 fail("Not yet implemented"); 249 } 250 251 /** 252 * Test method for {@link java.sql.CallableStatement#getDate(int, java.util.Calendar)}. 253 */ 254 @TestTargetNew( 255 level = TestLevel.NOT_FEASIBLE, 256 notes = "", 257 method = "getDate", 258 args = {int.class, Calendar.class} 259 ) 260 public void testGetDateIntCalendar() { 261 fail("Not yet implemented"); 262 } 263 264 /** 265 * Test method for {@link java.sql.CallableStatement#getDate(java.lang.String)}. 266 */ 267 @TestTargetNew( 268 level = TestLevel.NOT_FEASIBLE, 269 notes = "", 270 method = "getDate", 271 args = {String.class} 272 ) 273 public void testGetDateString() { 274 fail("Not yet implemented"); 275 } 276 277 /** 278 * Test method for {@link java.sql.CallableStatement#getDate(java.lang.String, java.util.Calendar)}. 279 */ 280 @TestTargetNew( 281 level = TestLevel.NOT_FEASIBLE, 282 notes = "", 283 method = "getDate", 284 args = {String.class, Calendar.class} 285 ) 286 public void testGetDateStringCalendar() { 287 fail("Not yet implemented"); 288 } 289 290 /** 291 * Test method for {@link java.sql.CallableStatement#getDouble(int)}. 292 */ 293 @TestTargetNew( 294 level = TestLevel.NOT_FEASIBLE, 295 notes = "", 296 method = "getDouble", 297 args = {int.class} 298 ) 299 public void testGetDoubleInt() { 300 fail("Not yet implemented"); 301 } 302 303 /** 304 * Test method for {@link java.sql.CallableStatement#getDouble(java.lang.String)}. 305 */ 306 @TestTargetNew( 307 level = TestLevel.NOT_FEASIBLE, 308 notes = "", 309 method = "getDouble", 310 args = {String.class} 311 ) 312 public void testGetDoubleString() { 313 fail("Not yet implemented"); 314 } 315 316 /** 317 * Test method for {@link java.sql.CallableStatement#getFloat(int)}. 318 */ 319 @TestTargetNew( 320 level = TestLevel.NOT_FEASIBLE, 321 notes = "", 322 method = "getFloat", 323 args = {int.class} 324 ) 325 public void testGetFloatInt() { 326 fail("Not yet implemented"); 327 } 328 329 /** 330 * Test method for {@link java.sql.CallableStatement#getFloat(java.lang.String)}. 331 */ 332 @TestTargetNew( 333 level = TestLevel.NOT_FEASIBLE, 334 notes = "", 335 method = "getFloat", 336 args = {String.class} 337 ) 338 public void testGetFloatString() { 339 fail("Not yet implemented"); 340 } 341 342 /** 343 * Test method for {@link java.sql.CallableStatement#getInt(int)}. 344 */ 345 @TestTargetNew( 346 level = TestLevel.NOT_FEASIBLE, 347 notes = "", 348 method = "getInt", 349 args = {int.class} 350 ) 351 public void testGetIntInt() { 352 fail("Not yet implemented"); 353 } 354 355 /** 356 * Test method for {@link java.sql.CallableStatement#getInt(java.lang.String)}. 357 */ 358 @TestTargetNew( 359 level = TestLevel.NOT_FEASIBLE, 360 notes = "", 361 method = "getInt", 362 args = {String.class} 363 ) 364 public void testGetIntString() { 365 fail("Not yet implemented"); 366 } 367 368 /** 369 * Test method for {@link java.sql.CallableStatement#getLong(int)}. 370 */ 371 @TestTargetNew( 372 level = TestLevel.NOT_FEASIBLE, 373 notes = "", 374 method = "getLong", 375 args = {int.class} 376 ) 377 public void testGetLongInt() { 378 fail("Not yet implemented"); 379 } 380 381 /** 382 * Test method for {@link java.sql.CallableStatement#getLong(java.lang.String)}. 383 */ 384 @TestTargetNew( 385 level = TestLevel.NOT_FEASIBLE, 386 notes = "", 387 method = "getLong", 388 args = {String.class} 389 ) 390 public void testGetLongString() { 391 fail("Not yet implemented"); 392 } 393 394 /** 395 * Test method for {@link java.sql.CallableStatement#getObject(int)}. 396 */ 397 @TestTargetNew( 398 level = TestLevel.NOT_FEASIBLE, 399 notes = "", 400 method = "getObject", 401 args = {int.class} 402 ) 403 public void testGetObjectInt() { 404 fail("Not yet implemented"); 405 } 406 407 /** 408 * Test method for {@link java.sql.CallableStatement#getObject(int, java.util.Map)}. 409 */ 410 @TestTargetNew( 411 level = TestLevel.NOT_FEASIBLE, 412 notes = "", 413 method = "getObject", 414 args = {int.class, Map.class} 415 ) 416 public void testGetObjectIntMapOfStringClassOfQ() { 417 fail("Not yet implemented"); 418 } 419 420 /** 421 * Test method for {@link java.sql.CallableStatement#getObject(java.lang.String)}. 422 */ 423 @TestTargetNew( 424 level = TestLevel.NOT_FEASIBLE, 425 notes = "", 426 method = "getObject", 427 args = {String.class} 428 ) 429 public void testGetObjectString() { 430 fail("Not yet implemented"); 431 } 432 433 /** 434 * Test method for {@link java.sql.CallableStatement#getObject(java.lang.String, java.util.Map)}. 435 */ 436 @TestTargetNew( 437 level = TestLevel.NOT_FEASIBLE, 438 notes = "", 439 method = "getObject", 440 args = {String.class, Map.class} 441 ) 442 public void testGetObjectStringMapOfStringClassOfQ() { 443 fail("Not yet implemented"); 444 } 445 446 /** 447 * Test method for {@link java.sql.CallableStatement#getRef(int)}. 448 */ 449 @TestTargetNew( 450 level = TestLevel.NOT_FEASIBLE, 451 notes = "", 452 method = "getRef", 453 args = {int.class} 454 ) 455 public void testGetRefInt() { 456 fail("Not yet implemented"); 457 } 458 459 /** 460 * Test method for {@link java.sql.CallableStatement#getRef(java.lang.String)}. 461 */ 462 @TestTargetNew( 463 level = TestLevel.NOT_FEASIBLE, 464 notes = "", 465 method = "getRef", 466 args = {String.class} 467 ) 468 public void testGetRefString() { 469 fail("Not yet implemented"); 470 } 471 472 /** 473 * Test method for {@link java.sql.CallableStatement#getShort(int)}. 474 */ 475 @TestTargetNew( 476 level = TestLevel.NOT_FEASIBLE, 477 notes = "", 478 method = "getShort", 479 args = {int.class} 480 ) 481 public void testGetShortInt() { 482 fail("Not yet implemented"); 483 } 484 485 /** 486 * Test method for {@link java.sql.CallableStatement#getShort(java.lang.String)}. 487 */ 488 @TestTargetNew( 489 level = TestLevel.NOT_FEASIBLE, 490 notes = "", 491 method = "getShort", 492 args = {String.class} 493 ) 494 public void testGetShortString() { 495 fail("Not yet implemented"); 496 } 497 498 /** 499 * Test method for {@link java.sql.CallableStatement#getString(int)}. 500 */ 501 @TestTargetNew( 502 level = TestLevel.NOT_FEASIBLE, 503 notes = "", 504 method = "getString", 505 args = {int.class} 506 ) 507 public void testGetStringInt() { 508 fail("Not yet implemented"); 509 } 510 511 /** 512 * Test method for {@link java.sql.CallableStatement#getString(java.lang.String)}. 513 */ 514 @TestTargetNew( 515 level = TestLevel.NOT_FEASIBLE, 516 notes = "", 517 method = "getString", 518 args = {String.class} 519 ) 520 public void testGetStringString() { 521 fail("Not yet implemented"); 522 } 523 524 /** 525 * Test method for {@link java.sql.CallableStatement#getTime(int)}. 526 */ 527 @TestTargetNew( 528 level = TestLevel.NOT_FEASIBLE, 529 notes = "", 530 method = "getTime", 531 args = {int.class} 532 ) 533 public void testGetTimeInt() { 534 fail("Not yet implemented"); 535 } 536 537 /** 538 * Test method for {@link java.sql.CallableStatement#getTime(int, java.util.Calendar)}. 539 */ 540 @TestTargetNew( 541 level = TestLevel.NOT_FEASIBLE, 542 notes = "", 543 method = "getTime", 544 args = {int.class, Calendar.class} 545 ) 546 public void testGetTimeIntCalendar() { 547 fail("Not yet implemented"); 548 } 549 550 /** 551 * Test method for {@link java.sql.CallableStatement#getTime(java.lang.String)}. 552 */ 553 @TestTargetNew( 554 level = TestLevel.NOT_FEASIBLE, 555 notes = "", 556 method = "getTime", 557 args = {String.class} 558 ) 559 public void testGetTimeString() { 560 fail("Not yet implemented"); 561 } 562 563 /** 564 * Test method for {@link java.sql.CallableStatement#getTime(java.lang.String, java.util.Calendar)}. 565 */ 566 @TestTargetNew( 567 level = TestLevel.NOT_FEASIBLE, 568 notes = "", 569 method = "getTime", 570 args = {String.class, Calendar.class} 571 ) 572 public void testGetTimeStringCalendar() { 573 fail("Not yet implemented"); 574 } 575 576 /** 577 * Test method for {@link java.sql.CallableStatement#getTimestamp(int)}. 578 */ 579 @TestTargetNew( 580 level = TestLevel.NOT_FEASIBLE, 581 notes = "", 582 method = "getTimestamp", 583 args = {int.class} 584 ) 585 public void testGetTimestampInt() { 586 fail("Not yet implemented"); 587 } 588 589 /** 590 * Test method for {@link java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)}. 591 */ 592 @TestTargetNew( 593 level = TestLevel.NOT_FEASIBLE, 594 notes = "", 595 method = "getTimestamp", 596 args = {int.class, Calendar.class} 597 ) 598 public void testGetTimestampIntCalendar() { 599 fail("Not yet implemented"); 600 } 601 602 /** 603 * Test method for {@link java.sql.CallableStatement#getTimestamp(java.lang.String)}. 604 */ 605 @TestTargetNew( 606 level = TestLevel.NOT_FEASIBLE, 607 notes = "", 608 method = "getTimestamp", 609 args = {String.class} 610 ) 611 public void testGetTimestampString() { 612 fail("Not yet implemented"); 613 } 614 615 /** 616 * Test method for {@link java.sql.CallableStatement#getTimestamp(java.lang.String, java.util.Calendar)}. 617 */ 618 @TestTargetNew( 619 level = TestLevel.NOT_FEASIBLE, 620 notes = "", 621 method = "getTimestamp", 622 args = {String.class, Calendar.class} 623 ) 624 public void testGetTimestampStringCalendar() { 625 fail("Not yet implemented"); 626 } 627 628 /** 629 * Test method for {@link java.sql.CallableStatement#getURL(int)}. 630 */ 631 @TestTargetNew( 632 level = TestLevel.NOT_FEASIBLE, 633 notes = "", 634 method = "getURL", 635 args = {int.class} 636 ) 637 public void testGetURLInt() { 638 fail("Not yet implemented"); 639 } 640 641 /** 642 * Test method for {@link java.sql.CallableStatement#getURL(java.lang.String)}. 643 */ 644 @TestTargetNew( 645 level = TestLevel.NOT_FEASIBLE, 646 notes = "", 647 method = "getURL", 648 args = {String.class} 649 ) 650 public void testGetURLString() { 651 fail("Not yet implemented"); 652 } 653 654 /** 655 * Test method for {@link java.sql.CallableStatement#registerOutParameter(int, int)}. 656 */ 657 @TestTargetNew( 658 level = TestLevel.NOT_FEASIBLE, 659 notes = "", 660 method = "registerOutParameter", 661 args = {int.class, int.class} 662 ) 663 public void testRegisterOutParameterIntInt() { 664 fail("Not yet implemented"); 665 } 666 667 /** 668 * Test method for {@link java.sql.CallableStatement#registerOutParameter(int, int, int)}. 669 */ 670 @TestTargetNew( 671 level = TestLevel.NOT_FEASIBLE, 672 notes = "", 673 method = "registerOutParameter", 674 args = {int.class, int.class, int.class} 675 ) 676 public void testRegisterOutParameterIntIntInt() { 677 fail("Not yet implemented"); 678 } 679 680 /** 681 * Test method for {@link java.sql.CallableStatement#registerOutParameter(int, int, java.lang.String)}. 682 */ 683 @TestTargetNew( 684 level = TestLevel.NOT_FEASIBLE, 685 notes = "", 686 method = "registerOutParameter", 687 args = {int.class, int.class, String.class} 688 ) 689 public void testRegisterOutParameterIntIntString() { 690 fail("Not yet implemented"); 691 } 692 693 /** 694 * Test method for {@link java.sql.CallableStatement#registerOutParameter(java.lang.String, int)}. 695 */ 696 @TestTargetNew( 697 level = TestLevel.NOT_FEASIBLE, 698 notes = "", 699 method = "registerOutParameter", 700 args = {String.class, int.class} 701 ) 702 public void testRegisterOutParameterStringInt() { 703 fail("Not yet implemented"); 704 } 705 706 /** 707 * Test method for {@link java.sql.CallableStatement#registerOutParameter(java.lang.String, int, int)}. 708 */ 709 @TestTargetNew( 710 level = TestLevel.NOT_FEASIBLE, 711 notes = "", 712 method = "registerOutParameter", 713 args = {String.class, int.class, int.class} 714 ) 715 public void testRegisterOutParameterStringIntInt() { 716 fail("Not yet implemented"); 717 } 718 719 /** 720 * Test method for {@link java.sql.CallableStatement#registerOutParameter(java.lang.String, int, java.lang.String)}. 721 */ 722 @TestTargetNew( 723 level = TestLevel.NOT_FEASIBLE, 724 notes = "", 725 method = "registerOutParameter", 726 args = {String.class, int.class, String.class} 727 ) 728 public void testRegisterOutParameterStringIntString() { 729 fail("Not yet implemented"); 730 } 731 732 /** 733 * Test method for {@link java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream, int)}. 734 */ 735 @TestTargetNew( 736 level = TestLevel.NOT_FEASIBLE, 737 notes = "", 738 method = "setAsciiStream", 739 args = {String.class, InputStream.class, int.class} 740 ) 741 public void testSetAsciiStreamStringInputStreamInt() { 742 fail("Not yet implemented"); 743 } 744 745 /** 746 * Test method for {@link java.sql.CallableStatement#setBigDecimal(java.lang.String, java.math.BigDecimal)}. 747 */ 748 @TestTargetNew( 749 level = TestLevel.NOT_FEASIBLE, 750 notes = "", 751 method = "setBigDecimal", 752 args = {String.class, BigDecimal.class} 753 ) 754 public void testSetBigDecimalStringBigDecimal() { 755 fail("Not yet implemented"); 756 } 757 758 /** 759 * Test method for {@link java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream, int)}. 760 */ 761 @TestTargetNew( 762 level = TestLevel.NOT_FEASIBLE, 763 notes = "", 764 method = "setBinaryStream", 765 args = {String.class, InputStream.class, int.class} 766 ) 767 public void testSetBinaryStreamStringInputStreamInt() { 768 fail("Not yet implemented"); 769 } 770 771 /** 772 * Test method for {@link java.sql.CallableStatement#setBoolean(java.lang.String, boolean)}. 773 */ 774 @TestTargetNew( 775 level = TestLevel.NOT_FEASIBLE, 776 notes = "", 777 method = "setBoolean", 778 args = {String.class, boolean.class} 779 ) 780 public void testSetBooleanStringBoolean() { 781 fail("Not yet implemented"); 782 } 783 784 /** 785 * Test method for {@link java.sql.CallableStatement#setByte(java.lang.String, byte)}. 786 */ 787 @TestTargetNew( 788 level = TestLevel.NOT_FEASIBLE, 789 notes = "", 790 method = "setByte", 791 args = {String.class, byte.class} 792 ) 793 public void testSetByteStringByte() { 794 fail("Not yet implemented"); 795 } 796 797 /** 798 * Test method for {@link java.sql.CallableStatement#setBytes(java.lang.String, byte[])}. 799 */ 800 @TestTargetNew( 801 level = TestLevel.NOT_FEASIBLE, 802 notes = "", 803 method = "setBytes", 804 args = {String.class, byte[].class} 805 ) 806 public void testSetBytesStringByteArray() { 807 fail("Not yet implemented"); 808 } 809 810 /** 811 * Test method for {@link java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader, int)}. 812 */ 813 @TestTargetNew( 814 level = TestLevel.NOT_FEASIBLE, 815 notes = "", 816 method = "setCharacterStream", 817 args = {String.class, Reader.class, int.class} 818 ) 819 public void testSetCharacterStreamStringReaderInt() { 820 fail("Not yet implemented"); 821 } 822 823 /** 824 * Test method for {@link java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)}. 825 */ 826 @TestTargetNew( 827 level = TestLevel.NOT_FEASIBLE, 828 notes = "", 829 method = "setDate", 830 args = {String.class, Date.class} 831 ) 832 public void testSetDateStringDate() { 833 fail("Not yet implemented"); 834 } 835 836 /** 837 * Test method for {@link java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date, java.util.Calendar)}. 838 */ 839 @TestTargetNew( 840 level = TestLevel.NOT_FEASIBLE, 841 notes = "", 842 method = "setDate", 843 args = {String.class, Date.class, Calendar.class} 844 ) 845 public void testSetDateStringDateCalendar() { 846 fail("Not yet implemented"); 847 } 848 849 /** 850 * Test method for {@link java.sql.CallableStatement#setDouble(java.lang.String, double)}. 851 */ 852 @TestTargetNew( 853 level = TestLevel.NOT_FEASIBLE, 854 notes = "", 855 method = "setDouble", 856 args = {String.class, double.class} 857 ) 858 public void testSetDoubleStringDouble() { 859 fail("Not yet implemented"); 860 } 861 862 /** 863 * Test method for {@link java.sql.CallableStatement#setFloat(java.lang.String, float)}. 864 */ 865 @TestTargetNew( 866 level = TestLevel.NOT_FEASIBLE, 867 notes = "", 868 method = "setFloat", 869 args = {String.class, float.class} 870 ) 871 public void testSetFloatStringFloat() { 872 fail("Not yet implemented"); 873 } 874 875 /** 876 * Test method for {@link java.sql.CallableStatement#setInt(java.lang.String, int)}. 877 */ 878 @TestTargetNew( 879 level = TestLevel.NOT_FEASIBLE, 880 notes = "", 881 method = "setInt", 882 args = {String.class, int.class} 883 ) 884 public void testSetIntStringInt() { 885 fail("Not yet implemented"); 886 } 887 888 /** 889 * Test method for {@link java.sql.CallableStatement#setLong(java.lang.String, long)}. 890 */ 891 @TestTargetNew( 892 level = TestLevel.NOT_FEASIBLE, 893 notes = "", 894 method = "setLong", 895 args = {String.class, long.class} 896 ) 897 public void testSetLongStringLong() { 898 fail("Not yet implemented"); 899 } 900 901 /** 902 * Test method for {@link java.sql.CallableStatement#setNull(java.lang.String, int)}. 903 */ 904 @TestTargetNew( 905 level = TestLevel.NOT_FEASIBLE, 906 notes = "", 907 method = "setNull", 908 args = {String.class, int.class} 909 ) 910 public void testSetNullStringInt() { 911 fail("Not yet implemented"); 912 } 913 914 /** 915 * Test method for {@link java.sql.CallableStatement#setNull(java.lang.String, int, java.lang.String)}. 916 */ 917 @TestTargetNew( 918 level = TestLevel.NOT_FEASIBLE, 919 notes = "", 920 method = "setNull", 921 args = {String.class, int.class, String.class} 922 ) 923 public void testSetNullStringIntString() { 924 fail("Not yet implemented"); 925 } 926 927 /** 928 * Test method for {@link java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object)}. 929 */ 930 @TestTargetNew( 931 level = TestLevel.NOT_FEASIBLE, 932 notes = "", 933 method = "setObject", 934 args = {String.class, Object.class} 935 ) 936 public void testSetObjectStringObject() { 937 fail("Not yet implemented"); 938 } 939 940 /** 941 * Test method for {@link java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object, int)}. 942 */ 943 @TestTargetNew( 944 level = TestLevel.NOT_FEASIBLE, 945 notes = "", 946 method = "setObject", 947 args = {String.class, Object.class, int.class} 948 ) 949 public void testSetObjectStringObjectInt() { 950 fail("Not yet implemented"); 951 } 952 953 /** 954 * Test method for {@link java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object, int, int)}. 955 */ 956 @TestTargetNew( 957 level = TestLevel.NOT_FEASIBLE, 958 notes = "", 959 method = "setObject", 960 args = {String.class, Object.class, int.class, int.class} 961 ) 962 public void testSetObjectStringObjectIntInt() { 963 fail("Not yet implemented"); 964 } 965 966 /** 967 * Test method for {@link java.sql.CallableStatement#setShort(java.lang.String, short)}. 968 */ 969 @TestTargetNew( 970 level = TestLevel.NOT_FEASIBLE, 971 notes = "", 972 method = "setShort", 973 args = {String.class, short.class} 974 ) 975 public void testSetShortStringShort() { 976 fail("Not yet implemented"); 977 } 978 979 /** 980 * Test method for {@link java.sql.CallableStatement#setString(java.lang.String, java.lang.String)}. 981 */ 982 @TestTargetNew( 983 level = TestLevel.NOT_FEASIBLE, 984 notes = "", 985 method = "setString", 986 args = {String.class, String.class} 987 ) 988 public void testSetStringStringString() { 989 fail("Not yet implemented"); 990 } 991 992 /** 993 * Test method for {@link java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)}. 994 */ 995 @TestTargetNew( 996 level = TestLevel.NOT_FEASIBLE, 997 notes = "", 998 method = "setTime", 999 args = {String.class, Time.class} 1000 ) 1001 public void testSetTimeStringTime() { 1002 fail("Not yet implemented"); 1003 } 1004 1005 /** 1006 * Test method for {@link java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time, java.util.Calendar)}. 1007 */ 1008 @TestTargetNew( 1009 level = TestLevel.NOT_FEASIBLE, 1010 notes = "", 1011 method = "setTime", 1012 args = {String.class, Time.class, Calendar.class} 1013 ) 1014 public void testSetTimeStringTimeCalendar() { 1015 fail("Not yet implemented"); 1016 } 1017 1018 /** 1019 * Test method for {@link java.sql.CallableStatement#setTimestamp(java.lang.String, java.sql.Timestamp)}. 1020 */ 1021 @TestTargetNew( 1022 level = TestLevel.NOT_FEASIBLE, 1023 notes = "", 1024 method = "setTimestamp", 1025 args = {String.class, Timestamp.class} 1026 ) 1027 public void testSetTimestampStringTimestamp() { 1028 fail("Not yet implemented"); 1029 } 1030 1031 /** 1032 * Test method for {@link java.sql.CallableStatement#setTimestamp(java.lang.String, java.sql.Timestamp, java.util.Calendar)}. 1033 */ 1034 @TestTargetNew( 1035 level = TestLevel.NOT_FEASIBLE, 1036 notes = "", 1037 method = "setTimestamp", 1038 args = {String.class, Timestamp.class, Calendar.class} 1039 ) 1040 public void testSetTimestampStringTimestampCalendar() { 1041 fail("Not yet implemented"); 1042 } 1043 1044 /** 1045 * Test method for {@link java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)}. 1046 */ 1047 @TestTargetNew( 1048 level = TestLevel.NOT_FEASIBLE, 1049 notes = "", 1050 method = "setURL", 1051 args = {String.class, URL.class} 1052 ) 1053 public void testSetURLStringURL() { 1054 fail("Not yet implemented"); 1055 } 1056 1057 /** 1058 * Test method for {@link java.sql.CallableStatement#wasNull()}. 1059 */ 1060 @TestTargetNew( 1061 level = TestLevel.NOT_FEASIBLE, 1062 notes = "", 1063 method = "wasNull", 1064 args = {} 1065 ) 1066 public void testWasNull() { 1067 fail("Not yet implemented"); 1068 } 1069 1070 } 1071