1 2 package org.jgroups.tests; 3 4 5 import org.jgroups.Address; 6 import org.jgroups.Global; 7 import org.jgroups.util.Digest; 8 import org.jgroups.util.MutableDigest; 9 import org.jgroups.util.Util; 10 import org.testng.Assert; 11 import org.testng.annotations.BeforeMethod; 12 import org.testng.annotations.BeforeClass; 13 import org.testng.annotations.Test; 14 15 import java.io.*; 16 import java.util.HashMap; 17 import java.util.Map; 18 19 /** 20 * @author Bela Ban 21 */ 22 @Test(groups=Global.FUNCTIONAL, sequential=true) 23 public class DigestTest { 24 Digest d, d2; 25 MutableDigest md; 26 Address a1, a2, a3; 27 28 29 @BeforeClass beforeClass()30 void beforeClass() throws Exception { 31 a1=Util.createRandomAddress(); 32 a2=Util.createRandomAddress(); 33 a3=Util.createRandomAddress(); 34 } 35 36 @BeforeMethod beforeMethod()37 void beforeMethod() { 38 Map<Address, Digest.Entry> map=new HashMap<Address, Digest.Entry>(); 39 map.put(a1, new Digest.Entry(4, 500, 501)); 40 map.put(a2, new Digest.Entry(25, 26, 26)); 41 map.put(a3, new Digest.Entry(20, 25, 33)); 42 d=new Digest(map); 43 md=new MutableDigest(map); 44 } 45 46 testSize()47 public void testSize() { 48 d2=new Digest(3); 49 Assert.assertEquals(0, d2.size()); 50 } 51 52 testEquals()53 public void testEquals() { 54 d2=d.copy(); 55 System.out.println("d: " + d + "\nd2= " + d2); 56 Assert.assertEquals(d, d); 57 Assert.assertEquals(d, d2); 58 } 59 60 testDifference()61 public void testDifference(){ 62 Map<Address, Digest.Entry> map=new HashMap<Address, Digest.Entry>(); 63 map.put(a1, new Digest.Entry(4, 500, 501)); 64 map.put(a2, new Digest.Entry(25, 26, 26)); 65 map.put(a3, new Digest.Entry(20, 25, 33)); 66 Digest digest =new Digest(map); 67 68 Map<Address, Digest.Entry> map2=new HashMap<Address, Digest.Entry>(); 69 map2.put(a1, new Digest.Entry(4, 500, 501)); 70 map2.put(a2, new Digest.Entry(25, 26, 26)); 71 map2.put(a3, new Digest.Entry(20, 37, 33)); 72 Digest digest2 =new Digest(map2); 73 74 Assert.assertNotSame(digest, digest2); 75 76 Digest diff = digest2.difference(digest); 77 System.out.println(diff); 78 assert diff.contains(a3); 79 Assert.assertEquals(1, diff.size()); 80 81 82 Map<Address, Digest.Entry> map3=new HashMap<Address, Digest.Entry>(); 83 map3.put(a1, new Digest.Entry(4, 500, 501)); 84 map3.put(a2, new Digest.Entry(25, 26, 26)); 85 map3.put(a3, new Digest.Entry(20, 37, 33)); 86 map3.put(Util.createRandomAddress(), new Digest.Entry(1, 2, 3)); 87 Digest digest3 =new Digest(map3); 88 89 diff = digest3.difference(digest); 90 System.out.println(diff); 91 Assert.assertEquals(2, diff.size()); 92 93 diff = digest3.difference(digest2); 94 System.out.println(diff); 95 Assert.assertEquals(1, diff.size()); 96 97 Digest diff2 = digest2.difference(digest3); 98 System.out.println(diff2); 99 Assert.assertEquals(1, diff2.size()); 100 Assert.assertEquals(diff, diff2); 101 } 102 103 104 105 testIsGreaterThanOrEqual()106 public void testIsGreaterThanOrEqual() { 107 Map<Address, Digest.Entry> map=new HashMap<Address, Digest.Entry>(); 108 map.put(a1, new Digest.Entry(4, 500, 501)); 109 map.put(a2, new Digest.Entry(25, 26, 26)); 110 map.put(a3, new Digest.Entry(20, 25, 33)); 111 Digest my=new Digest(map); 112 113 System.out.println("\nd: " + d + "\nmy: " + my); 114 assert my.isGreaterThanOrEqual(d); 115 116 map.remove(a3); 117 map.put(a3, new Digest.Entry(20, 26, 33)); 118 my=new Digest(map); 119 System.out.println("\nd: " + d + "\nmy: " + my); 120 assert my.isGreaterThanOrEqual(d); 121 122 map.remove(a3); 123 map.put(a3, new Digest.Entry(20, 22, 32)); 124 my=new Digest(map); 125 System.out.println("\nd: " + d + "\nmy: " + my); 126 assert !(my.isGreaterThanOrEqual(d)); 127 } 128 129 testEquals2()130 public void testEquals2() { 131 md=new MutableDigest(d); 132 System.out.println("d: " + d + "\nmd= " + md); 133 Assert.assertEquals(d, d); 134 Assert.assertEquals(d, md); 135 md.incrementHighestDeliveredSeqno(a1); 136 System.out.println("d: " + d + "\nmd= " + md); 137 assert !(d.equals(md)); 138 } 139 140 testMutability()141 public void testMutability() { 142 Digest md2=md; 143 Assert.assertEquals(md, md2); 144 md.incrementHighestDeliveredSeqno(a2); 145 Assert.assertEquals(md, md2); 146 } 147 148 testImmutability()149 public void testImmutability() { 150 MutableDigest tmp=new MutableDigest(d); 151 Assert.assertEquals(d, tmp); 152 tmp.incrementHighestDeliveredSeqno(a2); 153 assert !(d.equals(tmp)); 154 } 155 156 157 testImmutability2()158 public void testImmutability2() { 159 Digest tmp=d.copy(); 160 Assert.assertEquals(d, tmp); 161 } 162 163 testImmutability3()164 public void testImmutability3() { 165 Digest tmp=new Digest(d); 166 Assert.assertEquals(tmp, d); 167 } 168 169 testImmutability4()170 public void testImmutability4() { 171 Digest copy=md.copy(); 172 Assert.assertEquals(copy, md); 173 md.incrementHighestDeliveredSeqno(a1); 174 assert !(copy.equals(md)); 175 } 176 177 testSeal()178 public void testSeal() { 179 MutableDigest tmp=new MutableDigest(3); 180 tmp.add(a2, 1,2,3); 181 Assert.assertEquals(1, tmp.size()); 182 tmp.seal(); 183 try { 184 tmp.add(a2, 4,5,6); 185 assert false : "should run into an exception"; 186 } 187 catch(IllegalAccessError e) { 188 System.out.println("received exception \"" + e.toString() + "\" - as expected"); 189 } 190 Assert.assertEquals(1, tmp.size()); 191 } 192 193 194 testSeal2()195 public void testSeal2() { 196 md.incrementHighestDeliveredSeqno(a1); 197 md.seal(); 198 try { 199 md.incrementHighestDeliveredSeqno(a3); 200 assert false : "should run into an exception"; 201 } 202 catch(IllegalAccessError e) { 203 System.out.println("received exception \"" + e.toString() + "\" - as expected"); 204 } 205 206 MutableDigest tmp=new MutableDigest(md); 207 tmp.incrementHighestDeliveredSeqno(a3); 208 } 209 210 testAdd()211 public void testAdd() { 212 Assert.assertEquals(3, md.size()); 213 md.add(a1, 100, 200, 201); 214 Assert.assertEquals(3, md.size()); 215 md.add(Util.createRandomAddress(), 1,2,3); 216 Assert.assertEquals(4, md.size()); 217 } 218 219 testAddDigest()220 public void testAddDigest() { 221 Digest tmp=md.copy(); 222 md.add(tmp); 223 Assert.assertEquals(3, md.size()); 224 } 225 226 testAddDigest2()227 public void testAddDigest2() { 228 MutableDigest tmp=new MutableDigest(4); 229 tmp.add(Util.createRandomAddress(), 1,2,3); 230 tmp.add(Util.createRandomAddress(), 1,2,3); 231 tmp.add(a2, 1,2,3); 232 tmp.add(a3, 1,2,3); 233 md.add(tmp); 234 Assert.assertEquals(5, md.size()); 235 } 236 237 testGet()238 public void testGet() { 239 Digest.Entry entry; 240 entry=d.get(a1); 241 Assert.assertEquals(entry, new Digest.Entry(4, 500, 501)); 242 entry=d.get(a2); 243 Assert.assertEquals(entry, new Digest.Entry(25, 26, 26)); 244 entry=d.get(a3); 245 Assert.assertEquals(entry, new Digest.Entry(20, 25, 33)); 246 } 247 248 testIncrementHighSeqno()249 public void testIncrementHighSeqno() { 250 md=new MutableDigest(3); 251 md.add(a1, 1, 100); 252 md.add(a2, 3, 300); 253 md.add(a3, 7, 700); 254 255 long tmp=md.highestDeliveredSeqnoAt(a1); 256 md.incrementHighestDeliveredSeqno(a1); 257 Assert.assertEquals(md.highestDeliveredSeqnoAt(a1), tmp + 1); 258 259 tmp=md.highestDeliveredSeqnoAt(a2); 260 md.incrementHighestDeliveredSeqno(a2); 261 Assert.assertEquals(md.highestDeliveredSeqnoAt(a2), tmp + 1); 262 263 tmp=md.highestDeliveredSeqnoAt(a3); 264 md.incrementHighestDeliveredSeqno(a3); 265 Assert.assertEquals(md.highestDeliveredSeqnoAt(a3), tmp + 1); 266 } 267 268 269 testConstructor()270 public void testConstructor() { 271 Assert.assertEquals(3, md.size()); 272 md.clear(); 273 Assert.assertEquals(0, md.size()); 274 md.clear(); 275 Assert.assertEquals(0, md.size()); 276 } 277 278 279 testConstructor2()280 public static void testConstructor2() { 281 Digest dd=new Digest(3); 282 Assert.assertEquals(0, dd.size()); 283 } 284 285 testConstructor3()286 public static void testConstructor3() { 287 Digest dd=new MutableDigest(3); 288 Assert.assertEquals(0, dd.size()); 289 } 290 291 292 testContains()293 public void testContains() { 294 assert d.contains(a1); 295 assert d.contains(a2); 296 assert d.contains(a3); 297 } 298 299 300 301 testResetAt()302 public void testResetAt() { 303 md.resetAt(a1); 304 Assert.assertEquals(0, md.lowSeqnoAt(a1)); 305 Assert.assertEquals(0, md.highestDeliveredSeqnoAt(a1)); 306 Assert.assertEquals(0, md.highestReceivedSeqnoAt(a1)); 307 } 308 309 310 testLowSeqnoAt()311 public void testLowSeqnoAt() { 312 Assert.assertEquals(4, d.lowSeqnoAt(a1)); 313 Assert.assertEquals(25, d.lowSeqnoAt(a2)); 314 Assert.assertEquals(20, d.lowSeqnoAt(a3)); 315 } 316 317 318 testHighSeqnoAt()319 public void testHighSeqnoAt() { 320 Assert.assertEquals(500, d.highestDeliveredSeqnoAt(a1)); 321 Assert.assertEquals(26, d.highestDeliveredSeqnoAt(a2)); 322 Assert.assertEquals(25, d.highestDeliveredSeqnoAt(a3)); 323 } 324 325 // public void testSetHighSeqnoAt() { 326 // assertEquals(500, md.highSeqnoAt(a1)); 327 // md.setHighSeqnoAt(a1, 555); 328 // assertEquals(555, md.highSeqnoAt(a1)); 329 // } 330 331 testHighSeqnoSeenAt()332 public void testHighSeqnoSeenAt() { 333 Assert.assertEquals(501, d.highestReceivedSeqnoAt(a1)); 334 Assert.assertEquals(26, d.highestReceivedSeqnoAt(a2)); 335 Assert.assertEquals(33, d.highestReceivedSeqnoAt(a3)); 336 } 337 338 // public void testSetHighSeenSeqnoAt() { 339 // assertEquals(26, md.highSeqnoSeenAt(a2)); 340 // md.setHighSeqnoSeenAt(a2, 100); 341 // assertEquals(100, md.highSeqnoSeenAt(a2)); 342 // } 343 344 testSetHighestDeliveredAndSeenSeqnoAt()345 public void testSetHighestDeliveredAndSeenSeqnoAt() { 346 Assert.assertEquals(4, d.lowSeqnoAt(a1)); 347 Assert.assertEquals(500, d.highestDeliveredSeqnoAt(a1)); 348 Assert.assertEquals(501, md.highestReceivedSeqnoAt(a1)); 349 md.setHighestDeliveredAndSeenSeqnos(a1, 2, 10, 20); 350 Assert.assertEquals(2, md.lowSeqnoAt(a1)); 351 Assert.assertEquals(10, md.highestDeliveredSeqnoAt(a1)); 352 Assert.assertEquals(20, md.highestReceivedSeqnoAt(a1)); 353 } 354 355 testCopy()356 public void testCopy() { 357 d=d.copy(); 358 testLowSeqnoAt(); 359 testHighSeqnoAt(); 360 testHighSeqnoSeenAt(); 361 testContains(); 362 testResetAt(); 363 } 364 365 366 testCopy2()367 public void testCopy2() { 368 Digest tmp=d.copy(); 369 Assert.assertEquals(tmp, d); 370 } 371 372 373 testMutableCopy()374 public void testMutableCopy() { 375 Digest copy=md.copy(); 376 System.out.println("md=" + md + "\ncopy=" + copy); 377 Assert.assertEquals(md, copy); 378 md.add(a1, 4, 500, 1000); 379 System.out.println("md=" + md + "\ncopy=" + copy); 380 assert !(md.equals(copy)); 381 } 382 383 384 testMerge()385 public void testMerge() { 386 Map<Address, Digest.Entry> map=new HashMap<Address, Digest.Entry>(); 387 map.put(a1, new Digest.Entry(3, 499, 502)); 388 map.put(a2, new Digest.Entry(20, 26, 27)); 389 map.put(a3, new Digest.Entry(21, 26, 35)); 390 MutableDigest digest=new MutableDigest(map); 391 392 System.out.println("d: " + d); 393 System.out.println("digest: " + digest); 394 395 digest.merge(d); 396 System.out.println("merged digest: " + digest); 397 398 Assert.assertEquals(3, d.size()); 399 Assert.assertEquals(3, digest.size()); 400 401 Assert.assertEquals(3, digest.lowSeqnoAt(a1)); 402 Assert.assertEquals(500, digest.highestDeliveredSeqnoAt(a1)); 403 Assert.assertEquals(502, digest.highestReceivedSeqnoAt(a1)); 404 405 Assert.assertEquals(20, digest.lowSeqnoAt(a2)); 406 Assert.assertEquals(26, digest.highestDeliveredSeqnoAt(a2)); 407 Assert.assertEquals(27, digest.highestReceivedSeqnoAt(a2)); 408 409 Assert.assertEquals(20, digest.lowSeqnoAt(a3)); 410 Assert.assertEquals(26, digest.highestDeliveredSeqnoAt(a3)); 411 Assert.assertEquals(35, digest.highestReceivedSeqnoAt(a3)); 412 } 413 414 testNonConflictingMerge()415 public void testNonConflictingMerge() { 416 MutableDigest cons_d=new MutableDigest(5); 417 Address ip1=Util.createRandomAddress(), ip2=Util.createRandomAddress(); 418 419 cons_d.add(ip1, 1, 10, 10); 420 cons_d.add(ip2, 2, 20, 20); 421 // System.out.println("\ncons_d before: " + cons_d); 422 cons_d.merge(d); 423 424 Assert.assertEquals(5, cons_d.size()); 425 //System.out.println("\ncons_d after: " + cons_d); 426 Assert.assertEquals(1, cons_d.lowSeqnoAt(ip1)); 427 Assert.assertEquals(2, cons_d.lowSeqnoAt(ip2)); 428 Assert.assertEquals(4, cons_d.lowSeqnoAt(a1)); 429 Assert.assertEquals(25, cons_d.lowSeqnoAt(a2)); 430 Assert.assertEquals(20, cons_d.lowSeqnoAt(a3)); 431 432 Assert.assertEquals(10, cons_d.highestDeliveredSeqnoAt(ip1)); 433 Assert.assertEquals(20, cons_d.highestDeliveredSeqnoAt(ip2)); 434 Assert.assertEquals(500, cons_d.highestDeliveredSeqnoAt(a1)); 435 Assert.assertEquals(26, cons_d.highestDeliveredSeqnoAt(a2)); 436 Assert.assertEquals(25, cons_d.highestDeliveredSeqnoAt(a3)); 437 438 Assert.assertEquals(10, cons_d.highestReceivedSeqnoAt(ip1)); 439 Assert.assertEquals(20, cons_d.highestReceivedSeqnoAt(ip2)); 440 Assert.assertEquals(501, cons_d.highestReceivedSeqnoAt(a1)); 441 Assert.assertEquals(26, cons_d.highestReceivedSeqnoAt(a2)); 442 Assert.assertEquals(33, cons_d.highestReceivedSeqnoAt(a3)); 443 } 444 445 446 testConflictingMerge()447 public void testConflictingMerge() { 448 MutableDigest new_d=new MutableDigest(2); 449 new_d.add(a1, 5, 450, 501); 450 new_d.add(a3, 18, 28, 35); 451 //System.out.println("\nd before: " + d); 452 //System.out.println("new_: " + new_d); 453 md.merge(new_d); 454 455 Assert.assertEquals(3, md.size()); 456 //System.out.println("d after: " + d); 457 458 Assert.assertEquals(4, md.lowSeqnoAt(a1)); 459 Assert.assertEquals(500, md.highestDeliveredSeqnoAt(a1)); 460 Assert.assertEquals(501, md.highestReceivedSeqnoAt(a1)); 461 462 Assert.assertEquals(25, md.lowSeqnoAt(a2)); 463 Assert.assertEquals(26, md.highestDeliveredSeqnoAt(a2)); 464 Assert.assertEquals(26, md.highestReceivedSeqnoAt(a2)); 465 466 Assert.assertEquals(18, md.lowSeqnoAt(a3)); 467 Assert.assertEquals(28, md.highestDeliveredSeqnoAt(a3)); 468 Assert.assertEquals(35, md.highestReceivedSeqnoAt(a3)); 469 } 470 471 472 testSameSendersOtherIsNull()473 public void testSameSendersOtherIsNull() { 474 assert !(d.sameSenders(null)); 475 } 476 477 testSameSenders1MNullDifferentLenth()478 public void testSameSenders1MNullDifferentLenth() { 479 d2=new Digest(1); 480 assert !(d2.sameSenders(d)); 481 } 482 483 testSameSenders1MNullSameLength()484 public void testSameSenders1MNullSameLength() { 485 d2=new Digest(3); 486 assert !(d2.sameSenders(d)); 487 } 488 489 testSameSendersIdentical()490 public void testSameSendersIdentical() { 491 d2=d.copy(); 492 assert d.sameSenders(d2); 493 } 494 495 testSameSendersNotIdentical()496 public void testSameSendersNotIdentical() { 497 MutableDigest tmp=new MutableDigest(3); 498 tmp.add(a1, 4, 500, 501); 499 tmp.add(a3, 20, 25, 33); 500 tmp.add(a2, 25, 26, 26); 501 assert md.sameSenders(tmp); 502 assert d.sameSenders(tmp); 503 } 504 505 testSameSendersNotSameLength()506 public void testSameSendersNotSameLength() { 507 md=new MutableDigest(3); 508 md.add(a1, 4, 500, 501); 509 md.add(a2, 25, 26, 26); 510 assert !(d.sameSenders(md)); 511 } 512 513 514 testStreamable()515 public void testStreamable() throws IOException, IllegalAccessException, InstantiationException { 516 ByteArrayOutputStream outstream=new ByteArrayOutputStream(); 517 DataOutputStream dos=new DataOutputStream(outstream); 518 d.writeTo(dos); 519 dos.close(); 520 byte[] buf=outstream.toByteArray(); 521 ByteArrayInputStream instream=new ByteArrayInputStream(buf); 522 DataInputStream dis=new DataInputStream(instream); 523 Digest tmp=new Digest(); 524 tmp.readFrom(dis); 525 Assert.assertEquals(d, tmp); 526 } 527 528 testSerializedSize()529 public void testSerializedSize() throws Exception { 530 long len=d.serializedSize(); 531 byte[] buf=Util.streamableToByteBuffer(d); 532 Assert.assertEquals(len, buf.length); 533 } 534 535 536 537 } 538