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