KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > tc > util > diff > DifferenceBuilderTest


1 /*
2  * All content copyright (c) 2003-2006 Terracotta, Inc., except as may otherwise be noted in a separate copyright notice. All rights reserved.
3  */

4 package com.tc.util.diff;
5
6 import org.apache.commons.lang.builder.EqualsBuilder;
7
8 import com.tc.test.TCTestCase;
9 import com.tc.util.Stringifier;
10
11 /**
12  * Unit test for {@link DifferenceBuilder}.
13  */

14 public class DifferenceBuilderTest extends TCTestCase {
15
16   private static boolean USE_REFLECTION = false;
17
18   public static class TestObject implements Differenceable {
19     private final boolean aBoolean;
20     private final char aChar;
21     private final byte aByte;
22     private final short aShort;
23     private final int anInt;
24     private final long aLong;
25     private final float aFloat;
26     private final double aDouble;
27     private final Object JavaDoc anObject;
28
29     private final boolean[] arrBoolean;
30     private final char[] arrChar;
31     private final byte[] arrByte;
32     private final short[] arrShort;
33     private final int[] arrInt;
34     private final long[] arrLong;
35     private final float[] arrFloat;
36     private final double[] arrDouble;
37     private final Object JavaDoc[] arrObject;
38
39     public TestObject(boolean boolean1, char char1, byte byte1, short short1, int anInt, long long1, float float1,
40                       double double1, Object JavaDoc anObject, boolean[] arrBoolean, char[] arrChar, byte[] arrByte,
41                       short[] arrShort, int[] arrInt, long[] arrLong, float[] arrFloat, double[] arrDouble,
42                       Object JavaDoc[] arrObject) {
43       super();
44
45       this.aBoolean = boolean1;
46       this.aChar = char1;
47       this.aByte = byte1;
48       this.aShort = short1;
49       this.anInt = anInt;
50       this.aLong = long1;
51       this.aFloat = float1;
52       this.aDouble = double1;
53       this.anObject = anObject;
54       this.arrBoolean = arrBoolean;
55       this.arrChar = arrChar;
56       this.arrByte = arrByte;
57       this.arrShort = arrShort;
58       this.arrInt = arrInt;
59       this.arrLong = arrLong;
60       this.arrFloat = arrFloat;
61       this.arrDouble = arrDouble;
62       this.arrObject = arrObject;
63     }
64
65     public TestObject() {
66       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
67            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
68                5, 6 }, new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f },
69            new double[] { 0.4, 0.5, 0.6 }, new Object JavaDoc[] { "foo", "bar", "baz" });
70     }
71
72     public TestObject(boolean bool) {
73       this(bool, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
74            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
75                5, 6 }, new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f },
76            new double[] { 0.4, 0.5, 0.6 }, new Object JavaDoc[] { "foo", "bar", "baz" });
77     }
78
79     public TestObject(char ch) {
80       this(true, ch, (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo", new boolean[] {
81           true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 },
82            new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5,
83                0.6 }, new Object JavaDoc[] { "foo", "bar", "baz" });
84     }
85
86     public TestObject(byte b) {
87       this(true, 'x', b, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo", new boolean[] { true,
88           false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7,
89           8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
90            new Object JavaDoc[] { "foo", "bar", "baz" });
91     }
92
93     public TestObject(short s) {
94       this(true, 'x', (byte) 37, s, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo", new boolean[] { true,
95           false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7,
96           8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
97            new Object JavaDoc[] { "foo", "bar", "baz" });
98     }
99
100     public TestObject(int i) {
101       this(true, 'x', (byte) 37, (short) 137, i, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo", new boolean[] {
102           true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 },
103            new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5,
104                0.6 }, new Object JavaDoc[] { "foo", "bar", "baz" });
105     }
106
107     public TestObject(long l) {
108       this(true, 'x', (byte) 37, (short) 137, 1238415, l, 4.34e+27f, 1.32523482759e+109, "foo", new boolean[] { true,
109           false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7,
110           8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
111            new Object JavaDoc[] { "foo", "bar", "baz" });
112     }
113
114     public TestObject(float f) {
115       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, f, 1.32523482759e+109, "foo", new boolean[] { true,
116           false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7,
117           8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
118            new Object JavaDoc[] { "foo", "bar", "baz" });
119     }
120
121     public TestObject(double d) {
122       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, d, "foo", new boolean[] { true, false,
123           true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7, 8, 9 },
124            new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 }, new Object JavaDoc[] {
125                "foo", "bar", "baz" });
126     }
127
128     public TestObject(Object JavaDoc o) {
129       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, o, new boolean[] {
130           true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 },
131            new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5,
132                0.6 }, new Object JavaDoc[] { "foo", "bar", "baz" });
133     }
134
135     public TestObject(boolean[] ab) {
136       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo", ab,
137            new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7, 8, 9 },
138            new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 }, new Object JavaDoc[] {
139                "foo", "bar", "baz" });
140     }
141
142     public TestObject(char[] ac) {
143       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
144            new boolean[] { true, false, true }, ac, new byte[] { 3, 4, 5 }, new short[] { 4, 5, 6 }, new int[] { 7, 8,
145                9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
146            new Object JavaDoc[] { "foo", "bar", "baz" });
147     }
148
149     public TestObject(byte[] ab) {
150       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
151            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, ab, new short[] { 4, 5, 6 }, new int[] {
152                7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
153            new Object JavaDoc[] { "foo", "bar", "baz" });
154     }
155
156     public TestObject(short[] as) {
157       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
158            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, as, new int[] {
159                7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
160            new Object JavaDoc[] { "foo", "bar", "baz" });
161     }
162
163     public TestObject(int[] ai) {
164       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
165            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
166                5, 6 }, ai, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
167            new Object JavaDoc[] { "foo", "bar", "baz" });
168     }
169
170     public TestObject(long[] al) {
171       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
172            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
173                5, 6 }, new int[] { 7, 8, 9 }, al, new float[] { 0.1f, 0.2f, 0.3f }, new double[] { 0.4, 0.5, 0.6 },
174            new Object JavaDoc[] { "foo", "bar", "baz" });
175     }
176
177     public TestObject(float[] af) {
178       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
179            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
180                5, 6 }, new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, af, new double[] { 0.4, 0.5, 0.6 },
181            new Object JavaDoc[] { "foo", "bar", "baz" });
182     }
183
184     public TestObject(double[] ad) {
185       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
186            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
187                5, 6 }, new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f }, ad,
188            new Object JavaDoc[] { "foo", "bar", "baz" });
189     }
190
191     public TestObject(Object JavaDoc[] ao) {
192       this(true, 'x', (byte) 37, (short) 137, 1238415, 1238947198L, 4.34e+27f, 1.32523482759e+109, "foo",
193            new boolean[] { true, false, true }, new char[] { 'a', 'b', 'c' }, new byte[] { 3, 4, 5 }, new short[] { 4,
194                5, 6 }, new int[] { 7, 8, 9 }, new long[] { 10, 11, 12 }, new float[] { 0.1f, 0.2f, 0.3f },
195            new double[] { 0.4, 0.5, 0.6 }, ao);
196     }
197
198     public void addDifferences(DifferenceContext context, Object JavaDoc rawThat) {
199       TestObject that = (TestObject) rawThat;
200
201       if (USE_REFLECTION) {
202         new DifferenceBuilder(context).reflectionDifference(this, rawThat);
203       } else {
204         new DifferenceBuilder(context).append("aBoolean", this.aBoolean, that.aBoolean).append("aChar", this.aChar,
205                                                                                                that.aChar)
206             .append("aByte", this.aByte, that.aByte).append("aShort", this.aShort, that.aShort).append("anInt",
207                                                                                                        this.anInt,
208                                                                                                        that.anInt)
209             .append("aLong", this.aLong, that.aLong).append("aFloat", this.aFloat, that.aFloat).append("aDouble",
210                                                                                                        this.aDouble,
211                                                                                                        that.aDouble)
212             .append("anObject", this.anObject, that.anObject).append("arrBoolean", this.arrBoolean, that.arrBoolean)
213             .append("arrChar", this.arrChar, that.arrChar).append("arrByte", this.arrByte, that.arrByte)
214             .append("arrShort", this.arrShort, that.arrShort).append("arrInt", this.arrInt, that.arrInt)
215             .append("arrLong", this.arrLong, that.arrLong).append("arrFloat", this.arrFloat, that.arrFloat)
216             .append("arrDouble", this.arrDouble, that.arrDouble).append("arrObject", this.arrObject, that.arrObject);
217       }
218     }
219
220     public boolean equals(Object JavaDoc that) {
221       if (!(that instanceof TestObject)) return false;
222
223       TestObject testThat = (TestObject) that;
224
225       return EqualsBuilder.reflectionEquals(this, testThat);
226     }
227   }
228
229   public void testConstruction() throws Exception JavaDoc {
230     try {
231       new DifferenceBuilder(null);
232       fail("Didn't get NPE on no context");
233     } catch (NullPointerException JavaDoc npe) {
234       // ok
235
}
236   }
237
238   public void testNoDifference() throws Exception JavaDoc {
239     TestObject one = new TestObject();
240     TestObject two = new TestObject();
241
242     assertEqualsUnordered(new Object JavaDoc[0], DifferenceBuilder.getDifferences(one, two));
243     assertEqualsUnordered(new Object JavaDoc[0], DifferenceBuilder.getDifferencesAsArray(one, two));
244   }
245
246   public void testPrimitives() throws Exception JavaDoc {
247     USE_REFLECTION = false;
248     checkPrimitives();
249     USE_REFLECTION = true;
250     checkPrimitives();
251   }
252
253   public void testPrimitiveArrays() throws Exception JavaDoc {
254     USE_REFLECTION = false;
255     checkPrimitiveArrays();
256     USE_REFLECTION = true;
257     checkPrimitiveArrays();
258   }
259
260   public void testObjects() throws Exception JavaDoc {
261     USE_REFLECTION = true;
262     checkObjects();
263     USE_REFLECTION = false;
264     checkObjects();
265   }
266
267   public void testObjectArrays() throws Exception JavaDoc {
268     USE_REFLECTION = true;
269     checkObjectArrays();
270     USE_REFLECTION = false;
271     checkObjectArrays();
272   }
273
274   public void testNestedObjects() throws Exception JavaDoc {
275     USE_REFLECTION = true;
276     checkNestedObjects();
277     USE_REFLECTION = false;
278     checkNestedObjects();
279   }
280
281   public void testUsesStringifier() throws Exception JavaDoc {
282     USE_REFLECTION = true;
283     checkStringifier();
284     USE_REFLECTION = false;
285     checkStringifier();
286   }
287
288   public void testDifferentClasses() throws Exception JavaDoc {
289     USE_REFLECTION = true;
290     checkDifferentClasses();
291     USE_REFLECTION = false;
292     checkDifferentClasses();
293   }
294
295   public void testDerivedClasses() throws Exception JavaDoc {
296     USE_REFLECTION = true;
297     checkDerivedClasses();
298     USE_REFLECTION = false;
299     checkDerivedClasses();
300   }
301
302   private static class OtherDifferenceable implements Differenceable {
303     private final Object JavaDoc a;
304
305     public OtherDifferenceable(Object JavaDoc a) {
306       this.a = a;
307     }
308
309     public void addDifferences(DifferenceContext context, Object JavaDoc that) {
310       if (USE_REFLECTION) {
311         new DifferenceBuilder(context).reflectionDifference(this, that);
312       } else {
313         new DifferenceBuilder(context).append("a", this.a, ((OtherDifferenceable) that).a);
314       }
315     }
316
317     public boolean equals(Object JavaDoc o) {
318       return (o instanceof OtherDifferenceable) && (this.a.equals(((OtherDifferenceable) o).a));
319     }
320   }
321
322   private static class FieldAdded extends OtherDifferenceable {
323     private final Object JavaDoc b;
324
325     public FieldAdded(Object JavaDoc a, Object JavaDoc b) {
326       super(a);
327       this.b = b;
328     }
329
330     public void addDifferences(DifferenceContext context, Object JavaDoc that) {
331       super.addDifferences(context, that);
332       if (USE_REFLECTION) {
333         new DifferenceBuilder(context).reflectionDifference(this, that);
334       } else {
335         new DifferenceBuilder(context).append("b", this.b, ((FieldAdded) that).b);
336       }
337     }
338
339     public boolean equals(Object JavaDoc that) {
340       if (!super.equals(that)) return false;
341       if (!(that instanceof FieldAdded)) return false;
342       return ((FieldAdded) that).b.equals(this.b);
343     }
344   }
345
346   private static class FieldIgnored extends OtherDifferenceable {
347     private final Object JavaDoc b;
348
349     public FieldIgnored(Object JavaDoc a, Object JavaDoc b) {
350       super(a);
351       this.b = b;
352     }
353
354     Object JavaDoc getB() {
355       return this.b;
356     }
357   }
358
359   private void checkDifferentClasses() throws Exception JavaDoc {
360     TestObject oneSub = new TestObject();
361     TestObject one = new TestObject(oneSub);
362     OtherDifferenceable twoSub = new OtherDifferenceable("foo");
363     TestObject two = new TestObject(twoSub);
364     OtherDifferenceable three = new OtherDifferenceable(oneSub);
365
366     DifferenceContext initial = DifferenceContext.createInitial(), context;
367     context = initial.sub("anObject");
368     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, oneSub, twoSub)) },
369                           DifferenceBuilder.getDifferences(one, two));
370
371     initial = DifferenceContext.createInitial();
372     context = initial.sub("anObject");
373     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, twoSub, oneSub)) },
374                           DifferenceBuilder.getDifferences(two, one));
375
376     initial = DifferenceContext.createInitial();
377     context = initial;
378     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, one, three)) },
379                           DifferenceBuilder.getDifferences(one, three));
380
381     initial = DifferenceContext.createInitial();
382     context = initial;
383     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, three, one)) },
384                           DifferenceBuilder.getDifferences(three, one));
385   }
386
387   private void checkDerivedClasses() throws Exception JavaDoc {
388     OtherDifferenceable base = new OtherDifferenceable("a");
389     OtherDifferenceable added = new FieldAdded("a", "b");
390     OtherDifferenceable ignored = new FieldIgnored("a", "b");
391
392     DifferenceContext initial = DifferenceContext.createInitial(), context;
393     context = initial;
394     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, base, added)) },
395                           DifferenceBuilder.getDifferences(base, added));
396
397     initial = DifferenceContext.createInitial();
398     context = initial;
399     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, added, base)) },
400                           DifferenceBuilder.getDifferences(added, base));
401
402     initial = DifferenceContext.createInitial();
403     context = initial;
404     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, base, ignored)) },
405                           DifferenceBuilder.getDifferences(base, ignored));
406
407     initial = DifferenceContext.createInitial();
408     context = initial;
409     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, ignored, base)) },
410                           DifferenceBuilder.getDifferences(ignored, base));
411   }
412
413   private void checkStringifier() throws Exception JavaDoc {
414     Stringifier s = new Stringifier() {
415       public String JavaDoc toString(Object JavaDoc o) {
416         return "X" + o + "Y";
417       }
418     };
419
420     TestObject one, two;
421     DifferenceContext initial = DifferenceContext.createInitial(s);
422
423     one = new TestObject("foo");
424     two = new TestObject("foof");
425     initial.sub("anObject");
426     Difference[] differences = DifferenceBuilder.getDifferencesAsArray(one, two, s);
427     String JavaDoc theString = differences[0].toString();
428     assertTrue(theString.indexOf("XfooY") >= 0);
429     assertTrue(theString.indexOf("XfoofY") >= 0);
430   }
431
432   private void checkNestedObjects() throws Exception JavaDoc {
433     TestObject one, two;
434     DifferenceContext initial = DifferenceContext.createInitial(), context;
435
436     TestObject diffOne = new TestObject("foo");
437     TestObject diffTwo = new TestObject("bar");
438
439     one = new TestObject(new TestObject(new Object JavaDoc[] { new TestObject(),
440         new TestObject(new Object JavaDoc[] { "a", "b", "c", "d", new TestObject(diffOne) }) }));
441     two = new TestObject(new TestObject(new Object JavaDoc[] { new TestObject(),
442         new TestObject(new Object JavaDoc[] { "a", "b", "c", "d", new TestObject(diffTwo) }) }));
443
444     context = initial.sub("anObject").sub("arrObject[1]").sub("arrObject[4]").sub("anObject").sub("anObject");
445     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, "foo", "bar")) },
446                           DifferenceBuilder.getDifferences(one, two));
447   }
448
449   private void checkObjects() throws Exception JavaDoc {
450     TestObject one, two;
451     DifferenceContext initial = DifferenceContext.createInitial(), context;
452
453     one = new TestObject("foo");
454     two = new TestObject("foof");
455     context = initial.sub("anObject");
456     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, "foo", "foof")) },
457                           DifferenceBuilder.getDifferences(one, two));
458   }
459
460   private void checkObjectArrays() throws Exception JavaDoc {
461     TestObject one, two;
462     DifferenceContext initial = DifferenceContext.createInitial(), context;
463
464     one = new TestObject(new String JavaDoc[] { "a", "foo", "b" });
465     two = new TestObject(new String JavaDoc[] { "a", "foof", "b" });
466     context = initial.sub("arrObject[1]");
467     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new BasicObjectDifference(context, "foo", "foof")) },
468                           DifferenceBuilder.getDifferences(one, two));
469   }
470
471   private void checkPrimitives() throws Exception JavaDoc {
472     TestObject one, two;
473     DifferenceContext initial = DifferenceContext.createInitial(), context;
474
475     one = new TestObject(true);
476     two = new TestObject(false);
477     context = initial.sub("aBoolean");
478     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, true, false)) },
479                           DifferenceBuilder.getDifferences(one, two));
480
481     one = new TestObject('x');
482     two = new TestObject('y');
483     context = initial.sub("aChar");
484     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 'x', 'y')) },
485                           DifferenceBuilder.getDifferences(one, two));
486
487     one = new TestObject((byte) 14);
488     two = new TestObject((byte) 15);
489     context = initial.sub("aByte");
490     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, (byte) 14, (byte) 15)) },
491                           DifferenceBuilder.getDifferences(one, two));
492
493     one = new TestObject((short) 14);
494     two = new TestObject((short) 15);
495     context = initial.sub("aShort");
496     assertEqualsUnordered(
497                           new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, (short) 14, (short) 15)) },
498                           DifferenceBuilder.getDifferences(one, two));
499
500     one = new TestObject(14);
501     two = new TestObject(15);
502     context = initial.sub("anInt");
503     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14, 15)) },
504                           DifferenceBuilder.getDifferences(one, two));
505
506     one = new TestObject(14L);
507     two = new TestObject(15L);
508     context = initial.sub("aLong");
509     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14L, 15L)) },
510                           DifferenceBuilder.getDifferences(one, two));
511
512     one = new TestObject(14.0f);
513     two = new TestObject(15.0f);
514     context = initial.sub("aFloat");
515     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14.0f, 15.0f)) },
516                           DifferenceBuilder.getDifferences(one, two));
517
518     one = new TestObject(14.0);
519     two = new TestObject(15.0);
520     context = initial.sub("aDouble");
521     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14.0, 15.0)) },
522                           DifferenceBuilder.getDifferences(one, two));
523   }
524
525   private void checkPrimitiveArrays() throws Exception JavaDoc {
526     TestObject one, two;
527     DifferenceContext initial = DifferenceContext.createInitial(), context;
528
529     one = new TestObject(new boolean[] { true, false, true });
530     two = new TestObject(new boolean[] { true, false, false });
531     context = initial.sub("arrBoolean[2]");
532     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, true, false)) },
533                           DifferenceBuilder.getDifferences(one, two));
534
535     one = new TestObject(new char[] { 'a', 'x', 'c' });
536     two = new TestObject(new char[] { 'a', 'y', 'c' });
537     context = initial.sub("arrChar[1]");
538     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 'x', 'y')) },
539                           DifferenceBuilder.getDifferences(one, two));
540
541     one = new TestObject(new byte[] { (byte) 14, (byte) 14, (byte) 15 });
542     two = new TestObject(new byte[] { (byte) 15, (byte) 14, (byte) 15 });
543     context = initial.sub("arrByte[0]");
544     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, (byte) 14, (byte) 15)) },
545                           DifferenceBuilder.getDifferences(one, two));
546
547     one = new TestObject(new short[] { (short) 3, (short) 4, (short) 14 });
548     two = new TestObject(new short[] { (short) 3, (short) 4, (short) 15 });
549     context = initial.sub("arrShort[2]");
550     assertEqualsUnordered(
551                           new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, (short) 14, (short) 15)) },
552                           DifferenceBuilder.getDifferences(one, two));
553
554     one = new TestObject(new int[] { 3, 14, 5 });
555     two = new TestObject(new int[] { 3, 15, 5 });
556     context = initial.sub("arrInt[1]");
557     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14, 15)) },
558                           DifferenceBuilder.getDifferences(one, two));
559
560     one = new TestObject(new long[] { 14, 3, 4 });
561     two = new TestObject(new long[] { 15, 3, 4 });
562     context = initial.sub("arrLong[0]");
563     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14L, 15L)) },
564                           DifferenceBuilder.getDifferences(one, two));
565
566     one = new TestObject(new float[] { 3.0f, 4.0f, 14.0f });
567     two = new TestObject(new float[] { 3.0f, 4.0f, 15.0f });
568     context = initial.sub("arrFloat[2]");
569     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14.0f, 15.0f)) },
570                           DifferenceBuilder.getDifferences(one, two));
571
572     one = new TestObject(new double[] { 3.0, 14.0, 5.0 });
573     two = new TestObject(new double[] { 3.0, 15.0, 5.0 });
574     context = initial.sub("arrDouble[1]");
575     assertEqualsUnordered(new Object JavaDoc[] { contextify(context, new PrimitiveDifference(context, 14.0, 15.0)) },
576                           DifferenceBuilder.getDifferences(one, two));
577   }
578
579   private Difference contextify(DifferenceContext context, Difference difference) {
580     context.addDifference(difference);
581     return difference;
582   }
583
584 }
Popular Tags