diff options
Diffstat (limited to 'org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java')
| -rw-r--r-- | org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java | 263 |
1 files changed, 198 insertions, 65 deletions
diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java index f2ed684511..7590048a71 100644 --- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java +++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/lib/RefTest.java @@ -1,50 +1,18 @@ /* * Copyright (C) 2009-2010, Google Inc. * Copyright (C) 2009, Robin Rosenberg - * Copyright (C) 2009, Robin Rosenberg <robin.rosenberg@dewire.com> - * and other copyright owners as documented in the project's IP log. + * Copyright (C) 2009, Robin Rosenberg <robin.rosenberg@dewire.com> and others * - * This program and the accompanying materials are made available - * under the terms of the Eclipse Distribution License v1.0 which - * accompanies this distribution, is reproduced below, and is - * available at http://www.eclipse.org/org/documents/edl-v10.php + * This program and the accompanying materials are made available under the + * terms of the Eclipse Distribution License v. 1.0 which is available at + * https://www.eclipse.org/org/documents/edl-v10.php. * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or - * without modification, are permitted provided that the following - * conditions are met: - * - * - Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * - Redistributions in binary form must reproduce the above - * copyright notice, this list of conditions and the following - * disclaimer in the documentation and/or other materials provided - * with the distribution. - * - * - Neither the name of the Eclipse Foundation, Inc. nor the - * names of its contributors may be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND - * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER - * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, - * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * SPDX-License-Identifier: BSD-3-Clause */ package org.eclipse.jgit.lib; +import static java.nio.charset.StandardCharsets.UTF_8; import static org.eclipse.jgit.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -57,7 +25,11 @@ import static org.junit.Assert.fail; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; -import java.util.Map; +import java.util.Collection; +import java.util.HashSet; +import java.util.List; +import java.util.Optional; +import java.util.Set; import java.util.TreeSet; import org.eclipse.jgit.lib.Ref.Storage; @@ -84,6 +56,12 @@ public class RefTest extends SampleDataRepositoryTestCase { } } + private void writeNewRef(String name, ObjectId value) throws IOException { + RefUpdate updateRef = db.updateRef(name); + updateRef.setNewObjectId(value); + assertEquals(RefUpdate.Result.NEW, updateRef.update()); + } + @Test public void testRemoteNames() throws Exception { FileBasedConfig config = db.getConfig(); @@ -93,7 +71,7 @@ public class RefTest extends SampleDataRepositoryTestCase { "ab/c", "dummy", true); config.save(); assertEquals("[ab/c, origin]", - new TreeSet<String>(db.getRemoteNames()).toString()); + new TreeSet<>(db.getRemoteNames()).toString()); // one-level deep remote branch assertEquals("master", @@ -141,23 +119,28 @@ public class RefTest extends SampleDataRepositoryTestCase { ObjectId r = db.resolve("refs/remotes/origin/HEAD"); assertEquals(masterId, r); - Map<String, Ref> allRefs = db.getAllRefs(); - Ref refHEAD = allRefs.get("refs/remotes/origin/HEAD"); - assertNotNull(refHEAD); - assertEquals(masterId, refHEAD.getObjectId()); - assertFalse(refHEAD.isPeeled()); - assertNull(refHEAD.getPeeledObjectId()); - - Ref refmaster = allRefs.get("refs/remotes/origin/master"); - assertEquals(masterId, refmaster.getObjectId()); - assertFalse(refmaster.isPeeled()); - assertNull(refmaster.getPeeledObjectId()); + List<Ref> allRefs = db.getRefDatabase().getRefs(); + Optional<Ref> refHEAD = allRefs.stream() + .filter(ref -> ref.getName().equals("refs/remotes/origin/HEAD")) + .findAny(); + assertTrue(refHEAD.isPresent()); + assertEquals(masterId, refHEAD.get().getObjectId()); + assertFalse(refHEAD.get().isPeeled()); + assertNull(refHEAD.get().getPeeledObjectId()); + + Optional<Ref> refmaster = allRefs.stream().filter( + ref -> ref.getName().equals("refs/remotes/origin/master")) + .findAny(); + assertTrue(refmaster.isPresent()); + assertEquals(masterId, refmaster.get().getObjectId()); + assertFalse(refmaster.get().isPeeled()); + assertNull(refmaster.get().getPeeledObjectId()); } @Test public void testReadSymRefToPacked() throws IOException { writeSymref("HEAD", "refs/heads/b"); - Ref ref = db.getRef("HEAD"); + Ref ref = db.exactRef("HEAD"); assertEquals(Ref.Storage.LOOSE, ref.getStorage()); assertTrue("is symref", ref.isSymbolic()); ref = ref.getTarget(); @@ -175,7 +158,7 @@ public class RefTest extends SampleDataRepositoryTestCase { assertEquals(Result.FORCED, update); // internal writeSymref("HEAD", "refs/heads/master"); - Ref ref = db.getRef("HEAD"); + Ref ref = db.exactRef("HEAD"); assertEquals(Ref.Storage.LOOSE, ref.getStorage()); ref = ref.getTarget(); assertEquals("refs/heads/master", ref.getName()); @@ -188,10 +171,54 @@ public class RefTest extends SampleDataRepositoryTestCase { updateRef.setNewObjectId(db.resolve("refs/heads/master")); Result update = updateRef.update(); assertEquals(Result.NEW, update); - Ref ref = db.getRef("ref/heads/new"); + Ref ref = db.exactRef("ref/heads/new"); assertEquals(Storage.LOOSE, ref.getStorage()); } + @Test + public void testGetShortRef() throws IOException { + Ref ref = db.exactRef("refs/heads/master"); + assertEquals("refs/heads/master", ref.getName()); + assertEquals(db.resolve("refs/heads/master"), ref.getObjectId()); + } + + @Test + public void testGetShortExactRef() throws IOException { + assertNull(db.getRefDatabase().exactRef("master")); + + Ref ref = db.getRefDatabase().exactRef("HEAD"); + assertEquals("HEAD", ref.getName()); + assertEquals("refs/heads/master", ref.getTarget().getName()); + assertEquals(db.resolve("refs/heads/master"), ref.getObjectId()); + } + + @Test + public void testRefsUnderRefs() throws IOException { + ObjectId masterId = db.resolve("refs/heads/master"); + writeNewRef("refs/heads/refs/foo/bar", masterId); + + assertNull(db.getRefDatabase().exactRef("refs/foo/bar")); + + Ref ref = db.findRef("refs/foo/bar"); + assertEquals("refs/heads/refs/foo/bar", ref.getName()); + assertEquals(db.resolve("refs/heads/master"), ref.getObjectId()); + } + + @Test + public void testAmbiguousRefsUnderRefs() throws IOException { + ObjectId masterId = db.resolve("refs/heads/master"); + writeNewRef("refs/foo/bar", masterId); + writeNewRef("refs/heads/refs/foo/bar", masterId); + + Ref exactRef = db.getRefDatabase().exactRef("refs/foo/bar"); + assertEquals("refs/foo/bar", exactRef.getName()); + assertEquals(masterId, exactRef.getObjectId()); + + Ref ref = db.findRef("refs/foo/bar"); + assertEquals("refs/foo/bar", ref.getName()); + assertEquals(masterId, ref.getObjectId()); + } + /** * Let an "outsider" create a loose ref with the same name as a packed one * @@ -201,15 +228,15 @@ public class RefTest extends SampleDataRepositoryTestCase { @Test public void testReadLoosePackedRef() throws IOException, InterruptedException { - Ref ref = db.getRef("refs/heads/master"); + Ref ref = db.exactRef("refs/heads/master"); assertEquals(Storage.PACKED, ref.getStorage()); - FileOutputStream os = new FileOutputStream(new File(db.getDirectory(), - "refs/heads/master")); - os.write(ref.getObjectId().name().getBytes()); - os.write('\n'); - os.close(); + try (FileOutputStream os = new FileOutputStream( + new File(db.getDirectory(), "refs/heads/master"))) { + os.write(ref.getObjectId().name().getBytes(UTF_8)); + os.write('\n'); + } - ref = db.getRef("refs/heads/master"); + ref = db.exactRef("refs/heads/master"); assertEquals(Storage.LOOSE, ref.getStorage()); } @@ -221,7 +248,7 @@ public class RefTest extends SampleDataRepositoryTestCase { */ @Test public void testReadSimplePackedRefSameRepo() throws IOException { - Ref ref = db.getRef("refs/heads/master"); + Ref ref = db.exactRef("refs/heads/master"); ObjectId pid = db.resolve("refs/heads/master^"); assertEquals(Storage.PACKED, ref.getStorage()); RefUpdate updateRef = db.updateRef("refs/heads/master"); @@ -230,19 +257,19 @@ public class RefTest extends SampleDataRepositoryTestCase { Result update = updateRef.update(); assertEquals(Result.FORCED, update); - ref = db.getRef("refs/heads/master"); + ref = db.exactRef("refs/heads/master"); assertEquals(Storage.LOOSE, ref.getStorage()); } @Test public void testResolvedNamesBranch() throws IOException { - Ref ref = db.getRef("a"); + Ref ref = db.findRef("a"); assertEquals("refs/heads/a", ref.getName()); } @Test public void testResolvedSymRef() throws IOException { - Ref ref = db.getRef(Constants.HEAD); + Ref ref = db.exactRef(Constants.HEAD); assertEquals(Constants.HEAD, ref.getName()); assertTrue("is symbolic ref", ref.isSymbolic()); assertSame(Ref.Storage.LOOSE, ref.getStorage()); @@ -255,4 +282,110 @@ public class RefTest extends SampleDataRepositoryTestCase { assertSame(dst.getPeeledObjectId(), ref.getPeeledObjectId()); assertEquals(dst.isPeeled(), ref.isPeeled()); } + + private static void checkContainsRef(Collection<Ref> haystack, Ref needle) { + for (Ref ref : haystack) { + if (ref.getName().equals(needle.getName()) && + ref.getObjectId().equals(needle.getObjectId())) { + return; + } + } + fail("list " + haystack + " does not contain ref " + needle); + } + + @Test + public void testGetRefsByPrefix() throws IOException { + List<Ref> refs = db.getRefDatabase().getRefsByPrefix("refs/heads/g"); + assertEquals(2, refs.size()); + checkContainsRef(refs, db.exactRef("refs/heads/g")); + checkContainsRef(refs, db.exactRef("refs/heads/gitlink")); + + refs = db.getRefDatabase().getRefsByPrefix("refs/heads/prefix/"); + assertEquals(1, refs.size()); + checkContainsRef(refs, db.exactRef("refs/heads/prefix/a")); + } + + @Test + public void testGetRefsByPrefixes() throws IOException { + List<Ref> refs = db.getRefDatabase().getRefsByPrefix(); + assertEquals(0, refs.size()); + + refs = db.getRefDatabase().getRefsByPrefix("refs/heads/p", + "refs/tags/A"); + assertEquals(3, refs.size()); + checkContainsRef(refs, db.exactRef("refs/heads/pa")); + checkContainsRef(refs, db.exactRef("refs/heads/prefix/a")); + checkContainsRef(refs, db.exactRef("refs/tags/A")); + } + + @Test + public void testGetRefsExcludingPrefix() throws IOException { + Set<String> exclude = new HashSet<>(); + exclude.add("refs/tags"); + // HEAD + 12 refs/heads are present here. + List<Ref> refs = + db.getRefDatabase().getRefsByPrefixWithExclusions(RefDatabase.ALL, exclude); + assertEquals(13, refs.size()); + checkContainsRef(refs, db.exactRef("HEAD")); + checkContainsRef(refs, db.exactRef("refs/heads/a")); + for (Ref notInResult : db.getRefDatabase().getRefsByPrefix("refs/tags")) { + assertFalse(refs.contains(notInResult)); + } + } + + @Test + public void testGetRefsExcludingPrefixes() throws IOException { + Set<String> exclude = new HashSet<>(); + exclude.add("refs/tags/"); + exclude.add("refs/heads/"); + List<Ref> refs = db.getRefDatabase().getRefsByPrefixWithExclusions(RefDatabase.ALL, exclude); + assertEquals(1, refs.size()); + checkContainsRef(refs, db.exactRef("HEAD")); + } + + @Test + public void testGetRefsExcludingNonExistingPrefixes() throws IOException { + Set<String> prefixes = new HashSet<>(); + prefixes.add("refs/tags/"); + prefixes.add("refs/heads/"); + prefixes.add("refs/nonexistent/"); + List<Ref> refs = db.getRefDatabase().getRefsByPrefixWithExclusions(RefDatabase.ALL, prefixes); + assertEquals(1, refs.size()); + checkContainsRef(refs, db.exactRef("HEAD")); + } + + @Test + public void testGetRefsWithPrefixExcludingPrefixes() throws IOException { + Set<String> exclude = new HashSet<>(); + exclude.add("refs/heads/pa"); + String include = "refs/heads/p"; + List<Ref> refs = db.getRefDatabase().getRefsByPrefixWithExclusions(include, exclude); + assertEquals(1, refs.size()); + checkContainsRef(refs, db.exactRef("refs/heads/prefix/a")); + } + + @Test + public void testGetRefsWithPrefixExcludingOverlappingPrefixes() throws IOException { + Set<String> exclude = new HashSet<>(); + exclude.add("refs/heads/pa"); + exclude.add("refs/heads/"); + exclude.add("refs/heads/p"); + exclude.add("refs/tags/"); + List<Ref> refs = db.getRefDatabase().getRefsByPrefixWithExclusions(RefDatabase.ALL, exclude); + assertEquals(1, refs.size()); + checkContainsRef(refs, db.exactRef("HEAD")); + } + + @Test + public void testResolveTipSha1() throws IOException { + ObjectId masterId = db.resolve("refs/heads/master"); + Set<Ref> resolved = db.getRefDatabase().getTipsWithSha1(masterId); + + assertEquals(2, resolved.size()); + checkContainsRef(resolved, db.exactRef("refs/heads/master")); + checkContainsRef(resolved, db.exactRef("HEAD")); + + assertEquals(db.getRefDatabase() + .getTipsWithSha1(ObjectId.zeroId()).size(), 0); + } } |