Mercurial > hg4j

annotate test/org/tmatesoft/hg/test/TestHistory.java @ 599:55b7987c1796

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