add equals in RangeEqualsVisitor

tianchen92 · tianchen92 · commit bce258efc0ec · 2019-08-19T20:17:00.000+08:00
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java b/java/vector/src/main/java/org/apache/arrow/vector/ExtensionTypeVector.java
@@ -259,12 +259,7 @@ public BufferAllocator getAllocator() {
   }
 
   @Override
-<<<<<<< HEAD
-  public boolean accept(RangeEqualsVisitor visitor) {
-    return getUnderlyingVector().accept(visitor);
-=======
   public <OUT, IN> OUT accept(VectorVisitor<OUT, IN> visitor, IN value) {
-    return visitor.visit(getUnderlyingVector(), value);
->>>>>>> ARROW-6211: [Java] Remove dependency on RangeEqualsVisitor from ValueVector interface
+    return getUnderlyingVector().accept(visitor, value);
   }
 }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/compare/RangeEqualsVisitor.java b/java/vector/src/main/java/org/apache/arrow/vector/compare/RangeEqualsVisitor.java
@@ -84,6 +84,28 @@ private boolean validate(ValueVector left) {
     return true;
   }
 
+  /**
+   * Check range equals without passing IN param in VectorVisitor.
+   */
+  public boolean equals(ValueVector left) {
+    if (left instanceof BaseFixedWidthVector) {
+      return visit((BaseFixedWidthVector) left, null);
+    } else if (left instanceof BaseVariableWidthVector) {
+      return visit((BaseVariableWidthVector) left, null);
+    } else if (left instanceof ListVector) {
+      return visit((ListVector) left, null);
+    } else if (left instanceof FixedSizeListVector) {
+      return visit((FixedSizeListVector) left, null);
+    } else if (left instanceof NonNullableStructVector) {
+      return visit((NonNullableStructVector) left, null);
+    } else if (left instanceof UnionVector) {
+      return visit((UnionVector) left, null);
+    } else if (left instanceof ZeroVector) {
+      return visit((ZeroVector) left, null);
+    }
+    throw new UnsupportedOperationException();
+  }
+
   @Override
   public Boolean visit(BaseFixedWidthVector left, Void value) {
     return validate(left) && compareBaseFixedWidthVectors(left);
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/compare/VectorVisitor.java b/java/vector/src/main/java/org/apache/arrow/vector/compare/VectorVisitor.java
@@ -19,7 +19,6 @@
 
 import org.apache.arrow.vector.BaseFixedWidthVector;
 import org.apache.arrow.vector.BaseVariableWidthVector;
-import org.apache.arrow.vector.ValueVector;
 import org.apache.arrow.vector.ZeroVector;
 import org.apache.arrow.vector.complex.FixedSizeListVector;
 import org.apache.arrow.vector.complex.ListVector;
@@ -46,6 +45,4 @@ public interface VectorVisitor<OUT, IN> {
   OUT visit(UnionVector left, IN value);
 
   OUT visit(ZeroVector left, IN value);
-
-  OUT visit(ValueVector left, IN value);
 }
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/dictionary/Dictionary.java b/java/vector/src/main/java/org/apache/arrow/vector/dictionary/Dictionary.java
@@ -65,7 +65,7 @@ public boolean equals(Object o) {
     }
     Dictionary that = (Dictionary) o;
     return Objects.equals(encoding, that.encoding) &&
-        dictionary.accept(new VectorEqualsVisitor(that.dictionary), null);
+        (new VectorEqualsVisitor(that.dictionary)).equals(dictionary);
   }
 
   @Override
