pattern: add more test cases for globstar not used on its own

Bash documents globstar as follows:

    When the globstar shell option is enabled, and * is used in a
    pathname expansion context, two adjacent *s used as a single pattern
    will match all files and zero or more directories and subdirectories

That is, `/**/foo` or `bar/**` both result in globstar globbing
where we can match files and nested directories,
but `/**foo` or `bar**/` do not place the two star characters
in a single pattern, so they behave like a single glob star instead.

The interp and expand packages already deals with this correctly,
because they first split the glob pattern into path elements,
and they deal with one element being exactly "**" in a special way.

The pattern package still aims to support "**" by itself,
but it does not handle this edge case properly;
it treats any occurrence of "**" as a globstar wildcard no matter
whether or not it's on its own as a path element.

Fix coming in the next commit.

For #1149.

Author: mvdan

interp/interp_test.go

@@ -2877,6 +2877,10 @@ done <<< 2`,
 		"shopt -s globstar; mkdir -p a/b/c a/d; echo ** | sed 's@\\\\@/@g'",
 		"a a/b a/b/c a/d\n",
 	},
+	{
+		"shopt -s globstar; mkdir -p a.x a/b.x a/b/c.x; echo **.x ./**.x | sed 's@\\\\@/@g'",
+		"a.x ./a.x\n",
+	},
 	{
 		"mkdir foo; touch foo/bar; echo */bar */bar/ | sed 's@\\\\@/@g'",
 		"foo/bar */bar/\n",

pattern/pattern_test.go

@@ -5,15 +5,21 @@ package pattern
 
 import (
 	"fmt"
+	"regexp"
 	"regexp/syntax"
 	"testing"
+
+	"github.com/go-quicktest/qt"
 )
 
-var translateTests = []struct {
+var regexpTests = []struct {
 	pat     string
 	mode    Mode
 	want    string
 	wantErr bool
+
+	mustMatch    []string
+	mustNotMatch []string
 }{
 	{pat: ``, want: ``},
 	{pat: `foo`, want: `foo`},
@@ -30,7 +36,23 @@ var translateTests = []struct {
 	{pat: `/**/foo`, mode: Filenames, want: `(?s)/(.*/|)foo`},
 	{pat: `/**/foo`, mode: Filenames | NoGlobStar, want: `/[^/]*/foo`},
 	{pat: `/**/à`, mode: Filenames, want: `(?s)/(.*/|)à`},
-	{pat: `/**foo`, mode: Filenames, want: `(?s)/.*foo`},
+	{
+		pat: `/**foo`, mode: Filenames, want: `(?s)/.*foo`,
+		// These all match because without EntireString, we match substrings.
+		mustMatch: []string{"/foo", "/prefix-foo", "/foo-suffix", "/sub/foo"},
+	},
+	{
+		pat: `/**foo`, mode: Filenames | EntireString, want: `(?s)^/.*foo$`,
+		// TODO: /sub/foo should not match; see issue 1149
+		mustMatch:    []string{"/foo", "/prefix-foo", "/sub/foo"},
+		mustNotMatch: []string{"/foo-suffix"},
+	},
+	{
+		pat: `/foo**`, mode: Filenames | EntireString, want: `(?s)^/foo.*$`,
+		// TODO: /foo/sub should not match; see issue 1149
+		mustMatch:    []string{"/foo", "/foo-suffix", "/foo/sub"},
+		mustNotMatch: []string{"/prefix-foo"},
+	},
 	{pat: `\*`, want: `\*`},
 	{pat: `\`, wantErr: true},
 	{pat: `?`, want: `(?s).`},
@@ -88,7 +110,7 @@ var translateTests = []struct {
 
 func TestRegexp(t *testing.T) {
 	t.Parallel()
-	for i, tc := range translateTests {
+	for i, tc := range regexpTests {
 		t.Run(fmt.Sprintf("%02d", i), func(t *testing.T) {
 			got, gotErr := Regexp(tc.pat, tc.mode)
 			if tc.wantErr && gotErr == nil {
@@ -104,6 +126,13 @@ func TestRegexp(t *testing.T) {
 			if gotErr == nil && rxErr != nil {
 				t.Fatalf("regexp/syntax.Parse(%q) failed with %q", got, rxErr)
 			}
+			rx := regexp.MustCompile(got)
+			for _, s := range tc.mustMatch {
+				qt.Assert(t, qt.IsTrue(rx.MatchString(s)), qt.Commentf("must match: %q", s))
+			}
+			for _, s := range tc.mustNotMatch {
+				qt.Assert(t, qt.IsFalse(rx.MatchString(s)), qt.Commentf("must not match: %q", s))
+			}
 		})
 	}
 }