Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestAuxUtilities.java @ 574:88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Tue, 16 Apr 2013 14:44:57 +0200 |
parents | 154718ae23ed |
children | e4a71afd3c71 |
rev | line source |
---|---|
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
552
45751456b471
Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
2 * Copyright (c) 2011-2013 TMate Software Ltd |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.test; |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
19 import static java.lang.Integer.toBinaryString; |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
20 import static org.junit.Assert.*; |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
21 import static org.tmatesoft.hg.repo.HgRepository.TIP; |
443
072b5f3ed0c8
Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
22 import static org.tmatesoft.hg.util.Path.CompareResult.*; |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
23 |
322
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
24 import java.io.IOException; |
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
25 import java.nio.ByteBuffer; |
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
26 |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
27 import org.junit.Assert; |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
28 import org.junit.Ignore; |
443
072b5f3ed0c8
Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
29 import org.junit.Rule; |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
30 import org.junit.Test; |
322
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
31 import org.tmatesoft.hg.core.HgCatCommand; |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
32 import org.tmatesoft.hg.core.Nodeid; |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
33 import org.tmatesoft.hg.internal.ArrayHelper; |
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; |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
44 import org.tmatesoft.hg.repo.HgRepoConfig; |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
45 import org.tmatesoft.hg.repo.HgRepoConfig.PathsSection; |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
46 import org.tmatesoft.hg.repo.HgRepoConfig.Section; |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
47 import org.tmatesoft.hg.repo.HgRepository; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
48 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
|
49 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
|
50 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
|
51 import org.tmatesoft.hg.util.CancelledException; |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
52 import org.tmatesoft.hg.util.Pair; |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
53 import org.tmatesoft.hg.util.Path; |
478
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
54 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
|
55 |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
56 /** |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
57 * |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
58 * @author Artem Tikhomirov |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 * @author TMate Software Ltd. |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 */ |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
61 public class TestAuxUtilities { |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
62 |
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
|
63 @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
|
64 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
|
65 |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 @Test |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 public void testArrayHelper() { |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
68 String[] initial = {"d", "w", "k", "b", "c", "i", "a", "r", "e", "h" }; |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
69 ArrayHelper ah = new ArrayHelper(); |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
70 String[] result = initial.clone(); |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
71 ah.sort(result); |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
72 String[] restored = restore(result, ah.getReverse()); |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
73 assertArrayEquals(initial, restored); |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
74 // |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
75 // 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
|
76 // 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
|
77 initial = new String[] {"d", "h", "c", "b", "k", "i", "a", "r", "e", "w" }; |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
78 ah.sort(result = initial.clone()); |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
79 restored = restore(result, ah.getReverse()); |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
80 assertArrayEquals(initial, restored); |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
81 } |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
82 |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
83 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
|
84 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
|
85 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
|
86 int indexInOriginal = sortReverse[i]; |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
87 rebuilt[indexInOriginal-1] = sorted[i]; |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
88 } |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
89 return rebuilt; |
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
90 } |
478
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
91 |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
92 |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
93 @Test |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
94 public void checkSubProgress() { |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
95 // no repo |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
96 class PS implements ProgressSupport { |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
97 |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
98 @SuppressWarnings("unused") |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
99 public int units; |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
100 public int worked; |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
101 public boolean done = false; |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
102 |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
103 public void start(int totalUnits) { |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
104 units = totalUnits; |
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 worked(int wu) { |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
107 worked += wu; |
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 done() { |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
110 done = true; |
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 }; |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
113 PS ps = new PS(); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
114 ps.start(10); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
115 ProgressSupport.Sub s1 = new ProgressSupport.Sub(ps, 3); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
116 ProgressSupport.Sub s2 = new ProgressSupport.Sub(ps, 7); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
117 s1.start(10); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
118 s1.worked(1); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
119 s1.worked(1); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
120 s1.worked(1); |
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 // so far s1 consumed 40% of total 3 units |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
123 assertEquals(1, ps.worked); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
124 s1.done(); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
125 // now s1 consumed 100% of total 3 units |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
126 assertEquals(3, ps.worked); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
127 assertFalse(ps.done); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
128 // |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
129 s2.start(5); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
130 s2.worked(3); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
131 // s2 consumed 60% (3/5) of ps's 7 units |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
132 // 3+4 == 3 from s1 + 0.6*7 |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
133 assertEquals(3 + 4, ps.worked); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
134 s2.worked(2); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
135 assertEquals(3 + 7, ps.worked); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
136 assertFalse(ps.done); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
137 s2.done(); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
138 //assertTrue(ps.done); |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
139 } |
e74580e24feb
Test for subprogress
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
473
diff
changeset
|
140 |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
141 |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
142 static class CancelImpl implements CancelSupport { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
143 private boolean shallStop = false; |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
144 public void stop() { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
145 shallStop = true; |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
146 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
147 public void checkCancelled() throws CancelledException { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
148 if (shallStop) { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
149 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
|
150 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
151 } |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
152 } |
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
|
153 |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
478
diff
changeset
|
154 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
|
155 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
|
156 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
|
157 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
|
158 |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
478
diff
changeset
|
159 protected 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
|
160 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
|
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 |
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 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
|
164 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
|
165 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
|
166 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
|
167 } |
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 } |
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 } |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
170 |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
171 @Test |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
172 public void testChangelogCancelSupport() throws Exception { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
173 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
|
174 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
|
175 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
176 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
|
177 super(limit); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
178 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
179 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
180 public void 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
|
181 nextValue(revisionNumber); |
312
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 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
184 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
|
185 cancelImpl.checkCancelled(); |
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 }; |
520
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
478
diff
changeset
|
188 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
|
189 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
|
190 super(limit); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
191 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
192 |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
193 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
|
194 nextValue(revisionNumber); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
195 } |
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
|
196 |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
197 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
|
198 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
|
199 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
|
200 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
201 return null; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
202 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
203 } |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
204 // |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
205 InspectorImplementsCancel insp1; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
206 repository.getChangelog().all(insp1= new InspectorImplementsCancel(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
|
207 Assert.assertEquals(insp1.stopValue, insp1.lastSeen); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
208 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
|
209 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
|
210 // |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
211 InspectorImplementsAdaptable insp2; |
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
212 repository.getChangelog().all(insp2= new InspectorImplementsAdaptable(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
|
213 Assert.assertEquals(insp2.stopValue, insp2.lastSeen); |
312
f9f3e9b67ccc
Facilitate cancellation and progress reporting in changelog and manifest iterations
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
311
diff
changeset
|
214 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
|
215 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
|
216 } |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
217 |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
218 @Test |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
219 public void testManifestCancelSupport() throws Exception { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
220 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
|
221 class InspectorImplementsAdaptable extends CancelAtValue implements HgManifest.Inspector, Adaptable { |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
222 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
|
223 super(limit); |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
224 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
225 |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
226 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
|
227 nextValue(lastSeen+1); |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
228 return true; |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
229 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
230 |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
231 public boolean end(int manifestRevision) { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
232 return true; |
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 |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
235 public <T> T getAdapter(Class<T> adapterClass) { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
236 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
|
237 return adapterClass.cast(cancelImpl); |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
238 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
239 return null; |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
240 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
241 |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
242 public boolean next(Nodeid nid, Path fname, Flags flags) { |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
243 return true; |
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 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
246 InspectorImplementsAdaptable insp1; |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
247 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
|
248 Assert.assertEquals(insp1.stopValue, insp1.lastSeen); |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
249 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
|
250 Assert.assertEquals(insp1.stopValue, insp1.lastSeen); |
313
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
251 } |
c1e3c18fd2f2
Test manifest cancellation
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
312
diff
changeset
|
252 |
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
|
253 @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
|
254 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
|
255 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
|
256 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
|
257 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
|
258 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
|
259 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
|
260 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
|
261 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
|
262 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
|
263 } |
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
264 } |
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 }); |
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 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
|
267 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
|
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 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
|
270 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
|
271 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
|
272 } |
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
273 }); |
d68dcb3b5f49
Propagate command's CancelSupport to low-level API. CancelSupport from context got priority over one from command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
313
diff
changeset
|
274 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
|
275 } 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
|
276 // 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
|
277 } |
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 } |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
279 |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
280 @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
|
281 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
|
282 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
|
283 repository.getChangelog().indexWalk(0, TIP, new HgChangelog.RevisionInspector() { |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
284 |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
285 public void next(int localRevision, Nodeid revision, int linkedRevision) { |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
286 Assert.assertEquals(localRevision, linkedRevision); |
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 }); |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
289 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
|
290 fileNode.indexWalk(0, TIP, new HgDataFile.RevisionInspector() { |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
291 int i = 0; |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
292 |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
293 public void next(int localRevision, Nodeid revision, int linkedRevision) { |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
294 assertEquals(i++, localRevision); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
295 assertEquals(fileNode.getChangesetRevisionIndex(localRevision), linkedRevision); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
296 assertEquals(fileNode.getRevision(localRevision), revision); |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
297 } |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
298 }); |
445
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
299 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
|
300 private int i, c; |
445
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
301 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
|
302 private final int start; |
445
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
303 |
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
304 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
|
305 this.start = start; |
2e402c12ebc6
Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
445
diff
changeset
|
306 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
|
307 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
|
308 all = new Nodeid[total]; |
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
309 } |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
310 |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
311 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
|
312 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
|
313 all[c++] = revision; |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
314 assertNotNull(revision); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
315 assertFalse(localRevision == 0 && (parent1 != -1 || parent2 != -1)); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
316 assertFalse(localRevision > 0 && parent1 == -1 && parent2 == -1); |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
317 if (parent1 != -1) { |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
318 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
|
319 if (parent1 >= start) { |
2e402c12ebc6
Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
445
diff
changeset
|
320 // 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
|
321 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
|
322 } |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
323 } |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
324 if (parent2 != -1) { |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
325 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
|
326 if (parent2 >= start) { |
2e402c12ebc6
Issue 31: Revlog#walk() fails with AIOOBE when start > 0
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
445
diff
changeset
|
327 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
|
328 } |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
329 } |
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
330 } |
445
d0e5dc3cae6e
Support for phases functionality from Mercurial 2.1
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
367
diff
changeset
|
331 }; |
471
7bcfbc255f48
Merge changes from smartgit3 branch into 1.1 stream
Artem Tikhomirov <tikhomirov.artem@gmail.com>
diff
changeset
|
332 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
|
333 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
|
334 // 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>
diff
changeset
|
335 fileNode.indexWalk(1, 3, new ParentInspectorCheck(1, 3)); |
327
3f09b8c19142
Tests for Revlog.Inspectors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
322
diff
changeset
|
336 } |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
337 |
472
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
338 /* |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
339 * This test checks not only RevisionDescendants class, but also |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
340 * Revlog.indexWalk implementation defect, aka: |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
341 * 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
|
342 */ |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
343 @Test |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
344 public void testRevisionDescendants() throws Exception { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
345 HgRepository hgRepo = Configuration.get().find("branches-1"); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
346 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
|
347 // 0: all revisions are descendants, 17 total. |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
348 // 1: 2, 4, 7, 8, 9 |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
349 // 2: 7, 8, 9 |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
350 // 3: 5,6, 10-16 |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
351 // 4: no children |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
352 // 5: 6, 10-16 |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
353 // 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
|
354 // 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
|
355 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
|
356 RevisionDescendants[] result = new RevisionDescendants[roots.length]; |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
357 for (int i = 0; i < roots.length; i++) { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
358 result[i] = new RevisionDescendants(hgRepo, roots[i]); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
359 result[i].build(); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
360 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
361 /* |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
362 for (int i = 0; i < roots.length; i++) { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
363 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
|
364 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
|
365 if (result[i].isDescendant(j)) { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
366 System.out.printf("%3d ", j); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
367 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
368 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
369 System.out.printf(", isEmpty:%b\n", !result[i].hasDescendants()); |
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 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
|
373 // 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
|
374 if ((descendantBitset[i] & ~(1<<roots[i])) != 0) { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
375 assertTrue(result[i].hasDescendants()); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
376 } else { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
377 assertFalse(result[i].hasDescendants()); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
378 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
379 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
|
380 int bit = 1<<j; |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
381 boolean shallBeDescendant = (descendantBitset[i] & bit) != 0; |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
382 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
|
383 if (result[i].isDescendant(j)) { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
384 assertTrue(m, shallBeDescendant); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
385 } else { |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
386 assertFalse(m, shallBeDescendant); |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
387 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
388 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
389 } |
2a0b09eec376
Tests for issue 31
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
471
diff
changeset
|
390 } |
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 |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
393 @Test |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
394 @Ignore("just a dump for now, to compare values visually") |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
395 public void testRepositoryConfig() throws Exception { |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
396 HgRepository repo = Configuration.get().own(); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
397 final HgRepoConfig cfg = repo.getConfiguration(); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
398 Assert.assertNotNull(cfg.getPaths()); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
399 Assert.assertNotNull(cfg.getExtensions()); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
400 final Section dne = cfg.getSection("does-not-exist"); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
401 Assert.assertNotNull(dne); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
402 Assert.assertFalse(dne.exists()); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
403 for (Pair<String, String> p : cfg.getSection("ui")) { |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
404 System.out.printf("%s = %s\n", p.first(), p.second()); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
405 } |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
406 final PathsSection p = cfg.getPaths(); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
407 System.out.printf("Known paths: %d. default: %s(%s), default-push: %s(%s)\n", p.getKeys().size(), p.getDefault(), p.hasDefault(), p.getDefaultPush(), p.hasDefaultPush()); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
408 for (String k : cfg.getPaths().getKeys()) { |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
409 System.out.println(k); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
410 } |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
411 Assert.assertFalse(p.hasDefault() ^ p.getDefault() != null); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
412 Assert.assertFalse(p.hasDefaultPush() ^ p.getDefaultPush() != null); |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
413 } |
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
414 |
363
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
415 @Test |
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
416 public void testChangelogExtrasDecode() { |
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
417 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
|
418 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
|
419 // System.out.println(r); |
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
420 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
|
421 // System.out.println(r2); |
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
422 Assert.assertTrue(s.equals(r2)); |
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
423 } |
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
424 |
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
|
425 @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
|
426 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
|
427 // 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
|
428 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
|
429 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
|
430 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
|
431 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
|
432 }; |
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 // |
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 // 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
|
435 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
|
436 // 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
|
437 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
|
438 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
|
439 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
|
440 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
|
441 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
|
442 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
|
443 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
|
444 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
|
445 // 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
|
446 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
|
447 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
|
448 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
|
449 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
|
450 // |
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 // 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
|
452 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
|
453 // 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
|
454 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
|
455 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
|
456 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
|
457 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
|
458 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
|
459 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
|
460 // 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
|
461 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
|
462 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
|
463 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
|
464 |
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 // 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
|
466 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
|
467 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
|
468 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
|
469 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
|
470 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
|
471 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
|
472 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
|
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 // 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
|
475 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
|
476 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
|
477 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
|
478 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
|
479 } |
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 |
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 @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
|
482 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
|
483 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
|
484 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
|
485 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
|
486 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
|
487 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
|
488 |
072b5f3ed0c8
Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
489 errorCollector.assertEquals(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
|
490 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
|
491 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
|
492 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
|
493 // |
072b5f3ed0c8
Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
494 errorCollector.assertEquals(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
|
495 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
|
496 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
|
497 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
|
498 // |
072b5f3ed0c8
Path to tell immediate parent-child relationship; more powerful scope impl; tests for both
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
431
diff
changeset
|
499 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
|
500 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
|
501 } |
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
|
502 |
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
|
503 @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
|
504 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
|
505 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
|
506 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
|
507 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
|
508 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
|
509 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
|
510 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
|
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 // 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
|
513 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
|
514 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
|
515 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
|
516 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
|
517 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
|
518 } 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
|
519 } |
45751456b471
Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
520 v = 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
|
521 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
|
522 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
|
523 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
|
524 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
|
525 // 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
|
526 // 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
|
527 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
|
528 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
|
529 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
|
530 } |
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
|
531 } |
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
|
532 |
558
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
533 @Test |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
534 public void testRangeSequence() { |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
535 RangeSeq rs = new RangeSeq(); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
536 rs.add(-1, 5, 3); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
537 rs.add(-1, 10, 2); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
538 rs.add(-1, 15, 3); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
539 rs.add(-1, 20, 3); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
540 errorCollector.assertFalse(rs.includesTargetLine(4)); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
541 errorCollector.assertTrue(rs.includesTargetLine(7)); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
542 errorCollector.assertFalse(rs.includesTargetLine(8)); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
543 errorCollector.assertTrue(rs.includesTargetLine(10)); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
544 errorCollector.assertFalse(rs.includesTargetLine(12)); |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
545 } |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
546 |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
547 @Test |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
548 public void testByteVector() { |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
549 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
|
550 v.add(7); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
551 v.add(9); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
552 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
|
553 v.clear(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
554 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
|
555 v.add(10); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
556 v.add(9); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
557 v.add(8); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
558 v.add(7); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
559 v.add(6); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
560 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
|
561 v.add(5); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
562 v.add(4); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
563 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
|
564 byte x = 10; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
565 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
|
566 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
|
567 x--; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
568 } |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
569 x = 10; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
570 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
|
571 v.copyTo(dd); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
572 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
|
573 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
|
574 x--; |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
575 } |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
576 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
|
577 } |
363
d9dfa9fe9cec
Decode escape sequences in changeset extras field
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
354
diff
changeset
|
578 |
574
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
579 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
|
580 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
|
581 t.testByteVector(); |
88afffd39899
Improve memory consumption of HgManifest#getFileRevision(): avoid extra byte[] instances
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
582 t.errorCollector.verify(); |
331
a37ce7145c3f
Access to repository configuration
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
327
diff
changeset
|
583 } |
311
b9592e21176a
Tests for array sort and reverse index building helper
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
584 } |