tikhomirov@311: /* tikhomirov@552: * Copyright (c) 2011-2013 TMate Software Ltd tikhomirov@311: * tikhomirov@311: * This program is free software; you can redistribute it and/or modify tikhomirov@311: * it under the terms of the GNU General Public License as published by tikhomirov@311: * the Free Software Foundation; version 2 of the License. tikhomirov@311: * tikhomirov@311: * This program is distributed in the hope that it will be useful, tikhomirov@311: * but WITHOUT ANY WARRANTY; without even the implied warranty of tikhomirov@311: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the tikhomirov@311: * GNU General Public License for more details. tikhomirov@311: * tikhomirov@311: * For information on how to redistribute this software under tikhomirov@311: * the terms of a license other than GNU General Public License tikhomirov@311: * contact TMate Software at support@hg4j.com tikhomirov@311: */ tikhomirov@311: package org.tmatesoft.hg.test; tikhomirov@311: tikhomirov@472: import static java.lang.Integer.toBinaryString; tikhomirov@472: import static org.junit.Assert.*; tikhomirov@313: import static org.tmatesoft.hg.repo.HgRepository.TIP; tikhomirov@443: import static org.tmatesoft.hg.util.Path.CompareResult.*; tikhomirov@313: tikhomirov@322: import java.io.IOException; tikhomirov@322: import java.nio.ByteBuffer; tikhomirov@322: tikhomirov@311: import org.junit.Assert; tikhomirov@331: import org.junit.Ignore; tikhomirov@443: import org.junit.Rule; tikhomirov@311: import org.junit.Test; tikhomirov@322: import org.tmatesoft.hg.core.HgCatCommand; tikhomirov@312: import org.tmatesoft.hg.core.Nodeid; tikhomirov@311: import org.tmatesoft.hg.internal.ArrayHelper; tikhomirov@552: import org.tmatesoft.hg.internal.IntVector; tikhomirov@443: import org.tmatesoft.hg.internal.PathScope; tikhomirov@472: import org.tmatesoft.hg.internal.RevisionDescendants; tikhomirov@312: import org.tmatesoft.hg.repo.HgChangelog; tikhomirov@312: import org.tmatesoft.hg.repo.HgChangelog.RawChangeset; tikhomirov@327: import org.tmatesoft.hg.repo.HgDataFile; tikhomirov@313: import org.tmatesoft.hg.repo.HgManifest; tikhomirov@313: import org.tmatesoft.hg.repo.HgManifest.Flags; tikhomirov@331: import org.tmatesoft.hg.repo.HgRepoConfig; tikhomirov@331: import org.tmatesoft.hg.repo.HgRepoConfig.PathsSection; tikhomirov@331: import org.tmatesoft.hg.repo.HgRepoConfig.Section; tikhomirov@312: import org.tmatesoft.hg.repo.HgRepository; tikhomirov@312: import org.tmatesoft.hg.util.Adaptable; tikhomirov@322: import org.tmatesoft.hg.util.ByteChannel; tikhomirov@312: import org.tmatesoft.hg.util.CancelSupport; tikhomirov@312: import org.tmatesoft.hg.util.CancelledException; tikhomirov@331: import org.tmatesoft.hg.util.Pair; tikhomirov@313: import org.tmatesoft.hg.util.Path; tikhomirov@478: import org.tmatesoft.hg.util.ProgressSupport; tikhomirov@311: tikhomirov@311: /** tikhomirov@311: * tikhomirov@311: * @author Artem Tikhomirov tikhomirov@311: * @author TMate Software Ltd. tikhomirov@311: */ tikhomirov@311: public class TestAuxUtilities { tikhomirov@311: tikhomirov@443: @Rule tikhomirov@443: public ErrorCollectorExt errorCollector = new ErrorCollectorExt(); tikhomirov@443: tikhomirov@311: @Test tikhomirov@311: public void testArrayHelper() { tikhomirov@311: String[] initial = {"d", "w", "k", "b", "c", "i", "a", "r", "e", "h" }; tikhomirov@311: ArrayHelper ah = new ArrayHelper(); tikhomirov@311: String[] result = initial.clone(); tikhomirov@311: ah.sort(result); tikhomirov@311: String[] restored = restore(result, ah.getReverse()); tikhomirov@472: assertArrayEquals(initial, restored); tikhomirov@311: // tikhomirov@311: // few elements are on the right place from the very start and do not shift during sort. tikhomirov@311: // make sure for them we've got correct reversed indexes as well tikhomirov@311: initial = new String[] {"d", "h", "c", "b", "k", "i", "a", "r", "e", "w" }; tikhomirov@311: ah.sort(result = initial.clone()); tikhomirov@311: restored = restore(result, ah.getReverse()); tikhomirov@472: assertArrayEquals(initial, restored); tikhomirov@311: } tikhomirov@311: tikhomirov@311: private static String[] restore(String[] sorted, int[] sortReverse) { tikhomirov@311: String[] rebuilt = new String[sorted.length]; tikhomirov@311: for (int i = 0; i < sorted.length; i++) { tikhomirov@311: int indexInOriginal = sortReverse[i]; tikhomirov@311: rebuilt[indexInOriginal-1] = sorted[i]; tikhomirov@311: } tikhomirov@311: return rebuilt; tikhomirov@311: } tikhomirov@478: tikhomirov@478: tikhomirov@478: @Test tikhomirov@478: public void checkSubProgress() { tikhomirov@478: // no repo tikhomirov@478: class PS implements ProgressSupport { tikhomirov@478: tikhomirov@478: @SuppressWarnings("unused") tikhomirov@478: public int units; tikhomirov@478: public int worked; tikhomirov@478: public boolean done = false; tikhomirov@478: tikhomirov@478: public void start(int totalUnits) { tikhomirov@478: units = totalUnits; tikhomirov@478: } tikhomirov@478: public void worked(int wu) { tikhomirov@478: worked += wu; tikhomirov@478: } tikhomirov@478: public void done() { tikhomirov@478: done = true; tikhomirov@478: } tikhomirov@478: }; tikhomirov@478: PS ps = new PS(); tikhomirov@478: ps.start(10); tikhomirov@478: ProgressSupport.Sub s1 = new ProgressSupport.Sub(ps, 3); tikhomirov@478: ProgressSupport.Sub s2 = new ProgressSupport.Sub(ps, 7); tikhomirov@478: s1.start(10); tikhomirov@478: s1.worked(1); tikhomirov@478: s1.worked(1); tikhomirov@478: s1.worked(1); tikhomirov@478: s1.worked(1); tikhomirov@478: // so far s1 consumed 40% of total 3 units tikhomirov@478: assertEquals(1, ps.worked); tikhomirov@478: s1.done(); tikhomirov@478: // now s1 consumed 100% of total 3 units tikhomirov@478: assertEquals(3, ps.worked); tikhomirov@478: assertFalse(ps.done); tikhomirov@478: // tikhomirov@478: s2.start(5); tikhomirov@478: s2.worked(3); tikhomirov@478: // s2 consumed 60% (3/5) of ps's 7 units tikhomirov@478: // 3+4 == 3 from s1 + 0.6*7 tikhomirov@478: assertEquals(3 + 4, ps.worked); tikhomirov@478: s2.worked(2); tikhomirov@478: assertEquals(3 + 7, ps.worked); tikhomirov@478: assertFalse(ps.done); tikhomirov@478: s2.done(); tikhomirov@478: //assertTrue(ps.done); tikhomirov@478: } tikhomirov@478: tikhomirov@312: tikhomirov@313: static class CancelImpl implements CancelSupport { tikhomirov@313: private boolean shallStop = false; tikhomirov@313: public void stop() { tikhomirov@313: shallStop = true; tikhomirov@313: } tikhomirov@313: public void checkCancelled() throws CancelledException { tikhomirov@313: if (shallStop) { tikhomirov@313: throw new CancelledException(); tikhomirov@312: } tikhomirov@312: } tikhomirov@313: } tikhomirov@520: tikhomirov@520: static class CancelAtValue { tikhomirov@520: public int lastSeen; tikhomirov@520: public final int stopValue; tikhomirov@520: protected final CancelImpl cancelImpl = new CancelImpl(); tikhomirov@520: tikhomirov@520: protected CancelAtValue(int value) { tikhomirov@520: stopValue = value; tikhomirov@520: } tikhomirov@520: tikhomirov@520: protected void nextValue(int value) { tikhomirov@520: lastSeen = value; tikhomirov@520: if (value == stopValue) { tikhomirov@520: cancelImpl.stop(); tikhomirov@520: } tikhomirov@520: } tikhomirov@520: } tikhomirov@313: tikhomirov@313: @Test tikhomirov@313: public void testChangelogCancelSupport() throws Exception { tikhomirov@313: HgRepository repository = Configuration.get().find("branches-1"); // any repo with more revisions tikhomirov@520: class InspectorImplementsCancel extends CancelAtValue implements HgChangelog.Inspector, CancelSupport { tikhomirov@312: tikhomirov@312: public InspectorImplementsCancel(int limit) { tikhomirov@520: super(limit); tikhomirov@312: } tikhomirov@312: tikhomirov@312: public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) { tikhomirov@520: nextValue(revisionNumber); tikhomirov@312: } tikhomirov@312: tikhomirov@312: public void checkCancelled() throws CancelledException { tikhomirov@312: cancelImpl.checkCancelled(); tikhomirov@312: } tikhomirov@312: }; tikhomirov@520: class InspectorImplementsAdaptable extends CancelAtValue implements HgChangelog.Inspector, Adaptable { tikhomirov@312: public InspectorImplementsAdaptable(int limit) { tikhomirov@520: super(limit); tikhomirov@312: } tikhomirov@312: tikhomirov@312: public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) { tikhomirov@520: nextValue(revisionNumber); tikhomirov@312: } tikhomirov@520: tikhomirov@312: public T getAdapter(Class adapterClass) { tikhomirov@312: if (CancelSupport.class == adapterClass) { tikhomirov@322: return adapterClass.cast(cancelImpl); tikhomirov@312: } tikhomirov@312: return null; tikhomirov@312: } tikhomirov@312: } tikhomirov@312: // tikhomirov@312: InspectorImplementsCancel insp1; tikhomirov@312: repository.getChangelog().all(insp1= new InspectorImplementsCancel(2)); tikhomirov@520: Assert.assertEquals(insp1.stopValue, insp1.lastSeen); tikhomirov@312: repository.getChangelog().all(insp1 = new InspectorImplementsCancel(12)); tikhomirov@520: Assert.assertEquals(insp1.stopValue, insp1.lastSeen); tikhomirov@312: // tikhomirov@312: InspectorImplementsAdaptable insp2; tikhomirov@312: repository.getChangelog().all(insp2= new InspectorImplementsAdaptable(3)); tikhomirov@520: Assert.assertEquals(insp2.stopValue, insp2.lastSeen); tikhomirov@312: repository.getChangelog().all(insp2 = new InspectorImplementsAdaptable(10)); tikhomirov@520: Assert.assertEquals(insp2.stopValue, insp2.lastSeen); tikhomirov@312: } tikhomirov@313: tikhomirov@313: @Test tikhomirov@313: public void testManifestCancelSupport() throws Exception { tikhomirov@313: HgRepository repository = Configuration.get().find("branches-1"); // any repo with as many revisions as possible tikhomirov@520: class InspectorImplementsAdaptable extends CancelAtValue implements HgManifest.Inspector, Adaptable { tikhomirov@313: public InspectorImplementsAdaptable(int limit) { tikhomirov@520: super(limit); tikhomirov@313: } tikhomirov@313: tikhomirov@313: public boolean begin(int mainfestRevision, Nodeid nid, int changelogRevision) { tikhomirov@520: nextValue(lastSeen+1); tikhomirov@313: return true; tikhomirov@313: } tikhomirov@313: tikhomirov@313: public boolean end(int manifestRevision) { tikhomirov@313: return true; tikhomirov@313: } tikhomirov@313: tikhomirov@313: public T getAdapter(Class adapterClass) { tikhomirov@313: if (CancelSupport.class == adapterClass) { tikhomirov@322: return adapterClass.cast(cancelImpl); tikhomirov@313: } tikhomirov@313: return null; tikhomirov@313: } tikhomirov@313: tikhomirov@313: public boolean next(Nodeid nid, Path fname, Flags flags) { tikhomirov@313: return true; tikhomirov@313: } tikhomirov@313: } tikhomirov@313: InspectorImplementsAdaptable insp1; tikhomirov@313: repository.getManifest().walk(0, TIP, insp1= new InspectorImplementsAdaptable(3)); tikhomirov@520: Assert.assertEquals(insp1.stopValue, insp1.lastSeen); tikhomirov@313: repository.getManifest().walk(0, TIP, insp1 = new InspectorImplementsAdaptable(10)); tikhomirov@520: Assert.assertEquals(insp1.stopValue, insp1.lastSeen); tikhomirov@313: } tikhomirov@313: tikhomirov@322: @Test tikhomirov@322: public void testCatCommandCancelSupport() throws Exception { tikhomirov@322: HgRepository repository = Configuration.get().find("branches-1"); // any repo tikhomirov@322: final HgCatCommand cmd = new HgCatCommand(repository); tikhomirov@322: cmd.file(Path.create("file1")); tikhomirov@322: cmd.set(new CancelSupport() { tikhomirov@322: int i = 0; tikhomirov@322: public void checkCancelled() throws CancelledException { tikhomirov@322: if (i++ == 2) { tikhomirov@322: throw new CancelledException(); tikhomirov@322: } tikhomirov@322: } tikhomirov@322: }); tikhomirov@322: try { tikhomirov@322: cmd.execute(new ByteChannel() { tikhomirov@322: tikhomirov@322: public int write(ByteBuffer buffer) throws IOException, CancelledException { tikhomirov@322: Assert.fail("Shall not get that far provided cancellation from command's CancelSupport is functional"); tikhomirov@322: return 0; tikhomirov@322: } tikhomirov@322: }); tikhomirov@322: Assert.fail("Command execution shall not fail silently, exception shall propagate"); tikhomirov@322: } catch (CancelledException ex) { tikhomirov@322: // good! tikhomirov@322: } tikhomirov@322: } tikhomirov@327: tikhomirov@327: @Test tikhomirov@418: public void testRevlogInspectors() throws Exception { // TODO move to better place tikhomirov@327: HgRepository repository = Configuration.get().find("branches-1"); // any repo tikhomirov@431: repository.getChangelog().indexWalk(0, TIP, new HgChangelog.RevisionInspector() { tikhomirov@327: tikhomirov@327: public void next(int localRevision, Nodeid revision, int linkedRevision) { tikhomirov@327: Assert.assertEquals(localRevision, linkedRevision); tikhomirov@327: } tikhomirov@327: }); tikhomirov@327: final HgDataFile fileNode = repository.getFileNode("file1"); tikhomirov@431: fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() { tikhomirov@327: int i = 0; tikhomirov@327: tikhomirov@327: public void next(int localRevision, Nodeid revision, int linkedRevision) { tikhomirov@472: assertEquals(i++, localRevision); tikhomirov@472: assertEquals(fileNode.getChangesetRevisionIndex(localRevision), linkedRevision); tikhomirov@472: assertEquals(fileNode.getRevision(localRevision), revision); tikhomirov@327: } tikhomirov@327: }); tikhomirov@445: class ParentInspectorCheck implements HgDataFile.ParentInspector { tikhomirov@448: private int i, c; tikhomirov@445: private Nodeid[] all; tikhomirov@448: private final int start; tikhomirov@445: tikhomirov@445: public ParentInspectorCheck(int start, int total) { tikhomirov@448: this.start = start; tikhomirov@448: i = start; // revision index being iterated tikhomirov@448: c = 0; // index/counter of visited revisions tikhomirov@445: all = new Nodeid[total]; tikhomirov@445: } tikhomirov@327: tikhomirov@327: public void next(int localRevision, Nodeid revision, int parent1, int parent2, Nodeid nidParent1, Nodeid nidParent2) { tikhomirov@472: assertEquals(i++, localRevision); tikhomirov@448: all[c++] = revision; tikhomirov@472: assertNotNull(revision); tikhomirov@472: assertFalse(localRevision == 0 && (parent1 != -1 || parent2 != -1)); tikhomirov@472: assertFalse(localRevision > 0 && parent1 == -1 && parent2 == -1); tikhomirov@327: if (parent1 != -1) { tikhomirov@327: Assert.assertNotNull(nidParent1); tikhomirov@448: if (parent1 >= start) { tikhomirov@448: // deliberately ==, not asserEquals to ensure same instance tikhomirov@448: Assert.assertTrue(nidParent1 == all[parent1-start]); tikhomirov@448: } tikhomirov@327: } tikhomirov@327: if (parent2 != -1) { tikhomirov@327: Assert.assertNotNull(nidParent2); tikhomirov@448: if (parent2 >= start) { tikhomirov@448: Assert.assertTrue(nidParent2 == all[parent2-start]); tikhomirov@448: } tikhomirov@327: } tikhomirov@327: } tikhomirov@445: }; tikhomirov@471: fileNode.indexWalk(0, TIP, new ParentInspectorCheck(0, fileNode.getRevisionCount())); tikhomirov@445: assert fileNode.getRevisionCount() > 2 : "prereq"; // need at least few revisions tikhomirov@445: // there used to be a defect in #walk impl, assumption all parents come prior to a revision tikhomirov@471: fileNode.indexWalk(1, 3, new ParentInspectorCheck(1, 3)); tikhomirov@327: } tikhomirov@331: tikhomirov@472: /* tikhomirov@472: * This test checks not only RevisionDescendants class, but also tikhomirov@472: * Revlog.indexWalk implementation defect, aka: tikhomirov@472: * Issue 31: Revlog#walk doesn't handle ParentInspector correctly with start revision other than 0, fails with AIOOBE tikhomirov@472: */ tikhomirov@472: @Test tikhomirov@472: public void testRevisionDescendants() throws Exception { tikhomirov@472: HgRepository hgRepo = Configuration.get().find("branches-1"); tikhomirov@472: int[] roots = new int[] {0, 1, 2, 3, 4, 5}; tikhomirov@472: // 0: all revisions are descendants, 17 total. tikhomirov@472: // 1: 2, 4, 7, 8, 9 tikhomirov@472: // 2: 7, 8, 9 tikhomirov@472: // 3: 5,6, 10-16 tikhomirov@472: // 4: no children tikhomirov@472: // 5: 6, 10-16 tikhomirov@472: // array values represent bit mask, '1' for revision that shall re reported as descendant tikhomirov@472: // least significant bit is revision 0, and so on, so that 1< p : cfg.getSection("ui")) { tikhomirov@331: System.out.printf("%s = %s\n", p.first(), p.second()); tikhomirov@331: } tikhomirov@331: final PathsSection p = cfg.getPaths(); tikhomirov@331: System.out.printf("Known paths: %d. default: %s(%s), default-push: %s(%s)\n", p.getKeys().size(), p.getDefault(), p.hasDefault(), p.getDefaultPush(), p.hasDefaultPush()); tikhomirov@331: for (String k : cfg.getPaths().getKeys()) { tikhomirov@331: System.out.println(k); tikhomirov@331: } tikhomirov@331: Assert.assertFalse(p.hasDefault() ^ p.getDefault() != null); tikhomirov@331: Assert.assertFalse(p.hasDefaultPush() ^ p.getDefaultPush() != null); tikhomirov@331: } tikhomirov@331: tikhomirov@363: @Test tikhomirov@363: public void testChangelogExtrasDecode() { tikhomirov@363: final String s = "abc\u0123\r\ndef\n\txx\\yy"; tikhomirov@363: String r = s.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r").replace("\0", "\\0"); tikhomirov@363: // System.out.println(r); tikhomirov@363: String r2 = r.replace("\\\\", "\\").replace("\\n", "\n").replace("\\r", "\r").replace("\\0", "\00"); tikhomirov@363: // System.out.println(r2); tikhomirov@363: Assert.assertTrue(s.equals(r2)); tikhomirov@363: } tikhomirov@363: tikhomirov@443: @Test tikhomirov@443: public void testPathScope() { tikhomirov@443: // XXX whether PathScope shall accept paths that are leading towards configured elements tikhomirov@443: Path[] scope = new Path[] { tikhomirov@443: Path.create("a/"), tikhomirov@443: Path.create("b/c"), tikhomirov@443: Path.create("d/e/f/") tikhomirov@443: }; tikhomirov@443: // tikhomirov@443: // accept specified path, with files and folders below tikhomirov@443: PathScope ps1 = new PathScope(true, scope); tikhomirov@443: // folders tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("a/"))); // == scope[0] tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("a/d/"))); // scope[0] is parent and recursiveDir = true tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("a/d/e/"))); // scope[0] is parent and recursiveDir = true tikhomirov@443: errorCollector.assertTrue(!ps1.accept(Path.create("b/d/"))); // unrelated to any preconfigured tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("b/"))); // arg is parent to scope[1] tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("d/"))); // arg is parent to scope[2] tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("d/e/"))); // arg is parent to scope[2] tikhomirov@443: errorCollector.assertTrue(!ps1.accept(Path.create("d/g/"))); // unrelated to any preconfigured tikhomirov@443: // files tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("a/d"))); // "a/" is parent tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("a/d/f"))); // "a/" is still a parent tikhomirov@443: errorCollector.assertTrue(ps1.accept(Path.create("b/c"))); // == tikhomirov@443: errorCollector.assertTrue(!ps1.accept(Path.create("b/d"))); // file, != tikhomirov@443: // tikhomirov@443: // accept only specified files, folders and their direct children, allow navigate to them from above (FileIterator contract) tikhomirov@443: PathScope ps2 = new PathScope(true, false, true, scope); tikhomirov@443: // folders tikhomirov@443: errorCollector.assertTrue(!ps2.accept(Path.create("a/b/c/"))); // recursiveDirs = false tikhomirov@443: errorCollector.assertTrue(ps2.accept(Path.create("b/"))); // arg is parent to scope[1] (IOW, scope[1] is nested under arg) tikhomirov@443: errorCollector.assertTrue(ps2.accept(Path.create("d/"))); // scope[2] is nested under arg tikhomirov@443: errorCollector.assertTrue(ps2.accept(Path.create("d/e/"))); // scope[2] is nested under arg tikhomirov@443: errorCollector.assertTrue(!ps2.accept(Path.create("d/f/"))); tikhomirov@443: errorCollector.assertTrue(!ps2.accept(Path.create("b/f/"))); tikhomirov@443: // files tikhomirov@443: errorCollector.assertTrue(!ps2.accept(Path.create("a/b/c"))); // file, no exact match tikhomirov@443: errorCollector.assertTrue(ps2.accept(Path.create("d/e/f/g"))); // file under scope[2] tikhomirov@443: errorCollector.assertTrue(!ps2.accept(Path.create("b/e"))); // unrelated file tikhomirov@443: tikhomirov@443: // matchParentDirs == false tikhomirov@443: PathScope ps3 = new PathScope(false, true, true, Path.create("a/b/")); // match any dir/file under a/b/, but not above tikhomirov@443: errorCollector.assertTrue(!ps3.accept(Path.create("a/"))); tikhomirov@443: errorCollector.assertTrue(ps3.accept(Path.create("a/b/c/d"))); tikhomirov@443: errorCollector.assertTrue(ps3.accept(Path.create("a/b/c"))); tikhomirov@443: errorCollector.assertTrue(!ps3.accept(Path.create("b/"))); tikhomirov@443: errorCollector.assertTrue(!ps3.accept(Path.create("d/"))); tikhomirov@443: errorCollector.assertTrue(!ps3.accept(Path.create("d/e/"))); tikhomirov@443: tikhomirov@443: // match nested but not direct dir tikhomirov@443: PathScope ps4 = new PathScope(false, true, false, Path.create("a/b/")); // match any dir/file *deep* under a/b/, tikhomirov@443: errorCollector.assertTrue(!ps4.accept(Path.create("a/"))); tikhomirov@443: errorCollector.assertTrue(!ps4.accept(Path.create("a/b/c"))); tikhomirov@443: errorCollector.assertTrue(ps4.accept(Path.create("a/b/c/d"))); tikhomirov@443: } tikhomirov@443: tikhomirov@443: @Test tikhomirov@443: public void testPathCompareWith() { tikhomirov@443: Path p1 = Path.create("a/b/"); tikhomirov@443: Path p2 = Path.create("a/b/c"); tikhomirov@443: Path p3 = Path.create("a/b"); // file with the same name as dir tikhomirov@443: Path p4 = Path.create("a/b/c/d/"); tikhomirov@443: Path p5 = Path.create("d/"); tikhomirov@443: tikhomirov@443: errorCollector.assertEquals(Same, p1.compareWith(p1)); tikhomirov@443: errorCollector.assertEquals(Same, p1.compareWith(Path.create(p1.toString()))); tikhomirov@443: errorCollector.assertEquals(Unrelated, p1.compareWith(null)); tikhomirov@443: errorCollector.assertEquals(Unrelated, p1.compareWith(p5)); tikhomirov@443: // tikhomirov@443: errorCollector.assertEquals(Parent, p1.compareWith(p4)); tikhomirov@443: errorCollector.assertEquals(Nested, p4.compareWith(p1)); tikhomirov@443: errorCollector.assertEquals(ImmediateParent, p1.compareWith(p2)); tikhomirov@443: errorCollector.assertEquals(ImmediateChild, p2.compareWith(p1)); tikhomirov@443: // tikhomirov@443: errorCollector.assertEquals(Unrelated, p2.compareWith(p3)); tikhomirov@443: errorCollector.assertEquals(Unrelated, p3.compareWith(p2)); tikhomirov@443: } tikhomirov@443: tikhomirov@552: @Test tikhomirov@552: public void testIntVector() { tikhomirov@552: IntVector v = new IntVector(); tikhomirov@552: v.add(10, 9, 8); tikhomirov@552: v.add(7); tikhomirov@552: errorCollector.assertEquals(4, v.size()); tikhomirov@552: v.clear(); tikhomirov@552: errorCollector.assertEquals(0, v.size()); tikhomirov@552: tikhomirov@552: // vector that doesn't grow tikhomirov@552: v = new IntVector(3, 0); tikhomirov@552: v.add(1,2,3); tikhomirov@552: try { tikhomirov@552: v.add(4); tikhomirov@552: errorCollector.fail("This vector instance is not supposed to grow on demand"); tikhomirov@552: } catch (UnsupportedOperationException ex) { tikhomirov@552: } tikhomirov@552: v = new IntVector(5, 2); tikhomirov@552: v.add(10,9,8); tikhomirov@552: v.add(7,6); tikhomirov@552: v.add(5,4,3,2,1); tikhomirov@552: errorCollector.assertEquals(10, v.size()); tikhomirov@552: // so far so good - grow() works tikhomirov@552: // now, check reverse() tikhomirov@552: v.reverse(); tikhomirov@552: for (int i = 0; i < v.size(); i++) { tikhomirov@552: errorCollector.assertEquals(i+1, v.get(i)); tikhomirov@552: } tikhomirov@552: } tikhomirov@552: tikhomirov@363: tikhomirov@331: public static void main(String[] args) throws Exception { tikhomirov@331: new TestAuxUtilities().testRepositoryConfig(); tikhomirov@331: } tikhomirov@311: }