From ab32bf1d78f1f67cb03d590ef167f713d213bfd3 Mon Sep 17 00:00:00 2001 From: Thomas Neidhart Date: Tue, 31 Jul 2012 20:23:29 +0000 Subject: [PATCH] [COLLECTIONS-272] Added support for serialization to FixedOrderComparator and TransformingComparator, added missing equals/hashCode, renamed tests. git-svn-id: https://svn.apache.org/repos/asf/commons/proper/collections/trunk@1367748 13f79535-47bb-0310-9956-ffa450edef68 --- .../comparators/FixedOrderComparator.java | 57 +++++++++++++- .../comparators/TransformingComparator.java | 51 ++++++++++++- ...rator.java => AbstractComparatorTest.java} | 14 ++-- ...r.java => AbstractNullComparatorTest.java} | 14 ++-- ...arator.java => BooleanComparatorTest.java} | 14 ++-- ...tor.java => ComparableComparatorTest.java} | 6 +- ...torChain.java => ComparatorChainTest.java} | 15 ++-- ...tor.java => FixedOrderComparatorTest.java} | 32 ++++++-- ...arator.java => ReverseComparatorTest.java} | 11 +-- .../TransformingComparatorTest.java | 72 ++++++++++++++++++ .../data/test/ComparatorChain.version2.obj | Bin 425 -> 426 bytes .../test/FixedOrderComparator.version4.obj | Bin 0 -> 749 bytes .../test/TransformingComparator.version4.obj | Bin 0 -> 335 bytes 13 files changed, 245 insertions(+), 41 deletions(-) rename src/test/java/org/apache/commons/collections/comparators/{AbstractTestComparator.java => AbstractComparatorTest.java} (96%) rename src/test/java/org/apache/commons/collections/comparators/{AbstractTestNullComparator.java => AbstractNullComparatorTest.java} (87%) rename src/test/java/org/apache/commons/collections/comparators/{TestBooleanComparator.java => BooleanComparatorTest.java} (96%) rename src/test/java/org/apache/commons/collections/comparators/{TestComparableComparator.java => ComparableComparatorTest.java} (90%) rename src/test/java/org/apache/commons/collections/comparators/{TestComparatorChain.java => ComparatorChainTest.java} (96%) rename src/test/java/org/apache/commons/collections/comparators/{TestFixedOrderComparator.java => FixedOrderComparatorTest.java} (92%) rename src/test/java/org/apache/commons/collections/comparators/{TestReverseComparator.java => ReverseComparatorTest.java} (94%) create mode 100644 src/test/java/org/apache/commons/collections/comparators/TransformingComparatorTest.java create mode 100644 src/test/resources/data/test/FixedOrderComparator.version4.obj create mode 100644 src/test/resources/data/test/TransformingComparator.version4.obj diff --git a/src/main/java/org/apache/commons/collections/comparators/FixedOrderComparator.java b/src/main/java/org/apache/commons/collections/comparators/FixedOrderComparator.java index 9d55ec120..74751abf2 100644 --- a/src/main/java/org/apache/commons/collections/comparators/FixedOrderComparator.java +++ b/src/main/java/org/apache/commons/collections/comparators/FixedOrderComparator.java @@ -16,6 +16,7 @@ */ package org.apache.commons.collections.comparators; +import java.io.Serializable; import java.util.Comparator; import java.util.HashMap; import java.util.List; @@ -39,11 +40,16 @@ import java.util.Map; * Instances of FixedOrderComparator are not synchronized. The class is not * thread-safe at construction time, but it is thread-safe to perform * multiple comparisons after all the setup operations are complete. + *

