1 /*
2  * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.
8  *
9  * This code is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  * version 2 for more details (a copy is included in the LICENSE file that
13  * accompanied this code).
14  *
15  * You should have received a copy of the GNU General Public License version
16  * 2 along with this work; if not, write to the Free Software Foundation,
17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18  *
19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20  * or visit www.oracle.com if you need additional information or have any
21  * questions.
22  */
23 package test.sql;
24 
25 import java.sql.SQLException;
26 import java.sql.SQLFeatureNotSupportedException;
27 import java.sql.SQLNonTransientException;
28 import static org.testng.Assert.*;
29 import org.testng.annotations.Test;
30 import util.BaseTest;
31 
32 public class SQLFeatureNotSupportedExceptionTests extends BaseTest {
33 
34     /**
35      * Create SQLFeatureNotSupportedException and setting all objects to null
36      */
37     @Test
test()38     public void test() {
39         SQLFeatureNotSupportedException e =
40                 new SQLFeatureNotSupportedException(null, null, errorCode, null);
41         assertTrue(e.getMessage() == null && e.getSQLState() == null
42                 && e.getCause() == null && e.getErrorCode() == errorCode);
43     }
44 
45     /**
46      * Create SQLFeatureNotSupportedException with no-arg constructor
47      */
48     @Test
test1()49     public void test1() {
50         SQLFeatureNotSupportedException ex = new SQLFeatureNotSupportedException();
51         assertTrue(ex.getMessage() == null
52                 && ex.getSQLState() == null
53                 && ex.getCause() == null
54                 && ex.getErrorCode() == 0);
55     }
56 
57     /**
58      * Create SQLFeatureNotSupportedException with message
59      */
60     @Test
test2()61     public void test2() {
62         SQLFeatureNotSupportedException ex =
63                 new SQLFeatureNotSupportedException(reason);
64         assertTrue(ex.getMessage().equals(reason)
65                 && ex.getSQLState() == null
66                 && ex.getCause() == null
67                 && ex.getErrorCode() == 0);
68     }
69 
70     /**
71      * Create SQLFeatureNotSupportedException with message, and SQLState
72      */
73     @Test
test3()74     public void test3() {
75         SQLFeatureNotSupportedException ex =
76                 new SQLFeatureNotSupportedException(reason, state);
77         assertTrue(ex.getMessage().equals(reason)
78                 && ex.getSQLState().equals(state)
79                 && ex.getCause() == null
80                 && ex.getErrorCode() == 0);
81     }
82 
83     /**
84      * Create SQLFeatureNotSupportedException with message, SQLState, and error code
85      */
86     @Test
test4()87     public void test4() {
88         SQLFeatureNotSupportedException ex =
89                 new SQLFeatureNotSupportedException(reason, state, errorCode);
90         assertTrue(ex.getMessage().equals(reason)
91                 && ex.getSQLState().equals(state)
92                 && ex.getCause() == null
93                 && ex.getErrorCode() == errorCode);
94     }
95 
96     /**
97      * Create SQLFeatureNotSupportedException with message, SQLState, errorCode, and Throwable
98      */
99     @Test
test5()100     public void test5() {
101         SQLFeatureNotSupportedException ex =
102                 new SQLFeatureNotSupportedException(reason, state, errorCode, t);
103         assertTrue(ex.getMessage().equals(reason)
104                 && ex.getSQLState().equals(state)
105                 && cause.equals(ex.getCause().toString())
106                 && ex.getErrorCode() == errorCode);
107     }
108 
109     /**
110      * Create SQLFeatureNotSupportedException with message, SQLState, and Throwable
111      */
112     @Test
test6()113     public void test6() {
114         SQLFeatureNotSupportedException ex =
115                 new SQLFeatureNotSupportedException(reason, state, t);
116         assertTrue(ex.getMessage().equals(reason)
117                 && ex.getSQLState().equals(state)
118                 && cause.equals(ex.getCause().toString())
119                 && ex.getErrorCode() == 0);
120     }
121 
122     /**
123      * Create SQLFeatureNotSupportedException with message, and Throwable
124      */
125     @Test
test7()126     public void test7() {
127         SQLFeatureNotSupportedException ex =
128                 new SQLFeatureNotSupportedException(reason, t);
129         assertTrue(ex.getMessage().equals(reason)
130                 && ex.getSQLState() == null
131                 && cause.equals(ex.getCause().toString())
132                 && ex.getErrorCode() == 0);
133     }
134 
135     /**
136      * Create SQLFeatureNotSupportedException with null Throwable
137      */
138     @Test
test8()139     public void test8() {
140         SQLFeatureNotSupportedException ex =
141                 new SQLFeatureNotSupportedException((Throwable) null);
142         assertTrue(ex.getMessage() == null
143                 && ex.getSQLState() == null
144                 && ex.getCause() == null
145                 && ex.getErrorCode() == 0);
146     }
147 
148     /**
149      * Create SQLFeatureNotSupportedException with Throwable
150      */
151     @Test
test9()152     public void test9() {
153         SQLFeatureNotSupportedException ex =
154                 new SQLFeatureNotSupportedException(t);
155         assertTrue(ex.getMessage().equals(cause)
156                 && ex.getSQLState() == null
157                 && cause.equals(ex.getCause().toString())
158                 && ex.getErrorCode() == 0);
159     }
160 
161     /**
162      * Serialize a SQLFeatureNotSupportedException and make sure you can read it back properly
163      */
164     @Test
test10()165     public void test10() throws Exception {
166         SQLFeatureNotSupportedException e =
167                 new SQLFeatureNotSupportedException(reason, state, errorCode, t);
168         SQLFeatureNotSupportedException ex1 =
169                 createSerializedException(e);
170         assertTrue(reason.equals(ex1.getMessage())
171                 && ex1.getSQLState().equals(state)
172                 && cause.equals(ex1.getCause().toString())
173                 && ex1.getErrorCode() == errorCode);
174     }
175 
176     /**
177      * Validate that the ordering of the returned Exceptions is correct
178      * using for-each loop
179      */
180     @Test
test11()181     public void test11() {
182         SQLFeatureNotSupportedException ex =
183                 new SQLFeatureNotSupportedException("Exception 1", t1);
184         SQLFeatureNotSupportedException ex1 =
185                 new SQLFeatureNotSupportedException("Exception 2");
186         SQLFeatureNotSupportedException ex2 =
187                 new SQLFeatureNotSupportedException("Exception 3", t2);
188         ex.setNextException(ex1);
189         ex.setNextException(ex2);
190         int num = 0;
191         for (Throwable e : ex) {
192             assertTrue(msgs[num++].equals(e.getMessage()));
193         }
194     }
195 
196     /**
197      * Validate that the ordering of the returned Exceptions is correct
198      * using traditional while loop
199      */
200     @Test
test12()201     public void test12() {
202         SQLFeatureNotSupportedException ex =
203                 new SQLFeatureNotSupportedException("Exception 1", t1);
204         SQLFeatureNotSupportedException ex1 =
205                 new SQLFeatureNotSupportedException("Exception 2");
206         SQLFeatureNotSupportedException ex2 =
207                 new SQLFeatureNotSupportedException("Exception 3", t2);
208         ex.setNextException(ex1);
209         ex.setNextException(ex2);
210         int num = 0;
211         SQLException sqe = ex;
212         while (sqe != null) {
213             assertTrue(msgs[num++].equals(sqe.getMessage()));
214             Throwable c = sqe.getCause();
215             while (c != null) {
216                 assertTrue(msgs[num++].equals(c.getMessage()));
217                 c = c.getCause();
218             }
219             sqe = sqe.getNextException();
220         }
221     }
222 
223     /**
224      * Create SQLFeatureNotSupportedException and validate it is an instance of
225      * SQLNonTransientException
226      */
227     @Test
test13()228     public void test13() {
229         Exception ex = new SQLFeatureNotSupportedException();
230         assertTrue(ex instanceof SQLNonTransientException);
231     }
232 }
233