diff --git a/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryHashTable.java b/java/vector/src/main/java/org/apache/arrow/vector/dictionary/DictionaryHashTable.java
@@ -141,8 +141,9 @@ public int getIndex(int indexInArray, ValueVector toEncode) {
     for (DictionaryHashTable.Entry e = table[index]; e != null ; e = e.next) {
       if ((e.hash == hash)) {
         int dictIndex = e.index;
-        if (toEncode.accept(new RangeEqualsVisitor(dictionary, dictIndex, indexInArray, 1, false),
-            null)) {
+
+        if (new RangeEqualsVisitor(dictionary, dictIndex, indexInArray, 1, false)
+            .equals(toEncode)) {
           return dictIndex;
         }
       }
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java b/java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java
@@ -2262,7 +2262,7 @@ public void testZeroVectorEquals() {
         final ZeroVector vector2 = new ZeroVector()) {
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2272,10 +2272,10 @@ public void testZeroVectorNotEquals() {
         final ZeroVector zeroVector = new ZeroVector()) {
 
       VectorEqualsVisitor zeroVisitor = new VectorEqualsVisitor(zeroVector);
-      assertFalse(intVector.accept(zeroVisitor, null));
+      assertFalse(zeroVisitor.equals(intVector));
 
       VectorEqualsVisitor intVisitor = new VectorEqualsVisitor(intVector);
-      assertFalse(zeroVector.accept(intVisitor, null));
+      assertFalse(intVisitor.equals(zeroVector));
     }
   }
 
@@ -2295,7 +2295,7 @@ public void testIntVectorEqualsWithNull() {
       vector2.setSafe(0, 1);
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
 
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
     }
   }
 
@@ -2318,14 +2318,14 @@ public void testIntVectorEquals() {
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
 
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
 
       vector2.setValueCount(3);
       vector2.setSafe(2, 2);
       assertFalse(vector1.equals(vector2));
 
       vector2.setSafe(2, 3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2354,8 +2354,8 @@ public void testDecimalVectorEquals() {
       VectorEqualsVisitor visitor1 = new VectorEqualsVisitor(vector2);
       VectorEqualsVisitor visitor2 = new VectorEqualsVisitor(vector3);
 
-      assertTrue(vector1.accept(visitor1, null));
-      assertFalse(vector1.accept(visitor2, null));
+      assertTrue(visitor1.equals(vector1));
+      assertFalse(visitor2.equals(vector1));
     }
   }
 
@@ -2376,7 +2376,7 @@ public void testVarcharVectorEuqalsWithNull() {
       vector2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
     }
   }
 
@@ -2399,11 +2399,11 @@ public void testVarcharVectorEquals() {
       vector2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
 
       vector2.setSafe(2, STR3, 0, STR3.length);
       vector2.setValueCount(3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2426,11 +2426,11 @@ public void testVarBinaryVectorEquals() {
       vector2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
 
       vector2.setSafe(2, STR3, 0, STR3.length);
       vector2.setValueCount(3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2458,7 +2458,7 @@ public void testListVectorEqualsWithNull() {
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
 
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
     }
   }
 
@@ -2485,12 +2485,12 @@ public void testListVectorEquals() {
       writer2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
 
       writeListVector(writer2, new int[] {5, 6});
       writer2.setValueCount(3);
 
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2520,7 +2520,7 @@ public void testStructVectorEqualsWithNull() {
       writer2.setValueCount(3);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
     }
   }
 
@@ -2549,12 +2549,12 @@ public void testStructVectorEquals() {
       writer2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
 
       writeStructVector(writer2, 3, 30L);
       writer2.setValueCount(3);
 
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2582,7 +2582,7 @@ public void testStructVectorEqualsWithDiffChild() {
       writer2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
     }
   }
 
@@ -2614,7 +2614,7 @@ public void testUnionVectorEquals() {
       vector2.setValueCount(2);
 
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -2635,7 +2635,7 @@ public void testEqualsWithIndexOutOfRange() {
       vector2.setSafe(1, 2);
 
       RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 3, 2, 1);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
diff --git a/java/vector/src/test/java/org/apache/arrow/vector/compare/TestRangeEqualsVisitor.java b/java/vector/src/test/java/org/apache/arrow/vector/compare/TestRangeEqualsVisitor.java
@@ -77,7 +77,7 @@ public void testIntVectorEqualsWithNull() {
       vector2.setSafe(0, 1);
       VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);
 
-      assertFalse(vector1.accept(visitor, null));
+      assertFalse(visitor.equals(vector1));
     }
   }
 
@@ -104,7 +104,7 @@ public void testBaseFixedWidthVectorRangeEqual() {
       vector2.setSafe(4,55);
 
       RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -132,7 +132,7 @@ public void testBaseVariableVectorRangeEquals() {
       vector2.setValueCount(5);
 
       RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -164,7 +164,7 @@ public void testListVectorRangeEquals() {
       writer2.setValueCount(5);
 
       RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -198,7 +198,7 @@ public void testStructVectorRangeEquals() {
       writer2.setValueCount(5);
 
       RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -236,7 +236,7 @@ public void testUnionVectorRangeEquals() {
       vector2.setValueCount(3);
 
       RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 2);
-      assertTrue(vector1.accept(visitor, null));
+      assertTrue(visitor.equals(vector1));
     }
   }
 
@@ -246,10 +246,10 @@ public void testEqualsWithOutTypeCheck() {
         final ZeroVector zeroVector = new ZeroVector()) {
 
       VectorEqualsVisitor zeroVisitor = new VectorEqualsVisitor(zeroVector, false);
-      assertTrue(intVector.accept(zeroVisitor, null));
+      assertTrue(zeroVisitor.equals(intVector));
 
       VectorEqualsVisitor intVisitor = new VectorEqualsVisitor(intVector, false);
-      assertTrue(zeroVector.accept(intVisitor, null));
+      assertTrue(intVisitor.equals(zeroVector));
     }
   }
 

Original file line number	Diff line number	Diff line change
`@@ -259,12 +259,7 @@ public BufferAllocator getAllocator() {`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`@Override`
`262`		`-<<<<<<< HEAD`
`263`		`- public boolean accept(RangeEqualsVisitor visitor) {`
`264`		`- return getUnderlyingVector().accept(visitor);`
`265`		`-=======`
`266`	`262`	`public <OUT, IN> OUT accept(VectorVisitor<OUT, IN> visitor, IN value) {`
`267`		`- return visitor.visit(getUnderlyingVector(), value);`
`268`		`->>>>>>> ARROW-6211: [Java] Remove dependency on RangeEqualsVisitor from ValueVector interface`
	`263`	`+ return getUnderlyingVector().accept(visitor, value);`
`269`	`264`	`}`
`270`	`265`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ public boolean equals(Object o) {`
`65`	`65`	`}`
`66`	`66`	`Dictionary that = (Dictionary) o;`
`67`	`67`	`return Objects.equals(encoding, that.encoding) &&`
`68`		`- dictionary.accept(new VectorEqualsVisitor(that.dictionary), null);`
	`68`	`+ (new VectorEqualsVisitor(that.dictionary)).equals(dictionary);`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -141,8 +141,9 @@ public int getIndex(int indexInArray, ValueVector toEncode) {`
`141`	`141`	`for (DictionaryHashTable.Entry e = table[index]; e != null ; e = e.next) {`
`142`	`142`	`if ((e.hash == hash)) {`
`143`	`143`	`int dictIndex = e.index;`
`144`		`- if (toEncode.accept(new RangeEqualsVisitor(dictionary, dictIndex, indexInArray, 1, false),`
`145`		`- null)) {`
	`144`	`+`
	`145`	`+ if (new RangeEqualsVisitor(dictionary, dictIndex, indexInArray, 1, false)`
	`146`	`+ .equals(toEncode)) {`
`146`	`147`	`return dictIndex;`
`147`	`148`	`}`
`148`	`149`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2262,7 +2262,7 @@ public void testZeroVectorEquals() {`
`2262`	`2262`	`final ZeroVector vector2 = new ZeroVector()) {`
`2263`	`2263`
`2264`	`2264`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2265`		`- assertTrue(vector1.accept(visitor, null));`
	`2265`	`+ assertTrue(visitor.equals(vector1));`
`2266`	`2266`	`}`
`2267`	`2267`	`}`
`2268`	`2268`
`@@ -2272,10 +2272,10 @@ public void testZeroVectorNotEquals() {`
`2272`	`2272`	`final ZeroVector zeroVector = new ZeroVector()) {`
`2273`	`2273`
`2274`	`2274`	`VectorEqualsVisitor zeroVisitor = new VectorEqualsVisitor(zeroVector);`
`2275`		`- assertFalse(intVector.accept(zeroVisitor, null));`
	`2275`	`+ assertFalse(zeroVisitor.equals(intVector));`
`2276`	`2276`
`2277`	`2277`	`VectorEqualsVisitor intVisitor = new VectorEqualsVisitor(intVector);`
`2278`		`- assertFalse(zeroVector.accept(intVisitor, null));`
	`2278`	`+ assertFalse(intVisitor.equals(zeroVector));`
`2279`	`2279`	`}`
`2280`	`2280`	`}`
`2281`	`2281`
`@@ -2295,7 +2295,7 @@ public void testIntVectorEqualsWithNull() {`
`2295`	`2295`	`vector2.setSafe(0, 1);`
`2296`	`2296`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2297`	`2297`
`2298`		`- assertFalse(vector1.accept(visitor, null));`
	`2298`	`+ assertFalse(visitor.equals(vector1));`
`2299`	`2299`	`}`
`2300`	`2300`	`}`
`2301`	`2301`
`@@ -2318,14 +2318,14 @@ public void testIntVectorEquals() {`
`2318`	`2318`
`2319`	`2319`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2320`	`2320`
`2321`		`- assertFalse(vector1.accept(visitor, null));`
	`2321`	`+ assertFalse(visitor.equals(vector1));`
`2322`	`2322`
`2323`	`2323`	`vector2.setValueCount(3);`
`2324`	`2324`	`vector2.setSafe(2, 2);`
`2325`	`2325`	`assertFalse(vector1.equals(vector2));`
`2326`	`2326`
`2327`	`2327`	`vector2.setSafe(2, 3);`
`2328`		`- assertTrue(vector1.accept(visitor, null));`
	`2328`	`+ assertTrue(visitor.equals(vector1));`
`2329`	`2329`	`}`
`2330`	`2330`	`}`
`2331`	`2331`
`@@ -2354,8 +2354,8 @@ public void testDecimalVectorEquals() {`
`2354`	`2354`	`VectorEqualsVisitor visitor1 = new VectorEqualsVisitor(vector2);`
`2355`	`2355`	`VectorEqualsVisitor visitor2 = new VectorEqualsVisitor(vector3);`
`2356`	`2356`
`2357`		`- assertTrue(vector1.accept(visitor1, null));`
`2358`		`- assertFalse(vector1.accept(visitor2, null));`
	`2357`	`+ assertTrue(visitor1.equals(vector1));`
	`2358`	`+ assertFalse(visitor2.equals(vector1));`
`2359`	`2359`	`}`
`2360`	`2360`	`}`
`2361`	`2361`
`@@ -2376,7 +2376,7 @@ public void testVarcharVectorEuqalsWithNull() {`
`2376`	`2376`	`vector2.setValueCount(2);`
`2377`	`2377`
`2378`	`2378`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2379`		`- assertFalse(vector1.accept(visitor, null));`
	`2379`	`+ assertFalse(visitor.equals(vector1));`
`2380`	`2380`	`}`
`2381`	`2381`	`}`
`2382`	`2382`
`@@ -2399,11 +2399,11 @@ public void testVarcharVectorEquals() {`
`2399`	`2399`	`vector2.setValueCount(2);`
`2400`	`2400`
`2401`	`2401`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2402`		`- assertFalse(vector1.accept(visitor, null));`
	`2402`	`+ assertFalse(visitor.equals(vector1));`
`2403`	`2403`
`2404`	`2404`	`vector2.setSafe(2, STR3, 0, STR3.length);`
`2405`	`2405`	`vector2.setValueCount(3);`
`2406`		`- assertTrue(vector1.accept(visitor, null));`
	`2406`	`+ assertTrue(visitor.equals(vector1));`
`2407`	`2407`	`}`
`2408`	`2408`	`}`
`2409`	`2409`
`@@ -2426,11 +2426,11 @@ public void testVarBinaryVectorEquals() {`
`2426`	`2426`	`vector2.setValueCount(2);`
`2427`	`2427`
`2428`	`2428`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2429`		`- assertFalse(vector1.accept(visitor, null));`
	`2429`	`+ assertFalse(visitor.equals(vector1));`
`2430`	`2430`
`2431`	`2431`	`vector2.setSafe(2, STR3, 0, STR3.length);`
`2432`	`2432`	`vector2.setValueCount(3);`
`2433`		`- assertTrue(vector1.accept(visitor, null));`
	`2433`	`+ assertTrue(visitor.equals(vector1));`
`2434`	`2434`	`}`
`2435`	`2435`	`}`
`2436`	`2436`
`@@ -2458,7 +2458,7 @@ public void testListVectorEqualsWithNull() {`
`2458`	`2458`
`2459`	`2459`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2460`	`2460`
`2461`		`- assertFalse(vector1.accept(visitor, null));`
	`2461`	`+ assertFalse(visitor.equals(vector1));`
`2462`	`2462`	`}`
`2463`	`2463`	`}`
`2464`	`2464`
`@@ -2485,12 +2485,12 @@ public void testListVectorEquals() {`
`2485`	`2485`	`writer2.setValueCount(2);`
`2486`	`2486`
`2487`	`2487`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2488`		`- assertFalse(vector1.accept(visitor, null));`
	`2488`	`+ assertFalse(visitor.equals(vector1));`
`2489`	`2489`
`2490`	`2490`	`writeListVector(writer2, new int[] {5, 6});`
`2491`	`2491`	`writer2.setValueCount(3);`
`2492`	`2492`
`2493`		`- assertTrue(vector1.accept(visitor, null));`
	`2493`	`+ assertTrue(visitor.equals(vector1));`
`2494`	`2494`	`}`
`2495`	`2495`	`}`
`2496`	`2496`
`@@ -2520,7 +2520,7 @@ public void testStructVectorEqualsWithNull() {`
`2520`	`2520`	`writer2.setValueCount(3);`
`2521`	`2521`
`2522`	`2522`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2523`		`- assertFalse(vector1.accept(visitor, null));`
	`2523`	`+ assertFalse(visitor.equals(vector1));`
`2524`	`2524`	`}`
`2525`	`2525`	`}`
`2526`	`2526`
`@@ -2549,12 +2549,12 @@ public void testStructVectorEquals() {`
`2549`	`2549`	`writer2.setValueCount(2);`
`2550`	`2550`
`2551`	`2551`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2552`		`- assertFalse(vector1.accept(visitor, null));`
	`2552`	`+ assertFalse(visitor.equals(vector1));`
`2553`	`2553`
`2554`	`2554`	`writeStructVector(writer2, 3, 30L);`
`2555`	`2555`	`writer2.setValueCount(3);`
`2556`	`2556`
`2557`		`- assertTrue(vector1.accept(visitor, null));`
	`2557`	`+ assertTrue(visitor.equals(vector1));`
`2558`	`2558`	`}`
`2559`	`2559`	`}`
`2560`	`2560`
`@@ -2582,7 +2582,7 @@ public void testStructVectorEqualsWithDiffChild() {`
`2582`	`2582`	`writer2.setValueCount(2);`
`2583`	`2583`
`2584`	`2584`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2585`		`- assertFalse(vector1.accept(visitor, null));`
	`2585`	`+ assertFalse(visitor.equals(vector1));`
`2586`	`2586`	`}`
`2587`	`2587`	`}`
`2588`	`2588`
`@@ -2614,7 +2614,7 @@ public void testUnionVectorEquals() {`
`2614`	`2614`	`vector2.setValueCount(2);`
`2615`	`2615`
`2616`	`2616`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`2617`		`- assertTrue(vector1.accept(visitor, null));`
	`2617`	`+ assertTrue(visitor.equals(vector1));`
`2618`	`2618`	`}`
`2619`	`2619`	`}`
`2620`	`2620`
`@@ -2635,7 +2635,7 @@ public void testEqualsWithIndexOutOfRange() {`
`2635`	`2635`	`vector2.setSafe(1, 2);`
`2636`	`2636`
`2637`	`2637`	`RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 3, 2, 1);`
`2638`		`- assertTrue(vector1.accept(visitor, null));`
	`2638`	`+ assertTrue(visitor.equals(vector1));`
`2639`	`2639`	`}`
`2640`	`2640`	`}`
`2641`	`2641`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public void testIntVectorEqualsWithNull() {`
`77`	`77`	`vector2.setSafe(0, 1);`
`78`	`78`	`VectorEqualsVisitor visitor = new VectorEqualsVisitor(vector2);`
`79`	`79`
`80`		`- assertFalse(vector1.accept(visitor, null));`
	`80`	`+ assertFalse(visitor.equals(vector1));`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`
`@@ -104,7 +104,7 @@ public void testBaseFixedWidthVectorRangeEqual() {`
`104`	`104`	`vector2.setSafe(4,55);`
`105`	`105`
`106`	`106`	`RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);`
`107`		`- assertTrue(vector1.accept(visitor, null));`
	`107`	`+ assertTrue(visitor.equals(vector1));`
`108`	`108`	`}`
`109`	`109`	`}`
`110`	`110`
`@@ -132,7 +132,7 @@ public void testBaseVariableVectorRangeEquals() {`
`132`	`132`	`vector2.setValueCount(5);`
`133`	`133`
`134`	`134`	`RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);`
`135`		`- assertTrue(vector1.accept(visitor, null));`
	`135`	`+ assertTrue(visitor.equals(vector1));`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`@@ -164,7 +164,7 @@ public void testListVectorRangeEquals() {`
`164`	`164`	`writer2.setValueCount(5);`
`165`	`165`
`166`	`166`	`RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);`
`167`		`- assertTrue(vector1.accept(visitor, null));`
	`167`	`+ assertTrue(visitor.equals(vector1));`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`@@ -198,7 +198,7 @@ public void testStructVectorRangeEquals() {`
`198`	`198`	`writer2.setValueCount(5);`
`199`	`199`
`200`	`200`	`RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 3);`
`201`		`- assertTrue(vector1.accept(visitor, null));`
	`201`	`+ assertTrue(visitor.equals(vector1));`
`202`	`202`	`}`
`203`	`203`	`}`
`204`	`204`
`@@ -236,7 +236,7 @@ public void testUnionVectorRangeEquals() {`
`236`	`236`	`vector2.setValueCount(3);`
`237`	`237`
`238`	`238`	`RangeEqualsVisitor visitor = new RangeEqualsVisitor(vector2, 1, 1, 2);`
`239`		`- assertTrue(vector1.accept(visitor, null));`
	`239`	`+ assertTrue(visitor.equals(vector1));`
`240`	`240`	`}`
`241`	`241`	`}`
`242`	`242`
`@@ -246,10 +246,10 @@ public void testEqualsWithOutTypeCheck() {`
`246`	`246`	`final ZeroVector zeroVector = new ZeroVector()) {`
`247`	`247`
`248`	`248`	`VectorEqualsVisitor zeroVisitor = new VectorEqualsVisitor(zeroVector, false);`
`249`		`- assertTrue(intVector.accept(zeroVisitor, null));`
	`249`	`+ assertTrue(zeroVisitor.equals(intVector));`
`250`	`250`
`251`	`251`	`VectorEqualsVisitor intVisitor = new VectorEqualsVisitor(intVector, false);`
`252`		`- assertTrue(zeroVector.accept(intVisitor, null));`
	`252`	`+ assertTrue(intVisitor.equals(zeroVector));`
`253`	`253`	`}`
`254`	`254`	`}`
`255`	`255`