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.tests.java.util; 19 20 import java.util.AbstractList; 21 import java.util.ArrayList; 22 import java.util.Collection; 23 import java.util.ConcurrentModificationException; 24 import java.util.List; 25 import java.util.Vector; 26 27 import junit.framework.TestCase; 28 29 public class ConcurrentModTest extends TestCase { 30 31 /* 32 * Test method for 'java.util.AbstractList.subList(int, int)' 33 */ 34 public void testGet() { 35 AbstractList al = new ArrayList(); 36 Double one = new Double(1.0); 37 Double two = new Double(2.0); 38 Double three = new Double(3.0); 39 Double four = new Double(4.0); 40 al.add(one); 41 al.add(two); 42 al.add(three); 43 al.add(four); 44 List sub = al.subList(1, 3); 45 assertEquals(2, sub.size()); 46 // the sub.get(1) is 3.0 47 assertTrue(((Double) sub.get(1)).doubleValue() <= 3.0); 48 assertTrue(((Double) sub.get(1)).doubleValue() > 2.0); 49 50 al.remove(1); // remove the 2.0 51 52 try { 53 // illegal call the subList's method get(int). 54 sub.get(1); 55 fail("It should throws ConcurrentModificationException."); 56 } catch (ConcurrentModificationException e) { 57 return; 58 } 59 60 try { 61 al.get(-1); 62 fail("IndexOutOfBoundsException expected"); 63 } catch (IndexOutOfBoundsException ee) { 64 //expected 65 } 66 67 try { 68 al.get(al.size()+1); 69 fail("IndexOutOfBoundsException expected"); 70 } catch (IndexOutOfBoundsException ee) { 71 //expected 72 } 73 } 74 75 /* 76 * Test method for 'java.util.AbstractList.subList(int, int)' 77 */ 78 public void testSet() { 79 AbstractList al = new ArrayList(); 80 Double one = new Double(1.0); 81 Double two = new Double(2.0); 82 Double three = new Double(3.0); 83 Double four = new Double(4.0); 84 al.add(one); 85 al.add(two); 86 al.add(three); 87 al.add(four); 88 List sub = al.subList(1, 3); 89 assertEquals(2, sub.size()); 90 // the sub.get(1) is 3.0 91 assertTrue(((Double) sub.get(1)).doubleValue() <= 3.0); 92 assertTrue(((Double) sub.get(1)).doubleValue() > 2.0); 93 94 al.remove(1); // remove the 2.0 95 96 try { 97 // illegal call the subList's method set(int,Object). 98 sub.set(1, two); 99 fail("It should throws ConcurrentModificationException."); 100 } catch (ConcurrentModificationException e) { 101 return; 102 } 103 } 104 105 /* 106 * Test method for 'java.util.AbstractList.subList(int, int)' 107 */ 108 public void testAdd() { 109 AbstractList al = new ArrayList(); 110 Double one = new Double(1.0); 111 Double two = new Double(2.0); 112 Double three = new Double(3.0); 113 Double four = new Double(4.0); 114 al.add(one); 115 al.add(two); 116 al.add(three); 117 al.add(four); 118 List sub = al.subList(1, 3); 119 assertEquals(2, sub.size()); 120 // the sub.get(1) is 3.0 121 assertTrue(((Double) sub.get(1)).doubleValue() <= 3.0); 122 assertTrue(((Double) sub.get(1)).doubleValue() > 2.0); 123 124 al.remove(1); // remove the 2.0 125 126 try { 127 // illegal call the subList's method Add(int,Object). 128 sub.add(1, two); 129 fail("It should throws ConcurrentModificationException."); 130 } catch (ConcurrentModificationException e) { 131 return; 132 } 133 } 134 135 /* 136 * Test method for 'java.util.AbstractList.subList(int, int)' 137 */ 138 public void testRemove() { 139 AbstractList al = new ArrayList(); 140 Double one = new Double(1.0); 141 Double two = new Double(2.0); 142 Double three = new Double(3.0); 143 Double four = new Double(4.0); 144 al.add(one); 145 al.add(two); 146 al.add(three); 147 al.add(four); 148 List sub = al.subList(1, 3); 149 assertEquals(2, sub.size()); 150 // the sub.get(1) is 3.0 151 assertTrue(((Double) sub.get(1)).doubleValue() <= 3.0); 152 assertTrue(((Double) sub.get(1)).doubleValue() > 2.0); 153 154 al.remove(1); // remove the 2.0 155 156 try { 157 // illegal call the subList's method remove(int). 158 sub.remove(1); 159 fail("It should throws ConcurrentModificationException."); 160 } catch (ConcurrentModificationException e) { 161 return; 162 } 163 164 try { 165 sub.remove(-1); 166 fail("IndexOutOfBoundsException expected"); 167 } catch (IndexOutOfBoundsException ee) { 168 //expected 169 } 170 171 try { 172 sub.remove(sub.size() + 1); 173 fail("IndexOutOfBoundsException expected"); 174 } catch (IndexOutOfBoundsException ee) { 175 //expected 176 } 177 178 al = new AbstractList() { 179 180 @Override 181 public Object get(int index) { 182 // TODO Auto-generated method stub 183 return null; 184 } 185 186 @Override 187 public int size() { 188 // TODO Auto-generated method stub 189 return 0; 190 } 191 }; 192 193 try { 194 al.remove(1); 195 fail("UnsupportedOperationException expected"); 196 } catch (UnsupportedOperationException ee) { 197 //expected 198 } 199 } 200 201 /* 202 * Test method for 'java.util.AbstractList.subList(int, int)' 203 */ 204 public void testAddAll() { 205 AbstractList al = new ArrayList(); 206 Double one = new Double(1.0); 207 Double two = new Double(2.0); 208 Double three = new Double(3.0); 209 Double four = new Double(4.0); 210 al.add(one); 211 al.add(two); 212 al.add(three); 213 al.add(four); 214 List sub = al.subList(1, 3); 215 assertEquals(2, sub.size()); 216 // the sub.get(1) is 3.0 217 assertTrue(((Double) sub.get(1)).doubleValue() <= 3.0); 218 assertTrue(((Double) sub.get(1)).doubleValue() > 2.0); 219 220 al.remove(1); // remove the 2.0 221 222 try { 223 // illegal call the subList's method addAll(int,Collection). 224 Collection c = new Vector(); 225 Double five = new Double(5.0); 226 c.add(five); 227 sub.addAll(1, c); 228 fail("It should throws ConcurrentModificationException."); 229 } catch (ConcurrentModificationException e) { 230 return; 231 } 232 } 233 234 public void test_addLjava_lang_Object() { 235 AbstractList abstr = new AbstractList() { 236 237 @Override 238 public Object get(int arg0) { 239 return null; 240 } 241 242 @Override 243 public int size() { 244 return 0; 245 } 246 247 }; 248 249 try { 250 abstr.add(null); 251 fail("UnsupportedOperationException expected"); 252 } catch (UnsupportedOperationException e) { 253 //ecpected 254 } 255 abstr = new AbstractList<Double>() { 256 @Override 257 public boolean add(Double value) { 258 return true; 259 } 260 261 @Override 262 public Double get(int index) { 263 return null; 264 } 265 266 @Override 267 public int size() { 268 return 0; 269 } 270 }; 271 272 try { 273 abstr.add(1); 274 fail("ClassCastException expected"); 275 } catch (ClassCastException ee) { 276 //expected 277 } 278 279 abstr = new AbstractList<Integer>() { 280 final int forbiddenValue = 33; 281 @Override 282 public boolean add(Integer value) { 283 if (value == forbiddenValue) { 284 throw new IllegalArgumentException(); 285 } 286 return true; 287 } 288 289 @Override 290 public Integer get(int index) { 291 return null; 292 } 293 294 @Override 295 public int size() { 296 return 0; 297 } 298 }; 299 300 abstr.add(1); 301 try { 302 abstr.add(33); 303 fail("IllegalArgumentException expected"); 304 } catch (IllegalArgumentException ee) { 305 //expected 306 } 307 } 308 309 public void test_addILjava_lang_Object() { 310 AbstractList abstr = new AbstractList() { 311 312 @Override 313 public Object get(int arg0) { 314 return null; 315 } 316 317 @Override 318 public int size() { 319 return 0; 320 } 321 322 }; 323 324 try { 325 abstr.add(1, null); 326 fail("UnsupportedOperationException expected"); 327 } catch (UnsupportedOperationException e) { 328 //ecpected 329 } 330 abstr = new AbstractList<Double>() { 331 @Override 332 public void add(int index, Double value) { 333 } 334 335 @Override 336 public Double get(int index) { 337 return null; 338 } 339 340 @Override 341 public int size() { 342 return 0; 343 } 344 }; 345 346 try { 347 abstr.add(1, 1); 348 fail("ClassCastException expected"); 349 } catch (ClassCastException ee) { 350 //expected 351 } 352 353 abstr = new AbstractList<Integer>() { 354 final int forbiddenValue = 33; 355 @Override 356 public void add(int index, Integer value) { 357 if (value == forbiddenValue) { 358 throw new IllegalArgumentException(); 359 } 360 } 361 362 @Override 363 public Integer get(int index) { 364 return null; 365 } 366 367 @Override 368 public int size() { 369 return 0; 370 } 371 }; 372 373 abstr.add(1, 1); 374 try { 375 abstr.add(1, 33); 376 fail("IllegalArgumentException expected"); 377 } catch (IllegalArgumentException ee) { 378 //expected 379 } 380 381 abstr = new ArrayList(); 382 383 abstr.add(0, "element"); 384 abstr.add(1, null); 385 abstr.add(2, 1); 386 abstr.add(3, new Double(33)); 387 388 try { 389 abstr.add(-3, new Double(33)); 390 fail("IndexOutOfBoundsException expected"); 391 } catch (IndexOutOfBoundsException ee) { 392 //expected 393 } 394 395 try { 396 abstr.add(abstr.size() + 1, new Double(33)); 397 fail("IndexOutOfBoundsException expected"); 398 } catch (IndexOutOfBoundsException ee) { 399 //expected 400 } 401 } 402 403 public void test_addAllILjava_util_Collection() { 404 Collection c = new Vector(); 405 c.add(new Double(33)); 406 c.add(10); 407 c.add("String"); 408 409 AbstractList abstr = new AbstractList() { 410 @Override 411 public Object get(int arg0) { 412 return null; 413 } 414 415 @Override 416 public int size() { 417 return 0; 418 } 419 }; 420 421 try { 422 abstr.addAll(0, null); 423 fail("NullPointerException expected"); 424 } catch (NullPointerException ee) { 425 //expected 426 } 427 428 try { 429 abstr.addAll(0, c); 430 fail("UnsuportedOperationException expected"); 431 } catch (UnsupportedOperationException ee) { 432 //expected 433 } 434 435 abstr = new AbstractList<Double>() { 436 @Override 437 public void add(int index, Double value) { 438 } 439 440 @Override 441 public Double get(int arg0) { 442 return null; 443 } 444 445 @Override 446 public int size() { 447 return 0; 448 } 449 }; 450 451 try { 452 abstr.addAll(0, c); 453 fail("ClassCastException expected"); 454 } catch (ClassCastException ee) { 455 //expectd 456 } 457 458 abstr = new AbstractList<Integer>() { 459 final int forbiddenValue = 33; 460 @Override 461 public void add(int index, Integer value) { 462 if (value == forbiddenValue) { 463 throw new IllegalArgumentException(); 464 } 465 } 466 467 @Override 468 public Integer get(int arg0) { 469 return null; 470 } 471 472 @Override 473 public int size() { 474 return 0; 475 } 476 }; 477 c.clear(); 478 c.add(new Integer(1)); 479 c.add(new Integer(2)); 480 c.add(new Integer(3)); 481 c.add(new Integer(4)); 482 c.add(new Integer(5)); 483 484 abstr.addAll(0, c); 485 486 c.add(new Integer(33)); 487 488 try { 489 abstr.addAll(0, c); 490 fail("IllegalArgumentException expected"); 491 } catch (IllegalArgumentException ee) { 492 //expected 493 } 494 abstr = new ArrayList(); 495 abstr.addAll(0, c); 496 497 try { 498 abstr.addAll(-1, c); 499 fail("IndexOutOfBoundsException expected"); 500 } catch (IndexOutOfBoundsException ee) { 501 //expected 502 } 503 504 try { 505 abstr.addAll(abstr.size() + 1, c); 506 fail("IndexOutOfBoundsException expected"); 507 } catch (IndexOutOfBoundsException ee) { 508 //expected 509 } 510 } 511 512 public void test_clear() { 513 AbstractList abstr = new ArrayList(); 514 515 assertEquals(0, abstr.size()); 516 abstr.add("String"); 517 abstr.add("1"); 518 abstr.add(2); 519 abstr.add(new Double(3)); 520 assertEquals(4, abstr.size()); 521 abstr.clear(); 522 assertEquals(0, abstr.size()); 523 } 524 525 public void test_equalsLjava_lang_Object() { 526 Collection c = new Vector(); 527 c.add(new Double(33)); 528 c.add(10); 529 c.add("String"); 530 531 AbstractList abstr = new ArrayList(); 532 AbstractList abstr1 = new ArrayList(); 533 534 assertFalse(abstr.equals(this)); 535 abstr.add(new Double(33)); 536 abstr.add(10); 537 abstr.add("String"); 538 assertTrue(abstr.equals(c)); 539 abstr1.addAll(c); 540 assertTrue(abstr.equals(abstr1)); 541 } 542 543 public void test_setILjava_lang_Object() { 544 Collection c = new Vector(); 545 c.add(new Double(33)); 546 c.add(10); 547 c.add("String"); 548 549 AbstractList abstr1 = new ArrayList(); 550 AbstractList abstr2 = new ArrayList(); 551 552 abstr1.addAll(c); 553 abstr2.addAll(c); 554 assertTrue(abstr1.equals(abstr2)); 555 abstr1.set(1, 1); 556 assertFalse(abstr1.equals(abstr2)); 557 558 try { 559 abstr1.set(abstr1.size() + 1, 1); 560 fail("IndexOutOfBoundsException expected"); 561 } catch (IndexOutOfBoundsException ee) { 562 //expected 563 } 564 565 try { 566 abstr1.set(-1, 1); 567 fail("IndexOutOfBoundsException expected"); 568 } catch (IndexOutOfBoundsException ee) { 569 //expected 570 } 571 572 AbstractList abstr = new AbstractList() { 573 574 @Override 575 public Object get(int index) { 576 return null; 577 } 578 579 @Override 580 public int size() { 581 return 0; 582 } 583 584 }; 585 586 try { 587 abstr.set(0, null); 588 fail("UnsupportedOperationException expected"); 589 } catch (UnsupportedOperationException ee) { 590 //expected 591 } 592 593 abstr = new AbstractList<Double>() { 594 @Override 595 public Double set(int index, Double value) { 596 return value; 597 } 598 599 @Override 600 public Double get(int index) { 601 return null; 602 } 603 604 @Override 605 public int size() { 606 return 0; 607 } 608 }; 609 610 try { 611 abstr.set(0, 1); 612 fail("ClassCastException expected"); 613 } catch (ClassCastException ee) { 614 //expected 615 } 616 617 abstr = new AbstractList<Integer>() { 618 final int forbiddenValue = 33; 619 @Override 620 public Integer set(int index, Integer value) { 621 if (value == forbiddenValue) { 622 throw new IllegalArgumentException(); 623 } 624 return value; 625 } 626 627 @Override 628 public Integer get(int index) { 629 return null; 630 } 631 632 @Override 633 public int size() { 634 return 0; 635 } 636 }; 637 638 try { 639 abstr.set(0, 33); 640 fail("IllegalArgumentException expected"); 641 } catch (IllegalArgumentException ee) { 642 //expected 643 } 644 } 645 class Mock_ArrayList extends ArrayList { 646 @Override 647 public void removeRange(int fromIndex, int toIndex) { 648 super.removeRange(fromIndex, toIndex); 649 } 650 } 651 652 public void test_removeRangeII() { 653 Mock_ArrayList al1 = new Mock_ArrayList(); 654 al1.add(1); 655 al1.add(2); 656 al1.add(3); 657 al1.add(4); 658 al1.add(5); 659 Mock_ArrayList al2 = new Mock_ArrayList(); 660 661 al2.add(1); 662 al2.add(5); 663 assertNotSame(al1,al2); 664 al1.removeRange(1, 4); 665 assertEquals(al1,al2); 666 } 667 } 668
