Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 matcher.go // Copyright 2017 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package labels import ( "bytes" "encoding/json" "fmt" "regexp" "strconv" "strings" "unicode" "github.com/prometheus/common/model" ) // MatchType is an enum for label matching types. type MatchType int // Possible MatchTypes. const ( MatchEqual MatchType = iota MatchNotEqual MatchRegexp MatchNotRegexp ) func (m MatchType) String() string { typeToStr := map[MatchType]string{ MatchEqual: "=", MatchNotEqual: "!=", MatchRegexp: "=~", MatchNotRegexp: "!~", } if str, ok := typeToStr[m]; ok { return str } panic("unknown match type") } // Matcher models the matching of a label. type Matcher struct { Type MatchType Name string Value string re regexp.Regexp } // NewMatcher returns a matcher object. func NewMatcher(t MatchType, n, v string) (Matcher, error) { m := &Matcher{ Type: t, Name: n, Value: v, } if t == MatchRegexp \|\| t == MatchNotRegexp { re, err := regexp.Compile("^(?:" + v + ")$") if err != nil { return nil, err } m.re = re } return m, nil } func (m Matcher) String() string { if strings.ContainsFunc(m.Name, isReserved) { return fmt.Sprintf(`%s%s%s`, strconv.Quote(m.Name), m.Type, strconv.Quote(m.Value)) } return fmt.Sprintf(`%s%s"%s"`, m.Name, m.Type, openMetricsEscape(m.Value)) } // Matches returns whether the matcher matches the given string value. func (m Matcher) Matches(s string) bool { switch m.Type { case MatchEqual: return s == m.Value case MatchNotEqual: return s != m.Value case MatchRegexp: return m.re.MatchString(s) case MatchNotRegexp: return !m.re.MatchString(s) } panic("labels.Matcher.Matches: invalid match type") } type apiV1Matcher struct { Name string `json:"name"` Value string `json:"value"` IsRegex bool `json:"isRegex"` IsEqual bool `json:"isEqual"` } // MarshalJSON retains backwards compatibility with types.Matcher for the v1 API. func (m Matcher) MarshalJSON() ([]byte, error) { return json.Marshal(apiV1Matcher{ Name: m.Name, Value: m.Value, IsRegex: m.Type == MatchRegexp \|\| m.Type == MatchNotRegexp, IsEqual: m.Type == MatchRegexp \|\| m.Type == MatchEqual, }) } func (m Matcher) UnmarshalJSON(data []byte) error { v1m := apiV1Matcher{ IsEqual: true, } if err := json.Unmarshal(data, &v1m); err != nil { return err } var t MatchType switch { case v1m.IsEqual && !v1m.IsRegex: t = MatchEqual case !v1m.IsEqual && !v1m.IsRegex: t = MatchNotEqual case v1m.IsEqual && v1m.IsRegex: t = MatchRegexp case !v1m.IsEqual && v1m.IsRegex: t = MatchNotRegexp } matcher, err := NewMatcher(t, v1m.Name, v1m.Value) if err != nil { return err } m = matcher return nil } // openMetricsEscape is similar to the usual string escaping, but more // restricted. It merely replaces a new-line character with '\n', a double-quote // character with '\"', and a backslash with '\\', which is the escaping used by // OpenMetrics. func openMetricsEscape(s string) string { r := strings.NewReplacer( `\`, `\\`, "\n", `\n`, `"`, `\"`, ) return r.Replace(s) } // Matchers is a slice of Matchers that is sortable, implements Stringer, and // provides a Matches method to match a LabelSet against all Matchers in the // slice. Note that some users of Matchers might require it to be sorted. type Matchers []Matcher func (ms Matchers) Len() int { return len(ms) } func (ms Matchers) Swap(i, j int) { ms[i], ms[j] = ms[j], ms[i] } func (ms Matchers) Less(i, j int) bool { if ms[i].Name > ms[j].Name { return false } if ms[i].Name < ms[j].Name { return true } if ms[i].Value > ms[j].Value { return false } if ms[i].Value < ms[j].Value { return true } return ms[i].Type < ms[j].Type } // Matches checks whether all matchers are fulfilled against the given label set. func (ms Matchers) Matches(lset model.LabelSet) bool { for _, m := range ms { if !m.Matches(string(lset[model.LabelName(m.Name)])) { return false } } return true } func (ms Matchers) String() string { var buf bytes.Buffer buf.WriteByte('{') for i, m := range ms { if i > 0 { buf.WriteByte(',') } buf.WriteString(m.String()) } buf.WriteByte('}') return buf.String() } // This is copied from matcher/parse/lexer.go. It will be removed when // the transition window from classic matchers to UTF-8 matchers is complete, // as then we can use double quotes when printing the label name for all // matchers. Until then, the classic parser does not understand double quotes // around the label name, so we use this function as a heuristic to tell if // the matcher was parsed with the UTF-8 parser or the classic parser. func isReserved(r rune) bool { return unicode.IsSpace(r) \|\| strings.ContainsRune("{}!=~,\\\"'`", r) }	5.2 KB	2025-05-25 12:27
📄 matcher_test.go // Copyright 2017 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package labels import ( "encoding/json" "testing" ) func mustNewMatcher(t testing.T, mType MatchType, value string) Matcher { m, err := NewMatcher(mType, "", value) if err != nil { t.Fatal(err) } return m } func TestMatcher(t testing.T) { tests := []struct { matcher Matcher value string match bool }{ { matcher: mustNewMatcher(t, MatchEqual, "bar"), value: "bar", match: true, }, { matcher: mustNewMatcher(t, MatchEqual, "bar"), value: "foo-bar", match: false, }, { matcher: mustNewMatcher(t, MatchNotEqual, "bar"), value: "bar", match: false, }, { matcher: mustNewMatcher(t, MatchNotEqual, "bar"), value: "foo-bar", match: true, }, { matcher: mustNewMatcher(t, MatchRegexp, "bar"), value: "bar", match: true, }, { matcher: mustNewMatcher(t, MatchRegexp, "bar"), value: "foo-bar", match: false, }, { matcher: mustNewMatcher(t, MatchRegexp, ".bar"), value: "foo-bar", match: true, }, { matcher: mustNewMatcher(t, MatchNotRegexp, "bar"), value: "bar", match: false, }, { matcher: mustNewMatcher(t, MatchNotRegexp, "bar"), value: "foo-bar", match: true, }, { matcher: mustNewMatcher(t, MatchNotRegexp, ".bar"), value: "foo-bar", match: false, }, { matcher: mustNewMatcher(t, MatchRegexp, `foo.bar`), value: "foo-bar", match: true, }, { matcher: mustNewMatcher(t, MatchRegexp, `foo\.bar`), value: "foo-bar", match: false, }, { matcher: mustNewMatcher(t, MatchRegexp, `foo\.bar`), value: "foo.bar", match: true, }, { matcher: mustNewMatcher(t, MatchEqual, "foo\nbar"), value: "foo\nbar", match: true, }, { matcher: mustNewMatcher(t, MatchRegexp, "foo.bar"), value: "foo\nbar", match: false, }, { matcher: mustNewMatcher(t, MatchRegexp, "(?s)foo.bar"), value: "foo\nbar", match: true, }, { matcher: mustNewMatcher(t, MatchEqual, "~!=\""), value: "~!=\"", match: true, }, } for _, test := range tests { if test.matcher.Matches(test.value) != test.match { t.Fatalf("Unexpected match result for matcher %v and value %q; want %v, got %v", test.matcher, test.value, test.match, !test.match) } } } func TestMatcherString(t testing.T) { tests := []struct { name string op MatchType value string want string }{ { name: `foo`, op: MatchEqual, value: `bar`, want: `foo="bar"`, }, { name: `foo`, op: MatchNotEqual, value: `bar`, want: `foo!="bar"`, }, { name: `foo`, op: MatchRegexp, value: `bar`, want: `foo=~"bar"`, }, { name: `foo`, op: MatchNotRegexp, value: `bar`, want: `foo!~"bar"`, }, { name: `foo`, op: MatchEqual, value: `back\slash`, want: `foo="back\\slash"`, }, { name: `foo`, op: MatchEqual, value: `double"quote`, want: `foo="double\"quote"`, }, { name: `foo`, op: MatchEqual, value: `new line`, want: `foo="new\nline"`, }, { name: `foo`, op: MatchEqual, value: `tab stop`, want: `foo="tab stop"`, }, { name: `foo`, op: MatchEqual, value: `🙂`, want: `foo="🙂"`, }, { name: `foo!`, op: MatchNotEqual, value: `bar`, want: `"foo!"!="bar"`, }, { name: `foo🙂`, op: MatchEqual, value: `bar`, want: `foo🙂="bar"`, }, { name: `foo bar`, op: MatchEqual, value: `baz`, want: `"foo bar"="baz"`, }, } for _, test := range tests { m, err := NewMatcher(test.op, test.name, test.value) if err != nil { t.Fatal(err) } if got := m.String(); got != test.want { t.Errorf("Unexpected string representation of matcher; want %v, got %v", test.want, got) } } } func TestMatcherJSONMarshal(t testing.T) { tests := []struct { name string op MatchType value string want string }{ { name: `foo`, op: MatchEqual, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":false,"isEqual":true}`, }, { name: `foo`, op: MatchNotEqual, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":false,"isEqual":false}`, }, { name: `foo`, op: MatchRegexp, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":true,"isEqual":true}`, }, { name: `foo`, op: MatchNotRegexp, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":true,"isEqual":false}`, }, } cmp := func(m1, m2 Matcher) bool { return m1.Name == m2.Name && m1.Value == m2.Value && m1.Type == m2.Type } for _, test := range tests { m, err := NewMatcher(test.op, test.name, test.value) if err != nil { t.Fatal(err) } b, err := json.Marshal(m) if err != nil { t.Fatal(err) } if got := string(b); got != test.want { t.Errorf("Unexpected JSON representation of matcher:\nwant:\t%v\ngot:\t%v", test.want, got) } var m2 Matcher if err := json.Unmarshal(b, &m2); err != nil { t.Fatal(err) } if !cmp(m, m2) { t.Errorf("Doing Marshal and Unmarshal seems to be losing data; before %#v, after %#v", m, m2) } } } func TestMatcherJSONUnmarshal(t testing.T) { tests := []struct { name string op MatchType value string want string }{ { name: "foo", op: MatchEqual, value: "bar", want: `{"name":"foo","value":"bar","isRegex":false}`, }, { name: `foo`, op: MatchEqual, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":false,"isEqual":true}`, }, { name: `foo`, op: MatchNotEqual, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":false,"isEqual":false}`, }, { name: `foo`, op: MatchRegexp, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":true,"isEqual":true}`, }, { name: `foo`, op: MatchNotRegexp, value: `bar`, want: `{"name":"foo","value":"bar","isRegex":true,"isEqual":false}`, }, } cmp := func(m1, m2 Matcher) bool { return m1.Name == m2.Name && m1.Value == m2.Value && m1.Type == m2.Type } for _, test := range tests { var m Matcher if err := json.Unmarshal([]byte(test.want), &m); err != nil { t.Fatal(err) } m2, err := NewMatcher(test.op, test.name, test.value) if err != nil { t.Fatal(err) } if !cmp(m, *m2) { t.Errorf("Unmarshaling seems to be producing unexpected matchers; got %#v, expected %#v", m, m2) } } }	6.93 KB	2025-05-25 12:27
📄 parse.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package labels import ( "fmt" "regexp" "strings" "unicode/utf8" ) var ( // '=~' has to come before '=' because otherwise only the '=' // will be consumed, and the '~' will be part of the 3rd token. re = regexp.MustCompile(`^\s([a-zA-Z_:][a-zA-Z0-9_:])\s(=~\|=\|!=\|!~)\s((?s).?)\s$`) typeMap = map[string]MatchType{ "=": MatchEqual, "!=": MatchNotEqual, "=~": MatchRegexp, "!~": MatchNotRegexp, } ) // ParseMatchers parses a comma-separated list of Matchers. A leading '{' and/or // a trailing '}' is optional and will be trimmed before further // parsing. Individual Matchers are separated by commas outside of quoted parts // of the input string. Those commas may be surrounded by whitespace. Parts of the // string inside unescaped double quotes ('"…"') are considered quoted (and // commas don't act as separators there). If double quotes are escaped with a // single backslash ('\"'), they are ignored for the purpose of identifying // quoted parts of the input string. If the input string, after trimming the // optional trailing '}', ends with a comma, followed by optional whitespace, // this comma and whitespace will be trimmed. // // Examples for valid input strings: // // {foo = "bar", dings != "bums", } // foo=bar,dings!=bums // foo=bar, dings!=bums // {quote="She said: \"Hi, ladies! That's gender-neutral…\""} // statuscode=~"5.." // // See ParseMatcher for details on how an individual Matcher is parsed. func ParseMatchers(s string) ([]Matcher, error) { matchers := []Matcher{} s = strings.TrimPrefix(s, "{") s = strings.TrimSuffix(s, "}") var ( insideQuotes bool escaped bool token strings.Builder tokens []string ) for _, r := range s { switch r { case ',': if !insideQuotes { tokens = append(tokens, token.String()) token.Reset() continue } case '"': if !escaped { insideQuotes = !insideQuotes } else { escaped = false } case '\\': escaped = !escaped default: escaped = false } token.WriteRune(r) } if s := strings.TrimSpace(token.String()); s != "" { tokens = append(tokens, s) } for _, token := range tokens { m, err := ParseMatcher(token) if err != nil { return nil, err } matchers = append(matchers, m) } return matchers, nil } // ParseMatcher parses a matcher with a syntax inspired by PromQL and // OpenMetrics. This syntax is convenient to describe filters and selectors in // UIs and config files. To support the interactive nature of the use cases, the // parser is in various aspects fairly tolerant. // // The syntax of a matcher consists of three tokens: (1) A valid Prometheus // label name. (2) One of '=', '!=', '=~', or '!~', with the same meaning as // known from PromQL selectors. (3) A UTF-8 string, which may be enclosed in // double quotes. Before or after each token, there may be any amount of // whitespace, which will be discarded. The 3rd token may be the empty // string. Within the 3rd token, OpenMetrics escaping rules apply: '\"' for a // double-quote, '\n' for a line feed, '\\' for a literal backslash. Unescaped // '"' must not occur inside the 3rd token (only as the 1st or last // character). However, literal line feed characters are tolerated, as are // single '\' characters not followed by '\', 'n', or '"'. They act as a literal // backslash in that case. func ParseMatcher(s string) (_ *Matcher, err error) { ms := re.FindStringSubmatch(s) if len(ms) == 0 { return nil, fmt.Errorf("bad matcher format: %s", s) } var ( rawValue = ms[3] value strings.Builder escaped bool expectTrailingQuote bool ) if strings.HasPrefix(rawValue, "\"") { rawValue = strings.TrimPrefix(rawValue, "\"") expectTrailingQuote = true } if !utf8.ValidString(rawValue) { return nil, fmt.Errorf("matcher value not valid UTF-8: %s", ms[3]) } // Unescape the rawValue. for i, r := range rawValue { if escaped { escaped = false switch r { case 'n': value.WriteByte('\n') case '"', '\\': value.WriteRune(r) default: // This was a spurious escape, so treat the '\' as literal. value.WriteByte('\\') value.WriteRune(r) } continue } switch r { case '\\': if i < len(rawValue)-1 { escaped = true continue } // '\' encountered as last byte. Treat it as literal. value.WriteByte('\\') case '"': if !expectTrailingQuote \|\| i < len(rawValue)-1 { return nil, fmt.Errorf("matcher value contains unescaped double quote: %s", ms[3]) } expectTrailingQuote = false default: value.WriteRune(r) } } if expectTrailingQuote { return nil, fmt.Errorf("matcher value contains unescaped double quote: %s", ms[3]) } return NewMatcher(typeMap[ms[2]], ms[1], value.String()) }	5.25 KB	2025-05-25 12:27
📄 parse_test.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package labels import ( "reflect" "testing" ) func TestMatchers(t testing.T) { for _, tc := range []struct { input string want []Matcher err string }{ { input: `{}`, want: make([]Matcher, 0), }, { input: `,`, err: "bad matcher format: ", }, { input: `{,}`, err: "bad matcher format: ", }, { input: `{foo='}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "'") return append(ms, m) }(), }, { input: "{foo=`}", want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "`") return append(ms, m) }(), }, { input: "{foo=\\\"}", want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "\"") return append(ms, m) }(), }, { input: `{foo=bar}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") return append(ms, m) }(), }, { input: `{foo="bar"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") return append(ms, m) }(), }, { input: `{foo=~bar.}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchRegexp, "foo", "bar.") return append(ms, m) }(), }, { input: `{foo=~"bar."}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchRegexp, "foo", "bar.") return append(ms, m) }(), }, { input: `{foo!=bar}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchNotEqual, "foo", "bar") return append(ms, m) }(), }, { input: `{foo!="bar"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchNotEqual, "foo", "bar") return append(ms, m) }(), }, { input: `{foo!~bar.}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchNotRegexp, "foo", "bar.") return append(ms, m) }(), }, { input: `{foo!~"bar."}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchNotRegexp, "foo", "bar.") return append(ms, m) }(), }, { input: `{foo="bar", baz!="quux"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotEqual, "baz", "quux") return append(ms, m, m2) }(), }, { input: `{foo="bar", baz!~"quux."}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotRegexp, "baz", "quux.") return append(ms, m, m2) }(), }, { input: `{foo="bar",baz!~".quux", derp="wat"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotRegexp, "baz", ".quux") m3, _ := NewMatcher(MatchEqual, "derp", "wat") return append(ms, m, m2, m3) }(), }, { input: `{foo="bar", baz!="quux", derp="wat"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotEqual, "baz", "quux") m3, _ := NewMatcher(MatchEqual, "derp", "wat") return append(ms, m, m2, m3) }(), }, { input: `{foo="bar", baz!~".quux.", derp="wat"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotRegexp, "baz", ".quux.") m3, _ := NewMatcher(MatchEqual, "derp", "wat") return append(ms, m, m2, m3) }(), }, { input: `{foo="bar", instance=~"some-api."}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchRegexp, "instance", "some-api.") return append(ms, m, m2) }(), }, { input: `{foo=""}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "") return append(ms, m) }(), }, { input: `{foo="bar,quux", job="job1"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar,quux") m2, _ := NewMatcher(MatchEqual, "job", "job1") return append(ms, m, m2) }(), }, { input: `{foo = "bar", dings != "bums", }`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotEqual, "dings", "bums") return append(ms, m, m2) }(), }, { input: `foo=bar,dings!=bums`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar") m2, _ := NewMatcher(MatchNotEqual, "dings", "bums") return append(ms, m, m2) }(), }, { input: `{quote="She said: \"Hi, ladies! That's gender-neutral…\""}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "quote", `She said: "Hi, ladies! That's gender-neutral…"`) return append(ms, m) }(), }, { input: `statuscode=~"5.."`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchRegexp, "statuscode", "5..") return append(ms, m) }(), }, { input: `tricky=~~~`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchRegexp, "tricky", "~~") return append(ms, m) }(), }, { input: `trickier==\\=\=\"`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "trickier", `=\=\="`) return append(ms, m) }(), }, { input: `contains_quote != "\"" , contains_comma !~ "foo,bar" , `, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchNotEqual, "contains_quote", `"`) m2, _ := NewMatcher(MatchNotRegexp, "contains_comma", "foo,bar") return append(ms, m, m2) }(), }, { input: `{foo=bar}}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar}") return append(ms, m) }(), }, { input: `{foo=bar}},}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar}}") return append(ms, m) }(), }, { input: `{foo=,bar=}}`, want: func() []Matcher { ms := []Matcher{} m1, _ := NewMatcher(MatchEqual, "foo", "") m2, _ := NewMatcher(MatchEqual, "bar", "}") return append(ms, m1, m2) }(), }, { input: `{foo=bar\t}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar\\t") return append(ms, m) }(), }, { input: `{foo=bar\n}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar\n") return append(ms, m) }(), }, { input: `{foo=bar\}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar\\") return append(ms, m) }(), }, { input: `{foo=bar\\}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar\\") return append(ms, m) }(), }, { input: `{foo=bar\"}`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "bar\"") return append(ms, m) }(), }, { input: `job=`, want: func() []Matcher { m, _ := NewMatcher(MatchEqual, "job", "") return []Matcher{m} }(), }, { input: `job="value`, err: `matcher value contains unescaped double quote: "value`, }, { input: `job=value"`, err: `matcher value contains unescaped double quote: value"`, }, { input: `trickier==\\=\=\""`, err: `matcher value contains unescaped double quote: =\\=\=\""`, }, { input: `contains_unescaped_quote = foo"bar`, err: `matcher value contains unescaped double quote: foo"bar`, }, { input: `{invalid-name = "valid label"}`, err: `bad matcher format: invalid-name = "valid label"`, }, { input: `{foo=~"invalid[regexp"}`, err: "error parsing regexp: missing closing ]: `[regexp)$`", }, // Double escaped strings. { input: `"{foo=\"bar"}`, err: `bad matcher format: "{foo=\"bar"`, }, { input: `"foo=\"bar"`, err: `bad matcher format: "foo=\"bar"`, }, { input: `"foo=\"bar\""`, err: `bad matcher format: "foo=\"bar\""`, }, { input: `"foo=\"bar\"`, err: `bad matcher format: "foo=\"bar\"`, }, { input: `"{foo=\"bar\"}"`, err: `bad matcher format: "{foo=\"bar\"}"`, }, { input: `"foo="bar""`, err: `bad matcher format: "foo="bar""`, }, { input: `{{foo=`, err: `bad matcher format: {foo=`, }, { input: `{foo=`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "") return append(ms, m) }(), }, { input: `{foo=}b`, want: func() []Matcher { ms := []Matcher{} m, _ := NewMatcher(MatchEqual, "foo", "}b") return append(ms, m) }(), }, } { t.Run(tc.input, func(t testing.T) { got, err := ParseMatchers(tc.input) if err != nil && tc.err == "" { t.Fatalf("got error where none expected: %v", err) } if err == nil && tc.err != "" { t.Fatalf("expected error but got none: %v", tc.err) } if err != nil && err.Error() != tc.err { t.Fatalf("error not equal:\ngot %v\nwant %v", err, tc.err) } if !reflect.DeepEqual(got, tc.want) { t.Fatalf("labels not equal:\ngot %v\nwant %v", got, tc.want) } }) } }	9.84 KB	2025-05-25 12:27

Terminal