diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..4f138e8 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1,4 @@ +# See https://help.github.com/articles/about-codeowners/ +# for more info about CODEOWNERS file + +* @urfave/cli diff --git a/.github/ISSUE_TEMPLATE/bug-report.md b/.github/ISSUE_TEMPLATE/bug-report.md new file mode 100644 index 0000000..8b64d60 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug-report.md @@ -0,0 +1,75 @@ +--- +name: bug report +about: Create a report to help us fix bugs +title: 'your bug title goes here' +labels: 'kind/bug, status/triage' +assignees: '' + +--- + +## My urfave/sflags version is + +_**( Put the version of urfave/sflags that you are using here )**_ + +## Checklist + +- [ ] Are you running the latest release? The list of releases is [here](https://github.com/urfave/sflags/releases). +- [ ] Did you perform a search about this problem? Here's the [GitHub guide](https://help.github.com/en/github/managing-your-work-on-github/using-search-to-filter-issues-and-pull-requests) about searching. + +## Dependency Management + + + +- My project is using go modules. +- My project is using vendoring. +- My project is automatically downloading the latest version. +- I am unsure of what my dependency management setup is. + +## Describe the bug + +A clear and concise description of what the bug is. + +## To reproduce + +Describe the steps or code required to reproduce the behavior + +## Observed behavior + +What did you see happen immediately after the reproduction steps +above? + +## Expected behavior + +What would you have expected to happen immediately after the +reproduction steps above? + +## Additional context + +Add any other context about the problem here. + +If the issue relates to a specific open source GitHub repo, please +link that repo here. + +If you can reproduce this issue with a public CI system, please +link a failing build here. + +## Want to fix this yourself? + +We'd love to have more contributors on this project! If the fix for +this bug is easily explained and very small, feel free to create a +pull request for it. You'll want to base the PR off the `v1` +branch, all `v1` bug fix releases will be made from that branch. + +## Run `go version` and paste its output here + +``` +# paste `go version` output in here +``` + +## Run `go env` and paste its output here + +``` +# paste `go env` output in here +``` diff --git a/.github/ISSUE_TEMPLATE/feature-request.md b/.github/ISSUE_TEMPLATE/feature-request.md new file mode 100644 index 0000000..56497ba --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature-request.md @@ -0,0 +1,33 @@ +--- +name: feature request +about: Suggest an improvement to go into sflags +title: 'your feature title goes here' +labels: 'type/feature, status/triage' +assignees: '' + +--- + +## Checklist + +* [ ] Are you running the latest v3 release? The list of releases is [here](https://github.com/urfave/sflags/releases). +* [ ] Did you perform a search about this feature? Here's the [GitHub guide](https://help.github.com/en/github/managing-your-work-on-github/using-search-to-filter-issues-and-pull-requests) about searching. + +## What problem does this solve? + +A clear and concise description of what problem this feature would solve. For example: + +- needing to type out the full flag name takes a long time, so I + would like to suggest adding auto-complete +- I use (osx, windows, linux) and would like support for (some + existing feature) to be extended to my platform +- the terminal output for a particular error case is confusing, and + I think it could be improved + +## Solution description + +A detailed description of what you want to happen. + +## Describe alternatives you've considered + +A clear and concise description of any alternative solutions or +features you've considered. diff --git a/.github/ISSUE_TEMPLATE/question.md b/.github/ISSUE_TEMPLATE/question.md new file mode 100644 index 0000000..e49af63 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/question.md @@ -0,0 +1,10 @@ +--- +name: ask a question +about: ask a question - assume stackoverflow's guidelines apply here +title: your question title goes here +labels: 'kind/question, status/triage' +assignees: '' + +--- + +my question is... diff --git a/.github/codecov.yml b/.github/codecov.yml new file mode 100644 index 0000000..ef1a035 --- /dev/null +++ b/.github/codecov.yml @@ -0,0 +1,12 @@ +comment: false +coverage: + status: + project: + default: + threshold: 5% + patch: + default: + threshold: 5% +ignore: + - examples + - scripts diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md new file mode 100644 index 0000000..47348f8 --- /dev/null +++ b/.github/pull_request_template.md @@ -0,0 +1,75 @@ + + +## What type of PR is this? + +_(REQUIRED)_ + + + +- bug +- cleanup +- documentation +- feature + +## What this PR does / why we need it: + +_(REQUIRED)_ + + + +## Which issue(s) this PR fixes: + +_(REQUIRED)_ + + + +## Special notes for your reviewer: + +_(fill-in or delete this section)_ + + + +## Testing + +_(fill-in or delete this section)_ + + + +## Release Notes + +_(REQUIRED)_ + + +```release-note + +``` diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..4dc404e --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,33 @@ +name: golangci-lint +on: + push: + branches: + - main + - master + pull_request: + +permissions: + contents: read + # Optional: allow read access to pull request. Use with `only-new-issues` option. + # pull-requests: read + +jobs: + golangci: + strategy: + matrix: + go: [stable] + # disable windows-latest for now + os: [ubuntu-latest, macos-latest] + name: lint + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-go@v5 + with: + go-version: ${{ matrix.go }} + - name: golangci-lint + uses: golangci/golangci-lint-action@v6 + with: + version: v1.60 + - name: run CI + run: make ci \ No newline at end of file diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..1a89644 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,36 @@ +name: Run tests + +on: + push: + branches: + - main + pull_request: + branches: + - main + +permissions: + contents: read + +jobs: + test: + strategy: + matrix: + os: [ubuntu-latest, macos-latest, windows-latest] + go: [stable, oldstable] + + name: ${{ matrix.os }} @ Go ${{ matrix.go }} + runs-on: ${{ matrix.os }} + + steps: + - uses: actions/checkout@v4 + + - name: Set up Go + uses: actions/setup-go@v5 + with: + go-version: ${{ matrix.go }} + + - name: Set PATH + run: echo "${GITHUB_WORKSPACE}/.local/bin" >>"${GITHUB_PATH}" + + - name: Run tests + run: make test_v \ No newline at end of file diff --git a/Makefile b/Makefile index a4a418f..73b8c2d 100644 --- a/Makefile +++ b/Makefile @@ -8,7 +8,7 @@ PKGSDIRS=$(shell find -L . -type f -name "*.go") all: prepare -travis: info vet lint check test_v coverage +ci: vet check test_v coverage coverage: @echo "$(OK_COLOR)Generate coverage$(NO_COLOR)" @@ -30,7 +30,7 @@ lint: check: @echo "$(OK_COLOR)Run golangci-lint$(NO_COLOR)" - @golangci-lint run --no-config --exclude-use-default=true --max-same-issues=10 --disable=gosimple --disable=golint --enable=megacheck --enable=interfacer --enable=goconst --enable=misspell --enable=unparam --enable=goimports --disable=errcheck --disable=ineffassign --disable=gocyclo --disable=gas + @golangci-lint run --no-config --exclude-use-default=true --max-same-issues=10 --disable=gosimple --enable=staticcheck --enable=unused --enable=goconst --enable=misspell --enable=unparam --enable=goimports --disable=errcheck --disable=ineffassign --disable=gocyclo --disable=gosec vet: @echo "$(OK_COLOR)Run vet$(NO_COLOR)" @@ -42,7 +42,7 @@ race: fmt: @echo "$(OK_COLOR)Formatting$(NO_COLOR)" - @echo $(PKGSDIRS) | xargs -I '{p}' -n1 goimports -w {p} + @echo $(PKGSDIRS) | xargs goimports -w info: depscheck -totalonly -tests . diff --git a/camelcase.go b/camelcase.go index 5a48fe1..a736f7a 100644 --- a/camelcase.go +++ b/camelcase.go @@ -42,37 +42,37 @@ const ( // // Examples // -// "" => [""] -// "lowercase" => ["lowercase"] -// "Class" => ["Class"] -// "MyClass" => ["My", "Class"] -// "MyC" => ["My", "C"] -// "HTML" => ["HTML"] -// "PDFLoader" => ["PDF", "Loader"] -// "AString" => ["A", "String"] -// "SimpleXMLParser" => ["Simple", "XML", "Parser"] -// "vimRPCPlugin" => ["vim", "RPC", "Plugin"] -// "GL11Version" => ["GL11", "Version"] -// "99Bottles" => ["99", "Bottles"] -// "May5" => ["May5"] -// "BFG9000" => ["BFG9000"] -// "BöseÜberraschung" => ["Böse", "Überraschung"] -// "Two spaces" => ["Two", " ", "spaces"] -// "BadUTF8\xe2\xe2\xa1" => ["BadUTF8\xe2\xe2\xa1"] +// "" => [""] +// "lowercase" => ["lowercase"] +// "Class" => ["Class"] +// "MyClass" => ["My", "Class"] +// "MyC" => ["My", "C"] +// "HTML" => ["HTML"] +// "PDFLoader" => ["PDF", "Loader"] +// "AString" => ["A", "String"] +// "SimpleXMLParser" => ["Simple", "XML", "Parser"] +// "vimRPCPlugin" => ["vim", "RPC", "Plugin"] +// "GL11Version" => ["GL11", "Version"] +// "99Bottles" => ["99", "Bottles"] +// "May5" => ["May5"] +// "BFG9000" => ["BFG9000"] +// "BöseÜberraschung" => ["Böse", "Überraschung"] +// "Two spaces" => ["Two", " ", "spaces"] +// "BadUTF8\xe2\xe2\xa1" => ["BadUTF8\xe2\xe2\xa1"] // // Splitting rules // -// 1) If string is not valid UTF-8, return it without splitting as +// 1. If string is not valid UTF-8, return it without splitting as // single item array. -// 2) Assign all unicode characters into one of 4 sets: lower case +// 2. Assign all unicode characters into one of 4 sets: lower case // letters, upper case letters, numbers, and all other characters. -// 3) Iterate through characters of string, introducing splits +// 3. Iterate through characters of string, introducing splits // between adjacent characters that belong to different sets. -// 4) Iterate through array of split strings, and if a given string +// 4. Iterate through array of split strings, and if a given string // is upper case: -// if subsequent string is lower case: -// move last character of upper case string to beginning of -// lower case string +// if subsequent string is lower case: +// move last character of upper case string to beginning of +// lower case string func split(src string) (entries []string) { // don't split invalid utf8 if !utf8.ValidString(src) { diff --git a/camelcase_test.go b/camelcase_test.go index 855690a..93d06c9 100644 --- a/camelcase_test.go +++ b/camelcase_test.go @@ -2,7 +2,7 @@ // // The MIT License (MIT) // -// Copyright (c) 2015 Fatih Arslan +// # Copyright (c) 2015 Fatih Arslan // // Permission is hereby granted, free of charge, to any person obtaining a copy of // this software and associated documentation files (the "Software"), to deal in diff --git a/cmd/genvalues/main.go b/cmd/genvalues/main.go index 6a18615..8fc17bc 100644 --- a/cmd/genvalues/main.go +++ b/cmd/genvalues/main.go @@ -15,6 +15,9 @@ import ( "text/template" "unicode" "unicode/utf8" + + "golang.org/x/text/cases" + "golang.org/x/text/language" ) const ( @@ -36,14 +39,14 @@ var MapAllowedKinds = []reflect.Kind{ \nn } func parseGenerated(value interface{}) Value { - switch value.(type) { + switch v := value.(type) { {{range .Values}}{{ if eq (.|InterfereType) (.Type) }}\nn case *{{.Type}}: - return new{{.|Name}}Value(value.(*{{.Type}})) + return new{{.|Name}}Value(v) {{ end }}{{ end }}\nn {{range .Values}}{{ if not .NoSlice }}\nn case *[]{{.Type}}: - return new{{.|Plural}}Value(value.(*[]{{.Type}})) + return new{{.|Plural}}Value(v) {{end}}{{end}}\nn default: return nil @@ -51,10 +54,10 @@ func parseGenerated(value interface{}) Value { } func parseGeneratedPtrs(value interface{}) Value { - switch value.(type) { + switch v := value.(type) { {{range .Values}}{{ if ne (.|InterfereType) (.Type) }}\nn case *{{.Type}}: - return new{{.|Name}}Value(value.(*{{.Type}})) + return new{{.|Name}}Value(v) {{end}}{{end}}\nn default: return nil @@ -62,11 +65,11 @@ func parseGeneratedPtrs(value interface{}) Value { } func parseGeneratedMap(value interface{}) Value { - switch value.(type) { + switch v := value.(type) { {{range .Values}}{{ if not .NoMap }}\nn {{ $value := . }}{{range $mapKeyTypes}}\nn case *map[{{.}}]{{$value.Type}}: - return new{{MapValueName $value . | Title}}(value.(*map[{{.}}]{{$value.Type}})) + return new{{MapValueName $value . | Title}}(v) {{end}}{{end}}{{end}}\nn default: return nil @@ -523,11 +526,13 @@ func main() { err = json.NewDecoder(r).Decode(&values) fatalIfError(err) + caser := cases.Title(language.English, cases.NoLower) + valueName := func(v *value) string { if v.Name != "" { - return strings.Title(v.Name) + return caser.String(v.Name) } - return strings.Title(v.Type) + return caser.String(v.Type) } imports := []string{} for _, value := range values { @@ -536,7 +541,7 @@ func main() { baseT := template.New("genvalues").Funcs(template.FuncMap{ "Lower": strings.ToLower, - "Title": strings.Title, + "Title": caser.String, "Format": func(v *value) string { if v.Format != "" { return v.Format @@ -679,37 +684,37 @@ func camelToLower(s string) string { // // Examples // -// "" => [""] -// "lowercase" => ["lowercase"] -// "Class" => ["Class"] -// "MyClass" => ["My", "Class"] -// "MyC" => ["My", "C"] -// "HTML" => ["HTML"] -// "PDFLoader" => ["PDF", "Loader"] -// "AString" => ["A", "String"] -// "SimpleXMLParser" => ["Simple", "XML", "Parser"] -// "vimRPCPlugin" => ["vim", "RPC", "Plugin"] -// "GL11Version" => ["GL", "11", "Version"] -// "99Bottles" => ["99", "Bottles"] -// "May5" => ["May", "5"] -// "BFG9000" => ["BFG", "9000"] -// "BöseÜberraschung" => ["Böse", "Überraschung"] -// "Two spaces" => ["Two", " ", "spaces"] -// "BadUTF8\xe2\xe2\xa1" => ["BadUTF8\xe2\xe2\xa1"] +// "" => [""] +// "lowercase" => ["lowercase"] +// "Class" => ["Class"] +// "MyClass" => ["My", "Class"] +// "MyC" => ["My", "C"] +// "HTML" => ["HTML"] +// "PDFLoader" => ["PDF", "Loader"] +// "AString" => ["A", "String"] +// "SimpleXMLParser" => ["Simple", "XML", "Parser"] +// "vimRPCPlugin" => ["vim", "RPC", "Plugin"] +// "GL11Version" => ["GL", "11", "Version"] +// "99Bottles" => ["99", "Bottles"] +// "May5" => ["May", "5"] +// "BFG9000" => ["BFG", "9000"] +// "BöseÜberraschung" => ["Böse", "Überraschung"] +// "Two spaces" => ["Two", " ", "spaces"] +// "BadUTF8\xe2\xe2\xa1" => ["BadUTF8\xe2\xe2\xa1"] // // Splitting rules // -// 1) If string is not valid UTF-8, return it without splitting as +// 1. If string is not valid UTF-8, return it without splitting as // single item array. -// 2) Assign all unicode characters into one of 4 sets: lower case +// 2. Assign all unicode characters into one of 4 sets: lower case // letters, upper case letters, numbers, and all other characters. -// 3) Iterate through characters of string, introducing splits +// 3. Iterate through characters of string, introducing splits // between adjacent characters that belong to different sets. -// 4) Iterate through array of split strings, and if a given string +// 4. Iterate through array of split strings, and if a given string // is upper case: -// if subsequent string is lower case: -// move last character of upper case string to beginning of -// lower case string +// if subsequent string is lower case: +// move last character of upper case string to beginning of +// lower case string func split(src string) (entries []string) { // don't split invalid utf8 if !utf8.ValidString(src) { diff --git a/examples/kingpin/main.go b/examples/kingpin/main.go index 1c05e41..7168170 100644 --- a/examples/kingpin/main.go +++ b/examples/kingpin/main.go @@ -9,7 +9,7 @@ import ( "regexp" "time" - "github.com/alecthomas/kingpin" + "github.com/alecthomas/kingpin/v2" "github.com/davecgh/go-spew/spew" "github.com/octago/sflags" "github.com/octago/sflags/gen/gkingpin" diff --git a/examples/urfave_cli/main.go b/examples/urfave_cli/main.go index 8ff5627..df9b7fc 100644 --- a/examples/urfave_cli/main.go +++ b/examples/urfave_cli/main.go @@ -12,7 +12,7 @@ import ( "github.com/davecgh/go-spew/spew" "github.com/octago/sflags" "github.com/octago/sflags/gen/gcli" - "github.com/urfave/cli" + "github.com/urfave/cli/v2" ) type httpConfig struct { diff --git a/gen/gcli/gcli.go b/gen/gcli/gcli.go index bdec56f..7202d83 100644 --- a/gen/gcli/gcli.go +++ b/gen/gcli/gcli.go @@ -2,7 +2,7 @@ package gcli import ( "github.com/octago/sflags" - "github.com/urfave/cli" + "github.com/urfave/cli/v2" ) // GenerateTo takes a list of sflag.Flag, @@ -10,15 +10,17 @@ import ( func GenerateTo(src []*sflags.Flag, dst *[]cli.Flag) { for _, srcFlag := range src { name := srcFlag.Name + var aliases []string if srcFlag.Short != "" { - name += ", " + srcFlag.Short + aliases = append(aliases, srcFlag.Short) } *dst = append(*dst, &cli.GenericFlag{ - Name: name, - EnvVar: srcFlag.EnvName, - Hidden: srcFlag.Hidden, - Usage: srcFlag.Usage, - Value: srcFlag.Value, + Name: name, + EnvVars: []string{srcFlag.EnvName}, + Aliases: aliases, + Hidden: srcFlag.Hidden, + Usage: srcFlag.Usage, + Value: srcFlag.Value, }) } } diff --git a/gen/gcli/gcli_test.go b/gen/gcli/gcli_test.go index 205634c..e0c50f8 100644 --- a/gen/gcli/gcli_test.go +++ b/gen/gcli/gcli_test.go @@ -2,13 +2,13 @@ package gcli import ( "errors" - "io/ioutil" + "io" "testing" "github.com/octago/sflags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - "github.com/urfave/cli" + "github.com/urfave/cli/v2" ) type cfg1 struct { @@ -131,7 +131,8 @@ func TestParse(t *testing.T) { cliApp.Action = func(c *cli.Context) error { return nil } - cli.ErrWriter = ioutil.Discard + cliApp.UseShortOptionHandling = true + cli.ErrWriter = io.Discard cliApp.OnUsageError = func(_ *cli.Context, err error, _ bool) error { return err } diff --git a/gen/gcli/gcliv3.go b/gen/gcli/gcliv3.go new file mode 100644 index 0000000..2eef94e --- /dev/null +++ b/gen/gcli/gcliv3.go @@ -0,0 +1,75 @@ +package gcli + +import ( + "github.com/octago/sflags" + "github.com/urfave/cli/v3" +) + +type boolFlag interface { + IsBoolFlag() bool +} + +type value struct { + v sflags.Value +} + +func (v value) Get() any { + return v.v +} + +func (v value) Set(s string) error { + return v.v.Set(s) +} + +func (v value) String() string { + return v.v.String() +} + +func (v value) IsBoolFlag() bool { + b, ok := v.v.(boolFlag) + return ok && b.IsBoolFlag() +} + +// GenerateToV3 takes a list of sflag.Flag, +// that are parsed from some config structure, and put it to dst. +func GenerateToV3(src []*sflags.Flag, dst *[]cli.Flag) { + for _, srcFlag := range src { + name := srcFlag.Name + var aliases []string + if srcFlag.Short != "" { + aliases = append(aliases, srcFlag.Short) + } + *dst = append(*dst, &cli.GenericFlag{ + Name: name, + Sources: cli.EnvVars(srcFlag.EnvName), + Aliases: aliases, + Hidden: srcFlag.Hidden, + Usage: srcFlag.Usage, + Value: &value{ + v: srcFlag.Value, + }, + }) + } +} + +// ParseToV3 parses cfg, that is a pointer to some structure, +// and puts it to dst. +func ParseToV3(cfg interface{}, dst *[]cli.Flag, optFuncs ...sflags.OptFunc) error { + flags, err := sflags.ParseStruct(cfg, optFuncs...) + if err != nil { + return err + } + GenerateToV3(flags, dst) + return nil +} + +// ParseV3 parses cfg, that is a pointer to some structure, +// puts it to the new flag.FlagSet and returns it. +func ParseV3(cfg interface{}, optFuncs ...sflags.OptFunc) ([]cli.Flag, error) { + flags := make([]cli.Flag, 0) + err := ParseToV3(cfg, &flags, optFuncs...) + if err != nil { + return nil, err + } + return flags, nil +} diff --git a/gen/gcli/gcliv3_test.go b/gen/gcli/gcliv3_test.go new file mode 100644 index 0000000..386fa73 --- /dev/null +++ b/gen/gcli/gcliv3_test.go @@ -0,0 +1,156 @@ +package gcli + +import ( + "context" + "errors" + "io" + "testing" + + "github.com/octago/sflags" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "github.com/urfave/cli/v3" +) + +type cfg2 struct { + StringValue1 string + StringValue2 string `flag:"string-value-two s"` + + CounterValue1 sflags.Counter + + StringSliceValue1 []string +} + +func TestParseV3(t *testing.T) { + tests := []struct { + name string + + cfg interface{} + args []string + expCfg interface{} + expErr1 error // sflag Parse error + expErr2 error // cli Parse error + }{ + { + name: "Test cfg2", + cfg: &cfg2{ + StringValue1: "string_value1_value", + StringValue2: "string_value2_value", + + CounterValue1: 1, + + StringSliceValue1: []string{"one", "two"}, + }, + expCfg: &cfg2{ + StringValue1: "string_value1_value2", + StringValue2: "string_value2_value2", + + CounterValue1: 3, + + StringSliceValue1: []string{ + "one2", "two2", "three", "4"}, + }, + args: []string{ + "--string-value1", "string_value1_value2", + "--string-value-two", "string_value2_value2", + "--counter-value1", "--counter-value1", + "--string-slice-value1", "one2", + "--string-slice-value1", "two2", + "--string-slice-value1", "three,4", + }, + }, + { + name: "Test cfg2 no args", + cfg: &cfg2{ + StringValue1: "string_value1_value", + StringValue2: "", + }, + expCfg: &cfg2{ + StringValue1: "string_value1_value", + StringValue2: "", + }, + args: []string{}, + }, + { + name: "Test cfg2 short option", + cfg: &cfg2{ + StringValue2: "string_value2_value", + }, + expCfg: &cfg2{ + StringValue2: "string_value2_value2", + }, + args: []string{ + "-s=string_value2_value2", + }, + }, + { + name: "Test cfg2 without default values", + cfg: &cfg2{}, + expCfg: &cfg2{ + StringValue1: "string_value1_value2", + StringValue2: "string_value2_value2", + + CounterValue1: 3, + }, + args: []string{ + "--string-value1", "string_value1_value2", + "--string-value-two", "string_value2_value2", + "--counter-value1=2", "--counter-value1", + }, + }, + { + name: "Test cfg2 bad option", + cfg: &cfg2{ + StringValue1: "string_value1_value", + }, + args: []string{ + "--bad-value=string_value1_value2", + }, + expErr2: errors.New("flag provided but not defined: -bad-value"), + }, + { + name: "Test bad cfg value", + cfg: "bad config", + expErr1: errors.New("object must be a pointer to struct or interface"), + }, + } + // forbid urfave/cli to exit + cli.OsExiter = func(i int) {} + for _, test := range tests { + t.Run(test.name, func(t *testing.T) { + flags, err := ParseV3(test.cfg) + if test.expErr1 != nil { + require.Error(t, err) + require.Equal(t, test.expErr1, err) + } else { + require.NoError(t, err) + } + if err != nil { + return + } + cmd := &cli.Command{} + cmd.Action = func(_ context.Context, c *cli.Command) error { + return nil + } + cmd.UseShortOptionHandling = true + cli.ErrWriter = io.Discard + cmd.OnUsageError = func(ctx context.Context, cmd *cli.Command, err error, isSubcommand bool) error { + return err + } + + cmd.Flags = flags + args := append([]string{"cliApp"}, test.args...) + err = cmd.Run(context.Background(), args) + if test.expErr2 != nil { + require.Error(t, err) + require.Equal(t, test.expErr2, err) + } else { + require.NoError(t, err) + } + if err != nil { + return + } + assert.Equal(t, test.expCfg, test.cfg) + }) + } +} diff --git a/gen/gkingpin/gkingpin.go b/gen/gkingpin/gkingpin.go index 314269f..0712418 100644 --- a/gen/gkingpin/gkingpin.go +++ b/gen/gkingpin/gkingpin.go @@ -3,7 +3,7 @@ package gkingpin import ( "unicode/utf8" - "github.com/alecthomas/kingpin" + "github.com/alecthomas/kingpin/v2" "github.com/octago/sflags" ) @@ -15,10 +15,6 @@ type flagger interface { // that are parsed from some config structure, and put it to dst. func GenerateTo(src []*sflags.Flag, dst flagger) { for _, srcFlag := range src { - name := srcFlag.Name - if srcFlag.Short != "" { - name += ", " + srcFlag.Short - } flag := dst.Flag(srcFlag.Name, srcFlag.Usage) flag.SetValue(srcFlag.Value) if srcFlag.EnvName != "" { diff --git a/gen/gkingpin/gkingpin_test.go b/gen/gkingpin/gkingpin_test.go index e0b339b..a713165 100644 --- a/gen/gkingpin/gkingpin_test.go +++ b/gen/gkingpin/gkingpin_test.go @@ -4,7 +4,7 @@ import ( "errors" "testing" - "github.com/alecthomas/kingpin" + "github.com/alecthomas/kingpin/v2" "github.com/octago/sflags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" diff --git a/gen/gpflag/gpflag_test.go b/gen/gpflag/gpflag_test.go index 56efc06..96cc851 100644 --- a/gen/gpflag/gpflag_test.go +++ b/gen/gpflag/gpflag_test.go @@ -2,7 +2,7 @@ package gpflag import ( "errors" - "io/ioutil" + "io" "net" "os" "testing" @@ -130,7 +130,7 @@ func TestParse(t *testing.T) { return } fs.Init("pflagTest", pflag.ContinueOnError) - fs.SetOutput(ioutil.Discard) + fs.SetOutput(io.Discard) err = fs.Parse(test.args) if test.expErr2 != nil { require.Error(t, err) diff --git a/go.mod b/go.mod index a4bee3b..607b158 100644 --- a/go.mod +++ b/go.mod @@ -1,14 +1,26 @@ module github.com/octago/sflags +go 1.21.5 + require ( - github.com/alecthomas/kingpin v2.2.6+incompatible - github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc // indirect - github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf // indirect + github.com/alecthomas/kingpin/v2 v2.4.0 github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf github.com/davecgh/go-spew v1.1.1 - github.com/octago/sflags v0.2.0 github.com/spf13/cobra v0.0.3 github.com/spf13/pflag v1.0.3 - github.com/stretchr/testify v1.3.0 - github.com/urfave/cli v1.20.0 + github.com/stretchr/testify v1.9.0 + github.com/urfave/cli/v2 v2.27.5 + github.com/urfave/cli/v3 v3.0.0-alpha9.3 + golang.org/x/text v0.19.0 +) + +require ( + github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 // indirect + github.com/cpuguy83/go-md2man/v2 v2.0.5 // indirect + github.com/inconshreveable/mousetrap v1.1.0 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/russross/blackfriday/v2 v2.1.0 // indirect + github.com/xhit/go-str2duration/v2 v2.1.0 // indirect + github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 7ba1a45..7c2e937 100644 --- a/go.sum +++ b/go.sum @@ -1,19 +1,40 @@ -github.com/alecthomas/kingpin v2.2.6+incompatible h1:5svnBTFgJjZvGKyYBtMB0+m5wvrbUHiqye8wRJMlnYI= -github.com/alecthomas/kingpin v2.2.6+incompatible/go.mod h1:59OFYbFVLKQKq+mqrL6Rw5bR0c3ACQaawgXx0QYndlE= -github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= -github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/alecthomas/kingpin/v2 v2.4.0 h1:f48lwail6p8zpO1bC4TxtqACaGqHYA22qkHjHpqDjYY= +github.com/alecthomas/kingpin/v2 v2.4.0/go.mod h1:0gyi0zQnjuFk8xrkNKamJoyUo382HRL7ATRpFZCw6tE= +github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137 h1:s6gZFSlWYmbqAuRjVTiNNhvNRfY2Wxp9nhfyel4rklc= +github.com/alecthomas/units v0.0.0-20211218093645-b94a6e3cc137/go.mod h1:OMCwj8VM1Kc9e19TLln2VL61YJF0x1XFtfdL4JdbSyE= github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf h1:eg0MeVzsP1G42dRafH3vf+al2vQIJU0YHX+1Tw87oco= github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= +github.com/cpuguy83/go-md2man/v2 v2.0.5 h1:ZtcqGrnekaHpVLArFSe4HK5DoKx1T0rq2DwVB0alcyc= +github.com/cpuguy83/go-md2man/v2 v2.0.5/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/octago/sflags v0.2.0 h1:XceYzkRXGAHa/lSFmKLcaxSrsh4MTuOMQdIGsUD0wlk= -github.com/octago/sflags v0.2.0/go.mod h1:G0bjdxh4qPRycF74a2B8pU36iTp9QHGx0w0dFZXPt80= +github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8= +github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= +github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8= github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg= github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= -github.com/urfave/cli v1.20.0 h1:fDqGv3UG/4jbVl/QkFwEdddtEDjh/5Ov6X+0B/3bPaw= -github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= +github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= +github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/urfave/cli/v2 v2.27.5 h1:WoHEJLdsXr6dDWoJgMq/CboDmyY/8HMMH1fTECbih+w= +github.com/urfave/cli/v2 v2.27.5/go.mod h1:3Sevf16NykTbInEnD0yKkjDAeZDS0A6bzhBH5hrMvTQ= +github.com/urfave/cli/v3 v3.0.0-alpha9.3 h1:RfQlgUHMRxDMwEEmGsrHd+mXYJpWpXlcJM8w86cpjGs= +github.com/urfave/cli/v3 v3.0.0-alpha9.3/go.mod h1:FnIeEMYu+ko8zP1F9Ypr3xkZMIDqW3DR92yUtY39q1Y= +github.com/xhit/go-str2duration/v2 v2.1.0 h1:lxklc02Drh6ynqX+DdPyp5pCKLUQpRT8bp8Ydu2Bstc= +github.com/xhit/go-str2duration/v2 v2.1.0/go.mod h1:ohY8p+0f07DiV6Em5LKB0s2YpLtXVyJfNt1+BlmyAsU= +github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 h1:gEOO8jv9F4OT7lGCjxCBTO/36wtF6j2nSip77qHd4x4= +github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1/go.mod h1:Ohn+xnUBiLI6FVj/9LpzZWtj1/D6lUovWYBkxHVV3aM= +golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM= +golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/validator/govalidator/govalidator.go b/validator/govalidator/govalidator.go index 9243961..13dde8c 100644 --- a/validator/govalidator/govalidator.go +++ b/validator/govalidator/govalidator.go @@ -4,7 +4,7 @@ // // The MIT License (MIT) // -// Copyright (c) 2014 Alex Saskevich +// # Copyright (c) 2014 Alex Saskevich // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal @@ -98,14 +98,14 @@ func validateFunc(val string, options tagOptionsMap) error { var err error if !negate { if customMsgExists { - err = fmt.Errorf(customErrorMessage) + err = fmt.Errorf("%s", customErrorMessage) } else { err = fmt.Errorf("`%s` does not validate as %s", val, validator) } } else { if customMsgExists { - err = fmt.Errorf(customErrorMessage) + err = fmt.Errorf("%s", customErrorMessage) } else { err = fmt.Errorf("`%s` does validate as %s", val, validator) } @@ -123,13 +123,13 @@ func validateFunc(val string, options tagOptionsMap) error { if !negate { if customMsgExists { - err = fmt.Errorf(customErrorMessage) + err = fmt.Errorf("%s", customErrorMessage) } else { err = fmt.Errorf("`%s` does not validate as %s", val, validator) } } else { if customMsgExists { - err = fmt.Errorf(customErrorMessage) + err = fmt.Errorf("%s", customErrorMessage) } else { err = fmt.Errorf("`%s` does validate as %s", val, validator) } diff --git a/validator/govalidator/govalidator_test.go b/validator/govalidator/govalidator_test.go index fea25c5..15bd6af 100644 --- a/validator/govalidator/govalidator_test.go +++ b/validator/govalidator/govalidator_test.go @@ -3,7 +3,7 @@ package govalidator import ( "flag" "fmt" - "io/ioutil" + "io" "log" "testing" @@ -27,7 +27,7 @@ func ExampleNew() { log.Fatalf("err: %v", err) } fs.Init("text", flag.ContinueOnError) - fs.SetOutput(ioutil.Discard) + fs.SetOutput(io.Discard) // if we pass a wrong domain to the host flag, we'll get a error. if err = fs.Parse([]string{"-host", "wrong domain"}); err != nil { diff --git a/values.json b/values.json index 953d2c3..e56ae38 100644 --- a/values.json +++ b/values.json @@ -803,7 +803,7 @@ { "in": "3l", "out": "0s", - "err": "time: unknown unit l in duration 3l" + "err": "time: unknown unit \\\"l\\\" in duration \\\"3l\\\"" } ], "slice_tests": [ @@ -819,7 +819,7 @@ "1s,3l" ], "out": "[]", - "err": "time: unknown unit l in duration 3l" + "err": "time: unknown unit \\\"l\\\" in duration \\\"3l\\\"" } ], "map_tests": [ @@ -833,7 +833,7 @@ "in": [ "3l" ], - "err": "time: unknown unit l in duration 3l" + "err": "time: unknown unit \\\"l\\\" in duration \\\"3l\\\"" } ] }, diff --git a/values_generated.go b/values_generated.go index 9f3cb94..5830016 100644 --- a/values_generated.go +++ b/values_generated.go @@ -30,519 +30,519 @@ var MapAllowedKinds = []reflect.Kind{ } func parseGenerated(value interface{}) Value { - switch value.(type) { + switch v := value.(type) { case *string: - return newStringValue(value.(*string)) + return newStringValue(v) case *bool: - return newBoolValue(value.(*bool)) + return newBoolValue(v) case *uint: - return newUintValue(value.(*uint)) + return newUintValue(v) case *uint8: - return newUint8Value(value.(*uint8)) + return newUint8Value(v) case *uint16: - return newUint16Value(value.(*uint16)) + return newUint16Value(v) case *uint32: - return newUint32Value(value.(*uint32)) + return newUint32Value(v) case *uint64: - return newUint64Value(value.(*uint64)) + return newUint64Value(v) case *int: - return newIntValue(value.(*int)) + return newIntValue(v) case *int8: - return newInt8Value(value.(*int8)) + return newInt8Value(v) case *int16: - return newInt16Value(value.(*int16)) + return newInt16Value(v) case *int32: - return newInt32Value(value.(*int32)) + return newInt32Value(v) case *int64: - return newInt64Value(value.(*int64)) + return newInt64Value(v) case *float64: - return newFloat64Value(value.(*float64)) + return newFloat64Value(v) case *float32: - return newFloat32Value(value.(*float32)) + return newFloat32Value(v) case *time.Duration: - return newDurationValue(value.(*time.Duration)) + return newDurationValue(v) case *net.IP: - return newIPValue(value.(*net.IP)) + return newIPValue(v) case *HexBytes: - return newHexBytesValue(value.(*HexBytes)) + return newHexBytesValue(v) case *net.TCPAddr: - return newTCPAddrValue(value.(*net.TCPAddr)) + return newTCPAddrValue(v) case *net.IPNet: - return newIPNetValue(value.(*net.IPNet)) + return newIPNetValue(v) case *[]string: - return newStringSliceValue(value.(*[]string)) + return newStringSliceValue(v) case *[]bool: - return newBoolSliceValue(value.(*[]bool)) + return newBoolSliceValue(v) case *[]uint: - return newUintSliceValue(value.(*[]uint)) + return newUintSliceValue(v) case *[]uint8: - return newUint8SliceValue(value.(*[]uint8)) + return newUint8SliceValue(v) case *[]uint16: - return newUint16SliceValue(value.(*[]uint16)) + return newUint16SliceValue(v) case *[]uint32: - return newUint32SliceValue(value.(*[]uint32)) + return newUint32SliceValue(v) case *[]uint64: - return newUint64SliceValue(value.(*[]uint64)) + return newUint64SliceValue(v) case *[]int: - return newIntSliceValue(value.(*[]int)) + return newIntSliceValue(v) case *[]int8: - return newInt8SliceValue(value.(*[]int8)) + return newInt8SliceValue(v) case *[]int16: - return newInt16SliceValue(value.(*[]int16)) + return newInt16SliceValue(v) case *[]int32: - return newInt32SliceValue(value.(*[]int32)) + return newInt32SliceValue(v) case *[]int64: - return newInt64SliceValue(value.(*[]int64)) + return newInt64SliceValue(v) case *[]float64: - return newFloat64SliceValue(value.(*[]float64)) + return newFloat64SliceValue(v) case *[]float32: - return newFloat32SliceValue(value.(*[]float32)) + return newFloat32SliceValue(v) case *[]time.Duration: - return newDurationSliceValue(value.(*[]time.Duration)) + return newDurationSliceValue(v) case *[]net.IP: - return newIPSliceValue(value.(*[]net.IP)) + return newIPSliceValue(v) case *[]HexBytes: - return newHexBytesSliceValue(value.(*[]HexBytes)) + return newHexBytesSliceValue(v) case *[]*regexp.Regexp: - return newRegexpSliceValue(value.(*[]*regexp.Regexp)) + return newRegexpSliceValue(v) case *[]net.TCPAddr: - return newTCPAddrSliceValue(value.(*[]net.TCPAddr)) + return newTCPAddrSliceValue(v) case *[]net.IPNet: - return newIPNetSliceValue(value.(*[]net.IPNet)) + return newIPNetSliceValue(v) default: return nil } } func parseGeneratedPtrs(value interface{}) Value { - switch value.(type) { + switch v := value.(type) { case **regexp.Regexp: - return newRegexpValue(value.(**regexp.Regexp)) + return newRegexpValue(v) default: return nil } } func parseGeneratedMap(value interface{}) Value { - switch value.(type) { + switch v := value.(type) { case *map[string]string: - return newStringStringMapValue(value.(*map[string]string)) + return newStringStringMapValue(v) case *map[int]string: - return newIntStringMapValue(value.(*map[int]string)) + return newIntStringMapValue(v) case *map[int8]string: - return newInt8StringMapValue(value.(*map[int8]string)) + return newInt8StringMapValue(v) case *map[int16]string: - return newInt16StringMapValue(value.(*map[int16]string)) + return newInt16StringMapValue(v) case *map[int32]string: - return newInt32StringMapValue(value.(*map[int32]string)) + return newInt32StringMapValue(v) case *map[int64]string: - return newInt64StringMapValue(value.(*map[int64]string)) + return newInt64StringMapValue(v) case *map[uint]string: - return newUintStringMapValue(value.(*map[uint]string)) + return newUintStringMapValue(v) case *map[uint8]string: - return newUint8StringMapValue(value.(*map[uint8]string)) + return newUint8StringMapValue(v) case *map[uint16]string: - return newUint16StringMapValue(value.(*map[uint16]string)) + return newUint16StringMapValue(v) case *map[uint32]string: - return newUint32StringMapValue(value.(*map[uint32]string)) + return newUint32StringMapValue(v) case *map[uint64]string: - return newUint64StringMapValue(value.(*map[uint64]string)) + return newUint64StringMapValue(v) case *map[string]bool: - return newStringBoolMapValue(value.(*map[string]bool)) + return newStringBoolMapValue(v) case *map[int]bool: - return newIntBoolMapValue(value.(*map[int]bool)) + return newIntBoolMapValue(v) case *map[int8]bool: - return newInt8BoolMapValue(value.(*map[int8]bool)) + return newInt8BoolMapValue(v) case *map[int16]bool: - return newInt16BoolMapValue(value.(*map[int16]bool)) + return newInt16BoolMapValue(v) case *map[int32]bool: - return newInt32BoolMapValue(value.(*map[int32]bool)) + return newInt32BoolMapValue(v) case *map[int64]bool: - return newInt64BoolMapValue(value.(*map[int64]bool)) + return newInt64BoolMapValue(v) case *map[uint]bool: - return newUintBoolMapValue(value.(*map[uint]bool)) + return newUintBoolMapValue(v) case *map[uint8]bool: - return newUint8BoolMapValue(value.(*map[uint8]bool)) + return newUint8BoolMapValue(v) case *map[uint16]bool: - return newUint16BoolMapValue(value.(*map[uint16]bool)) + return newUint16BoolMapValue(v) case *map[uint32]bool: - return newUint32BoolMapValue(value.(*map[uint32]bool)) + return newUint32BoolMapValue(v) case *map[uint64]bool: - return newUint64BoolMapValue(value.(*map[uint64]bool)) + return newUint64BoolMapValue(v) case *map[string]uint: - return newStringUintMapValue(value.(*map[string]uint)) + return newStringUintMapValue(v) case *map[int]uint: - return newIntUintMapValue(value.(*map[int]uint)) + return newIntUintMapValue(v) case *map[int8]uint: - return newInt8UintMapValue(value.(*map[int8]uint)) + return newInt8UintMapValue(v) case *map[int16]uint: - return newInt16UintMapValue(value.(*map[int16]uint)) + return newInt16UintMapValue(v) case *map[int32]uint: - return newInt32UintMapValue(value.(*map[int32]uint)) + return newInt32UintMapValue(v) case *map[int64]uint: - return newInt64UintMapValue(value.(*map[int64]uint)) + return newInt64UintMapValue(v) case *map[uint]uint: - return newUintUintMapValue(value.(*map[uint]uint)) + return newUintUintMapValue(v) case *map[uint8]uint: - return newUint8UintMapValue(value.(*map[uint8]uint)) + return newUint8UintMapValue(v) case *map[uint16]uint: - return newUint16UintMapValue(value.(*map[uint16]uint)) + return newUint16UintMapValue(v) case *map[uint32]uint: - return newUint32UintMapValue(value.(*map[uint32]uint)) + return newUint32UintMapValue(v) case *map[uint64]uint: - return newUint64UintMapValue(value.(*map[uint64]uint)) + return newUint64UintMapValue(v) case *map[string]uint8: - return newStringUint8MapValue(value.(*map[string]uint8)) + return newStringUint8MapValue(v) case *map[int]uint8: - return newIntUint8MapValue(value.(*map[int]uint8)) + return newIntUint8MapValue(v) case *map[int8]uint8: - return newInt8Uint8MapValue(value.(*map[int8]uint8)) + return newInt8Uint8MapValue(v) case *map[int16]uint8: - return newInt16Uint8MapValue(value.(*map[int16]uint8)) + return newInt16Uint8MapValue(v) case *map[int32]uint8: - return newInt32Uint8MapValue(value.(*map[int32]uint8)) + return newInt32Uint8MapValue(v) case *map[int64]uint8: - return newInt64Uint8MapValue(value.(*map[int64]uint8)) + return newInt64Uint8MapValue(v) case *map[uint]uint8: - return newUintUint8MapValue(value.(*map[uint]uint8)) + return newUintUint8MapValue(v) case *map[uint8]uint8: - return newUint8Uint8MapValue(value.(*map[uint8]uint8)) + return newUint8Uint8MapValue(v) case *map[uint16]uint8: - return newUint16Uint8MapValue(value.(*map[uint16]uint8)) + return newUint16Uint8MapValue(v) case *map[uint32]uint8: - return newUint32Uint8MapValue(value.(*map[uint32]uint8)) + return newUint32Uint8MapValue(v) case *map[uint64]uint8: - return newUint64Uint8MapValue(value.(*map[uint64]uint8)) + return newUint64Uint8MapValue(v) case *map[string]uint16: - return newStringUint16MapValue(value.(*map[string]uint16)) + return newStringUint16MapValue(v) case *map[int]uint16: - return newIntUint16MapValue(value.(*map[int]uint16)) + return newIntUint16MapValue(v) case *map[int8]uint16: - return newInt8Uint16MapValue(value.(*map[int8]uint16)) + return newInt8Uint16MapValue(v) case *map[int16]uint16: - return newInt16Uint16MapValue(value.(*map[int16]uint16)) + return newInt16Uint16MapValue(v) case *map[int32]uint16: - return newInt32Uint16MapValue(value.(*map[int32]uint16)) + return newInt32Uint16MapValue(v) case *map[int64]uint16: - return newInt64Uint16MapValue(value.(*map[int64]uint16)) + return newInt64Uint16MapValue(v) case *map[uint]uint16: - return newUintUint16MapValue(value.(*map[uint]uint16)) + return newUintUint16MapValue(v) case *map[uint8]uint16: - return newUint8Uint16MapValue(value.(*map[uint8]uint16)) + return newUint8Uint16MapValue(v) case *map[uint16]uint16: - return newUint16Uint16MapValue(value.(*map[uint16]uint16)) + return newUint16Uint16MapValue(v) case *map[uint32]uint16: - return newUint32Uint16MapValue(value.(*map[uint32]uint16)) + return newUint32Uint16MapValue(v) case *map[uint64]uint16: - return newUint64Uint16MapValue(value.(*map[uint64]uint16)) + return newUint64Uint16MapValue(v) case *map[string]uint32: - return newStringUint32MapValue(value.(*map[string]uint32)) + return newStringUint32MapValue(v) case *map[int]uint32: - return newIntUint32MapValue(value.(*map[int]uint32)) + return newIntUint32MapValue(v) case *map[int8]uint32: - return newInt8Uint32MapValue(value.(*map[int8]uint32)) + return newInt8Uint32MapValue(v) case *map[int16]uint32: - return newInt16Uint32MapValue(value.(*map[int16]uint32)) + return newInt16Uint32MapValue(v) case *map[int32]uint32: - return newInt32Uint32MapValue(value.(*map[int32]uint32)) + return newInt32Uint32MapValue(v) case *map[int64]uint32: - return newInt64Uint32MapValue(value.(*map[int64]uint32)) + return newInt64Uint32MapValue(v) case *map[uint]uint32: - return newUintUint32MapValue(value.(*map[uint]uint32)) + return newUintUint32MapValue(v) case *map[uint8]uint32: - return newUint8Uint32MapValue(value.(*map[uint8]uint32)) + return newUint8Uint32MapValue(v) case *map[uint16]uint32: - return newUint16Uint32MapValue(value.(*map[uint16]uint32)) + return newUint16Uint32MapValue(v) case *map[uint32]uint32: - return newUint32Uint32MapValue(value.(*map[uint32]uint32)) + return newUint32Uint32MapValue(v) case *map[uint64]uint32: - return newUint64Uint32MapValue(value.(*map[uint64]uint32)) + return newUint64Uint32MapValue(v) case *map[string]uint64: - return newStringUint64MapValue(value.(*map[string]uint64)) + return newStringUint64MapValue(v) case *map[int]uint64: - return newIntUint64MapValue(value.(*map[int]uint64)) + return newIntUint64MapValue(v) case *map[int8]uint64: - return newInt8Uint64MapValue(value.(*map[int8]uint64)) + return newInt8Uint64MapValue(v) case *map[int16]uint64: - return newInt16Uint64MapValue(value.(*map[int16]uint64)) + return newInt16Uint64MapValue(v) case *map[int32]uint64: - return newInt32Uint64MapValue(value.(*map[int32]uint64)) + return newInt32Uint64MapValue(v) case *map[int64]uint64: - return newInt64Uint64MapValue(value.(*map[int64]uint64)) + return newInt64Uint64MapValue(v) case *map[uint]uint64: - return newUintUint64MapValue(value.(*map[uint]uint64)) + return newUintUint64MapValue(v) case *map[uint8]uint64: - return newUint8Uint64MapValue(value.(*map[uint8]uint64)) + return newUint8Uint64MapValue(v) case *map[uint16]uint64: - return newUint16Uint64MapValue(value.(*map[uint16]uint64)) + return newUint16Uint64MapValue(v) case *map[uint32]uint64: - return newUint32Uint64MapValue(value.(*map[uint32]uint64)) + return newUint32Uint64MapValue(v) case *map[uint64]uint64: - return newUint64Uint64MapValue(value.(*map[uint64]uint64)) + return newUint64Uint64MapValue(v) case *map[string]int: - return newStringIntMapValue(value.(*map[string]int)) + return newStringIntMapValue(v) case *map[int]int: - return newIntIntMapValue(value.(*map[int]int)) + return newIntIntMapValue(v) case *map[int8]int: - return newInt8IntMapValue(value.(*map[int8]int)) + return newInt8IntMapValue(v) case *map[int16]int: - return newInt16IntMapValue(value.(*map[int16]int)) + return newInt16IntMapValue(v) case *map[int32]int: - return newInt32IntMapValue(value.(*map[int32]int)) + return newInt32IntMapValue(v) case *map[int64]int: - return newInt64IntMapValue(value.(*map[int64]int)) + return newInt64IntMapValue(v) case *map[uint]int: - return newUintIntMapValue(value.(*map[uint]int)) + return newUintIntMapValue(v) case *map[uint8]int: - return newUint8IntMapValue(value.(*map[uint8]int)) + return newUint8IntMapValue(v) case *map[uint16]int: - return newUint16IntMapValue(value.(*map[uint16]int)) + return newUint16IntMapValue(v) case *map[uint32]int: - return newUint32IntMapValue(value.(*map[uint32]int)) + return newUint32IntMapValue(v) case *map[uint64]int: - return newUint64IntMapValue(value.(*map[uint64]int)) + return newUint64IntMapValue(v) case *map[string]int8: - return newStringInt8MapValue(value.(*map[string]int8)) + return newStringInt8MapValue(v) case *map[int]int8: - return newIntInt8MapValue(value.(*map[int]int8)) + return newIntInt8MapValue(v) case *map[int8]int8: - return newInt8Int8MapValue(value.(*map[int8]int8)) + return newInt8Int8MapValue(v) case *map[int16]int8: - return newInt16Int8MapValue(value.(*map[int16]int8)) + return newInt16Int8MapValue(v) case *map[int32]int8: - return newInt32Int8MapValue(value.(*map[int32]int8)) + return newInt32Int8MapValue(v) case *map[int64]int8: - return newInt64Int8MapValue(value.(*map[int64]int8)) + return newInt64Int8MapValue(v) case *map[uint]int8: - return newUintInt8MapValue(value.(*map[uint]int8)) + return newUintInt8MapValue(v) case *map[uint8]int8: - return newUint8Int8MapValue(value.(*map[uint8]int8)) + return newUint8Int8MapValue(v) case *map[uint16]int8: - return newUint16Int8MapValue(value.(*map[uint16]int8)) + return newUint16Int8MapValue(v) case *map[uint32]int8: - return newUint32Int8MapValue(value.(*map[uint32]int8)) + return newUint32Int8MapValue(v) case *map[uint64]int8: - return newUint64Int8MapValue(value.(*map[uint64]int8)) + return newUint64Int8MapValue(v) case *map[string]int16: - return newStringInt16MapValue(value.(*map[string]int16)) + return newStringInt16MapValue(v) case *map[int]int16: - return newIntInt16MapValue(value.(*map[int]int16)) + return newIntInt16MapValue(v) case *map[int8]int16: - return newInt8Int16MapValue(value.(*map[int8]int16)) + return newInt8Int16MapValue(v) case *map[int16]int16: - return newInt16Int16MapValue(value.(*map[int16]int16)) + return newInt16Int16MapValue(v) case *map[int32]int16: - return newInt32Int16MapValue(value.(*map[int32]int16)) + return newInt32Int16MapValue(v) case *map[int64]int16: - return newInt64Int16MapValue(value.(*map[int64]int16)) + return newInt64Int16MapValue(v) case *map[uint]int16: - return newUintInt16MapValue(value.(*map[uint]int16)) + return newUintInt16MapValue(v) case *map[uint8]int16: - return newUint8Int16MapValue(value.(*map[uint8]int16)) + return newUint8Int16MapValue(v) case *map[uint16]int16: - return newUint16Int16MapValue(value.(*map[uint16]int16)) + return newUint16Int16MapValue(v) case *map[uint32]int16: - return newUint32Int16MapValue(value.(*map[uint32]int16)) + return newUint32Int16MapValue(v) case *map[uint64]int16: - return newUint64Int16MapValue(value.(*map[uint64]int16)) + return newUint64Int16MapValue(v) case *map[string]int32: - return newStringInt32MapValue(value.(*map[string]int32)) + return newStringInt32MapValue(v) case *map[int]int32: - return newIntInt32MapValue(value.(*map[int]int32)) + return newIntInt32MapValue(v) case *map[int8]int32: - return newInt8Int32MapValue(value.(*map[int8]int32)) + return newInt8Int32MapValue(v) case *map[int16]int32: - return newInt16Int32MapValue(value.(*map[int16]int32)) + return newInt16Int32MapValue(v) case *map[int32]int32: - return newInt32Int32MapValue(value.(*map[int32]int32)) + return newInt32Int32MapValue(v) case *map[int64]int32: - return newInt64Int32MapValue(value.(*map[int64]int32)) + return newInt64Int32MapValue(v) case *map[uint]int32: - return newUintInt32MapValue(value.(*map[uint]int32)) + return newUintInt32MapValue(v) case *map[uint8]int32: - return newUint8Int32MapValue(value.(*map[uint8]int32)) + return newUint8Int32MapValue(v) case *map[uint16]int32: - return newUint16Int32MapValue(value.(*map[uint16]int32)) + return newUint16Int32MapValue(v) case *map[uint32]int32: - return newUint32Int32MapValue(value.(*map[uint32]int32)) + return newUint32Int32MapValue(v) case *map[uint64]int32: - return newUint64Int32MapValue(value.(*map[uint64]int32)) + return newUint64Int32MapValue(v) case *map[string]int64: - return newStringInt64MapValue(value.(*map[string]int64)) + return newStringInt64MapValue(v) case *map[int]int64: - return newIntInt64MapValue(value.(*map[int]int64)) + return newIntInt64MapValue(v) case *map[int8]int64: - return newInt8Int64MapValue(value.(*map[int8]int64)) + return newInt8Int64MapValue(v) case *map[int16]int64: - return newInt16Int64MapValue(value.(*map[int16]int64)) + return newInt16Int64MapValue(v) case *map[int32]int64: - return newInt32Int64MapValue(value.(*map[int32]int64)) + return newInt32Int64MapValue(v) case *map[int64]int64: - return newInt64Int64MapValue(value.(*map[int64]int64)) + return newInt64Int64MapValue(v) case *map[uint]int64: - return newUintInt64MapValue(value.(*map[uint]int64)) + return newUintInt64MapValue(v) case *map[uint8]int64: - return newUint8Int64MapValue(value.(*map[uint8]int64)) + return newUint8Int64MapValue(v) case *map[uint16]int64: - return newUint16Int64MapValue(value.(*map[uint16]int64)) + return newUint16Int64MapValue(v) case *map[uint32]int64: - return newUint32Int64MapValue(value.(*map[uint32]int64)) + return newUint32Int64MapValue(v) case *map[uint64]int64: - return newUint64Int64MapValue(value.(*map[uint64]int64)) + return newUint64Int64MapValue(v) case *map[string]float64: - return newStringFloat64MapValue(value.(*map[string]float64)) + return newStringFloat64MapValue(v) case *map[int]float64: - return newIntFloat64MapValue(value.(*map[int]float64)) + return newIntFloat64MapValue(v) case *map[int8]float64: - return newInt8Float64MapValue(value.(*map[int8]float64)) + return newInt8Float64MapValue(v) case *map[int16]float64: - return newInt16Float64MapValue(value.(*map[int16]float64)) + return newInt16Float64MapValue(v) case *map[int32]float64: - return newInt32Float64MapValue(value.(*map[int32]float64)) + return newInt32Float64MapValue(v) case *map[int64]float64: - return newInt64Float64MapValue(value.(*map[int64]float64)) + return newInt64Float64MapValue(v) case *map[uint]float64: - return newUintFloat64MapValue(value.(*map[uint]float64)) + return newUintFloat64MapValue(v) case *map[uint8]float64: - return newUint8Float64MapValue(value.(*map[uint8]float64)) + return newUint8Float64MapValue(v) case *map[uint16]float64: - return newUint16Float64MapValue(value.(*map[uint16]float64)) + return newUint16Float64MapValue(v) case *map[uint32]float64: - return newUint32Float64MapValue(value.(*map[uint32]float64)) + return newUint32Float64MapValue(v) case *map[uint64]float64: - return newUint64Float64MapValue(value.(*map[uint64]float64)) + return newUint64Float64MapValue(v) case *map[string]float32: - return newStringFloat32MapValue(value.(*map[string]float32)) + return newStringFloat32MapValue(v) case *map[int]float32: - return newIntFloat32MapValue(value.(*map[int]float32)) + return newIntFloat32MapValue(v) case *map[int8]float32: - return newInt8Float32MapValue(value.(*map[int8]float32)) + return newInt8Float32MapValue(v) case *map[int16]float32: - return newInt16Float32MapValue(value.(*map[int16]float32)) + return newInt16Float32MapValue(v) case *map[int32]float32: - return newInt32Float32MapValue(value.(*map[int32]float32)) + return newInt32Float32MapValue(v) case *map[int64]float32: - return newInt64Float32MapValue(value.(*map[int64]float32)) + return newInt64Float32MapValue(v) case *map[uint]float32: - return newUintFloat32MapValue(value.(*map[uint]float32)) + return newUintFloat32MapValue(v) case *map[uint8]float32: - return newUint8Float32MapValue(value.(*map[uint8]float32)) + return newUint8Float32MapValue(v) case *map[uint16]float32: - return newUint16Float32MapValue(value.(*map[uint16]float32)) + return newUint16Float32MapValue(v) case *map[uint32]float32: - return newUint32Float32MapValue(value.(*map[uint32]float32)) + return newUint32Float32MapValue(v) case *map[uint64]float32: - return newUint64Float32MapValue(value.(*map[uint64]float32)) + return newUint64Float32MapValue(v) case *map[string]time.Duration: - return newStringDurationMapValue(value.(*map[string]time.Duration)) + return newStringDurationMapValue(v) case *map[int]time.Duration: - return newIntDurationMapValue(value.(*map[int]time.Duration)) + return newIntDurationMapValue(v) case *map[int8]time.Duration: - return newInt8DurationMapValue(value.(*map[int8]time.Duration)) + return newInt8DurationMapValue(v) case *map[int16]time.Duration: - return newInt16DurationMapValue(value.(*map[int16]time.Duration)) + return newInt16DurationMapValue(v) case *map[int32]time.Duration: - return newInt32DurationMapValue(value.(*map[int32]time.Duration)) + return newInt32DurationMapValue(v) case *map[int64]time.Duration: - return newInt64DurationMapValue(value.(*map[int64]time.Duration)) + return newInt64DurationMapValue(v) case *map[uint]time.Duration: - return newUintDurationMapValue(value.(*map[uint]time.Duration)) + return newUintDurationMapValue(v) case *map[uint8]time.Duration: - return newUint8DurationMapValue(value.(*map[uint8]time.Duration)) + return newUint8DurationMapValue(v) case *map[uint16]time.Duration: - return newUint16DurationMapValue(value.(*map[uint16]time.Duration)) + return newUint16DurationMapValue(v) case *map[uint32]time.Duration: - return newUint32DurationMapValue(value.(*map[uint32]time.Duration)) + return newUint32DurationMapValue(v) case *map[uint64]time.Duration: - return newUint64DurationMapValue(value.(*map[uint64]time.Duration)) + return newUint64DurationMapValue(v) case *map[string]net.IP: - return newStringIPMapValue(value.(*map[string]net.IP)) + return newStringIPMapValue(v) case *map[int]net.IP: - return newIntIPMapValue(value.(*map[int]net.IP)) + return newIntIPMapValue(v) case *map[int8]net.IP: - return newInt8IPMapValue(value.(*map[int8]net.IP)) + return newInt8IPMapValue(v) case *map[int16]net.IP: - return newInt16IPMapValue(value.(*map[int16]net.IP)) + return newInt16IPMapValue(v) case *map[int32]net.IP: - return newInt32IPMapValue(value.(*map[int32]net.IP)) + return newInt32IPMapValue(v) case *map[int64]net.IP: - return newInt64IPMapValue(value.(*map[int64]net.IP)) + return newInt64IPMapValue(v) case *map[uint]net.IP: - return newUintIPMapValue(value.(*map[uint]net.IP)) + return newUintIPMapValue(v) case *map[uint8]net.IP: - return newUint8IPMapValue(value.(*map[uint8]net.IP)) + return newUint8IPMapValue(v) case *map[uint16]net.IP: - return newUint16IPMapValue(value.(*map[uint16]net.IP)) + return newUint16IPMapValue(v) case *map[uint32]net.IP: - return newUint32IPMapValue(value.(*map[uint32]net.IP)) + return newUint32IPMapValue(v) case *map[uint64]net.IP: - return newUint64IPMapValue(value.(*map[uint64]net.IP)) + return newUint64IPMapValue(v) case *map[string]HexBytes: - return newStringHexBytesMapValue(value.(*map[string]HexBytes)) + return newStringHexBytesMapValue(v) case *map[int]HexBytes: - return newIntHexBytesMapValue(value.(*map[int]HexBytes)) + return newIntHexBytesMapValue(v) case *map[int8]HexBytes: - return newInt8HexBytesMapValue(value.(*map[int8]HexBytes)) + return newInt8HexBytesMapValue(v) case *map[int16]HexBytes: - return newInt16HexBytesMapValue(value.(*map[int16]HexBytes)) + return newInt16HexBytesMapValue(v) case *map[int32]HexBytes: - return newInt32HexBytesMapValue(value.(*map[int32]HexBytes)) + return newInt32HexBytesMapValue(v) case *map[int64]HexBytes: - return newInt64HexBytesMapValue(value.(*map[int64]HexBytes)) + return newInt64HexBytesMapValue(v) case *map[uint]HexBytes: - return newUintHexBytesMapValue(value.(*map[uint]HexBytes)) + return newUintHexBytesMapValue(v) case *map[uint8]HexBytes: - return newUint8HexBytesMapValue(value.(*map[uint8]HexBytes)) + return newUint8HexBytesMapValue(v) case *map[uint16]HexBytes: - return newUint16HexBytesMapValue(value.(*map[uint16]HexBytes)) + return newUint16HexBytesMapValue(v) case *map[uint32]HexBytes: - return newUint32HexBytesMapValue(value.(*map[uint32]HexBytes)) + return newUint32HexBytesMapValue(v) case *map[uint64]HexBytes: - return newUint64HexBytesMapValue(value.(*map[uint64]HexBytes)) + return newUint64HexBytesMapValue(v) case *map[string]*regexp.Regexp: - return newStringRegexpMapValue(value.(*map[string]*regexp.Regexp)) + return newStringRegexpMapValue(v) case *map[int]*regexp.Regexp: - return newIntRegexpMapValue(value.(*map[int]*regexp.Regexp)) + return newIntRegexpMapValue(v) case *map[int8]*regexp.Regexp: - return newInt8RegexpMapValue(value.(*map[int8]*regexp.Regexp)) + return newInt8RegexpMapValue(v) case *map[int16]*regexp.Regexp: - return newInt16RegexpMapValue(value.(*map[int16]*regexp.Regexp)) + return newInt16RegexpMapValue(v) case *map[int32]*regexp.Regexp: - return newInt32RegexpMapValue(value.(*map[int32]*regexp.Regexp)) + return newInt32RegexpMapValue(v) case *map[int64]*regexp.Regexp: - return newInt64RegexpMapValue(value.(*map[int64]*regexp.Regexp)) + return newInt64RegexpMapValue(v) case *map[uint]*regexp.Regexp: - return newUintRegexpMapValue(value.(*map[uint]*regexp.Regexp)) + return newUintRegexpMapValue(v) case *map[uint8]*regexp.Regexp: - return newUint8RegexpMapValue(value.(*map[uint8]*regexp.Regexp)) + return newUint8RegexpMapValue(v) case *map[uint16]*regexp.Regexp: - return newUint16RegexpMapValue(value.(*map[uint16]*regexp.Regexp)) + return newUint16RegexpMapValue(v) case *map[uint32]*regexp.Regexp: - return newUint32RegexpMapValue(value.(*map[uint32]*regexp.Regexp)) + return newUint32RegexpMapValue(v) case *map[uint64]*regexp.Regexp: - return newUint64RegexpMapValue(value.(*map[uint64]*regexp.Regexp)) + return newUint64RegexpMapValue(v) case *map[string]net.IPNet: - return newStringIPNetMapValue(value.(*map[string]net.IPNet)) + return newStringIPNetMapValue(v) case *map[int]net.IPNet: - return newIntIPNetMapValue(value.(*map[int]net.IPNet)) + return newIntIPNetMapValue(v) case *map[int8]net.IPNet: - return newInt8IPNetMapValue(value.(*map[int8]net.IPNet)) + return newInt8IPNetMapValue(v) case *map[int16]net.IPNet: - return newInt16IPNetMapValue(value.(*map[int16]net.IPNet)) + return newInt16IPNetMapValue(v) case *map[int32]net.IPNet: - return newInt32IPNetMapValue(value.(*map[int32]net.IPNet)) + return newInt32IPNetMapValue(v) case *map[int64]net.IPNet: - return newInt64IPNetMapValue(value.(*map[int64]net.IPNet)) + return newInt64IPNetMapValue(v) case *map[uint]net.IPNet: - return newUintIPNetMapValue(value.(*map[uint]net.IPNet)) + return newUintIPNetMapValue(v) case *map[uint8]net.IPNet: - return newUint8IPNetMapValue(value.(*map[uint8]net.IPNet)) + return newUint8IPNetMapValue(v) case *map[uint16]net.IPNet: - return newUint16IPNetMapValue(value.(*map[uint16]net.IPNet)) + return newUint16IPNetMapValue(v) case *map[uint32]net.IPNet: - return newUint32IPNetMapValue(value.(*map[uint32]net.IPNet)) + return newUint32IPNetMapValue(v) case *map[uint64]net.IPNet: - return newUint64IPNetMapValue(value.(*map[uint64]net.IPNet)) + return newUint64IPNetMapValue(v) default: return nil } diff --git a/values_generated_test.go b/values_generated_test.go index e616e92..f150708 100644 --- a/values_generated_test.go +++ b/values_generated_test.go @@ -167,13 +167,13 @@ func TestStringStringMapValue(t *testing.T) { v := newStringStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("XVlBzval1") + err = v.Set("wVWkeval1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gbaiC:val1") + err = v.Set("qLcBL:val1") assert.Nil(t, err) - err = v.Set("MRAjWval2") + err = v.Set("aRnPzval2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("whTHc:val2") + err = v.Set("GLPNd:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]string", v.Type()) @@ -185,9 +185,9 @@ func TestStringStringMapValue(t *testing.T) { v := newStringStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("tcuAx") + err = v.Set("lyFwg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("hxKQF:") + err = v.Set("hqyuW:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]string", v.Type()) @@ -202,13 +202,13 @@ func TestIntStringMapValue(t *testing.T) { v := newIntStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5val1") + err = v.Set("0val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("0:val1") + err = v.Set("1:val1") assert.Nil(t, err) - err = v.Set("3val2") + err = v.Set("7val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) @@ -224,11 +224,11 @@ func TestIntStringMapValue(t *testing.T) { v := newIntStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5") + err = v.Set("7") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("4:") + err = v.Set("6:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]string", v.Type()) @@ -243,17 +243,17 @@ func TestInt8StringMapValue(t *testing.T) { v := newInt8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1val1") + err = v.Set("6val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("7:val1") + err = v.Set("5:val1") assert.Nil(t, err) err = v.Set("5val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("7:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]string", v.Type()) @@ -265,11 +265,11 @@ func TestInt8StringMapValue(t *testing.T) { v := newInt8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5") + err = v.Set("1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("2:") + err = v.Set("1:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]string", v.Type()) @@ -284,17 +284,17 @@ func TestInt16StringMapValue(t *testing.T) { v := newInt16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2val1") + err = v.Set("5val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("3:val1") + err = v.Set("1:val1") assert.Nil(t, err) - err = v.Set("1val2") + err = v.Set("7val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("3:val2") + err = v.Set("4:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]string", v.Type()) @@ -306,11 +306,11 @@ func TestInt16StringMapValue(t *testing.T) { v := newInt16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6") + err = v.Set("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("4:") + err = v.Set("3:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]string", v.Type()) @@ -325,17 +325,17 @@ func TestInt32StringMapValue(t *testing.T) { v := newInt32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7val1") + err = v.Set("3val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("1:val1") + err = v.Set("7:val1") assert.Nil(t, err) - err = v.Set("5val2") + err = v.Set("6val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("1:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]string", v.Type()) @@ -347,11 +347,11 @@ func TestInt32StringMapValue(t *testing.T) { v := newInt32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5") + err = v.Set("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("7:") + err = v.Set("1:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]string", v.Type()) @@ -366,17 +366,17 @@ func TestInt64StringMapValue(t *testing.T) { v := newInt64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0val1") + err = v.Set("3val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("1:val1") + err = v.Set("5:val1") assert.Nil(t, err) - err = v.Set("0val2") + err = v.Set("6val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("0:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]string", v.Type()) @@ -388,11 +388,11 @@ func TestInt64StringMapValue(t *testing.T) { v := newInt64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7") + err = v.Set("4") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("3:") + err = v.Set("1:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]string", v.Type()) @@ -407,17 +407,17 @@ func TestUintStringMapValue(t *testing.T) { v := newUintStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3val1") + err = v.Set("5val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("6:val1") + err = v.Set("4:val1") assert.Nil(t, err) err = v.Set("5val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("4:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]string", v.Type()) @@ -429,11 +429,11 @@ func TestUintStringMapValue(t *testing.T) { v := newUintStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2") + err = v.Set("5") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("4:") + err = v.Set("1:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]string", v.Type()) @@ -448,17 +448,17 @@ func TestUint8StringMapValue(t *testing.T) { v := newUint8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1val1") + err = v.Set("0val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("2:val1") + err = v.Set("5:val1") assert.Nil(t, err) - err = v.Set("7val2") + err = v.Set("0val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -470,11 +470,11 @@ func TestUint8StringMapValue(t *testing.T) { v := newUint8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3") + err = v.Set("4") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("0:") + err = v.Set("5:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -489,17 +489,17 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2val1") + err = v.Set("3val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("6:val1") + err = v.Set("1:val1") assert.Nil(t, err) err = v.Set("7val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("6:val2") + err = v.Set("2:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -511,11 +511,11 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1") + err = v.Set("3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("7:") + err = v.Set("4:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -530,17 +530,17 @@ func TestUint32StringMapValue(t *testing.T) { v := newUint32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4val1") + err = v.Set("7val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("4:val1") + err = v.Set("5:val1") assert.Nil(t, err) err = v.Set("7val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("1:val2") + err = v.Set("7:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]string", v.Type()) @@ -552,11 +552,11 @@ func TestUint32StringMapValue(t *testing.T) { v := newUint32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1") + err = v.Set("3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("5:") + err = v.Set("6:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]string", v.Type()) @@ -571,17 +571,17 @@ func TestUint64StringMapValue(t *testing.T) { v := newUint64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1val1") + err = v.Set("0val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("3:val1") + err = v.Set("6:val1") assert.Nil(t, err) - err = v.Set("1val2") + err = v.Set("5val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("3:val2") + err = v.Set("4:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]string", v.Type()) @@ -597,7 +597,7 @@ func TestUint64StringMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("2:") + err = v.Set("0:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]string", v.Type()) @@ -813,13 +813,13 @@ func TestStringBoolMapValue(t *testing.T) { v := newStringBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("gmotatrue") + err = v.Set("hvZrrtrue") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FetHs:true") + err = v.Set("yerAZ:true") assert.Nil(t, err) - err = v.Set("bZRjxfalse") + err = v.Set("AEMahfalse") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Awnwe:false") + err = v.Set("oQbAR:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]bool", v.Type()) @@ -831,9 +831,9 @@ func TestStringBoolMapValue(t *testing.T) { v := newStringBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("krBEmunexpected") + err = v.Set("FMIkpunexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("fdzdc:unexpected") + err = v.Set("BSxrd:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]bool", v.Type()) @@ -848,17 +848,17 @@ func TestIntBoolMapValue(t *testing.T) { v := newIntBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6true") + err = v.Set("1true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) err = v.Set("2:true") assert.Nil(t, err) - err = v.Set("5false") + err = v.Set("1false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("7:false") + err = v.Set("1:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]bool", v.Type()) @@ -870,7 +870,7 @@ func TestIntBoolMapValue(t *testing.T) { v := newIntBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2unexpected") + err = v.Set("0unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) @@ -889,17 +889,17 @@ func TestInt8BoolMapValue(t *testing.T) { v := newInt8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5true") + err = v.Set("3true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("6:true") + err = v.Set("3:true") assert.Nil(t, err) - err = v.Set("3false") + err = v.Set("5false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("5:false") + err = v.Set("0:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]bool", v.Type()) @@ -911,11 +911,11 @@ func TestInt8BoolMapValue(t *testing.T) { v := newInt8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4unexpected") + err = v.Set("6unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("7:unexpected") + err = v.Set("0:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]bool", v.Type()) @@ -930,17 +930,17 @@ func TestInt16BoolMapValue(t *testing.T) { v := newInt16BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5true") + err = v.Set("1true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("6:true") + err = v.Set("2:true") assert.Nil(t, err) err = v.Set("3false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("5:false") + err = v.Set("2:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]bool", v.Type()) @@ -952,11 +952,11 @@ func TestInt16BoolMapValue(t *testing.T) { v := newInt16BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0unexpected") + err = v.Set("3unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("2:unexpected") + err = v.Set("5:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]bool", v.Type()) @@ -971,13 +971,13 @@ func TestInt32BoolMapValue(t *testing.T) { v := newInt32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0true") + err = v.Set("4true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("7:true") + err = v.Set("6:true") assert.Nil(t, err) - err = v.Set("0false") + err = v.Set("2false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) @@ -993,11 +993,11 @@ func TestInt32BoolMapValue(t *testing.T) { v := newInt32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4unexpected") + err = v.Set("6unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("4:unexpected") + err = v.Set("0:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]bool", v.Type()) @@ -1012,13 +1012,13 @@ func TestInt64BoolMapValue(t *testing.T) { v := newInt64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0true") + err = v.Set("1true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("7:true") + err = v.Set("3:true") assert.Nil(t, err) - err = v.Set("4false") + err = v.Set("7false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) @@ -1034,11 +1034,11 @@ func TestInt64BoolMapValue(t *testing.T) { v := newInt64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3unexpected") + err = v.Set("6unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("4:unexpected") + err = v.Set("2:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]bool", v.Type()) @@ -1053,13 +1053,13 @@ func TestUintBoolMapValue(t *testing.T) { v := newUintBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0true") + err = v.Set("4true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("7:true") + err = v.Set("3:true") assert.Nil(t, err) - err = v.Set("4false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) @@ -1075,7 +1075,7 @@ func TestUintBoolMapValue(t *testing.T) { v := newUintBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1unexpected") + err = v.Set("0unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) @@ -1094,13 +1094,13 @@ func TestUint8BoolMapValue(t *testing.T) { v := newUint8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1true") + err = v.Set("2true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) err = v.Set("2:true") assert.Nil(t, err) - err = v.Set("2false") + err = v.Set("1false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) @@ -1120,7 +1120,7 @@ func TestUint8BoolMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("7:unexpected") + err = v.Set("3:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]bool", v.Type()) @@ -1135,17 +1135,17 @@ func TestUint16BoolMapValue(t *testing.T) { v := newUint16BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2true") + err = v.Set("0true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("2:true") + err = v.Set("7:true") assert.Nil(t, err) - err = v.Set("6false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("7:false") + err = v.Set("2:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]bool", v.Type()) @@ -1157,11 +1157,11 @@ func TestUint16BoolMapValue(t *testing.T) { v := newUint16BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6unexpected") + err = v.Set("0unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("0:unexpected") + err = v.Set("6:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]bool", v.Type()) @@ -1176,17 +1176,17 @@ func TestUint32BoolMapValue(t *testing.T) { v := newUint32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7true") + err = v.Set("1true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("0:true") + err = v.Set("3:true") assert.Nil(t, err) - err = v.Set("6false") + err = v.Set("4false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("6:false") + err = v.Set("0:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]bool", v.Type()) @@ -1198,11 +1198,11 @@ func TestUint32BoolMapValue(t *testing.T) { v := newUint32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7unexpected") + err = v.Set("5unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("0:unexpected") + err = v.Set("2:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]bool", v.Type()) @@ -1217,17 +1217,17 @@ func TestUint64BoolMapValue(t *testing.T) { v := newUint64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0true") + err = v.Set("4true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("2:true") + err = v.Set("0:true") assert.Nil(t, err) - err = v.Set("1false") + err = v.Set("6false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("7:false") + err = v.Set("4:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]bool", v.Type()) @@ -1239,11 +1239,11 @@ func TestUint64BoolMapValue(t *testing.T) { v := newUint64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3unexpected") + err = v.Set("6unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("7:unexpected") + err = v.Set("0:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]bool", v.Type()) @@ -1449,13 +1449,13 @@ func TestStringUintMapValue(t *testing.T) { v := newStringUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("sbOJi10") + err = v.Set("zKbJy10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FQGZs:10") + err = v.Set("eSYjx:10") assert.Nil(t, err) - err = v.Set("nwTKS20") + err = v.Set("WiVSz20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mVoiG:20") + err = v.Set("RFNPI:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint", v.Type()) @@ -1467,9 +1467,9 @@ func TestStringUintMapValue(t *testing.T) { v := newStringUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("LOpbU-1") + err = v.Set("prKMT-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("OpEdK:-1") + err = v.Set("ISXKA:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint", v.Type()) @@ -1484,17 +1484,17 @@ func TestIntUintMapValue(t *testing.T) { v := newIntUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2:10") assert.Nil(t, err) err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint", v.Type()) @@ -1506,7 +1506,7 @@ func TestIntUintMapValue(t *testing.T) { v := newIntUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -1525,17 +1525,17 @@ func TestInt8UintMapValue(t *testing.T) { v := newInt8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint", v.Type()) @@ -1547,11 +1547,11 @@ func TestInt8UintMapValue(t *testing.T) { v := newInt8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint", v.Type()) @@ -1566,17 +1566,17 @@ func TestInt16UintMapValue(t *testing.T) { v := newInt16UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint", v.Type()) @@ -1588,11 +1588,11 @@ func TestInt16UintMapValue(t *testing.T) { v := newInt16UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("2:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint", v.Type()) @@ -1607,17 +1607,17 @@ func TestInt32UintMapValue(t *testing.T) { v := newInt32UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint", v.Type()) @@ -1629,11 +1629,11 @@ func TestInt32UintMapValue(t *testing.T) { v := newInt32UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("7-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint", v.Type()) @@ -1648,17 +1648,17 @@ func TestInt64UintMapValue(t *testing.T) { v := newInt64UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint", v.Type()) @@ -1674,7 +1674,7 @@ func TestInt64UintMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("5:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint", v.Type()) @@ -1689,13 +1689,13 @@ func TestUintUintMapValue(t *testing.T) { v := newUintUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -1711,11 +1711,11 @@ func TestUintUintMapValue(t *testing.T) { v := newUintUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint", v.Type()) @@ -1730,17 +1730,17 @@ func TestUint8UintMapValue(t *testing.T) { v := newUint8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint", v.Type()) @@ -1752,11 +1752,11 @@ func TestUint8UintMapValue(t *testing.T) { v := newUint8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("7-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint", v.Type()) @@ -1771,11 +1771,11 @@ func TestUint16UintMapValue(t *testing.T) { v := newUint16UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("5:10") assert.Nil(t, err) err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -1793,11 +1793,11 @@ func TestUint16UintMapValue(t *testing.T) { v := newUint16UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint", v.Type()) @@ -1812,17 +1812,17 @@ func TestUint32UintMapValue(t *testing.T) { v := newUint32UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint", v.Type()) @@ -1834,11 +1834,11 @@ func TestUint32UintMapValue(t *testing.T) { v := newUint32UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint", v.Type()) @@ -1857,13 +1857,13 @@ func TestUint64UintMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint", v.Type()) @@ -1875,11 +1875,11 @@ func TestUint64UintMapValue(t *testing.T) { v := newUint64UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint", v.Type()) @@ -2085,13 +2085,13 @@ func TestStringUint8MapValue(t *testing.T) { v := newStringUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("YCOhg10") + err = v.Set("uDyYv10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("HOvgS:10") + err = v.Set("jCZze:10") assert.Nil(t, err) - err = v.Set("eycJP20") + err = v.Set("TweqK20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JHYNu:20") + err = v.Set("KYadV:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint8", v.Type()) @@ -2103,9 +2103,9 @@ func TestStringUint8MapValue(t *testing.T) { v := newStringUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("fNjJh-1") + err = v.Set("LkFci-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("hjUVR:-1") + err = v.Set("HViPd:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint8", v.Type()) @@ -2120,17 +2120,17 @@ func TestIntUint8MapValue(t *testing.T) { v := newIntUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("3:10") assert.Nil(t, err) err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint8", v.Type()) @@ -2142,11 +2142,11 @@ func TestIntUint8MapValue(t *testing.T) { v := newIntUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint8", v.Type()) @@ -2161,17 +2161,17 @@ func TestInt8Uint8MapValue(t *testing.T) { v := newInt8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint8", v.Type()) @@ -2183,11 +2183,11 @@ func TestInt8Uint8MapValue(t *testing.T) { v := newInt8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("2:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint8", v.Type()) @@ -2202,17 +2202,17 @@ func TestInt16Uint8MapValue(t *testing.T) { v := newInt16Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint8", v.Type()) @@ -2224,11 +2224,11 @@ func TestInt16Uint8MapValue(t *testing.T) { v := newInt16Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint8", v.Type()) @@ -2243,11 +2243,11 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -2265,11 +2265,11 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint8", v.Type()) @@ -2288,13 +2288,13 @@ func TestInt64Uint8MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint8", v.Type()) @@ -2306,11 +2306,11 @@ func TestInt64Uint8MapValue(t *testing.T) { v := newInt64Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint8", v.Type()) @@ -2325,17 +2325,17 @@ func TestUintUint8MapValue(t *testing.T) { v := newUintUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint8", v.Type()) @@ -2347,11 +2347,11 @@ func TestUintUint8MapValue(t *testing.T) { v := newUintUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint8", v.Type()) @@ -2366,17 +2366,17 @@ func TestUint8Uint8MapValue(t *testing.T) { v := newUint8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint8", v.Type()) @@ -2388,11 +2388,11 @@ func TestUint8Uint8MapValue(t *testing.T) { v := newUint8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint8", v.Type()) @@ -2407,17 +2407,17 @@ func TestUint16Uint8MapValue(t *testing.T) { v := newUint16Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint8", v.Type()) @@ -2429,11 +2429,11 @@ func TestUint16Uint8MapValue(t *testing.T) { v := newUint16Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint8", v.Type()) @@ -2448,17 +2448,17 @@ func TestUint32Uint8MapValue(t *testing.T) { v := newUint32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint8", v.Type()) @@ -2470,11 +2470,11 @@ func TestUint32Uint8MapValue(t *testing.T) { v := newUint32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint8", v.Type()) @@ -2489,17 +2489,17 @@ func TestUint64Uint8MapValue(t *testing.T) { v := newUint64Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint8", v.Type()) @@ -2511,11 +2511,11 @@ func TestUint64Uint8MapValue(t *testing.T) { v := newUint64Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint8", v.Type()) @@ -2721,13 +2721,13 @@ func TestStringUint16MapValue(t *testing.T) { v := newStringUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("sdjSG10") + err = v.Set("ZWDcG10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("pngCw:10") + err = v.Set("zpSHG:10") assert.Nil(t, err) - err = v.Set("FkDif20") + err = v.Set("iZvcw20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("IBuuf:20") + err = v.Set("STXEP:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint16", v.Type()) @@ -2739,9 +2739,9 @@ func TestStringUint16MapValue(t *testing.T) { v := newStringUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("FMoWd-1") + err = v.Set("laIam-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("iTskZ:-1") + err = v.Set("dHqZN:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint16", v.Type()) @@ -2760,13 +2760,13 @@ func TestIntUint16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("7:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint16", v.Type()) @@ -2778,11 +2778,11 @@ func TestIntUint16MapValue(t *testing.T) { v := newIntUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint16", v.Type()) @@ -2797,17 +2797,17 @@ func TestInt8Uint16MapValue(t *testing.T) { v := newInt8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint16", v.Type()) @@ -2819,11 +2819,11 @@ func TestInt8Uint16MapValue(t *testing.T) { v := newInt8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint16", v.Type()) @@ -2838,17 +2838,17 @@ func TestInt16Uint16MapValue(t *testing.T) { v := newInt16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint16", v.Type()) @@ -2860,11 +2860,11 @@ func TestInt16Uint16MapValue(t *testing.T) { v := newInt16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint16", v.Type()) @@ -2879,13 +2879,13 @@ func TestInt32Uint16MapValue(t *testing.T) { v := newInt32Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -2901,11 +2901,11 @@ func TestInt32Uint16MapValue(t *testing.T) { v := newInt32Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint16", v.Type()) @@ -2924,13 +2924,13 @@ func TestInt64Uint16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint16", v.Type()) @@ -2942,11 +2942,11 @@ func TestInt64Uint16MapValue(t *testing.T) { v := newInt64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint16", v.Type()) @@ -2961,17 +2961,17 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint16", v.Type()) @@ -2983,11 +2983,11 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint16", v.Type()) @@ -3002,17 +3002,17 @@ func TestUint8Uint16MapValue(t *testing.T) { v := newUint8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint16", v.Type()) @@ -3024,11 +3024,11 @@ func TestUint8Uint16MapValue(t *testing.T) { v := newUint8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint16", v.Type()) @@ -3043,17 +3043,17 @@ func TestUint16Uint16MapValue(t *testing.T) { v := newUint16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint16", v.Type()) @@ -3065,7 +3065,7 @@ func TestUint16Uint16MapValue(t *testing.T) { v := newUint16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -3088,13 +3088,13 @@ func TestUint32Uint16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint16", v.Type()) @@ -3106,11 +3106,11 @@ func TestUint32Uint16MapValue(t *testing.T) { v := newUint32Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint16", v.Type()) @@ -3129,13 +3129,13 @@ func TestUint64Uint16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint16", v.Type()) @@ -3147,11 +3147,11 @@ func TestUint64Uint16MapValue(t *testing.T) { v := newUint64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("4-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint16", v.Type()) @@ -3357,13 +3357,13 @@ func TestStringUint32MapValue(t *testing.T) { v := newStringUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("VgzHb10") + err = v.Set("arnss10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("lmYYt:10") + err = v.Set("KaofM:10") assert.Nil(t, err) - err = v.Set("EjVgw20") + err = v.Set("WvCvL20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("fFbbG:20") + err = v.Set("HHaqq:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint32", v.Type()) @@ -3375,9 +3375,9 @@ func TestStringUint32MapValue(t *testing.T) { v := newStringUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("Gcnqb-1") + err = v.Set("unoWJ-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("aEREu:-1") + err = v.Set("nSNPJ:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint32", v.Type()) @@ -3392,17 +3392,17 @@ func TestIntUint32MapValue(t *testing.T) { v := newIntUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint32", v.Type()) @@ -3414,11 +3414,11 @@ func TestIntUint32MapValue(t *testing.T) { v := newIntUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("1:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint32", v.Type()) @@ -3433,13 +3433,13 @@ func TestInt8Uint32MapValue(t *testing.T) { v := newInt8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -3455,11 +3455,11 @@ func TestInt8Uint32MapValue(t *testing.T) { v := newInt8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("7:-1") + err = v.Set("5:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint32", v.Type()) @@ -3474,17 +3474,17 @@ func TestInt16Uint32MapValue(t *testing.T) { v := newInt16Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint32", v.Type()) @@ -3496,11 +3496,11 @@ func TestInt16Uint32MapValue(t *testing.T) { v := newInt16Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint32", v.Type()) @@ -3515,13 +3515,13 @@ func TestInt32Uint32MapValue(t *testing.T) { v := newInt32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -3537,11 +3537,11 @@ func TestInt32Uint32MapValue(t *testing.T) { v := newInt32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint32", v.Type()) @@ -3556,17 +3556,17 @@ func TestInt64Uint32MapValue(t *testing.T) { v := newInt64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("1:10") assert.Nil(t, err) err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint32", v.Type()) @@ -3578,11 +3578,11 @@ func TestInt64Uint32MapValue(t *testing.T) { v := newInt64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint32", v.Type()) @@ -3601,13 +3601,13 @@ func TestUintUint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3623,7 +3623,7 @@ func TestUintUint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3638,17 +3638,17 @@ func TestUint8Uint32MapValue(t *testing.T) { v := newUint8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint32", v.Type()) @@ -3660,11 +3660,11 @@ func TestUint8Uint32MapValue(t *testing.T) { v := newUint8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("7-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint32", v.Type()) @@ -3679,17 +3679,17 @@ func TestUint16Uint32MapValue(t *testing.T) { v := newUint16Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint32", v.Type()) @@ -3701,11 +3701,11 @@ func TestUint16Uint32MapValue(t *testing.T) { v := newUint16Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint32", v.Type()) @@ -3720,13 +3720,13 @@ func TestUint32Uint32MapValue(t *testing.T) { v := newUint32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -3742,7 +3742,7 @@ func TestUint32Uint32MapValue(t *testing.T) { v := newUint32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -3761,17 +3761,17 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint32", v.Type()) @@ -3787,7 +3787,7 @@ func TestUint64Uint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint32", v.Type()) @@ -3993,13 +3993,13 @@ func TestStringUint64MapValue(t *testing.T) { v := newStringUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("Lpruc10") + err = v.Set("MTiCb10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("jiOgj:10") + err = v.Set("AjVGx:10") assert.Nil(t, err) - err = v.Set("hYeVw20") + err = v.Set("yMQaj20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BTCML:20") + err = v.Set("LqoQr:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint64", v.Type()) @@ -4011,9 +4011,9 @@ func TestStringUint64MapValue(t *testing.T) { v := newStringUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("frDGX-1") + err = v.Set("CdpKS-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qwpzw:-1") + err = v.Set("dYAvN:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint64", v.Type()) @@ -4028,13 +4028,13 @@ func TestIntUint64MapValue(t *testing.T) { v := newIntUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -4050,7 +4050,7 @@ func TestIntUint64MapValue(t *testing.T) { v := newIntUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -4069,13 +4069,13 @@ func TestInt8Uint64MapValue(t *testing.T) { v := newInt8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -4091,7 +4091,7 @@ func TestInt8Uint64MapValue(t *testing.T) { v := newInt8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -4110,17 +4110,17 @@ func TestInt16Uint64MapValue(t *testing.T) { v := newInt16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint64", v.Type()) @@ -4136,7 +4136,7 @@ func TestInt16Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint64", v.Type()) @@ -4151,17 +4151,17 @@ func TestInt32Uint64MapValue(t *testing.T) { v := newInt32Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint64", v.Type()) @@ -4173,11 +4173,11 @@ func TestInt32Uint64MapValue(t *testing.T) { v := newInt32Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint64", v.Type()) @@ -4196,13 +4196,13 @@ func TestInt64Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint64", v.Type()) @@ -4214,7 +4214,7 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -4233,17 +4233,17 @@ func TestUintUint64MapValue(t *testing.T) { v := newUintUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint64", v.Type()) @@ -4255,11 +4255,11 @@ func TestUintUint64MapValue(t *testing.T) { v := newUintUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint64", v.Type()) @@ -4274,17 +4274,17 @@ func TestUint8Uint64MapValue(t *testing.T) { v := newUint8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint64", v.Type()) @@ -4296,11 +4296,11 @@ func TestUint8Uint64MapValue(t *testing.T) { v := newUint8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("5:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint64", v.Type()) @@ -4319,9 +4319,9 @@ func TestUint16Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -4337,11 +4337,11 @@ func TestUint16Uint64MapValue(t *testing.T) { v := newUint16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint64", v.Type()) @@ -4356,17 +4356,17 @@ func TestUint32Uint64MapValue(t *testing.T) { v := newUint32Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint64", v.Type()) @@ -4382,7 +4382,7 @@ func TestUint32Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("1:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint64", v.Type()) @@ -4397,17 +4397,17 @@ func TestUint64Uint64MapValue(t *testing.T) { v := newUint64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint64", v.Type()) @@ -4423,7 +4423,7 @@ func TestUint64Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint64", v.Type()) @@ -4669,13 +4669,13 @@ func TestStringIntMapValue(t *testing.T) { v := newStringIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("aiIsN10") + err = v.Set("rVIJd10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BakqS:10") + err = v.Set("LrrZI:10") assert.Nil(t, err) - err = v.Set("wQpOQ20") + err = v.Set("wnDyW20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gNczg:20") + err = v.Set("qZDDN:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int", v.Type()) @@ -4687,9 +4687,9 @@ func TestStringIntMapValue(t *testing.T) { v := newStringIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("aczAIa") + err = v.Set("fJBoWa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nLqLI:a") + err = v.Set("HtHNc:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int", v.Type()) @@ -4704,17 +4704,17 @@ func TestIntIntMapValue(t *testing.T) { v := newIntIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4726,11 +4726,11 @@ func TestIntIntMapValue(t *testing.T) { v := newIntIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4745,17 +4745,17 @@ func TestInt8IntMapValue(t *testing.T) { v := newInt8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int", v.Type()) @@ -4767,11 +4767,11 @@ func TestInt8IntMapValue(t *testing.T) { v := newInt8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int", v.Type()) @@ -4786,17 +4786,17 @@ func TestInt16IntMapValue(t *testing.T) { v := newInt16IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int", v.Type()) @@ -4808,11 +4808,11 @@ func TestInt16IntMapValue(t *testing.T) { v := newInt16IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int", v.Type()) @@ -4827,17 +4827,17 @@ func TestInt32IntMapValue(t *testing.T) { v := newInt32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int", v.Type()) @@ -4849,11 +4849,11 @@ func TestInt32IntMapValue(t *testing.T) { v := newInt32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int", v.Type()) @@ -4868,17 +4868,17 @@ func TestInt64IntMapValue(t *testing.T) { v := newInt64IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("4:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int", v.Type()) @@ -4890,11 +4890,11 @@ func TestInt64IntMapValue(t *testing.T) { v := newInt64IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int", v.Type()) @@ -4909,17 +4909,17 @@ func TestUintIntMapValue(t *testing.T) { v := newUintIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int", v.Type()) @@ -4931,11 +4931,11 @@ func TestUintIntMapValue(t *testing.T) { v := newUintIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int", v.Type()) @@ -4950,13 +4950,13 @@ func TestUint8IntMapValue(t *testing.T) { v := newUint8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -4976,7 +4976,7 @@ func TestUint8IntMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int", v.Type()) @@ -4991,17 +4991,17 @@ func TestUint16IntMapValue(t *testing.T) { v := newUint16IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int", v.Type()) @@ -5013,11 +5013,11 @@ func TestUint16IntMapValue(t *testing.T) { v := newUint16IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int", v.Type()) @@ -5032,13 +5032,13 @@ func TestUint32IntMapValue(t *testing.T) { v := newUint32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -5054,11 +5054,11 @@ func TestUint32IntMapValue(t *testing.T) { v := newUint32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int", v.Type()) @@ -5077,9 +5077,9 @@ func TestUint64IntMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -5095,11 +5095,11 @@ func TestUint64IntMapValue(t *testing.T) { v := newUint64IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int", v.Type()) @@ -5315,13 +5315,13 @@ func TestStringInt8MapValue(t *testing.T) { v := newStringInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("eBZBF10") + err = v.Set("qHgZv10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("elhXk:10") + err = v.Set("RaRQa:10") assert.Nil(t, err) - err = v.Set("zzfNa20") + err = v.Set("blbcP20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("VtAyy:20") + err = v.Set("nuxdP:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int8", v.Type()) @@ -5333,9 +5333,9 @@ func TestStringInt8MapValue(t *testing.T) { v := newStringInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("qWzKqa") + err = v.Set("kzsXha") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("QFbuc:a") + err = v.Set("jLGQx:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int8", v.Type()) @@ -5350,17 +5350,17 @@ func TestIntInt8MapValue(t *testing.T) { v := newIntInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int8", v.Type()) @@ -5372,7 +5372,7 @@ func TestIntInt8MapValue(t *testing.T) { v := newIntInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -5391,17 +5391,17 @@ func TestInt8Int8MapValue(t *testing.T) { v := newInt8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int8", v.Type()) @@ -5413,11 +5413,11 @@ func TestInt8Int8MapValue(t *testing.T) { v := newInt8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int8", v.Type()) @@ -5432,17 +5432,17 @@ func TestInt16Int8MapValue(t *testing.T) { v := newInt16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int8", v.Type()) @@ -5454,11 +5454,11 @@ func TestInt16Int8MapValue(t *testing.T) { v := newInt16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int8", v.Type()) @@ -5473,17 +5473,17 @@ func TestInt32Int8MapValue(t *testing.T) { v := newInt32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int8", v.Type()) @@ -5495,11 +5495,11 @@ func TestInt32Int8MapValue(t *testing.T) { v := newInt32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int8", v.Type()) @@ -5514,17 +5514,17 @@ func TestInt64Int8MapValue(t *testing.T) { v := newInt64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int8", v.Type()) @@ -5536,11 +5536,11 @@ func TestInt64Int8MapValue(t *testing.T) { v := newInt64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int8", v.Type()) @@ -5555,17 +5555,17 @@ func TestUintInt8MapValue(t *testing.T) { v := newUintInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int8", v.Type()) @@ -5577,11 +5577,11 @@ func TestUintInt8MapValue(t *testing.T) { v := newUintInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int8", v.Type()) @@ -5596,17 +5596,17 @@ func TestUint8Int8MapValue(t *testing.T) { v := newUint8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2:10") assert.Nil(t, err) err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int8", v.Type()) @@ -5618,11 +5618,11 @@ func TestUint8Int8MapValue(t *testing.T) { v := newUint8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int8", v.Type()) @@ -5637,17 +5637,17 @@ func TestUint16Int8MapValue(t *testing.T) { v := newUint16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int8", v.Type()) @@ -5659,11 +5659,11 @@ func TestUint16Int8MapValue(t *testing.T) { v := newUint16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int8", v.Type()) @@ -5678,17 +5678,17 @@ func TestUint32Int8MapValue(t *testing.T) { v := newUint32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int8", v.Type()) @@ -5700,11 +5700,11 @@ func TestUint32Int8MapValue(t *testing.T) { v := newUint32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int8", v.Type()) @@ -5719,17 +5719,17 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int8", v.Type()) @@ -5741,11 +5741,11 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int8", v.Type()) @@ -5961,13 +5961,13 @@ func TestStringInt16MapValue(t *testing.T) { v := newStringInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("qcnCT10") + err = v.Set("wuHSc10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uGZam:10") + err = v.Set("WtNWk:10") assert.Nil(t, err) - err = v.Set("CToZv20") + err = v.Set("iXfXk20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("PynaE:20") + err = v.Set("hJVJs:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int16", v.Type()) @@ -5979,9 +5979,9 @@ func TestStringInt16MapValue(t *testing.T) { v := newStringInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("phIdXa") + err = v.Set("qblTTa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("aKUaq:a") + err = v.Set("Vilcp:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int16", v.Type()) @@ -6000,13 +6000,13 @@ func TestIntInt16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int16", v.Type()) @@ -6018,11 +6018,11 @@ func TestIntInt16MapValue(t *testing.T) { v := newIntInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int16", v.Type()) @@ -6037,17 +6037,17 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int16", v.Type()) @@ -6059,11 +6059,11 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int16", v.Type()) @@ -6078,17 +6078,17 @@ func TestInt16Int16MapValue(t *testing.T) { v := newInt16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int16", v.Type()) @@ -6100,7 +6100,7 @@ func TestInt16Int16MapValue(t *testing.T) { v := newInt16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6119,17 +6119,17 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int16", v.Type()) @@ -6141,11 +6141,11 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int16", v.Type()) @@ -6160,13 +6160,13 @@ func TestInt64Int16MapValue(t *testing.T) { v := newInt64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -6182,11 +6182,11 @@ func TestInt64Int16MapValue(t *testing.T) { v := newInt64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int16", v.Type()) @@ -6201,17 +6201,17 @@ func TestUintInt16MapValue(t *testing.T) { v := newUintInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int16", v.Type()) @@ -6223,7 +6223,7 @@ func TestUintInt16MapValue(t *testing.T) { v := newUintInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6246,13 +6246,13 @@ func TestUint8Int16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int16", v.Type()) @@ -6264,11 +6264,11 @@ func TestUint8Int16MapValue(t *testing.T) { v := newUint8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int16", v.Type()) @@ -6283,17 +6283,17 @@ func TestUint16Int16MapValue(t *testing.T) { v := newUint16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int16", v.Type()) @@ -6305,11 +6305,11 @@ func TestUint16Int16MapValue(t *testing.T) { v := newUint16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int16", v.Type()) @@ -6324,17 +6324,17 @@ func TestUint32Int16MapValue(t *testing.T) { v := newUint32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6346,11 +6346,11 @@ func TestUint32Int16MapValue(t *testing.T) { v := newUint32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6365,17 +6365,17 @@ func TestUint64Int16MapValue(t *testing.T) { v := newUint64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("3:10") assert.Nil(t, err) err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int16", v.Type()) @@ -6387,11 +6387,11 @@ func TestUint64Int16MapValue(t *testing.T) { v := newUint64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int16", v.Type()) @@ -6607,13 +6607,13 @@ func TestStringInt32MapValue(t *testing.T) { v := newStringInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("hGCMd10") + err = v.Set("SljxD10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("fLitT:10") + err = v.Set("cXwzs:10") assert.Nil(t, err) - err = v.Set("qwLUe20") + err = v.Set("ACHMZ20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("cgOcz:20") + err = v.Set("QoEiV:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int32", v.Type()) @@ -6625,9 +6625,9 @@ func TestStringInt32MapValue(t *testing.T) { v := newStringInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("XTbRMa") + err = v.Set("yPlyHa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("GxqPe:a") + err = v.Set("FxUNj:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int32", v.Type()) @@ -6642,17 +6642,17 @@ func TestIntInt32MapValue(t *testing.T) { v := newIntInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int32", v.Type()) @@ -6683,17 +6683,17 @@ func TestInt8Int32MapValue(t *testing.T) { v := newInt8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int32", v.Type()) @@ -6705,11 +6705,11 @@ func TestInt8Int32MapValue(t *testing.T) { v := newInt8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int32", v.Type()) @@ -6724,11 +6724,11 @@ func TestInt16Int32MapValue(t *testing.T) { v := newInt16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("4:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -6750,7 +6750,7 @@ func TestInt16Int32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int32", v.Type()) @@ -6765,17 +6765,17 @@ func TestInt32Int32MapValue(t *testing.T) { v := newInt32Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int32", v.Type()) @@ -6787,11 +6787,11 @@ func TestInt32Int32MapValue(t *testing.T) { v := newInt32Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int32", v.Type()) @@ -6806,17 +6806,17 @@ func TestInt64Int32MapValue(t *testing.T) { v := newInt64Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int32", v.Type()) @@ -6832,7 +6832,7 @@ func TestInt64Int32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int32", v.Type()) @@ -6847,17 +6847,17 @@ func TestUintInt32MapValue(t *testing.T) { v := newUintInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int32", v.Type()) @@ -6869,7 +6869,7 @@ func TestUintInt32MapValue(t *testing.T) { v := newUintInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6888,17 +6888,17 @@ func TestUint8Int32MapValue(t *testing.T) { v := newUint8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6910,11 +6910,11 @@ func TestUint8Int32MapValue(t *testing.T) { v := newUint8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6929,17 +6929,17 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int32", v.Type()) @@ -6951,11 +6951,11 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("6:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int32", v.Type()) @@ -6970,17 +6970,17 @@ func TestUint32Int32MapValue(t *testing.T) { v := newUint32Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("7:10") assert.Nil(t, err) err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int32", v.Type()) @@ -6992,11 +6992,11 @@ func TestUint32Int32MapValue(t *testing.T) { v := newUint32Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int32", v.Type()) @@ -7011,13 +7011,13 @@ func TestUint64Int32MapValue(t *testing.T) { v := newUint64Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -7033,7 +7033,7 @@ func TestUint64Int32MapValue(t *testing.T) { v := newUint64Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -7253,13 +7253,13 @@ func TestStringInt64MapValue(t *testing.T) { v := newStringInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("ORvAU10") + err = v.Set("eBZsW10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kAwww:10") + err = v.Set("BFAwB:10") assert.Nil(t, err) - err = v.Set("TndUJ20") + err = v.Set("gniQC20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("HiQec:20") + err = v.Set("IIlTv:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int64", v.Type()) @@ -7271,9 +7271,9 @@ func TestStringInt64MapValue(t *testing.T) { v := newStringInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("bxzvqa") + err = v.Set("MeQeea") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("zlPWy:a") + err = v.Set("MUlPs:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int64", v.Type()) @@ -7288,13 +7288,13 @@ func TestIntInt64MapValue(t *testing.T) { v := newIntInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -7310,11 +7310,11 @@ func TestIntInt64MapValue(t *testing.T) { v := newIntInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int64", v.Type()) @@ -7329,17 +7329,17 @@ func TestInt8Int64MapValue(t *testing.T) { v := newInt8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int64", v.Type()) @@ -7351,11 +7351,11 @@ func TestInt8Int64MapValue(t *testing.T) { v := newInt8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int64", v.Type()) @@ -7370,17 +7370,17 @@ func TestInt16Int64MapValue(t *testing.T) { v := newInt16Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int64", v.Type()) @@ -7392,11 +7392,11 @@ func TestInt16Int64MapValue(t *testing.T) { v := newInt16Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int64", v.Type()) @@ -7411,17 +7411,17 @@ func TestInt32Int64MapValue(t *testing.T) { v := newInt32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int64", v.Type()) @@ -7433,11 +7433,11 @@ func TestInt32Int64MapValue(t *testing.T) { v := newInt32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int64", v.Type()) @@ -7452,17 +7452,17 @@ func TestInt64Int64MapValue(t *testing.T) { v := newInt64Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("7:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int64", v.Type()) @@ -7474,11 +7474,11 @@ func TestInt64Int64MapValue(t *testing.T) { v := newInt64Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int64", v.Type()) @@ -7493,17 +7493,17 @@ func TestUintInt64MapValue(t *testing.T) { v := newUintInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int64", v.Type()) @@ -7515,11 +7515,11 @@ func TestUintInt64MapValue(t *testing.T) { v := newUintInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int64", v.Type()) @@ -7534,17 +7534,17 @@ func TestUint8Int64MapValue(t *testing.T) { v := newUint8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int64", v.Type()) @@ -7556,11 +7556,11 @@ func TestUint8Int64MapValue(t *testing.T) { v := newUint8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int64", v.Type()) @@ -7575,13 +7575,13 @@ func TestUint16Int64MapValue(t *testing.T) { v := newUint16Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -7597,11 +7597,11 @@ func TestUint16Int64MapValue(t *testing.T) { v := newUint16Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int64", v.Type()) @@ -7616,17 +7616,17 @@ func TestUint32Int64MapValue(t *testing.T) { v := newUint32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int64", v.Type()) @@ -7638,11 +7638,11 @@ func TestUint32Int64MapValue(t *testing.T) { v := newUint32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int64", v.Type()) @@ -7657,17 +7657,17 @@ func TestUint64Int64MapValue(t *testing.T) { v := newUint64Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("1:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int64", v.Type()) @@ -7683,7 +7683,7 @@ func TestUint64Int64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int64", v.Type()) @@ -7879,13 +7879,13 @@ func TestStringFloat64MapValue(t *testing.T) { v := newStringFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("hTtUT10.2") + err = v.Set("dVhza10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uWJRG:10.2") + err = v.Set("pMsAo:10.2") assert.Nil(t, err) - err = v.Set("iQjOT20.99") + err = v.Set("xEEAV20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("cVwHj:20.99") + err = v.Set("qXQPe:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]float64", v.Type()) @@ -7897,9 +7897,9 @@ func TestStringFloat64MapValue(t *testing.T) { v := newStringFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("KVtPoa") + err = v.Set("aRkYla") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("VVTYN:a") + err = v.Set("pgwVB:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]float64", v.Type()) @@ -7914,17 +7914,17 @@ func TestIntFloat64MapValue(t *testing.T) { v := newIntFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110.2") + err = v.Set("510.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("5:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("520.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("5:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float64", v.Type()) @@ -7936,11 +7936,11 @@ func TestIntFloat64MapValue(t *testing.T) { v := newIntFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float64", v.Type()) @@ -7955,17 +7955,17 @@ func TestInt8Float64MapValue(t *testing.T) { v := newInt8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("620.99") + err = v.Set("720.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("4:20.99") + err = v.Set("6:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float64", v.Type()) @@ -7977,11 +7977,11 @@ func TestInt8Float64MapValue(t *testing.T) { v := newInt8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float64", v.Type()) @@ -7996,13 +7996,13 @@ func TestInt16Float64MapValue(t *testing.T) { v := newInt16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710.2") + err = v.Set("510.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("520.99") + err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) @@ -8018,11 +8018,11 @@ func TestInt16Float64MapValue(t *testing.T) { v := newInt16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]float64", v.Type()) @@ -8037,17 +8037,17 @@ func TestInt32Float64MapValue(t *testing.T) { v := newInt32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510.2") + err = v.Set("110.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("2:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("220.99") + err = v.Set("120.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("4:20.99") + err = v.Set("5:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float64", v.Type()) @@ -8059,11 +8059,11 @@ func TestInt32Float64MapValue(t *testing.T) { v := newInt32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float64", v.Type()) @@ -8078,17 +8078,17 @@ func TestInt64Float64MapValue(t *testing.T) { v := newInt64Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("3:10.2") + err = v.Set("6:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("3:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float64", v.Type()) @@ -8100,11 +8100,11 @@ func TestInt64Float64MapValue(t *testing.T) { v := newInt64Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float64", v.Type()) @@ -8119,17 +8119,17 @@ func TestUintFloat64MapValue(t *testing.T) { v := newUintFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("7:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("620.99") + err = v.Set("120.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("3:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]float64", v.Type()) @@ -8141,11 +8141,11 @@ func TestUintFloat64MapValue(t *testing.T) { v := newUintFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]float64", v.Type()) @@ -8160,17 +8160,17 @@ func TestUint8Float64MapValue(t *testing.T) { v := newUint8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.2") + err = v.Set("610.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("5:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("120.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float64", v.Type()) @@ -8182,11 +8182,11 @@ func TestUint8Float64MapValue(t *testing.T) { v := newUint8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float64", v.Type()) @@ -8201,17 +8201,17 @@ func TestUint16Float64MapValue(t *testing.T) { v := newUint16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010.2") + err = v.Set("710.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("320.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("7:20.99") + err = v.Set("5:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float64", v.Type()) @@ -8223,11 +8223,11 @@ func TestUint16Float64MapValue(t *testing.T) { v := newUint16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float64", v.Type()) @@ -8246,7 +8246,7 @@ func TestUint32Float64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("3:10.2") assert.Nil(t, err) err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -8264,11 +8264,11 @@ func TestUint32Float64MapValue(t *testing.T) { v := newUint32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float64", v.Type()) @@ -8283,17 +8283,17 @@ func TestUint64Float64MapValue(t *testing.T) { v := newUint64Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410.2") + err = v.Set("710.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("7:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("320.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("4:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]float64", v.Type()) @@ -8305,11 +8305,11 @@ func TestUint64Float64MapValue(t *testing.T) { v := newUint64Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("6:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]float64", v.Type()) @@ -8505,13 +8505,13 @@ func TestStringFloat32MapValue(t *testing.T) { v := newStringFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("aWlfV10.2") + err = v.Set("GrXUf10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("cjYMc:10.2") + err = v.Set("gQrwG:10.2") assert.Nil(t, err) - err = v.Set("wVxDr20.99") + err = v.Set("lztbz20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nsfUr:20.99") + err = v.Set("RXHcI:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]float32", v.Type()) @@ -8523,9 +8523,9 @@ func TestStringFloat32MapValue(t *testing.T) { v := newStringFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("CFsVya") + err = v.Set("ZQpDxa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("SzWtb:a") + err = v.Set("XeJjf:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]float32", v.Type()) @@ -8540,17 +8540,17 @@ func TestIntFloat32MapValue(t *testing.T) { v := newIntFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710.2") + err = v.Set("410.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("3:10.2") assert.Nil(t, err) - err = v.Set("520.99") + err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float32", v.Type()) @@ -8562,7 +8562,7 @@ func TestIntFloat32MapValue(t *testing.T) { v := newIntFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -8581,17 +8581,17 @@ func TestInt8Float32MapValue(t *testing.T) { v := newInt8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710.2") + err = v.Set("510.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("6:10.2") assert.Nil(t, err) - err = v.Set("520.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("5:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float32", v.Type()) @@ -8603,7 +8603,7 @@ func TestInt8Float32MapValue(t *testing.T) { v := newInt8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -8622,17 +8622,17 @@ func TestInt16Float32MapValue(t *testing.T) { v := newInt16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("7:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("020.99") + err = v.Set("620.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]float32", v.Type()) @@ -8644,11 +8644,11 @@ func TestInt16Float32MapValue(t *testing.T) { v := newInt16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]float32", v.Type()) @@ -8663,17 +8663,17 @@ func TestInt32Float32MapValue(t *testing.T) { v := newInt32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510.2") + err = v.Set("110.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("2:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("120.99") + err = v.Set("520.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("4:20.99") + err = v.Set("3:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float32", v.Type()) @@ -8685,11 +8685,11 @@ func TestInt32Float32MapValue(t *testing.T) { v := newInt32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float32", v.Type()) @@ -8704,17 +8704,17 @@ func TestInt64Float32MapValue(t *testing.T) { v := newInt64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("7:10.2") assert.Nil(t, err) - err = v.Set("720.99") + err = v.Set("120.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("4:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float32", v.Type()) @@ -8726,11 +8726,11 @@ func TestInt64Float32MapValue(t *testing.T) { v := newInt64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float32", v.Type()) @@ -8745,17 +8745,17 @@ func TestUintFloat32MapValue(t *testing.T) { v := newUintFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410.2") + err = v.Set("610.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("6:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]float32", v.Type()) @@ -8767,11 +8767,11 @@ func TestUintFloat32MapValue(t *testing.T) { v := newUintFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]float32", v.Type()) @@ -8786,17 +8786,17 @@ func TestUint8Float32MapValue(t *testing.T) { v := newUint8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410.2") + err = v.Set("010.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("1:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("120.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8812,7 +8812,7 @@ func TestUint8Float32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8827,17 +8827,17 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("5:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("220.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float32", v.Type()) @@ -8849,11 +8849,11 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float32", v.Type()) @@ -8868,17 +8868,17 @@ func TestUint32Float32MapValue(t *testing.T) { v := newUint32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.2") + err = v.Set("610.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("4:10.2") + err = v.Set("0:10.2") assert.Nil(t, err) - err = v.Set("220.99") + err = v.Set("520.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("0:20.99") + err = v.Set("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float32", v.Type()) @@ -8890,11 +8890,11 @@ func TestUint32Float32MapValue(t *testing.T) { v := newUint32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float32", v.Type()) @@ -8909,13 +8909,13 @@ func TestUint64Float32MapValue(t *testing.T) { v := newUint64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("520.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) @@ -8931,7 +8931,7 @@ func TestUint64Float32MapValue(t *testing.T) { v := newUint64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -8968,7 +8968,7 @@ func TestDurationValue(t *testing.T) { v := newDurationValue(a) assert.Equal(t, parseGenerated(a), v) err := v.Set("3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, "0s", v.String()) assert.Equal(t, *a, v.Get()) assert.Equal(t, "duration", v.Type()) @@ -9106,7 +9106,7 @@ func TestDurationSliceValue(t *testing.T) { assert.Equal(t, parseGenerated(a), v) assert.True(t, v.IsCumulative()) err = v.Set("1s,3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, "[]", v.String()) assert.Equal(t, *a, v.Get()) assert.Equal(t, "durationSlice", v.Type()) @@ -9121,13 +9121,13 @@ func TestStringDurationMapValue(t *testing.T) { v := newStringDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("oLEzi10s") + err = v.Set("RgLTs10s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JiWmA:10s") + err = v.Set("yROpJ:10s") assert.Nil(t, err) - err = v.Set("PKvAT30m") + err = v.Set("uXVQl30m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("djZyE:30m") + err = v.Set("ARHxL:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]time.Duration", v.Type()) @@ -9139,10 +9139,10 @@ func TestStringDurationMapValue(t *testing.T) { v := newStringDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("vvmsI3l") + err = v.Set("qFbQh3l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("DSJeK:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("IcUSQ:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9156,13 +9156,13 @@ func TestIntDurationMapValue(t *testing.T) { v := newIntDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210s") + err = v.Set("010s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("5:10s") + err = v.Set("1:10s") assert.Nil(t, err) - err = v.Set("130m") + err = v.Set("430m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) @@ -9178,12 +9178,12 @@ func TestIntDurationMapValue(t *testing.T) { v := newIntDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("63l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("0:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("4:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9197,17 +9197,17 @@ func TestInt8DurationMapValue(t *testing.T) { v := newInt8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510s") + err = v.Set("210s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("0:10s") + err = v.Set("2:10s") assert.Nil(t, err) err = v.Set("330m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("0:30m") + err = v.Set("6:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]time.Duration", v.Type()) @@ -9219,12 +9219,12 @@ func TestInt8DurationMapValue(t *testing.T) { v := newInt8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("53l") + err = v.Set("73l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("5:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("0:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9238,17 +9238,17 @@ func TestInt16DurationMapValue(t *testing.T) { v := newInt16DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510s") + err = v.Set("010s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) err = v.Set("4:10s") assert.Nil(t, err) - err = v.Set("230m") + err = v.Set("130m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("7:30m") + err = v.Set("1:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]time.Duration", v.Type()) @@ -9260,12 +9260,12 @@ func TestInt16DurationMapValue(t *testing.T) { v := newInt16DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("53l") + err = v.Set("23l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("1:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("2:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9279,17 +9279,17 @@ func TestInt32DurationMapValue(t *testing.T) { v := newInt32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410s") + err = v.Set("610s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("7:10s") + err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("530m") + err = v.Set("630m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("0:30m") + err = v.Set("1:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]time.Duration", v.Type()) @@ -9305,8 +9305,8 @@ func TestInt32DurationMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("3:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("5:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9320,17 +9320,17 @@ func TestInt64DurationMapValue(t *testing.T) { v := newInt64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110s") + err = v.Set("210s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("3:10s") + err = v.Set("1:10s") assert.Nil(t, err) - err = v.Set("130m") + err = v.Set("330m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("7:30m") + err = v.Set("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]time.Duration", v.Type()) @@ -9342,12 +9342,12 @@ func TestInt64DurationMapValue(t *testing.T) { v := newInt64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("73l") + err = v.Set("03l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("1:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("0:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9361,17 +9361,17 @@ func TestUintDurationMapValue(t *testing.T) { v := newUintDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710s") + err = v.Set("010s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("6:10s") + err = v.Set("4:10s") assert.Nil(t, err) - err = v.Set("730m") + err = v.Set("130m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("4:30m") + err = v.Set("7:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]time.Duration", v.Type()) @@ -9387,8 +9387,8 @@ func TestUintDurationMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("3:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("0:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9402,17 +9402,17 @@ func TestUint8DurationMapValue(t *testing.T) { v := newUint8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710s") + err = v.Set("110s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("2:10s") + err = v.Set("6:10s") assert.Nil(t, err) - err = v.Set("730m") + err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("4:30m") + err = v.Set("7:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]time.Duration", v.Type()) @@ -9424,12 +9424,12 @@ func TestUint8DurationMapValue(t *testing.T) { v := newUint8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("03l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("6:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("1:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9443,17 +9443,17 @@ func TestUint16DurationMapValue(t *testing.T) { v := newUint16DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710s") + err = v.Set("210s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("4:10s") + err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("230m") + err = v.Set("530m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("6:30m") + err = v.Set("4:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]time.Duration", v.Type()) @@ -9465,12 +9465,12 @@ func TestUint16DurationMapValue(t *testing.T) { v := newUint16DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("73l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("4:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("0:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9484,17 +9484,17 @@ func TestUint32DurationMapValue(t *testing.T) { v := newUint32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710s") + err = v.Set("110s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("2:10s") + err = v.Set("1:10s") assert.Nil(t, err) err = v.Set("630m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("6:30m") + err = v.Set("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]time.Duration", v.Type()) @@ -9506,12 +9506,12 @@ func TestUint32DurationMapValue(t *testing.T) { v := newUint32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("23l") + err = v.Set("73l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("1:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + err = v.Set("6:3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9525,17 +9525,17 @@ func TestUint64DurationMapValue(t *testing.T) { v := newUint64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710s") + err = v.Set("410s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) err = v.Set("2:10s") assert.Nil(t, err) - err = v.Set("330m") + err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("5:30m") + err = v.Set("3:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]time.Duration", v.Type()) @@ -9547,12 +9547,12 @@ func TestUint64DurationMapValue(t *testing.T) { v := newUint64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("33l") + err = v.Set("43l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) err = v.Set("3:3l") - assert.EqualError(t, err, "time: unknown unit l in duration 3l") + assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]time.Duration", v.Type()) assert.Empty(t, v.String()) @@ -9737,13 +9737,13 @@ func TestStringIPMapValue(t *testing.T) { v := newStringIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("iyeoU127.0.0.1") + err = v.Set("QFFBa127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qzMJG:127.0.0.1") + err = v.Set("mqHlH:127.0.0.1") assert.Nil(t, err) - err = v.Set("HOxYT127.0.0.3") + err = v.Set("BBiLL127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("sbfqA:127.0.0.3") + err = v.Set("PUJSy:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]net.IP", v.Type()) @@ -9755,9 +9755,9 @@ func TestStringIPMapValue(t *testing.T) { v := newStringIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("qtXjk127.0.0.1.3") + err = v.Set("onkvD127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("VItIB:127.0.0.1.3") + err = v.Set("ZffwS:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]net.IP", v.Type()) @@ -9772,17 +9772,17 @@ func TestIntIPMapValue(t *testing.T) { v := newIntIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1") + err = v.Set("0127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1") + err = v.Set("5:127.0.0.1") assert.Nil(t, err) - err = v.Set("6127.0.0.3") + err = v.Set("5127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("5:127.0.0.3") + err = v.Set("6:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IP", v.Type()) @@ -9794,11 +9794,11 @@ func TestIntIPMapValue(t *testing.T) { v := newIntIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4127.0.0.1.3") + err = v.Set("2127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("1:127.0.0.1.3") + err = v.Set("5:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IP", v.Type()) @@ -9813,17 +9813,17 @@ func TestInt8IPMapValue(t *testing.T) { v := newInt8IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.0.0.1") + err = v.Set("6127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("4:127.0.0.1") + err = v.Set("7:127.0.0.1") assert.Nil(t, err) - err = v.Set("1127.0.0.3") + err = v.Set("0127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("5:127.0.0.3") + err = v.Set("7:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]net.IP", v.Type()) @@ -9835,11 +9835,11 @@ func TestInt8IPMapValue(t *testing.T) { v := newInt8IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1.3") + err = v.Set("3127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("4:127.0.0.1.3") + err = v.Set("2:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]net.IP", v.Type()) @@ -9854,17 +9854,17 @@ func TestInt16IPMapValue(t *testing.T) { v := newInt16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4127.0.0.1") + err = v.Set("3127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("1:127.0.0.1") + err = v.Set("3:127.0.0.1") assert.Nil(t, err) - err = v.Set("2127.0.0.3") + err = v.Set("5127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("1:127.0.0.3") + err = v.Set("7:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IP", v.Type()) @@ -9876,11 +9876,11 @@ func TestInt16IPMapValue(t *testing.T) { v := newInt16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5127.0.0.1.3") + err = v.Set("4127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("6:127.0.0.1.3") + err = v.Set("4:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IP", v.Type()) @@ -9895,13 +9895,13 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.0.0.1") + err = v.Set("7127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("3:127.0.0.1") + err = v.Set("5:127.0.0.1") assert.Nil(t, err) - err = v.Set("5127.0.0.3") + err = v.Set("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) @@ -9917,11 +9917,11 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1.3") + err = v.Set("5127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("3:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IP", v.Type()) @@ -9936,17 +9936,17 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4127.0.0.1") + err = v.Set("2127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("7:127.0.0.1") + err = v.Set("1:127.0.0.1") assert.Nil(t, err) - err = v.Set("7127.0.0.3") + err = v.Set("0127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.3") + err = v.Set("4:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IP", v.Type()) @@ -9958,11 +9958,11 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6127.0.0.1.3") + err = v.Set("0127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("1:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IP", v.Type()) @@ -9977,17 +9977,17 @@ func TestUintIPMapValue(t *testing.T) { v := newUintIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1127.0.0.1") + err = v.Set("6127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1") + err = v.Set("6:127.0.0.1") assert.Nil(t, err) - err = v.Set("7127.0.0.3") + err = v.Set("2127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("1:127.0.0.3") + err = v.Set("0:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]net.IP", v.Type()) @@ -9999,11 +9999,11 @@ func TestUintIPMapValue(t *testing.T) { v := newUintIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.0.0.1.3") + err = v.Set("1127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("6:127.0.0.1.3") + err = v.Set("3:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]net.IP", v.Type()) @@ -10018,17 +10018,17 @@ func TestUint8IPMapValue(t *testing.T) { v := newUint8IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5127.0.0.1") + err = v.Set("7127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) err = v.Set("6:127.0.0.1") assert.Nil(t, err) - err = v.Set("5127.0.0.3") + err = v.Set("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("4:127.0.0.3") + err = v.Set("6:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]net.IP", v.Type()) @@ -10040,11 +10040,11 @@ func TestUint8IPMapValue(t *testing.T) { v := newUint8IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.0.0.1.3") + err = v.Set("4127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("4:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]net.IP", v.Type()) @@ -10059,17 +10059,17 @@ func TestUint16IPMapValue(t *testing.T) { v := newUint16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3127.0.0.1") + err = v.Set("7127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("0:127.0.0.1") + err = v.Set("1:127.0.0.1") assert.Nil(t, err) - err = v.Set("3127.0.0.3") + err = v.Set("6127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("4:127.0.0.3") + err = v.Set("6:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]net.IP", v.Type()) @@ -10081,11 +10081,11 @@ func TestUint16IPMapValue(t *testing.T) { v := newUint16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.0.0.1.3") + err = v.Set("4127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("0:127.0.0.1.3") + err = v.Set("2:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]net.IP", v.Type()) @@ -10100,17 +10100,17 @@ func TestUint32IPMapValue(t *testing.T) { v := newUint32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1127.0.0.1") + err = v.Set("2127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("6:127.0.0.1") + err = v.Set("1:127.0.0.1") assert.Nil(t, err) - err = v.Set("2127.0.0.3") + err = v.Set("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("1:127.0.0.3") + err = v.Set("6:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IP", v.Type()) @@ -10122,11 +10122,11 @@ func TestUint32IPMapValue(t *testing.T) { v := newUint32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1.3") + err = v.Set("1127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("5:127.0.0.1.3") + err = v.Set("7:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IP", v.Type()) @@ -10141,17 +10141,17 @@ func TestUint64IPMapValue(t *testing.T) { v := newUint64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1") + err = v.Set("0127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("1:127.0.0.1") + err = v.Set("2:127.0.0.1") assert.Nil(t, err) err = v.Set("2127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("7:127.0.0.3") + err = v.Set("2:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]net.IP", v.Type()) @@ -10163,11 +10163,11 @@ func TestUint64IPMapValue(t *testing.T) { v := newUint64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5127.0.0.1.3") + err = v.Set("2127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("7:127.0.0.1.3") + err = v.Set("2:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]net.IP", v.Type()) @@ -10373,13 +10373,13 @@ func TestStringHexBytesMapValue(t *testing.T) { v := newStringHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("OxKmRff") + err = v.Set("ABWyoff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("NwKDO:ff") + err = v.Set("RJNHB:ff") assert.Nil(t, err) - err = v.Set("UnXzmaa") + err = v.Set("KJFGmaa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("DikdJ:aa") + err = v.Set("mnere:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]HexBytes", v.Type()) @@ -10391,9 +10391,9 @@ func TestStringHexBytesMapValue(t *testing.T) { v := newStringHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("PukQLgg") + err = v.Set("QMMMPgg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("axAHz:gg") + err = v.Set("iPFfK:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]HexBytes", v.Type()) @@ -10408,17 +10408,17 @@ func TestIntHexBytesMapValue(t *testing.T) { v := newIntHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3ff") + err = v.Set("6ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("4:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("5aa") + err = v.Set("7aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("6:aa") + err = v.Set("4:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]HexBytes", v.Type()) @@ -10430,11 +10430,11 @@ func TestIntHexBytesMapValue(t *testing.T) { v := newIntHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7gg") + err = v.Set("2gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("7:gg") + err = v.Set("5:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]HexBytes", v.Type()) @@ -10449,17 +10449,17 @@ func TestInt8HexBytesMapValue(t *testing.T) { v := newInt8HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4ff") + err = v.Set("6ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("0:ff") + err = v.Set("7:ff") assert.Nil(t, err) - err = v.Set("3aa") + err = v.Set("4aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("6:aa") + err = v.Set("5:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]HexBytes", v.Type()) @@ -10471,7 +10471,7 @@ func TestInt8HexBytesMapValue(t *testing.T) { v := newInt8HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1gg") + err = v.Set("3gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) @@ -10490,17 +10490,17 @@ func TestInt16HexBytesMapValue(t *testing.T) { v := newInt16HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4ff") + err = v.Set("2ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("1:ff") + err = v.Set("7:ff") assert.Nil(t, err) - err = v.Set("2aa") + err = v.Set("1aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("6:aa") + err = v.Set("7:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]HexBytes", v.Type()) @@ -10512,11 +10512,11 @@ func TestInt16HexBytesMapValue(t *testing.T) { v := newInt16HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6gg") + err = v.Set("3gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("2:gg") + err = v.Set("6:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]HexBytes", v.Type()) @@ -10535,13 +10535,13 @@ func TestInt32HexBytesMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("6:ff") + err = v.Set("4:ff") assert.Nil(t, err) - err = v.Set("4aa") + err = v.Set("5aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("4:aa") + err = v.Set("5:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]HexBytes", v.Type()) @@ -10553,11 +10553,11 @@ func TestInt32HexBytesMapValue(t *testing.T) { v := newInt32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7gg") + err = v.Set("5gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("3:gg") + err = v.Set("6:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]HexBytes", v.Type()) @@ -10572,13 +10572,13 @@ func TestInt64HexBytesMapValue(t *testing.T) { v := newInt64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6ff") + err = v.Set("1ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("5:ff") + err = v.Set("7:ff") assert.Nil(t, err) - err = v.Set("0aa") + err = v.Set("1aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) @@ -10594,11 +10594,11 @@ func TestInt64HexBytesMapValue(t *testing.T) { v := newInt64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2gg") + err = v.Set("4gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("6:gg") + err = v.Set("7:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]HexBytes", v.Type()) @@ -10613,13 +10613,13 @@ func TestUintHexBytesMapValue(t *testing.T) { v := newUintHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4ff") + err = v.Set("5ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("1:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("7aa") + err = v.Set("3aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) @@ -10635,11 +10635,11 @@ func TestUintHexBytesMapValue(t *testing.T) { v := newUintHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4gg") + err = v.Set("2gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("6:gg") + err = v.Set("5:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]HexBytes", v.Type()) @@ -10654,17 +10654,17 @@ func TestUint8HexBytesMapValue(t *testing.T) { v := newUint8HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2ff") + err = v.Set("5ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("1:ff") + err = v.Set("7:ff") assert.Nil(t, err) - err = v.Set("5aa") + err = v.Set("7aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("1:aa") + err = v.Set("6:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]HexBytes", v.Type()) @@ -10676,11 +10676,11 @@ func TestUint8HexBytesMapValue(t *testing.T) { v := newUint8HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4gg") + err = v.Set("5gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("5:gg") + err = v.Set("1:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]HexBytes", v.Type()) @@ -10699,13 +10699,13 @@ func TestUint16HexBytesMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("4:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("6aa") + err = v.Set("5aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("5:aa") + err = v.Set("3:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]HexBytes", v.Type()) @@ -10717,11 +10717,11 @@ func TestUint16HexBytesMapValue(t *testing.T) { v := newUint16HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3gg") + err = v.Set("6gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("6:gg") + err = v.Set("5:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]HexBytes", v.Type()) @@ -10736,17 +10736,17 @@ func TestUint32HexBytesMapValue(t *testing.T) { v := newUint32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0ff") + err = v.Set("2ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("7:ff") + err = v.Set("3:ff") assert.Nil(t, err) - err = v.Set("5aa") + err = v.Set("0aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("6:aa") + err = v.Set("1:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]HexBytes", v.Type()) @@ -10758,11 +10758,11 @@ func TestUint32HexBytesMapValue(t *testing.T) { v := newUint32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6gg") + err = v.Set("4gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("5:gg") + err = v.Set("4:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]HexBytes", v.Type()) @@ -10777,17 +10777,17 @@ func TestUint64HexBytesMapValue(t *testing.T) { v := newUint64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1ff") + err = v.Set("4ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("2:ff") + err = v.Set("5:ff") assert.Nil(t, err) - err = v.Set("6aa") + err = v.Set("7aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("4:aa") + err = v.Set("5:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]HexBytes", v.Type()) @@ -10799,11 +10799,11 @@ func TestUint64HexBytesMapValue(t *testing.T) { v := newUint64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5gg") + err = v.Set("6gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("3:gg") + err = v.Set("1:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]HexBytes", v.Type()) @@ -10989,13 +10989,13 @@ func TestStringRegexpMapValue(t *testing.T) { v := newStringRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("LLBLbabc.*") + err = v.Set("CDpUTabc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uEhZF:abc.*") + err = v.Set("ysOwM:abc.*") assert.Nil(t, err) - err = v.Set("xQuvAxyz.*") + err = v.Set("nwZIsxyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("pLIPk:xyz.*") + err = v.Set("pUbMr:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]*regexp.Regexp", v.Type()) @@ -11007,9 +11007,9 @@ func TestStringRegexpMapValue(t *testing.T) { v := newStringRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("PzXDP[abc") + err = v.Set("IaMKg[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("izdhp:[abc") + err = v.Set("Wwbwj:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]*regexp.Regexp", v.Type()) @@ -11024,17 +11024,17 @@ func TestIntRegexpMapValue(t *testing.T) { v := newIntRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2abc.*") + err = v.Set("6abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("3:abc.*") + err = v.Set("2:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + err = v.Set("7xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("1:xyz.*") + err = v.Set("5:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]*regexp.Regexp", v.Type()) @@ -11046,11 +11046,11 @@ func TestIntRegexpMapValue(t *testing.T) { v := newIntRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0[abc") + err = v.Set("1[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("7:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]*regexp.Regexp", v.Type()) @@ -11071,11 +11071,11 @@ func TestInt8RegexpMapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + err = v.Set("0xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("7:xyz.*") + err = v.Set("2:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]*regexp.Regexp", v.Type()) @@ -11087,11 +11087,11 @@ func TestInt8RegexpMapValue(t *testing.T) { v := newInt8RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0[abc") + err = v.Set("7[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("0:[abc") + err = v.Set("6:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]*regexp.Regexp", v.Type()) @@ -11106,13 +11106,13 @@ func TestInt16RegexpMapValue(t *testing.T) { v := newInt16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5abc.*") + err = v.Set("0abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("0:abc.*") + err = v.Set("6:abc.*") assert.Nil(t, err) - err = v.Set("3xyz.*") + err = v.Set("5xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -11128,11 +11128,11 @@ func TestInt16RegexpMapValue(t *testing.T) { v := newInt16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2[abc") + err = v.Set("6[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("4:[abc") + err = v.Set("3:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]*regexp.Regexp", v.Type()) @@ -11151,13 +11151,13 @@ func TestInt32RegexpMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("6:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + err = v.Set("3xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("4:xyz.*") + err = v.Set("5:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]*regexp.Regexp", v.Type()) @@ -11169,11 +11169,11 @@ func TestInt32RegexpMapValue(t *testing.T) { v := newInt32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7[abc") + err = v.Set("5[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("2:[abc") + err = v.Set("7:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]*regexp.Regexp", v.Type()) @@ -11188,17 +11188,17 @@ func TestInt64RegexpMapValue(t *testing.T) { v := newInt64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2abc.*") + err = v.Set("6abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("4:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) - err = v.Set("4xyz.*") + err = v.Set("0xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("7:xyz.*") + err = v.Set("2:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]*regexp.Regexp", v.Type()) @@ -11210,11 +11210,11 @@ func TestInt64RegexpMapValue(t *testing.T) { v := newInt64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7[abc") + err = v.Set("4[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("0:[abc") + err = v.Set("6:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]*regexp.Regexp", v.Type()) @@ -11229,17 +11229,17 @@ func TestUintRegexpMapValue(t *testing.T) { v := newUintRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1abc.*") + err = v.Set("2abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("5:abc.*") + err = v.Set("0:abc.*") assert.Nil(t, err) - err = v.Set("6xyz.*") + err = v.Set("4xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("4:xyz.*") + err = v.Set("1:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]*regexp.Regexp", v.Type()) @@ -11251,7 +11251,7 @@ func TestUintRegexpMapValue(t *testing.T) { v := newUintRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2[abc") + err = v.Set("7[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) @@ -11270,17 +11270,17 @@ func TestUint8RegexpMapValue(t *testing.T) { v := newUint8RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1abc.*") + err = v.Set("0abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("0:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) - err = v.Set("6xyz.*") + err = v.Set("5xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("5:xyz.*") + err = v.Set("6:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]*regexp.Regexp", v.Type()) @@ -11292,11 +11292,11 @@ func TestUint8RegexpMapValue(t *testing.T) { v := newUint8RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5[abc") + err = v.Set("4[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("5:[abc") + err = v.Set("3:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]*regexp.Regexp", v.Type()) @@ -11311,13 +11311,13 @@ func TestUint16RegexpMapValue(t *testing.T) { v := newUint16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6abc.*") + err = v.Set("5abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("2:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) - err = v.Set("4xyz.*") + err = v.Set("7xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -11333,11 +11333,11 @@ func TestUint16RegexpMapValue(t *testing.T) { v := newUint16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3[abc") + err = v.Set("7[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("3:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]*regexp.Regexp", v.Type()) @@ -11352,13 +11352,13 @@ func TestUint32RegexpMapValue(t *testing.T) { v := newUint32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4abc.*") + err = v.Set("3abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("2:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("3xyz.*") + err = v.Set("2xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -11374,11 +11374,11 @@ func TestUint32RegexpMapValue(t *testing.T) { v := newUint32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4[abc") + err = v.Set("3[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("3:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]*regexp.Regexp", v.Type()) @@ -11397,13 +11397,13 @@ func TestUint64RegexpMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("6:abc.*") + err = v.Set("3:abc.*") assert.Nil(t, err) err = v.Set("3xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("5:xyz.*") + err = v.Set("6:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]*regexp.Regexp", v.Type()) @@ -11415,11 +11415,11 @@ func TestUint64RegexpMapValue(t *testing.T) { v := newUint64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2[abc") + err = v.Set("4[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("4:[abc") + err = v.Set("6:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]*regexp.Regexp", v.Type()) @@ -11737,13 +11737,13 @@ func TestStringIPNetMapValue(t *testing.T) { v := newStringIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("EqCuP0.0.0.0/0") + err = v.Set("GMqSh0.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("DMNeu:0.0.0.0/0") + err = v.Set("BXpUO:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("iKTxR255.255.255.255/19") + err = v.Set("xbIVx255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("INKSz:255.255.255.255/19") + err = v.Set("GHLzG:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]net.IPNet", v.Type()) @@ -11755,9 +11755,9 @@ func TestStringIPNetMapValue(t *testing.T) { v := newStringIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("jAIvx0.0.0.256/16") + err = v.Set("DXcEz0.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BRDRL:0.0.0.256/16") + err = v.Set("SMSwS:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]net.IPNet", v.Type()) @@ -11772,17 +11772,17 @@ func TestIntIPNetMapValue(t *testing.T) { v := newIntIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("00.0.0.0/0") + err = v.Set("10.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("6:0.0.0.0/0") + err = v.Set("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("0255.255.255.255/19") + err = v.Set("3255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("3:255.255.255.255/19") + err = v.Set("6:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IPNet", v.Type()) @@ -11794,11 +11794,11 @@ func TestIntIPNetMapValue(t *testing.T) { v := newIntIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("60.0.0.256/16") + err = v.Set("10.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("4:0.0.0.256/16") + err = v.Set("5:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IPNet", v.Type()) @@ -11813,13 +11813,13 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.0/0") + err = v.Set("50.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) @@ -11835,11 +11835,11 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.256/16") + err = v.Set("70.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("7:0.0.0.256/16") + err = v.Set("3:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]net.IPNet", v.Type()) @@ -11854,13 +11854,13 @@ func TestInt16IPNetMapValue(t *testing.T) { v := newInt16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.0/0") + err = v.Set("70.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("0:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("5255.255.255.255/19") + err = v.Set("2255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) @@ -11876,11 +11876,11 @@ func TestInt16IPNetMapValue(t *testing.T) { v := newInt16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("40.0.0.256/16") + err = v.Set("70.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("2:0.0.0.256/16") + err = v.Set("1:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IPNet", v.Type()) @@ -11895,17 +11895,17 @@ func TestInt32IPNetMapValue(t *testing.T) { v := newInt32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("00.0.0.0/0") + err = v.Set("20.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("2:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("7255.255.255.255/19") + err = v.Set("0255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("1:255.255.255.255/19") + err = v.Set("6:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IPNet", v.Type()) @@ -11917,11 +11917,11 @@ func TestInt32IPNetMapValue(t *testing.T) { v := newInt32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.256/16") + err = v.Set("60.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("2:0.0.0.256/16") + err = v.Set("1:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IPNet", v.Type()) @@ -11936,17 +11936,17 @@ func TestInt64IPNetMapValue(t *testing.T) { v := newInt64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.0/0") + err = v.Set("20.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) err = v.Set("5:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("5255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("2:255.255.255.255/19") + err = v.Set("3:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IPNet", v.Type()) @@ -11958,11 +11958,11 @@ func TestInt64IPNetMapValue(t *testing.T) { v := newInt64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.256/16") + err = v.Set("50.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("1:0.0.0.256/16") + err = v.Set("7:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IPNet", v.Type()) @@ -11977,13 +11977,13 @@ func TestUintIPNetMapValue(t *testing.T) { v := newUintIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("40.0.0.0/0") + err = v.Set("50.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("7:0.0.0.0/0") + err = v.Set("5:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("1255.255.255.255/19") + err = v.Set("7255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) @@ -11999,11 +11999,11 @@ func TestUintIPNetMapValue(t *testing.T) { v := newUintIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("60.0.0.256/16") + err = v.Set("20.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("2:0.0.0.256/16") + err = v.Set("6:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]net.IPNet", v.Type()) @@ -12018,13 +12018,13 @@ func TestUint8IPNetMapValue(t *testing.T) { v := newUint8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.0/0") + err = v.Set("20.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("1:0.0.0.0/0") + err = v.Set("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("4255.255.255.255/19") + err = v.Set("6255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) @@ -12040,11 +12040,11 @@ func TestUint8IPNetMapValue(t *testing.T) { v := newUint8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.256/16") + err = v.Set("00.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("6:0.0.0.256/16") + err = v.Set("4:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]net.IPNet", v.Type()) @@ -12059,17 +12059,17 @@ func TestUint16IPNetMapValue(t *testing.T) { v := newUint16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("40.0.0.0/0") + err = v.Set("60.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("7:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("2:255.255.255.255/19") + err = v.Set("5:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]net.IPNet", v.Type()) @@ -12081,7 +12081,7 @@ func TestUint16IPNetMapValue(t *testing.T) { v := newUint16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("40.0.0.256/16") + err = v.Set("20.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) @@ -12100,17 +12100,17 @@ func TestUint32IPNetMapValue(t *testing.T) { v := newUint32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.0/0") + err = v.Set("00.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("4:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("1255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("2:255.255.255.255/19") + err = v.Set("6:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IPNet", v.Type()) @@ -12122,11 +12122,11 @@ func TestUint32IPNetMapValue(t *testing.T) { v := newUint32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("50.0.0.256/16") + err = v.Set("00.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("5:0.0.0.256/16") + err = v.Set("4:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IPNet", v.Type()) @@ -12141,17 +12141,17 @@ func TestUint64IPNetMapValue(t *testing.T) { v := newUint64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("30.0.0.0/0") + err = v.Set("70.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("1:0.0.0.0/0") + err = v.Set("4:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("2255.255.255.255/19") + err = v.Set("1255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("7:255.255.255.255/19") + err = v.Set("1:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]net.IPNet", v.Type()) @@ -12163,7 +12163,7 @@ func TestUint64IPNetMapValue(t *testing.T) { v := newUint64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("50.0.0.256/16") + err = v.Set("00.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err)