/** * @param name the name of the ref * @param value the value of the ref * @return {@code null} if the ref didn't exist already, its old value otherwise */ @Override public void putRef(String name, String value) { checkNotNull(name); checkNotNull(value); ObjectId.valueOf(value); refs.put(name, value); }
private static ObjectId id(String hash) { hash = Strings.padEnd(hash, 2 * ObjectId.NUM_BYTES, '0'); return ObjectId.valueOf(hash); } }
private static ObjectId id(String hash) { hash = Strings.padEnd(hash, 2 * ObjectId.NUM_BYTES, '0'); return ObjectId.valueOf(hash); } }
private static ObjectId id(String hash) { hash = Strings.padEnd(hash, 2 * ObjectId.NUM_BYTES, '0'); return ObjectId.valueOf(hash); } }
private static ObjectId id(@Nullable String partialHash) { if (partialHash == null) { return ObjectId.NULL; } partialHash = Strings.padEnd(partialHash, 2 * ObjectId.NUM_BYTES, '0'); return ObjectId.valueOf(partialHash); }
private static ObjectId id(String hash) { hash = Strings.padEnd(hash, 2 * ObjectId.NUM_BYTES, '0'); return ObjectId.valueOf(hash); } }
@Test public void testGetRawValue2() { byte bytes[] = new byte[] { (byte) 0xff, (byte) 0x68, (byte) 0xb7, (byte) 0x47, (byte) 0x66, (byte) 0xe2, (byte) 0x0c, (byte) 0xca, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; ObjectId id1 = ObjectId.valueOf("ff68b74766e20cca000000000000000000000000"); byte bytes2[] = id1.getRawValue(); assertTrue(Arrays.equals(bytes, bytes2)); }
@Test public void testGraphEdge() { GraphNode node1 = new TestGraphNode( ObjectId.valueOf("abc123000000000000001234567890abcdef0000")); GraphNode node2 = new TestGraphNode( ObjectId.valueOf("abc123000000000000001234567890abcdef0001")); GraphEdge edge = new GraphEdge(node1, node2); assertEquals(node1, edge.getFromNode()); assertEquals(node2, edge.getToNode()); assertEquals(node1.toString() + ":" + node2.toString(), edge.toString()); }
@Test public void testConstructorAndAccessors() { ObjectId id1 = ObjectId.valueOf("abc123000000000000001234567890abcdef0000"); ObjectId id2 = ObjectId.valueOf("abc123000000000000001234567890abcdef0001"); ObjectId id3 = ObjectId.valueOf("abc123000000000000001234567890abcdef0002"); Conflict conflict = new Conflict("Points/1", id1, id2, id3); assertEquals("Points/1", conflict.getPath()); assertEquals(id1, conflict.getAncestor()); assertEquals(id2, conflict.getOurs()); assertEquals(id3, conflict.getTheirs()); }
@Test public void testNaturalOrder() { assertEquals(0, RevTree.EMPTY.compareTo(RevTree.EMPTY)); ObjectId oId1 = ObjectId.valueOf("abc123000000000000001234567890abcdef0001"); ObjectId oId2 = ObjectId.valueOf("abc123000000000000001234567890abcdef0002"); RevFeature f1 = RevObjectFactory.defaultInstance().createFeature(oId1, Collections.singletonList("1")); RevFeature f2 = RevObjectFactory.defaultInstance().createFeature(oId2, Collections.singletonList("2")); assertTrue(f1.compareTo(f2) < 0); assertTrue(f2.compareTo(f1) > 0); }
@Test public void testHashCode() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, null, null); Node node2 = RevObjectFactory.defaultInstance().createNode("Lines.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0001"), ObjectId.NULL, TYPE.FEATURE, null, null); assertNotSame(node.hashCode(), node2.hashCode()); }
@Test public void testTree() { ObjectId oId = ObjectId.valueOf("abc123000000000000001234567890abcdef0000"); ObjectId metadataId = ObjectId.valueOf("abc123000000000000001234567890abcdef0001"); NodeRef nodeRef = NodeRef.tree("Points", oId, metadataId); assertEquals(oId, nodeRef.getObjectId()); assertEquals(metadataId, nodeRef.getMetadataId()); assertEquals("Points", nodeRef.getNode().getName()); }
@Test public void testCreateInvalidType() { exception.expect(IllegalArgumentException.class); exception.expectMessage("only FEATURE and TREE nodes can be created"); RevObjectFactory.defaultInstance().createNode("Points", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURETYPE, null, null); }
@Test public void testCompareTo() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, null, null); Node node2 = RevObjectFactory.defaultInstance().createNode("Lines.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0001"), ObjectId.NULL, TYPE.FEATURE, null, null); assertTrue(node.compareTo(node2) > 0); assertTrue(node2.compareTo(node) < 0); assertTrue(node.compareTo(node) == 0); }
@Given("^There is a tag called \"([^\"]*)\" on the \"([^\"]*)\" repo pointing to \"([^\"]*)\" with the \"([^\"]*)\" message$") public void There_is_a_tag(String tagName, String repoName, String target, String message) { Repository repo = context.getRepo(repoName); target = context.replaceVariables(target); repo.command(TagCreateOp.class).setName(tagName).setCommitId(ObjectId.valueOf(target)) .setMessage(message).call(); // add the repo to the set so it can be closed openedRepos.add(repoName); }
@Test public void testBuildEmpty() throws Exception { RevFeature emptyFeature = RevFeature.builder().build(); assertNotNull(emptyFeature); assertTrue(emptyFeature.getValues().isEmpty()); assertEquals(ObjectId.valueOf("0aaf76f425c6e0f43a36197de768e67d9e035abb"), emptyFeature.getId()); }
@Test public void testExpand() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, new Envelope(0, 1, 2, 3), null); NodeRef nodeRef = NodeRef.create("Points", node); Envelope env = new Envelope(1, 3, 1, 2); nodeRef.expand(env); assertEquals(new Envelope(0, 3, 1, 3), env); } }
@Test public void testSymRef() { Ref testRef = new Ref(Ref.REFS_PREFIX + "commit1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000")); SymRef symRef = new SymRef("TestRef", testRef); assertEquals(testRef.getName(), symRef.getTarget()); String symRefString = symRef.toString(); assertEquals("TestRef -> " + "[" + testRef.getName() + " -> " + testRef.getObjectId().toString() + "]", symRefString); } }
@Test public void testIntersects() { Node node = RevObjectFactory.defaultInstance().createNode("Points.1", ObjectId.valueOf("abc123000000000000001234567890abcdef0000"), ObjectId.NULL, TYPE.FEATURE, new Envelope(0, 1, 2, 3), null); NodeRef nodeRef = NodeRef.create("Points", node); assertTrue(nodeRef.intersects(new Envelope(0, 0.5, 2, 2.5))); assertFalse(nodeRef.intersects(new Envelope(2, 3, 2, 3))); }