Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/TestAuxUtilities.java @ 653:629a7370554c

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Tests for recent changes in HgParentChildMap and RepositoryComparator (outgoing to respect drafts and Issue 47)
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Wed, 03 Jul 2013 14:38:30 +0200
parents 6526d8adbc0f
children 6334b0267103
rev   line source
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
1 /*
552
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
2 * Copyright (c) 2011-2013 TMate Software Ltd
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
3 *
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
4 * This program is free software; you can redistribute it and/or modify
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
5 * it under the terms of the GNU General Public License as published by
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
6 * the Free Software Foundation; version 2 of the License.
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
7 *
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
8 * This program is distributed in the hope that it will be useful,
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
11 * GNU General Public License for more details.
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
12 *
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
13 * For information on how to redistribute this software under
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
14 * the terms of a license other than GNU General Public License
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
15 * contact TMate Software at support@hg4j.com
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
16 */
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
17 package org.tmatesoft.hg.test;
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
18
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
19 import static java.lang.Integer.toBinaryString;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
20 import static org.junit.Assert.*;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
21 import static org.tmatesoft.hg.repo.HgRepository.TIP;
443
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
22 import static org.tmatesoft.hg.util.Path.CompareResult.*;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
23
322
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
24 import java.io.IOException;
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
25 import java.nio.ByteBuffer;
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
26
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
27 import org.junit.Assert;
443
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
28 import org.junit.Rule;
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
29 import org.junit.Test;
322
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
30 import org.tmatesoft.hg.core.HgCatCommand;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
31 import org.tmatesoft.hg.core.Nodeid;
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
32 import org.tmatesoft.hg.internal.ArrayHelper;
574
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
33 import org.tmatesoft.hg.internal.ByteVector;
552
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
34 import org.tmatesoft.hg.internal.IntVector;
443
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
35 import org.tmatesoft.hg.internal.PathScope;
558
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
36 import org.tmatesoft.hg.internal.RangeSeq;
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
37 import org.tmatesoft.hg.internal.RevisionDescendants;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
38 import org.tmatesoft.hg.repo.HgChangelog;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
39 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset;
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
40 import org.tmatesoft.hg.repo.HgDataFile;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
41 import org.tmatesoft.hg.repo.HgManifest;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
42 import org.tmatesoft.hg.repo.HgManifest.Flags;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
43 import org.tmatesoft.hg.repo.HgRepository;
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 609
diff changeset
44 import org.tmatesoft.hg.repo.HgRuntimeException;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
45 import org.tmatesoft.hg.util.Adaptable;
322
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
46 import org.tmatesoft.hg.util.ByteChannel;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
47 import org.tmatesoft.hg.util.CancelSupport;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
48 import org.tmatesoft.hg.util.CancelledException;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
49 import org.tmatesoft.hg.util.Path;
478
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
50 import org.tmatesoft.hg.util.ProgressSupport;
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
51
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
52 /**
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
53 *
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
54 * @author Artem Tikhomirov
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
55 * @author TMate Software Ltd.
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
56 */
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
57 public class TestAuxUtilities {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
58
443
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
59 @Rule
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
60 public ErrorCollectorExt errorCollector = new ErrorCollectorExt();
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
61
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
62 @Test
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
63 public void testArrayHelper() {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
64 String[] initial = {"d", "w", "k", "b", "c", "i", "a", "r", "e", "h" };
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
65 ArrayHelper ah = new ArrayHelper();
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
66 String[] result = initial.clone();
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
67 ah.sort(result);
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
68 String[] restored = restore(result, ah.getReverse());
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
69 assertArrayEquals(initial, restored);
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
70 //
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
71 // few elements are on the right place from the very start and do not shift during sort.
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
72 // make sure for them we've got correct reversed indexes as well
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
73 initial = new String[] {"d", "h", "c", "b", "k", "i", "a", "r", "e", "w" };
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
74 ah.sort(result = initial.clone());
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
75 restored = restore(result, ah.getReverse());
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
76 assertArrayEquals(initial, restored);
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
77 }
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
78
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
79 private static String[] restore(String[] sorted, int[] sortReverse) {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
80 String[] rebuilt = new String[sorted.length];
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
81 for (int i = 0; i < sorted.length; i++) {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
82 int indexInOriginal = sortReverse[i];
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
83 rebuilt[indexInOriginal-1] = sorted[i];
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
84 }
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
85 return rebuilt;
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
86 }
478
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
87
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
88
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
89 @Test
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
90 public void checkSubProgress() {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
91 // no repo
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
92 class PS implements ProgressSupport {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
93
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
94 @SuppressWarnings("unused")
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
95 public int units;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
96 public int worked;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
97 public boolean done = false;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
98
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
99 public void start(int totalUnits) {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
100 units = totalUnits;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
101 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
102 public void worked(int wu) {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
103 worked += wu;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
104 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
105 public void done() {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
106 done = true;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
107 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
108 };
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
109 PS ps = new PS();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
110 ps.start(10);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
111 ProgressSupport.Sub s1 = new ProgressSupport.Sub(ps, 3);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
112 ProgressSupport.Sub s2 = new ProgressSupport.Sub(ps, 7);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
113 s1.start(10);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
114 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
115 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
116 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
117 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
118 // so far s1 consumed 40% of total 3 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
119 assertEquals(1, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
120 s1.done();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
121 // now s1 consumed 100% of total 3 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
122 assertEquals(3, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
123 assertFalse(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
124 //
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
125 s2.start(5);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
126 s2.worked(3);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
127 // s2 consumed 60% (3/5) of ps's 7 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
128 // 3+4 == 3 from s1 + 0.6*7
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
129 assertEquals(3 + 4, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
130 s2.worked(2);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
131 assertEquals(3 + 7, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
132 assertFalse(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
133 s2.done();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
134 //assertTrue(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
135 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
136
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
137
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
138 static class CancelImpl implements CancelSupport {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
139 private boolean shallStop = false;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
140 public void stop() {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
141 shallStop = true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
142 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
143 public void checkCancelled() throws CancelledException {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
144 if (shallStop) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
145 throw new CancelledException();
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
146 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
147 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
148 }
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
149
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
150 static class CancelAtValue {
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
151 public int lastSeen;
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
152 public final int stopValue;
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
153 protected final CancelImpl cancelImpl = new CancelImpl();
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
154
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
155 protected CancelAtValue(int value) {
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
156 stopValue = value;
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
157 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
158
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
159 protected void nextValue(int value) {
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
160 lastSeen = value;
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
161 if (value == stopValue) {
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
162 cancelImpl.stop();
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
163 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
164 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
165 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
166
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
167 @Test
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
168 public void testChangelogCancelSupport() throws Exception {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
169 HgRepository repository = Configuration.get().find("branches-1"); // any repo with more revisions
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
170 class InspectorImplementsCancel extends CancelAtValue implements HgChangelog.Inspector, CancelSupport {
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
171
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
172 public InspectorImplementsCancel(int limit) {
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
173 super(limit);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
174 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
175
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
176 public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) {
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
177 nextValue(revisionNumber);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
178 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
179
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
180 public void checkCancelled() throws CancelledException {
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
181 cancelImpl.checkCancelled();
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
182 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
183 };
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
184 class InspectorImplementsAdaptable extends CancelAtValue implements HgChangelog.Inspector, Adaptable {
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
185 public InspectorImplementsAdaptable(int limit) {
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
186 super(limit);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
187 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
188
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
189 public void next(int revisionNumber, Nodeid nodeid, RawChangeset cset) {
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
190 nextValue(revisionNumber);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
191 }
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
192
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
193 public <T> T getAdapter(Class<T> adapterClass) {
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
194 if (CancelSupport.class == adapterClass) {
322
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
195 return adapterClass.cast(cancelImpl);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
196 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
197 return null;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
198 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
199 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
200 //
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
201 InspectorImplementsCancel insp1;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
202 repository.getChangelog().all(insp1= new InspectorImplementsCancel(2));
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
203 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
204 repository.getChangelog().all(insp1 = new InspectorImplementsCancel(12));
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
205 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
206 //
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
207 InspectorImplementsAdaptable insp2;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
208 repository.getChangelog().all(insp2= new InspectorImplementsAdaptable(3));
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
209 Assert.assertEquals(insp2.stopValue, insp2.lastSeen);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
210 repository.getChangelog().all(insp2 = new InspectorImplementsAdaptable(10));
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
211 Assert.assertEquals(insp2.stopValue, insp2.lastSeen);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
212 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
213
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
214 @Test
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
215 public void testManifestCancelSupport() throws Exception {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
216 HgRepository repository = Configuration.get().find("branches-1"); // any repo with as many revisions as possible
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
217 class InspectorImplementsAdaptable extends CancelAtValue implements HgManifest.Inspector, Adaptable {
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
218 public InspectorImplementsAdaptable(int limit) {
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
219 super(limit);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
220 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
221
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
222 public boolean begin(int mainfestRevision, Nodeid nid, int changelogRevision) {
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
223 nextValue(lastSeen+1);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
224 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
225 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
226
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
227 public boolean end(int manifestRevision) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
228 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
229 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
230
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
231 public <T> T getAdapter(Class<T> adapterClass) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
232 if (CancelSupport.class == adapterClass) {
322
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
233 return adapterClass.cast(cancelImpl);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
234 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
235 return null;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
236 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
237
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
238 public boolean next(Nodeid nid, Path fname, Flags flags) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
239 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
240 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
241 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
242 InspectorImplementsAdaptable insp1;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
243 repository.getManifest().walk(0, TIP, insp1= new InspectorImplementsAdaptable(3));
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
244 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
245 repository.getManifest().walk(0, TIP, insp1 = new InspectorImplementsAdaptable(10));
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
246 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
247 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
248
322
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
249 @Test
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
250 public void testCatCommandCancelSupport() throws Exception {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
251 HgRepository repository = Configuration.get().find("branches-1"); // any repo
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
252 final HgCatCommand cmd = new HgCatCommand(repository);
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
253 cmd.file(Path.create("file1"));
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
254 cmd.set(new CancelSupport() {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
255 int i = 0;
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
256 public void checkCancelled() throws CancelledException {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
257 if (i++ == 2) {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
258 throw new CancelledException();
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
259 }
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
260 }
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
261 });
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
262 try {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
263 cmd.execute(new ByteChannel() {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
264
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
265 public int write(ByteBuffer buffer) throws IOException, CancelledException {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
266 Assert.fail("Shall not get that far provided cancellation from command's CancelSupport is functional");
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
267 return 0;
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
268 }
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
269 });
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
270 Assert.fail("Command execution shall not fail silently, exception shall propagate");
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
271 } catch (CancelledException ex) {
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
272 // good!
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
273 }
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
274 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
275
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
276 @Test
418
528b6780a8bd A bit of FIXME cleanup (mostly degraded to TODO post 1.0), comments and javadoc
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
277 public void testRevlogInspectors() throws Exception { // TODO move to better place
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
278 HgRepository repository = Configuration.get().find("branches-1"); // any repo
431
12f668401613 FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
279 repository.getChangelog().indexWalk(0, TIP, new HgChangelog.RevisionInspector() {
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
280
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
281 public void next(int localRevision, Nodeid revision, int linkedRevision) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
282 Assert.assertEquals(localRevision, linkedRevision);
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
283 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
284 });
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
285 final HgDataFile fileNode = repository.getFileNode("file1");
431
12f668401613 FIXMEs: awkward API refactored, what need to be internal got hidden; public aspects got captured in slim interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 424
diff changeset
286 fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() {
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
287 int i = 0;
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
288
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 609
diff changeset
289 public void next(int localRevision, Nodeid revision, int linkedRevision) throws HgRuntimeException {
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
290 assertEquals(i++, localRevision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
291 assertEquals(fileNode.getChangesetRevisionIndex(localRevision), linkedRevision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
292 assertEquals(fileNode.getRevision(localRevision), revision);
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
293 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
294 });
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
295 class ParentInspectorCheck implements HgDataFile.ParentInspector {
448
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
296 private int i, c;
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
297 private Nodeid[] all;
448
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
298 private final int start;
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
299
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
300 public ParentInspectorCheck(int start, int total) {
448
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
301 this.start = start;
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
302 i = start; // revision index being iterated
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
303 c = 0; // index/counter of visited revisions
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
304 all = new Nodeid[total];
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
305 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
306
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
307 public void next(int localRevision, Nodeid revision, int parent1, int parent2, Nodeid nidParent1, Nodeid nidParent2) {
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
308 assertEquals(i++, localRevision);
448
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
309 all[c++] = revision;
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
310 assertNotNull(revision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
311 assertFalse(localRevision == 0 && (parent1 != -1 || parent2 != -1));
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
312 assertFalse(localRevision > 0 && parent1 == -1 && parent2 == -1);
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
313 if (parent1 != -1) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
314 Assert.assertNotNull(nidParent1);
448
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
315 if (parent1 >= start) {
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
316 // deliberately ==, not asserEquals to ensure same instance
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
317 Assert.assertTrue(nidParent1 == all[parent1-start]);
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
318 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
319 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
320 if (parent2 != -1) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
321 Assert.assertNotNull(nidParent2);
448
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
322 if (parent2 >= start) {
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
323 Assert.assertTrue(nidParent2 == all[parent2-start]);
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
324 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
325 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
326 }
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
327 };
471
7bcfbc255f48 Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 443 448
diff changeset
328 fileNode.indexWalk(0, TIP, new ParentInspectorCheck(0, fileNode.getRevisionCount()));
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
329 assert fileNode.getRevisionCount() > 2 : "prereq"; // need at least few revisions
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
330 // there used to be a defect in #walk impl, assumption all parents come prior to a revision
471
7bcfbc255f48 Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 443 448
diff changeset
331 fileNode.indexWalk(1, 3, new ParentInspectorCheck(1, 3));
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
332 }
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
333
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
334 /*
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
335 * This test checks not only RevisionDescendants class, but also
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
336 * Revlog.indexWalk implementation defect, aka:
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
337 * Issue 31: Revlog#walk doesn't handle ParentInspector correctly with start revision other than 0, fails with AIOOBE
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
338 */
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
339 @Test
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
340 public void testRevisionDescendants() throws Exception {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
341 HgRepository hgRepo = Configuration.get().find("branches-1");
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
342 int[] roots = new int[] {0, 1, 2, 3, 4, 5};
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
343 // 0: all revisions are descendants, 17 total.
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
344 // 1: 2, 4, 7, 8, 9
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
345 // 2: 7, 8, 9
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
346 // 3: 5,6, 10-16
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
347 // 4: no children
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
348 // 5: 6, 10-16
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
349 // array values represent bit mask, '1' for revision that shall re reported as descendant
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
350 // least significant bit is revision 0, and so on, so that 1<<revision points to bit in the bitmask
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
351 int[] descendantBitset = new int[] { 0x01FFFF, 0x0396, 0x0384, 0x01FC68, 0x010, 0x01FC60 };
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
352 RevisionDescendants[] result = new RevisionDescendants[roots.length];
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
353 for (int i = 0; i < roots.length; i++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
354 result[i] = new RevisionDescendants(hgRepo, roots[i]);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
355 result[i].build();
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
356 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
357 /*
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
358 for (int i = 0; i < roots.length; i++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
359 System.out.printf("For root %d descendats are:", roots[i]);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
360 for (int j = roots[i], x = hgRepo.getChangelog().getLastRevision(); j <= x; j++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
361 if (result[i].isDescendant(j)) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
362 System.out.printf("%3d ", j);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
363 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
364 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
365 System.out.printf(", isEmpty:%b\n", !result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
366 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
367 */
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
368 for (int i = 0; i < roots.length; i++) {
473
5c09a9f2e073 Issue 34: incorrect status for a file copy in wc against base rev
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 472
diff changeset
369 // System.out.printf("%s & %s = 0x%x\n", toBinaryString(descendantBitset[i]), toBinaryString(~(1<<roots[i])), descendantBitset[i] & ~(1<<roots[i]));
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
370 if ((descendantBitset[i] & ~(1<<roots[i])) != 0) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
371 assertTrue(result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
372 } else {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
373 assertFalse(result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
374 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
375 for (int j = roots[i], x = hgRepo.getChangelog().getLastRevision(); j <= x; j++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
376 int bit = 1<<j;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
377 boolean shallBeDescendant = (descendantBitset[i] & bit) != 0;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
378 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);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
379 if (result[i].isDescendant(j)) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
380 assertTrue(m, shallBeDescendant);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
381 } else {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
382 assertFalse(m, shallBeDescendant);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
383 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
384 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
385 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
386 }
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
387
363
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
388 @Test
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
389 public void testChangelogExtrasDecode() {
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
390 final String s = "abc\u0123\r\ndef\n\txx\\yy";
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
391 String r = s.replace("\\", "\\\\").replace("\n", "\\n").replace("\r", "\\r").replace("\0", "\\0");
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
392 // System.out.println(r);
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
393 String r2 = r.replace("\\\\", "\\").replace("\\n", "\n").replace("\\r", "\r").replace("\\0", "\00");
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
394 // System.out.println(r2);
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
395 Assert.assertTrue(s.equals(r2));
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
396 }
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
397
443
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
398 @Test
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
399 public void testPathScope() {
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
400 // XXX whether PathScope shall accept paths that are leading towards configured elements
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
401 Path[] scope = new Path[] {
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
402 Path.create("a/"),
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
403 Path.create("b/c"),
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
404 Path.create("d/e/f/")
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
405 };
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
406 //
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
407 // accept specified path, with files and folders below
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
408 PathScope ps1 = new PathScope(true, scope);
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
409 // folders
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
410 errorCollector.assertTrue(ps1.accept(Path.create("a/"))); // == scope[0]
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
411 errorCollector.assertTrue(ps1.accept(Path.create("a/d/"))); // scope[0] is parent and recursiveDir = true
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
412 errorCollector.assertTrue(ps1.accept(Path.create("a/d/e/"))); // scope[0] is parent and recursiveDir = true
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
413 errorCollector.assertTrue(!ps1.accept(Path.create("b/d/"))); // unrelated to any preconfigured
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
414 errorCollector.assertTrue(ps1.accept(Path.create("b/"))); // arg is parent to scope[1]
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
415 errorCollector.assertTrue(ps1.accept(Path.create("d/"))); // arg is parent to scope[2]
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
416 errorCollector.assertTrue(ps1.accept(Path.create("d/e/"))); // arg is parent to scope[2]
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
417 errorCollector.assertTrue(!ps1.accept(Path.create("d/g/"))); // unrelated to any preconfigured
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
418 // files
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
419 errorCollector.assertTrue(ps1.accept(Path.create("a/d"))); // "a/" is parent
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
420 errorCollector.assertTrue(ps1.accept(Path.create("a/d/f"))); // "a/" is still a parent
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
421 errorCollector.assertTrue(ps1.accept(Path.create("b/c"))); // ==
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
422 errorCollector.assertTrue(!ps1.accept(Path.create("b/d"))); // file, !=
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
423 //
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
424 // accept only specified files, folders and their direct children, allow navigate to them from above (FileIterator contract)
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
425 PathScope ps2 = new PathScope(true, false, true, scope);
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
426 // folders
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
427 errorCollector.assertTrue(!ps2.accept(Path.create("a/b/c/"))); // recursiveDirs = false
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
428 errorCollector.assertTrue(ps2.accept(Path.create("b/"))); // arg is parent to scope[1] (IOW, scope[1] is nested under arg)
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
429 errorCollector.assertTrue(ps2.accept(Path.create("d/"))); // scope[2] is nested under arg
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
430 errorCollector.assertTrue(ps2.accept(Path.create("d/e/"))); // scope[2] is nested under arg
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
431 errorCollector.assertTrue(!ps2.accept(Path.create("d/f/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
432 errorCollector.assertTrue(!ps2.accept(Path.create("b/f/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
433 // files
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
434 errorCollector.assertTrue(!ps2.accept(Path.create("a/b/c"))); // file, no exact match
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
435 errorCollector.assertTrue(ps2.accept(Path.create("d/e/f/g"))); // file under scope[2]
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
436 errorCollector.assertTrue(!ps2.accept(Path.create("b/e"))); // unrelated file
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
437
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
438 // matchParentDirs == false
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
439 PathScope ps3 = new PathScope(false, true, true, Path.create("a/b/")); // match any dir/file under a/b/, but not above
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
440 errorCollector.assertTrue(!ps3.accept(Path.create("a/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
441 errorCollector.assertTrue(ps3.accept(Path.create("a/b/c/d")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
442 errorCollector.assertTrue(ps3.accept(Path.create("a/b/c")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
443 errorCollector.assertTrue(!ps3.accept(Path.create("b/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
444 errorCollector.assertTrue(!ps3.accept(Path.create("d/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
445 errorCollector.assertTrue(!ps3.accept(Path.create("d/e/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
446
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
447 // match nested but not direct dir
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
448 PathScope ps4 = new PathScope(false, true, false, Path.create("a/b/")); // match any dir/file *deep* under a/b/,
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
449 errorCollector.assertTrue(!ps4.accept(Path.create("a/")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
450 errorCollector.assertTrue(!ps4.accept(Path.create("a/b/c")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
451 errorCollector.assertTrue(ps4.accept(Path.create("a/b/c/d")));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
452 }
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
453
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
454 @Test
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
455 public void testPathCompareWith() {
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
456 Path p1 = Path.create("a/b/");
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
457 Path p2 = Path.create("a/b/c");
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
458 Path p3 = Path.create("a/b"); // file with the same name as dir
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
459 Path p4 = Path.create("a/b/c/d/");
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
460 Path p5 = Path.create("d/");
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
461
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
462 errorCollector.assertEquals(Same, p1.compareWith(p1));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
463 errorCollector.assertEquals(Same, p1.compareWith(Path.create(p1.toString())));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
464 errorCollector.assertEquals(Unrelated, p1.compareWith(null));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
465 errorCollector.assertEquals(Unrelated, p1.compareWith(p5));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
466 //
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
467 errorCollector.assertEquals(Parent, p1.compareWith(p4));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
468 errorCollector.assertEquals(Nested, p4.compareWith(p1));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
469 errorCollector.assertEquals(ImmediateParent, p1.compareWith(p2));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
470 errorCollector.assertEquals(ImmediateChild, p2.compareWith(p1));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
471 //
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
472 errorCollector.assertEquals(Unrelated, p2.compareWith(p3));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
473 errorCollector.assertEquals(Unrelated, p3.compareWith(p2));
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
474 }
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
475
552
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
476 @Test
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
477 public void testIntVector() {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
478 IntVector v = new IntVector();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
479 v.add(10, 9, 8);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
480 v.add(7);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
481 errorCollector.assertEquals(4, v.size());
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
482 v.clear();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
483 errorCollector.assertEquals(0, v.size());
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
484
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
485 // vector that doesn't grow
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
486 v = new IntVector(3, 0);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
487 v.add(1,2,3);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
488 try {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
489 v.add(4);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
490 errorCollector.fail("This vector instance is not supposed to grow on demand");
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
491 } catch (UnsupportedOperationException ex) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
492 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
493 v = new IntVector(5, 2);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
494 v.add(10,9,8);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
495 v.add(7,6);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
496 v.add(5,4,3,2,1);
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
497 errorCollector.assertEquals(10, v.size());
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
498 // so far so good - grow() works
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
499 // now, check reverse()
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
500 v.reverse();
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
501 for (int i = 0; i < v.size(); i++) {
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
502 errorCollector.assertEquals(i+1, v.get(i));
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
503 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
504 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
505
558
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
506 @Test
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
507 public void testRangeSequence() {
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
508 RangeSeq rs = new RangeSeq();
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
509 rs.add(-1, 5, 3);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
510 rs.add(-1, 10, 2);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
511 rs.add(-1, 15, 3);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
512 rs.add(-1, 20, 3);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
513 errorCollector.assertFalse(rs.includesTargetLine(4));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
514 errorCollector.assertTrue(rs.includesTargetLine(7));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
515 errorCollector.assertFalse(rs.includesTargetLine(8));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
516 errorCollector.assertTrue(rs.includesTargetLine(10));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
517 errorCollector.assertFalse(rs.includesTargetLine(12));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
518 }
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
519
574
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
520 @Test
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
521 public void testByteVector() {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
522 ByteVector v = new ByteVector(4, 2);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
523 v.add(7);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
524 v.add(9);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
525 errorCollector.assertEquals(2, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
526 v.clear();
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
527 errorCollector.assertEquals(0, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
528 v.add(10);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
529 v.add(9);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
530 v.add(8);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
531 v.add(7);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
532 v.add(6);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
533 errorCollector.assertEquals(5, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
534 v.add(5);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
535 v.add(4);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
536 errorCollector.assertEquals(7, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
537 byte x = 10;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
538 for (byte d : v.toByteArray()) {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
539 errorCollector.assertEquals(x, d);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
540 x--;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
541 }
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
542 x = 10;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
543 byte[] dd = new byte[10];
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
544 v.copyTo(dd);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
545 for (int i = 0; i < v.size(); i++) {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
546 errorCollector.assertEquals(x, dd[i]);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
547 x--;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
548 }
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
549 errorCollector.assertTrue(v.equalsTo(new byte[] { 10,9,8,7,6,5,4 }));
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
550 }
363
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
551
574
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
552 public static void main(String[] args) throws Throwable {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
553 TestAuxUtilities t = new TestAuxUtilities();
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
554 t.testByteVector();
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
555 t.errorCollector.verify();
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
556 }
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
557 }