diff --git a/README.md b/README.md index 93d5c05..574ffd0 100644 --- a/README.md +++ b/README.md @@ -52,7 +52,7 @@ And you can use your favorite flag or cli library! - [x] Required - [ ] Placeholders (by `name`) - [x] Deprecated and hidden options - - [ ] Multiple ENV names + - [x] Multiple ENV names - [x] Interface for user types. - [x] [Validation](https://godoc.org/github.com/urfave/sflags/validator/govalidator#New) (using [govalidator](https://github.com/asaskevich/govalidator) package) - [x] Anonymous nested structure support (anonymous structures flatten by default) diff --git a/flag.go b/flag.go index cdd2c90..b54f9a9 100644 --- a/flag.go +++ b/flag.go @@ -5,7 +5,7 @@ package sflags type Flag struct { Name string // name as it appears on command line Short string // optional short name - EnvName string + EnvNames []string Usage string // help message Value Value // value as set DefValue string // default value (as text); for usage message diff --git a/gen/gcli/gcli.go b/gen/gcli/gcli.go index f6c2391..f364b01 100644 --- a/gen/gcli/gcli.go +++ b/gen/gcli/gcli.go @@ -16,7 +16,7 @@ func GenerateTo(src []*sflags.Flag, dst *[]cli.Flag) { } *dst = append(*dst, &cli.GenericFlag{ Name: name, - EnvVars: []string{srcFlag.EnvName}, + EnvVars: srcFlag.EnvNames, Aliases: aliases, Hidden: srcFlag.Hidden, Usage: srcFlag.Usage, diff --git a/gen/gcli/gcliv3.go b/gen/gcli/gcliv3.go index d6f71f8..cf047d8 100644 --- a/gen/gcli/gcliv3.go +++ b/gen/gcli/gcliv3.go @@ -41,7 +41,7 @@ func GenerateToV3(src []*sflags.Flag, dst *[]cli.Flag) { } *dst = append(*dst, &cli.GenericFlag{ Name: name, - Sources: cli.EnvVars(srcFlag.EnvName), + Sources: cli.EnvVars(srcFlag.EnvNames...), Aliases: aliases, Hidden: srcFlag.Hidden, Usage: srcFlag.Usage, diff --git a/gen/gkingpin/gkingpin.go b/gen/gkingpin/gkingpin.go index 7c25547..20b6419 100644 --- a/gen/gkingpin/gkingpin.go +++ b/gen/gkingpin/gkingpin.go @@ -17,8 +17,8 @@ func GenerateTo(src []*sflags.Flag, dst flagger) { for _, srcFlag := range src { flag := dst.Flag(srcFlag.Name, srcFlag.Usage) flag.SetValue(srcFlag.Value) - if srcFlag.EnvName != "" { - flag.Envar(srcFlag.EnvName) + if len(srcFlag.EnvNames) > 0 && srcFlag.EnvNames[0] != "" { + flag.Envar(srcFlag.EnvNames[0]) } if srcFlag.Hidden { flag.Hidden() diff --git a/parser.go b/parser.go index 8199433..47a7c60 100644 --- a/parser.go +++ b/parser.go @@ -123,37 +123,47 @@ func parseFlagTag(field reflect.StructField, opt opts) *Flag { return &flag } -func parseEnv(flagName string, field reflect.StructField, opt opts) string { - ignoreEnvPrefix := false - envVar := flagToEnv(flagName, opt.flagDivider, opt.envDivider) +func parseEnv(flagName string, field reflect.StructField, opt opts) []string { + var envVars []string + flagEnvVar := flagToEnv(flagName, opt.flagDivider, opt.envDivider) if envTags := strings.Split(field.Tag.Get(defaultEnvTag), ","); len(envTags) > 0 { switch envName := envTags[0]; envName { case "-": - // if tag is `env:"-"` then won't fill flag from environment - envVar = "" + return envVars case "": // if tag is `env:""` then env var will be taken from flag name + envVars = append(envVars, opt.envPrefix+flagEnvVar) default: // if tag is `env:"NAME"` then env var is envPrefix_flagPrefix_NAME // if tag is `env:"~NAME"` then env var is NAME - if strings.HasPrefix(envName, "~") { - envVar = envName[1:] - ignoreEnvPrefix = true - } else { - envVar = envName - if opt.prefix != "" { - envVar = flagToEnv( - opt.prefix, - opt.flagDivider, - opt.envDivider) + envVar + for _, envName := range envTags { + ignoreEnvPrefix := false + var envVar string + if strings.HasPrefix(envName, "~") { + envVar = envName[1:] + ignoreEnvPrefix = true + } else { + envVar = envName + if opt.prefix != "" { + envVar = flagToEnv( + opt.prefix, + opt.flagDivider, + opt.envDivider) + envVar + } + } + if envVar != "" { + if !ignoreEnvPrefix { + envVars = append(envVars, opt.envPrefix+envVar) + } else { + envVars = append(envVars, envVar) + } } } } + } else if flagEnvVar != "" { + envVars = append(envVars, opt.envPrefix+flagEnvVar) } - if envVar != "" && opt.envPrefix != "" && !ignoreEnvPrefix { - envVar = opt.envPrefix + envVar - } - return envVar + return envVars } // ParseStruct parses structure and returns list of flags based on this structure. @@ -247,7 +257,7 @@ fields: continue fields } - flag.EnvName = parseEnv(flag.Name, field, opt) + flag.EnvNames = parseEnv(flag.Name, field, opt) flag.Usage = field.Tag.Get(opt.descTag) prefix := flag.Name + opt.flagDivider if field.Anonymous && opt.flatten { diff --git a/parser_test.go b/parser_test.go index da39eac..8cf3a2f 100644 --- a/parser_test.go +++ b/parser_test.go @@ -27,7 +27,8 @@ func TestParseStruct(t *testing.T) { Name4 *string Name5 string `flag:"-"` name6 string - Name7 int `flag:",required"` + Name7 int `flag:",required"` + Name8 float64 `flag:"name_8" env:"NAME_8,~nn_8"` Addr *net.TCPAddr @@ -122,7 +123,7 @@ func TestParseStruct(t *testing.T) { expFlagSet: []*Flag{ { Name: "name", - EnvName: "", + EnvNames: nil, DefValue: "name_value", Value: newStringValue(&simpleCfg.Name), Usage: "name description", @@ -130,7 +131,7 @@ func TestParseStruct(t *testing.T) { { Name: "name_two", Short: "t", - EnvName: "NAME_TWO", + EnvNames: []string{"NAME_TWO"}, DefValue: "name2_value", Value: newStringValue(&simpleCfg.Name2), Hidden: true, @@ -138,32 +139,38 @@ func TestParseStruct(t *testing.T) { }, { Name: "name3", - EnvName: "NAME_THREE", + EnvNames: []string{"NAME_THREE"}, DefValue: "", Value: newStringValue(&simpleCfg.Name3), }, { Name: "name4", - EnvName: "NAME4", + EnvNames: []string{"NAME4"}, DefValue: "name_value4", Value: newStringValue(simpleCfg.Name4), }, { Name: "name7", - EnvName: "NAME7", + EnvNames: []string{"NAME7"}, Required: true, DefValue: "0", Value: newIntValue(&simpleCfg.Name7), }, + { + Name: "name_8", + EnvNames: []string{"NAME_8", "nn_8"}, + DefValue: "0", + Value: newFloat64Value(&simpleCfg.Name8), + }, { Name: "addr", - EnvName: "ADDR", + EnvNames: []string{"ADDR"}, DefValue: "127.0.0.1:0", Value: newTCPAddrValue(simpleCfg.Addr), }, { Name: "map", - EnvName: "MAP", + EnvNames: []string{"MAP"}, DefValue: "map[test:15]", Value: newStringIntMapValue(&simpleCfg.Map), }, @@ -176,7 +183,7 @@ func TestParseStruct(t *testing.T) { expFlagSet: []*Flag{ { Name: "name", - EnvName: "", + EnvNames: nil, DefValue: "name_value", Value: newStringValue(&simpleCfg.Name), Usage: "name description", @@ -184,7 +191,7 @@ func TestParseStruct(t *testing.T) { { Name: "name_two", Short: "t", - EnvName: "PP|NAME_TWO", + EnvNames: []string{"PP|NAME_TWO"}, DefValue: "name2_value", Value: newStringValue(&simpleCfg.Name2), Hidden: true, @@ -192,32 +199,38 @@ func TestParseStruct(t *testing.T) { }, { Name: "name3", - EnvName: "PP|NAME_THREE", + EnvNames: []string{"PP|NAME_THREE"}, DefValue: "", Value: newStringValue(&simpleCfg.Name3), }, { Name: "name4", - EnvName: "PP|NAME4", + EnvNames: []string{"PP|NAME4"}, DefValue: "name_value4", Value: newStringValue(simpleCfg.Name4), }, { Name: "name7", - EnvName: "PP|NAME7", + EnvNames: []string{"PP|NAME7"}, Required: true, DefValue: "0", Value: newIntValue(&simpleCfg.Name7), }, + { + Name: "name_8", + EnvNames: []string{"PP|NAME_8", "nn_8"}, + DefValue: "0", + Value: newFloat64Value(&simpleCfg.Name8), + }, { Name: "addr", - EnvName: "PP|ADDR", + EnvNames: []string{"PP|ADDR"}, DefValue: "127.0.0.1:0", Value: newTCPAddrValue(simpleCfg.Addr), }, { Name: "map", - EnvName: "PP|MAP", + EnvNames: []string{"PP|MAP"}, DefValue: "map[test:15]", Value: newStringIntMapValue(&simpleCfg.Map), }, @@ -230,67 +243,67 @@ func TestParseStruct(t *testing.T) { expFlagSet: []*Flag{ { Name: "string-value", - EnvName: "STRING_VALUE", + EnvNames: []string{"STRING_VALUE"}, DefValue: "string", Value: newStringValue(&diffTypesCfg.StringValue), Usage: "", }, { Name: "byte-value", - EnvName: "BYTE_VALUE", + EnvNames: []string{"BYTE_VALUE"}, DefValue: "10", Value: newUint8Value(&diffTypesCfg.ByteValue), Usage: "", }, { Name: "string-slice-value", - EnvName: "STRING_SLICE_VALUE", + EnvNames: []string{"STRING_SLICE_VALUE"}, DefValue: "[]", Value: newStringSliceValue(&diffTypesCfg.StringSliceValue), Usage: "", }, { Name: "bool-slice-value", - EnvName: "BOOL_SLICE_VALUE", + EnvNames: []string{"BOOL_SLICE_VALUE"}, DefValue: "[]", Value: newBoolSliceValue(&diffTypesCfg.BoolSliceValue), Usage: "", }, { Name: "counter-value", - EnvName: "COUNTER_VALUE", + EnvNames: []string{"COUNTER_VALUE"}, DefValue: "10", Value: &diffTypesCfg.CounterValue, Usage: "", }, { Name: "regexp-value", - EnvName: "REGEXP_VALUE", + EnvNames: []string{"REGEXP_VALUE"}, DefValue: "", Value: newRegexpValue(&diffTypesCfg.RegexpValue), Usage: "", }, { Name: "map-int8-bool", - EnvName: "MAP_INT8_BOOL", + EnvNames: []string{"MAP_INT8_BOOL"}, DefValue: "", Value: newInt8BoolMapValue(&diffTypesCfg.MapInt8Bool), }, { Name: "map-int16-int8", - EnvName: "MAP_INT16_INT8", + EnvNames: []string{"MAP_INT16_INT8"}, DefValue: "", Value: newInt16Int8MapValue(&diffTypesCfg.MapInt16Int8), }, { Name: "map-string-int64", - EnvName: "MAP_STRING_INT64", + EnvNames: []string{"MAP_STRING_INT64"}, DefValue: "map[test:888]", Value: newStringInt64MapValue(&diffTypesCfg.MapStringInt64), }, { Name: "map-string-string", - EnvName: "MAP_STRING_STRING", + EnvNames: []string{"MAP_STRING_STRING"}, DefValue: "map[test:test-val]", Value: newStringStringMapValue(&diffTypesCfg.MapStringString), }, @@ -302,32 +315,32 @@ func TestParseStruct(t *testing.T) { expFlagSet: []*Flag{ { Name: "sub-name", - EnvName: "SUB_NAME", + EnvNames: []string{"SUB_NAME"}, DefValue: "name_value", Value: newStringValue(&nestedCfg.Sub.Name), Usage: "name description", }, { Name: "sub-name2", - EnvName: "SUB_NAME_TWO", + EnvNames: []string{"SUB_NAME_TWO"}, DefValue: "name2_value", Value: newStringValue(&nestedCfg.Sub.Name2), }, { Name: "name3", - EnvName: "NAME_THREE", + EnvNames: []string{"NAME_THREE"}, DefValue: "", Value: newStringValue(&nestedCfg.Sub.Name3), }, { Name: "sub-sub2-name4", - EnvName: "SUB_SUB2_NAME4", + EnvNames: []string{"SUB_SUB2_NAME4"}, DefValue: "name4_value", Value: newStringValue(&nestedCfg.Sub.SUB2.Name4), }, { Name: "sub-sub2-name5", - EnvName: "SUB_SUB2_name_five", + EnvNames: []string{"SUB_SUB2_name_five"}, DefValue: "", Value: newStringValue(&nestedCfg.Sub.SUB2.Name5), }, @@ -340,15 +353,15 @@ func TestParseStruct(t *testing.T) { optFuncs: []OptFunc{DescTag("description")}, expFlagSet: []*Flag{ { - Name: "name", - EnvName: "NAME", - Value: newStringValue(&descCfg.Name), + Name: "name", + EnvNames: []string{"NAME"}, + Value: newStringValue(&descCfg.Name), }, { - Name: "name2", - EnvName: "NAME2", - Value: newStringValue(&descCfg.Name2), - Usage: "name2 description", + Name: "name2", + EnvNames: []string{"NAME2"}, + Value: newStringValue(&descCfg.Name2), + Usage: "name2 description", }, }, }, @@ -357,13 +370,13 @@ func TestParseStruct(t *testing.T) { cfg: anonymousCfg, expFlagSet: []*Flag{ { - Name: "name1", - EnvName: "NAME1", - Value: newStringValue(&anonymousCfg.Name1), + Name: "name1", + EnvNames: []string{"NAME1"}, + Value: newStringValue(&anonymousCfg.Name1), }, { Name: "name", - EnvName: "NAME", + EnvNames: []string{"NAME"}, DefValue: "name_value", Value: newStringValue(&anonymousCfg.Name), }, @@ -375,13 +388,13 @@ func TestParseStruct(t *testing.T) { optFuncs: []OptFunc{Flatten(false)}, expFlagSet: []*Flag{ { - Name: "name1", - EnvName: "NAME1", - Value: newStringValue(&anonymousCfg.Name1), + Name: "name1", + EnvNames: []string{"NAME1"}, + Value: newStringValue(&anonymousCfg.Name1), }, { Name: "simple-name", - EnvName: "SIMPLE_NAME", + EnvNames: []string{"SIMPLE_NAME"}, DefValue: "name_value", Value: newStringValue(&anonymousCfg.Name), }, diff --git a/values_generated_test.go b/values_generated_test.go index 02ce66b..e148632 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("PjnxHval1") + err = v.Set("wrsgrval1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JGJtB:val1") + err = v.Set("UZFOx:val1") assert.Nil(t, err) - err = v.Set("jZFHkval2") + err = v.Set("HDbppval2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("iHPlL:val2") + err = v.Set("WeqHO: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("QhsBt") + err = v.Set("OVeUH") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Pviem:") + err = v.Set("kQsaU:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]string", v.Type()) @@ -202,17 +202,17 @@ func TestIntStringMapValue(t *testing.T) { v := newIntStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6val1") + 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("6: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) - err = v.Set("3:val2") + err = v.Set("7:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]string", v.Type()) @@ -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("3") + 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("2:") + 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("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("1:val1") + err = v.Set("7:val1") assert.Nil(t, err) - err = v.Set("6val2") + err = v.Set("3val2") 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("2: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("6") 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("2:") 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("6: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("7:val2") + err = v.Set("2: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("0") 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("6:") 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("4val1") + err = v.Set("1val1") 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("6: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("5:val2") + err = v.Set("0: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("7") 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[int32]string", v.Type()) @@ -370,13 +370,13 @@ func TestInt64StringMapValue(t *testing.T) { 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("7val2") + err = v.Set("3val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("5: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("0") + 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("0:") + err = v.Set("6:") 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("6val1") + err = v.Set("1val1") 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("0: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("1:val2") + err = v.Set("5:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]string", v.Type()) @@ -429,7 +429,7 @@ func TestUintStringMapValue(t *testing.T) { v := newUintStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3") + err = v.Set("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) @@ -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("3val1") + err = v.Set("1val1") 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("4val2") + err = v.Set("1val2") 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("0:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -470,7 +470,7 @@ 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("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) @@ -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("4val1") + 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("0:val1") + err = v.Set("4: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("1:val2") + err = v.Set("6:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -511,7 +511,7 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2") + err = v.Set("4") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) @@ -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("6val1") + err = v.Set("1val1") 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("5: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("5:val2") + err = v.Set("2: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("6") 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("7:") 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("6val1") + err = v.Set("4val1") 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("6:val1") assert.Nil(t, err) - err = v.Set("1val2") + 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("6:val2") + err = v.Set("2: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("6:") 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("ztFTqtrue") + err = v.Set("xtPRdtrue") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("RjWBg:true") + err = v.Set("IgVpT:true") assert.Nil(t, err) - err = v.Set("prfzMfalse") + err = v.Set("UDQDefalse") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kIMOi:false") + err = v.Set("FleAe: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("NBOqcunexpected") + err = v.Set("IzEfIunexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("tnDZE:unexpected") + err = v.Set("PLJAS: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("7true") + 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("1:true") + err = v.Set("7:true") assert.Nil(t, err) - err = v.Set("0false") + 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("5:false") + err = v.Set("3:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]bool", v.Type()) @@ -870,11 +870,11 @@ func TestIntBoolMapValue(t *testing.T) { v := newIntBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4unexpected") + err = v.Set("2unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("3: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[int]bool", v.Type()) @@ -893,13 +893,13 @@ func TestInt8BoolMapValue(t *testing.T) { 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("1:true") assert.Nil(t, err) - err = v.Set("3false") + err = v.Set("7false") 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("6: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("3unexpected") + err = v.Set("7unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("5: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("6true") + 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("6:true") + err = v.Set("4: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) - err = v.Set("7:false") + err = v.Set("6: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("2unexpected") + err = v.Set("7unexpected") 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("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,17 +971,17 @@ func TestInt32BoolMapValue(t *testing.T) { v := newInt32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5true") + 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("0:true") + err = v.Set("6:true") assert.Nil(t, err) - err = v.Set("0false") + err = v.Set("7false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("0:false") + err = v.Set("1:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]bool", v.Type()) @@ -997,7 +997,7 @@ func TestInt32BoolMapValue(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("3: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[int32]bool", v.Type()) @@ -1012,17 +1012,17 @@ 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("5true") 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("2false") + 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("3:false") + err = v.Set("7:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]bool", v.Type()) @@ -1034,7 +1034,7 @@ func TestInt64BoolMapValue(t *testing.T) { v := newInt64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6unexpected") + err = v.Set("5unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) @@ -1053,17 +1053,17 @@ func TestUintBoolMapValue(t *testing.T) { v := newUintBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3true") + 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("1: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("0:false") + err = v.Set("6:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]bool", v.Type()) @@ -1075,11 +1075,11 @@ 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) - err = v.Set("2: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[uint]bool", v.Type()) @@ -1094,17 +1094,17 @@ func TestUint8BoolMapValue(t *testing.T) { v := newUint8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4true") + err = v.Set("7true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("4:true") + err = v.Set("6:true") assert.Nil(t, err) - err = v.Set("3false") + 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("3:false") + err = v.Set("2:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]bool", v.Type()) @@ -1116,11 +1116,11 @@ func TestUint8BoolMapValue(t *testing.T) { v := newUint8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3unexpected") + 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("2: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("5true") 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("4:true") assert.Nil(t, err) - err = v.Set("6false") + 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("4:false") + err = v.Set("7: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("7unexpected") + 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("2: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("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("3:true") + err = v.Set("4:true") assert.Nil(t, err) - err = v.Set("7false") + err = v.Set("2false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("4:false") + err = v.Set("7:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]bool", v.Type()) @@ -1202,7 +1202,7 @@ func TestUint32BoolMapValue(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("0: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[uint32]bool", v.Type()) @@ -1217,13 +1217,13 @@ func TestUint64BoolMapValue(t *testing.T) { v := newUint64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2true") + 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("5:true") assert.Nil(t, err) - err = v.Set("0false") + err = v.Set("3false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) @@ -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("1unexpected") + 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("5: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[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("enuzv10") + err = v.Set("sTxqO10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("rFKbo:10") + err = v.Set("BnVXN:10") assert.Nil(t, err) - err = v.Set("biQMq20") + err = v.Set("XgzpF20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("SDfoO:20") + err = v.Set("ogrSY: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("qwrmY-1") + err = v.Set("ICxdC-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("lrHNu:-1") + err = v.Set("gFmOK:-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("410") 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("320") + 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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint", v.Type()) @@ -1506,11 +1506,11 @@ func TestIntUintMapValue(t *testing.T) { v := newIntUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-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("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[int]uint", v.Type()) @@ -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("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") 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("6:20") + err = v.Set("2: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("0-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("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("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("7: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("3: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("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("1:-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("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") 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("1:20") + err = v.Set("6: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("0-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[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("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("7: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("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint", v.Type()) @@ -1670,11 +1670,11 @@ func TestInt64UintMapValue(t *testing.T) { v := newInt64UintMapValue(&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("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[int64]uint", v.Type()) @@ -1689,17 +1689,17 @@ func TestUintUintMapValue(t *testing.T) { v := newUintUintMapValue(&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("7:10") + err = v.Set("5: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("7:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint", v.Type()) @@ -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("2-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("1:-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]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("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("4:10") + err = v.Set("1: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("2:20") + err = v.Set("3: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("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("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]uint", v.Type()) @@ -1771,13 +1771,13 @@ func TestUint16UintMapValue(t *testing.T) { v := newUint16UintMapValue(&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("6:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("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("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[uint16]uint", v.Type()) @@ -1816,13 +1816,13 @@ func TestUint32UintMapValue(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("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) - err = v.Set("1:20") + err = v.Set("0: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("0-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("3:-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()) @@ -1853,17 +1853,17 @@ func TestUint64UintMapValue(t *testing.T) { v := newUint64UintMapValue(&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("2: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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint", v.Type()) @@ -1879,7 +1879,7 @@ func TestUint64UintMapValue(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]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("qxbQs10") + err = v.Set("rGCRh10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FgeYF:10") + err = v.Set("GIDKP:10") assert.Nil(t, err) - err = v.Set("tkokN20") + err = v.Set("IgfuE20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Yxcii:20") + err = v.Set("yvWGn: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("UUpXP-1") + err = v.Set("vSCQu-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("rDddw:-1") + err = v.Set("duvqL:-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,7 +2120,7 @@ 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) @@ -2130,7 +2130,7 @@ func TestIntUint8MapValue(t *testing.T) { 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[int]uint8", v.Type()) @@ -2142,7 +2142,7 @@ func TestIntUint8MapValue(t *testing.T) { v := newIntUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-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) @@ -2165,13 +2165,13 @@ func TestInt8Uint8MapValue(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("2: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("3:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint8", v.Type()) @@ -2187,7 +2187,7 @@ func TestInt8Uint8MapValue(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[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("010") + 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("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("5: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("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("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[int16]uint8", v.Type()) @@ -2243,13 +2243,13 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&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("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -2269,7 +2269,7 @@ func TestInt32Uint8MapValue(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("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[int32]uint8", v.Type()) @@ -2284,17 +2284,17 @@ func TestInt64Uint8MapValue(t *testing.T) { v := newInt64Uint8MapValue(&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("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("1:20") + err = v.Set("3: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("0-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("7:-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[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("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("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("120") + 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("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("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("7:-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("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("5:10") assert.Nil(t, err) - err = v.Set("120") + 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("2:20") + err = v.Set("3: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("6-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("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[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("610") + 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("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("2: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("3-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("3:-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("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("1:10") + err = v.Set("5: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("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()) @@ -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("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("3: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("5:20") + err = v.Set("0: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("3-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("7:-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]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("cCMEf10") + err = v.Set("woLRx10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("MINCC:10") + err = v.Set("qcURU:10") assert.Nil(t, err) - err = v.Set("Unuhm20") + err = v.Set("ZZJpK20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gHNjr:20") + err = v.Set("ijFdU: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("QpOWW-1") + err = v.Set("btVXM-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("NKglz:-1") + err = v.Set("UxiKB:-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()) @@ -2756,17 +2756,17 @@ func TestIntUint16MapValue(t *testing.T) { v := newIntUint16MapValue(&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("1:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("220") + 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("4: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("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("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[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("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("2: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("2: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("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("0:-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()) @@ -2842,13 +2842,13 @@ func TestInt16Uint16MapValue(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("4: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("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint16", v.Type()) @@ -2864,7 +2864,7 @@ func TestInt16Uint16MapValue(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]uint16", v.Type()) @@ -2879,17 +2879,17 @@ 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("110") 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("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("0:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint16", v.Type()) @@ -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("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("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[int32]uint16", v.Type()) @@ -2920,17 +2920,17 @@ func TestInt64Uint16MapValue(t *testing.T) { v := newInt64Uint16MapValue(&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("1: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("0:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint16", v.Type()) @@ -2946,7 +2946,7 @@ func TestInt64Uint16MapValue(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("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[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("010") + 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("3:10") assert.Nil(t, err) - err = v.Set("120") + 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("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint16", v.Type()) @@ -3006,13 +3006,13 @@ func TestUint8Uint16MapValue(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("7: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("7:20") + err = v.Set("6: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("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("1:-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[uint8]uint16", v.Type()) @@ -3047,13 +3047,13 @@ func TestUint16Uint16MapValue(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("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("5: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,11 +3065,11 @@ func TestUint16Uint16MapValue(t *testing.T) { v := newUint16Uint16MapValue(&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) - 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[uint16]uint16", v.Type()) @@ -3084,17 +3084,17 @@ func TestUint32Uint16MapValue(t *testing.T) { v := newUint32Uint16MapValue(&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") + err = v.Set("5: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("2:20") + err = v.Set("1: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("0-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("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[uint32]uint16", v.Type()) @@ -3125,17 +3125,17 @@ func TestUint64Uint16MapValue(t *testing.T) { v := newUint64Uint16MapValue(&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("0:10") + err = v.Set("6: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("6:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint16", v.Type()) @@ -3151,7 +3151,7 @@ func TestUint64Uint16MapValue(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("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[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("EVXYF10") + err = v.Set("jUIFq10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JjvfF:10") + err = v.Set("uqvCQ:10") assert.Nil(t, err) - err = v.Set("mwoJb20") + err = v.Set("JgddE20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ZFZqU:20") + err = v.Set("NTETe: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("CZutW-1") + err = v.Set("GohSC-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("OWbBF:-1") + err = v.Set("Nhcim:-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()) @@ -3396,13 +3396,13 @@ func TestIntUint32MapValue(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("4: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("0: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("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("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[int]uint32", v.Type()) @@ -3433,17 +3433,17 @@ func TestInt8Uint32MapValue(t *testing.T) { v := newInt8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + 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") + err = v.Set("7: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("4:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint32", v.Type()) @@ -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("5-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("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[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("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("5:10") + 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("1: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("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("5:-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,17 +3515,17 @@ func TestInt32Uint32MapValue(t *testing.T) { v := newInt32Uint32MapValue(&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("5: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[int32]uint32", v.Type()) @@ -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("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("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[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("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("5:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("620") + 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("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("3-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("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()) @@ -3597,17 +3597,17 @@ func TestUintUint32MapValue(t *testing.T) { v := newUintUint32MapValue(&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("5:10") + err = v.Set("0: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("2:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3619,11 +3619,11 @@ func TestUintUint32MapValue(t *testing.T) { v := newUintUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-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("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("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("7: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("1:20") + err = v.Set("4: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("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("4:-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]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("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("2: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("7:20") + err = v.Set("4: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("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("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[uint16]uint32", v.Type()) @@ -3720,17 +3720,17 @@ func TestUint32Uint32MapValue(t *testing.T) { v := newUint32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + 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("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("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint32", v.Type()) @@ -3742,11 +3742,11 @@ func TestUint32Uint32MapValue(t *testing.T) { v := newUint32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-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("2:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint32", v.Type()) @@ -3761,13 +3761,13 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&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("2: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) @@ -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("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[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("cfnSM10") + err = v.Set("WicBB10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JNMZa:10") + err = v.Set("DDYhz:10") assert.Nil(t, err) - err = v.Set("siCln20") + err = v.Set("Wowlk20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("bAmgS:20") + err = v.Set("HyCsK: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("EbeZl-1") + err = v.Set("bldSl-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("sziRO:-1") + err = v.Set("htflf:-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,17 +4028,17 @@ func TestIntUint64MapValue(t *testing.T) { v := newIntUint64MapValue(&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("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("3:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint64", v.Type()) @@ -4050,11 +4050,11 @@ func TestIntUint64MapValue(t *testing.T) { v := newIntUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-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("2:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint64", v.Type()) @@ -4069,17 +4069,17 @@ func TestInt8Uint64MapValue(t *testing.T) { v := newInt8Uint64MapValue(&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("3:10") + err = v.Set("1: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("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint64", v.Type()) @@ -4091,11 +4091,11 @@ func TestInt8Uint64MapValue(t *testing.T) { v := newInt8Uint64MapValue(&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("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[int8]uint64", v.Type()) @@ -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("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("7:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + 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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint64", v.Type()) @@ -4132,11 +4132,11 @@ func TestInt16Uint64MapValue(t *testing.T) { v := newInt16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-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("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[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("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("5:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("320") + 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("3:20") + err = v.Set("4: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("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("1:-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()) @@ -4192,13 +4192,13 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&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("2:10") + err = v.Set("7: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) @@ -4214,11 +4214,11 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-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("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint64", v.Type()) @@ -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("110") 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("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("7:20") + err = v.Set("1:20") assert.Nil(t, err) 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("210") + 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("6: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("7:20") + err = v.Set("1: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("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("1:-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]uint64", v.Type()) @@ -4315,17 +4315,17 @@ func TestUint16Uint64MapValue(t *testing.T) { v := newUint16Uint64MapValue(&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("0: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("3:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint64", v.Type()) @@ -4337,7 +4337,7 @@ func TestUint16Uint64MapValue(t *testing.T) { v := newUint16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-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) @@ -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("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("7:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("020") + 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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint64", v.Type()) @@ -4403,11 +4403,11 @@ func TestUint64Uint64MapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("6: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("0: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("0:-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("dekJz10") + err = v.Set("NPHew10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gGrVM:10") + err = v.Set("SEayQ:10") assert.Nil(t, err) - err = v.Set("IWaYa20") + err = v.Set("Hqbxo20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("oFGzL:20") + err = v.Set("VwBuK: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("PIiQna") + err = v.Set("BwmzEa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nrFzc:a") + err = v.Set("lpPUx: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("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("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("6:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4726,7 +4726,7 @@ func TestIntIntMapValue(t *testing.T) { v := newIntIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("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("1: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("0:20") + err = v.Set("3: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("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("0: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("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("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("4:20") + err = v.Set("3: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("2a") + 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()) @@ -4831,13 +4831,13 @@ func TestInt32IntMapValue(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("5:10") + err = v.Set("0: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("4: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("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("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[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("410") + 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("7: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("2: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("1a") 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("6: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("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("7: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("2:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int", v.Type()) @@ -4931,7 +4931,7 @@ func TestUintIntMapValue(t *testing.T) { v := newUintIntMapValue(&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) @@ -4950,17 +4950,17 @@ func TestUint8IntMapValue(t *testing.T) { v := newUint8IntMapValue(&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("4:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("020") + 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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int", v.Type()) @@ -4972,11 +4972,11 @@ func TestUint8IntMapValue(t *testing.T) { v := newUint8IntMapValue(&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("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[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("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("6: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("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,7 +5013,7 @@ func TestUint16IntMapValue(t *testing.T) { v := newUint16IntMapValue(&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) @@ -5032,17 +5032,17 @@ func TestUint32IntMapValue(t *testing.T) { v := newUint32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + 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") assert.Nil(t, err) - err = v.Set("020") + 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("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int", v.Type()) @@ -5054,7 +5054,7 @@ func TestUint32IntMapValue(t *testing.T) { v := newUint32IntMapValue(&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) @@ -5073,17 +5073,17 @@ func TestUint64IntMapValue(t *testing.T) { v := newUint64IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + 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("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("1:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int", v.Type()) @@ -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("3a") + 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("1: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("JCDsl10") + err = v.Set("BYltm10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("OMKzb:10") + err = v.Set("RUAjb:10") assert.Nil(t, err) - err = v.Set("nnPAH20") + err = v.Set("vPJHu20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qHaxF:20") + err = v.Set("iGlkH: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("zpuHGa") + err = v.Set("Xwgxqa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nQdDX:a") + err = v.Set("kOVvs: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("310") 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("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("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,11 +5372,11 @@ func TestIntInt8MapValue(t *testing.T) { v := newIntInt8MapValue(&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("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[int]int8", v.Type()) @@ -5391,13 +5391,13 @@ func TestInt8Int8MapValue(t *testing.T) { v := newInt8Int8MapValue(&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("0: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) @@ -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("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("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[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("610") + 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("3:10") assert.Nil(t, err) - err = v.Set("620") + 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("2: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("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("0: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,13 +5473,13 @@ 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("1: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) @@ -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("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("3: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("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("6:10") + err = v.Set("5: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("1:20") + err = v.Set("4: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("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("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[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("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("7:10") + err = v.Set("3: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("7:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int8", v.Type()) @@ -5581,7 +5581,7 @@ func TestUintInt8MapValue(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("2: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("610") + 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("2: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("3: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("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("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]int8", v.Type()) @@ -5641,13 +5641,13 @@ func TestUint16Int8MapValue(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("620") + 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("4: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("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("5: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[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("610") + 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("4: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("1:20") + err = v.Set("6: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("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("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,13 +5719,13 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&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("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -5745,7 +5745,7 @@ func TestUint64Int8MapValue(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("1: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("DjljB10") + err = v.Set("diTxK10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("TVMGd:10") + err = v.Set("jdFiy:10") assert.Nil(t, err) - err = v.Set("lGQiL20") + err = v.Set("UBdKs20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("OjHTD:20") + err = v.Set("JLnio: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("JUkAGa") + err = v.Set("GdqnGa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LHQTT:a") + err = v.Set("bFwrk: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()) @@ -5996,17 +5996,17 @@ func TestIntInt16MapValue(t *testing.T) { v := newIntInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + 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("020") + 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("0:20") + err = v.Set("2: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("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("4: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[int]int16", v.Type()) @@ -6037,13 +6037,13 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&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("1:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("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("5: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) - err = v.Set("5:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int16", v.Type()) @@ -6100,11 +6100,11 @@ func TestInt16Int16MapValue(t *testing.T) { v := newInt16Int16MapValue(&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("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[int16]int16", v.Type()) @@ -6125,11 +6125,11 @@ func TestInt32Int16MapValue(t *testing.T) { assert.NotNil(t, err) 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("4:20") + err = v.Set("1: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("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("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[int32]int16", v.Type()) @@ -6160,17 +6160,17 @@ func TestInt64Int16MapValue(t *testing.T) { v := newInt64Int16MapValue(&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("3: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("0:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int16", v.Type()) @@ -6182,7 +6182,7 @@ func TestInt64Int16MapValue(t *testing.T) { v := newInt64Int16MapValue(&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) @@ -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("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("5:10") assert.Nil(t, err) - err = v.Set("020") + 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("4:20") + err = v.Set("3: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("6a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6242,17 +6242,17 @@ func TestUint8Int16MapValue(t *testing.T) { v := newUint8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + 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("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("5:20") + err = v.Set("7: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("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("3: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[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("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("7:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("020") + 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[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("5a") + 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("5: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("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("3: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("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6350,7 +6350,7 @@ func TestUint32Int16MapValue(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("4: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("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") + err = v.Set("4: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("7:20") + err = v.Set("1: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("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("4: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[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("xnutA10") + err = v.Set("qYWYf10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("WCqYP:10") + err = v.Set("QTpWU:10") assert.Nil(t, err) - err = v.Set("JSElL20") + err = v.Set("YLbbO20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uldGZ:20") + err = v.Set("NSkYj: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("nNtMta") + err = v.Set("NxWVva") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gLxNq:a") + err = v.Set("qGPsu: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("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("5: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("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int32", v.Type()) @@ -6664,7 +6664,7 @@ func TestIntInt32MapValue(t *testing.T) { v := newIntInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6687,13 +6687,13 @@ func TestInt8Int32MapValue(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("5:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + 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("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("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("0: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,17 +6724,17 @@ func TestInt16Int32MapValue(t *testing.T) { v := newInt16Int32MapValue(&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") 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("6:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int32", v.Type()) @@ -6746,11 +6746,11 @@ func TestInt16Int32MapValue(t *testing.T) { v := newInt16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + 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("0: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("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("0:10") + err = v.Set("7: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("6:20") + err = v.Set("1: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("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("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[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("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("5:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("220") + 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("4:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int32", v.Type()) @@ -6828,11 +6828,11 @@ func TestInt64Int32MapValue(t *testing.T) { v := newInt64Int32MapValue(&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("0: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[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("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("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("7: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("7a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6888,7 +6888,7 @@ 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("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) @@ -6898,7 +6898,7 @@ func TestUint8Int32MapValue(t *testing.T) { 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("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6910,7 +6910,7 @@ func TestUint8Int32MapValue(t *testing.T) { v := newUint8Int32MapValue(&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) @@ -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("610") + 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("0:10") + err = v.Set("6: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("6:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int32", v.Type()) @@ -6951,7 +6951,7 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&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) @@ -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("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("7: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) - err = v.Set("3:20") + err = v.Set("2: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("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("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[uint32]int32", v.Type()) @@ -7011,17 +7011,17 @@ func TestUint64Int32MapValue(t *testing.T) { v := newUint64Int32MapValue(&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("1:10") + err = v.Set("3: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("5:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int32", v.Type()) @@ -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("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) @@ -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("UUWUt10") + err = v.Set("DiYmt10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FbmhA:10") + err = v.Set("OkaWm:10") assert.Nil(t, err) - err = v.Set("RcqTB20") + err = v.Set("zQWYI20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ZoFto:20") + err = v.Set("SWiwW: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("duzbya") + err = v.Set("wMsGxa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XkuLv:a") + err = v.Set("CEOlY: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()) @@ -7292,9 +7292,9 @@ func TestIntInt64MapValue(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("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("620") 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("3a") + 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("0: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("010") + 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") + err = v.Set("7: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("4: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("5a") + 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[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("210") + 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("6: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("5:20") + err = v.Set("0: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("6a") 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[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("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("4: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("0:20") + err = v.Set("2: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("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("4: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[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("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("5:10") + err = v.Set("7: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("1:20") + err = v.Set("3: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("4a") + 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("1: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("610") + 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("3:10") + err = v.Set("5: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("5:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int64", v.Type()) @@ -7519,7 +7519,7 @@ func TestUintInt64MapValue(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("4: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[uint]int64", v.Type()) @@ -7540,11 +7540,11 @@ func TestUint8Int64MapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("120") + 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("2: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("2a") + 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("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]int64", v.Type()) @@ -7575,17 +7575,17 @@ func TestUint16Int64MapValue(t *testing.T) { v := newUint16Int64MapValue(&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("7:10") + err = v.Set("2: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("0:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int64", v.Type()) @@ -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("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("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[uint16]int64", v.Type()) @@ -7620,13 +7620,13 @@ func TestUint32Int64MapValue(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("6: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("2:20") + err = v.Set("5: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("5a") 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[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("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("0:10") + err = v.Set("6: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("0:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int64", v.Type()) @@ -7679,11 +7679,11 @@ func TestUint64Int64MapValue(t *testing.T) { v := newUint64Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + 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[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("FejRb10.2") + err = v.Set("YDZQL10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("IFhMx:10.2") + err = v.Set("RoakS:10.2") assert.Nil(t, err) - err = v.Set("BXidS20.99") + err = v.Set("sGcUw20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("xVHOg:20.99") + err = v.Set("BnTRE: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("RuExea") + err = v.Set("pRWBNa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("TnyDK:a") + err = v.Set("GhdOA: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("710.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("0:10.2") assert.Nil(t, err) - err = v.Set("720.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("1:20.99") + err = v.Set("4:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float64", v.Type()) @@ -7940,7 +7940,7 @@ func TestIntFloat64MapValue(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.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float64", v.Type()) @@ -7959,13 +7959,13 @@ func TestInt8Float64MapValue(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("1:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("720.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("7:20.99") + err = v.Set("4: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("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("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()) @@ -8000,9 +8000,9 @@ func TestInt16Float64MapValue(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("1:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("620.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("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("0: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[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("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("2:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("220.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("0: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()) @@ -8063,7 +8063,7 @@ func TestInt32Float64MapValue(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("6: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("510.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("5:10.2") assert.Nil(t, err) 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("7: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("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("0: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("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("5:10.2") + err = v.Set("0: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("0:20.99") + err = v.Set("7: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("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("4: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[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("010.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("7:10.2") + err = v.Set("6:10.2") assert.Nil(t, err) 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("2:20.99") + err = v.Set("5: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("2a") + 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.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("210.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("2:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("120.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("0:20.99") + err = v.Set("6: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("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("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[uint16]float64", v.Type()) @@ -8242,17 +8242,17 @@ func TestUint32Float64MapValue(t *testing.T) { v := newUint32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.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("1:10.2") + err = v.Set("2: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("4:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float64", v.Type()) @@ -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("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("1: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[uint32]float64", v.Type()) @@ -8287,13 +8287,13 @@ func TestUint64Float64MapValue(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("0:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("120.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("3:20.99") + err = v.Set("5: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("0a") + 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("5: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[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("wXrlb10.2") + err = v.Set("BDLrL10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("IMxdl:10.2") + err = v.Set("eXCff:10.2") assert.Nil(t, err) - err = v.Set("hTYoj20.99") + err = v.Set("KQJkO20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LmOXw:20.99") + err = v.Set("nIauO: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("srEnPa") + err = v.Set("JsJpra") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("vwhRx:a") + err = v.Set("XqyaF: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("010.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("3: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("7:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float32", v.Type()) @@ -8562,11 +8562,11 @@ func TestIntFloat32MapValue(t *testing.T) { v := newIntFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + 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("0: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[int]float32", v.Type()) @@ -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("410.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("3:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) 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("5:20.99") + err = v.Set("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float32", v.Type()) @@ -8603,11 +8603,11 @@ func TestInt8Float32MapValue(t *testing.T) { v := newInt8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + 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("2:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float32", v.Type()) @@ -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("610.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("7:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("320.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("4:20.99") + err = v.Set("1: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("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("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[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("310.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("7:10.2") + err = v.Set("6:10.2") assert.Nil(t, err) - err = v.Set("020.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("0:20.99") + err = v.Set("7: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("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("1: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[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("010.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("1:10.2") + err = v.Set("7:10.2") assert.Nil(t, err) - err = v.Set("320.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("2:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float32", v.Type()) @@ -8730,7 +8730,7 @@ func TestInt64Float32MapValue(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("3: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[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("610.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") assert.Nil(t, err) - err = v.Set("020.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("3:20.99") + err = v.Set("0: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("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("2: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[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("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("4:10.2") + err = v.Set("5: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("7:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8808,11 +8808,11 @@ func TestUint8Float32MapValue(t *testing.T) { v := newUint8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + 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("7: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[uint8]float32", v.Type()) @@ -8827,13 +8827,13 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310.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("7:10.2") assert.Nil(t, err) - err = v.Set("320.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) @@ -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("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("3: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[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("110.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("3:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("020.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("3: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("2a") + 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("5: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[uint32]float32", v.Type()) @@ -8909,17 +8909,17 @@ func TestUint64Float32MapValue(t *testing.T) { v := newUint64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010.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("4:10.2") + err = v.Set("0:10.2") assert.Nil(t, err) - err = v.Set("720.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("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]float32", v.Type()) @@ -8931,11 +8931,11 @@ func TestUint64Float32MapValue(t *testing.T) { v := newUint64Float32MapValue(&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("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[uint64]float32", 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("EnGJV10s") + err = v.Set("NEpGo10s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("hDPTi:10s") + err = v.Set("eEhBW:10s") assert.Nil(t, err) - err = v.Set("HMyyo30m") + err = v.Set("iFjGW30m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("YLaeV:30m") + err = v.Set("WPwSP:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]time.Duration", v.Type()) @@ -9139,9 +9139,9 @@ func TestStringDurationMapValue(t *testing.T) { v := newStringDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("uuEpn3l") + err = v.Set("GRWHd3l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("AMlnf:3l") + err = v.Set("ZqLkq: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()) @@ -9156,17 +9156,17 @@ func TestIntDurationMapValue(t *testing.T) { v := newIntDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310s") + 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("1:10s") + err = v.Set("2:10s") assert.Nil(t, err) - err = v.Set("530m") + err = v.Set("430m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("3:30m") + err = v.Set("4:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]time.Duration", v.Type()) @@ -9178,11 +9178,11 @@ func TestIntDurationMapValue(t *testing.T) { v := newIntDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("33l") + err = v.Set("13l") 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") + err = v.Set("3: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()) @@ -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("110s") + 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("7: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("3:30m") + err = v.Set("4:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]time.Duration", v.Type()) @@ -9219,11 +9219,11 @@ func TestInt8DurationMapValue(t *testing.T) { v := newInt8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("73l") + err = v.Set("63l") 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") + 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[int8]time.Duration", v.Type()) @@ -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("610s") + 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("0:10s") assert.Nil(t, err) - err = v.Set("330m") + 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("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]time.Duration", v.Type()) @@ -9260,11 +9260,11 @@ func TestInt16DurationMapValue(t *testing.T) { v := newInt16DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("33l") + 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("6:3l") + err = v.Set("7: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()) @@ -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("310s") 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("2:10s") assert.Nil(t, err) - err = v.Set("330m") + 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("3:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]time.Duration", v.Type()) @@ -9305,7 +9305,7 @@ 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("7: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[int32]time.Duration", v.Type()) @@ -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("510s") + err = v.Set("710s") 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("0:10s") assert.Nil(t, err) err = v.Set("430m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("1:30m") + err = v.Set("3:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]time.Duration", v.Type()) @@ -9342,11 +9342,11 @@ 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("53l") 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") + 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[int64]time.Duration", v.Type()) @@ -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("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("7:10s") assert.Nil(t, err) - err = v.Set("230m") + 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("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]time.Duration", v.Type()) @@ -9383,11 +9383,11 @@ func TestUintDurationMapValue(t *testing.T) { v := newUintDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("23l") + 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("7: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[uint]time.Duration", v.Type()) @@ -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("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("1:10s") + err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("630m") + 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("0:30m") + err = v.Set("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]time.Duration", v.Type()) @@ -9424,11 +9424,11 @@ func TestUint8DurationMapValue(t *testing.T) { v := newUint8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("63l") + 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("4: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[uint8]time.Duration", v.Type()) @@ -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("010s") + 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("5:10s") + err = v.Set("3:10s") assert.Nil(t, err) - err = v.Set("030m") + err = v.Set("730m") 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("3:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]time.Duration", v.Type()) @@ -9465,11 +9465,11 @@ func TestUint16DurationMapValue(t *testing.T) { v := newUint16DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("13l") + 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("2: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[uint16]time.Duration", v.Type()) @@ -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("610s") + err = v.Set("310s") 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("0:10s") assert.Nil(t, err) - err = v.Set("430m") + 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("6:30m") + err = v.Set("0:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]time.Duration", v.Type()) @@ -9506,11 +9506,11 @@ func TestUint32DurationMapValue(t *testing.T) { v := newUint32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("53l") + err = v.Set("13l") 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") + 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()) @@ -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("010s") 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("630m") + err = v.Set("730m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("2:30m") + err = v.Set("7:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]time.Duration", v.Type()) @@ -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("ptmQh127.0.0.1") + err = v.Set("DdCgV127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("agKCM:127.0.0.1") + err = v.Set("jdasN:127.0.0.1") assert.Nil(t, err) - err = v.Set("lyuxY127.0.0.3") + err = v.Set("iogwe127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("vapzk:127.0.0.3") + err = v.Set("TZEKR: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("yYhXZ127.0.0.1.3") + err = v.Set("NdqMY127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LTfLc:127.0.0.1.3") + err = v.Set("wWHqT: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()) @@ -9776,13 +9776,13 @@ func TestIntIPMapValue(t *testing.T) { 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("3:127.0.0.1") assert.Nil(t, err) - err = v.Set("7127.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("2:127.0.0.3") + err = v.Set("3: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("6127.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("3:127.0.0.1.3") + err = v.Set("6: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("0127.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("7127.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("1: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[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("1127.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("0: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[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("5127.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("4:127.0.0.1") + err = v.Set("7:127.0.0.1") assert.Nil(t, err) - err = v.Set("2127.0.0.3") + err = v.Set("7127.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("3: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("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("3:127.0.0.1.3") + err = v.Set("0: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,17 +9895,17 @@ 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") + 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("3:127.0.0.1") + err = v.Set("7: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("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[int32]net.IP", v.Type()) @@ -9917,7 +9917,7 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1127.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) @@ -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("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("1:127.0.0.1") + err = v.Set("7:127.0.0.1") assert.Nil(t, err) - err = v.Set("4127.0.0.3") + err = v.Set("3127.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("1: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("1127.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("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[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("6127.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("5:127.0.0.1") + err = v.Set("2:127.0.0.1") assert.Nil(t, err) - err = v.Set("1127.0.0.3") + err = v.Set("3127.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("6: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[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("5127.0.0.1.3") + err = v.Set("6127.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("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[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("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("0:127.0.0.1") + err = v.Set("1:127.0.0.1") assert.Nil(t, err) - err = v.Set("0127.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("7: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[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("5127.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("3:127.0.0.1.3") + err = v.Set("6: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("2127.0.0.1") + err = v.Set("4127.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") assert.Nil(t, err) - err = v.Set("1127.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("3: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("6127.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[uint16]net.IP", v.Type()) @@ -10104,13 +10104,13 @@ func TestUint32IPMapValue(t *testing.T) { 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("5: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("1127.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[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("6127.0.0.1.3") + err = v.Set("7127.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("0: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("0127.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("4:127.0.0.1") + err = v.Set("7:127.0.0.1") assert.Nil(t, err) - err = v.Set("7127.0.0.3") + err = v.Set("3127.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("4: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("6127.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("5:127.0.0.1.3") + err = v.Set("6: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("UWQpwff") + err = v.Set("EhOkpff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("KViVe:ff") + err = v.Set("DBBqp:ff") assert.Nil(t, err) - err = v.Set("PoqYuaa") + err = v.Set("KvNtYaa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("bqHHM:aa") + err = v.Set("hiUsJ: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("CQsMtgg") + err = v.Set("kkgXhgg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("wdJPZ:gg") + err = v.Set("saopk: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,13 +10408,13 @@ func TestIntHexBytesMapValue(t *testing.T) { v := newIntHexBytesMapValue(&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("2:ff") + err = v.Set("5:ff") assert.Nil(t, err) - err = v.Set("2aa") + err = v.Set("6aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) @@ -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("3: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("3ff") + 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("2:ff") + err = v.Set("0:ff") assert.Nil(t, err) 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("0: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,11 +10471,11 @@ func TestInt8HexBytesMapValue(t *testing.T) { v := newInt8HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0gg") + err = v.Set("7gg") 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[int8]HexBytes", v.Type()) @@ -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("6ff") + err = v.Set("3ff") 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("5:ff") assert.Nil(t, err) - err = v.Set("4aa") + 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("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("4gg") + err = v.Set("0gg") 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[int16]HexBytes", v.Type()) @@ -10531,13 +10531,13 @@ func TestInt32HexBytesMapValue(t *testing.T) { v := newInt32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3ff") + 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("1:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("7aa") + err = v.Set("1aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) @@ -10557,7 +10557,7 @@ func TestInt32HexBytesMapValue(t *testing.T) { 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("7: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("2ff") + 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("0:ff") + err = v.Set("3:ff") assert.Nil(t, err) - err = v.Set("4aa") + 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("0gg") + 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("6: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[int64]HexBytes", v.Type()) @@ -10617,13 +10617,13 @@ func TestUintHexBytesMapValue(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("0:ff") assert.Nil(t, err) - err = v.Set("1aa") + err = v.Set("2aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("3:aa") + err = v.Set("6:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]HexBytes", v.Type()) @@ -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("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("1:gg") + err = v.Set("3: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("7ff") + 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("4:ff") + err = v.Set("5:ff") assert.Nil(t, err) 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("1: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("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("2: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[uint8]HexBytes", v.Type()) @@ -10695,17 +10695,17 @@ func TestUint16HexBytesMapValue(t *testing.T) { v := newUint16HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2ff") + 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("6:ff") + err = v.Set("4:ff") assert.Nil(t, err) - err = v.Set("0aa") + 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("2:aa") + err = v.Set("1: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("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("1: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[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("2ff") + 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("1:ff") + err = v.Set("3:ff") assert.Nil(t, err) - err = v.Set("6aa") + err = v.Set("2aa") 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[uint32]HexBytes", v.Type()) @@ -10762,7 +10762,7 @@ func TestUint32HexBytesMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("4: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[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("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("6:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("4aa") + 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("2:aa") + err = v.Set("4: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("6gg") + err = v.Set("0gg") 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("2: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("vTUctabc.*") + err = v.Set("qeCtzabc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("SyjSF:abc.*") + err = v.Set("DJzqr:abc.*") assert.Nil(t, err) - err = v.Set("MHwDCxyz.*") + err = v.Set("pUjJsxyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JOyAs:xyz.*") + err = v.Set("QjTUj: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("wVJjb[abc") + err = v.Set("gwoKA[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("UVukK:[abc") + err = v.Set("UAOGv:[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()) @@ -11028,13 +11028,13 @@ func TestIntRegexpMapValue(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("7:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) err = v.Set("2xyz.*") 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("6: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("3[abc") + err = v.Set("2[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("5:[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()) @@ -11065,17 +11065,17 @@ func TestInt8RegexpMapValue(t *testing.T) { v := newInt8RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4abc.*") + 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.*") assert.Nil(t, err) - err = v.Set("7xyz.*") + 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("3: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("1[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("6:[abc") + err = v.Set("4:[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,17 +11106,17 @@ func TestInt16RegexpMapValue(t *testing.T) { v := newInt16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7abc.*") + 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("3:abc.*") assert.Nil(t, err) - err = v.Set("3xyz.*") + 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("7:xyz.*") + err = v.Set("5:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]*regexp.Regexp", v.Type()) @@ -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("5[abc") + err = v.Set("0[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("4:[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()) @@ -11147,17 +11147,17 @@ func TestInt32RegexpMapValue(t *testing.T) { v := newInt32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0abc.*") + 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("2:abc.*") assert.Nil(t, err) - err = v.Set("1xyz.*") + 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("7:xyz.*") + err = v.Set("1:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]*regexp.Regexp", v.Type()) @@ -11173,7 +11173,7 @@ 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("2:[abc") + err = v.Set("5:[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("1abc.*") 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("4:abc.*") assert.Nil(t, err) - err = v.Set("5xyz.*") + 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("6:xyz.*") + err = v.Set("5: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("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) - err = v.Set("6:[abc") + err = v.Set("1:[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("2abc.*") + 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("3:abc.*") + err = v.Set("7:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + 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("6:xyz.*") + err = v.Set("7:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]*regexp.Regexp", v.Type()) @@ -11251,11 +11251,11 @@ func TestUintRegexpMapValue(t *testing.T) { v := newUintRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1[abc") + err = v.Set("0[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("3:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]*regexp.Regexp", v.Type()) @@ -11274,13 +11274,13 @@ func TestUint8RegexpMapValue(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("4:abc.*") + err = v.Set("3:abc.*") assert.Nil(t, err) - err = v.Set("5xyz.*") + 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("1:xyz.*") + err = v.Set("7: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("2:[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("5:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("0xyz.*") + err = v.Set("3xyz.*") 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("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("7:[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[uint16]*regexp.Regexp", v.Type()) @@ -11352,17 +11352,17 @@ func TestUint32RegexpMapValue(t *testing.T) { v := newUint32RegexpMapValue(&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("5:abc.*") + err = v.Set("0:abc.*") assert.Nil(t, err) 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("1:xyz.*") + err = v.Set("5:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]*regexp.Regexp", v.Type()) @@ -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("2[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("0:[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()) @@ -11393,17 +11393,17 @@ func TestUint64RegexpMapValue(t *testing.T) { v := newUint64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0abc.*") + 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("3:abc.*") + err = v.Set("2:abc.*") assert.Nil(t, err) - err = v.Set("0xyz.*") + 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("1: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("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("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("tezIO0.0.0.0/0") + err = v.Set("IGYfs0.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ZMfFT:0.0.0.0/0") + err = v.Set("mxFfO:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("cfBXK255.255.255.255/19") + err = v.Set("ELWWJ255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("cYNEA:255.255.255.255/19") + err = v.Set("SMCaq: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("aFRBj0.0.0.256/16") + err = v.Set("bcOjd0.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XuYFj:0.0.0.256/16") + err = v.Set("mhCxJ: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("20.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("4: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("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("3:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IPNet", v.Type()) @@ -11798,7 +11798,7 @@ func TestIntIPNetMapValue(t *testing.T) { 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("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[int]net.IPNet", v.Type()) @@ -11813,17 +11813,17 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&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("3:0.0.0.0/0") + err = v.Set("0: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) - err = v.Set("6: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[int8]net.IPNet", v.Type()) @@ -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("20.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[int8]net.IPNet", v.Type()) @@ -11854,17 +11854,17 @@ func TestInt16IPNetMapValue(t *testing.T) { v := newInt16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("60.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("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("2255.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) - err = v.Set("5: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[int16]net.IPNet", v.Type()) @@ -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("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("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[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("20.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("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("5255.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("4: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[int32]net.IPNet", v.Type()) @@ -11917,7 +11917,7 @@ func TestInt32IPNetMapValue(t *testing.T) { v := newInt32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("50.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) @@ -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("50.0.0.0/0") + err = v.Set("40.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("4:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("1255.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) - err = v.Set("1: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()) @@ -11962,7 +11962,7 @@ func TestInt64IPNetMapValue(t *testing.T) { 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("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[int64]net.IPNet", v.Type()) @@ -11977,17 +11977,17 @@ func TestUintIPNetMapValue(t *testing.T) { v := newUintIPNetMapValue(&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("5:0.0.0.0/0") + err = v.Set("4:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("5255.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("5:255.255.255.255/19") + err = v.Set("4:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]net.IPNet", v.Type()) @@ -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("50.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("1:0.0.0.256/16") + err = v.Set("0: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,17 +12018,17 @@ 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("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("1:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("2255.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) - err = v.Set("4: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[uint8]net.IPNet", v.Type()) @@ -12044,7 +12044,7 @@ func TestUint8IPNetMapValue(t *testing.T) { 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("0: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[uint8]net.IPNet", v.Type()) @@ -12059,13 +12059,13 @@ func TestUint16IPNetMapValue(t *testing.T) { v := newUint16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("60.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("5:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("4255.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) @@ -12081,11 +12081,11 @@ func TestUint16IPNetMapValue(t *testing.T) { v := newUint16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.256/16") + err = v.Set("40.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("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[uint16]net.IPNet", v.Type()) @@ -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("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("3:0.0.0.0/0") + err = v.Set("7:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("5255.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("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("10.0.0.256/16") + err = v.Set("40.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("0: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("40.0.0.0/0") + err = v.Set("30.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("3:0.0.0.0/0") + err = v.Set("7:0.0.0.0/0") assert.Nil(t, err) 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) - err = v.Set("4: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[uint64]net.IPNet", v.Type()) @@ -12163,11 +12163,11 @@ func TestUint64IPNetMapValue(t *testing.T) { v := newUint64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.256/16") + err = v.Set("30.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[uint64]net.IPNet", v.Type())