+ * This class is Serializable from Commons Collections 4.0. * * @since 3.0 * @version $Id$ */ -public class FixedOrderComparator implements Comparator { +public class FixedOrderComparator implements Comparator, Serializable { + + /** Serialization version from Collections 4.0. */ + private static final long serialVersionUID = 82794675842863201L; /** * Unknown object behavior enum. @@ -240,4 +246,53 @@ public class FixedOrderComparator implements Comparator { return position1.compareTo(position2); } + //----------------------------------------------------------------------- + /** + * Implement a hash code for this comparator that is consistent with + * {@link #equals(Object) equals}. + * + * @return a hash code for this comparator. + */ + @Override + public int hashCode() { + int total = 17; + total = total*37 + (map == null ? 0 : map.hashCode()); + total = total*37 + (unknownObjectBehavior == null ? 0 : unknownObjectBehavior.hashCode()); + total = total*37 + counter; + total = total*37 + (isLocked ? 0 : 1); + return total; + } + + /** + * Returns true iff that Object is + * is a {@link Comparator} whose ordering is known to be + * equivalent to mine. + *

+ * This implementation returns true + * iff that is a {@link FixedOrderComparator} + * whose attributes are equal to mine. + * + * @param object the object to compare to + * @return true if equal + */ + @Override + public boolean equals(Object object) { + if (this == object) { + return true; + } + if (null == object) { + return false; + } + if (object.getClass().equals(this.getClass())) { + FixedOrderComparator comp = (FixedOrderComparator) object; + return (null == map ? null == comp.map : map.equals(comp.map) && + null == unknownObjectBehavior ? null == comp.unknownObjectBehavior : + unknownObjectBehavior == comp.unknownObjectBehavior && + counter == comp.counter && + isLocked == comp.isLocked && + unknownObjectBehavior == comp.unknownObjectBehavior); + } + return false; + } + } diff --git a/src/main/java/org/apache/commons/collections/comparators/TransformingComparator.java b/src/main/java/org/apache/commons/collections/comparators/TransformingComparator.java index 4c5bd4cca..a6cb687b6 100644 --- a/src/main/java/org/apache/commons/collections/comparators/TransformingComparator.java +++ b/src/main/java/org/apache/commons/collections/comparators/TransformingComparator.java @@ -16,6 +16,7 @@ */ package org.apache.commons.collections.comparators; +import java.io.Serializable; import java.util.Comparator; import org.apache.commons.collections.ComparatorUtils; @@ -25,6 +26,8 @@ import org.apache.commons.collections.Transformer; * Decorates another Comparator with transformation behavior. That is, the * return value from the transform operation will be passed to the decorated * {@link Comparator#compare(Object,Object) compare} method. + *

+ * This class is Serializable from Commons Collections 4.0. * * @since 2.1 * @version $Id$ @@ -32,8 +35,11 @@ import org.apache.commons.collections.Transformer; * @see org.apache.commons.collections.Transformer * @see org.apache.commons.collections.comparators.ComparableComparator */ -public class TransformingComparator implements Comparator { +public class TransformingComparator implements Comparator, Serializable { + /** Serialization version from Collections 4.0. */ + private static final long serialVersionUID = 3456940356043606220L; + /** The decorated comparator. */ protected final Comparator decorated; /** The transformer being used. */ @@ -76,5 +82,48 @@ public class TransformingComparator implements Comparator { return this.decorated.compare(value1, value2); } + //----------------------------------------------------------------------- + /** + * Implement a hash code for this comparator that is consistent with + * {@link #equals(Object) equals}. + * + * @return a hash code for this comparator. + */ + @Override + public int hashCode() { + int total = 17; + total = total*37 + (decorated == null ? 0 : decorated.hashCode()); + total = total*37 + (transformer == null ? 0 : transformer.hashCode()); + return total; + } + + /** + * Returns true iff that Object is + * is a {@link Comparator} whose ordering is known to be + * equivalent to mine. + *

+ * This implementation returns true + * iff that is a {@link TransformingComparator} + * whose attributes are equal to mine. + * + * @param object the object to compare to + * @return true if equal + */ + @Override + public boolean equals(Object object) { + if (this == object) { + return true; + } + if (null == object) { + return false; + } + if (object.getClass().equals(this.getClass())) { + TransformingComparator comp = (TransformingComparator) object; + return (null == decorated ? null == comp.decorated : decorated.equals(comp.decorated) && + null == transformer ? null == comp.transformer : transformer.equals(comp.transformer)); + } + return false; + } + } diff --git a/src/test/java/org/apache/commons/collections/comparators/AbstractTestComparator.java b/src/test/java/org/apache/commons/collections/comparators/AbstractComparatorTest.java similarity index 96% rename from src/test/java/org/apache/commons/collections/comparators/AbstractTestComparator.java rename to src/test/java/org/apache/commons/collections/comparators/AbstractComparatorTest.java index c08fd898e..e3fcbfd88 100644 --- a/src/test/java/org/apache/commons/collections/comparators/AbstractTestComparator.java +++ b/src/test/java/org/apache/commons/collections/comparators/AbstractComparatorTest.java @@ -25,23 +25,22 @@ import java.util.LinkedList; import java.util.List; import org.apache.commons.collections.AbstractTestObject; +import org.junit.Test; /** * Abstract test class for testing the Comparator interface. *

* Concrete subclasses declare the comparator to be tested. * They also declare certain aspects of the tests. - * - * @author Stephen Colebourne */ -public abstract class AbstractTestComparator extends AbstractTestObject { +public abstract class AbstractComparatorTest extends AbstractTestObject { /** * JUnit constructor. * * @param testName the test class name */ - public AbstractTestComparator(String testName) { + public AbstractComparatorTest(String testName) { super(testName); } @@ -114,6 +113,7 @@ public abstract class AbstractTestComparator extends AbstractTestObject { /** * Test sorting an empty list */ + @Test public void testEmptyListSort() { List list = new LinkedList(); sortObjects(list, makeObject()); @@ -126,6 +126,7 @@ public abstract class AbstractTestComparator extends AbstractTestObject { /** * Test sorting a reversed list. */ + @Test public void testReverseListSort() { Comparator comparator = makeObject(); @@ -142,6 +143,7 @@ public abstract class AbstractTestComparator extends AbstractTestObject { /** * Test sorting a random list. */ + @Test public void testRandomListSort() { Comparator comparator = makeObject(); @@ -166,6 +168,7 @@ public abstract class AbstractTestComparator extends AbstractTestObject { /** * Nearly all Comparators should be Serializable. */ + @Test public void testComparatorIsSerializable() { Comparator comparator = makeObject(); assertTrue("This comparator should be Serializable.", @@ -189,6 +192,7 @@ public abstract class AbstractTestComparator extends AbstractTestObject { * against the canonical version in SVN. */ @SuppressWarnings("unchecked") + @Test public void testComparatorCompatibility() throws IOException, ClassNotFoundException { if (!skipSerializedCanonicalTests()) { Comparator comparator = null; @@ -201,7 +205,7 @@ public abstract class AbstractTestComparator extends AbstractTestObject { boolean autoCreateSerialized = false; if (autoCreateSerialized) { - comparator = makeObject(); + comparator = makeObject(); String fileName = getCanonicalComparatorName(comparator); writeExternalFormToDisk((Serializable) comparator, fileName); fail("Serialized form could not be found. A serialized version " diff --git a/src/test/java/org/apache/commons/collections/comparators/AbstractTestNullComparator.java b/src/test/java/org/apache/commons/collections/comparators/AbstractNullComparatorTest.java similarity index 87% rename from src/test/java/org/apache/commons/collections/comparators/AbstractTestNullComparator.java rename to src/test/java/org/apache/commons/collections/comparators/AbstractNullComparatorTest.java index 5589ec9b6..ccffa6b05 100644 --- a/src/test/java/org/apache/commons/collections/comparators/AbstractTestNullComparator.java +++ b/src/test/java/org/apache/commons/collections/comparators/AbstractNullComparatorTest.java @@ -26,18 +26,16 @@ import junit.framework.TestSuite; /** * Test the NullComparator. * - * @version $Revision$ - * - * @author Michael A. Smith + * @version $Id$ */ -public abstract class AbstractTestNullComparator extends AbstractTestComparator { +public abstract class AbstractNullComparatorTest extends AbstractComparatorTest { - public AbstractTestNullComparator(String testName) { + public AbstractNullComparatorTest(String testName) { super(testName); } public static Test suite() { - TestSuite suite = new TestSuite(AbstractTestNullComparator.class.getName()); + TestSuite suite = new TestSuite(AbstractNullComparatorTest.class.getName()); suite.addTest(new TestSuite(TestNullComparator1.class)); suite.addTest(new TestSuite(TestNullComparator2.class)); return suite; @@ -46,7 +44,7 @@ public abstract class AbstractTestNullComparator extends AbstractTestComparator< /** * Test the NullComparator with nulls high, using comparable comparator **/ - public static class TestNullComparator1 extends AbstractTestNullComparator { + public static class TestNullComparator1 extends AbstractNullComparatorTest { public TestNullComparator1(String testName) { super(testName); @@ -78,7 +76,7 @@ public abstract class AbstractTestNullComparator extends AbstractTestComparator< /** * Test the NullComparator with nulls low using the comparable comparator **/ - public static class TestNullComparator2 extends AbstractTestNullComparator { + public static class TestNullComparator2 extends AbstractNullComparatorTest { public TestNullComparator2(String testName) { super(testName); diff --git a/src/test/java/org/apache/commons/collections/comparators/TestBooleanComparator.java b/src/test/java/org/apache/commons/collections/comparators/BooleanComparatorTest.java similarity index 96% rename from src/test/java/org/apache/commons/collections/comparators/TestBooleanComparator.java rename to src/test/java/org/apache/commons/collections/comparators/BooleanComparatorTest.java index 2fceff2aa..5ef2d5789 100644 --- a/src/test/java/org/apache/commons/collections/comparators/TestBooleanComparator.java +++ b/src/test/java/org/apache/commons/collections/comparators/BooleanComparatorTest.java @@ -20,20 +20,20 @@ import java.util.ArrayList; import java.util.Comparator; import java.util.List; +import org.junit.Test; + /** * Tests for {@link BooleanComparator}. * - * @version $Revision$ - * - * @author Rodney Waldhoff + * @version $Id$ */ @SuppressWarnings("boxing") -public class TestBooleanComparator extends AbstractTestComparator { +public class BooleanComparatorTest extends AbstractComparatorTest { // conventional // ------------------------------------------------------------------------ - public TestBooleanComparator(String testName) { + public BooleanComparatorTest(String testName) { super(testName); } @@ -65,12 +65,15 @@ public class TestBooleanComparator extends AbstractTestComparator { // tests // ------------------------------------------------------------------------ + @Test public void testConstructors() { allTests(false,new BooleanComparator()); allTests(false,new BooleanComparator(false)); allTests(true,new BooleanComparator(true)); } + @Test + public void testStaticFactoryMethods() { allTests(false,BooleanComparator.getFalseFirstComparator()); allTests(false,BooleanComparator.booleanComparator(false)); @@ -78,6 +81,7 @@ public class TestBooleanComparator extends AbstractTestComparator { allTests(true,BooleanComparator.booleanComparator(true)); } + @Test public void testEqualsCompatibleInstance() { assertEquals(new BooleanComparator(),new BooleanComparator(false)); assertEquals(new BooleanComparator(false),new BooleanComparator(false)); diff --git a/src/test/java/org/apache/commons/collections/comparators/TestComparableComparator.java b/src/test/java/org/apache/commons/collections/comparators/ComparableComparatorTest.java similarity index 90% rename from src/test/java/org/apache/commons/collections/comparators/TestComparableComparator.java rename to src/test/java/org/apache/commons/collections/comparators/ComparableComparatorTest.java index 0b1a45fe8..28e9abc46 100644 --- a/src/test/java/org/apache/commons/collections/comparators/TestComparableComparator.java +++ b/src/test/java/org/apache/commons/collections/comparators/ComparableComparatorTest.java @@ -23,13 +23,13 @@ import java.util.List; /** * Tests for ComparableComparator. * - * @version $Revision$ + * @version $Id$ * */ @SuppressWarnings("boxing") -public class TestComparableComparator extends AbstractTestComparator { +public class ComparableComparatorTest extends AbstractComparatorTest { - public TestComparableComparator(String testName) { + public ComparableComparatorTest(String testName) { super(testName); } diff --git a/src/test/java/org/apache/commons/collections/comparators/TestComparatorChain.java b/src/test/java/org/apache/commons/collections/comparators/ComparatorChainTest.java similarity index 96% rename from src/test/java/org/apache/commons/collections/comparators/TestComparatorChain.java rename to src/test/java/org/apache/commons/collections/comparators/ComparatorChainTest.java index dd07bcf3e..5b0c3a1bf 100644 --- a/src/test/java/org/apache/commons/collections/comparators/TestComparatorChain.java +++ b/src/test/java/org/apache/commons/collections/comparators/ComparatorChainTest.java @@ -21,16 +21,16 @@ import java.util.Comparator; import java.util.LinkedList; import java.util.List; +import org.junit.Test; + /** * Tests for ComparatorChain. * - * @version $Revision$ - * - * @author Unknown + * @version $Id$ */ -public class TestComparatorChain extends AbstractTestComparator { +public class ComparatorChainTest extends AbstractComparatorTest { - public TestComparatorChain(String testName) { + public ComparatorChainTest(String testName) { super(testName); } @@ -42,6 +42,7 @@ public class TestComparatorChain extends AbstractTestComparator chain = new ComparatorChain(); Integer i1 = new Integer(4); @@ -52,6 +53,7 @@ public class TestComparatorChain extends AbstractTestComparator chain = new ComparatorChain(); Integer i1 = new Integer(4); @@ -63,6 +65,7 @@ public class TestComparatorChain extends AbstractTestComparator> list = new LinkedList>(); list.add(new ComparableComparator()); @@ -74,6 +77,7 @@ public class TestComparatorChain extends AbstractTestComparator> list = new LinkedList>(); ComparatorChain chain = new ComparatorChain(list); @@ -86,6 +90,7 @@ public class TestComparatorChain extends AbstractTestComparator { /** * Top cities of the world, by population including metro areas. @@ -54,7 +51,7 @@ public class TestFixedOrderComparator extends TestCase { // Initialization and busywork // - public TestFixedOrderComparator(String name) { + public FixedOrderComparatorTest(String name) { super(name); } @@ -62,7 +59,21 @@ public class TestFixedOrderComparator extends TestCase { // Set up and tear down // + @Override + public Comparator makeObject() { + FixedOrderComparator comparator = new FixedOrderComparator(topCities); + return comparator; + } + @Override + public List getComparableObjectsOrdered() { + return Arrays.asList(topCities); + } + + @Override + public String getCompatibilityVersion() { + return "4"; + } // // The tests @@ -71,6 +82,7 @@ public class TestFixedOrderComparator extends TestCase { /** * Tests that the constructor plus add method compares items properly. */ + @Test public void testConstructorPlusAdd() { FixedOrderComparator comparator = new FixedOrderComparator(); for (int i = 0; i < topCities.length; i++) { @@ -83,6 +95,7 @@ public class TestFixedOrderComparator extends TestCase { /** * Tests that the array constructor compares items properly. */ + @Test public void testArrayConstructor() { String[] keys = topCities.clone(); String[] topCitiesForTest = topCities.clone(); @@ -96,6 +109,7 @@ public class TestFixedOrderComparator extends TestCase { /** * Tests the list constructor. */ + @Test public void testListConstructor() { String[] keys = topCities.clone(); List topCitiesForTest = new LinkedList(Arrays.asList(topCities)); @@ -109,6 +123,7 @@ public class TestFixedOrderComparator extends TestCase { /** * Tests addAsEqual method. */ + @Test public void testAddAsEqual() { FixedOrderComparator comparator = new FixedOrderComparator(topCities); comparator.addAsEqual("New York", "Minneapolis"); @@ -120,6 +135,7 @@ public class TestFixedOrderComparator extends TestCase { /** * Tests whether or not updates are disabled after a comparison is made. */ + @Test public void testLock() { FixedOrderComparator comparator = new FixedOrderComparator(topCities); assertEquals(false, comparator.isLocked()); @@ -140,6 +156,7 @@ public class TestFixedOrderComparator extends TestCase { } } + @Test public void testUnknownObjectBehavior() { FixedOrderComparator comparator = new FixedOrderComparator(topCities); try { @@ -186,7 +203,6 @@ public class TestFixedOrderComparator extends TestCase { /** Shuffles the keys and asserts that the comparator sorts them back to * their original order. */ - @SuppressWarnings("unused") private void assertComparatorYieldsOrder(String[] orderedObjects, Comparator comparator) { String[] keys = orderedObjects.clone(); diff --git a/src/test/java/org/apache/commons/collections/comparators/TestReverseComparator.java b/src/test/java/org/apache/commons/collections/comparators/ReverseComparatorTest.java similarity index 94% rename from src/test/java/org/apache/commons/collections/comparators/TestReverseComparator.java rename to src/test/java/org/apache/commons/collections/comparators/ReverseComparatorTest.java index bdffe095e..fccce6285 100644 --- a/src/test/java/org/apache/commons/collections/comparators/TestReverseComparator.java +++ b/src/test/java/org/apache/commons/collections/comparators/ReverseComparatorTest.java @@ -25,16 +25,16 @@ import java.util.Comparator; import java.util.LinkedList; import java.util.List; +import org.junit.Test; + /** * Tests for ReverseComparator. * - * @version $Revision$ - * - * @author Unknown + * @version $Id$ */ -public class TestReverseComparator extends AbstractTestComparator { +public class ReverseComparatorTest extends AbstractComparatorTest { - public TestReverseComparator(String testName) { + public ReverseComparatorTest(String testName) { super(testName); } @@ -71,6 +71,7 @@ public class TestReverseComparator extends AbstractTestComparator { */ @Override @SuppressWarnings("unchecked") + @Test public void testSerializeDeserializeThenCompare() throws Exception { Comparator comp = new ReverseComparator(new ComparableComparator()); diff --git a/src/test/java/org/apache/commons/collections/comparators/TransformingComparatorTest.java b/src/test/java/org/apache/commons/collections/comparators/TransformingComparatorTest.java new file mode 100644 index 000000000..071cb5363 --- /dev/null +++ b/src/test/java/org/apache/commons/collections/comparators/TransformingComparatorTest.java @@ -0,0 +1,72 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.collections.comparators; + +import java.util.Comparator; +import java.util.LinkedList; +import java.util.List; + +import org.apache.commons.collections.TransformerUtils; + +/** + * Test class for TransformingComparator. + * + * @version $Id$ + */ +public class TransformingComparatorTest extends AbstractComparatorTest { + + // + // Initialization and busywork + // + + public TransformingComparatorTest(String name) { + super(name); + } + + // + // Set up and tear down + // + + @Override + public Comparator makeObject() { + Comparator decorated = new ComparableComparator(); + TransformingComparator comparator = + new TransformingComparator(TransformerUtils.nopTransformer(), decorated); + return comparator; + } + + @Override + public List getComparableObjectsOrdered() { + List list = new LinkedList(); + list.add(1); + list.add(2); + list.add(3); + list.add(4); + list.add(5); + return list; + } + + @Override + public String getCompatibilityVersion() { + return "4"; + } + + // + // The tests + // + +} diff --git a/src/test/resources/data/test/ComparatorChain.version2.obj b/src/test/resources/data/test/ComparatorChain.version2.obj index e41f7489e6076a7ba3b7a2b9a065eb7f3f2ecdcb..66dcce07b3bdf6104313e8f1b7192aedbfc0a0e4 100644 GIT binary patch delta 33 ocmZ3<{9 delta 31 mcmZ3*ypnkX2cvLEYH^8ker`cxQDRAck#k03X5M6J#y$Y65(@qR diff --git a/src/test/resources/data/test/FixedOrderComparator.version4.obj b/src/test/resources/data/test/FixedOrderComparator.version4.obj new file mode 100644 index 0000000000000000000000000000000000000000..979f64e9058c094cf61c9dbefd1a0e4d672ca2a5 GIT binary patch literal 749 zcmbu7zi-n(6vtnjy7|!xN~N+PWdKHdMe0y!ln6`C57butn0U2Mwwv=kb3P~TQi+8Q zUCYkEg!)e){sLAe#KgkP%1cU3hHO}}&-%Rc_dfT0SHHl{HSCd&9Lz9?g%ePklFE6M zQUoTseor&hXh`QyKPg2x(xK2@x}mj)51xJcIYtZCJZJ<|C?oVMXePN&!9;{U)Kkn1 z-1bj!if&;N=?*a4^ z6}($!0MG{B^PRbhGgon*Vji=O-T3zT%iY&s>tOYvEeXRu2E1nvS|-*ak4c7Qw)dD5 z05)e$es1yIHqbgi>Ws0FR0T^^k>hb6BB8f`eE9hL?fD}MY982Al!YiYY%K&9^M*xw zEcCmp_xCm~zh77Y3(dNL^#NBf$=|>kG2l=c}aRw!8L|mltEz( zRNTx;t%{eRgsWO ryiuNMIQq|%wfZ-5Cl=Q>cS^&pe~s*^B3&->nQQf4bbI4NZ#4V^LDT3J literal 0 HcmV?d00001 diff --git a/src/test/resources/data/test/TransformingComparator.version4.obj b/src/test/resources/data/test/TransformingComparator.version4.obj new file mode 100644 index 0000000000000000000000000000000000000000..19d010103af5aa76a58a59bad769dbc34b90c0f4 GIT binary patch literal 335 zcmZ4UmVvdnh`}+xC|xhHATc>3RWCU|H#a}87)a;jq$ZbSLfE+liA9Me`9;NgAw`LK z#cBCPxtV$C&iOEL{huu#v^R2`VPatNVc<+jP0j}@PfaOd5cA1OEKAfcEy>K$M<}=U zVc;%-8I)R7!l2^=bb>y_3Hnec0BN`r^x@W~7Fkym0Nrd)f}5chC*`Cfobdb0Ow}EE l8_k&*7{KP45il>UG%pz(0Dk@fNRE-6D{X7Ps(cpM7yze6e{KK( literal 0 HcmV?d00001