Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/TestAuxUtilities.java @ 552:45751456b471

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Annotate file changes through few revisions, walking either direction (old to new and vice versa)
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Wed, 20 Feb 2013 22:23:50 +0100
parents 1ee452f31187
children 154718ae23ed
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;
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
28 import org.junit.Ignore;
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
29 import org.junit.Rule;
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
30 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
31 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
32 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
33 import org.tmatesoft.hg.internal.ArrayHelper;
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;
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
36 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
37 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
38 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset;
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
39 import org.tmatesoft.hg.repo.HgDataFile;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
40 import org.tmatesoft.hg.repo.HgManifest;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
41 import org.tmatesoft.hg.repo.HgManifest.Flags;
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
42 import org.tmatesoft.hg.repo.HgRepoConfig;
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
43 import org.tmatesoft.hg.repo.HgRepoConfig.PathsSection;
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
44 import org.tmatesoft.hg.repo.HgRepoConfig.Section;
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.repo.HgRepository;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
46 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
47 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
48 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
49 import org.tmatesoft.hg.util.CancelledException;
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
50 import org.tmatesoft.hg.util.Pair;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
51 import org.tmatesoft.hg.util.Path;
478
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
52 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
53
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
54 /**
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
55 *
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
56 * @author Artem Tikhomirov
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
57 * @author TMate Software Ltd.
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
58 */
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
59 public class TestAuxUtilities {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
60
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
61 @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
62 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
63
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
64 @Test
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
65 public void testArrayHelper() {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
66 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
67 ArrayHelper ah = new ArrayHelper();
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
68 String[] result = initial.clone();
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
69 ah.sort(result);
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
70 String[] restored = restore(result, ah.getReverse());
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
71 assertArrayEquals(initial, restored);
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
72 //
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
73 // 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
74 // 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
75 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
76 ah.sort(result = initial.clone());
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
77 restored = restore(result, ah.getReverse());
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
78 assertArrayEquals(initial, restored);
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
79 }
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
80
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
81 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
82 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
83 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
84 int indexInOriginal = sortReverse[i];
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
85 rebuilt[indexInOriginal-1] = sorted[i];
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
86 }
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
87 return rebuilt;
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
88 }
478
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
89
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
90
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
91 @Test
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
92 public void checkSubProgress() {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
93 // no repo
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
94 class PS implements ProgressSupport {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
95
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
96 @SuppressWarnings("unused")
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
97 public int units;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
98 public int worked;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
99 public boolean done = false;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
100
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
101 public void start(int totalUnits) {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
102 units = totalUnits;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
103 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
104 public void worked(int wu) {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
105 worked += wu;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
106 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
107 public void done() {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
108 done = true;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
109 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
110 };
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
111 PS ps = new PS();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
112 ps.start(10);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
113 ProgressSupport.Sub s1 = new ProgressSupport.Sub(ps, 3);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
114 ProgressSupport.Sub s2 = new ProgressSupport.Sub(ps, 7);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
115 s1.start(10);
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 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
119 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
120 // so far s1 consumed 40% of total 3 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
121 assertEquals(1, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
122 s1.done();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
123 // now s1 consumed 100% of total 3 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
124 assertEquals(3, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
125 assertFalse(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
126 //
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
127 s2.start(5);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
128 s2.worked(3);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
129 // s2 consumed 60% (3/5) of ps's 7 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
130 // 3+4 == 3 from s1 + 0.6*7
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
131 assertEquals(3 + 4, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
132 s2.worked(2);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
133 assertEquals(3 + 7, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
134 assertFalse(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
135 s2.done();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
136 //assertTrue(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
137 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
138
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
139
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
140 static class CancelImpl implements CancelSupport {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
141 private boolean shallStop = false;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
142 public void stop() {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
143 shallStop = true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
144 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
145 public void checkCancelled() throws CancelledException {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
146 if (shallStop) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
147 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
148 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
149 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
150 }
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
151
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 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
153 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
154 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
155 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
156
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 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
158 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
159 }
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
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 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
162 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
163 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
164 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
165 }
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
166 }
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
167 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
168
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
169 @Test
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
170 public void testChangelogCancelSupport() throws Exception {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
171 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
172 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
173
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
174 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
175 super(limit);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
176 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
177
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
178 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
179 nextValue(revisionNumber);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
180 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
181
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
182 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
183 cancelImpl.checkCancelled();
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
184 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
185 };
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 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
187 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
188 super(limit);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
189 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
190
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
191 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
192 nextValue(revisionNumber);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
193 }
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
194
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
195 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
196 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
197 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
198 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
199 return null;
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 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
202 //
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
203 InspectorImplementsCancel insp1;
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(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
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 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
207 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
208 //
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
209 InspectorImplementsAdaptable insp2;
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(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
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 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
213 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
214 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
215
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
216 @Test
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
217 public void testManifestCancelSupport() throws Exception {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
218 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
219 class InspectorImplementsAdaptable extends CancelAtValue implements HgManifest.Inspector, Adaptable {
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
220 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
221 super(limit);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
222 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
223
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
224 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
225 nextValue(lastSeen+1);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
226 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
227 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
228
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
229 public boolean end(int manifestRevision) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
230 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
231 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
232
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
233 public <T> T getAdapter(Class<T> adapterClass) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
234 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
235 return adapterClass.cast(cancelImpl);
313
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 return null;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
238 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
239
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
240 public boolean next(Nodeid nid, Path fname, Flags flags) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
241 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
242 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
243 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
244 InspectorImplementsAdaptable insp1;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
245 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
246 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
247 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
248 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
249 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
250
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
251 @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
252 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
253 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
254 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
255 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
256 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
257 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
258 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
259 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
260 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
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 }
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 });
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 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
265 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
266
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 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
268 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
269 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
270 }
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 });
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 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
273 } 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
274 // 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
275 }
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
276 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
277
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
278 @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
279 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
280 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
281 repository.getChangelog().indexWalk(0, TIP, new HgChangelog.RevisionInspector() {
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
282
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
283 public void next(int localRevision, Nodeid revision, int linkedRevision) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
284 Assert.assertEquals(localRevision, linkedRevision);
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
285 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
286 });
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
287 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
288 fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() {
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
289 int i = 0;
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
290
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
291 public void next(int localRevision, Nodeid revision, int linkedRevision) {
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
292 assertEquals(i++, localRevision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
293 assertEquals(fileNode.getChangesetRevisionIndex(localRevision), linkedRevision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
294 assertEquals(fileNode.getRevision(localRevision), revision);
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
295 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
296 });
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
297 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
298 private int i, c;
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
299 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
300 private final int start;
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
301
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
302 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
303 this.start = start;
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
304 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
305 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
306 all = new Nodeid[total];
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
307 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
308
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
309 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
310 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
311 all[c++] = revision;
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
312 assertNotNull(revision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
313 assertFalse(localRevision == 0 && (parent1 != -1 || parent2 != -1));
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
314 assertFalse(localRevision > 0 && parent1 == -1 && parent2 == -1);
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
315 if (parent1 != -1) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
316 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
317 if (parent1 >= start) {
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
318 // 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
319 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
320 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
321 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
322 if (parent2 != -1) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
323 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
324 if (parent2 >= start) {
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
325 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
326 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
327 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
328 }
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
329 };
471
7bcfbc255f48 Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 443 448
diff changeset
330 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
331 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
332 // 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
333 fileNode.indexWalk(1, 3, new ParentInspectorCheck(1, 3));
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
334 }
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
335
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
336 /*
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
337 * This test checks not only RevisionDescendants class, but also
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
338 * Revlog.indexWalk implementation defect, aka:
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
339 * 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
340 */
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
341 @Test
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
342 public void testRevisionDescendants() throws Exception {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
343 HgRepository hgRepo = Configuration.get().find("branches-1");
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
344 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
345 // 0: all revisions are descendants, 17 total.
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
346 // 1: 2, 4, 7, 8, 9
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
347 // 2: 7, 8, 9
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
348 // 3: 5,6, 10-16
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
349 // 4: no children
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
350 // 5: 6, 10-16
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
351 // 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
352 // 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
353 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
354 RevisionDescendants[] result = new RevisionDescendants[roots.length];
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
355 for (int i = 0; i < roots.length; i++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
356 result[i] = new RevisionDescendants(hgRepo, roots[i]);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
357 result[i].build();
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
358 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
359 /*
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
360 for (int i = 0; i < roots.length; i++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
361 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
362 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
363 if (result[i].isDescendant(j)) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
364 System.out.printf("%3d ", j);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
365 }
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 System.out.printf(", isEmpty:%b\n", !result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
368 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
369 */
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
370 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
371 // 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
372 if ((descendantBitset[i] & ~(1<<roots[i])) != 0) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
373 assertTrue(result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
374 } else {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
375 assertFalse(result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
376 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
377 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
378 int bit = 1<<j;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
379 boolean shallBeDescendant = (descendantBitset[i] & bit) != 0;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
380 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
381 if (result[i].isDescendant(j)) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
382 assertTrue(m, shallBeDescendant);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
383 } else {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
384 assertFalse(m, shallBeDescendant);
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 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
387 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
388 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
389
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
390
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
391 @Test
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
392 @Ignore("just a dump for now, to compare values visually")
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
393 public void testRepositoryConfig() throws Exception {
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
394 HgRepository repo = Configuration.get().own();
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
395 final HgRepoConfig cfg = repo.getConfiguration();
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
396 Assert.assertNotNull(cfg.getPaths());
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
397 Assert.assertNotNull(cfg.getExtensions());
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
398 final Section dne = cfg.getSection("does-not-exist");
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
399 Assert.assertNotNull(dne);
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
400 Assert.assertFalse(dne.exists());
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
401 for (Pair<String, String> p : cfg.getSection("ui")) {
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
402 System.out.printf("%s = %s\n", p.first(), p.second());
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
403 }
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
404 final PathsSection p = cfg.getPaths();
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
405 System.out.printf("Known paths: %d. default: %s(%s), default-push: %s(%s)\n", p.getKeys().size(), p.getDefault(), p.hasDefault(), p.getDefaultPush(), p.hasDefaultPush());
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
406 for (String k : cfg.getPaths().getKeys()) {
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
407 System.out.println(k);
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
408 }
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
409 Assert.assertFalse(p.hasDefault() ^ p.getDefault() != null);
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
410 Assert.assertFalse(p.hasDefaultPush() ^ p.getDefaultPush() != null);
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
411 }
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
412
363
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
413 @Test
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
414 public void testChangelogExtrasDecode() {
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
415 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
416 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
417 // System.out.println(r);
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
418 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
419 // System.out.println(r2);
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
420 Assert.assertTrue(s.equals(r2));
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
421 }
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
422
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
423 @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
424 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
425 // 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
426 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
427 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
428 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
429 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
430 };
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 //
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 // 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
433 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
434 // 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
435 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
436 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
437 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
438 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
439 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
440 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
441 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
442 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
443 // 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
444 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
445 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
446 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
447 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
448 //
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 // 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
450 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
451 // 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
452 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
453 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
454 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
455 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
456 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
457 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
458 // 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
459 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
460 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
461 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
462
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 // 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
464 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
465 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
466 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
467 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
468 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
469 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
470 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
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 // 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
473 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
474 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
475 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
476 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
477 }
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
478
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
479 @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
480 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
481 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
482 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
483 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
484 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
485 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
486
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
487 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
488 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
489 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
490 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
491 //
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
492 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
493 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
494 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
495 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
496 //
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
497 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
498 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
499 }
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
500
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
501 @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
502 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
503 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
504 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
505 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
506 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
507 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
508 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
509
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
510 // 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
511 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
512 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
513 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
514 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
515 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
516 } 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
517 }
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
518 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
519 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
520 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
521 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
522 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
523 // 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
524 // 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
525 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
526 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
527 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
528 }
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
529 }
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
530
363
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
531
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
532 public static void main(String[] args) throws Exception {
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
533 new TestAuxUtilities().testRepositoryConfig();
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
534 }
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
535 }