#!/bin/sh

test_description='git blame ignore fuzzy heuristic'
. ./test-lib.sh

# short circuit until blame has the fuzzy capabilities
test_done

pick_author='s/^[0-9a-f^]* *(\([^ ]*\) .*/\1/'

# Each test is composed of 4 variables:
# titleN - the test name
# aN - the initial content
# bN - the final content
# expectedN - the line numbers from aN that we expect git blame
#             on bN to identify, or "Final" if bN itself should
#             be identified as the origin of that line.

# We start at test 2 because setup will show as test 1
title2="Regression test for partially overlapping search ranges"
cat <<EOF >a2
1
2
3
abcdef
5
6
7
ijkl
9
10
11
pqrs
13
14
15
wxyz
17
18
19
EOF
cat <<EOF >b2
abcde
ijk
pqr
wxy
EOF
cat <<EOF >expected2
4
8
12
16
EOF

title3="Combine 3 lines into 2"
cat <<EOF >a3
if ((maxgrow==0) ||
        ( single_line_field && (field->dcols < maxgrow)) ||
        (!single_line_field && (field->drows < maxgrow)))
EOF
cat <<EOF >b3
if ((maxgrow == 0) || (single_line_field && (field->dcols < maxgrow)) ||
        (!single_line_field && (field->drows < maxgrow))) {
EOF
cat <<EOF >expected3
2
3
EOF

title4="Add curly brackets"
cat <<EOF >a4
        if (rows) *rows = field->rows;
        if (cols) *cols = field->cols;
        if (frow) *frow = field->frow;
        if (fcol) *fcol = field->fcol;
EOF
cat <<EOF >b4
        if (rows) {
                *rows = field->rows;
        }
        if (cols) {
                *cols = field->cols;
        }
        if (frow) {
                *frow = field->frow;
        }
        if (fcol) {
                *fcol = field->fcol;
        }
EOF
cat <<EOF >expected4
1
1
Final
2
2
Final
3
3
Final
4
4
Final
EOF


title5="Combine many lines and change case"
cat <<EOF >a5
for(row=0,pBuffer=field->buf;
        row<height;
        row++,pBuffer+=width )
{
        if ((len = (int)( After_End_Of_Data( pBuffer, width ) - pBuffer )) > 0)
        {
                wmove( win, row, 0 );
                waddnstr( win, pBuffer, len );
EOF
cat <<EOF >b5
for (Row = 0, PBuffer = field->buf; Row < Height; Row++, PBuffer += Width) {
        if ((Len = (int)(afterEndOfData(PBuffer, Width) - PBuffer)) > 0) {
                wmove(win, Row, 0);
                waddnstr(win, PBuffer, Len);
EOF
cat <<EOF >expected5
1
5
7
8
EOF

title6="Rename and combine lines"
cat <<EOF >a6
bool need_visual_update = ((form != (FORM *)0)      &&
        (form->status & _POSTED) &&
        (form->current==field));

if (need_visual_update)
        Synchronize_Buffer(form);

if (single_line_field)
{
        growth = field->cols * amount;
        if (field->maxgrow)
                growth = Minimum(field->maxgrow - field->dcols,growth);
        field->dcols += growth;
        if (field->dcols == field->maxgrow)
EOF
cat <<EOF >b6
bool NeedVisualUpdate = ((Form != (FORM *)0) && (Form->status & _POSTED) &&
        (Form->current == field));

if (NeedVisualUpdate) {
        synchronizeBuffer(Form);
}

if (SingleLineField) {
        Growth = field->cols * amount;
        if (field->maxgrow) {
                Growth = Minimum(field->maxgrow - field->dcols, Growth);
        }
        field->dcols += Growth;
        if (field->dcols == field->maxgrow) {
EOF
cat <<EOF >expected6
1
3
4
5
6
Final
7
8
10
11
12
Final
13
14
EOF

# Both lines match identically so position must be used to tie-break.
title7="Same line twice"
cat <<EOF >a7
abc
abc
EOF
cat <<EOF >b7
abcd
abcd
EOF
cat <<EOF >expected7
1
2
EOF

title8="Enforce line order"
cat <<EOF >a8
abcdef
ghijkl
ab
EOF
cat <<EOF >b8
ghijk
abcd
EOF
cat <<EOF >expected8
2
3
EOF

title9="Expand lines and rename variables"
cat <<EOF >a9
int myFunction(int ArgumentOne, Thing *ArgTwo, Blah XuglyBug) {
        Squiggle FabulousResult = squargle(ArgumentOne, *ArgTwo,
                XuglyBug) + EwwwGlobalWithAReallyLongNameYepTooLong;
        return FabulousResult * 42;
}
EOF
cat <<EOF >b9
int myFunction(int argument_one, Thing *arg_asdfgh,
        Blah xugly_bug) {
        Squiggle fabulous_result = squargle(argument_one,
                *arg_asdfgh, xugly_bug)
                + g_ewww_global_with_a_really_long_name_yep_too_long;
        return fabulous_result * 42;
}
EOF
cat <<EOF >expected9
1
1
2
3
3
4
5
EOF

title10="Two close matches versus one less close match"
cat <<EOF >a10
abcdef
abcdef
ghijkl
EOF
cat <<EOF >b10
gh
abcdefx
EOF
cat <<EOF >expected10
Final
2
EOF

# The first line of b matches best with the last line of a, but the overall
# match is better if we match it with the the first line of a.
title11="Piggy in the middle"
cat <<EOF >a11
abcdefg
ijklmn
abcdefgh
EOF
cat <<EOF >b11
abcdefghx
ijklm
EOF
cat <<EOF >expected11
1
2
EOF

title12="No trailing newline"
printf "abc\ndef" >a12
printf "abx\nstu" >b12
cat <<EOF >expected12
1
Final
EOF

title13="Reorder includes"
cat <<EOF >a13
#include "c.h"
#include "b.h"
#include "a.h"
#include "e.h"
#include "d.h"
EOF
cat <<EOF >b13
#include "a.h"
#include "b.h"
#include "c.h"
#include "d.h"
#include "e.h"
EOF
cat <<EOF >expected13
3
2
1
5
4
EOF

last_test=13

test_expect_success setup '
        { for i in $(test_seq 2 $last_test)
        do
                # Append each line in a separate commit to make it easy to
                # check which original line the blame output relates to.

                line_count=0 &&
                { while IFS= read line
                do
                        line_count=$((line_count+1)) &&
                        echo "$line" >>"$i" &&
                        git add "$i" &&
                        test_tick &&
                        GIT_AUTHOR_NAME="$line_count" git commit -m "$line_count"
                done } <"a$i"
        done } &&

        { for i in $(test_seq 2 $last_test)
        do
                # Overwrite the files with the final content.
                cp b$i $i &&
                git add $i
        done } &&
        test_tick &&

        # Commit the final content all at once so it can all be
        # referred to with the same commit ID.
        GIT_AUTHOR_NAME=Final git commit -m Final &&

        IGNOREME=$(git rev-parse HEAD)
'

for i in $(test_seq 2 $last_test); do
        eval title="\$title$i"
        test_expect_success "$title" \
        "git blame -M9 --ignore-rev $IGNOREME $i >output &&
        sed -e \"$pick_author\" output >actual &&
        test_cmp expected$i actual"
done

# This invoked a null pointer dereference when the chunk callback was called
# with a zero length parent chunk and there were no more suspects.
test_expect_success 'Diff chunks with no suspects' '
        test_write_lines xy1 A B C xy1 >file &&
        git add file &&
        test_tick &&
        GIT_AUTHOR_NAME=1 git commit -m 1 &&

        test_write_lines xy2 A B xy2 C xy2 >file &&
        git add file &&
        test_tick &&
        GIT_AUTHOR_NAME=2 git commit -m 2 &&
        REV_2=$(git rev-parse HEAD) &&

        test_write_lines xy3 A >file &&
        git add file &&
        test_tick &&
        GIT_AUTHOR_NAME=3 git commit -m 3 &&
        REV_3=$(git rev-parse HEAD) &&

        test_write_lines 1 1 >expected &&

        git blame --ignore-rev $REV_2 --ignore-rev $REV_3 file >output &&
        sed -e "$pick_author" output >actual &&

        test_cmp expected actual
        '

test_expect_success 'position matching' '
        test_write_lines abc def >file2 &&
        git add file2 &&
        test_tick &&
        GIT_AUTHOR_NAME=1 git commit -m 1 &&

        test_write_lines abc def abc def >file2 &&
        git add file2 &&
        test_tick &&
        GIT_AUTHOR_NAME=2 git commit -m 2 &&

        test_write_lines abcx defx abcx defx >file2 &&
        git add file2 &&
        test_tick &&
        GIT_AUTHOR_NAME=3 git commit -m 3 &&
        REV_3=$(git rev-parse HEAD) &&

        test_write_lines abcy defy abcx defx >file2 &&
        git add file2 &&
        test_tick &&
        GIT_AUTHOR_NAME=4 git commit -m 4 &&
        REV_4=$(git rev-parse HEAD) &&

        test_write_lines 1 1 2 2 >expected &&

        git blame --ignore-rev $REV_3 --ignore-rev $REV_4 file2 >output &&
        sed -e "$pick_author" output >actual &&

        test_cmp expected actual
        '

# This fails if each blame entry is processed independently instead of
# processing each diff change in full.
test_expect_success 'preserve order' '
        test_write_lines bcde >file3 &&
        git add file3 &&
        test_tick &&
        GIT_AUTHOR_NAME=1 git commit -m 1 &&

        test_write_lines bcde fghij >file3 &&
        git add file3 &&
        test_tick &&
        GIT_AUTHOR_NAME=2 git commit -m 2 &&

        test_write_lines bcde fghij abcd >file3 &&
        git add file3 &&
        test_tick &&
        GIT_AUTHOR_NAME=3 git commit -m 3 &&

        test_write_lines abcdx fghijx bcdex >file3 &&
        git add file3 &&
        test_tick &&
        GIT_AUTHOR_NAME=4 git commit -m 4 &&
        REV_4=$(git rev-parse HEAD) &&

        test_write_lines abcdx fghijy bcdex >file3 &&
        git add file3 &&
        test_tick &&
        GIT_AUTHOR_NAME=5 git commit -m 5 &&
        REV_5=$(git rev-parse HEAD) &&

        test_write_lines 1 2 3 >expected &&

        git blame --ignore-rev $REV_4 --ignore-rev $REV_5 file3 >output &&
        sed -e "$pick_author" output >actual &&

        test_cmp expected actual
        '

test_done