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@657: import java.util.Arrays;
tikhomirov@322: 
tikhomirov@311: import org.junit.Assert;
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@574: import org.tmatesoft.hg.internal.ByteVector;
tikhomirov@674: import org.tmatesoft.hg.internal.IntSliceSeq;
tikhomirov@674: import org.tmatesoft.hg.internal.IntTuple;
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@703: import org.tmatesoft.hg.internal.diff.RangePairSeq;
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@312: import org.tmatesoft.hg.repo.HgRepository;
tikhomirov@628: import org.tmatesoft.hg.repo.HgRuntimeException;
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@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@657: 		ArrayHelper<String> ah = new ArrayHelper<String>(initial);
tikhomirov@311: 		String[] result = initial.clone();
tikhomirov@657: 		ah.sort(result, false, false);
tikhomirov@657: 		String[] restored = restore(result, ah.getReverseIndexes());
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@657: 		ah = new ArrayHelper<String>(initial);
tikhomirov@657: 		ah.sort(result = new String[initial.length], true, true);
tikhomirov@657: 		restored = restore(result, ah.getReverseIndexes());
tikhomirov@472: 		assertArrayEquals(initial, restored);
tikhomirov@657: 		for (int i = 0; i < initial.length; i++) {
tikhomirov@657: 			String s = initial[i];
tikhomirov@657: 			errorCollector.assertEquals(i, ah.binarySearch(s, -1));
tikhomirov@657: 			errorCollector.assertEquals(Arrays.binarySearch(result, s), ah.binarySearchSorted(s));
tikhomirov@657: 		}
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@657: 			rebuilt[indexInOriginal] = 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> T getAdapter(Class<T> 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> T getAdapter(Class<T> 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@628: 			public void next(int localRevision, Nodeid revision, int linkedRevision) throws HgRuntimeException {
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<<revision points to bit in the bitmask
tikhomirov@472: 		int[] descendantBitset = new int[] { 0x01FFFF, 0x0396, 0x0384, 0x01FC68, 0x010, 0x01FC60 };
tikhomirov@472: 		RevisionDescendants[] result = new RevisionDescendants[roots.length];
tikhomirov@472: 		for (int i = 0; i < roots.length; i++) {
tikhomirov@472: 			result[i] = new RevisionDescendants(hgRepo, roots[i]);
tikhomirov@472: 			result[i].build();
tikhomirov@472: 		}
tikhomirov@472: 		/*
tikhomirov@472: 		for (int i = 0; i < roots.length; i++) {
tikhomirov@472: 			System.out.printf("For root %d descendats are:", roots[i]);
tikhomirov@472: 			for (int j = roots[i], x = hgRepo.getChangelog().getLastRevision(); j <= x; j++) {
tikhomirov@472: 				if (result[i].isDescendant(j)) {
tikhomirov@472: 					System.out.printf("%3d ", j);
tikhomirov@472: 				}
tikhomirov@472: 			}
tikhomirov@472: 			System.out.printf(", isEmpty:%b\n", !result[i].hasDescendants());
tikhomirov@472: 		}
tikhomirov@472: 		*/
tikhomirov@472: 		for (int i = 0; i < roots.length; i++) {
tikhomirov@473: //			System.out.printf("%s & %s = 0x%x\n", toBinaryString(descendantBitset[i]), toBinaryString(~(1<<roots[i])), descendantBitset[i] & ~(1<<roots[i]));
tikhomirov@472: 			if ((descendantBitset[i] & ~(1<<roots[i])) != 0) {
tikhomirov@472: 				assertTrue(result[i].hasDescendants());
tikhomirov@472: 			} else {
tikhomirov@472: 				assertFalse(result[i].hasDescendants());
tikhomirov@472: 			}
tikhomirov@472: 			for (int j = roots[i], x = hgRepo.getChangelog().getLastRevision(); j <= x; j++) {
tikhomirov@472: 				int bit = 1<<j;
tikhomirov@472: 				boolean shallBeDescendant = (descendantBitset[i] & bit) != 0;
tikhomirov@472: 				String m = String.format("Check rev %d from root %d. Bit %s in %s, shallBeDescendant:%b", j, roots[i], toBinaryString(bit), toBinaryString(descendantBitset[i]), shallBeDescendant);
tikhomirov@472: 				if (result[i].isDescendant(j)) {
tikhomirov@472: 					assertTrue(m, shallBeDescendant);
tikhomirov@472: 				} else {
tikhomirov@472: 					assertFalse(m, shallBeDescendant);
tikhomirov@472: 				}
tikhomirov@472: 			}
tikhomirov@472: 		}
tikhomirov@472: 	}
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@558: 	@Test
tikhomirov@674: 	public void testRangePairSequence() {
tikhomirov@674: 		RangePairSeq rs = new RangePairSeq();
tikhomirov@558: 		rs.add(-1, 5, 3);
tikhomirov@558: 		rs.add(-1, 10, 2);
tikhomirov@558: 		rs.add(-1, 15, 3);
tikhomirov@558: 		rs.add(-1, 20, 3);
tikhomirov@558: 		errorCollector.assertFalse(rs.includesTargetLine(4));
tikhomirov@558: 		errorCollector.assertTrue(rs.includesTargetLine(7));
tikhomirov@558: 		errorCollector.assertFalse(rs.includesTargetLine(8));
tikhomirov@558: 		errorCollector.assertTrue(rs.includesTargetLine(10));
tikhomirov@558: 		errorCollector.assertFalse(rs.includesTargetLine(12));
tikhomirov@558: 	}
tikhomirov@558: 	
tikhomirov@574: 	@Test
tikhomirov@574: 	public void testByteVector() {
tikhomirov@574: 		ByteVector v = new ByteVector(4, 2);
tikhomirov@574: 		v.add(7);
tikhomirov@574: 		v.add(9);
tikhomirov@574: 		errorCollector.assertEquals(2, v.size());
tikhomirov@574: 		v.clear();
tikhomirov@574: 		errorCollector.assertEquals(0, v.size());
tikhomirov@574: 		v.add(10);
tikhomirov@574: 		v.add(9);
tikhomirov@574: 		v.add(8);
tikhomirov@574: 		v.add(7);
tikhomirov@574: 		v.add(6);
tikhomirov@574: 		errorCollector.assertEquals(5, v.size());
tikhomirov@574: 		v.add(5);
tikhomirov@574: 		v.add(4);
tikhomirov@574: 		errorCollector.assertEquals(7, v.size());
tikhomirov@574: 		byte x = 10;
tikhomirov@574: 		for (byte d : v.toByteArray()) {
tikhomirov@574: 			errorCollector.assertEquals(x, d);
tikhomirov@574: 			x--;
tikhomirov@574: 		}
tikhomirov@574: 		x = 10;
tikhomirov@574: 		byte[] dd = new byte[10];
tikhomirov@574: 		v.copyTo(dd);
tikhomirov@574: 		for (int i = 0; i < v.size(); i++) {
tikhomirov@574: 			errorCollector.assertEquals(x, dd[i]);
tikhomirov@574: 			x--;
tikhomirov@574: 		}
tikhomirov@574: 		errorCollector.assertTrue(v.equalsTo(new byte[] { 10,9,8,7,6,5,4 }));
tikhomirov@574: 	}
tikhomirov@363: 	
tikhomirov@674: 	@Test
tikhomirov@674: 	public void testIntSliceSeq() {
tikhomirov@674: 		IntSliceSeq s1 = new IntSliceSeq(3, 10, 10);
tikhomirov@674: 		s1.add(1,2,3);
tikhomirov@674: 		try {
tikhomirov@674: 			s1.add(1,2);
tikhomirov@674: 			errorCollector.fail("shall accept precise number of arguments");
tikhomirov@674: 		} catch (IllegalArgumentException ex) {
tikhomirov@674: 		}
tikhomirov@674: 		try {
tikhomirov@674: 			s1.add(1,2,3,4);
tikhomirov@674: 			errorCollector.fail("shall accept precise number of arguments");
tikhomirov@674: 		} catch (IllegalArgumentException ex) {
tikhomirov@674: 		}
tikhomirov@674: 		s1.add(21,22,23);
tikhomirov@674: 		errorCollector.assertEquals(2, s1.size());
tikhomirov@674: 		s1.add(7, 8, 9);
tikhomirov@674: 		s1.set(1, 4, 5, 6);
tikhomirov@674: 		IntTuple l = s1.last();
tikhomirov@674: 		errorCollector.assertEquals(7, l.at(0));
tikhomirov@674: 		errorCollector.assertEquals(8, l.at(1));
tikhomirov@674: 		errorCollector.assertEquals(9, l.at(2));
tikhomirov@674: 		int v = 1, slice = 0;
tikhomirov@674: 		for (IntTuple t : s1) {
tikhomirov@674: 			for (int i = 0; i < t.size(); i++) {
tikhomirov@674: 				errorCollector.assertEquals(String.format("Slice %d, element %d", slice, i), v++, t.at(i));
tikhomirov@674: 			}
tikhomirov@674: 			slice++;
tikhomirov@674: 		}
tikhomirov@674: 		errorCollector.assertEquals(10, v);
tikhomirov@674: 	}
tikhomirov@674: 	
tikhomirov@574: 	public static void main(String[] args) throws Throwable {
tikhomirov@574: 		TestAuxUtilities t = new TestAuxUtilities();
tikhomirov@574: 		t.testByteVector();
tikhomirov@574: 		t.errorCollector.verify();
tikhomirov@331: 	}
tikhomirov@311: }