Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/TestHistory.java @ 656:a937e63b6e02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Performance: rebuild information about branches takes too long (my improvement: 3 times, 11-15 s to less than 4 sec)
author Artem Tikhomirov <tikhomirov.artem@gmail.com>
date Thu, 04 Jul 2013 18:40:03 +0200
parents 6526d8adbc0f
children 72fc7774b87e
rev   line source
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
1 /*
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 528
diff changeset
2 * Copyright (c) 2011-2013 TMate Software Ltd
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
3 *
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
4 * This program is free software; you can redistribute it and/or modify
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
5 * it under the terms of the GNU General Public License as published by
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
6 * the Free Software Foundation; version 2 of the License.
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
7 *
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
8 * This program is distributed in the hope that it will be useful,
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
11 * GNU General Public License for more details.
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
12 *
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
13 * For information on how to redistribute this software under
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
14 * the terms of a license other than GNU General Public License
102
a3a2e5deb320 Updated contact address to support@hg4j.com
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 101
diff changeset
15 * contact TMate Software at support@hg4j.com
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
16 */
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
17 package org.tmatesoft.hg.test;
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
18
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
19 import static org.hamcrest.CoreMatchers.equalTo;
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
20 import static org.hamcrest.CoreMatchers.is;
514
5dcb4581c8ef Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 510
diff changeset
21 import static org.junit.Assert.assertEquals;
147
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
22 import static org.junit.Assert.assertTrue;
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
23 import static org.tmatesoft.hg.core.HgIterateDirection.NewToOld;
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
24
202
706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 147
diff changeset
25 import java.util.ArrayList;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
26 import java.util.Collections;
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
27 import java.util.Comparator;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
28 import java.util.Iterator;
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
29 import java.util.LinkedList;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
30 import java.util.List;
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
31
518
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
32 import org.junit.Assert;
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
33 import org.junit.Rule;
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
34 import org.junit.Test;
507
a6435c1a42d0 Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 468
diff changeset
35 import org.tmatesoft.hg.core.HgCallbackTargetException;
129
645829962785 core.Cset renamed to HgChangeset; repo.Changeset moved into HgChangelog
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 103
diff changeset
36 import org.tmatesoft.hg.core.HgChangeset;
427
31a89587eb04 FIXMEs: consistent names, throws for commands and their handlers. Use of checked exceptions in hi-level api
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 423
diff changeset
37 import org.tmatesoft.hg.core.HgChangesetHandler;
507
a6435c1a42d0 Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 468
diff changeset
38 import org.tmatesoft.hg.core.HgChangesetTreeHandler;
514
5dcb4581c8ef Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 510
diff changeset
39 import org.tmatesoft.hg.core.HgFileRenameHandlerMixin;
249
4c3b9f679412 Deprecated HgLogCommand.FileRevision gone, top-level HgFileRevision is bright and shiny replacement
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 214
diff changeset
40 import org.tmatesoft.hg.core.HgFileRevision;
528
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
41 import org.tmatesoft.hg.core.HgIterateDirection;
131
aa1629f36482 Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 129
diff changeset
42 import org.tmatesoft.hg.core.HgLogCommand;
aa1629f36482 Renamed .core classes to start with Hg prefix
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 129
diff changeset
43 import org.tmatesoft.hg.core.HgLogCommand.CollectHandler;
507
a6435c1a42d0 Test for HgChangesetTreeHandler - make sure nothing is broken prior to adding --follow support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 468
diff changeset
44 import org.tmatesoft.hg.core.Nodeid;
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
45 import org.tmatesoft.hg.internal.AdapterPlug;
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
46 import org.tmatesoft.hg.repo.HgLookup;
74
6f1b88693d48 Complete refactoring to org.tmatesoft
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 70
diff changeset
47 import org.tmatesoft.hg.repo.HgRepository;
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 528
diff changeset
48 import org.tmatesoft.hg.repo.HgRuntimeException;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
49 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
50 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
51 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
52 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
53 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
54 import org.tmatesoft.hg.util.Path;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
55
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
56
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
57 /**
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
58 *
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
59 * @author Artem Tikhomirov
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
60 * @author TMate Software Ltd.
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
61 */
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
62 public class TestHistory {
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
63
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
64 @Rule
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
65 public ErrorCollectorExt errorCollector = new ErrorCollectorExt();
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
66
147
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
67 private HgRepository repo;
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
68 private final ExecHelper eh;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
69 private LogOutputParser changelogParser;
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
70
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
71 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
72 TestHistory th = new TestHistory();
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
73 th.testCompleteLog();
82
7255c971dd66 Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 74
diff changeset
74 th.testFollowHistory();
103
0b2dcca7de9f ErrorCollector in tests to grab multiple errors
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 102
diff changeset
75 th.errorCollector.verify();
147
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
76 // th.testPerformance();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
77 th.testOriginalTestLogRepo();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
78 th.testUsernames();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
79 th.testBranches();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
80 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
81 th.errorCollector.verify();
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
82 }
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
83
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
84 public TestHistory() throws Exception {
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
85 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
86 // this(new HgLookup().detect("\\temp\\hg\\hello"));
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
87 }
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
88
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
89 private TestHistory(HgRepository hgRepo) {
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
90 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
91 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
92
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
93 }
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
94
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
95 @Test
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
96 public void testCompleteLog() throws Exception {
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
97 changelogParser.reset();
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
98 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
99 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
100 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
101
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
102 r = new HgLogCommand(repo).order(NewToOld).execute();
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
103 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
104 }
7255c971dd66 Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 74
diff changeset
105
101
777ab7034c1b Switch to JUnit for tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 100
diff changeset
106 @Test
82
7255c971dd66 Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 74
diff changeset
107 public void testFollowHistory() throws Exception {
7255c971dd66 Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 74
diff changeset
108 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
109 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
110 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
111 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
112
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
113 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
114 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
115 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
116 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
117 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
118 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
119 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
120 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
121 //
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 // 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
123 // 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
124 // (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
125 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
126 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
127 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
128 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
129 }
4252faa556cd Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 202
diff changeset
130 });
4252faa556cd Use custom timezone identifier to avoid applying daylight savings from the zone guessed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 202
diff changeset
131 report(what, sorted, false);
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
132 }
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
133
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 @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
135 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
136 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
137 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
138 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
139 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
140
508
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
141 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
142 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
143 // 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
144 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
145 }
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
146
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
147 /**
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 * 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
149 * 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
150 * 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
151 * 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
152 * 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
153 */
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 @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
155 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
156 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
157 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
158 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
159 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
160 // 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
161 // 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
162 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
163
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
164 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
165 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
166 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
167 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
168 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
169 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
170 // 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
171 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
172 // 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
173 // 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
174 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
175 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
176 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
177 //
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 // 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
179 h = new CollectWithRenameHandler();
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
180 new HgLogCommand(repo).file(fname2, true, false).order(NewToOld).execute(h);
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
181 // 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
182 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
183 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
184 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
185 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
186 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
187 // 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
188 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
189 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
190 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
191 //
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
192 // TreeChangeHandler - in #testChangesetTreeFollowRenamesNotAncestry
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
193 }
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
194
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
195 @Test
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
196 public void testChangesetTreeFollowRenamesNotAncestry() throws Exception {
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
197 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
198 final String fname1 = "file1_a";
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
199 final String fname2 = "file1_b";
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
200 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
201 // 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
202 // 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
203 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
204
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
205 TreeCollectHandler h = new TreeCollectHandler(true);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
206 RenameCollector rh = new RenameCollector(h);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
207 // 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
208 // 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
209 // and followAncestry is false
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
210 // h.checkPrevInParents = true;
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
211 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
212 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
213 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
214 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
215 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
216 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
217
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
218 // Direction
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
219 h = new TreeCollectHandler(false);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
220 rh = new RenameCollector(h);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
221 // h.checkPrevInChildren = true; see above
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
222 new HgLogCommand(repo).file(fname2, true, false).order(NewToOld).execute(h);
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
223 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
224 rename = rh.renames.get(0);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
225 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
226 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
227 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
228 }
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
229
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 @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
231 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
232 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
233 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
234 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
235 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
236
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
237 CollectWithRenameHandler h = new CollectWithRenameHandler();
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
238 new HgLogCommand(repo).file(fname2, false, true).execute(h);
528
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
239 // renames are reported regardless of followRenames parameter, but
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
240 // solely based on HgFileRenameHandlerMixin
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
241 errorCollector.assertEquals(1, h.rh.renames.size());
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
242 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
243 //
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
244 // Direction
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
245 h = new CollectWithRenameHandler();
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
246 new HgLogCommand(repo).file(fname2, false, true).order(NewToOld).execute(h);
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
247 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
248 //
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
249 // TreeChangeHandler - in #testChangesetTreeFollowAncestryNotRenames
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
250 }
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
251
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
252 @Test
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
253 public void testChangesetTreeFollowAncestryNotRenames() throws Exception {
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
254 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
255 final String fname2 = "file1_b";
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
256 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
257
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
258 TreeCollectHandler h = new TreeCollectHandler(false);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
259 h.checkPrevInParents = true;
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
260 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
261 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
262
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
263 // Direction
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
264 h = new TreeCollectHandler(false);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
265 h.checkPrevInChildren = true;
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
266 new HgLogCommand(repo).file(fname2, false, true).order(NewToOld).execute(h);
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
267 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
268 }
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
269
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
270
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
271 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
272 // 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
273 // 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
274 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
275 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
276 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
277 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
278 // 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
279 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
280 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
281 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
282 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
283 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
284 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
285 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
286 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
287 }
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
288 }
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 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
290 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
291 }
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 }
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
293 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
294 }
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
295
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
296 /**
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 * 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
298 */
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 @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
300 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
301 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
302 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
303 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
304 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
305 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
306
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
307 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
308 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
309 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
310 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
311 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
312 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
313 // 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
314 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
315 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
316 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
317 // 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
318 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
319 //
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 // 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
321 h = new CollectWithRenameHandler();
522
2103388d4010 Expose option to report changesets in reversed order
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 521
diff changeset
322 new HgLogCommand(repo).file(fname2, true, true).order(NewToOld).execute(h);
520
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
323 // 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
324 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
325 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
326 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
327 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
328 // 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
329 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
330 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
331 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
332 //
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
333 // 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
334 }
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
335
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
336 @Test
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
337 public void testChangesetTreeFollowRenameAndAncestry() throws Exception {
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
338 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
339 final String fname = "file1_b";
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
340 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
341 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
342
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
343 TreeCollectHandler h = new TreeCollectHandler(true);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
344 RenameCollector rh = new RenameCollector(h);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
345 h.checkPrevInParents = true;
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
346 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
347
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
348 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
349
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
350 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
351
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
352 assertEquals(1, rh.renames.size());
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
353 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
354 }
528
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
355
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
356 /**
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
357 * Ensure {@link HgFileRenameHandlerMixin} is always notified, even
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
358 * if followRename is false.
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
359 * Shall check:
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
360 * both {@link HgLogCommand#execute(HgChangesetHandler)} and {@link HgLogCommand#execute(HgChangesetTreeHandler)}
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
361 * and for both iteration directions in each case
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
362 */
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
363 @Test
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
364 public void testRenameHandlerNotifiedEvenIfNotFollowRename() throws Exception {
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
365 repo = Configuration.get().find("log-follow");
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
366 final String fname1 = "file1_a";
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
367 final String fname2 = "file1_b";
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
368 final String fnameNoRename = "file2";
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
369 assertTrue("[sanity]", repo.getFileNode(fnameNoRename).exists());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
370
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
371 // first, check that file without renames doesn't report any accidentally
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
372 CollectWithRenameHandler h1 = new CollectWithRenameHandler();
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
373 HgLogCommand cmd = new HgLogCommand(repo).file(fnameNoRename, false, false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
374 cmd.execute(h1);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
375 errorCollector.assertEquals(0, h1.rh.renames.size());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
376 TreeCollectHandler h2 = new TreeCollectHandler(false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
377 RenameCollector rh = new RenameCollector(h2);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
378 cmd.execute(h2);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
379 errorCollector.assertEquals(0, rh.renames.size());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
380
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
381 // check default iterate direction
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
382 cmd = new HgLogCommand(repo).file(fname2, false, false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
383 cmd.execute(h1 = new CollectWithRenameHandler());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
384 errorCollector.assertEquals(1, h1.rh.renames.size());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
385 assertRename(fname1, fname2, h1.rh.renames.get(0));
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
386
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
387 h2 = new TreeCollectHandler(false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
388 rh = new RenameCollector(h2);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
389 cmd.execute(h2);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
390 errorCollector.assertEquals(1, rh.renames.size());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
391 assertRename(fname1, fname2, rh.renames.get(0));
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
392
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
393 eh.run("hg", "log", "--debug", fname2, "--cwd", repo.getLocation());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
394 report("HgChangesetHandler+RenameHandler with followRenames = false, default iteration order", h1.getChanges(), true);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
395 report("HgChangesetTreeHandler+RenameHandler with followRenames = false, default iteration order", h2.getResult(), true);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
396
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
397 //
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
398 // Now, check that iteration in opposite direction (new to old)
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
399 // still reports renames (and correct revisions, too)
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
400 cmd.order(HgIterateDirection.NewToOld);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
401 cmd.execute(h1 = new CollectWithRenameHandler());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
402 errorCollector.assertEquals(1, h1.rh.renames.size());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
403 assertRename(fname1, fname2, h1.rh.renames.get(0));
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
404 h2 = new TreeCollectHandler(false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
405 rh = new RenameCollector(h2);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
406 cmd.execute(h2);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
407 errorCollector.assertEquals(1, rh.renames.size());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
408 assertRename(fname1, fname2, rh.renames.get(0));
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
409 report("HgChangesetHandler+RenameHandler with followRenames = false, new2old iteration order", h1.getChanges(), false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
410 report("HgChangesetTreeHandler+RenameHandler with followRenames = false, new2old iteration order", h2.getResult(), false);
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
411 }
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
412
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
413 private void assertRename(String fnameFrom, String fnameTo, Pair<HgFileRevision, HgFileRevision> rename) {
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
414 errorCollector.assertEquals(fnameFrom, rename.first().getPath().toString());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
415 errorCollector.assertEquals(fnameTo, rename.second().getPath().toString());
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
416 }
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
417
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
418 /**
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
419 * @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
420 */
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
421 @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
422 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
423 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
424 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
425 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
426 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
427 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
428 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
429 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
430 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
431 };
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
432 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
433 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
434 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
435 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
436 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
437 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
438 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
439 };
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
440 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
441 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
442 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
443 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
444 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
445 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
446 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
447 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
448 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
449 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
450 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
451
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
452 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
453 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
454 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
455 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
456 } 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
457 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
458 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
459 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
460 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
461 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
462 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
463 } 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
464 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
465 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
466 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
467 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
468 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
469 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
470 } 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
471 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
472 }
1ee452f31187 Experimental support for inverse direction history walking. Refactored/streamlined cancellation in HgLogCommand and down the stack
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 518
diff changeset
473 }
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
474
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
475 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
476 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
477 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
478 }
706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 147
diff changeset
479
706bcc7cfee4 Basic test for HgIncomingCommand. Fix RepositoryComparator for cases when whole repository is unknown. Respect freshly initialized (empty) repositories in general.
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 147
diff changeset
480 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
481 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
482 if (reverseConsoleResult) {
82
7255c971dd66 Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 74
diff changeset
483 Collections.reverse(consoleResult);
7255c971dd66 Promitive test for follow file history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 74
diff changeset
484 }
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
485 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
486 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
487 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
488 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
489 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
490 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
491 }
147
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
492 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
493 // 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
494 // 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
495 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
496 x |= cs.getDate().toString().equals(cr.date) ? 0x2 : 0;
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
497 x |= cs.getNodeid().toString().equals(cr.changesetNodeid) ? 0x4 : 0;
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
498 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
499 // 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
500 // 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
501 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
502 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
503 consoleResultItr.remove();
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
504 }
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
505 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
506 }
100
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
507
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
508 public void testPerformance() throws Exception {
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
509 final int runs = 10;
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
510 final long start1 = System.currentTimeMillis();
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
511 for (int i = 0; i < runs; i++) {
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
512 changelogParser.reset();
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
513 eh.run("hg", "log", "--debug");
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
514 }
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
515 final long start2 = System.currentTimeMillis();
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
516 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
517 new HgLogCommand(repo).execute();
100
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
518 }
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
519 final long end = System.currentTimeMillis();
b71b3f7d24d4 Primitive performance test
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 95
diff changeset
520 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
521 }
147
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
522
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
523 @Test
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
524 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
525 // 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
526 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
527 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
528 // 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
529 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
530 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
531 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
532 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
533 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
534 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
535 // 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
536 // 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
537 // 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
538 // 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
539 // 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
540 // 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
541
147
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
542 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
543 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
544 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
545 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
546 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
547 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
548 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
549 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
550 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
551 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
552 //
ad0322a4af20 Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 427
diff changeset
553 // 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
554 // 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
555 // 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
556 // 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
557 /*
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
558 * #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
559 * 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
560 * order of revisions.
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
561 */
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
562
ad0322a4af20 Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 427
diff changeset
563 // 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
564 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
565 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
566 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
567 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
568 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
569 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
570 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
571 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
572 //
ad0322a4af20 Update tests not to fail with Mercurial 2.2 changes, run tests with gradle
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 427
diff changeset
573 // 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
574 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
575 }
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
576
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
577 @Test
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
578 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
579 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
580 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
581 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
582 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
583 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
584 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
585 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
586 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
587 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
588 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
589 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
590 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
591 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
592 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
593 }
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
594
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
595 @Test
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
596 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
597 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
598 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
599 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
600 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
601 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
602 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
603 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
604 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
605 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
606 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
607 //
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
608 changelogParser.reset();
a05145db4d0c Bring test repos along with us to recreate testbench
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 133
diff changeset
609 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
610 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
611 }
508
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
612
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
613 ////
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
614
514
5dcb4581c8ef Report renames when following file history tree with HgFileRenameHandlerMixin
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 510
diff changeset
615 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
616 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
617 private final boolean reverseResult;
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
618 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
619 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
620
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
621 public TreeCollectHandler(boolean _reverseResult) {
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
622 this.reverseResult = _reverseResult;
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
623 }
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
624
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
625 public List<HgChangeset> getResult() {
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
626 return cmdResult;
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
627 }
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
628
508
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
629
628
6526d8adbc0f Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 528
diff changeset
630 public void treeElement(TreeElement entry) throws HgCallbackTargetException, HgRuntimeException {
508
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
631 // check consistency
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
632 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
633 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
634 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
635 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
636 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
637 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
638 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
639 } else {
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
640 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
641 }
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
642 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
643 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
644 } else {
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
645 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
646 }
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
647 //
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
648 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
649 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
650 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
651 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
652 }
a30e74dca193 Establish parent-child between first and last elements of history chunks for two renamed files
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 508
diff changeset
653 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
654 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
655 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
656 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
657 }
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
658 //
508
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
659 if (reverseResult) {
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
660 cmdResult.addFirst(entry.changeset());
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
661 } else {
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
662 cmdResult.addLast(entry.changeset());
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
663 }
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
664 }
ca5202afea90 Support follow history option when walking file history tree
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 507
diff changeset
665 }
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
666
0d5e1ea7955e Tests for HgLogCommand#execute(HgChangesetHandler) with various combination of follow renames and ancestry
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 517
diff changeset
667 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
668 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
669 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
670
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
671 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
672 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
673 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
674 lastChangesetReportedAtRename.add(lastKnown);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
675 rh.copy(from, to);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
676 }
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
677 };
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
678
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
679 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
680 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
681 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
682
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
683 public RenameCollector() {
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
684 }
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
685
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
686 public RenameCollector(AdapterPlug ap) {
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
687 ap.attachAdapter(HgFileRenameHandlerMixin.class, this);
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
688 }
528
f7fbf48b9383 Report rename when walking file history regardless of followRenames parameter, solely based on HgFileRenameHandlerMixin presence
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 522
diff changeset
689
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
690 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
691 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
692 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
693 }
521
59e555c85da0 Cover ChangesetTreeHandler with various followRename, followAncestry and direction
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents: 520
diff changeset
694 }
70
993f6f8e1314 Test for log command
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff changeset
695 }