Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/TestAuxUtilities.java @ 657:6334b0267103

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Thu, 04 Jul 2013 20:27:45 +0200
parents 6526d8adbc0f
children cce0387c6041
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;
657
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
26 import java.util.Arrays;
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
27
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
28 import org.junit.Assert;
443
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
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;
574
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
34 import org.tmatesoft.hg.internal.ByteVector;
552
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
35 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
36 import org.tmatesoft.hg.internal.PathScope;
558
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
37 import org.tmatesoft.hg.internal.RangeSeq;
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
38 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
39 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
40 import org.tmatesoft.hg.repo.HgChangelog.RawChangeset;
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
41 import org.tmatesoft.hg.repo.HgDataFile;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
42 import org.tmatesoft.hg.repo.HgManifest;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
43 import org.tmatesoft.hg.repo.HgManifest.Flags;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
44 import org.tmatesoft.hg.repo.HgRepository;
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 609
diff changeset
45 import org.tmatesoft.hg.repo.HgRuntimeException;
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
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;
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
50 import org.tmatesoft.hg.util.Path;
478
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
51 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
52
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
53 /**
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
54 *
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
55 * @author Artem Tikhomirov
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
56 * @author TMate Software Ltd.
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
57 */
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
58 public class TestAuxUtilities {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
59
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
60 @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
61 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
62
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
63 @Test
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
64 public void testArrayHelper() {
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
65 String[] initial = {"d", "w", "k", "b", "c", "i", "a", "r", "e", "h" };
657
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
66 ArrayHelper<String> ah = new ArrayHelper<String>(initial);
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
67 String[] result = initial.clone();
657
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
68 ah.sort(result, false, false);
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
69 String[] restored = restore(result, ah.getReverseIndexes());
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
70 assertArrayEquals(initial, restored);
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
71 //
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
72 // 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
73 // 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
74 initial = new String[] {"d", "h", "c", "b", "k", "i", "a", "r", "e", "w" };
657
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
75 ah = new ArrayHelper<String>(initial);
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
76 ah.sort(result = new String[initial.length], true, true);
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
77 restored = restore(result, ah.getReverseIndexes());
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
78 assertArrayEquals(initial, restored);
657
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
79 for (int i = 0; i < initial.length; i++) {
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
80 String s = initial[i];
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
81 errorCollector.assertEquals(i, ah.binarySearch(s, -1));
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
82 errorCollector.assertEquals(Arrays.binarySearch(result, s), ah.binarySearchSorted(s));
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
83 }
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
84 }
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
85
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
86 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
87 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
88 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
89 int indexInOriginal = sortReverse[i];
657
6334b0267103 ParentChildMap can supply RevisionMap. Refactor ArrayHelper to keep most of sorted/reverse index magic inside
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 628
diff changeset
90 rebuilt[indexInOriginal] = sorted[i];
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
91 }
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
92 return rebuilt;
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
93 }
478
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
94
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 @Test
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
97 public void checkSubProgress() {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
98 // no repo
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
99 class PS implements ProgressSupport {
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 @SuppressWarnings("unused")
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
102 public int units;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
103 public int worked;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
104 public boolean done = false;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
105
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
106 public void start(int totalUnits) {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
107 units = totalUnits;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
108 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
109 public void worked(int wu) {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
110 worked += wu;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
111 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
112 public void done() {
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
113 done = true;
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
114 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
115 };
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
116 PS ps = new PS();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
117 ps.start(10);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
118 ProgressSupport.Sub s1 = new ProgressSupport.Sub(ps, 3);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
119 ProgressSupport.Sub s2 = new ProgressSupport.Sub(ps, 7);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
120 s1.start(10);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
121 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
122 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
123 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
124 s1.worked(1);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
125 // so far s1 consumed 40% of total 3 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
126 assertEquals(1, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
127 s1.done();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
128 // now s1 consumed 100% of total 3 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
129 assertEquals(3, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
130 assertFalse(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
131 //
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
132 s2.start(5);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
133 s2.worked(3);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
134 // s2 consumed 60% (3/5) of ps's 7 units
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
135 // 3+4 == 3 from s1 + 0.6*7
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
136 assertEquals(3 + 4, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
137 s2.worked(2);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
138 assertEquals(3 + 7, ps.worked);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
139 assertFalse(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
140 s2.done();
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
141 //assertTrue(ps.done);
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
142 }
e74580e24feb Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 473
diff changeset
143
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
144
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
145 static class CancelImpl implements CancelSupport {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
146 private boolean shallStop = false;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
147 public void stop() {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
148 shallStop = true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
149 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
150 public void checkCancelled() throws CancelledException {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
151 if (shallStop) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
152 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
153 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
154 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
155 }
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
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 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
158 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
159 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
160 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
161
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 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
163 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
164 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 478
diff changeset
165
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 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
167 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
168 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
169 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
170 }
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
171 }
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 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
173
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
174 @Test
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
175 public void testChangelogCancelSupport() throws Exception {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
176 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
177 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
178
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
179 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
180 super(limit);
312
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
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
183 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
184 nextValue(revisionNumber);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
185 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
186
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
187 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
188 cancelImpl.checkCancelled();
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 };
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
191 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
192 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
193 super(limit);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
194 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
195
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
196 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
197 nextValue(revisionNumber);
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
198 }
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
199
312
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
200 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
201 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
202 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
203 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
204 return null;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
205 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
206 }
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
207 //
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
208 InspectorImplementsCancel insp1;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
209 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
210 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
211 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
212 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
213 //
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
214 InspectorImplementsAdaptable insp2;
f9f3e9b67ccc Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 311
diff changeset
215 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
216 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
217 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
218 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
219 }
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
220
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
221 @Test
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
222 public void testManifestCancelSupport() throws Exception {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
223 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
224 class InspectorImplementsAdaptable extends CancelAtValue implements HgManifest.Inspector, Adaptable {
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
225 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
226 super(limit);
313
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 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
230 nextValue(lastSeen+1);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
231 return true;
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
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
234 public boolean end(int manifestRevision) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
235 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
236 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
237
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
238 public <T> T getAdapter(Class<T> adapterClass) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
239 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
240 return adapterClass.cast(cancelImpl);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
241 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
242 return null;
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
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
245 public boolean next(Nodeid nid, Path fname, Flags flags) {
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
246 return true;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
247 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
248 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
249 InspectorImplementsAdaptable insp1;
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
250 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
251 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
252 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
253 Assert.assertEquals(insp1.stopValue, insp1.lastSeen);
313
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
254 }
c1e3c18fd2f2 Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 312
diff changeset
255
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
256 @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
257 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
258 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
259 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
260 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
261 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
262 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
263 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
264 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
265 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
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 }
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
268 });
d68dcb3b5f49 Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 313
diff changeset
269 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
270 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
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 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
273 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
274 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
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 });
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
277 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
278 } 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
279 // 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
280 }
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
281 }
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 @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
284 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
285 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
286 repository.getChangelog().indexWalk(0, TIP, new HgChangelog.RevisionInspector() {
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
287
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
288 public void next(int localRevision, Nodeid revision, int linkedRevision) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
289 Assert.assertEquals(localRevision, linkedRevision);
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 });
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
292 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
293 fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() {
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
294 int i = 0;
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
295
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 609
diff changeset
296 public void next(int localRevision, Nodeid revision, int linkedRevision) throws HgRuntimeException {
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
297 assertEquals(i++, localRevision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
298 assertEquals(fileNode.getChangesetRevisionIndex(localRevision), linkedRevision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
299 assertEquals(fileNode.getRevision(localRevision), revision);
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
300 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
301 });
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
302 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
303 private int i, c;
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
304 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
305 private final int start;
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
306
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
307 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
308 this.start = start;
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
309 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
310 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
311 all = new Nodeid[total];
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
312 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
313
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
314 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
315 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
316 all[c++] = revision;
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
317 assertNotNull(revision);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
318 assertFalse(localRevision == 0 && (parent1 != -1 || parent2 != -1));
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
319 assertFalse(localRevision > 0 && parent1 == -1 && parent2 == -1);
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
320 if (parent1 != -1) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
321 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
322 if (parent1 >= start) {
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
323 // 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
324 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
325 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
326 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
327 if (parent2 != -1) {
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
328 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
329 if (parent2 >= start) {
2e402c12ebc6 Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 445
diff changeset
330 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
331 }
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
332 }
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
333 }
445
d0e5dc3cae6e Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 367
diff changeset
334 };
471
7bcfbc255f48 Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 443 448
diff changeset
335 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
336 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
337 // 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
338 fileNode.indexWalk(1, 3, new ParentInspectorCheck(1, 3));
327
3f09b8c19142 Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 322
diff changeset
339 }
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
340
472
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
341 /*
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
342 * This test checks not only RevisionDescendants class, but also
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
343 * Revlog.indexWalk implementation defect, aka:
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
344 * 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
345 */
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
346 @Test
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
347 public void testRevisionDescendants() throws Exception {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
348 HgRepository hgRepo = Configuration.get().find("branches-1");
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
349 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
350 // 0: all revisions are descendants, 17 total.
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
351 // 1: 2, 4, 7, 8, 9
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
352 // 2: 7, 8, 9
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
353 // 3: 5,6, 10-16
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
354 // 4: no children
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
355 // 5: 6, 10-16
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
356 // 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
357 // 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
358 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
359 RevisionDescendants[] result = new RevisionDescendants[roots.length];
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 result[i] = new RevisionDescendants(hgRepo, roots[i]);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
362 result[i].build();
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
363 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
364 /*
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
365 for (int i = 0; i < roots.length; i++) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
366 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
367 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
368 if (result[i].isDescendant(j)) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
369 System.out.printf("%3d ", j);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
370 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
371 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
372 System.out.printf(", isEmpty:%b\n", !result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
373 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
374 */
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
375 for (int 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
376 // 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
377 if ((descendantBitset[i] & ~(1<<roots[i])) != 0) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
378 assertTrue(result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
379 } else {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
380 assertFalse(result[i].hasDescendants());
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
381 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
382 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
383 int bit = 1<<j;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
384 boolean shallBeDescendant = (descendantBitset[i] & bit) != 0;
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
385 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
386 if (result[i].isDescendant(j)) {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
387 assertTrue(m, shallBeDescendant);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
388 } else {
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
389 assertFalse(m, shallBeDescendant);
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
390 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
391 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
392 }
2a0b09eec376 Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 471
diff changeset
393 }
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
394
363
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
395 @Test
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
396 public void testChangelogExtrasDecode() {
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
397 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
398 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
399 // System.out.println(r);
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
400 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
401 // System.out.println(r2);
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
402 Assert.assertTrue(s.equals(r2));
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
403 }
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
404
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
405 @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
406 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
407 // 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
408 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
409 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
410 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
411 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
412 };
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
413 //
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
414 // 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
415 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
416 // 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
417 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
418 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
419 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
420 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
421 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
422 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
423 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
424 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
425 // 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
426 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
427 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
428 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
429 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
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 // 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
432 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
433 // 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
434 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
435 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
436 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
437 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
438 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
439 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
440 // 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
441 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
442 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
443 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
444
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 // 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
446 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
447 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
448 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
449 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
450 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
451 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
452 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
453
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
454 // 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
455 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
456 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
457 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
458 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
459 }
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
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 @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
462 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
463 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
464 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
465 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
466 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
467 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
468
072b5f3ed0c8 Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 431
diff changeset
469 errorCollector.assertEquals(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
470 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
471 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
472 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
473 //
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.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
475 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
476 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
477 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
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 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
480 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
481 }
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
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
483 @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
484 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
485 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
486 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
487 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
488 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
489 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
490 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
491
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
492 // 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
493 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
494 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
495 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
496 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
497 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
498 } 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
499 }
45751456b471 Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
500 v = 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
501 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
502 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
503 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
504 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
505 // 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
506 // 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
507 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
508 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
509 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
510 }
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 }
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
558
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
513 @Test
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
514 public void testRangeSequence() {
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
515 RangeSeq rs = new RangeSeq();
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
516 rs.add(-1, 5, 3);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
517 rs.add(-1, 10, 2);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
518 rs.add(-1, 15, 3);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
519 rs.add(-1, 20, 3);
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
520 errorCollector.assertFalse(rs.includesTargetLine(4));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
521 errorCollector.assertTrue(rs.includesTargetLine(7));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
522 errorCollector.assertFalse(rs.includesTargetLine(8));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
523 errorCollector.assertTrue(rs.includesTargetLine(10));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
524 errorCollector.assertFalse(rs.includesTargetLine(12));
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
525 }
154718ae23ed Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 552
diff changeset
526
574
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
527 @Test
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
528 public void testByteVector() {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
529 ByteVector v = new ByteVector(4, 2);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
530 v.add(7);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
531 v.add(9);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
532 errorCollector.assertEquals(2, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
533 v.clear();
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
534 errorCollector.assertEquals(0, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
535 v.add(10);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
536 v.add(9);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
537 v.add(8);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
538 v.add(7);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
539 v.add(6);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
540 errorCollector.assertEquals(5, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
541 v.add(5);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
542 v.add(4);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
543 errorCollector.assertEquals(7, v.size());
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
544 byte x = 10;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
545 for (byte d : v.toByteArray()) {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
546 errorCollector.assertEquals(x, d);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
547 x--;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
548 }
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
549 x = 10;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
550 byte[] dd = new byte[10];
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
551 v.copyTo(dd);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
552 for (int i = 0; i < v.size(); i++) {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
553 errorCollector.assertEquals(x, dd[i]);
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
554 x--;
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
555 }
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
556 errorCollector.assertTrue(v.equalsTo(new byte[] { 10,9,8,7,6,5,4 }));
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
557 }
363
d9dfa9fe9cec Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 354
diff changeset
558
574
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
559 public static void main(String[] args) throws Throwable {
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
560 TestAuxUtilities t = new TestAuxUtilities();
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
561 t.testByteVector();
88afffd39899 Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 558
diff changeset
562 t.errorCollector.verify();
331
a37ce7145c3f Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 327
diff changeset
563 }
311
b9592e21176a Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
564 }