Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestHistory.java @ 591:e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Tue, 30 Apr 2013 18:55:42 +0200 |
parents | f7fbf48b9383 |
children | 6526d8adbc0f |
rev | line source |
---|---|
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
282
diff
changeset
|
2 * Copyright (c) 2011-2012 TMate Software Ltd |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
102
a3a2e5deb320
Updated contact address to support@hg4j.com
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
101
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.test; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
19 import static org.hamcrest.CoreMatchers.equalTo; |
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
20 import static org.hamcrest.CoreMatchers.is; |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
510
diff
changeset
|
21 import static org.junit.Assert.assertEquals; |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
22 import static org.junit.Assert.assertTrue; |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
23 import static org.tmatesoft.hg.core.HgIterateDirection.NewToOld; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
24 |
202
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
25 import java.util.ArrayList; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
26 import java.util.Collections; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
27 import java.util.Comparator; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
28 import java.util.Iterator; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
29 import java.util.LinkedList; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
30 import java.util.List; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
31 |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
32 import org.junit.Assert; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
33 import org.junit.Rule; |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
34 import org.junit.Test; |
507
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
35 import org.tmatesoft.hg.core.HgCallbackTargetException; |
129
645829962785
core.Cset renamed to HgChangeset; repo.Changeset moved into HgChangelog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
103
diff
changeset
|
36 import org.tmatesoft.hg.core.HgChangeset; |
427
31a89587eb04
FIXMEs: consistent names, throws for commands and their handlers. Use of checked exceptions in hi-level api
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
423
diff
changeset
|
37 import org.tmatesoft.hg.core.HgChangesetHandler; |
507
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
38 import org.tmatesoft.hg.core.HgChangesetTreeHandler; |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
510
diff
changeset
|
39 import org.tmatesoft.hg.core.HgFileRenameHandlerMixin; |
249
4c3b9f679412
Deprecated HgLogCommand.FileRevision gone, top-level HgFileRevision is bright and shiny replacement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
214
diff
changeset
|
40 import org.tmatesoft.hg.core.HgFileRevision; |
528
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
41 import org.tmatesoft.hg.core.HgIterateDirection; |
131
aa1629f36482
Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
129
diff
changeset
|
42 import org.tmatesoft.hg.core.HgLogCommand; |
aa1629f36482
Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
129
diff
changeset
|
43 import org.tmatesoft.hg.core.HgLogCommand.CollectHandler; |
507
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
44 import org.tmatesoft.hg.core.Nodeid; |
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:
518
diff
changeset
|
45 import org.tmatesoft.hg.internal.AdapterPlug; |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
46 import org.tmatesoft.hg.repo.HgLookup; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
70
diff
changeset
|
47 import org.tmatesoft.hg.repo.HgRepository; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
48 import org.tmatesoft.hg.test.LogOutputParser.Record; |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
510
diff
changeset
|
49 import org.tmatesoft.hg.util.Adaptable; |
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:
518
diff
changeset
|
50 import org.tmatesoft.hg.util.CancelSupport; |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
51 import org.tmatesoft.hg.util.CancelledException; |
507
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
52 import org.tmatesoft.hg.util.Pair; |
133
4a948ec83980
core.Path to util.Path as it's not Hg repo dependant
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
131
diff
changeset
|
53 import org.tmatesoft.hg.util.Path; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
54 |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
55 |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
56 /** |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
57 * |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
58 * @author Artem Tikhomirov |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 * @author TMate Software Ltd. |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 */ |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
61 public class TestHistory { |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
62 |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
63 @Rule |
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
64 public ErrorCollectorExt errorCollector = new ErrorCollectorExt(); |
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
65 |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
66 private HgRepository repo; |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
67 private final ExecHelper eh; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
68 private LogOutputParser changelogParser; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
69 |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
70 public static void main(String[] args) throws Throwable { |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
71 TestHistory th = new TestHistory(); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
72 th.testCompleteLog(); |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
73 th.testFollowHistory(); |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
74 th.errorCollector.verify(); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
75 // th.testPerformance(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
76 th.testOriginalTestLogRepo(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
77 th.testUsernames(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
78 th.testBranches(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
79 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
80 th.errorCollector.verify(); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
81 } |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
82 |
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
83 public TestHistory() throws Exception { |
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
84 this(new HgLookup().detectFromWorkingDir()); |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
85 // this(new HgLookup().detect("\\temp\\hg\\hello")); |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
86 } |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
87 |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
88 private TestHistory(HgRepository hgRepo) { |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
89 repo = hgRepo; |
282
e51dd9a14b6f
Yet another WC status fix, where dirstate parent and base revision are treated right (dirstate parent other than tip and explicit baseRevision are not the same)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
249
diff
changeset
|
90 eh = new ExecHelper(changelogParser = new LogOutputParser(true), repo.getWorkingDir()); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
91 |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
92 } |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
93 |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
94 @Test |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
95 public void testCompleteLog() throws Exception { |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
96 changelogParser.reset(); |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
97 eh.run("hg", "log", "--debug"); |
131
aa1629f36482
Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
129
diff
changeset
|
98 List<HgChangeset> r = new HgLogCommand(repo).execute(); |
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:
518
diff
changeset
|
99 report("hg log - COMPLETE REPO HISTORY", r, true); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
100 |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
101 r = new HgLogCommand(repo).order(NewToOld).execute(); |
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:
518
diff
changeset
|
102 report("hg log - COMPLETE REPO HISTORY, FROM NEW TO OLD", r, false); |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
103 } |
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
104 |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
105 @Test |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
106 public void testFollowHistory() throws Exception { |
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
107 final Path f = Path.create("cmdline/org/tmatesoft/hg/console/Remote.java"); |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
108 assertTrue(repo.getFileNode(f).exists()); |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
109 changelogParser.reset(); |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
110 eh.run("hg", "log", "--debug", "--follow", f.toString()); |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
111 |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
112 CollectWithRenameHandler h = new CollectWithRenameHandler(); |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
113 new HgLogCommand(repo).file(f, true).execute(h); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
114 errorCollector.assertEquals(1, h.rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
115 HgFileRevision from = h.rh.renames.get(0).first(); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
116 boolean fromMatched = "src/com/tmate/hgkit/console/Remote.java".equals(from.getPath().toString()); |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
117 String what = "hg log - FOLLOW FILE HISTORY"; |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
118 errorCollector.checkThat(what + "#copyReported ", h.rh.copyReported, is(true)); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
119 errorCollector.checkThat(what + "#copyFromMatched", fromMatched, is(true)); |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
120 // |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
121 // cmdline always gives in changesets in order from newest (bigger rev number) to oldest. |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
122 // LogCommand does other way round, from oldest to newest, follewed by revisions of copy source, if any |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
123 // (apparently older than oldest of the copy target). Hence need to sort Java results according to rev numbers |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
124 final LinkedList<HgChangeset> sorted = new LinkedList<HgChangeset>(h.getChanges()); |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
125 Collections.sort(sorted, new Comparator<HgChangeset>() { |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
126 public int compare(HgChangeset cs1, HgChangeset cs2) { |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
282
diff
changeset
|
127 return cs1.getRevisionIndex() < cs2.getRevisionIndex() ? 1 : -1; |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
128 } |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
129 }); |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
130 report(what, sorted, false); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
131 } |
507
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
132 |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
133 @Test |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
134 public void testChangesetTree() throws Exception { |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
135 repo = Configuration.get().find("branches-1"); |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
136 final String fname = "file1"; |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
137 assertTrue("[sanity]", repo.getFileNode(fname).exists()); |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
138 eh.run("hg", "log", "--debug", fname, "--cwd", repo.getLocation()); |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
139 |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
140 TreeCollectHandler h = new TreeCollectHandler(false); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
141 new HgLogCommand(repo).file(fname, false).execute(h); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
142 // since we use TreeCollectHandler with natural order (older to newer), shall reverse console result in report() |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
143 report("execute with HgChangesetTreeHandler(follow == false)", h.getResult(), true); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
144 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
145 |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
146 /** |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
147 * Few tests to check newly introduced followAncestry parameter to HgLogCommand: |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
148 * followRename: true, followAncestry: false |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
149 * followRename: false, followAncestry: true |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
150 * followRename: true, followAncestry: true |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
151 * Perhaps, shall be merged with {@link #testFollowHistory()} |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
152 */ |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
153 @Test |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
154 public void testFollowRenamesNotAncestry() throws Exception { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
155 repo = Configuration.get().find("log-follow"); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
156 final String fname1 = "file1_a"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
157 final String fname2 = "file1_b"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
158 assertTrue("[sanity]", repo.getFileNode(fname2).exists()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
159 // no --follow, but two names we know have been the same file (fname1 renamed to fname2) |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
160 // sequentially gives follow rename semantics without ancestry |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
161 eh.run("hg", "log", "--debug", fname2, fname1, "--cwd", repo.getLocation()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
162 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
163 CollectWithRenameHandler h = new CollectWithRenameHandler(); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
164 new HgLogCommand(repo).file(fname2, true, false).execute(h); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
165 errorCollector.assertEquals(1, h.rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
166 Pair<HgFileRevision, HgFileRevision> rename = h.rh.renames.get(0); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
167 errorCollector.assertEquals(fname1, rename.first().getPath().toString()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
168 errorCollector.assertEquals(fname2, rename.second().getPath().toString()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
169 // Ensure rename info came in the right moment |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
170 errorCollector.assertEquals(1, h.lastChangesetReportedAtRename.size()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
171 // Command iterates old to new, rename comes after last fname1 revision. Since we don't follow |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
172 // ancestry, it's the very last revision in fname1 history |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
173 String lastRevOfFname1 = "369c0882d477c11424a62eb4b791e86d1d4b6769"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
174 errorCollector.assertEquals(lastRevOfFname1, h.lastChangesetReportedAtRename.get(0).getNodeid().toString()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
175 report("HgChangesetHandler(renames: true, ancestry:false)", h.getChanges(), true); |
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:
518
diff
changeset
|
176 // |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
177 // Direction |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
178 h = new CollectWithRenameHandler(); |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
179 new HgLogCommand(repo).file(fname2, true, false).order(NewToOld).execute(h); |
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:
518
diff
changeset
|
180 // Identical rename shall be reported, at the same moment |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
181 errorCollector.assertEquals(1, h.rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
182 rename = h.rh.renames.get(0); |
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:
518
diff
changeset
|
183 errorCollector.assertEquals(fname1, rename.first().getPath().toString()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
184 errorCollector.assertEquals(fname2, rename.second().getPath().toString()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
185 errorCollector.assertEquals(1, h.lastChangesetReportedAtRename.size()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
186 // new to old, recently reported would be the very first revision fname2 pops up |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
187 String firstRevOfFname2 = "27e7a69373b74d42e75f3211e56510ff17d01370"; |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
188 errorCollector.assertEquals(firstRevOfFname2, h.lastChangesetReportedAtRename.get(0).getNodeid().toString()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
189 report("HgChangesetHandler(renames: true, ancestry:false)", h.getChanges(), false); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
190 // |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
191 // TreeChangeHandler - in #testChangesetTreeFollowRenamesNotAncestry |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
192 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
193 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
194 @Test |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
195 public void testChangesetTreeFollowRenamesNotAncestry() throws Exception { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
196 repo = Configuration.get().find("log-follow"); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
197 final String fname1 = "file1_a"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
198 final String fname2 = "file1_b"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
199 assertTrue("[sanity]", repo.getFileNode(fname2).exists()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
200 // no --follow, but two names we know have been the same file (fname1 renamed to fname2) |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
201 // sequentially gives follow rename semantics without ancestry |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
202 eh.run("hg", "log", "--debug", fname2, fname1, "--cwd", repo.getLocation()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
203 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
204 TreeCollectHandler h = new TreeCollectHandler(true); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
205 RenameCollector rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
206 // can't check that prev revision is in parent because there are forks in |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
207 // file history (e.g. rev2 and rev3 (that comes next) both have rev0 as their parent |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
208 // and followAncestry is false |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
209 // h.checkPrevInParents = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
210 new HgLogCommand(repo).file(fname2, true, false).execute(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
211 errorCollector.assertEquals(1, rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
212 Pair<HgFileRevision, HgFileRevision> rename = rh.renames.get(0); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
213 errorCollector.assertEquals(fname1, rename.first().getPath().toString()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
214 errorCollector.assertEquals(fname2, rename.second().getPath().toString()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
215 report("HgChangesetTreeHandler(renames: true, ancestry:false)", h.getResult(), false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
216 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
217 // Direction |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
218 h = new TreeCollectHandler(false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
219 rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
220 // h.checkPrevInChildren = true; see above |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
221 new HgLogCommand(repo).file(fname2, true, false).order(NewToOld).execute(h); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
222 errorCollector.assertEquals(1, rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
223 rename = rh.renames.get(0); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
224 errorCollector.assertEquals(fname1, rename.first().getPath().toString()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
225 errorCollector.assertEquals(fname2, rename.second().getPath().toString()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
226 report("HgChangesetTreeHandler(renames: true, ancestry:false)", h.getResult(), false); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
227 } |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
228 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
229 @Test |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
230 public void testFollowAncestryNotRenames() throws Exception { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
231 repo = Configuration.get().find("log-follow"); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
232 final String fname2 = "file1_b"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
233 assertTrue("[sanity]", repo.getFileNode(fname2).exists()); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
234 final List<Record> fname2Follow = getAncestryWithoutRenamesFromCmdline(fname2); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
235 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
236 CollectWithRenameHandler h = new CollectWithRenameHandler(); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
237 new HgLogCommand(repo).file(fname2, false, true).execute(h); |
528
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
238 // renames are reported regardless of followRenames parameter, but |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
239 // solely based on HgFileRenameHandlerMixin |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
240 errorCollector.assertEquals(1, h.rh.renames.size()); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
241 report("HgChangesetHandler(renames: false, ancestry:true)", h.getChanges(), fname2Follow, true, errorCollector); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
242 // |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
243 // Direction |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
244 h = new CollectWithRenameHandler(); |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
245 new HgLogCommand(repo).file(fname2, false, true).order(NewToOld).execute(h); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
246 report("HgChangesetHandler(renames: false, ancestry:true)", h.getChanges(), fname2Follow, false/*!!!*/, errorCollector); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
247 // |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
248 // TreeChangeHandler - in #testChangesetTreeFollowAncestryNotRenames |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
249 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
250 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
251 @Test |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
252 public void testChangesetTreeFollowAncestryNotRenames() throws Exception { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
253 repo = Configuration.get().find("log-follow"); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
254 final String fname2 = "file1_b"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
255 final List<Record> fname2Follow = getAncestryWithoutRenamesFromCmdline(fname2); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
256 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
257 TreeCollectHandler h = new TreeCollectHandler(false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
258 h.checkPrevInParents = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
259 new HgLogCommand(repo).file(fname2, false, true).execute(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
260 report("HgChangesetTreeHandler(renames: false, ancestry:true)", h.getResult(), fname2Follow, true, errorCollector); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
261 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
262 // Direction |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
263 h = new TreeCollectHandler(false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
264 h.checkPrevInChildren = true; |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
265 new HgLogCommand(repo).file(fname2, false, true).order(NewToOld).execute(h); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
266 report("HgChangesetTreeHandler(renames: false, ancestry:true)", h.getResult(), fname2Follow, false, errorCollector); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
267 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
268 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
269 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
270 private List<Record> getAncestryWithoutRenamesFromCmdline(String fname2) throws Exception { |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
271 // to get "followed" history of fname2 only (without fname1 origin), |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
272 // get the complete history and keep there only elements that match fname2 own history |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
273 eh.run("hg", "log", "--debug", "--follow", fname2, "--cwd", repo.getLocation()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
274 final List<Record> fname2Follow = new LinkedList<LogOutputParser.Record>(changelogParser.getResult()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
275 changelogParser.reset(); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
276 eh.run("hg", "log", "--debug", fname2, "--cwd", repo.getLocation()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
277 // fname2Follow.retainAll(changelogParser.getResult()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
278 for (Iterator<Record> it = fname2Follow.iterator(); it.hasNext();) { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
279 Record r = it.next(); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
280 boolean belongsToSoleFname2History = false; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
281 for (Record d : changelogParser.getResult()) { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
282 if (d.changesetIndex == r.changesetIndex) { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
283 assert d.changesetNodeid.equals(r.changesetNodeid) : "[sanity]"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
284 belongsToSoleFname2History = true; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
285 break; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
286 } |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
287 } |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
288 if (!belongsToSoleFname2History) { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
289 it.remove(); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
290 } |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
291 } |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
292 return fname2Follow; |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
293 } |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
294 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
295 /** |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
296 * output identical to that of "hg log --follow" |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
297 */ |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
298 @Test |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
299 public void testFollowBothRenameAndAncestry() throws Exception { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
300 repo = Configuration.get().find("log-follow"); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
301 final String fname1 = "file1_a"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
302 final String fname2 = "file1_b"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
303 assertTrue("[sanity]", repo.getFileNode(fname2).exists()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
304 eh.run("hg", "log", "--debug", "--follow", fname2, "--cwd", repo.getLocation()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
305 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
306 CollectWithRenameHandler h = new CollectWithRenameHandler(); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
307 new HgLogCommand(repo).file(fname2, true, true).execute(h); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
308 errorCollector.assertEquals(1, h.rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
309 Pair<HgFileRevision, HgFileRevision> rename = h.rh.renames.get(0); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
310 errorCollector.assertEquals(fname1, rename.first().getPath().toString()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
311 errorCollector.assertEquals(fname2, rename.second().getPath().toString()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
312 // Ensure rename info came in the right moment |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
313 errorCollector.assertEquals(1, h.lastChangesetReportedAtRename.size()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
314 String fname1BranchRevision = "6e668ff2940acb250c8627843f8116166fe5d5cd"; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
315 errorCollector.assertEquals(fname1BranchRevision, h.lastChangesetReportedAtRename.get(0).getNodeid().toString()); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
316 // finally, match output |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
317 report("HgChangesetHandler(renames: true, ancestry:true)", h.getChanges(), true); |
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:
518
diff
changeset
|
318 // |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
319 // Switch direction and compare, order shall match that from console |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
320 h = new CollectWithRenameHandler(); |
522
2103388d4010
Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
521
diff
changeset
|
321 new HgLogCommand(repo).file(fname2, true, true).order(NewToOld).execute(h); |
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:
518
diff
changeset
|
322 // Identical rename event shall be reported |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
323 errorCollector.assertEquals(1, h.rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
324 rename = h.rh.renames.get(0); |
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:
518
diff
changeset
|
325 errorCollector.assertEquals(fname1, rename.first().getPath().toString()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
326 errorCollector.assertEquals(fname2, rename.second().getPath().toString()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
327 // new to old, recently reported would be the very first revision fname2 pops up |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
328 String firstRevOfFname2 = "27e7a69373b74d42e75f3211e56510ff17d01370"; |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
329 errorCollector.assertEquals(firstRevOfFname2, h.lastChangesetReportedAtRename.get(0).getNodeid().toString()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
330 report("HgChangesetHandler(renames: true, ancestry:true)", h.getChanges(), false /*do not reorder console results !!!*/); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
331 // |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
332 // TreeChangeHandler in #testChangesetTreeFollowRenameAndAncestry |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
333 } |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
334 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
335 @Test |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
336 public void testChangesetTreeFollowRenameAndAncestry() throws Exception { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
337 repo = Configuration.get().find("log-follow"); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
338 final String fname = "file1_b"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
339 assertTrue("[sanity]", repo.getFileNode(fname).exists()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
340 eh.run("hg", "log", "--debug", "--follow", fname, "--cwd", repo.getLocation()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
341 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
342 TreeCollectHandler h = new TreeCollectHandler(true); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
343 RenameCollector rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
344 h.checkPrevInParents = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
345 new HgLogCommand(repo).file(fname, true, true).execute(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
346 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
347 assertEquals(1, h.getAdapterUse(HgFileRenameHandlerMixin.class)); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
348 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
349 report("execute with HgChangesetTreeHandler(follow == true)", h.getResult(), false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
350 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
351 assertEquals(1, rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
352 assertEquals(Path.create(fname), rh.renames.get(0).second().getPath()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
353 } |
528
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
354 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
355 /** |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
356 * Ensure {@link HgFileRenameHandlerMixin} is always notified, even |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
357 * if followRename is false. |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
358 * Shall check: |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
359 * both {@link HgLogCommand#execute(HgChangesetHandler)} and {@link HgLogCommand#execute(HgChangesetTreeHandler)} |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
360 * and for both iteration directions in each case |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
361 */ |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
362 @Test |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
363 public void testRenameHandlerNotifiedEvenIfNotFollowRename() throws Exception { |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
364 repo = Configuration.get().find("log-follow"); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
365 final String fname1 = "file1_a"; |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
366 final String fname2 = "file1_b"; |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
367 final String fnameNoRename = "file2"; |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
368 assertTrue("[sanity]", repo.getFileNode(fnameNoRename).exists()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
369 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
370 // first, check that file without renames doesn't report any accidentally |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
371 CollectWithRenameHandler h1 = new CollectWithRenameHandler(); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
372 HgLogCommand cmd = new HgLogCommand(repo).file(fnameNoRename, false, false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
373 cmd.execute(h1); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
374 errorCollector.assertEquals(0, h1.rh.renames.size()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
375 TreeCollectHandler h2 = new TreeCollectHandler(false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
376 RenameCollector rh = new RenameCollector(h2); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
377 cmd.execute(h2); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
378 errorCollector.assertEquals(0, rh.renames.size()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
379 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
380 // check default iterate direction |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
381 cmd = new HgLogCommand(repo).file(fname2, false, false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
382 cmd.execute(h1 = new CollectWithRenameHandler()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
383 errorCollector.assertEquals(1, h1.rh.renames.size()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
384 assertRename(fname1, fname2, h1.rh.renames.get(0)); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
385 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
386 h2 = new TreeCollectHandler(false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
387 rh = new RenameCollector(h2); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
388 cmd.execute(h2); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
389 errorCollector.assertEquals(1, rh.renames.size()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
390 assertRename(fname1, fname2, rh.renames.get(0)); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
391 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
392 eh.run("hg", "log", "--debug", fname2, "--cwd", repo.getLocation()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
393 report("HgChangesetHandler+RenameHandler with followRenames = false, default iteration order", h1.getChanges(), true); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
394 report("HgChangesetTreeHandler+RenameHandler with followRenames = false, default iteration order", h2.getResult(), true); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
395 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
396 // |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
397 // Now, check that iteration in opposite direction (new to old) |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
398 // still reports renames (and correct revisions, too) |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
399 cmd.order(HgIterateDirection.NewToOld); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
400 cmd.execute(h1 = new CollectWithRenameHandler()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
401 errorCollector.assertEquals(1, h1.rh.renames.size()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
402 assertRename(fname1, fname2, h1.rh.renames.get(0)); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
403 h2 = new TreeCollectHandler(false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
404 rh = new RenameCollector(h2); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
405 cmd.execute(h2); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
406 errorCollector.assertEquals(1, rh.renames.size()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
407 assertRename(fname1, fname2, rh.renames.get(0)); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
408 report("HgChangesetHandler+RenameHandler with followRenames = false, new2old iteration order", h1.getChanges(), false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
409 report("HgChangesetTreeHandler+RenameHandler with followRenames = false, new2old iteration order", h2.getResult(), false); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
410 } |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
411 |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
412 private void assertRename(String fnameFrom, String fnameTo, Pair<HgFileRevision, HgFileRevision> rename) { |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
413 errorCollector.assertEquals(fnameFrom, rename.first().getPath().toString()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
414 errorCollector.assertEquals(fnameTo, rename.second().getPath().toString()); |
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
415 } |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
416 |
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:
518
diff
changeset
|
417 /** |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
418 * @see TestAuxUtilities#testChangelogCancelSupport() |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
419 */ |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
420 @Test |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
421 public void testLogCommandCancelSupport() throws Exception { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
422 repo = Configuration.get().find("branches-1"); // any repo with more revisions |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
423 class BaseCancel extends TestAuxUtilities.CancelAtValue implements HgChangesetHandler { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
424 BaseCancel(int limit) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
425 super(limit); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
426 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
427 public void cset(HgChangeset changeset) throws HgCallbackTargetException { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
428 nextValue(changeset.getRevisionIndex()); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
429 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
430 }; |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
431 class ImplementsCancel extends BaseCancel implements CancelSupport { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
432 ImplementsCancel(int limit) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
433 super(limit); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
434 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
435 public void checkCancelled() throws CancelledException { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
436 cancelImpl.checkCancelled(); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
437 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
438 }; |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
439 class AdaptsToCancel extends BaseCancel implements Adaptable { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
440 AdaptsToCancel(int limit) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
441 super(limit); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
442 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
443 public <T> T getAdapter(Class<T> adapterClass) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
444 if (adapterClass == CancelSupport.class) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
445 return adapterClass.cast(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:
518
diff
changeset
|
446 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
447 return null; |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
448 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
449 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
450 |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
451 BaseCancel insp = new ImplementsCancel(3); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
452 try { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
453 new HgLogCommand(repo).execute(insp); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
454 errorCollector.fail("CancelSupport as implemented iface"); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
455 } catch (CancelledException ex) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
456 errorCollector.assertEquals("CancelSupport as implemented iface", insp.stopValue, insp.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:
518
diff
changeset
|
457 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
458 insp = new AdaptsToCancel(5); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
459 try { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
460 new HgLogCommand(repo).execute(insp); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
461 errorCollector.fail("Adaptable to CancelSupport"); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
462 } catch (CancelledException ex) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
463 errorCollector.assertEquals("Adaptable to CancelSupport", insp.stopValue, insp.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:
518
diff
changeset
|
464 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
465 insp = new BaseCancel(9); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
466 try { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
467 new HgLogCommand(repo).set(insp.cancelImpl).execute(insp); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
468 errorCollector.fail("cmd#set(CancelSupport)"); |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
469 } catch (CancelledException e) { |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
470 errorCollector.assertEquals("cmd#set(CancelSupport)", insp.stopValue, insp.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:
518
diff
changeset
|
471 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
472 } |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
473 |
202
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
474 private void report(String what, List<HgChangeset> r, boolean reverseConsoleResult) { |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
475 final List<Record> consoleResult = changelogParser.getResult(); |
202
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
476 report(what, r, consoleResult, reverseConsoleResult, errorCollector); |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
477 } |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
478 |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
479 static void report(String what, List<HgChangeset> hg4jResult, List<Record> consoleResult, boolean reverseConsoleResult, ErrorCollectorExt errorCollector) { |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
480 consoleResult = new ArrayList<Record>(consoleResult); // need a copy in case callee would use result again |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
481 if (reverseConsoleResult) { |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
482 Collections.reverse(consoleResult); |
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
483 } |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
484 errorCollector.checkThat(what + ". Number of changeset reported didn't match", hg4jResult.size(), equalTo(consoleResult.size())); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
485 Iterator<Record> consoleResultItr = consoleResult.iterator(); |
202
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
486 for (HgChangeset cs : hg4jResult) { |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
487 if (!consoleResultItr.hasNext()) { |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
488 errorCollector.addError(new AssertionError("Ran out of console results while there are still hg4j results")); |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
489 break; |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
490 } |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
491 Record cr = consoleResultItr.next(); |
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:
518
diff
changeset
|
492 // flags, not separate checkThat() because when lists are large, and do not match, |
1ee452f31187
Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
518
diff
changeset
|
493 // number of failures may slow down test process significantly |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
282
diff
changeset
|
494 int x = cs.getRevisionIndex() == cr.changesetIndex ? 0x1 : 0; |
214
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
495 x |= cs.getDate().toString().equals(cr.date) ? 0x2 : 0; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
496 x |= cs.getNodeid().toString().equals(cr.changesetNodeid) ? 0x4 : 0; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
497 x |= cs.getUser().equals(cr.user) ? 0x8 : 0; |
202
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
498 // need to do trim() on comment because command-line template does, and there are |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
499 // repositories that have couple of newlines in the end of the comment (e.g. hello sample repo from the book) |
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
500 x |= cs.getComment().trim().equals(cr.description) ? 0x10 : 0; |
423
9c9c442b5f2e
Major refactoring of exception handling. Low-level API uses RuntimeExceptions, while checked are left for higher level
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
282
diff
changeset
|
501 errorCollector.checkThat(String.format(what + ". Mismatch (0x%x) in %d hg4j rev comparing to %d cmdline's.", x, cs.getRevisionIndex(), cr.changesetIndex), x, equalTo(0x1f)); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
502 consoleResultItr.remove(); |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
503 } |
202
706bcc7cfee4
Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
147
diff
changeset
|
504 errorCollector.checkThat(what + ". Unprocessed results in console left (insufficient from hg4j)", consoleResultItr.hasNext(), equalTo(false)); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
505 } |
100
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
506 |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
507 public void testPerformance() throws Exception { |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
508 final int runs = 10; |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
509 final long start1 = System.currentTimeMillis(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
510 for (int i = 0; i < runs; i++) { |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
511 changelogParser.reset(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
512 eh.run("hg", "log", "--debug"); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
513 } |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
514 final long start2 = System.currentTimeMillis(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
515 for (int i = 0; i < runs; i++) { |
131
aa1629f36482
Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
129
diff
changeset
|
516 new HgLogCommand(repo).execute(); |
100
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
517 } |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
518 final long end = System.currentTimeMillis(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
519 System.out.printf("'hg log --debug', %d runs: Native client total %d (%d per run), Java client %d (%d)\n", runs, start2-start1, (start2-start1)/runs, end-start2, (end-start2)/runs); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
520 } |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
521 |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
522 @Test |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
523 public void testOriginalTestLogRepo() throws Exception { |
462
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
524 // tests fro mercurial distribution, test-log.t |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
525 repo = Configuration.get().find("log-1"); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
526 HgLogCommand cmd = new HgLogCommand(repo); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
527 // funny enough, but hg log -vf a -R c:\temp\hg\test-log\a doesn't work, while --cwd <same> works fine |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
528 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
529 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
530 eh.run("hg", "log", "--debug", "a", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
531 report("log a", cmd.file("a", false).execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
532 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
533 changelogParser.reset(); |
462
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
534 // fails with Mercurial 2.2.1, @see http://selenic.com/pipermail/mercurial-devel/2012-February/038249.html |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
535 // and http://www.selenic.com/hg/rev/60101427d618?rev= |
468
3ca4ae7bdd38
Clean experimental marks and deprecation code. Update version number to release
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
462
diff
changeset
|
536 // fix for the test (replacement) is available below |
3ca4ae7bdd38
Clean experimental marks and deprecation code. Update version number to release
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
462
diff
changeset
|
537 // eh.run("hg", "log", "--debug", "-f", "a", "--cwd", repo.getLocation()); |
3ca4ae7bdd38
Clean experimental marks and deprecation code. Update version number to release
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
462
diff
changeset
|
538 // List<HgChangeset> r = cmd.file("a", true).execute(); |
3ca4ae7bdd38
Clean experimental marks and deprecation code. Update version number to release
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
462
diff
changeset
|
539 // report("log -f a", r, true); |
3ca4ae7bdd38
Clean experimental marks and deprecation code. Update version number to release
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
462
diff
changeset
|
540 |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
541 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
542 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
543 eh.run("hg", "log", "--debug", "-f", "e", "--cwd", repo.getLocation()); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
544 report("log -f e", cmd.file("e", true).execute(), true); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
545 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
546 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
547 eh.run("hg", "log", "--debug", "dir/b", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
548 report("log dir/b", cmd.file("dir/b", false).execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
549 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
550 changelogParser.reset(); |
462
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
551 // |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
552 // Commented out for the same reason as above hg log -f a - newly introduced error message in Mercurial 2.2 |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
553 // when files are not part of the parent revision |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
554 // eh.run("hg", "log", "--debug", "-f", "dir/b", "--cwd", repo.getLocation()); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
555 // report("log -f dir/b", cmd.file("dir/b", true).execute(), false /*#1, below*/); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
556 /* |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
557 * #1: false works because presently commands dispatches history of the queried file, and then history |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
558 * of it's origin. With history comprising of renames only, this effectively gives reversed (newest to oldest) |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
559 * order of revisions. |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
560 */ |
462
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
561 |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
562 // commented tests from above updated to work in 2.2 - update repo to revision where files are present |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
563 eh.run("hg", "update", "-q", "-r", "2", "--cwd", repo.getLocation()); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
564 changelogParser.reset(); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
565 eh.run("hg", "log", "--debug", "-f", "a", "--cwd", repo.getLocation()); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
566 List<HgChangeset> r = cmd.file("a", true).execute(); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
567 report("log -f a", r, true); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
568 changelogParser.reset(); |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
569 eh.run("hg", "log", "--debug", "-f", "dir/b", "--cwd", repo.getLocation()); |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
570 report("log -f dir/b", cmd.file("dir/b", true).execute(), true); |
462
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
571 // |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
572 // get repo back into clear state, up to the tip |
ad0322a4af20
Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
427
diff
changeset
|
573 eh.run("hg", "update", "-q", "--cwd", repo.getLocation()); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
574 } |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
575 |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
576 @Test |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
577 public void testUsernames() throws Exception { |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
578 repo = Configuration.get().find("log-users"); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
579 final String user1 = "User One <user1@example.org>"; |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
580 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
581 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
582 eh.run("hg", "log", "--debug", "-u", user1, "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
583 report("log -u " + user1, new HgLogCommand(repo).user(user1).execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
584 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
585 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
586 eh.run("hg", "log", "--debug", "-u", "user1", "-u", "user2", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
587 report("log -u user1 -u user2", new HgLogCommand(repo).user("user1").user("user2").execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
588 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
589 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
590 eh.run("hg", "log", "--debug", "-u", "user3", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
591 report("log -u user3", new HgLogCommand(repo).user("user3").execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
592 } |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
593 |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
594 @Test |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
595 public void testBranches() throws Exception { |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
596 repo = Configuration.get().find("log-branches"); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
597 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
598 eh.run("hg", "log", "--debug", "-b", "default", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
599 report("log -b default" , new HgLogCommand(repo).branch("default").execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
600 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
601 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
602 eh.run("hg", "log", "--debug", "-b", "test", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
603 report("log -b test" , new HgLogCommand(repo).branch("test").execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
604 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
605 assertTrue("log -b dummy shall yeild empty result", new HgLogCommand(repo).branch("dummy").execute().isEmpty()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
606 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
607 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
608 eh.run("hg", "log", "--debug", "-b", "default", "-b", "test", "--cwd", repo.getLocation()); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
609 report("log -b default -b test" , new HgLogCommand(repo).branch("default").branch("test").execute(), true); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
610 } |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
611 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
612 //// |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
613 |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
510
diff
changeset
|
614 private final class TreeCollectHandler extends AdapterPlug implements HgChangesetTreeHandler { |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
615 private final LinkedList<HgChangeset> cmdResult = new LinkedList<HgChangeset>(); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
616 private final boolean reverseResult; |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
617 boolean checkPrevInChildren = false; // true when iterating new to old |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
618 boolean checkPrevInParents = false; // true when iterating old to new |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
619 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
620 public TreeCollectHandler(boolean _reverseResult) { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
621 this.reverseResult = _reverseResult; |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
622 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
623 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
624 public List<HgChangeset> getResult() { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
625 return cmdResult; |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
626 } |
509
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
627 |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
628 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
629 public void treeElement(TreeElement entry) throws HgCallbackTargetException { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
630 // check consistency |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
631 Nodeid cset = entry.changeset().getNodeid(); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
632 errorCollector.assertEquals(entry.changesetRevision(), cset); |
509
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
633 Pair<HgChangeset, HgChangeset> p = entry.parents(); |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
634 Pair<HgChangeset, HgChangeset> parents_a = p; |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
635 Pair<Nodeid, Nodeid> parents_b = entry.parentRevisions(); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
636 if (parents_b.first().isNull()) { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
637 errorCollector.assertTrue(parents_a.first() == null); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
638 } else { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
639 errorCollector.assertEquals(parents_b.first(), parents_a.first().getNodeid()); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
640 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
641 if (parents_b.second().isNull()) { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
642 errorCollector.assertTrue(parents_a.second() == null); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
643 } else { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
644 errorCollector.assertEquals(parents_b.second(), parents_a.second().getNodeid()); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
645 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
646 // |
509
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
647 if (checkPrevInChildren && !cmdResult.isEmpty()) { |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
648 HgChangeset prevChangeset = reverseResult ? cmdResult.getFirst() : cmdResult.getLast(); |
517
9922d1f7cb2a
Update test to use new command configuration argument (used to have followAncestry == true by default)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
514
diff
changeset
|
649 String msg = String.format("No parent-child bind between revisions %d and %d", prevChangeset.getRevisionIndex(), entry.changeset().getRevisionIndex()); |
509
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
650 errorCollector.assertTrue(msg, entry.children().contains(prevChangeset)); |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
651 } |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
652 if (checkPrevInParents && !cmdResult.isEmpty()) { |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
653 HgChangeset prevChangeset = reverseResult ? cmdResult.getFirst() : cmdResult.getLast(); |
517
9922d1f7cb2a
Update test to use new command configuration argument (used to have followAncestry == true by default)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
514
diff
changeset
|
654 String msg = String.format("No parent-child bind between revisions %d and %d", prevChangeset.getRevisionIndex(), entry.changeset().getRevisionIndex()); |
509
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
655 errorCollector.assertTrue(msg, p.first() == prevChangeset || p.second() == prevChangeset); |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
656 } |
a30e74dca193
Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
508
diff
changeset
|
657 // |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
658 if (reverseResult) { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
659 cmdResult.addFirst(entry.changeset()); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
660 } else { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
661 cmdResult.addLast(entry.changeset()); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
662 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
663 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
664 } |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
665 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
666 private static class CollectWithRenameHandler extends CollectHandler implements HgChangesetHandler.WithCopyHistory { |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
667 public final RenameCollector rh = new RenameCollector(); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
668 public List<HgChangeset> lastChangesetReportedAtRename = new LinkedList<HgChangeset>(); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
669 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
670 public void copy(HgFileRevision from, HgFileRevision to) throws HgCallbackTargetException { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
671 Assert.assertTrue("Renames couldn't be reported prior to any change", getChanges().size() > 0); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
672 HgChangeset lastKnown = getChanges().get(getChanges().size() - 1); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
673 lastChangesetReportedAtRename.add(lastKnown); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
674 rh.copy(from, to); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
675 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
676 }; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
677 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
678 private static class RenameCollector implements HgFileRenameHandlerMixin { |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
679 public boolean copyReported = false; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
680 public List<Pair<HgFileRevision, HgFileRevision>> renames = new LinkedList<Pair<HgFileRevision,HgFileRevision>>(); |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
681 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
682 public RenameCollector() { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
683 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
684 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
685 public RenameCollector(AdapterPlug ap) { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
686 ap.attachAdapter(HgFileRenameHandlerMixin.class, this); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
687 } |
528
f7fbf48b9383
Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
522
diff
changeset
|
688 |
518
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
689 public void copy(HgFileRevision from, HgFileRevision to) { |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
690 copyReported = true; |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
691 renames.add(new Pair<HgFileRevision, HgFileRevision>(from, to)); |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
692 } |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
693 } |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
694 } |