How to use Regex method of got Package

...5import (6	"github.com/stretchr/testify/assert"7	"testing"8)9func TestNamespace_RegexMatch(t *testing.T) {10	tt := map[string]struct {11		regex string12		str   string13		want  bool14	}{15		"True 1": {16			`[A-Za-z0-9._%+-]`,17			"test@verbiscms.com",18			true,19		},20		"True 2": {21			`[A-Za-z0-9._%+-]`,22			"TesT@VERBISCMS.COM",23			true,24		},25		"False 1": {26			`[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}`,27			"verbis",28			false,29		},30		"False 2": {31			`[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}`,32			"verbis.com",33			false,34		},35	}36	for name, test := range tt {37		t.Run(name, func(t *testing.T) {38			got := ns.Match(test.regex, test.str)39			assert.Equal(t, test.want, got)40		})41	}42}43func TestNamespace_RegexFindAll(t *testing.T) {44	var s []string45	tt := map[string]struct {46		regex string47		str   string48		n     int49		want  interface{}50	}{51		"Length 1": {52			"v{2}",53			"vvvvvv",54			1,55			[]string{"vv"},56		},57		"Length 2": {58			"v{2}",59			"vv",60			-1,61			[]string{"vv"},62		},63		"None": {64			"v{2}",65			"none",66			-1,67			s,68		},69	}70	for name, test := range tt {71		t.Run(name, func(t *testing.T) {72			got := ns.FindAll(test.regex, test.str, test.n)73			assert.Equal(t, test.want, got)74		})75	}76}77func TestNamespace_RegexFind(t *testing.T) {78	tt := map[string]struct {79		regex string80		str   string81		want  interface{}82	}{83		"Found 1": {84			"verbis.?",85			"verbis",86			"verbis",87		},88		"Found 2": {89			"verbis.?",90			"verbiscmsverrbis",91			"verbisc",92		},93		"None": {94			"verbis.?",95			"none",96			"",97		},98	}99	for name, test := range tt {100		t.Run(name, func(t *testing.T) {101			got := ns.Find(test.regex, test.str)102			assert.Equal(t, test.want, got)103		})104	}105}106func TestNamespace_RegexReplaceAll(t *testing.T) {107	tt := map[string]struct {108		regex string109		str   string110		repl  string111		want  interface{}112	}{113		"1": {114			"a(x*)b",115			"-ab-axxb-",116			"${1}W",117			"-W-xxW-",118		},119		"2": {120			"a(x*)b",121			"-ab-ab-",122			"${1}W",123			"-W-W-",124		},125		"3": {126			"a(x*)b",127			"ababababab",128			"${1}W",129			"WWWWW",130		},131		"4": {132			"a(x*)b",133			"----",134			"${1}W",135			"----",136		},137	}138	for name, test := range tt {139		t.Run(name, func(t *testing.T) {140			got := ns.ReplaceAll(test.regex, test.str, test.repl)141			assert.Equal(t, test.want, got)142		})143	}144}145func TestNamespace_RegexReplaceAllLiteral(t *testing.T) {146	tt := map[string]struct {147		regex string148		str   string149		repl  string150		want  interface{}151	}{152		"1": {153			"a(x*)b",154			"-ab-axxb-",155			"${1}",156			"-${1}-${1}-",157		},158		"2": {159			"a(x*)b",160			"-ab-ab-",161			"${1}",162			"-${1}-${1}-",163		},164		"3": {165			"a(x*)b",166			"ababababab",167			"${1}",168			"${1}${1}${1}${1}${1}",169		},170		"4": {171			"a(x*)b",172			"----",173			"${1}",174			"----",175		},176	}177	for name, test := range tt {178		t.Run(name, func(t *testing.T) {179			got := ns.ReplaceAllLiteral(test.regex, test.str, test.repl)180			assert.Equal(t, test.want, got)181		})182	}183}184func TestNamespace_RegexSplit(t *testing.T) {185	tt := map[string]struct {186		regex string187		str   string188		i     int189		want  []string190	}{191		"Positive": {192			"v",193			"verbis",194			1,195			[]string{"verbis"},196		},197		"Negative": {198			"v",199			"verbis",200			-1,201			[]string{"", "erbis"},202		},203		"Multiple": {204			"v",205			"vvvvvvv",206			-1,207			[]string{"", "", "", "", "", "", "", ""},208		},209		"None": {210			"v",211			"none",212			-1,213			[]string{"none"},214		},215	}216	for name, test := range tt {217		t.Run(name, func(t *testing.T) {218			got := ns.Split(test.regex, test.str, test.i)219			assert.Equal(t, test.want, got)220		})221	}222}223func TestNamespace_RegexQuoteMeta(t *testing.T) {224	tt := map[string]struct {225		input string226		want  interface{}227	}{228		"Stripped": {229			"verbis+",230			"verbis\\+",231		},232		"None": {233			"verbis",234			"verbis",235		},236	}237	for name, test := range tt {...

...6func TestMatchers(t *testing.T) {7	var (8		glob    = &globMatcher{glob: "foo*"}9		globInv = &globMatcher{glob: "foo*", inverse: true}10		regex    = newRegexMatcher(regexp.MustCompile("foo.*"), false)11		regexInv = newRegexMatcher(regexp.MustCompile("foo.*"), true)12		multi = multiMatcher{13			newRegexMatcher(regexp.MustCompile("foo"), false),14			newRegexMatcher(regexp.MustCompile(`\.go$`), false),15			newRegexMatcher(regexp.MustCompile("foobar"), true),16		}17	)18	for _, tt := range []struct {19		m    Matcher20		s    string21		want bool22	}{23		{glob, "foo", true},24		{glob, "foobar", true},25		{glob, "bar", false},26		{globInv, "foo", false},27		{globInv, "foobar", false},28		{globInv, "bar", true},29		{regex, "foo", true},30		{regex, "foobar", true},31		{regex, "bar", false},32		{regexInv, "foo", false},33		{regexInv, "foobar", false},34		{regexInv, "bar", true},35		{multi, "foo.go", true},36		{multi, "foo/bar.go", true},37		{multi, "foobar/blah.go", false},38	} {39		if got := tt.m.Match(tt.s); got != tt.want {40			t.Errorf("(%v).Match(%q): got %t; want %t",41				tt.m, tt.s, got, tt.want)42		}43	}44}45func TestExcludePrefix(t *testing.T) {46	m := newRegexMatcher(regexp.MustCompile("foo"), false)47	if m.ExcludePrefix("bar") {48		t.Error("m.ExcludePrefix gave true for a non-inverted matcher")49	}50	for _, tt := range []struct {51		re     string52		prefix string53		want   bool54	}{55		{"foo", "foo", true},56		{"((foo{3,4})|abc*)+|foo", "foo", true},57		{"foo$", "foo", false},58		{`foo\b`, "foo", false},59		{`(foo\b)|(baz$)`, "foo", false},60	} {61		m := newRegexMatcher(regexp.MustCompile(tt.re), true)62		if got := m.ExcludePrefix(tt.prefix); got != tt.want {63			t.Errorf("(%v).ExcludePrefix(%q): got %t; want %t",64				m, tt.prefix, got, tt.want)65		}66	}67}68func TestDefaultExcludes(t *testing.T) {69	for _, tt := range []struct {70		name string71		want bool72	}{73		{".git/HEAD", false},74		{"foo.git", true},75		{"foo/bar.git", true},...

...33		{"var", validName},34		{"vaR", validName},35		{"varName", validName},36		// [FAIL] snake_case37		{"var_name", invalidNameRegex},38		// [FAIL] PascalCase39		{"Var", invalidNameRegex},40		// [FAIL] ALLUPERCASE41		{"VAR", invalidNameRegex},42		// [FAIL] Special*Characters43		{"va.", invalidNameRegex},44		{"va.r", invalidNameRegex},45		{"va-r", invalidNameRegex},46		{"va*r", invalidNameRegex},47		{"va^r", invalidNameRegex},48		{"va&r", invalidNameRegex},49		{"&var", invalidNameRegex},50		{"var&", invalidNameRegex},51		// [FAIL] Blank52		{"", invalidNameRegex},53		// Reserved words54		{"jmp", reservedWord},55		{"copy", reservedWord},56	}57	for _, test := range tests {58		got := nameStatus(test.param)59		if test.expected != got {60			t.Errorf("For var name '%s': Expected: %d, Got: %d", test.param, test.expected, got)61		}62		gotError := got != validName63		gotParam := CheckParamName(test.param)64		gotErrorParam := gotParam != nil65		gotJump := CheckJumpLabelName(test.param)66		gotErrorJump := gotJump != nil...

1import (2func main() {3	fmt.Println("Enter the string")4	fmt.Scan(&str)5	fmt.Println("Enter the regex")6	fmt.Scan(&reg)7	match, err := regexp.MatchString(reg, str)8	if err != nil {9		fmt.Println(err)10	}11	fmt.Println(match)12}

1import (2func main() {3	match, _ := regexp.MatchString(pattern, str)4	fmt.Println(match)5	r, _ := regexp.Compile(pattern)6	fmt.Println(r.MatchString(str))7	fmt.Println(r.FindString(str))8	fmt.Println(r.FindStringIndex(str))9	fmt.Println(r.FindStringSubmatch(str))10	fmt.Println(r.FindStringSubmatchIndex(str))11	fmt.Println(r.FindAllString(str, -1))12	fmt.Println(r.FindAllString(str, 2))13	fmt.Println(r.FindAllStringIndex(str, -1))14	fmt.Println(r.FindAllStringSubmatch(str, -1))15	fmt.Println(r.FindAllStringSubmatchIndex(str, -1))16	fmt.Println(r.Match([]byte(str)))17	fmt.Println(r.Find([]byte(str)))18	fmt.Println(r.FindIndex([]byte(str)))19	fmt.Println(r.FindSubmatch([]byte(str)))20	fmt.Println(r.FindSubmatchIndex([]byte(str)))21	fmt.Println(r.FindAll([]byte(str), -1))22	fmt.Println(r.FindAllIndex([]byte(str), -1))23	fmt.Println(r.FindAllSubmatch([]byte(str), -1))24	fmt.Println(r.FindAllSubmatchIndex([]byte(str), -1))25}

1import (2func main() {3	fmt.Println("Enter a string to check if it is valid or not")4	fmt.Scan(&str)5	regex := regexp.MustCompile(`^[A-Z]{1}[a-z]{2,}$`)6	match := regex.MatchString(str)7	fmt.Println(match)8}

1import (2func main() {3	var reg = regexp.MustCompile("hello")4	fmt.Println(reg.FindString(str))5	fmt.Println(reg.FindAllString(str, -1))6	fmt.Println(reg.FindAllStringIndex(str, -1))7	fmt.Println(reg.FindAllStringSubmatch(str, -1))8	fmt.Println(reg.FindAllStringSubmatchIndex(str, -1))9}

1import (2func main() {3	regex, err := regexp.Compile(pattern)4	if err != nil {5		fmt.Println("Error : ", err)6	}7	if regex.MatchString(str) {8		fmt.Println("Match Found")9	} else {10		fmt.Println("Match Not Found")11	}12}

1import (2func main() {3	regex, _ := regexp.Compile("[a-z]+")4	matches := regex.FindAllString(str, -1)5	fmt.Println(matches)6	fmt.Println(len(matches))7}