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 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)); } }
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)); } }
@Test public void testCreateTypeTreeAutomaticallyWhenInsertingWitNoExistingTypeTree() throws Exception { insert(points1, points2); Optional<NodeRef> treeRef = repo.command(FindTreeChild.class).setChildPath(pointsName) .setParent(workTree.getTree()).call(); assertTrue(treeRef.isPresent()); assertTrue(treeRef.get().getNode().getMetadataId().isPresent()); assertFalse(treeRef.get().getNode().getMetadataId().get().isNull()); RevFeatureType featureType = repo.objectDatabase() .getFeatureType(treeRef.get().getMetadataId()); RevObjectTestUtil.deepEquals(RevFeatureType.builder().type(pointsType).build(), featureType); }
private RevTree testCreateLeafTree(ObjectId id, long size, List<Node> trees, List<Node> features) { RevTree actual = factory.createTree(id, size, trees, features); assertNotNull(actual); RevTree expected = DEFAULT.createTree(id, size, trees, features); assertNotNull(expected); assertEquals(id, expected.getId()); assertEquals(size, expected.size()); assertEquals(trees.size(), expected.numTrees()); assertEquals(trees.size(), expected.treesSize()); assertEquals(features.size(), expected.featuresSize()); assertEquals(0, expected.bucketsSize()); RevObjectTestUtil.deepEquals(expected, actual); return actual; }
private RevTree testCreateTree(ObjectId id, @Nonnegative long size, int childTreeCount, SortedSet<Bucket> buckets) { RevTree actual = factory.createTree(id, size, childTreeCount, buckets); assertNotNull(actual); RevTree expected = DEFAULT.createTree(id, size, childTreeCount, buckets); assertNotNull(expected); assertEquals(id, expected.getId()); assertEquals(size, expected.size()); assertEquals(0, expected.treesSize()); assertEquals(0, expected.featuresSize()); assertEquals(childTreeCount, expected.numTrees()); assertEquals(buckets.size(), expected.bucketsSize()); RevObjectTestUtil.deepEquals(expected, actual); return actual; }
@Test public void testConstructorAndAccessors() { RevFeatureType featureType = RevFeatureType.builder().type(linesType).build(); assertEquals(RevObject.TYPE.FEATURETYPE, featureType.getType()); RevObjectTestUtil.deepEquals(RevFeatureType.builder().type(linesType).build(), featureType); }
@Test public void testCreateTypeNestedNonExistingParent() throws Exception { NodeRef treeRef = workTree.createTypeTree("path/to/nested/type", pointsType); assertNotNull(treeRef); assertEquals("path/to/nested/type", treeRef.path()); assertEquals("path/to/nested", treeRef.getParentPath()); assertTrue(treeRef.getNode().getMetadataId().isPresent()); assertEquals(treeRef.getMetadataId(), treeRef.getNode().getMetadataId().get()); RevFeatureType featureType = repo.objectDatabase().getFeatureType(treeRef.getMetadataId()); RevObjectTestUtil.deepEquals(RevFeatureType.builder().type(pointsType).build(), featureType); }
@Test public void testCreateTypeTree() throws Exception { NodeRef treeRef = workTree.createTypeTree("points2", pointsType); assertNotNull(treeRef); assertEquals("points2", treeRef.path()); assertEquals("", treeRef.getParentPath()); assertTrue(treeRef.getNode().getMetadataId().isPresent()); assertEquals(treeRef.getMetadataId(), treeRef.getNode().getMetadataId().get()); RevFeatureType featureType = repo.objectDatabase().getFeatureType(treeRef.getMetadataId()); RevObjectTestUtil.deepEquals(RevFeatureType.builder().type(pointsType).build(), featureType); }