Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestBlame.java @ 629:5f52074707b2
Diff/blame methods as command, their residence in HgDataFile was a mistake
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Wed, 22 May 2013 16:46:15 +0200 |
parents | 6526d8adbc0f |
children | 72c979555cb8 |
rev | line source |
---|---|
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
2 * Copyright (c) 2013 TMate Software Ltd |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.test; |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
19 import static org.junit.Assert.assertEquals; |
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
20 import static org.junit.Assert.assertTrue; |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
21 import static org.tmatesoft.hg.core.HgIterateDirection.NewToOld; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
22 import static org.tmatesoft.hg.core.HgIterateDirection.OldToNew; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
23 import static org.tmatesoft.hg.repo.HgRepository.NO_REVISION; |
548
ab21ac7dd833
Line-by-line annotation API and support code in place
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
546
diff
changeset
|
24 import static org.tmatesoft.hg.repo.HgRepository.TIP; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
25 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
26 import java.io.ByteArrayOutputStream; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
27 import java.io.File; |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
28 import java.io.IOException; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
29 import java.io.OutputStream; |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
30 import java.io.PrintStream; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
31 import java.util.ArrayList; |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
32 import java.util.Arrays; |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
33 import java.util.LinkedHashSet; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
34 import java.util.LinkedList; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
35 import java.util.List; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
36 import java.util.ListIterator; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
37 import java.util.regex.Matcher; |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
38 import java.util.regex.Pattern; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
39 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
40 import org.junit.Assert; |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
41 import org.junit.Rule; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
42 import org.junit.Test; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
43 import org.tmatesoft.hg.core.HgAnnotateCommand; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
44 import org.tmatesoft.hg.core.HgAnnotateCommand.LineInfo; |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
45 import org.tmatesoft.hg.core.HgCallbackTargetException; |
552
45751456b471
Annotate file changes through few revisions, walking either direction (old to new and vice versa)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
549
diff
changeset
|
46 import org.tmatesoft.hg.core.HgIterateDirection; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
47 import org.tmatesoft.hg.core.HgRepoFacade; |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
48 import org.tmatesoft.hg.core.Nodeid; |
555
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
49 import org.tmatesoft.hg.internal.FileAnnotation; |
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
50 import org.tmatesoft.hg.internal.FileAnnotation.LineDescriptor; |
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
51 import org.tmatesoft.hg.internal.FileAnnotation.LineInspector; |
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
52 import org.tmatesoft.hg.internal.IntVector; |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
53 import org.tmatesoft.hg.repo.HgBlameInspector; |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
54 import org.tmatesoft.hg.repo.HgChangelog; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
55 import org.tmatesoft.hg.repo.HgDataFile; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
56 import org.tmatesoft.hg.repo.HgLookup; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
57 import org.tmatesoft.hg.repo.HgRepository; |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
58 import org.tmatesoft.hg.util.Path; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 /** |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
61 * |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
62 * @author Artem Tikhomirov |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
63 * @author TMate Software Ltd. |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
64 */ |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
65 public class TestBlame { |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
66 |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
67 @Rule |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
68 public ErrorCollectorExt errorCollector = new ErrorCollectorExt(); |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
69 |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
70 |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
71 @Test |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
72 public void testSingleParentBlame() throws Exception { |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
73 HgRepository repo = new HgLookup().detectFromWorkingDir(); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
74 final String fname = "src/org/tmatesoft/hg/internal/PatchGenerator.java"; |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
75 final int checkChangeset = repo.getChangelog().getRevisionIndex(Nodeid.fromAscii("946b131962521f9199e1fedbdc2487d3aaef5e46")); // 539 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
76 HgDataFile df = repo.getFileNode(fname); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
77 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
78 df.annotateSingleRevision(checkChangeset, new DiffOutInspector(new PrintStream(bos))); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
79 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
80 ExecHelper eh = new ExecHelper(gp, null); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
81 eh.run("hg", "diff", "-c", String.valueOf(checkChangeset), "-U", "0", fname); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
82 // |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
83 String[] apiResult = splitLines(bos.toString()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
84 String[] expected = splitLines(gp.result()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
85 Assert.assertArrayEquals(expected, apiResult); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
86 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
87 |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
88 @Test |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
89 public void testFileLineAnnotate1() throws Exception { |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
90 HgRepository repo = new HgLookup().detectFromWorkingDir(); |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
91 final String fname = "src/org/tmatesoft/hg/internal/PatchGenerator.java"; |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
92 HgDataFile df = repo.getFileNode(fname); |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
93 AnnotateRunner ar = new AnnotateRunner(df.getPath(), null); |
548
ab21ac7dd833
Line-by-line annotation API and support code in place
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
546
diff
changeset
|
94 |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
95 final HgChangelog clog = repo.getChangelog(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
96 final int[] toTest = new int[] { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
97 clog.getRevisionIndex(Nodeid.fromAscii("946b131962521f9199e1fedbdc2487d3aaef5e46")), // 539 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
98 clog.getRevisionIndex(Nodeid.fromAscii("1e95f48d9886abe79b9711ab371bc877ca5e773e")), // 541 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
99 /*, TIP */}; |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
100 for (int cs : toTest) { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
101 ar.run(cs, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
102 FileAnnotateInspector fa = new FileAnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
103 FileAnnotation.annotate(df, cs, fa); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
104 doAnnotateLineCheck(cs, ar.getLines(), Arrays.asList(fa.lineRevisions), Arrays.asList(fa.lines)); |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
105 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
106 } |
548
ab21ac7dd833
Line-by-line annotation API and support code in place
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
546
diff
changeset
|
107 |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
108 @Test |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
109 public void testFileLineAnnotate2() throws Exception { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
110 HgRepository repo = Configuration.get().find("test-annotate"); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
111 HgDataFile df = repo.getFileNode("file1"); |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
112 AnnotateRunner ar = new AnnotateRunner(df.getPath(), repo.getWorkingDir()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
113 |
558
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
114 for (int cs : new int[] { 4, 6 /*, 8 see below*/, TIP}) { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
115 ar.run(cs, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
116 FileAnnotateInspector fa = new FileAnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
117 FileAnnotation.annotate(df, cs, fa); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
118 doAnnotateLineCheck(cs, ar.getLines(), Arrays.asList(fa.lineRevisions), Arrays.asList(fa.lines)); |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
119 } |
558
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
120 /*`hg annotate -r 8` and HgBlameFacility give different result |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
121 * for "r0, line 5" line, which was deleted in rev2 and restored back in |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
122 * rev4 (both in default branch), while branch with r3 and r6 kept the line intact. |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
123 * HgBlame reports rev4 for the line, `hg annotate` gives original, rev0. |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
124 * However `hg annotate -r 4` shows rev4 for the line, too. The aforementioned rev0 for |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
125 * the merge rev8 results from the iteration order and is implementation specific |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
126 * (i.e. one can't tell which one is right). Mercurial walks from parents to children, |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
127 * and traces equal lines, wile HgBlameFacility walks from child to parents and records |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
128 * changes (additions). Seems it processes branch with rev3 and rev6 first |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
129 * (printout in context.py, annotate and annotate.pair reveals that), and the line 0_5 |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
130 * comes as unchanged through this branch, and later processing rev2 and rev4 doesn't |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
131 * change that. |
154718ae23ed
Annotate: refactor/reuse range handling code
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
557
diff
changeset
|
132 */ |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
133 } |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
134 |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
135 @Test |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
136 public void testComplexHistoryAnnotate() throws Exception { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
137 HgRepository repo = Configuration.get().find("test-annotate"); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
138 HgDataFile df = repo.getFileNode("file1"); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
139 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
140 DiffOutInspector dump = new DiffOutInspector(new PrintStream(bos)); |
629
5f52074707b2
Diff/blame methods as command, their residence in HgDataFile was a mistake
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
141 df.annotate(0, TIP, dump, HgIterateDirection.OldToNew); |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
142 LinkedList<String> apiResult = new LinkedList<String>(Arrays.asList(splitLines(bos.toString()))); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
143 |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
144 /* |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
145 * FIXME this is an ugly hack to deal with the way `hg diff -c <mergeRev>` describes the change |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
146 * and our merge handling approach. For merged revision m, and lines changed both in p1 and p2 |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
147 * we report lines from p2 as pure additions, regardless of intersecting p1 changes (which |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
148 * are reported as deletions, if no sufficient changed lines in m found) |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
149 * So, here we try to combine deletion that follows a change (based on identical insertionPoint) |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
150 * into a single change |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
151 * To fix, need to find better approach to find out reference info (i.e. `hg diff -c` is flawed in this case, |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
152 * as it uses first parent only). |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
153 */ |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
154 Pattern fix = Pattern.compile("@@ -(\\d+),(\\d+) \\+(\\d+),(\\d+) @@"); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
155 int v1, v2, v3, v4; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
156 v1 = v2 = v3 = v4 = -1; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
157 for (ListIterator<String> it = apiResult.listIterator(); it.hasNext();) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
158 String n = it.next(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
159 Matcher m = fix.matcher(n); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
160 if (m.find()) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
161 int d1 = Integer.parseInt(m.group(1)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
162 int d2 = Integer.parseInt(m.group(2)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
163 int d3 = Integer.parseInt(m.group(3)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
164 int d4 = Integer.parseInt(m.group(4)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
165 if (v1 == d1 && d4 == 0) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
166 it.previous(); // shift to current element |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
167 it.previous(); // to real previous |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
168 it.remove(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
169 it.next(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
170 it.set(String.format("@@ -%d,%d +%d,%d @@", v1, v2+d2, v3, v4)); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
171 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
172 v1 = d1; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
173 v2 = d2; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
174 v3 = d3; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
175 v4 = d4; |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
176 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
177 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
178 |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
179 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
180 ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
181 for (int cs : dump.getReportedTargetRevisions()) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
182 gp.reset(); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
183 eh.run("hg", "diff", "-c", String.valueOf(cs), "-U", "0", df.getPath().toString()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
184 for (String expected : splitLines(gp.result())) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
185 if (!apiResult.remove(expected)) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
186 errorCollector.fail(String.format("Expected diff output '%s' for changes in revision %d", expected, cs)); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
187 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
188 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
189 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
190 errorCollector.assertTrue(String.format("Annotate API reported excessive diff: %s ", apiResult.toString()), apiResult.isEmpty()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
191 } |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
192 |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
193 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
194 @Test |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
195 public void testPartialHistoryFollow() throws Exception { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
196 HgRepository repo = Configuration.get().find("test-annotate2"); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
197 HgDataFile df = repo.getFileNode("file1b.txt"); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
198 // rev3: file1 -> file1a, rev7: file1a -> file1b, tip: rev10 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
199 DiffOutInspector insp = new DiffOutInspector(new PrintStream(new OutputStream() { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
200 @Override |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
201 public void write(int b) throws IOException { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
202 // NULL OutputStream |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
203 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
204 })); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
205 // rev6 changes rev4, rev4 changes rev3. Plus, anything changed |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
206 // earlier than rev2 shall be reported as new from change3 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
207 int[] change_2_8_new2old = new int[] {4, 6, 3, 4, -1, 3}; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
208 int[] change_2_8_old2new = new int[] {-1, 3, 3, 4, 4, 6 }; |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
209 df.annotate(2, 8, insp, NewToOld); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
210 Assert.assertArrayEquals(change_2_8_new2old, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
211 insp.reset(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
212 df.annotate(2, 8, insp, OldToNew); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
213 Assert.assertArrayEquals(change_2_8_old2new, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
214 // same as 2 to 8, with addition of rev9 changes rev7 (rev6 to rev7 didn't change content, only name) |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
215 int[] change_3_9_new2old = new int[] {7, 9, 4, 6, 3, 4, -1, 3 }; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
216 int[] change_3_9_old2new = new int[] {-1, 3, 3, 4, 4, 6, 7, 9 }; |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
217 insp.reset(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
218 df.annotate(3, 9, insp, NewToOld); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
219 Assert.assertArrayEquals(change_3_9_new2old, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
220 insp.reset(); |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
221 df.annotate(3, 9, insp, OldToNew); |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
222 Assert.assertArrayEquals(change_3_9_old2new, insp.getReportedRevisionPairs()); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
223 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
224 |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
225 @Test |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
226 public void testAnnotateCmdFollowNoFollow() throws Exception { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
227 HgRepoFacade hgRepoFacade = new HgRepoFacade(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
228 HgRepository repo = Configuration.get().find("test-annotate2"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
229 hgRepoFacade.init(repo); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
230 HgAnnotateCommand cmd = hgRepoFacade.createAnnotateCommand(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
231 final Path fname = Path.create("file1b.txt"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
232 final int changeset = TIP; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
233 AnnotateInspector ai = new AnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
234 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
235 cmd.changeset(changeset); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
236 // follow |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
237 cmd.file(fname); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
238 cmd.execute(ai); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
239 AnnotateRunner ar = new AnnotateRunner(fname, repo.getWorkingDir()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
240 ar.run(changeset, true); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
241 doAnnotateLineCheck(changeset, ar.getLines(), ai.changesets, ai.lines); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
242 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
243 // no follow |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
244 cmd.file(fname, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
245 ai = new AnnotateInspector(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
246 cmd.execute(ai); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
247 ar.run(changeset, false); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
248 doAnnotateLineCheck(changeset, ar.getLines(), ai.changesets, ai.lines); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
249 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
250 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
251 private void doAnnotateLineCheck(int cs, String[] hgAnnotateLines, List<Integer> cmdChangesets, List<String> cmdLines) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
252 assertTrue("[sanity]", hgAnnotateLines.length > 0); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
253 assertEquals("Number of lines reported by native annotate and our impl", hgAnnotateLines.length, cmdLines.size()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
254 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
255 for (int i = 0; i < cmdChangesets.size(); i++) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
256 int hgAnnotateRevIndex = Integer.parseInt(hgAnnotateLines[i].substring(0, hgAnnotateLines[i].indexOf(':')).trim()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
257 errorCollector.assertEquals(String.format("Revision mismatch for line %d (annotating rev: %d)", i+1, cs), hgAnnotateRevIndex, cmdChangesets.get(i)); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
258 String hgAnnotateLine = hgAnnotateLines[i].substring(hgAnnotateLines[i].indexOf(':') + 1); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
259 String apiLine = cmdLines.get(i).trim(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
260 errorCollector.assertEquals(hgAnnotateLine.trim(), apiLine); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
261 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
262 } |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
263 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
264 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
265 @Test |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
266 public void testDiffTwoRevisions() throws Exception { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
267 HgRepository repo = Configuration.get().find("test-annotate"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
268 HgDataFile df = repo.getFileNode("file1"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
269 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
270 ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
271 int[] toTest = { 3, 4, 5 }; // p1 ancestry line, p2 ancestry line, not in ancestry line |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
272 for (int cs : toTest) { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
273 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
274 df.diff(cs, 8, new DiffOutInspector(new PrintStream(bos))); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
275 eh.run("hg", "diff", "-r", String.valueOf(cs), "-r", "8", "-U", "0", df.getPath().toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
276 // |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
277 String[] apiResult = splitLines(bos.toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
278 String[] expected = splitLines(gp.result()); |
628
6526d8adbc0f
Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
625
diff
changeset
|
279 Assert.assertArrayEquals("diff -r " + cs + " - r 8", expected, apiResult); |
625
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
280 gp.reset(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
281 } |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
282 } |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
283 |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
284 /** |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
285 * Make sure boundary values are ok (down to BlameHelper#prepare and FileHistory) |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
286 */ |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
287 @Test |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
288 public void testAnnotateFirstFileRev() throws Exception { |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
289 HgRepository repo = Configuration.get().find("test-annotate"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
290 HgDataFile df = repo.getFileNode("file1"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
291 LineGrepOutputParser gp = new LineGrepOutputParser("^@@.+"); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
292 ExecHelper eh = new ExecHelper(gp, repo.getWorkingDir()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
293 eh.run("hg", "diff", "-c", "0", "-U", "0", df.getPath().toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
294 // |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
295 ByteArrayOutputStream bos = new ByteArrayOutputStream(); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
296 df.annotateSingleRevision(0, new DiffOutInspector(new PrintStream(bos))); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
297 // |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
298 String[] apiResult = splitLines(bos.toString()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
299 String[] expected = splitLines(gp.result()); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
300 Assert.assertArrayEquals(expected, apiResult); |
b4948b159ab1
Refactor internals of blame support, tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
301 } |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
302 |
624
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
603
diff
changeset
|
303 // TODO HgWorkingCopyStatusCollector (and HgStatusCollector), with their ancestors (rev 59/69) have examples |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
304 // of *incorrect* assignment of common lines (like "}") - our impl doesn't process common lines in any special way |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
305 // while original diff lib does. Would be nice to behave as close to original, as possible. |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
306 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
307 private static String[] splitLines(CharSequence seq) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
308 int lineCount = 0; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
309 for (int i = 0, x = seq.length(); i < x; i++) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
310 if (seq.charAt(i) == '\n') { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
311 lineCount++; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
312 } |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
313 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
314 if (seq.length() > 0 && seq.charAt(seq.length()-1) != '\n') { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
315 lineCount++; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
316 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
317 String[] rv = new String[lineCount]; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
318 int lineStart = 0, lineEnd = 0, ix = 0; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
319 do { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
320 while (lineEnd < seq.length() && seq.charAt(lineEnd) != '\n') lineEnd++; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
321 if (lineEnd == lineStart) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
322 continue; |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
323 } |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
324 CharSequence line = seq.subSequence(lineStart, lineEnd); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
325 rv[ix++] = line.toString(); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
326 lineStart = ++lineEnd; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
327 } while (lineStart < seq.length()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
328 assert ix == lineCount; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
329 return rv; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
330 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
331 |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
332 |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
333 private void ccc() throws Throwable { |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
334 HgRepository repo = new HgLookup().detect("/home/artem/hg/hgtest-annotate-merge/"); |
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
335 HgDataFile df = repo.getFileNode("file.txt"); |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
336 DiffOutInspector dump = new DiffOutInspector(System.out); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
337 dump.needRevisions(true); |
629
5f52074707b2
Diff/blame methods as command, their residence in HgDataFile was a mistake
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
338 df.annotate(0, 8, dump, HgIterateDirection.NewToOld); |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
339 // af.annotateSingleRevision(df, 113, dump); |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
340 // System.out.println(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
341 // af.annotate(df, TIP, new LineDumpInspector(true), HgIterateDirection.NewToOld); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
342 // System.out.println(); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
343 // af.annotate(df, TIP, new LineDumpInspector(false), HgIterateDirection.NewToOld); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
344 // System.out.println(); |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
345 /* |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
346 OutputParser.Stub op = new OutputParser.Stub(); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
347 eh = new ExecHelper(op, repo.getWorkingDir()); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
348 for (int cs : new int[] { 24, 46, 49, 52, 59, 62, 64, TIP}) { |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
349 doLineAnnotateTest(df, cs, op); |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
350 } |
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
351 errorCollector.verify(); |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
352 */ |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
353 FileAnnotateInspector fa = new FileAnnotateInspector(); |
562
6fbca6506bb5
Allow HgBlameFacility.Inspector (former BlockInspector) to throw an exception
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
561
diff
changeset
|
354 FileAnnotation.annotate(df, 8, fa); |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
355 for (int i = 0; i < fa.lineRevisions.length; i++) { |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
356 System.out.printf("%d: %s", fa.lineRevisions[i], fa.line(i) == null ? "null\n" : fa.line(i)); |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
357 } |
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
358 } |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
359 |
561
d3c71498919c
Do not process child revisions before all possible parent paths were visited
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
558
diff
changeset
|
360 public static void main(String[] args) throws Throwable { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
361 TestBlame tt = new TestBlame(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
362 tt.ccc(); |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
363 } |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
364 |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
365 private static class DiffOutInspector implements HgBlameInspector { |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
366 private final PrintStream out; |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
367 private boolean dumpRevs; |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
368 private IntVector reportedRevisionPairs = new IntVector(); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
369 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
370 DiffOutInspector(PrintStream ps) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
371 out = ps; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
372 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
373 |
554
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
374 // Note, true makes output incompatible with 'hg diff' |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
375 public void needRevisions(boolean dumpRevs) { |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
376 this.dumpRevs = dumpRevs; |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
377 } |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
378 |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
379 private void printRevs(Block b) { |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
380 if (dumpRevs) { |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
381 out.printf("[%3d -> %3d] ", b.originChangesetIndex(), b.targetChangesetIndex()); |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
382 } |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
383 reportedRevisionPairs.add(b.originChangesetIndex(), b.targetChangesetIndex()); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
384 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
385 |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
386 int[] getReportedTargetRevisions() { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
387 LinkedHashSet<Integer> rv = new LinkedHashSet<Integer>(); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
388 for (int i = 1; i < reportedRevisionPairs.size(); i += 2) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
389 rv.add(reportedRevisionPairs.get(i)); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
390 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
391 int[] x = new int[rv.size()]; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
392 int i = 0; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
393 for (int v : rv) { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
394 x[i++] = v; |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
395 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
396 return x; |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
397 } |
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
398 |
573
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
399 int[] getReportedRevisionPairs() { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
400 return reportedRevisionPairs.toArray(); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
401 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
402 |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
403 void reset() { |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
404 reportedRevisionPairs.clear(); |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
405 } |
e49f9d9513fa
Partial blame when start/end revisions are in the middle of a single filename history
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
570
diff
changeset
|
406 |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
407 public void same(EqualBlock block) { |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
408 // nothing |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
409 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
410 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
411 public void deleted(DeleteBlock block) { |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
412 printRevs(block); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
413 out.printf("@@ -%d,%d +%d,0 @@\n", block.firstRemovedLine() + 1, block.totalRemovedLines(), block.removedAt()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
414 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
415 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
416 public void changed(ChangeBlock block) { |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
417 printRevs(block); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
418 out.printf("@@ -%d,%d +%d,%d @@\n", block.firstRemovedLine() + 1, block.totalRemovedLines(), block.firstAddedLine() + 1, block.totalAddedLines()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
419 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
420 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
421 public void added(AddBlock block) { |
549
83afa680555d
Annotate merge revision (combined diff against two parents without looking further)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
548
diff
changeset
|
422 printRevs(block); |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
423 out.printf("@@ -%d,0 +%d,%d @@\n", block.insertedAt(), block.firstAddedLine() + 1, block.totalAddedLines()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
424 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
425 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
426 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
427 public static class LineGrepOutputParser implements OutputParser { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
428 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
429 private final Pattern pattern; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
430 private final StringBuilder result = new StringBuilder(); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
431 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
432 public LineGrepOutputParser(String regexp) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
433 pattern = Pattern.compile(regexp); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
434 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
435 |
553
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
436 public void reset() { |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
437 result.setLength(0); |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
438 } |
093a2022dad5
Test (with tailored repository) for annotation of multiple revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
552
diff
changeset
|
439 |
543
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
440 public CharSequence result() { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
441 return result; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
442 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
443 |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
444 public void parse(CharSequence seq) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
445 int lineStart = 0, lineEnd = 0; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
446 do { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
447 while (lineEnd < seq.length() && seq.charAt(lineEnd) != '\n') lineEnd++; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
448 if (lineEnd == lineStart) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
449 continue; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
450 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
451 CharSequence line = seq.subSequence(lineStart, lineEnd); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
452 if (pattern.matcher(line).matches()) { |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
453 result.append(line); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
454 result.append('\n'); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
455 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
456 lineStart = ++lineEnd; |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
457 } while (lineStart < seq.length()); |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
458 } |
1e95f48d9886
Report line index for insertion and deletion, test against 'hg diff' output
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
542
diff
changeset
|
459 } |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
460 |
555
e623aa2ca526
Annotate: RevisionDescriptor provides extra knowledge about inspected/annotated revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
554
diff
changeset
|
461 private static class FileAnnotateInspector implements LineInspector { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
462 private Integer[] lineRevisions; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
463 private String[] lines; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
464 |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
465 FileAnnotateInspector() { |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
466 } |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
467 |
629
5f52074707b2
Diff/blame methods as command, their residence in HgDataFile was a mistake
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
468 public void line(int lineNumber, int changesetRevIndex, HgBlameInspector.BlockData lineContent, LineDescriptor ld) { |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
469 if (lineRevisions == null) { |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
470 lineRevisions = new Integer[ld.totalLines()]; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
471 Arrays.fill(lineRevisions, NO_REVISION); |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
472 lines = new String[ld.totalLines()]; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
473 } |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
474 lineRevisions[lineNumber] = changesetRevIndex; |
557
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
475 lines[lineNumber] = new String(lineContent.asArray()); |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
476 } |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
477 |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
478 public String line(int i) { |
b9e5ac26dd83
Annotate: Line annotation needs true line position from merged blocks; test-annotate repo updated to show elements from both parents in the merged revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
556
diff
changeset
|
479 return lines[i]; |
545
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
480 } |
15b406c7cd9d
First round of annotate file is functional
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
544
diff
changeset
|
481 } |
546
cd78e8b9d7bc
File annotate test. Refactored FileAnnotation as standalone class, introduced LineInspector to make line offset calc code shared
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
545
diff
changeset
|
482 |
603
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
483 @SuppressWarnings("unused") |
707b5c7c6fa4
Refactor HgBlameFacility: relevant action methods moved to proper home (HgDataFile), as facility doesn't provide anything but packaging of relevant methods/interfaces
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
573
diff
changeset
|
484 private static class LineDumpInspector implements HgBlameInspector { |
554
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
485 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
486 private final boolean lineByLine; |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
487 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
488 public LineDumpInspector(boolean lineByLine) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
489 this.lineByLine = lineByLine; |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
490 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
491 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
492 public void same(EqualBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
493 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
494 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
495 public void added(AddBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
496 BlockData lines = block.addedLines(); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
497 printBlock(lines, block.targetChangesetIndex(), block.firstAddedLine(), block.totalAddedLines(), "+++"); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
498 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
499 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
500 public void changed(ChangeBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
501 deleted(block); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
502 added(block); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
503 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
504 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
505 public void deleted(DeleteBlock block) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
506 BlockData lines = block.removedLines(); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
507 assert lines.elementCount() == block.totalRemovedLines(); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
508 printBlock(lines, block.originChangesetIndex(), block.firstRemovedLine(), block.totalRemovedLines(), "---"); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
509 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
510 |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
511 private void printBlock(BlockData lines, int cset, int first, int length, String marker) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
512 assert lines.elementCount() == length; |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
513 if (lineByLine) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
514 for (int i = 0, ln = first; i < length; i++, ln++) { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
515 String line = new String(lines.elementAt(i).asArray()); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
516 System.out.printf("%3d:%3d:%s:%s", cset, ln, marker, line); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
517 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
518 } else { |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
519 String content = new String(lines.asArray()); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
520 System.out.printf("%3d:%s:[%d..%d):\n%s", cset, marker, first, first+length, content); |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
521 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
522 } |
a5fd757d1b5d
Access to content of annotated files through BlockData interface
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
553
diff
changeset
|
523 } |
570
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
524 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
525 static class AnnotateInspector implements HgAnnotateCommand.Inspector { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
526 private int lineNumber = 1; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
527 public final ArrayList<String> lines = new ArrayList<String>(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
528 public final ArrayList<Integer> changesets = new ArrayList<Integer>(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
529 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
530 public void next(LineInfo lineInfo) throws HgCallbackTargetException { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
531 Assert.assertEquals(lineInfo.getLineNumber(), lineNumber); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
532 lineNumber++; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
533 lines.add(new String(lineInfo.getContent())); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
534 changesets.add(lineInfo.getChangesetIndex()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
535 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
536 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
537 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
538 private static class AnnotateRunner { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
539 private final ExecHelper eh; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
540 private final OutputParser.Stub op; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
541 private final Path file; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
542 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
543 public AnnotateRunner(Path filePath, File repoDir) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
544 file = filePath; |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
545 op = new OutputParser.Stub(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
546 eh = new ExecHelper(op, repoDir); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
547 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
548 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
549 public void run(int cset, boolean follow) throws Exception { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
550 op.reset(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
551 ArrayList<String> args = new ArrayList<String>(); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
552 args.add("hg"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
553 args.add("annotate"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
554 args.add("-r"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
555 args.add(cset == TIP ? "tip" : String.valueOf(cset)); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
556 if (!follow) { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
557 args.add("--no-follow"); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
558 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
559 args.add(file.toString()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
560 eh.run(args); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
561 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
562 |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
563 public String[] getLines() { |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
564 return splitLines(op.result()); |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
565 } |
36853bb80a35
Tests for HgAnnotateCommand with follow/no-follow option
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
568
diff
changeset
|
566 } |
542
a71a05ec11bc
Towards annotate/blame support: general outline of the functionality
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
567 } |