Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestHistory.java @ 521:59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Wed, 26 Dec 2012 17:51:07 +0100 |
parents | 1ee452f31187 |
children | 2103388d4010 |
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; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
23 |
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
|
24 import java.util.ArrayList; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
25 import java.util.Collections; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
26 import java.util.Comparator; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
27 import java.util.Iterator; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
28 import java.util.LinkedList; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
29 import java.util.List; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
30 |
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
|
31 import org.junit.Assert; |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
32 import org.junit.Rule; |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
33 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
|
34 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
|
35 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
|
36 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
|
37 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
|
38 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
|
39 import org.tmatesoft.hg.core.HgFileRevision; |
131
aa1629f36482
Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
129
diff
changeset
|
40 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
|
41 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
|
42 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
|
43 import org.tmatesoft.hg.internal.AdapterPlug; |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
44 import org.tmatesoft.hg.repo.HgLookup; |
74
6f1b88693d48
Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
70
diff
changeset
|
45 import org.tmatesoft.hg.repo.HgRepository; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
46 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
|
47 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
|
48 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
|
49 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
|
50 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
|
51 import org.tmatesoft.hg.util.Path; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
52 |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
53 |
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 * @author Artem Tikhomirov |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
57 * @author TMate Software Ltd. |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
58 */ |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 public class TestHistory { |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
61 @Rule |
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
62 public ErrorCollectorExt errorCollector = new ErrorCollectorExt(); |
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
63 |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
64 private HgRepository repo; |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
65 private final ExecHelper eh; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 private LogOutputParser changelogParser; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
67 |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
68 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
|
69 TestHistory th = new TestHistory(); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
70 th.testCompleteLog(); |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
71 th.testFollowHistory(); |
103
0b2dcca7de9f
ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
102
diff
changeset
|
72 th.errorCollector.verify(); |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
73 // th.testPerformance(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
74 th.testOriginalTestLogRepo(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
75 th.testUsernames(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
76 th.testBranches(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
77 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
78 th.errorCollector.verify(); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
79 } |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
80 |
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
81 public TestHistory() throws Exception { |
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
82 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
|
83 // this(new HgLookup().detect("\\temp\\hg\\hello")); |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
84 } |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
85 |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
86 private TestHistory(HgRepository hgRepo) { |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
87 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
|
88 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
|
89 |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
90 } |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
91 |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
92 @Test |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
93 public void testCompleteLog() throws Exception { |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
94 changelogParser.reset(); |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
95 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
|
96 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
|
97 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
|
98 |
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 r = new HgLogCommand(repo).debugSwitch1().execute(); |
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 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
|
101 } |
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
102 |
101
777ab7034c1b
Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
100
diff
changeset
|
103 @Test |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
104 public void testFollowHistory() throws Exception { |
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
105 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
|
106 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
|
107 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
|
108 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
|
109 |
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
|
110 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
|
111 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
|
112 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
|
113 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
|
114 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
|
115 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
|
116 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
|
117 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
|
118 // |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
119 // 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
|
120 // 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
|
121 // (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
|
122 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
|
123 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
|
124 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
|
125 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
|
126 } |
4252faa556cd
Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
202
diff
changeset
|
127 }); |
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 report(what, sorted, false); |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
129 } |
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
|
130 |
a6435c1a42d0
Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
468
diff
changeset
|
131 @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
|
132 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
|
133 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
|
134 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
|
135 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
|
136 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
|
137 |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
138 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
|
139 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
|
140 // 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
|
141 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
|
142 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
143 |
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
|
144 /** |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
145 * 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
|
146 * 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
|
147 * 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
|
148 * 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
|
149 * 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
|
150 */ |
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 @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
|
152 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
|
153 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
|
154 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
|
155 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
|
156 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
|
157 // 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
|
158 // 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
|
159 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
|
160 |
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 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
|
162 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
|
163 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
|
164 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
|
165 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
|
166 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
|
167 // 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
|
168 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
|
169 // 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
|
170 // 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
|
171 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
|
172 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
|
173 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
|
174 // |
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
|
175 // 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
|
176 h = new CollectWithRenameHandler(); |
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 new HgLogCommand(repo).file(fname2, true, false).debugSwitch1().execute(h); |
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 // 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
|
179 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
|
180 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
|
181 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
|
182 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
|
183 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
|
184 // 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
|
185 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
|
186 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
|
187 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
|
188 // |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
189 // TreeChangeHandler - in #testChangesetTreeFollowRenamesNotAncestry |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
190 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
191 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
192 @Test |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
193 public void testChangesetTreeFollowRenamesNotAncestry() throws Exception { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
194 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
|
195 final String fname1 = "file1_a"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
196 final String fname2 = "file1_b"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
197 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
|
198 // 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
|
199 // 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
|
200 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
|
201 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
202 TreeCollectHandler h = new TreeCollectHandler(true); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
203 RenameCollector rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
204 // 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
|
205 // 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
|
206 // and followAncestry is false |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
207 // h.checkPrevInParents = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
208 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
|
209 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
|
210 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
|
211 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
|
212 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
|
213 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
|
214 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
215 // Direction |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
216 h = new TreeCollectHandler(false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
217 rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
218 // h.checkPrevInChildren = true; see above |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
219 new HgLogCommand(repo).file(fname2, true, false).debugSwitch1().execute(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
220 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
|
221 rename = rh.renames.get(0); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
222 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
|
223 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
|
224 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
|
225 } |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
226 |
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 @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
|
228 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
|
229 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
|
230 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
|
231 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
|
232 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
|
233 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
234 CollectWithRenameHandler h = new CollectWithRenameHandler(); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
235 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
|
236 errorCollector.assertEquals(0, h.rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
237 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
|
238 // |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
239 // Direction |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
240 h = new CollectWithRenameHandler(); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
241 new HgLogCommand(repo).file(fname2, false, true).debugSwitch1().execute(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
242 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
|
243 // |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
244 // TreeChangeHandler - in #testChangesetTreeFollowAncestryNotRenames |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
245 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
246 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
247 @Test |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
248 public void testChangesetTreeFollowAncestryNotRenames() throws Exception { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
249 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
|
250 final String fname2 = "file1_b"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
251 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
|
252 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
253 TreeCollectHandler h = new TreeCollectHandler(false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
254 RenameCollector rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
255 h.checkPrevInParents = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
256 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
|
257 errorCollector.assertEquals(0, rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
258 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
|
259 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
260 // Direction |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
261 h = new TreeCollectHandler(false); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
262 rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
263 h.checkPrevInChildren = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
264 new HgLogCommand(repo).file(fname2, false, true).debugSwitch1().execute(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
265 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
|
266 } |
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 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
|
270 // 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
|
271 // 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
|
272 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
|
273 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
|
274 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
|
275 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
|
276 // 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
|
277 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
|
278 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
|
279 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
|
280 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
|
281 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
|
282 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
|
283 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
|
284 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
|
285 } |
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 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
|
288 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
|
289 } |
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 } |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
291 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
|
292 } |
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 * 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
|
296 */ |
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 @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
|
298 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
|
299 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
|
300 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
|
301 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
|
302 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
|
303 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
|
304 |
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 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
|
306 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
|
307 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
|
308 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
|
309 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
|
310 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
|
311 // 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
|
312 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
|
313 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
|
314 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
|
315 // 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
|
316 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
|
317 // |
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 // 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
|
319 h = new CollectWithRenameHandler(); |
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 new HgLogCommand(repo).file(fname2, true, true).debugSwitch1().execute(h); |
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
|
321 // 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
|
322 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
|
323 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
|
324 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
|
325 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
|
326 // 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
|
327 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
|
328 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
|
329 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
|
330 // |
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
|
331 // 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
|
332 } |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
333 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
334 @Test |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
335 public void testChangesetTreeFollowRenameAndAncestry() throws Exception { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
336 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
|
337 final String fname = "file1_b"; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
338 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
|
339 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
|
340 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
341 TreeCollectHandler h = new TreeCollectHandler(true); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
342 RenameCollector rh = new RenameCollector(h); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
343 h.checkPrevInParents = true; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
344 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
|
345 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
346 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
|
347 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
348 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
|
349 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
350 assertEquals(1, rh.renames.size()); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
351 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
|
352 } |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
353 |
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
|
354 /** |
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
|
355 * @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
|
356 */ |
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
|
357 @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
|
358 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
|
359 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
|
360 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
|
361 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
|
362 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
|
363 } |
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
|
364 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
|
365 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
|
366 } |
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
|
367 }; |
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
|
368 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
|
369 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
|
370 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
|
371 } |
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
|
372 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
|
373 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
|
374 } |
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
|
375 }; |
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
|
376 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
|
377 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
|
378 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
|
379 } |
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
|
380 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
|
381 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
|
382 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
|
383 } |
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
|
384 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
|
385 } |
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
|
386 } |
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
|
387 |
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
|
388 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
|
389 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
|
390 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
|
391 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
|
392 } 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
|
393 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
|
394 } |
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
|
395 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
|
396 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
|
397 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
|
398 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
|
399 } 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
|
400 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
|
401 } |
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
|
402 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
|
403 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
|
404 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
|
405 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
|
406 } 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
|
407 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
|
408 } |
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
|
409 } |
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
|
410 |
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
|
411 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
|
412 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
|
413 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
|
414 } |
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
|
415 |
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
|
416 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
|
417 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
|
418 if (reverseConsoleResult) { |
82
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
419 Collections.reverse(consoleResult); |
7255c971dd66
Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
74
diff
changeset
|
420 } |
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
|
421 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
|
422 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
|
423 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
|
424 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
|
425 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
|
426 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
|
427 } |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
428 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
|
429 // 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
|
430 // 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
|
431 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
|
432 x |= cs.getDate().toString().equals(cr.date) ? 0x2 : 0; |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
433 x |= cs.getNodeid().toString().equals(cr.changesetNodeid) ? 0x4 : 0; |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
434 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
|
435 // 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
|
436 // 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
|
437 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
|
438 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
|
439 consoleResultItr.remove(); |
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
440 } |
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
|
441 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
|
442 } |
100
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
443 |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
444 public void testPerformance() throws Exception { |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
445 final int runs = 10; |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
446 final long start1 = System.currentTimeMillis(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
447 for (int i = 0; i < runs; i++) { |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
448 changelogParser.reset(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
449 eh.run("hg", "log", "--debug"); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
450 } |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
451 final long start2 = System.currentTimeMillis(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
452 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
|
453 new HgLogCommand(repo).execute(); |
100
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
454 } |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
455 final long end = System.currentTimeMillis(); |
b71b3f7d24d4
Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
95
diff
changeset
|
456 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
|
457 } |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
458 |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
459 @Test |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
460 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
|
461 // 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
|
462 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
|
463 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
|
464 // 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
|
465 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
466 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
467 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
|
468 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
|
469 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
470 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
|
471 // 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
|
472 // 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
|
473 // 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
|
474 // 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
|
475 // 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
|
476 // 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
|
477 |
147
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
478 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
479 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
480 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
|
481 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
|
482 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
483 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
484 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
|
485 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
|
486 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
487 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
|
488 // |
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
|
489 // 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
|
490 // 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
|
491 // 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
|
492 // 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
|
493 /* |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
494 * #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
|
495 * 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
|
496 * order of revisions. |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
497 */ |
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
|
498 |
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
|
499 // 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
|
500 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
|
501 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
|
502 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
|
503 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
|
504 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
|
505 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
|
506 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
|
507 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
|
508 // |
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
|
509 // 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
|
510 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
|
511 } |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
512 |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
513 @Test |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
514 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
|
515 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
|
516 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
|
517 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
518 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
519 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
|
520 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
|
521 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
522 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
523 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
|
524 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
|
525 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
526 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
527 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
|
528 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
|
529 } |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
530 |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
531 @Test |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
532 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
|
533 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
|
534 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
535 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
|
536 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
|
537 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
538 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
539 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
|
540 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
|
541 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
542 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
|
543 // |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
544 changelogParser.reset(); |
a05145db4d0c
Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
133
diff
changeset
|
545 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
|
546 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
|
547 } |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
548 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
549 //// |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
550 |
514
5dcb4581c8ef
Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
510
diff
changeset
|
551 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
|
552 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
|
553 private final boolean reverseResult; |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
554 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
|
555 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
|
556 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
557 public TreeCollectHandler(boolean _reverseResult) { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
558 this.reverseResult = _reverseResult; |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
559 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
560 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
561 public List<HgChangeset> getResult() { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
562 return cmdResult; |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
563 } |
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
|
564 |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
565 |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
566 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
|
567 // check consistency |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
568 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
|
569 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
|
570 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
|
571 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
|
572 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
|
573 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
|
574 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
|
575 } else { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
576 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
|
577 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
578 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
|
579 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
|
580 } else { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
581 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
|
582 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
583 // |
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
|
584 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
|
585 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
|
586 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
|
587 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
|
588 } |
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
|
589 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
|
590 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
|
591 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
|
592 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
|
593 } |
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
|
594 // |
508
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
595 if (reverseResult) { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
596 cmdResult.addFirst(entry.changeset()); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
597 } else { |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
598 cmdResult.addLast(entry.changeset()); |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
599 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
600 } |
ca5202afea90
Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
507
diff
changeset
|
601 } |
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
|
602 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
603 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
|
604 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
|
605 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
|
606 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
607 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
|
608 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
|
609 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
|
610 lastChangesetReportedAtRename.add(lastKnown); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
611 rh.copy(from, to); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
612 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
613 }; |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
614 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
615 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
|
616 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
|
617 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
|
618 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
619 public RenameCollector() { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
620 } |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
621 |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
622 public RenameCollector(AdapterPlug ap) { |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
623 ap.attachAdapter(HgFileRenameHandlerMixin.class, this); |
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
624 } |
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
|
625 |
0d5e1ea7955e
Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
517
diff
changeset
|
626 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
|
627 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
|
628 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
|
629 } |
521
59e555c85da0
Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
520
diff
changeset
|
630 } |
70
993f6f8e1314
Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
631 } |