Home | History | Annotate | Download | only in sql 
      1 /*
      2  * Licensed to the Apache Software Foundation (ASF) under one or more
      3  * contributor license agreements. See the NOTICE file distributed with
      4  * this work for additional information regarding copyright ownership.
      5  * The ASF licenses this file to You under the Apache License, Version 2.0
      6  * (the "License"); you may not use this file except in compliance with
      7  * the License. You may obtain a copy of the License at
      8  *
      9  * http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  * Unless required by applicable law or agreed to in writing, software
     12  * distributed under the License is distributed on an "AS IS" BASIS,
     13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  * See the License for the specific language governing permissions and
     15  * limitations under the License.
     16  */
     17 
     18 package org.apache.harmony.sql.tests.java.sql;
     19 
     20 import java.sql.SQLTransactionRollbackException;
     21 
     22 import junit.framework.TestCase;
     23 
     24 import org.apache.harmony.testframework.serialization.SerializationTest;
     25 
     26 public class SQLTransactionRollbackExceptionTest extends TestCase {
     27 
     28     private SQLTransactionRollbackException sQLTransactionRollbackException;
     29 
     30     protected void setUp() throws Exception {
     31         sQLTransactionRollbackException = new SQLTransactionRollbackException(
     32                 "MYTESTSTRING", "MYTESTSTRING", 1, new Exception("MYTHROWABLE"));
     33     }
     34 
     35     protected void tearDown() throws Exception {
     36         sQLTransactionRollbackException = null;
     37     }
     38 
     39     /**
     40      * @test java.sql.SQLTransactionRollbackException(String)
     41      */
     42     public void test_Constructor_LString() {
     43         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
     44                 "MYTESTSTRING");
     45         assertNotNull(sQLTransactionRollbackException);
     46         assertNull(
     47                 "The SQLState of SQLTransactionRollbackException should be null",
     48                 sQLTransactionRollbackException.getSQLState());
     49         assertEquals(
     50                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
     51                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
     52         assertEquals(
     53                 "The error code of SQLTransactionRollbackException should be 0",
     54                 sQLTransactionRollbackException.getErrorCode(), 0);
     55     }
     56 
     57     /**
     58      * @test java.sql.SQLTransactionRollbackException(String)
     59      */
     60     public void test_Constructor_LString_1() {
     61         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
     62                 (String) null);
     63         assertNotNull(sQLTransactionRollbackException);
     64         assertNull(
     65                 "The SQLState of SQLTransactionRollbackException should be null",
     66                 sQLTransactionRollbackException.getSQLState());
     67         assertNull(
     68                 "The reason of SQLTransactionRollbackException should be null",
     69                 sQLTransactionRollbackException.getMessage());
     70         assertEquals(
     71                 "The error code of SQLTransactionRollbackException should be 0",
     72                 sQLTransactionRollbackException.getErrorCode(), 0);
     73     }
     74 
     75     /**
     76      * @test java.sql.SQLTransactionRollbackException(String, String)
     77      */
     78     public void test_Constructor_LStringLString() {
     79         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
     80                 "MYTESTSTRING1", "MYTESTSTRING2");
     81         assertNotNull(sQLTransactionRollbackException);
     82         assertEquals(
     83                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
     84                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
     85         assertEquals(
     86                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
     87                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
     88         assertEquals(
     89                 "The error code of SQLTransactionRollbackException should be 0",
     90                 sQLTransactionRollbackException.getErrorCode(), 0);
     91 
     92     }
     93 
     94     /**
     95      * @test java.sql.SQLTransactionRollbackException(String, String)
     96      */
     97     public void test_Constructor_LStringLString_1() {
     98         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
     99                 "MYTESTSTRING", (String) null);
    100         assertNotNull(sQLTransactionRollbackException);
    101         assertNull(
    102                 "The SQLState of SQLTransactionRollbackException should be null",
    103                 sQLTransactionRollbackException.getSQLState());
    104         assertEquals(
    105                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    106                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    107         assertEquals(
    108                 "The error code of SQLTransactionRollbackException should be 0",
    109                 sQLTransactionRollbackException.getErrorCode(), 0);
    110     }
    111 
    112     /**
    113      * @test java.sql.SQLTransactionRollbackException(String, String)
    114      */
    115     public void test_Constructor_LStringLString_2() {
    116         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    117                 null, "MYTESTSTRING");
    118         assertNotNull(sQLTransactionRollbackException);
    119         assertEquals(
    120                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    121                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    122         assertNull(
    123                 "The reason of SQLTransactionRollbackException should be null",
    124                 sQLTransactionRollbackException.getMessage());
    125         assertEquals(
    126                 "The error code of SQLTransactionRollbackException should be 0",
    127                 sQLTransactionRollbackException.getErrorCode(), 0);
    128     }
    129 
    130     /**
    131      * @test java.sql.SQLTransactionRollbackException(String, String)
    132      */
    133     public void test_Constructor_LStringLString_3() {
    134         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    135                 (String) null, (String) null);
    136         assertNotNull(sQLTransactionRollbackException);
    137         assertNull(
    138                 "The SQLState of SQLTransactionRollbackException should be null",
    139                 sQLTransactionRollbackException.getSQLState());
    140         assertNull(
    141                 "The reason of SQLTransactionRollbackException should be null",
    142                 sQLTransactionRollbackException.getMessage());
    143         assertEquals(
    144                 "The error code of SQLTransactionRollbackException should be 0",
    145                 sQLTransactionRollbackException.getErrorCode(), 0);
    146     }
    147 
    148     /**
    149      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    150      */
    151     public void test_Constructor_LStringLStringI() {
    152         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    153                 "MYTESTSTRING1", "MYTESTSTRING2", 1);
    154         assertNotNull(sQLTransactionRollbackException);
    155         assertEquals(
    156                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    157                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    158         assertEquals(
    159                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    160                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    161         assertEquals(
    162                 "The error code of SQLTransactionRollbackException should be 1",
    163                 sQLTransactionRollbackException.getErrorCode(), 1);
    164     }
    165 
    166     /**
    167      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    168      */
    169     public void test_Constructor_LStringLStringI_1() {
    170         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    171                 "MYTESTSTRING1", "MYTESTSTRING2", 0);
    172         assertNotNull(sQLTransactionRollbackException);
    173         assertEquals(
    174                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    175                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    176         assertEquals(
    177                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    178                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    179         assertEquals(
    180                 "The error code of SQLTransactionRollbackException should be 0",
    181                 sQLTransactionRollbackException.getErrorCode(), 0);
    182     }
    183 
    184     /**
    185      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    186      */
    187     public void test_Constructor_LStringLStringI_2() {
    188         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    189                 "MYTESTSTRING1", "MYTESTSTRING2", -1);
    190         assertNotNull(sQLTransactionRollbackException);
    191         assertEquals(
    192                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    193                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    194         assertEquals(
    195                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    196                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    197         assertEquals(
    198                 "The error code of SQLTransactionRollbackException should be -1",
    199                 sQLTransactionRollbackException.getErrorCode(), -1);
    200     }
    201 
    202     /**
    203      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    204      */
    205     public void test_Constructor_LStringLStringI_3() {
    206         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    207                 "MYTESTSTRING", null, 1);
    208         assertNotNull(sQLTransactionRollbackException);
    209         assertNull(
    210                 "The SQLState of SQLTransactionRollbackException should be null",
    211                 sQLTransactionRollbackException.getSQLState());
    212         assertEquals(
    213                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    214                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    215         assertEquals(
    216                 "The error code of SQLTransactionRollbackException should be 1",
    217                 sQLTransactionRollbackException.getErrorCode(), 1);
    218     }
    219 
    220     /**
    221      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    222      */
    223     public void test_Constructor_LStringLStringI_4() {
    224         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    225                 "MYTESTSTRING", null, 0);
    226         assertNotNull(sQLTransactionRollbackException);
    227         assertNull(
    228                 "The SQLState of SQLTransactionRollbackException should be null",
    229                 sQLTransactionRollbackException.getSQLState());
    230         assertEquals(
    231                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    232                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    233         assertEquals(
    234                 "The error code of SQLTransactionRollbackException should be 0",
    235                 sQLTransactionRollbackException.getErrorCode(), 0);
    236     }
    237 
    238     /**
    239      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    240      */
    241     public void test_Constructor_LStringLStringI_5() {
    242         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    243                 "MYTESTSTRING", null, -1);
    244         assertNotNull(sQLTransactionRollbackException);
    245         assertNull(
    246                 "The SQLState of SQLTransactionRollbackException should be null",
    247                 sQLTransactionRollbackException.getSQLState());
    248         assertEquals(
    249                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    250                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    251         assertEquals(
    252                 "The error code of SQLTransactionRollbackException should be -1",
    253                 sQLTransactionRollbackException.getErrorCode(), -1);
    254     }
    255 
    256     /**
    257      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    258      */
    259     public void test_Constructor_LStringLStringI_6() {
    260         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    261                 null, "MYTESTSTRING", 1);
    262         assertNotNull(sQLTransactionRollbackException);
    263         assertEquals(
    264                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    265                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    266         assertNull(
    267                 "The reason of SQLTransactionRollbackException should be null",
    268                 sQLTransactionRollbackException.getMessage());
    269         assertEquals(
    270                 "The error code of SQLTransactionRollbackException should be 1",
    271                 sQLTransactionRollbackException.getErrorCode(), 1);
    272     }
    273 
    274     /**
    275      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    276      */
    277     public void test_Constructor_LStringLStringI_7() {
    278         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    279                 null, "MYTESTSTRING", 0);
    280         assertNotNull(sQLTransactionRollbackException);
    281         assertEquals(
    282                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    283                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    284         assertNull(
    285                 "The reason of SQLTransactionRollbackException should be null",
    286                 sQLTransactionRollbackException.getMessage());
    287         assertEquals(
    288                 "The error code of SQLTransactionRollbackException should be 0",
    289                 sQLTransactionRollbackException.getErrorCode(), 0);
    290     }
    291 
    292     /**
    293      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    294      */
    295     public void test_Constructor_LStringLStringI_8() {
    296         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    297                 null, "MYTESTSTRING", -1);
    298         assertNotNull(sQLTransactionRollbackException);
    299         assertEquals(
    300                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    301                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    302         assertNull(
    303                 "The reason of SQLTransactionRollbackException should be null",
    304                 sQLTransactionRollbackException.getMessage());
    305         assertEquals(
    306                 "The error code of SQLTransactionRollbackException should be -1",
    307                 sQLTransactionRollbackException.getErrorCode(), -1);
    308     }
    309 
    310     /**
    311      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    312      */
    313     public void test_Constructor_LStringLStringI_9() {
    314         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    315                 null, null, 1);
    316         assertNotNull(sQLTransactionRollbackException);
    317         assertNull(
    318                 "The SQLState of SQLTransactionRollbackException should be null",
    319                 sQLTransactionRollbackException.getSQLState());
    320         assertNull(
    321                 "The reason of SQLTransactionRollbackException should be null",
    322                 sQLTransactionRollbackException.getMessage());
    323         assertEquals(
    324                 "The error code of SQLTransactionRollbackException should be 1",
    325                 sQLTransactionRollbackException.getErrorCode(), 1);
    326     }
    327 
    328     /**
    329      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    330      */
    331     public void test_Constructor_LStringLStringI_10() {
    332         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    333                 null, null, 0);
    334         assertNotNull(sQLTransactionRollbackException);
    335         assertNull(
    336                 "The SQLState of SQLTransactionRollbackException should be null",
    337                 sQLTransactionRollbackException.getSQLState());
    338         assertNull(
    339                 "The reason of SQLTransactionRollbackException should be null",
    340                 sQLTransactionRollbackException.getMessage());
    341         assertEquals(
    342                 "The error code of SQLTransactionRollbackException should be 0",
    343                 sQLTransactionRollbackException.getErrorCode(), 0);
    344     }
    345 
    346     /**
    347      * @test java.sql.SQLTransactionRollbackException(String, String, int)
    348      */
    349     public void test_Constructor_LStringLStringI_11() {
    350         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    351                 null, null, -1);
    352         assertNotNull(sQLTransactionRollbackException);
    353         assertNull(
    354                 "The SQLState of SQLTransactionRollbackException should be null",
    355                 sQLTransactionRollbackException.getSQLState());
    356         assertNull(
    357                 "The reason of SQLTransactionRollbackException should be null",
    358                 sQLTransactionRollbackException.getMessage());
    359         assertEquals(
    360                 "The error code of SQLTransactionRollbackException should be -1",
    361                 sQLTransactionRollbackException.getErrorCode(), -1);
    362     }
    363 
    364     /**
    365      * @test java.sql.SQLTransactionRollbackException(Throwable)
    366      */
    367     public void test_Constructor_LThrowable() {
    368         Throwable cause = new Exception("MYTHROWABLE");
    369         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    370                 cause);
    371         assertNotNull(sQLTransactionRollbackException);
    372         assertEquals(
    373                 "The reason of SQLTransactionRollbackException should be equals to cause.toString()",
    374                 "java.lang.Exception: MYTHROWABLE",
    375                 sQLTransactionRollbackException.getMessage());
    376         assertNull(
    377                 "The SQLState of SQLTransactionRollbackException should be null",
    378                 sQLTransactionRollbackException.getSQLState());
    379         assertEquals(
    380                 "The error code of SQLTransactionRollbackException should be 0",
    381                 sQLTransactionRollbackException.getErrorCode(), 0);
    382         assertEquals(
    383                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    384                 cause, sQLTransactionRollbackException.getCause());
    385     }
    386 
    387     /**
    388      * @test java.sql.SQLTransactionRollbackException(Throwable)
    389      */
    390     public void test_Constructor_LThrowable_1() {
    391         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    392                 (Throwable) null);
    393         assertNotNull(sQLTransactionRollbackException);
    394         assertNull(
    395                 "The SQLState of SQLTransactionRollbackException should be null",
    396                 sQLTransactionRollbackException.getSQLState());
    397         assertNull(
    398                 "The reason of SQLTransactionRollbackException should be null",
    399                 sQLTransactionRollbackException.getMessage());
    400         assertEquals(
    401                 "The error code of SQLTransactionRollbackException should be 0",
    402                 sQLTransactionRollbackException.getErrorCode(), 0);
    403         assertNull(
    404                 "The cause of SQLTransactionRollbackException should be null",
    405                 sQLTransactionRollbackException.getCause());
    406     }
    407 
    408     /**
    409      * @test java.sql.SQLTransactionRollbackException(String, Throwable)
    410      */
    411     public void test_Constructor_LStringLThrowable() {
    412         Throwable cause = new Exception("MYTHROWABLE");
    413         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    414                 "MYTESTSTRING", cause);
    415         assertNotNull(sQLTransactionRollbackException);
    416         assertEquals(
    417                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    418                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    419         assertNull(
    420                 "The SQLState of SQLTransactionRollbackException should be null",
    421                 sQLTransactionRollbackException.getSQLState());
    422         assertEquals(
    423                 "The error code of SQLTransactionRollbackException should be 0",
    424                 sQLTransactionRollbackException.getErrorCode(), 0);
    425         assertEquals(
    426                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    427                 cause, sQLTransactionRollbackException.getCause());
    428     }
    429 
    430     /**
    431      * @test java.sql.SQLTransactionRollbackException(String, Throwable)
    432      */
    433     public void test_Constructor_LStringLThrowable_1() {
    434         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    435                 "MYTESTSTRING", (Throwable) null);
    436         assertNotNull(sQLTransactionRollbackException);
    437         assertEquals(
    438                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    439                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    440         assertNull(
    441                 "The SQLState of SQLTransactionRollbackException should be null",
    442                 sQLTransactionRollbackException.getSQLState());
    443         assertEquals(
    444                 "The error code of SQLTransactionRollbackException should be 0",
    445                 sQLTransactionRollbackException.getErrorCode(), 0);
    446         assertNull(
    447                 "The cause of SQLTransactionRollbackException should be null",
    448                 sQLTransactionRollbackException.getCause());
    449     }
    450 
    451     /**
    452      * @test java.sql.SQLTransactionRollbackException(String, Throwable)
    453      */
    454     public void test_Constructor_LStringLThrowable_2() {
    455         Throwable cause = new Exception("MYTHROWABLE");
    456         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    457                 null, cause);
    458         assertNotNull(sQLTransactionRollbackException);
    459         assertNull(
    460                 "The reason of SQLTransactionRollbackException should be null",
    461                 sQLTransactionRollbackException.getMessage());
    462         assertNull(
    463                 "The SQLState of SQLTransactionRollbackException should be null",
    464                 sQLTransactionRollbackException.getSQLState());
    465         assertEquals(
    466                 "The error code of SQLTransactionRollbackException should be 0",
    467                 sQLTransactionRollbackException.getErrorCode(), 0);
    468     }
    469 
    470     /**
    471      * @test java.sql.SQLTransactionRollbackException(String, Throwable)
    472      */
    473     public void test_Constructor_LStringLThrowable_3() {
    474         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    475                 (String) null, (Throwable) null);
    476         assertNotNull(sQLTransactionRollbackException);
    477         assertNull(
    478                 "The SQLState of SQLTransactionRollbackException should be null",
    479                 sQLTransactionRollbackException.getSQLState());
    480         assertNull(
    481                 "The reason of SQLTransactionRollbackException should be null",
    482                 sQLTransactionRollbackException.getMessage());
    483         assertEquals(
    484                 "The error code of SQLTransactionRollbackException should be 0",
    485                 sQLTransactionRollbackException.getErrorCode(), 0);
    486         assertNull(
    487                 "The cause of SQLTransactionRollbackException should be null",
    488                 sQLTransactionRollbackException.getCause());
    489     }
    490 
    491     /**
    492      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    493      */
    494     public void test_Constructor_LStringLStringLThrowable() {
    495         Throwable cause = new Exception("MYTHROWABLE");
    496         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    497                 "MYTESTSTRING1", "MYTESTSTRING2", cause);
    498         assertNotNull(sQLTransactionRollbackException);
    499         assertEquals(
    500                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    501                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    502         assertEquals(
    503                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    504                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    505         assertEquals(
    506                 "The error code of SQLTransactionRollbackException should be 0",
    507                 sQLTransactionRollbackException.getErrorCode(), 0);
    508         assertEquals(
    509                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    510                 cause, sQLTransactionRollbackException.getCause());
    511     }
    512 
    513     /**
    514      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    515      */
    516     public void test_Constructor_LStringLStringLThrowable_1() {
    517         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    518                 "MYTESTSTRING1", "MYTESTSTRING2", null);
    519         assertNotNull(sQLTransactionRollbackException);
    520         assertEquals(
    521                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    522                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    523         assertEquals(
    524                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    525                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    526         assertEquals(
    527                 "The error code of SQLTransactionRollbackException should be 0",
    528                 sQLTransactionRollbackException.getErrorCode(), 0);
    529         assertNull(
    530                 "The cause of SQLTransactionRollbackException should be null",
    531                 sQLTransactionRollbackException.getCause());
    532     }
    533 
    534     /**
    535      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    536      */
    537     public void test_Constructor_LStringLStringLThrowable_2() {
    538         Throwable cause = new Exception("MYTHROWABLE");
    539         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    540                 "MYTESTSTRING", null, cause);
    541         assertNotNull(sQLTransactionRollbackException);
    542         assertNull(
    543                 "The SQLState of SQLTransactionRollbackException should be null",
    544                 sQLTransactionRollbackException.getSQLState());
    545         assertEquals(
    546                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    547                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    548         assertEquals(
    549                 "The error code of SQLTransactionRollbackException should be 0",
    550                 sQLTransactionRollbackException.getErrorCode(), 0);
    551         assertEquals(
    552                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    553                 cause, sQLTransactionRollbackException.getCause());
    554     }
    555 
    556     /**
    557      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    558      */
    559     public void test_Constructor_LStringLStringLThrowable_3() {
    560         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    561                 "MYTESTSTRING", null, null);
    562         assertNotNull(sQLTransactionRollbackException);
    563         assertNull(
    564                 "The SQLState of SQLTransactionRollbackException should be null",
    565                 sQLTransactionRollbackException.getSQLState());
    566         assertEquals(
    567                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    568                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    569         assertEquals(
    570                 "The error code of SQLTransactionRollbackException should be 0",
    571                 sQLTransactionRollbackException.getErrorCode(), 0);
    572         assertNull(
    573                 "The cause of SQLTransactionRollbackException should be null",
    574                 sQLTransactionRollbackException.getCause());
    575     }
    576 
    577     /**
    578      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    579      */
    580     public void test_Constructor_LStringLStringLThrowable_4() {
    581         Throwable cause = new Exception("MYTHROWABLE");
    582         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    583                 null, "MYTESTSTRING", cause);
    584         assertNotNull(sQLTransactionRollbackException);
    585         assertEquals(
    586                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    587                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    588         assertNull(
    589                 "The reason of SQLTransactionRollbackException should be null",
    590                 sQLTransactionRollbackException.getMessage());
    591         assertEquals(
    592                 "The error code of SQLTransactionRollbackException should be 0",
    593                 sQLTransactionRollbackException.getErrorCode(), 0);
    594         assertEquals(
    595                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    596                 cause, sQLTransactionRollbackException.getCause());
    597     }
    598 
    599     /**
    600      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    601      */
    602     public void test_Constructor_LStringLStringLThrowable_5() {
    603         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    604                 null, "MYTESTSTRING", null);
    605         assertNotNull(sQLTransactionRollbackException);
    606         assertEquals(
    607                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    608                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    609         assertNull(
    610                 "The reason of SQLTransactionRollbackException should be null",
    611                 sQLTransactionRollbackException.getMessage());
    612         assertEquals(
    613                 "The error code of SQLTransactionRollbackException should be 0",
    614                 sQLTransactionRollbackException.getErrorCode(), 0);
    615         assertNull(
    616                 "The cause of SQLTransactionRollbackException should be null",
    617                 sQLTransactionRollbackException.getCause());
    618     }
    619 
    620     /**
    621      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    622      */
    623     public void test_Constructor_LStringLStringLThrowable_6() {
    624         Throwable cause = new Exception("MYTHROWABLE");
    625         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    626                 null, null, cause);
    627         assertNotNull(sQLTransactionRollbackException);
    628         assertNull(
    629                 "The SQLState of SQLTransactionRollbackException should be null",
    630                 sQLTransactionRollbackException.getSQLState());
    631         assertNull(
    632                 "The reason of SQLTransactionRollbackException should be null",
    633                 sQLTransactionRollbackException.getMessage());
    634         assertEquals(
    635                 "The error code of SQLTransactionRollbackException should be 0",
    636                 sQLTransactionRollbackException.getErrorCode(), 0);
    637         assertEquals(
    638                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    639                 cause, sQLTransactionRollbackException.getCause());
    640     }
    641 
    642     /**
    643      * @test java.sql.SQLTransactionRollbackException(String, String, Throwable)
    644      */
    645     public void test_Constructor_LStringLStringLThrowable_7() {
    646         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    647                 null, null, null);
    648         assertNotNull(sQLTransactionRollbackException);
    649         assertNull(
    650                 "The SQLState of SQLTransactionRollbackException should be null",
    651                 sQLTransactionRollbackException.getSQLState());
    652         assertNull(
    653                 "The reason of SQLTransactionRollbackException should be null",
    654                 sQLTransactionRollbackException.getMessage());
    655         assertEquals(
    656                 "The error code of SQLTransactionRollbackException should be 0",
    657                 sQLTransactionRollbackException.getErrorCode(), 0);
    658         assertNull(
    659                 "The cause of SQLTransactionRollbackException should be null",
    660                 sQLTransactionRollbackException.getCause());
    661     }
    662 
    663     /**
    664      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    665      *Throwable)
    666      */
    667     public void test_Constructor_LStringLStringILThrowable() {
    668         Throwable cause = new Exception("MYTHROWABLE");
    669         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    670                 "MYTESTSTRING1", "MYTESTSTRING2", 1, cause);
    671         assertNotNull(sQLTransactionRollbackException);
    672         assertEquals(
    673                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    674                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    675         assertEquals(
    676                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    677                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    678         assertEquals(
    679                 "The error code of SQLTransactionRollbackException should be 1",
    680                 sQLTransactionRollbackException.getErrorCode(), 1);
    681         assertEquals(
    682                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    683                 cause, sQLTransactionRollbackException.getCause());
    684     }
    685 
    686     /**
    687      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    688      *Throwable)
    689      */
    690     public void test_Constructor_LStringLStringILThrowable_1() {
    691         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    692                 "MYTESTSTRING1", "MYTESTSTRING2", 1, null);
    693         assertNotNull(sQLTransactionRollbackException);
    694         assertEquals(
    695                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    696                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    697         assertEquals(
    698                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    699                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    700         assertEquals(
    701                 "The error code of SQLTransactionRollbackException should be 1",
    702                 sQLTransactionRollbackException.getErrorCode(), 1);
    703         assertNull(
    704                 "The cause of SQLTransactionRollbackException should be null",
    705                 sQLTransactionRollbackException.getCause());
    706     }
    707 
    708     /**
    709      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    710      *Throwable)
    711      */
    712     public void test_Constructor_LStringLStringILThrowable_2() {
    713         Throwable cause = new Exception("MYTHROWABLE");
    714         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    715                 "MYTESTSTRING1", "MYTESTSTRING2", 0, cause);
    716         assertNotNull(sQLTransactionRollbackException);
    717         assertEquals(
    718                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    719                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    720         assertEquals(
    721                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    722                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    723         assertEquals(
    724                 "The error code of SQLTransactionRollbackException should be 0",
    725                 sQLTransactionRollbackException.getErrorCode(), 0);
    726         assertEquals(
    727                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    728                 cause, sQLTransactionRollbackException.getCause());
    729     }
    730 
    731     /**
    732      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    733      *Throwable)
    734      */
    735     public void test_Constructor_LStringLStringILThrowable_3() {
    736         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    737                 "MYTESTSTRING1", "MYTESTSTRING2", 0, null);
    738         assertNotNull(sQLTransactionRollbackException);
    739         assertEquals(
    740                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    741                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    742         assertEquals(
    743                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    744                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    745         assertEquals(
    746                 "The error code of SQLTransactionRollbackException should be 0",
    747                 sQLTransactionRollbackException.getErrorCode(), 0);
    748         assertNull(
    749                 "The cause of SQLTransactionRollbackException should be null",
    750                 sQLTransactionRollbackException.getCause());
    751     }
    752 
    753     /**
    754      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    755      *Throwable)
    756      */
    757     public void test_Constructor_LStringLStringILThrowable_4() {
    758         Throwable cause = new Exception("MYTHROWABLE");
    759         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    760                 "MYTESTSTRING1", "MYTESTSTRING2", -1, cause);
    761         assertNotNull(sQLTransactionRollbackException);
    762         assertEquals(
    763                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    764                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    765         assertEquals(
    766                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    767                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    768         assertEquals(
    769                 "The error code of SQLTransactionRollbackException should be -1",
    770                 sQLTransactionRollbackException.getErrorCode(), -1);
    771         assertEquals(
    772                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    773                 cause, sQLTransactionRollbackException.getCause());
    774     }
    775 
    776     /**
    777      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    778      *Throwable)
    779      */
    780     public void test_Constructor_LStringLStringILThrowable_5() {
    781         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    782                 "MYTESTSTRING1", "MYTESTSTRING2", -1, null);
    783         assertNotNull(sQLTransactionRollbackException);
    784         assertEquals(
    785                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    786                 "MYTESTSTRING2", sQLTransactionRollbackException.getSQLState());
    787         assertEquals(
    788                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    789                 "MYTESTSTRING1", sQLTransactionRollbackException.getMessage());
    790         assertEquals(
    791                 "The error code of SQLTransactionRollbackException should be -1",
    792                 sQLTransactionRollbackException.getErrorCode(), -1);
    793         assertNull(
    794                 "The cause of SQLTransactionRollbackException should be null",
    795                 sQLTransactionRollbackException.getCause());
    796 
    797     }
    798 
    799     /**
    800      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    801      *Throwable)
    802      */
    803     public void test_Constructor_LStringLStringILThrowable_6() {
    804         Throwable cause = new Exception("MYTHROWABLE");
    805         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    806                 "MYTESTSTRING", null, 1, cause);
    807         assertNotNull(sQLTransactionRollbackException);
    808         assertNull(
    809                 "The SQLState of SQLTransactionRollbackException should be null",
    810                 sQLTransactionRollbackException.getSQLState());
    811         assertEquals(
    812                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    813                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    814         assertEquals(
    815                 "The error code of SQLTransactionRollbackException should be 1",
    816                 sQLTransactionRollbackException.getErrorCode(), 1);
    817         assertEquals(
    818                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    819                 cause, sQLTransactionRollbackException.getCause());
    820     }
    821 
    822     /**
    823      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    824      *Throwable)
    825      */
    826     public void test_Constructor_LStringLStringILThrowable_7() {
    827         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    828                 "MYTESTSTRING", null, 1, null);
    829         assertNotNull(sQLTransactionRollbackException);
    830         assertNotNull(sQLTransactionRollbackException);
    831         assertNull(
    832                 "The SQLState of SQLTransactionRollbackException should be null",
    833                 sQLTransactionRollbackException.getSQLState());
    834         assertEquals(
    835                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    836                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    837         assertEquals(
    838                 "The error code of SQLTransactionRollbackException should be 1",
    839                 sQLTransactionRollbackException.getErrorCode(), 1);
    840         assertNull(
    841                 "The cause of SQLTransactionRollbackException should be null",
    842                 sQLTransactionRollbackException.getCause());
    843     }
    844 
    845     /**
    846      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    847      *Throwable)
    848      */
    849     public void test_Constructor_LStringLStringILThrowable_8() {
    850         Throwable cause = new Exception("MYTHROWABLE");
    851         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    852                 "MYTESTSTRING", null, 0, cause);
    853         assertNotNull(sQLTransactionRollbackException);
    854         assertNull(
    855                 "The SQLState of SQLTransactionRollbackException should be null",
    856                 sQLTransactionRollbackException.getSQLState());
    857         assertEquals(
    858                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    859                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    860         assertEquals(
    861                 "The error code of SQLTransactionRollbackException should be 0",
    862                 sQLTransactionRollbackException.getErrorCode(), 0);
    863         assertEquals(
    864                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    865                 cause, sQLTransactionRollbackException.getCause());
    866     }
    867 
    868     /**
    869      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    870      *Throwable)
    871      */
    872     public void test_Constructor_LStringLStringILThrowable_9() {
    873         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    874                 "MYTESTSTRING", null, 0, null);
    875         assertNotNull(sQLTransactionRollbackException);
    876         assertNull(
    877                 "The SQLState of SQLTransactionRollbackException should be null",
    878                 sQLTransactionRollbackException.getSQLState());
    879         assertEquals(
    880                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    881                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    882         assertEquals(
    883                 "The error code of SQLTransactionRollbackException should be 0",
    884                 sQLTransactionRollbackException.getErrorCode(), 0);
    885         assertNull(
    886                 "The cause of SQLTransactionRollbackException should be null",
    887                 sQLTransactionRollbackException.getCause());
    888     }
    889 
    890     /**
    891      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    892      *Throwable)
    893      */
    894     public void test_Constructor_LStringLStringILThrowable_10() {
    895         Throwable cause = new Exception("MYTHROWABLE");
    896         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    897                 "MYTESTSTRING", null, -1, cause);
    898         assertNotNull(sQLTransactionRollbackException);
    899         assertNull(
    900                 "The SQLState of SQLTransactionRollbackException should be null",
    901                 sQLTransactionRollbackException.getSQLState());
    902         assertEquals(
    903                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    904                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    905         assertEquals(
    906                 "The error code of SQLTransactionRollbackException should be -1",
    907                 sQLTransactionRollbackException.getErrorCode(), -1);
    908         assertEquals(
    909                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    910                 cause, sQLTransactionRollbackException.getCause());
    911     }
    912 
    913     /**
    914      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    915      *Throwable)
    916      */
    917     public void test_Constructor_LStringLStringILThrowable_11() {
    918         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    919                 "MYTESTSTRING", null, -1, null);
    920         assertNotNull(sQLTransactionRollbackException);
    921         assertNull(
    922                 "The SQLState of SQLTransactionRollbackException should be null",
    923                 sQLTransactionRollbackException.getSQLState());
    924         assertEquals(
    925                 "The reason of SQLTransactionRollbackException set and get should be equivalent",
    926                 "MYTESTSTRING", sQLTransactionRollbackException.getMessage());
    927         assertEquals(
    928                 "The error code of SQLTransactionRollbackException should be -1",
    929                 sQLTransactionRollbackException.getErrorCode(), -1);
    930         assertNull(
    931                 "The cause of SQLTransactionRollbackException should be null",
    932                 sQLTransactionRollbackException.getCause());
    933     }
    934 
    935     /**
    936      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    937      *Throwable)
    938      */
    939     public void test_Constructor_LStringLStringILThrowable_12() {
    940         Throwable cause = new Exception("MYTHROWABLE");
    941         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    942                 null, "MYTESTSTRING", 1, cause);
    943         assertNotNull(sQLTransactionRollbackException);
    944         assertEquals(
    945                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    946                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    947         assertNull(
    948                 "The reason of SQLTransactionRollbackException should be null",
    949                 sQLTransactionRollbackException.getMessage());
    950         assertEquals(
    951                 "The error code of SQLTransactionRollbackException should be 1",
    952                 sQLTransactionRollbackException.getErrorCode(), 1);
    953         assertEquals(
    954                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
    955                 cause, sQLTransactionRollbackException.getCause());
    956     }
    957 
    958     /**
    959      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    960      *Throwable)
    961      */
    962     public void test_Constructor_LStringLStringILThrowable_13() {
    963         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    964                 null, "MYTESTSTRING", 1, null);
    965         assertNotNull(sQLTransactionRollbackException);
    966         assertEquals(
    967                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    968                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    969         assertNull(
    970                 "The reason of SQLTransactionRollbackException should be null",
    971                 sQLTransactionRollbackException.getMessage());
    972         assertEquals(
    973                 "The error code of SQLTransactionRollbackException should be 1",
    974                 sQLTransactionRollbackException.getErrorCode(), 1);
    975         assertNull(
    976                 "The cause of SQLTransactionRollbackException should be null",
    977                 sQLTransactionRollbackException.getCause());
    978     }
    979 
    980     /**
    981      * @test java.sql.SQLTransactionRollbackException(String, String, int,
    982      *Throwable)
    983      */
    984     public void test_Constructor_LStringLStringILThrowable_14() {
    985         Throwable cause = new Exception("MYTHROWABLE");
    986         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
    987                 null, "MYTESTSTRING", 0, cause);
    988         assertNotNull(sQLTransactionRollbackException);
    989         assertEquals(
    990                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
    991                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
    992         assertNull(
    993                 "The reason of SQLTransactionRollbackException should be null",
    994                 sQLTransactionRollbackException.getMessage());
    995         assertEquals(
    996                 "The error code of SQLTransactionRollbackException should be 0",
    997                 sQLTransactionRollbackException.getErrorCode(), 0);
    998         assertEquals(
    999                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
   1000                 cause, sQLTransactionRollbackException.getCause());
   1001     }
   1002 
   1003     /**
   1004      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1005      *Throwable)
   1006      */
   1007     public void test_Constructor_LStringLStringILThrowable_15() {
   1008         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1009                 null, "MYTESTSTRING", 0, null);
   1010         assertNotNull(sQLTransactionRollbackException);
   1011         assertEquals(
   1012                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
   1013                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
   1014         assertNull(
   1015                 "The reason of SQLTransactionRollbackException should be null",
   1016                 sQLTransactionRollbackException.getMessage());
   1017         assertEquals(
   1018                 "The error code of SQLTransactionRollbackException should be 0",
   1019                 sQLTransactionRollbackException.getErrorCode(), 0);
   1020         assertNull(
   1021                 "The cause of SQLTransactionRollbackException should be null",
   1022                 sQLTransactionRollbackException.getCause());
   1023 
   1024     }
   1025 
   1026     /**
   1027      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1028      *Throwable)
   1029      */
   1030     public void test_Constructor_LStringLStringILThrowable_16() {
   1031         Throwable cause = new Exception("MYTHROWABLE");
   1032         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1033                 null, "MYTESTSTRING", -1, cause);
   1034         assertNotNull(sQLTransactionRollbackException);
   1035         assertEquals(
   1036                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
   1037                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
   1038         assertNull(
   1039                 "The reason of SQLTransactionRollbackException should be null",
   1040                 sQLTransactionRollbackException.getMessage());
   1041         assertEquals(
   1042                 "The error code of SQLTransactionRollbackException should be -1",
   1043                 sQLTransactionRollbackException.getErrorCode(), -1);
   1044         assertEquals(
   1045                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
   1046                 cause, sQLTransactionRollbackException.getCause());
   1047     }
   1048 
   1049     /**
   1050      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1051      *Throwable)
   1052      */
   1053     public void test_Constructor_LStringLStringILThrowable_17() {
   1054         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1055                 null, "MYTESTSTRING", -1, null);
   1056         assertNotNull(sQLTransactionRollbackException);
   1057         assertEquals(
   1058                 "The SQLState of SQLTransactionRollbackException set and get should be equivalent",
   1059                 "MYTESTSTRING", sQLTransactionRollbackException.getSQLState());
   1060         assertNull(
   1061                 "The reason of SQLTransactionRollbackException should be null",
   1062                 sQLTransactionRollbackException.getMessage());
   1063         assertEquals(
   1064                 "The error code of SQLTransactionRollbackException should be -1",
   1065                 sQLTransactionRollbackException.getErrorCode(), -1);
   1066         assertNull(
   1067                 "The cause of SQLTransactionRollbackException should be null",
   1068                 sQLTransactionRollbackException.getCause());
   1069     }
   1070 
   1071     /**
   1072      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1073      *Throwable)
   1074      */
   1075     public void test_Constructor_LStringLStringILThrowable_18() {
   1076         Throwable cause = new Exception("MYTHROWABLE");
   1077         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1078                 null, null, 1, cause);
   1079         assertNotNull(sQLTransactionRollbackException);
   1080         assertNull(
   1081                 "The SQLState of SQLTransactionRollbackException should be null",
   1082                 sQLTransactionRollbackException.getSQLState());
   1083         assertNull(
   1084                 "The reason of SQLTransactionRollbackException should be null",
   1085                 sQLTransactionRollbackException.getMessage());
   1086         assertEquals(
   1087                 "The error code of SQLTransactionRollbackException should be 1",
   1088                 sQLTransactionRollbackException.getErrorCode(), 1);
   1089         assertEquals(
   1090                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
   1091                 cause, sQLTransactionRollbackException.getCause());
   1092     }
   1093 
   1094     /**
   1095      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1096      *Throwable)
   1097      */
   1098     public void test_Constructor_LStringLStringILThrowable_19() {
   1099         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1100                 null, null, 1, null);
   1101         assertNotNull(sQLTransactionRollbackException);
   1102         assertNull(
   1103                 "The SQLState of SQLTransactionRollbackException should be null",
   1104                 sQLTransactionRollbackException.getSQLState());
   1105         assertNull(
   1106                 "The reason of SQLTransactionRollbackException should be null",
   1107                 sQLTransactionRollbackException.getMessage());
   1108         assertEquals(
   1109                 "The error code of SQLTransactionRollbackException should be 1",
   1110                 sQLTransactionRollbackException.getErrorCode(), 1);
   1111         assertNull(
   1112                 "The cause of SQLTransactionRollbackException should be null",
   1113                 sQLTransactionRollbackException.getCause());
   1114     }
   1115 
   1116     /**
   1117      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1118      *Throwable)
   1119      */
   1120     public void test_Constructor_LStringLStringILThrowable_20() {
   1121         Throwable cause = new Exception("MYTHROWABLE");
   1122         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1123                 null, null, 0, cause);
   1124         assertNotNull(sQLTransactionRollbackException);
   1125         assertNull(
   1126                 "The SQLState of SQLTransactionRollbackException should be null",
   1127                 sQLTransactionRollbackException.getSQLState());
   1128         assertNull(
   1129                 "The reason of SQLTransactionRollbackException should be null",
   1130                 sQLTransactionRollbackException.getMessage());
   1131         assertEquals(
   1132                 "The error code of SQLTransactionRollbackException should be 0",
   1133                 sQLTransactionRollbackException.getErrorCode(), 0);
   1134         assertEquals(
   1135                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
   1136                 cause, sQLTransactionRollbackException.getCause());
   1137     }
   1138 
   1139     /**
   1140      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1141      *Throwable)
   1142      */
   1143     public void test_Constructor_LStringLStringILThrowable_21() {
   1144         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1145                 null, null, 0, null);
   1146         assertNotNull(sQLTransactionRollbackException);
   1147         assertNull(
   1148                 "The SQLState of SQLTransactionRollbackException should be null",
   1149                 sQLTransactionRollbackException.getSQLState());
   1150         assertNull(
   1151                 "The reason of SQLTransactionRollbackException should be null",
   1152                 sQLTransactionRollbackException.getMessage());
   1153         assertEquals(
   1154                 "The error code of SQLTransactionRollbackException should be 0",
   1155                 sQLTransactionRollbackException.getErrorCode(), 0);
   1156         assertNull(
   1157                 "The cause of SQLTransactionRollbackException should be null",
   1158                 sQLTransactionRollbackException.getCause());
   1159     }
   1160 
   1161     /**
   1162      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1163      *Throwable)
   1164      */
   1165     public void test_Constructor_LStringLStringILThrowable_22() {
   1166         Throwable cause = new Exception("MYTHROWABLE");
   1167         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1168                 null, null, -1, cause);
   1169         assertNotNull(sQLTransactionRollbackException);
   1170         assertNull(
   1171                 "The SQLState of SQLTransactionRollbackException should be null",
   1172                 sQLTransactionRollbackException.getSQLState());
   1173         assertNull(
   1174                 "The reason of SQLTransactionRollbackException should be null",
   1175                 sQLTransactionRollbackException.getMessage());
   1176         assertEquals(
   1177                 "The error code of SQLTransactionRollbackException should be -1",
   1178                 sQLTransactionRollbackException.getErrorCode(), -1);
   1179         assertEquals(
   1180                 "The cause of SQLTransactionRollbackException set and get should be equivalent",
   1181                 cause, sQLTransactionRollbackException.getCause());
   1182     }
   1183 
   1184     /**
   1185      * @test java.sql.SQLTransactionRollbackException(String, String, int,
   1186      *Throwable)
   1187      */
   1188     public void test_Constructor_LStringLStringILThrowable_23() {
   1189         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException(
   1190                 null, null, -1, null);
   1191         assertNotNull(sQLTransactionRollbackException);
   1192         assertNull(
   1193                 "The SQLState of SQLTransactionRollbackException should be null",
   1194                 sQLTransactionRollbackException.getSQLState());
   1195         assertNull(
   1196                 "The reason of SQLTransactionRollbackException should be null",
   1197                 sQLTransactionRollbackException.getMessage());
   1198         assertEquals(
   1199                 "The error code of SQLTransactionRollbackException should be -1",
   1200                 sQLTransactionRollbackException.getErrorCode(), -1);
   1201         assertNull(
   1202                 "The cause of SQLTransactionRollbackException should be null",
   1203                 sQLTransactionRollbackException.getCause());
   1204     }
   1205 
   1206     /**
   1207      * @test java.sql.SQLTransactionRollbackException()
   1208      */
   1209     public void test_Constructor() {
   1210         SQLTransactionRollbackException sQLTransactionRollbackException = new SQLTransactionRollbackException();
   1211         assertNotNull(sQLTransactionRollbackException);
   1212         assertNull(
   1213                 "The SQLState of SQLTransactionRollbackException should be null",
   1214                 sQLTransactionRollbackException.getSQLState());
   1215         assertNull(
   1216                 "The reason of SQLTransactionRollbackException should be null",
   1217                 sQLTransactionRollbackException.getMessage());
   1218         assertEquals(
   1219                 "The error code of SQLTransactionRollbackException should be 0",
   1220                 sQLTransactionRollbackException.getErrorCode(), 0);
   1221     }
   1222 
   1223     /**
   1224      * @test serialization/deserialization compatibility.
   1225      */
   1226     public void test_serialization() throws Exception {
   1227         SerializationTest.verifySelf(sQLTransactionRollbackException);
   1228     }
   1229 
   1230     /**
   1231      * @test serialization/deserialization compatibility with RI.
   1232      */
   1233     public void test_compatibilitySerialization() throws Exception {
   1234         SerializationTest.verifyGolden(this, sQLTransactionRollbackException);
   1235     }
   1236 }
   1237