public static void deepEquals(@NonNull List<Node> expected, @NonNull List<Node> actual) { assertEquals(expected.size(), actual.size()); for (int i = 0; i < expected.size(); i++) { deepEquals(expected.get(i), actual.get(i)); } }
private List<Object> createValuesAllSupportedTypes() { FieldType[] types = FieldType.values(); List<Object> values = new ArrayList<>(); for (FieldType ft : types) { if (ft != FieldType.UNKNOWN) { values.add(RevObjectTestUtil.sampleValue(ft)); } } return values; }
private static void assertDeepEquals(@NonNull Map<String, Object> expected, @NonNull Map<String, Object> actual) { assertEquals(expected.size(), actual.size()); assertEquals("Key sets don't match", new TreeSet<>(expected.keySet()), new TreeSet<>(actual.keySet())); for (String key : expected.keySet()) { Object expectedVal = expected.get(key); Object actualVal = actual.get(key); assertDeepEqualsValue(expectedVal, actualVal); } }
return new long[] { Long.MIN_VALUE, 0, Long.MAX_VALUE }; case MAP: return createExtraData(7); case INTEGER: return 7890; return new int[] { Integer.MIN_VALUE, 0, Integer.MAX_VALUE }; case GEOMETRY: return geom("POINT(9.8765 4.321)"); case GEOMETRYCOLLECTION: return geom( "GEOMETRYCOLLECTION(POINT(9.8765 4.321), LINESTRING(0 0, 0 1, 1 1, 1 0, 0 1))"); case LINESTRING: return geom("LINESTRING(0 0, 0 1, 1 1, 1 0, 0 1)"); case MULTILINESTRING: return geom("MULTILINESTRING((0 0, 0 1), (1 1, 1 0, 0 1))"); case MULTIPOINT: return geom("MULTIPOINT((9.8765 4.321), (8.8765 3.321), (7.8765 2.321))"); case MULTIPOLYGON: return geom( "MULTIPOLYGON(((0 0, 0 1, 1 1, 1 0, 0 0)), ((10 10, 10 11, 11 11, 11 10, 10 10)))"); case NULL: return null; case POINT: return geom("POINT(98.765 43.21)"); case POLYGON: return geom("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))"); case SHORT: return Short.MIN_VALUE;
public static void deepEquals(@NonNull Node expected, @NonNull Node actual) { assertEquals(expected.getName(), actual.getName()); assertEquals(expected.getObjectId(), actual.getObjectId()); assertEquals(expected.getType(), actual.getType()); assertNotNull(expected.getMetadataId()); assertNotNull(actual.getMetadataId()); assertEquals(expected.getMetadataId().orNull(), actual.getMetadataId().orNull()); assertNotNull(expected.bounds()); assertNotNull(actual.bounds()); equalsPrecise(expected.bounds().orNull(), actual.bounds().orNull()); Map<String, Object> expectedExtraData = expected.getExtraData(); Map<String, Object> actualExtraData = actual.getExtraData(); assertNotNull(expectedExtraData); assertNotNull(actualExtraData); assertDeepEquals(expectedExtraData, actualExtraData); }
public static Map<String, Object> createExtraData(int nodeIndex) { Map<String, Object> map1, map2, extraData; map1 = new HashMap<>(); map2 = new TreeMap<>(); map1.put("long", Long.valueOf(nodeIndex)); map2.put("long", Long.valueOf(nodeIndex)); map1.put("int", Integer.valueOf(1000 + nodeIndex)); map2.put("int", Integer.valueOf(1000 + nodeIndex)); map1.put("string", "hello " + nodeIndex); map2.put("string", "hello " + nodeIndex); Geometry geom = geom( String.format("LINESTRING(%d 1, 1.1 %d.1, 100 1000)", nodeIndex, nodeIndex)); map1.put("geom", geom); map2.put("geom", geom); extraData = ImmutableMap.of("I", (Object) "am", "a", (Object) "different", "map than", (Object) map1, "and", (Object) map2); return extraData; } }
public static void deepEquals(@NonNull Bucket expected, @NonNull Bucket actual) { assertEquals(expected.getObjectId(), actual.getObjectId()); assertEquals(expected.getIndex(), actual.getIndex()); assertNotNull(expected.bounds()); assertNotNull(actual.bounds()); equalsPrecise(expected.bounds().orNull(), actual.bounds().orNull()); }
assertDeepEquals((Map<String, Object>) expected, (Map<String, Object>) actual);
private static void deepEquals(@NonNull Iterable<Bucket> expected, @NonNull Iterable<Bucket> actual) { ArrayList<Bucket> e = Lists.newArrayList(expected); ArrayList<Bucket> a = Lists.newArrayList(actual); assertEquals(e.size(), a.size()); for (int i = 0; i < e.size(); i++) { deepEquals(e.get(i), a.get(i)); } }
attributeDescriptorSpecs .add(String.format("%s_type:%s", ft, ft.getBinding().getName())); attributeSampleValues.add(RevObjectTestUtil.sampleValue(ft));
public static void deepEquals(@NonNull ValueArray expected, @NonNull ValueArray actual) { assertEquals(expected.size(), actual.size()); List<Integer> geometryIndices = new ArrayList<>(); for (int i = 0; i < expected.size(); i++) { Object expectedValue = expected.get(i).orNull(); Object actualValue = actual.get(i).orNull(); if (expectedValue instanceof Geometry) { geometryIndices.add(i); } assertDeepEqualsValue(expectedValue, actualValue); } GeometryFactory providedGeomFac = new GeometryFactory(); for (int index : geometryIndices) { Optional<Geometry> geom = actual.get(index, providedGeomFac); assertTrue(geom.isPresent()); assertSame(providedGeomFac, geom.get().getFactory()); } }
private void testCreateValueArray(List<Object> values) { ValueArray actual = factory.createValueArray(values); ValueArray expected = DEFAULT.createValueArray(values); RevObjectTestUtil.deepEquals(expected, actual); }
public void testCreateNode(String name, ObjectId oid, ObjectId metadataId, TYPE type, @Nullable Envelope bounds, @Nullable Map<String, Object> extraData) { Node actual = createNode(name, oid, metadataId, type, bounds, extraData); assertNotNull(actual); Node expected = DEFAULT.createNode(name, oid, metadataId, type, bounds, extraData); RevObjectTestUtil.deepEquals(expected, actual); }
private void testCreateValueArray(Object[] values) { ValueArray actual = factory.createValueArray(values); ValueArray expected = DEFAULT.createValueArray(values); RevObjectTestUtil.deepEquals(expected, actual); }
private Bucket testCreateBucket(ObjectId bucketTree, int bucketIndex, Envelope bounds) { Bucket actual = bucket(bucketTree, bucketIndex, bounds); Bucket expected = DEFAULT.createBucket(bucketTree, bucketIndex, bounds); RevObjectTestUtil.deepEquals(expected, actual); return actual; }
@Test public void lazyFeatureNodeResolve() { DAGNode node = DAGNode.featureNode(5, 511); when(cache.resolve(eq(5))).thenReturn(featuresTree); Node resolved = node.resolve(cache); assertNotNull(resolved); Node expected = featuresTree.features().get(511); RevObjectTestUtil.deepEquals(expected, resolved); }
private void testCommit(ObjectId id, ObjectId treeId, List<ObjectId> parents, RevPerson author, RevPerson committer, String message) { RevCommit actual = factory.createCommit(id, treeId, parents, author, committer, message); assertNotNull(actual); final RevCommit expected = DEFAULT.createCommit(id, treeId, parents, author, committer, message); RevObjectTestUtil.deepEquals(expected, actual); }
private RevFeatureType testCreateFeatureType(ObjectId id, SimpleFeatureType type) { RevFeatureType actual = factory.createFeatureType(id, type); assertNotNull(actual); RevFeatureType expected = DEFAULT.createFeatureType(id, type); assertNotNull(expected); RevObjectTestUtil.deepEquals(expected, actual); return actual; }
private void testCreateFeature(ObjectId id, List<Object> values) { RevFeature actual = factory.createFeature(id, values); assertNotNull(actual); RevFeature expected = DEFAULT.createFeature(id, values); assertNotNull(expected); assertEquals(id, expected.getId()); RevObjectTestUtil.deepEquals(expected, actual); }
public static void deepEquals(@NonNull RevTree expected, @NonNull RevTree actual) { assertEquals(TYPE.TREE, actual.getType()); assertEquals(expected.getId(), expected.getId()); assertEquals(expected.size(), expected.size()); assertEquals(expected.numTrees(), expected.numTrees()); assertEquals(expected.treesSize(), expected.treesSize()); assertEquals(expected.featuresSize(), expected.featuresSize()); assertEquals(expected.bucketsSize(), expected.bucketsSize()); deepEquals(expected.trees(), actual.trees()); deepEquals(expected.features(), actual.features()); deepEquals(expected.getBuckets(), actual.getBuckets()); for (Bucket b : expected.getBuckets()) { deepEquals(b, actual.getBucket(b.getIndex()).orElse(null)); } }