grep: amend submodule recursion test for regex engine testing

Amend the submodule recursion test to prepare it for subsequent tests
of whether it passes along the grep.patternType to the submodule
greps.

This is the result of searching & replacing:

foobar -> (1|2)d(3|4)
foo    -> (1|2)
bar    -> (3|4)

Currently there's no tests for whether e.g. -P or -E is correctly
passed along, tests for that will be added in a follow-up change, but
first add content to the tests which will match differently under
different regex engines.

Reuse the pattern established in an earlier commit of mine in this
series ("log: add exhaustive tests for pattern style options &
config", 2017-04-07). The pattern "(.|.)[\d]" will match this content
differently under fixed/basic/extended & perl.

This test code was originally added in commit 0281e487fd ("grep:
optionally recurse into submodules", 2016-12-16).

Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/t/t7814-grep-recurse-submodules.sh b/t/t7814-grep-recurse-submodules.sh
index 5b6eb3a65e26263db526c2e891ae01a4578bf48e..1472855e1d0e98f702f11eaed791519cf37e0a62 100755 (executable)
--- a/t/t7814-grep-recurse-submodules.sh
+++ b/t/t7814-grep-recurse-submodules.sh
@@ -9,13 +9,13 @@ submodules.
 . ./test-lib.sh
 
 test_expect_success 'setup directory structure and submodule' '
-       echo "foobar" >a &&
+       echo "(1|2)d(3|4)" >a &&
        mkdir b &&
-       echo "bar" >b/b &&
+       echo "(3|4)" >b/b &&
        git add a b &&
        git commit -m "add a and b" &&
        git init submodule &&
-       echo "foobar" >submodule/a &&
+       echo "(1|2)d(3|4)" >submodule/a &&
        git -C submodule add a &&
        git -C submodule commit -m "add a" &&
        git submodule add ./submodule &&
@@ -24,18 +24,18 @@ test_expect_success 'setup directory structure and submodule' '
 
 test_expect_success 'grep correctly finds patterns in a submodule' '
        cat >expect <<-\EOF &&
-       a:foobar
-       b/b:bar
-       submodule/a:foobar
+       a:(1|2)d(3|4)
+       b/b:(3|4)
+       submodule/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules >actual &&
+       git grep -e "(3|4)" --recurse-submodules >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep and basic pathspecs' '
        cat >expect <<-\EOF &&
-       submodule/a:foobar
+       submodule/a:(1|2)d(3|4)
        EOF
 
        git grep -e. --recurse-submodules -- submodule >actual &&
@@ -44,7 +44,7 @@ test_expect_success 'grep and basic pathspecs' '
 
 test_expect_success 'grep and nested submodules' '
        git init submodule/sub &&
-       echo "foobar" >submodule/sub/a &&
+       echo "(1|2)d(3|4)" >submodule/sub/a &&
        git -C submodule/sub add a &&
        git -C submodule/sub commit -m "add a" &&
        git -C submodule submodule add ./sub &&
@@ -54,117 +54,117 @@ test_expect_success 'grep and nested submodules' '
        git commit -m "updated submodule" &&
 
        cat >expect <<-\EOF &&
-       a:foobar
-       b/b:bar
-       submodule/a:foobar
-       submodule/sub/a:foobar
+       a:(1|2)d(3|4)
+       b/b:(3|4)
+       submodule/a:(1|2)d(3|4)
+       submodule/sub/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules >actual &&
+       git grep -e "(3|4)" --recurse-submodules >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep and multiple patterns' '
        cat >expect <<-\EOF &&
-       a:foobar
-       submodule/a:foobar
-       submodule/sub/a:foobar
+       a:(1|2)d(3|4)
+       submodule/a:(1|2)d(3|4)
+       submodule/sub/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --and -e "foo" --recurse-submodules >actual &&
+       git grep -e "(3|4)" --and -e "(1|2)" --recurse-submodules >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep and multiple patterns' '
        cat >expect <<-\EOF &&
-       b/b:bar
+       b/b:(3|4)
        EOF
 
-       git grep -e "bar" --and --not -e "foo" --recurse-submodules >actual &&
+       git grep -e "(3|4)" --and --not -e "(1|2)" --recurse-submodules >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'basic grep tree' '
        cat >expect <<-\EOF &&
-       HEAD:a:foobar
-       HEAD:b/b:bar
-       HEAD:submodule/a:foobar
-       HEAD:submodule/sub/a:foobar
+       HEAD:a:(1|2)d(3|4)
+       HEAD:b/b:(3|4)
+       HEAD:submodule/a:(1|2)d(3|4)
+       HEAD:submodule/sub/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep tree HEAD^' '
        cat >expect <<-\EOF &&
-       HEAD^:a:foobar
-       HEAD^:b/b:bar
-       HEAD^:submodule/a:foobar
+       HEAD^:a:(1|2)d(3|4)
+       HEAD^:b/b:(3|4)
+       HEAD^:submodule/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD^ >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD^ >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep tree HEAD^^' '
        cat >expect <<-\EOF &&
-       HEAD^^:a:foobar
-       HEAD^^:b/b:bar
+       HEAD^^:a:(1|2)d(3|4)
+       HEAD^^:b/b:(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD^^ >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD^^ >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep tree and pathspecs' '
        cat >expect <<-\EOF &&
-       HEAD:submodule/a:foobar
-       HEAD:submodule/sub/a:foobar
+       HEAD:submodule/a:(1|2)d(3|4)
+       HEAD:submodule/sub/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD -- submodule >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD -- submodule >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep tree and pathspecs' '
        cat >expect <<-\EOF &&
-       HEAD:submodule/a:foobar
-       HEAD:submodule/sub/a:foobar
+       HEAD:submodule/a:(1|2)d(3|4)
+       HEAD:submodule/sub/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD -- "submodule*a" >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD -- "submodule*a" >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep tree and more pathspecs' '
        cat >expect <<-\EOF &&
-       HEAD:submodule/a:foobar
+       HEAD:submodule/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD -- "submodul?/a" >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD -- "submodul?/a" >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep tree and more pathspecs' '
        cat >expect <<-\EOF &&
-       HEAD:submodule/sub/a:foobar
+       HEAD:submodule/sub/a:(1|2)d(3|4)
        EOF
 
-       git grep -e "bar" --recurse-submodules HEAD -- "submodul*/sub/a" >actual &&
+       git grep -e "(3|4)" --recurse-submodules HEAD -- "submodul*/sub/a" >actual &&
        test_cmp expect actual
 '
 
 test_expect_success !MINGW 'grep recurse submodule colon in name' '
        git init parent &&
        test_when_finished "rm -rf parent" &&
-       echo "foobar" >"parent/fi:le" &&
+       echo "(1|2)d(3|4)" >"parent/fi:le" &&
        git -C parent add "fi:le" &&
        git -C parent commit -m "add fi:le" &&
 
        git init "su:b" &&
        test_when_finished "rm -rf su:b" &&
-       echo "foobar" >"su:b/fi:le" &&
+       echo "(1|2)d(3|4)" >"su:b/fi:le" &&
        git -C "su:b" add "fi:le" &&
        git -C "su:b" commit -m "add fi:le" &&
 
@@ -172,30 +172,30 @@ test_expect_success !MINGW 'grep recurse submodule colon in name' '
        git -C parent commit -m "add submodule" &&
 
        cat >expect <<-\EOF &&
-       fi:le:foobar
-       su:b/fi:le:foobar
+       fi:le:(1|2)d(3|4)
+       su:b/fi:le:(1|2)d(3|4)
        EOF
-       git -C parent grep -e "foobar" --recurse-submodules >actual &&
+       git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules >actual &&
        test_cmp expect actual &&
 
        cat >expect <<-\EOF &&
-       HEAD:fi:le:foobar
-       HEAD:su:b/fi:le:foobar
+       HEAD:fi:le:(1|2)d(3|4)
+       HEAD:su:b/fi:le:(1|2)d(3|4)
        EOF
-       git -C parent grep -e "foobar" --recurse-submodules HEAD >actual &&
+       git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules HEAD >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep history with moved submoules' '
        git init parent &&
        test_when_finished "rm -rf parent" &&
-       echo "foobar" >parent/file &&
+       echo "(1|2)d(3|4)" >parent/file &&
        git -C parent add file &&
        git -C parent commit -m "add file" &&
 
        git init sub &&
        test_when_finished "rm -rf sub" &&
-       echo "foobar" >sub/file &&
+       echo "(1|2)d(3|4)" >sub/file &&
        git -C sub add file &&
        git -C sub commit -m "add file" &&
 
@@ -203,82 +203,82 @@ test_expect_success 'grep history with moved submoules' '
        git -C parent commit -m "add submodule" &&
 
        cat >expect <<-\EOF &&
-       dir/sub/file:foobar
-       file:foobar
+       dir/sub/file:(1|2)d(3|4)
+       file:(1|2)d(3|4)
        EOF
-       git -C parent grep -e "foobar" --recurse-submodules >actual &&
+       git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules >actual &&
        test_cmp expect actual &&
 
        git -C parent mv dir/sub sub-moved &&
        git -C parent commit -m "moved submodule" &&
 
        cat >expect <<-\EOF &&
-       file:foobar
-       sub-moved/file:foobar
+       file:(1|2)d(3|4)
+       sub-moved/file:(1|2)d(3|4)
        EOF
-       git -C parent grep -e "foobar" --recurse-submodules >actual &&
+       git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules >actual &&
        test_cmp expect actual &&
 
        cat >expect <<-\EOF &&
-       HEAD^:dir/sub/file:foobar
-       HEAD^:file:foobar
+       HEAD^:dir/sub/file:(1|2)d(3|4)
+       HEAD^:file:(1|2)d(3|4)
        EOF
-       git -C parent grep -e "foobar" --recurse-submodules HEAD^ >actual &&
+       git -C parent grep -e "(1|2)d(3|4)" --recurse-submodules HEAD^ >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep using relative path' '
        test_when_finished "rm -rf parent sub" &&
        git init sub &&
-       echo "foobar" >sub/file &&
+       echo "(1|2)d(3|4)" >sub/file &&
        git -C sub add file &&
        git -C sub commit -m "add file" &&
 
        git init parent &&
-       echo "foobar" >parent/file &&
+       echo "(1|2)d(3|4)" >parent/file &&
        git -C parent add file &&
        mkdir parent/src &&
-       echo "foobar" >parent/src/file2 &&
+       echo "(1|2)d(3|4)" >parent/src/file2 &&
        git -C parent add src/file2 &&
        git -C parent submodule add ../sub &&
        git -C parent commit -m "add files and submodule" &&
 
        # From top works
        cat >expect <<-\EOF &&
-       file:foobar
-       src/file2:foobar
-       sub/file:foobar
+       file:(1|2)d(3|4)
+       src/file2:(1|2)d(3|4)
+       sub/file:(1|2)d(3|4)
        EOF
-       git -C parent grep --recurse-submodules -e "foobar" >actual &&
+       git -C parent grep --recurse-submodules -e "(1|2)d(3|4)" >actual &&
        test_cmp expect actual &&
 
        # Relative path to top
        cat >expect <<-\EOF &&
-       ../file:foobar
-       file2:foobar
-       ../sub/file:foobar
+       ../file:(1|2)d(3|4)
+       file2:(1|2)d(3|4)
+       ../sub/file:(1|2)d(3|4)
        EOF
-       git -C parent/src grep --recurse-submodules -e "foobar" -- .. >actual &&
+       git -C parent/src grep --recurse-submodules -e "(1|2)d(3|4)" -- .. >actual &&
        test_cmp expect actual &&
 
        # Relative path to submodule
        cat >expect <<-\EOF &&
-       ../sub/file:foobar
+       ../sub/file:(1|2)d(3|4)
        EOF
-       git -C parent/src grep --recurse-submodules -e "foobar" -- ../sub >actual &&
+       git -C parent/src grep --recurse-submodules -e "(1|2)d(3|4)" -- ../sub >actual &&
        test_cmp expect actual
 '
 
 test_expect_success 'grep from a subdir' '
        test_when_finished "rm -rf parent sub" &&
        git init sub &&
-       echo "foobar" >sub/file &&
+       echo "(1|2)d(3|4)" >sub/file &&
        git -C sub add file &&
        git -C sub commit -m "add file" &&
 
        git init parent &&
        mkdir parent/src &&
-       echo "foobar" >parent/src/file &&
+       echo "(1|2)d(3|4)" >parent/src/file &&
        git -C parent add src/file &&
        git -C parent submodule add ../sub src/sub &&
        git -C parent submodule add ../sub sub &&
@@ -286,19 +286,19 @@ test_expect_success 'grep from a subdir' '
 
        # Verify grep from root works
        cat >expect <<-\EOF &&
-       src/file:foobar
-       src/sub/file:foobar
-       sub/file:foobar
+       src/file:(1|2)d(3|4)
+       src/sub/file:(1|2)d(3|4)
+       sub/file:(1|2)d(3|4)
        EOF
-       git -C parent grep --recurse-submodules -e "foobar" >actual &&
+       git -C parent grep --recurse-submodules -e "(1|2)d(3|4)" >actual &&
        test_cmp expect actual &&
 
        # Verify grep from a subdir works
        cat >expect <<-\EOF &&
-       file:foobar
-       sub/file:foobar
+       file:(1|2)d(3|4)
+       sub/file:(1|2)d(3|4)
        EOF
-       git -C parent/src grep --recurse-submodules -e "foobar" >actual &&
+       git -C parent/src grep --recurse-submodules -e "(1|2)d(3|4)" >actual &&
        test_cmp expect actual
 '