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.rowset.serial; 24 25 import java.io.InputStream; 26 import java.io.OutputStream; 27 import java.util.Arrays; 28 import javax.sql.rowset.serial.SerialBlob; 29 import javax.sql.rowset.serial.SerialException; 30 import static org.testng.Assert.*; 31 import org.testng.annotations.Test; 32 import util.BaseTest; 33 import util.StubBlob; 34 35 public class SerialBlobTests extends BaseTest { 36 37 // byte[] used to populate SerialBlob 38 private byte[] bytes = new byte[]{1, 2, 3, 4, 5}; 39 40 /* 41 * Validate calling free() does not throw an Exception 42 */ 43 @Test test()44 public void test() throws Exception { 45 SerialBlob sb = new SerialBlob(new StubBlob()); 46 sb.free(); 47 } 48 49 /* 50 * Validate calling getBinaryStream() after calling free() throws an 51 * SerialException 52 */ 53 @Test(expectedExceptions = SerialException.class) test01()54 public void test01() throws Exception { 55 SerialBlob sb = new SerialBlob(new StubBlob()); 56 sb.free(); 57 sb.getBinaryStream(); 58 } 59 60 /* 61 * Validate calling getBinaryStream() after calling free() throws an 62 * SerialException 63 */ 64 @Test(expectedExceptions = SerialException.class) test02()65 public void test02() throws Exception { 66 SerialBlob sb = new SerialBlob(new StubBlob()); 67 sb.free(); 68 sb.getBinaryStream(1, 5); 69 } 70 71 /* 72 * Validate calling getBytes() after calling free() throws an 73 * SerialException 74 */ 75 @Test(expectedExceptions = SerialException.class) test03()76 public void test03() throws Exception { 77 SerialBlob sb = new SerialBlob(new StubBlob()); 78 sb.free(); 79 sb.getBytes(1, 1); 80 } 81 82 /* 83 * Validate calling getLength() after calling free() throws an 84 * SerialException 85 */ 86 @Test(expectedExceptions = SerialException.class) test04()87 public void test04() throws Exception { 88 SerialBlob sb = new SerialBlob(new StubBlob()); 89 sb.free(); 90 sb.length(); 91 } 92 93 /* 94 * Validate calling position() after calling free() throws an 95 * SerialException 96 */ 97 @Test(expectedExceptions = SerialException.class) test05()98 public void test05() throws Exception { 99 SerialBlob sb = new SerialBlob(new StubBlob()); 100 sb.free(); 101 sb.position(new byte[5], 1); 102 } 103 104 /* 105 * Validate calling position() after calling free() throws an 106 * SerialException 107 */ 108 @Test(expectedExceptions = SerialException.class) test06()109 public void test06() throws Exception { 110 SerialBlob sb = new SerialBlob(new StubBlob()); 111 sb.free(); 112 sb.position(new StubBlob(), 1); 113 } 114 115 /* 116 * Validate calling free() after calling setBinaryStream() throws an 117 * SerialException 118 */ 119 @Test(expectedExceptions = SerialException.class) test07()120 public void test07() throws Exception { 121 SerialBlob sb = new SerialBlob(new StubBlob()); 122 sb.free(); 123 sb.setBinaryStream(5); 124 } 125 126 /* 127 * Validate calling free() after calling setBytes() throws an 128 * SerialException 129 */ 130 @Test(expectedExceptions = SerialException.class) test08()131 public void test08() throws Exception { 132 SerialBlob sb = new SerialBlob(new StubBlob()); 133 sb.free(); 134 sb.setBytes(1, new byte[5]); 135 } 136 137 /* 138 * Validate calling setBytes() after calling free() throws an 139 * SerialException 140 */ 141 @Test(expectedExceptions = SerialException.class) test09()142 public void test09() throws Exception { 143 SerialBlob sb = new SerialBlob(new StubBlob()); 144 sb.free(); 145 sb.setBytes(1, new byte[10], 0, 5); 146 } 147 148 /* 149 * Validate calling truncate() after calling free() throws an 150 * SerialException 151 */ 152 @Test(expectedExceptions = SerialException.class) test10()153 public void test10() throws Exception { 154 SerialBlob sb = new SerialBlob(new StubBlob()); 155 sb.free(); 156 sb.truncate(1); 157 } 158 159 /* 160 * Validate getBinaryStream returns the correct bytes 161 */ 162 @Test test11()163 public void test11() throws Exception { 164 byte[] expected = new byte[]{1, 2, 3}; 165 SerialBlob sb = new SerialBlob(bytes); 166 InputStream is = sb.getBinaryStream(1, 3); 167 for (byte b : expected) { 168 byte val = (byte) is.read(); 169 assertTrue(b == val, val + " does not match " + b); 170 } 171 } 172 173 /* 174 * Validate a SerialException is thrown if pos < 0 for getBinaryStream 175 */ 176 @Test(expectedExceptions = SerialException.class) test12()177 public void test12() throws Exception { 178 SerialBlob sb = new SerialBlob(bytes); 179 InputStream is = sb.getBinaryStream(-1, 3); 180 } 181 182 /* 183 * Validate a SerialException is thrown if pos = 0 for getBinaryStream 184 */ 185 @Test(expectedExceptions = SerialException.class) test13()186 public void test13() throws Exception { 187 SerialBlob sb = new SerialBlob(bytes); 188 InputStream is = sb.getBinaryStream(0, 3); 189 } 190 191 /* 192 * Validate a SerialException is thrown if len > the length of the stream 193 * for getBinaryStream 194 */ 195 @Test(expectedExceptions = SerialException.class) test14()196 public void test14() throws Exception { 197 SerialBlob sb = new SerialBlob(bytes); 198 InputStream is = sb.getBinaryStream(0, 3); 199 } 200 201 /* 202 * Validate a SerialException is thrown if length < 1 203 */ 204 @Test(expectedExceptions = SerialException.class) test15()205 public void test15() throws Exception { 206 SerialBlob sb = new SerialBlob(bytes); 207 InputStream is = sb.getBinaryStream(1, 0); 208 } 209 210 /* 211 * Validate a SerialException is thrown if length > byte array length 212 */ 213 @Test(expectedExceptions = SerialException.class) test16()214 public void test16() throws Exception { 215 SerialBlob sb = new SerialBlob(bytes); 216 InputStream is = sb.getBinaryStream(1, 6); 217 } 218 219 /* 220 * Validate a SerialException is thrown if pos > byte array length 221 */ 222 @Test(expectedExceptions = SerialException.class) test17()223 public void test17() throws Exception { 224 SerialBlob sb = new SerialBlob(bytes); 225 InputStream is = sb.getBinaryStream(bytes.length + 2, 6); 226 } 227 228 /* 229 * Validate that a cloned SerializedBlob bytes match the original 230 */ 231 @Test test18()232 public void test18() throws Exception { 233 SerialBlob sb = new SerialBlob(bytes); 234 SerialBlob sb2 = (SerialBlob) sb.clone(); 235 assertTrue( 236 Arrays.equals(sb.getBytes(1, (int) sb.length()), 237 sb2.getBytes(1, (int) sb2.length())), 238 "arrays do not match "); 239 } 240 241 /* 242 * Test clone after free has been called that the clone is not accessible 243 */ 244 @Test(expectedExceptions = SerialException.class) test19()245 public void test19() throws Exception { 246 SerialBlob sb = new SerialBlob(bytes); 247 sb.free(); 248 SerialBlob sb2 = (SerialBlob) sb.clone(); 249 InputStream is = sb2.getBinaryStream(1, 3); 250 } 251 252 /* 253 * Validate that a SerialBlob that is serialized & deserialized is equal to 254 * itself 255 */ 256 @Test test20()257 public void test20() throws Exception { 258 SerialBlob sb = new SerialBlob(bytes); 259 SerialBlob sb2 = serializeDeserializeObject(sb); 260 assertTrue(sb.equals(sb2), "SerialBlob not equal"); 261 } 262 263 /* 264 * Validate a SerialException is thrown if byte[] is used to 265 * create the SeriablBlob and setBinaryStream is called 266 */ 267 @Test(expectedExceptions = SerialException.class) test21()268 public void test21() throws Exception { 269 SerialBlob sb = new SerialBlob(bytes); 270 sb.setBinaryStream(3); 271 } 272 273 /* 274 * Validate that setBytes will properly write a set of bytes to the 275 * specified location in the SerialBlob and the correct count is returned 276 * for bytes written 277 */ 278 @Test test22()279 public void test22() throws Exception { 280 byte[] diff = new byte[]{7, 8, 9}; 281 byte[] expected = new byte[]{1, 7, 8, 9, 5}; 282 SerialBlob sb = new SerialBlob(bytes); 283 int written = sb.setBytes(2, diff); 284 assertEquals(written, diff.length); 285 assertTrue( 286 Arrays.equals(sb.getBytes(1, (int) sb.length()), 287 expected), 288 "arrays do not match "); 289 } 290 291 /* 292 * Validate that setBytes will properly write a set of bytes to the 293 * specified location in the SerialBlob and the correct count is returned 294 * for bytes written 295 */ 296 @Test test23()297 public void test23() throws Exception { 298 int bytesToWrite = 3; 299 byte[] diff = new byte[]{7, 8, 9, 0}; 300 byte[] expected = new byte[]{1, 8, 9, 0, 5}; 301 SerialBlob sb = new SerialBlob(bytes); 302 int written = sb.setBytes(2, diff, 1, bytesToWrite); 303 assertEquals(written, bytesToWrite); 304 assertTrue( 305 Arrays.equals(sb.getBytes(1, (int) sb.length()), 306 expected), 307 "arrays do not match "); 308 } 309 310 /* 311 * Validate that truncate reduces the length of the SerlizedBlob to the 312 * specified value 313 */ 314 @Test test24()315 public void test24() throws Exception { 316 SerialBlob sb = new SerialBlob(bytes); 317 sb.truncate(0); 318 assertTrue(sb.length() == 0); 319 sb = new SerialBlob(bytes); 320 sb.truncate(3); 321 assertTrue(sb.length() == 3); 322 } 323 324 /* 325 * Validate getBinaryStream returns the correct bytes 326 */ 327 @Test test25()328 public void test25() throws Exception { 329 byte[] expected = bytes; 330 SerialBlob sb = new SerialBlob(bytes); 331 InputStream is = sb.getBinaryStream(); 332 for (byte b : expected) { 333 byte val = (byte) is.read(); 334 assertTrue(b == val, val + " does not match " + b); 335 } 336 } 337 338 /* 339 * Validate setBinaryStream returns an OutputStream when passed a Blob 340 */ 341 @Test test26()342 public void test26() throws Exception { 343 SerialBlob sb = new SerialBlob(new StubBlob()); 344 OutputStream os = sb.setBinaryStream(0); 345 assertTrue(os != null); 346 } 347 348 /* 349 * Validate that position returns the correct starting location for a 350 * pattern in the SerialBlob 351 */ 352 @Test test27()353 public void test27() throws Exception { 354 long expectedPos = 3; // starting offset is 1 vs 0 355 byte[] pattern = new byte[]{3, 4}; 356 SerialBlob sb = new SerialBlob(bytes); 357 long pos = sb.position(pattern, 1); 358 assertEquals(pos, expectedPos); 359 } 360 361 /* 362 * Validate that position returns the correct starting location for a 363 * pattern in the SerialBlob 364 */ 365 @Test test28()366 public void test28() throws Exception { 367 long expectedPos = 3; // starting offset is 1 vs 0 368 byte[] pattern = new byte[]{3, 4, 5}; 369 SerialBlob sb = new SerialBlob(bytes); 370 long pos = sb.position(pattern, 2); 371 assertEquals(pos, expectedPos); 372 } 373 374 /* 375 * Validate that position returns the correct starting location for a 376 * pattern in the SerialBlob 377 */ 378 @Test test29()379 public void test29() throws Exception { 380 long expectedPos = 2; // starting offset is 1 vs 0 381 byte[] pattern = new byte[]{4, 6}; 382 SerialBlob sb = new SerialBlob(new StubBlob()); 383 long pos = sb.position(pattern, 1); 384 assertEquals(pos, expectedPos); 385 } 386 387 /* 388 * Validate that position returns the correct starting location for a 389 * pattern in the SerialBlob 390 */ 391 @Test test30()392 public void test30() throws Exception { 393 long expectedPos = 3; // starting offset is 1 vs 0 394 byte[] pattern = new byte[]{6, 8}; 395 SerialBlob sb = new SerialBlob(new StubBlob()); 396 long pos = sb.position(pattern, 2); 397 assertEquals(pos, expectedPos); 398 } 399 } 400