From ce14d2a098be6926adea832dc436ab0dfd7fc26d Mon Sep 17 00:00:00 2001 From: Naveen Gogineni Date: Tue, 12 Nov 2024 20:44:56 -0500 Subject: [PATCH 1/5] Feature: Add required flag support --- flag.go | 1 + gen/gcli/gcli.go | 13 +- gen/gcli/gcli_test.go | 10 +- gen/gcli/gcliv3.go | 1 + gen/gcli/gcliv3_test.go | 10 +- gen/gkingpin/gkingpin.go | 3 + gen/gkingpin/gkingpin_test.go | 7 +- parser.go | 2 +- parser_test.go | 15 + values_generated_test.go | 2222 ++++++++++++++++----------------- 10 files changed, 1158 insertions(+), 1126 deletions(-) diff --git a/flag.go b/flag.go index 4ceaaa1..cdd2c90 100644 --- a/flag.go +++ b/flag.go @@ -11,4 +11,5 @@ type Flag struct { DefValue string // default value (as text); for usage message Hidden bool Deprecated bool + Required bool } diff --git a/gen/gcli/gcli.go b/gen/gcli/gcli.go index de2472e..f6c2391 100644 --- a/gen/gcli/gcli.go +++ b/gen/gcli/gcli.go @@ -15,12 +15,13 @@ func GenerateTo(src []*sflags.Flag, dst *[]cli.Flag) { aliases = append(aliases, srcFlag.Short) } *dst = append(*dst, &cli.GenericFlag{ - Name: name, - EnvVars: []string{srcFlag.EnvName}, - Aliases: aliases, - Hidden: srcFlag.Hidden, - Usage: srcFlag.Usage, - Value: srcFlag.Value, + Name: name, + EnvVars: []string{srcFlag.EnvName}, + Aliases: aliases, + Hidden: srcFlag.Hidden, + Usage: srcFlag.Usage, + Value: srcFlag.Value, + Required: srcFlag.Required, }) } } diff --git a/gen/gcli/gcli_test.go b/gen/gcli/gcli_test.go index 0c52346..bb60979 100644 --- a/gen/gcli/gcli_test.go +++ b/gen/gcli/gcli_test.go @@ -3,6 +3,7 @@ package gcli import ( "errors" "io" + "strings" "testing" "github.com/stretchr/testify/assert" @@ -12,7 +13,7 @@ import ( ) type cfg1 struct { - StringValue1 string + StringValue1 string `flag:",required"` StringValue2 string `flag:"string-value-two s"` CounterValue1 sflags.Counter @@ -68,7 +69,8 @@ func TestParse(t *testing.T) { StringValue1: "string_value1_value", StringValue2: "", }, - args: []string{}, + args: []string{}, + expErr2: errors.New("required flag \"string-value1\" not set"), }, { name: "Test cfg1 short option", @@ -76,10 +78,12 @@ func TestParse(t *testing.T) { StringValue2: "string_value2_value", }, expCfg: &cfg1{ + StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", }, args: []string{ "-s=string_value2_value2", + "--string-value1", "string_value1_value2", }, }, { @@ -142,7 +146,7 @@ func TestParse(t *testing.T) { err = cliApp.Run(args) if test.expErr2 != nil { require.Error(t, err) - require.Equal(t, test.expErr2, err) + require.Equal(t, test.expErr2.Error(), strings.ToLower(err.Error())) } else { require.NoError(t, err) } diff --git a/gen/gcli/gcliv3.go b/gen/gcli/gcliv3.go index 7c6fa9f..d6f71f8 100644 --- a/gen/gcli/gcliv3.go +++ b/gen/gcli/gcliv3.go @@ -48,6 +48,7 @@ func GenerateToV3(src []*sflags.Flag, dst *[]cli.Flag) { Value: &value{ v: srcFlag.Value, }, + Required: srcFlag.Required, }) } } diff --git a/gen/gcli/gcliv3_test.go b/gen/gcli/gcliv3_test.go index 7088f25..a319c6e 100644 --- a/gen/gcli/gcliv3_test.go +++ b/gen/gcli/gcliv3_test.go @@ -4,6 +4,7 @@ import ( "context" "errors" "io" + "strings" "testing" "github.com/stretchr/testify/assert" @@ -13,7 +14,7 @@ import ( ) type cfg2 struct { - StringValue1 string + StringValue1 string `flag:",required"` StringValue2 string `flag:"string-value-two s"` CounterValue1 sflags.Counter @@ -69,7 +70,8 @@ func TestParseV3(t *testing.T) { StringValue1: "string_value1_value", StringValue2: "", }, - args: []string{}, + args: []string{}, + expErr2: errors.New("required flag \"string-value1\" not set"), }, { name: "Test cfg2 short option", @@ -77,10 +79,12 @@ func TestParseV3(t *testing.T) { StringValue2: "string_value2_value", }, expCfg: &cfg2{ + StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", }, args: []string{ "-s=string_value2_value2", + "--string-value1", "string_value1_value2", }, }, { @@ -143,7 +147,7 @@ func TestParseV3(t *testing.T) { err = cmd.Run(context.Background(), args) if test.expErr2 != nil { require.Error(t, err) - require.Equal(t, test.expErr2, err) + require.Equal(t, test.expErr2.Error(), strings.ToLower(err.Error())) } else { require.NoError(t, err) } diff --git a/gen/gkingpin/gkingpin.go b/gen/gkingpin/gkingpin.go index 82841dd..7c25547 100644 --- a/gen/gkingpin/gkingpin.go +++ b/gen/gkingpin/gkingpin.go @@ -23,6 +23,9 @@ func GenerateTo(src []*sflags.Flag, dst flagger) { if srcFlag.Hidden { flag.Hidden() } + if srcFlag.Required { + flag.Required() + } if srcFlag.Short != "" { r, _ := utf8.DecodeRuneInString(srcFlag.Short) if r != utf8.RuneError { diff --git a/gen/gkingpin/gkingpin_test.go b/gen/gkingpin/gkingpin_test.go index 4dab690..92ab781 100644 --- a/gen/gkingpin/gkingpin_test.go +++ b/gen/gkingpin/gkingpin_test.go @@ -11,7 +11,7 @@ import ( ) type cfg1 struct { - StringValue1 string + StringValue1 string `flag:",required"` StringValue2 string `flag:"string-value-two s"` CounterValue1 sflags.Counter @@ -67,7 +67,8 @@ func TestParse(t *testing.T) { StringValue1: "string_value1_value", StringValue2: "", }, - args: []string{}, + args: []string{}, + expErr2: errors.New("required flag(s) '--string-value1' not provided"), }, { name: "Test cfg1 short option", @@ -75,10 +76,12 @@ func TestParse(t *testing.T) { StringValue2: "string_value2_value", }, expCfg: &cfg1{ + StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", }, args: []string{ "-s", "string_value2_value2", + "--string-value1", "string_value1_value2", }, }, { diff --git a/parser.go b/parser.go index ff2a472..8199433 100644 --- a/parser.go +++ b/parser.go @@ -114,7 +114,7 @@ func parseFlagTag(field reflect.StructField, opt opts) *Flag { } flag.Hidden = hasOption(flagTags[1:], "hidden") flag.Deprecated = hasOption(flagTags[1:], "deprecated") - + flag.Required = hasOption(flagTags[1:], "required") } if opt.prefix != "" && !ignoreFlagPrefix { diff --git a/parser_test.go b/parser_test.go index a7cc231..da39eac 100644 --- a/parser_test.go +++ b/parser_test.go @@ -27,6 +27,7 @@ func TestParseStruct(t *testing.T) { Name4 *string Name5 string `flag:"-"` name6 string + Name7 int `flag:",required"` Addr *net.TCPAddr @@ -147,6 +148,13 @@ func TestParseStruct(t *testing.T) { DefValue: "name_value4", Value: newStringValue(simpleCfg.Name4), }, + { + Name: "name7", + EnvName: "NAME7", + Required: true, + DefValue: "0", + Value: newIntValue(&simpleCfg.Name7), + }, { Name: "addr", EnvName: "ADDR", @@ -194,6 +202,13 @@ func TestParseStruct(t *testing.T) { DefValue: "name_value4", Value: newStringValue(simpleCfg.Name4), }, + { + Name: "name7", + EnvName: "PP|NAME7", + Required: true, + DefValue: "0", + Value: newIntValue(&simpleCfg.Name7), + }, { Name: "addr", EnvName: "PP|ADDR", diff --git a/values_generated_test.go b/values_generated_test.go index 282d61b..f1dea87 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("dzMfxval1") + err = v.Set("eqJMbval1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XcrRz:val1") + err = v.Set("GOgZJ:val1") assert.Nil(t, err) - err = v.Set("WjIXlval2") + err = v.Set("UCDQEval2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("DqGev:val2") + err = v.Set("aGgBp: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("dXmJx") + err = v.Set("GxTWJ") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("jQufn:") + err = v.Set("BSxvV:") 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("3val1") + 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("7:val1") + err = v.Set("0:val1") assert.Nil(t, err) err = v.Set("6val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("1: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("1") + err = v.Set("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("7:") + err = v.Set("2:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]string", v.Type()) @@ -243,17 +243,17 @@ func TestInt8StringMapValue(t *testing.T) { v := newInt8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1val1") + err = v.Set("0val1") 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("7:val1") assert.Nil(t, err) - err = v.Set("1val2") + err = v.Set("2val2") 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("6: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("1") + err = v.Set("3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("4:") + err = v.Set("0:") 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("1val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("7:val1") + err = v.Set("0:val1") assert.Nil(t, err) - err = v.Set("1val2") + err = v.Set("4val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("0") + 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[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("3val1") + err = v.Set("0val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("4:val1") + err = v.Set("0:val1") assert.Nil(t, err) err = v.Set("2val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("4:val2") + err = v.Set("5: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("2") + err = v.Set("5") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("1:") + err = v.Set("2:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]string", v.Type()) @@ -366,17 +366,17 @@ func TestInt64StringMapValue(t *testing.T) { v := newInt64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2val1") + 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("3:val1") + err = v.Set("1:val1") assert.Nil(t, err) - err = v.Set("0val2") + 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("2:val2") + err = v.Set("3: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("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("7:") + 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("7val1") + 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("7:val1") + err = v.Set("5:val1") assert.Nil(t, err) err = v.Set("4val2") 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("1:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]string", v.Type()) @@ -433,7 +433,7 @@ func TestUintStringMapValue(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("5:") + err = v.Set("0:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]string", v.Type()) @@ -448,17 +448,17 @@ func TestUint8StringMapValue(t *testing.T) { v := newUint8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("7:val1") + err = v.Set("4:val1") assert.Nil(t, err) - err = v.Set("6val2") + err = v.Set("4val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -470,11 +470,11 @@ func TestUint8StringMapValue(t *testing.T) { v := newUint8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4") + 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("3:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -489,17 +489,17 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6val1") + err = v.Set("3val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("0:val1") + err = v.Set("6:val1") assert.Nil(t, err) - err = v.Set("5val2") + 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("0:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -511,11 +511,11 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0") + err = v.Set("1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("2:") + err = v.Set("4:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -530,17 +530,17 @@ func TestUint32StringMapValue(t *testing.T) { v := newUint32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6val1") + err = v.Set("0val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("2:val1") + err = v.Set("0: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("4:val2") + err = v.Set("1:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]string", v.Type()) @@ -552,7 +552,7 @@ func TestUint32StringMapValue(t *testing.T) { v := newUint32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3") + err = v.Set("5") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) @@ -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("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("6:val1") assert.Nil(t, err) - err = v.Set("0val2") + 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("4:val2") + err = v.Set("0:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]string", v.Type()) @@ -593,11 +593,11 @@ func TestUint64StringMapValue(t *testing.T) { v := newUint64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6") + err = v.Set("1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("5:") + err = v.Set("4:") 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("kBIsStrue") + err = v.Set("npmuPtrue") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mcfFU:true") + err = v.Set("FfXII:true") assert.Nil(t, err) - err = v.Set("apWUZfalse") + err = v.Set("HoToifalse") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LwwHu:false") + err = v.Set("nZmRn: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("TJTRSunexpected") + err = v.Set("JTHCNunexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BnMTA:unexpected") + err = v.Set("YDwfu: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("1true") + err = v.Set("2true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("0:true") + err = v.Set("2:true") assert.Nil(t, err) - err = v.Set("4false") + 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("2:false") + err = v.Set("1:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]bool", v.Type()) @@ -870,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("0unexpected") + err = v.Set("1unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("4:unexpected") + err = v.Set("2:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]bool", v.Type()) @@ -889,17 +889,17 @@ func TestInt8BoolMapValue(t *testing.T) { v := newInt8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6true") + err = v.Set("3true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("6:true") + err = v.Set("0:true") assert.Nil(t, err) - err = v.Set("6false") + 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("2:false") + err = v.Set("5:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]bool", v.Type()) @@ -911,11 +911,11 @@ func TestInt8BoolMapValue(t *testing.T) { v := newInt8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4unexpected") + err = v.Set("1unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("4:unexpected") + err = v.Set("6: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("1true") + 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("3:true") + err = v.Set("7:true") assert.Nil(t, err) - err = v.Set("1false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("0: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("7unexpected") + err = v.Set("4unexpected") 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("4: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("1true") + 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("2:true") assert.Nil(t, err) - err = v.Set("1false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("5:false") + err = v.Set("3: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("5:unexpected") + err = v.Set("4: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("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("4:true") + err = v.Set("0:true") assert.Nil(t, err) - err = v.Set("5false") + err = v.Set("1false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("4:false") + err = v.Set("6:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]bool", v.Type()) @@ -1034,11 +1034,11 @@ func TestInt64BoolMapValue(t *testing.T) { v := newInt64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4unexpected") + err = v.Set("6unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("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[int64]bool", v.Type()) @@ -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("2true") + 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("1:true") + err = v.Set("6:true") assert.Nil(t, err) - err = v.Set("0false") + err = v.Set("6false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("1: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,7 +1075,7 @@ func TestUintBoolMapValue(t *testing.T) { v := newUintBoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2unexpected") + err = v.Set("3unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) @@ -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("6true") + 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("0:true") + err = v.Set("6: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("1:false") + err = v.Set("0: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("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("1:unexpected") + err = v.Set("7: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("3true") + 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("3: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("6:false") + err = v.Set("2:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]bool", v.Type()) @@ -1157,11 +1157,11 @@ func TestUint16BoolMapValue(t *testing.T) { v := newUint16BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1unexpected") + err = v.Set("3unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("1: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[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("1true") + 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("0:true") + err = v.Set("2:true") assert.Nil(t, err) - err = v.Set("6false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("4:false") + err = v.Set("2: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("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[uint32]bool", v.Type()) @@ -1217,17 +1217,17 @@ func TestUint64BoolMapValue(t *testing.T) { v := newUint64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3true") + 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("6:true") + err = v.Set("2:true") assert.Nil(t, err) - err = v.Set("3false") + err = v.Set("5false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("0:false") + err = v.Set("2:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]bool", v.Type()) @@ -1243,7 +1243,7 @@ func TestUint64BoolMapValue(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("7: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("ULDsu10") + err = v.Set("cXzqA10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LRHqe:10") + err = v.Set("dAAYD:10") assert.Nil(t, err) - err = v.Set("Qvoja20") + err = v.Set("mXjHe20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JOzDp:20") + err = v.Set("nYdcp: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("aNUHv-1") + err = v.Set("XdMyj-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FhXzh:-1") + err = v.Set("wqwmy:-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("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("5:10") + err = v.Set("6: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("3: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("7-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint", v.Type()) @@ -1529,13 +1529,13 @@ func TestInt8UintMapValue(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("1:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6: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("6-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[int8]uint", v.Type()) @@ -1570,13 +1570,13 @@ func TestInt16UintMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("2:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("7:-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[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("510") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("5: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("1:20") + err = v.Set("3: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("7-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("5:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint", v.Type()) @@ -1648,11 +1648,11 @@ func TestInt64UintMapValue(t *testing.T) { v := newInt64UintMapValue(&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("3:10") + err = v.Set("1:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -1674,7 +1674,7 @@ func TestInt64UintMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("6:-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("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("3: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("3:20") + err = v.Set("6: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("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("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[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("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("4:10") + err = v.Set("5: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("7: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("1-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[uint8]uint", v.Type()) @@ -1771,17 +1771,17 @@ func TestUint16UintMapValue(t *testing.T) { v := newUint16UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6: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("7:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint", v.Type()) @@ -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("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("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("6:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("7: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("2-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("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("2:10") + err = v.Set("1: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("3:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint", v.Type()) @@ -1875,11 +1875,11 @@ func TestUint64UintMapValue(t *testing.T) { v := newUint64UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-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("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[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("lkBMJ10") + err = v.Set("qvjbJ10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("vMxai:10") + err = v.Set("dbsYg:10") assert.Nil(t, err) - err = v.Set("NjAmP20") + err = v.Set("UcWrd20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BqnHu:20") + err = v.Set("iTbhy: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("HxRkr-1") + err = v.Set("HSMJr-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("wxdUJ:-1") + err = v.Set("yWXCo:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint8", v.Type()) @@ -2120,17 +2120,17 @@ func TestIntUint8MapValue(t *testing.T) { v := newIntUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("4:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint8", v.Type()) @@ -2142,11 +2142,11 @@ func TestIntUint8MapValue(t *testing.T) { v := newIntUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[int]uint8", v.Type()) @@ -2161,13 +2161,13 @@ func TestInt8Uint8MapValue(t *testing.T) { v := newInt8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("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("6:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -2183,11 +2183,11 @@ func TestInt8Uint8MapValue(t *testing.T) { v := newInt8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - 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[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("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("0:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("0-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("1:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint8", v.Type()) @@ -2243,17 +2243,17 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&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("3: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("5:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint8", v.Type()) @@ -2265,11 +2265,11 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-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("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]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("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("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2: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("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("6:-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("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("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("3:20") + err = v.Set("0: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("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("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[uint]uint8", v.Type()) @@ -2370,13 +2370,13 @@ func TestUint8Uint8MapValue(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("2: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("0:20") + err = v.Set("6: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("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[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("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0: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("4:20") + err = v.Set("2:20") assert.Nil(t, err) 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("210") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint8", v.Type()) @@ -2470,7 +2470,7 @@ func TestUint32Uint8MapValue(t *testing.T) { v := newUint32Uint8MapValue(&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) @@ -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("110") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("2: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[uint64]uint8", v.Type()) @@ -2515,7 +2515,7 @@ func TestUint64Uint8MapValue(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("5:-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[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("aWbPd10") + err = v.Set("FeZNk10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("fxYeD:10") + err = v.Set("Pzulp:10") assert.Nil(t, err) - err = v.Set("CzbXP20") + err = v.Set("RoFAk20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gRoVH:20") + err = v.Set("ncRYi: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("hyiEE-1") + err = v.Set("kThJl-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("tJjLa:-1") + err = v.Set("lPyBp:-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("710") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("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("2: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("7-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("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[int]uint16", v.Type()) @@ -2797,11 +2797,11 @@ func TestInt8Uint16MapValue(t *testing.T) { v := newInt8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -2823,7 +2823,7 @@ func TestInt8Uint16MapValue(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[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("5: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("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint16", v.Type()) @@ -2860,11 +2860,11 @@ func TestInt16Uint16MapValue(t *testing.T) { v := newInt16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint16", v.Type()) @@ -2879,13 +2879,13 @@ func TestInt32Uint16MapValue(t *testing.T) { v := newInt32Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + 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") 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) @@ -2905,7 +2905,7 @@ func TestInt32Uint16MapValue(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[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("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("3:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint16", v.Type()) @@ -2942,11 +2942,11 @@ func TestInt64Uint16MapValue(t *testing.T) { v := newInt64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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) - err = v.Set("1:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint16", v.Type()) @@ -2961,17 +2961,17 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("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("6:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint16", v.Type()) @@ -2983,11 +2983,11 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-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[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("6:10") + err = v.Set("2: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("5: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,7 +3024,7 @@ func TestUint8Uint16MapValue(t *testing.T) { v := newUint8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-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) @@ -3043,17 +3043,17 @@ func TestUint16Uint16MapValue(t *testing.T) { v := newUint16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("1:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("2: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("6-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("110") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - 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]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("1-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("210") + 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("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("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint16", v.Type()) @@ -3147,11 +3147,11 @@ func TestUint64Uint16MapValue(t *testing.T) { v := newUint64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-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("1:-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[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("rRSCT10") + err = v.Set("JKzWs10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qCqRG:10") + err = v.Set("MAaOa:10") assert.Nil(t, err) - err = v.Set("tgLNl20") + err = v.Set("jVzBM20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("MfWnI:20") + err = v.Set("gkUOu: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("Ugjzx-1") + err = v.Set("jfkcl-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LinnY:-1") + err = v.Set("pwkZk:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint32", v.Type()) @@ -3392,17 +3392,17 @@ func TestIntUint32MapValue(t *testing.T) { v := newIntUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") 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[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("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("2: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("1:20") + err = v.Set("5: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("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("4:-1") + err = v.Set("2:-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,7 +3474,7 @@ func TestInt16Uint32MapValue(t *testing.T) { v := newInt16Uint32MapValue(&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) @@ -3484,7 +3484,7 @@ func TestInt16Uint32MapValue(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("6:20") + err = v.Set("0: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("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("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint32", v.Type()) @@ -3515,13 +3515,13 @@ func TestInt32Uint32MapValue(t *testing.T) { v := newInt32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("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("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) @@ -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("2-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("5:10") assert.Nil(t, err) err = v.Set("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("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("1-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("0:-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]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("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3623,7 +3623,7 @@ func TestUintUint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("1:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("1: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("4-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]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("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("7:10") + err = v.Set("4: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("5:20") + err = v.Set("7: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("6-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("1:-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("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("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("7:20") + err = v.Set("5: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("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("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[uint32]uint32", v.Type()) @@ -3761,17 +3761,17 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("6:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint32", v.Type()) @@ -3783,11 +3783,11 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&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("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[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("Ynkph10") + err = v.Set("PnSQV10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("JtETa:10") + err = v.Set("ZxrgG:10") assert.Nil(t, err) - err = v.Set("TIlsU20") + err = v.Set("HqwhS20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("MpMcH:20") + err = v.Set("mSUsY: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("oLfCf-1") + err = v.Set("ljxHR-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("zJUJB:-1") + err = v.Set("VoBzJ:-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("410") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2: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("6: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("0-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("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("310") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("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("5: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("5-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("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("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint64", v.Type()) @@ -4132,7 +4132,7 @@ func TestInt16Uint64MapValue(t *testing.T) { v := newInt16Uint64MapValue(&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) @@ -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("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("5: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("7: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("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("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[int32]uint64", v.Type()) @@ -4192,17 +4192,17 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("620") + 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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint64", v.Type()) @@ -4214,7 +4214,7 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-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) @@ -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("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("5: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("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint64", v.Type()) @@ -4255,11 +4255,11 @@ func TestUintUint64MapValue(t *testing.T) { v := newUintUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint64", v.Type()) @@ -4278,13 +4278,13 @@ func TestUint8Uint64MapValue(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("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("7-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("7:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint64", v.Type()) @@ -4337,11 +4337,11 @@ func TestUint16Uint64MapValue(t *testing.T) { v := newUint16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint64", v.Type()) @@ -4356,17 +4356,17 @@ func TestUint32Uint64MapValue(t *testing.T) { v := newUint32Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("3:10") + err = v.Set("1: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("5:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint64", v.Type()) @@ -4378,11 +4378,11 @@ func TestUint32Uint64MapValue(t *testing.T) { v := newUint32Uint64MapValue(&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("5:-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]uint64", v.Type()) @@ -4397,17 +4397,17 @@ func TestUint64Uint64MapValue(t *testing.T) { v := newUint64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:10") + err = v.Set("0: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("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint64", v.Type()) @@ -4419,11 +4419,11 @@ func TestUint64Uint64MapValue(t *testing.T) { v := newUint64Uint64MapValue(&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("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[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("HVsTf10") + err = v.Set("XggYD10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qzbLs:10") + err = v.Set("Ggcme:10") assert.Nil(t, err) - err = v.Set("fVYzM20") + err = v.Set("dpYJD20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qPpCS:20") + err = v.Set("vdRFU: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("fJUBya") + err = v.Set("gDmePa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uuoIX:a") + err = v.Set("uKxBv: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("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4726,11 +4726,11 @@ func TestIntIntMapValue(t *testing.T) { v := newIntIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + 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("6:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4745,17 +4745,17 @@ func TestInt8IntMapValue(t *testing.T) { v := newInt8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("6:10") + err = v.Set("5: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("3:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int", v.Type()) @@ -4767,11 +4767,11 @@ func TestInt8IntMapValue(t *testing.T) { v := newInt8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("3:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("620") + 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("5: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("6a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int", v.Type()) @@ -4827,17 +4827,17 @@ func TestInt32IntMapValue(t *testing.T) { v := newInt32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("5:10") assert.Nil(t, err) err = v.Set("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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int", v.Type()) @@ -4849,11 +4849,11 @@ func TestInt32IntMapValue(t *testing.T) { v := newInt32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int", v.Type()) @@ -4868,17 +4868,17 @@ func TestInt64IntMapValue(t *testing.T) { v := newInt64IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("0:10") + err = v.Set("2: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("7:20") + err = v.Set("1: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("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("7: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,13 +4909,13 @@ func TestUintIntMapValue(t *testing.T) { v := newUintIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("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("2: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) @@ -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("2a") + err = v.Set("3a") 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("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("5:10") + err = v.Set("7: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("4: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("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("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]int", v.Type()) @@ -4991,13 +4991,13 @@ func TestUint16IntMapValue(t *testing.T) { v := newUint16IntMapValue(&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("1:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -5017,7 +5017,7 @@ func TestUint16IntMapValue(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("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int", v.Type()) @@ -5032,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("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") 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("4: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("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) @@ -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("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("5: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("1:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int", v.Type()) @@ -5095,7 +5095,7 @@ 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("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("iOPrg10") + err = v.Set("fHngP10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("rndrW:10") + err = v.Set("kuflq:10") assert.Nil(t, err) - err = v.Set("HxSDh20") + err = v.Set("lBMHM20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("VaTuR:20") + err = v.Set("xERna: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("PMVjba") + err = v.Set("FKPNMa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kuWVP:a") + err = v.Set("kmNKD: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,13 +5350,13 @@ func TestIntInt8MapValue(t *testing.T) { v := newIntInt8MapValue(&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("7:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("2a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("1: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("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("5: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) @@ -5413,7 +5413,7 @@ func TestInt8Int8MapValue(t *testing.T) { v := newInt8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("1:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("1: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("1a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[int16]int8", v.Type()) @@ -5473,17 +5473,17 @@ func TestInt32Int8MapValue(t *testing.T) { v := newInt32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("1:10") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int8", v.Type()) @@ -5495,11 +5495,11 @@ func TestInt32Int8MapValue(t *testing.T) { v := newInt32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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]int8", v.Type()) @@ -5514,13 +5514,13 @@ func TestInt64Int8MapValue(t *testing.T) { v := newInt64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("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("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) @@ -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("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("5: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[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("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("3:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("420") + 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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int8", v.Type()) @@ -5577,11 +5577,11 @@ func TestUintInt8MapValue(t *testing.T) { v := newUintInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("0: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("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2: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("5a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int8", v.Type()) @@ -5637,17 +5637,17 @@ func TestUint16Int8MapValue(t *testing.T) { v := newUint16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("3: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("3a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[uint16]int8", v.Type()) @@ -5682,9 +5682,9 @@ func TestUint32Int8MapValue(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("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) @@ -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("2a") + 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("4: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[uint32]int8", v.Type()) @@ -5719,17 +5719,17 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:10") + err = v.Set("0: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[uint64]int8", v.Type()) @@ -5741,11 +5741,11 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("hAnpH10") + err = v.Set("RupnA10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("KVDnT:10") + err = v.Set("WYsPG:10") assert.Nil(t, err) - err = v.Set("XCcdg20") + err = v.Set("BjUIw20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("bBjFj:20") + err = v.Set("oiKEV: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("rzOnGa") + err = v.Set("XtNUQa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("zJovW:a") + err = v.Set("XkyFq: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,7 +5996,7 @@ func TestIntInt16MapValue(t *testing.T) { v := newIntInt16MapValue(&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) @@ -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("7a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int16", v.Type()) @@ -6037,17 +6037,17 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("5: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("1:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int16", v.Type()) @@ -6059,11 +6059,11 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int16", v.Type()) @@ -6078,17 +6078,17 @@ func TestInt16Int16MapValue(t *testing.T) { v := newInt16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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) - err = v.Set("4: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("6a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("6: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()) @@ -6119,17 +6119,17 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("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("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int16", v.Type()) @@ -6141,7 +6141,7 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int16", v.Type()) @@ -6182,11 +6182,11 @@ func TestInt64Int16MapValue(t *testing.T) { v := newInt64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int16", v.Type()) @@ -6201,17 +6201,17 @@ func TestUintInt16MapValue(t *testing.T) { v := newUintInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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("1: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,11 +6223,11 @@ func TestUintInt16MapValue(t *testing.T) { v := newUintInt16MapValue(&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("0: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[uint]int16", v.Type()) @@ -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("310") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("3: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("2: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("6a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int16", v.Type()) @@ -6283,13 +6283,13 @@ func TestUint16Int16MapValue(t *testing.T) { v := newUint16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("0: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) @@ -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("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.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("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("3: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("0:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6346,11 +6346,11 @@ func TestUint32Int16MapValue(t *testing.T) { v := newUint32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6365,17 +6365,17 @@ func TestUint64Int16MapValue(t *testing.T) { v := newUint64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:10") + err = v.Set("7:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("7: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("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("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[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("OFaXx10") + err = v.Set("ggUNP10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("bOZZv:10") + err = v.Set("PnhvL:10") assert.Nil(t, err) - err = v.Set("wKMHM20") + err = v.Set("YnGqd20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uDqyA:20") + err = v.Set("yUqin: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("FrWVfa") + err = v.Set("whQwja") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("glgQW:a") + err = v.Set("hMHqT: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("710") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("3: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("0:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int32", v.Type()) @@ -6664,11 +6664,11 @@ func TestIntInt32MapValue(t *testing.T) { v := newIntInt32MapValue(&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("4: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[int]int32", v.Type()) @@ -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("0:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("0: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("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("0:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int32", v.Type()) @@ -6724,13 +6724,13 @@ func TestInt16Int32MapValue(t *testing.T) { v := newInt16Int32MapValue(&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("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -6746,7 +6746,7 @@ func TestInt16Int32MapValue(t *testing.T) { v := newInt16Int32MapValue(&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) @@ -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("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("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("0:20") + err = v.Set("7: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("0a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int32", v.Type()) @@ -6810,13 +6810,13 @@ func TestInt64Int32MapValue(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("7:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("5: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("1a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int32", v.Type()) @@ -6847,17 +6847,17 @@ func TestUintInt32MapValue(t *testing.T) { v := newUintInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("7: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("3: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,11 +6869,11 @@ func TestUintInt32MapValue(t *testing.T) { v := newUintInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - 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[uint]int32", v.Type()) @@ -6888,17 +6888,17 @@ func TestUint8Int32MapValue(t *testing.T) { v := newUint8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("1: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("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6910,11 +6910,11 @@ func TestUint8Int32MapValue(t *testing.T) { v := newUint8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6929,17 +6929,17 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("7: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("2:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int32", v.Type()) @@ -6951,11 +6951,11 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int32", v.Type()) @@ -6970,17 +6970,17 @@ func TestUint32Int32MapValue(t *testing.T) { v := newUint32Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("4: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("0:20") + err = v.Set("5: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("3a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("2: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("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("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("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("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) @@ -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("Kwidi10") + err = v.Set("LOWwK10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("WiqYf:10") + err = v.Set("Amyih:10") assert.Nil(t, err) - err = v.Set("zuXZp20") + err = v.Set("hojtM20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("cfcEq:20") + err = v.Set("RYdwp: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("EGPMBa") + err = v.Set("LTTISa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("sbkWa:a") + err = v.Set("EODEu:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int64", v.Type()) @@ -7288,17 +7288,17 @@ func TestIntInt64MapValue(t *testing.T) { v := newIntInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + 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") + 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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int64", v.Type()) @@ -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("4a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("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("3:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("5: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("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("7:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("3: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("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("2: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("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("0:10") 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("2:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int64", v.Type()) @@ -7433,7 +7433,7 @@ func TestInt32Int64MapValue(t *testing.T) { v := newInt32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -7456,13 +7456,13 @@ func TestInt64Int64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int64", v.Type()) @@ -7474,7 +7474,7 @@ func TestInt64Int64MapValue(t *testing.T) { v := newInt64Int64MapValue(&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) @@ -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("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("0:10") + err = v.Set("3: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("7:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int64", v.Type()) @@ -7515,11 +7515,11 @@ func TestUintInt64MapValue(t *testing.T) { v := newUintInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[uint]int64", v.Type()) @@ -7534,17 +7534,17 @@ func TestUint8Int64MapValue(t *testing.T) { v := newUint8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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("5:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int64", v.Type()) @@ -7560,7 +7560,7 @@ func TestUint8Int64MapValue(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("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int64", v.Type()) @@ -7575,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("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("3:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("6: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("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("3:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int64", v.Type()) @@ -7616,17 +7616,17 @@ func TestUint32Int64MapValue(t *testing.T) { v := newUint32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("4:10") 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("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("4a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("710") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("2: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("1a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("EfBGI10.2") + err = v.Set("DfQff10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("vDVDf:10.2") + err = v.Set("IMUVc:10.2") assert.Nil(t, err) - err = v.Set("RuRcq20.99") + err = v.Set("yNswP20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FzABr:20.99") + err = v.Set("LIHQg: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("OeYHia") + err = v.Set("zKMmma") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qllmQ:a") + err = v.Set("XhTRg: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("310.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("1:10.2") assert.Nil(t, err) - err = v.Set("720.99") + err = v.Set("120.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("6:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float64", v.Type()) @@ -7936,7 +7936,7 @@ func TestIntFloat64MapValue(t *testing.T) { v := newIntFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -7955,17 +7955,17 @@ func TestInt8Float64MapValue(t *testing.T) { v := newInt8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410.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("1:10.2") + err = v.Set("6:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("320.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("7:20.99") + err = v.Set("0: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("7a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1: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[int8]float64", v.Type()) @@ -7996,17 +7996,17 @@ func TestInt16Float64MapValue(t *testing.T) { v := newInt16Float64MapValue(&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("5:10.2") + err = v.Set("0:10.2") assert.Nil(t, err) - err = v.Set("720.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("3:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]float64", v.Type()) @@ -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("6a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("610.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) err = v.Set("0:10.2") assert.Nil(t, err) - err = v.Set("220.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("4:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float64", v.Type()) @@ -8059,11 +8059,11 @@ func TestInt32Float64MapValue(t *testing.T) { v := newInt32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[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("410.2") + err = v.Set("610.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("4:10.2") + err = v.Set("5: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("7:20.99") + err = v.Set("5: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("4a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - 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[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("210.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("4:10.2") assert.Nil(t, err) - err = v.Set("720.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("6:20.99") + err = v.Set("5: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("3a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6: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()) @@ -8164,13 +8164,13 @@ func TestUint8Float64MapValue(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("1:10.2") assert.Nil(t, err) - err = v.Set("120.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("4: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("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("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[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("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("0:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("3:20.99") + err = v.Set("5:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float64", v.Type()) @@ -8223,11 +8223,11 @@ func TestUint16Float64MapValue(t *testing.T) { v := newUint16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("6: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("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("0: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("3: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()) @@ -8268,7 +8268,7 @@ func TestUint32Float64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float64", v.Type()) @@ -8283,17 +8283,17 @@ func TestUint64Float64MapValue(t *testing.T) { v := newUint64Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110.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("3:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("320.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("5:20.99") + err = v.Set("3: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("5a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("cVZgO10.2") + err = v.Set("ZixsM10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("iUebv:10.2") + err = v.Set("rzbDB:10.2") assert.Nil(t, err) - err = v.Set("hNDye20.99") + err = v.Set("XNUkY20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ybuCc:20.99") + err = v.Set("xXXOh: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("zMdbsa") + err = v.Set("KIxEEa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uvBAw:a") + err = v.Set("kCglT: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("410.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("2:10.2") + err = v.Set("1: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("1: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("1a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1: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[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("310.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("7:10.2") + err = v.Set("6: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("7: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("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("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("710.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("4:10.2") + err = v.Set("6: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("3:20.99") + err = v.Set("6: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("0a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[int16]float32", v.Type()) @@ -8663,11 +8663,11 @@ 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("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("5:10.2") assert.Nil(t, err) err = v.Set("320.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -8685,11 +8685,11 @@ func TestInt32Float32MapValue(t *testing.T) { v := newInt32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("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.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("610.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("5:10.2") + err = v.Set("6:10.2") assert.Nil(t, err) - err = v.Set("420.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("6:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float32", v.Type()) @@ -8726,11 +8726,11 @@ func TestInt64Float32MapValue(t *testing.T) { v := newInt64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2: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("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("5:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("120.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("6:20.99") + err = v.Set("2: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("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("0: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,13 +8786,13 @@ func TestUint8Float32MapValue(t *testing.T) { v := newUint8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.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("420.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) @@ -8812,7 +8812,7 @@ func TestUint8Float32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8827,17 +8827,17 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("7:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("320.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float32", v.Type()) @@ -8849,7 +8849,7 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&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) @@ -8872,13 +8872,13 @@ func TestUint32Float32MapValue(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("6:10.2") assert.Nil(t, err) - err = v.Set("620.99") + err = v.Set("120.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("0: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("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("1: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("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("7:10.2") + err = v.Set("3:10.2") assert.Nil(t, err) - err = v.Set("020.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("2:20.99") + err = v.Set("6: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("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("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[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("dePor10s") + err = v.Set("NjUZE10s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("oyNdT:10s") + err = v.Set("Jbnpq:10s") assert.Nil(t, err) - err = v.Set("EBcbh30m") + err = v.Set("lFyfn30m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("jmcXV:30m") + err = v.Set("NpXtF: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("InyIN3l") + err = v.Set("mWFjq3l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mnpPy:3l") + err = v.Set("iUceL: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("710s") + err = v.Set("110s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("6:10s") + err = v.Set("3:10s") assert.Nil(t, err) - err = v.Set("530m") + 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[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("13l") + 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("4: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("510s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("2:10s") + err = v.Set("0:10s") assert.Nil(t, err) - err = v.Set("330m") + err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("5:30m") + err = v.Set("4:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]time.Duration", v.Type()) @@ -9223,7 +9223,7 @@ func TestInt8DurationMapValue(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("0: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("310s") + 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("1:10s") + err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("330m") + 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("2:30m") + err = v.Set("0: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("63l") + 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("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("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("5:10s") + err = v.Set("3:10s") assert.Nil(t, err) err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("7:30m") + err = v.Set("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]time.Duration", v.Type()) @@ -9301,11 +9301,11 @@ func TestInt32DurationMapValue(t *testing.T) { v := newInt32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("33l") + 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("0: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("410s") + 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("430m") + 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("5:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]time.Duration", v.Type()) @@ -9342,7 +9342,7 @@ func TestInt64DurationMapValue(t *testing.T) { v := newInt64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("63l") + err = v.Set("43l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) @@ -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("110s") + err = v.Set("510s") 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("130m") + err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("2:30m") + err = v.Set("4:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]time.Duration", v.Type()) @@ -9383,7 +9383,7 @@ func TestUintDurationMapValue(t *testing.T) { v := newUintDurationMapValue(&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) @@ -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("310s") + 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("7: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("7: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("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("3: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[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("410s") + err = v.Set("210s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("4:10s") + err = v.Set("3:10s") assert.Nil(t, err) - err = v.Set("030m") + 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("1:30m") + err = v.Set("0: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("43l") + err = v.Set("23l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("3:3l") + err = v.Set("0:3l") assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]time.Duration", v.Type()) @@ -9484,17 +9484,17 @@ func TestUint32DurationMapValue(t *testing.T) { v := newUint32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710s") + err = v.Set("610s") 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("5:10s") assert.Nil(t, err) 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("1:30m") + err = v.Set("6:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]time.Duration", v.Type()) @@ -9510,7 +9510,7 @@ func TestUint32DurationMapValue(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("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[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("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("2:10s") assert.Nil(t, err) - err = v.Set("030m") + err = v.Set("330m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("7:30m") + err = v.Set("6:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]time.Duration", v.Type()) @@ -9547,7 +9547,7 @@ func TestUint64DurationMapValue(t *testing.T) { v := newUint64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("03l") + err = v.Set("53l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) @@ -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("hPVqi127.0.0.1") + err = v.Set("OFOqq127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("crRzo:127.0.0.1") + err = v.Set("dYklF:127.0.0.1") assert.Nil(t, err) - err = v.Set("aEsNw127.0.0.3") + err = v.Set("JFoAd127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("peGOe:127.0.0.3") + err = v.Set("kLdLG: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("reGcf127.0.0.1.3") + err = v.Set("CDTPJ127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("bcUTZ:127.0.0.1.3") + err = v.Set("zGNum:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]net.IP", v.Type()) @@ -9772,17 +9772,17 @@ func TestIntIPMapValue(t *testing.T) { v := newIntIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0127.0.0.1") + err = v.Set("1127.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("4:127.0.0.1") assert.Nil(t, err) 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[int]net.IP", v.Type()) @@ -9798,7 +9798,7 @@ func TestIntIPMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("4:127.0.0.1.3") + err = v.Set("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("1127.0.0.1") + err = v.Set("7127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("0:127.0.0.1") + err = v.Set("3:127.0.0.1") assert.Nil(t, err) - err = v.Set("7127.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("2: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[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("0127.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("4: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[int8]net.IP", v.Type()) @@ -9858,7 +9858,7 @@ func TestInt16IPMapValue(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("7:127.0.0.1") + err = v.Set("3:127.0.0.1") assert.Nil(t, err) err = v.Set("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -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("4127.0.0.1.3") + err = v.Set("2127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("7: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,13 +9895,13 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3127.0.0.1") + err = v.Set("5127.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("3:127.0.0.1") assert.Nil(t, err) - err = v.Set("1127.0.0.3") + err = v.Set("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) @@ -9917,11 +9917,11 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6127.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("5:127.0.0.1.3") + err = v.Set("7:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IP", v.Type()) @@ -9936,17 +9936,17 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0127.0.0.1") + err = v.Set("5127.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("0127.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("5:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IP", v.Type()) @@ -9958,11 +9958,11 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6127.0.0.1.3") + err = v.Set("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("0:127.0.0.1.3") + err = v.Set("1:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IP", v.Type()) @@ -9977,17 +9977,17 @@ func TestUintIPMapValue(t *testing.T) { v := newUintIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5127.0.0.1") + err = v.Set("0127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1") + err = v.Set("4:127.0.0.1") assert.Nil(t, err) - err = v.Set("3127.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("5:127.0.0.3") + err = v.Set("2:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]net.IP", v.Type()) @@ -9999,11 +9999,11 @@ func TestUintIPMapValue(t *testing.T) { v := newUintIPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.0.0.1.3") + err = v.Set("0127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("1: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[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("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("4:127.0.0.1") + err = v.Set("2:127.0.0.1") assert.Nil(t, err) - err = v.Set("2127.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("0: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("0127.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("2: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[uint8]net.IP", v.Type()) @@ -10063,9 +10063,9 @@ func TestUint16IPMapValue(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("6:127.0.0.1") + err = v.Set("2:127.0.0.1") assert.Nil(t, err) - err = v.Set("5127.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) @@ -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("5127.0.0.1.3") + err = v.Set("4127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("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[uint16]net.IP", v.Type()) @@ -10100,17 +10100,17 @@ func TestUint32IPMapValue(t *testing.T) { v := newUint32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4127.0.0.1") + err = v.Set("2127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("3: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("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("1:127.0.0.3") + err = v.Set("3:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IP", v.Type()) @@ -10126,7 +10126,7 @@ func TestUint32IPMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("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[uint32]net.IP", v.Type()) @@ -10145,13 +10145,13 @@ func TestUint64IPMapValue(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("2: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("0127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("7: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[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("7127.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("1: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[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("WjNXoff") + err = v.Set("EQwESff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("xOWtq:ff") + err = v.Set("haVbX:ff") assert.Nil(t, err) - err = v.Set("MBoKnaa") + err = v.Set("NNjdyaa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mQySg:aa") + err = v.Set("Lsbaa: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("cKukagg") + err = v.Set("qyNPggg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("PXZLX:gg") + err = v.Set("eVhTs:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]HexBytes", v.Type()) @@ -10408,17 +10408,17 @@ func TestIntHexBytesMapValue(t *testing.T) { v := newIntHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1ff") + err = v.Set("4ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("0:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("6aa") + 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("7:aa") + err = v.Set("4:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]HexBytes", v.Type()) @@ -10430,11 +10430,11 @@ func TestIntHexBytesMapValue(t *testing.T) { v := newIntHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4gg") + 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("1: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[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("1ff") + 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("1:ff") assert.Nil(t, err) - err = v.Set("2aa") + err = v.Set("3aa") 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[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("1gg") + 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("4: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[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("0ff") + 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("2:ff") + err = v.Set("0:ff") assert.Nil(t, err) - err = v.Set("3aa") + err = v.Set("6aa") 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("0:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]HexBytes", v.Type()) @@ -10512,7 +10512,7 @@ func TestInt16HexBytesMapValue(t *testing.T) { v := newInt16HexBytesMapValue(&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) @@ -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("7ff") + 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("5:ff") + err = v.Set("1:ff") assert.Nil(t, err) - err = v.Set("2aa") + err = v.Set("7aa") 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("6: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[int32]HexBytes", v.Type()) @@ -10572,17 +10572,17 @@ 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("6ff") 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("4aa") + 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("4:aa") + err = v.Set("3:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]HexBytes", v.Type()) @@ -10594,11 +10594,11 @@ func TestInt64HexBytesMapValue(t *testing.T) { v := newInt64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2gg") + err = v.Set("3gg") 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("0:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]HexBytes", v.Type()) @@ -10613,17 +10613,17 @@ func TestUintHexBytesMapValue(t *testing.T) { v := newUintHexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7ff") + 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("6:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("0aa") + 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("3:aa") + err = v.Set("4:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]HexBytes", v.Type()) @@ -10639,7 +10639,7 @@ func TestUintHexBytesMapValue(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("5:gg") + err = v.Set("6:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("1ff") + 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("3:ff") + err = v.Set("4: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) - err = v.Set("7:aa") + err = v.Set("3: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("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("7: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[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("0ff") + 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("7:ff") + err = v.Set("5:ff") assert.Nil(t, err) - err = v.Set("3aa") + 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("1:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]HexBytes", v.Type()) @@ -10721,7 +10721,7 @@ func TestUint16HexBytesMapValue(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("0: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[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("3ff") + 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("2:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("3aa") + 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("3:aa") + err = v.Set("2:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]HexBytes", v.Type()) @@ -10758,11 +10758,11 @@ func TestUint32HexBytesMapValue(t *testing.T) { v := newUint32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6gg") + err = v.Set("4gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("2:gg") + err = v.Set("0: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("3ff") + err = v.Set("0ff") 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("3aa") 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("5:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]HexBytes", v.Type()) @@ -10799,11 +10799,11 @@ func TestUint64HexBytesMapValue(t *testing.T) { v := newUint64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1gg") + 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("5:gg") + err = v.Set("1:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("UiAIbabc.*") + err = v.Set("ETnIjabc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("wLRMC:abc.*") + err = v.Set("XGPPa:abc.*") assert.Nil(t, err) - err = v.Set("HokCexyz.*") + err = v.Set("LlWUMxyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("AktfY:xyz.*") + err = v.Set("rZdGR: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("ezNXi[abc") + err = v.Set("GJtWY[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("jFqCQ:[abc") + err = v.Set("LCRop:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]*regexp.Regexp", v.Type()) @@ -11024,17 +11024,17 @@ func TestIntRegexpMapValue(t *testing.T) { v := newIntRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3abc.*") + 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("6:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("0xyz.*") + 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("2:xyz.*") + err = v.Set("5:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]*regexp.Regexp", v.Type()) @@ -11046,11 +11046,11 @@ func TestIntRegexpMapValue(t *testing.T) { v := newIntRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0[abc") + err = v.Set("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("3:[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,13 +11065,13 @@ func TestInt8RegexpMapValue(t *testing.T) { v := newInt8RegexpMapValue(&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("1:abc.*") + err = v.Set("0:abc.*") assert.Nil(t, err) - err = v.Set("6xyz.*") + err = v.Set("0xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -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("3[abc") + err = v.Set("5[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("2:[abc") + err = v.Set("1:[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("2abc.*") + err = v.Set("4abc.*") 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("4xyz.*") + 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("3:xyz.*") + err = v.Set("0: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("0[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("2:[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("1abc.*") + err = v.Set("7abc.*") 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("6xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("5:xyz.*") + err = v.Set("6:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]*regexp.Regexp", v.Type()) @@ -11169,11 +11169,11 @@ func TestInt32RegexpMapValue(t *testing.T) { v := newInt32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6[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("5:[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[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("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("4:abc.*") + err = v.Set("1: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("0: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("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("0:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("6abc.*") + 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("6:abc.*") assert.Nil(t, err) - err = v.Set("7xyz.*") + err = v.Set("6xyz.*") 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("4: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("5[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("2:[abc") + err = v.Set("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()) @@ -11276,11 +11276,11 @@ func TestUint8RegexpMapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("2:abc.*") assert.Nil(t, err) - err = v.Set("0xyz.*") + 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("6:xyz.*") + err = v.Set("0:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]*regexp.Regexp", v.Type()) @@ -11296,7 +11296,7 @@ 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("2:[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[uint8]*regexp.Regexp", v.Type()) @@ -11311,17 +11311,17 @@ func TestUint16RegexpMapValue(t *testing.T) { v := newUint16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1abc.*") + 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("4:abc.*") + err = v.Set("7:abc.*") assert.Nil(t, err) - err = v.Set("6xyz.*") + err = v.Set("4xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("4:xyz.*") + err = v.Set("1:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]*regexp.Regexp", v.Type()) @@ -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("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("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[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("1abc.*") + err = v.Set("2abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("4:abc.*") + err = v.Set("2: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("4: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()) @@ -11378,7 +11378,7 @@ func TestUint32RegexpMapValue(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("3:[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("5abc.*") + err = v.Set("7abc.*") 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.*") assert.Nil(t, err) - err = v.Set("4xyz.*") + 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("3:xyz.*") + err = v.Set("5:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]*regexp.Regexp", v.Type()) @@ -11415,7 +11415,7 @@ func TestUint64RegexpMapValue(t *testing.T) { v := newUint64RegexpMapValue(&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) @@ -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("FMUiB0.0.0.0/0") + err = v.Set("CZNAw0.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("URLpf:0.0.0.0/0") + err = v.Set("eyxsx:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("GDCxB255.255.255.255/19") + err = v.Set("VbZJj255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("AjRnv:255.255.255.255/19") + err = v.Set("vbMJG: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("jtsGD0.0.0.256/16") + err = v.Set("xwoJN0.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("UbvdA:0.0.0.256/16") + err = v.Set("rTiiB: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("60.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("6:0.0.0.0/0") + err = v.Set("4:0.0.0.0/0") assert.Nil(t, err) err = v.Set("3255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("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[int]net.IPNet", v.Type()) @@ -11794,11 +11794,11 @@ func TestIntIPNetMapValue(t *testing.T) { v := newIntIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("30.0.0.256/16") + err = v.Set("70.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("3: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[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("10.0.0.0/0") + err = v.Set("60.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("1:0.0.0.0/0") + err = v.Set("7:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("1255.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("4: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[int8]net.IPNet", v.Type()) @@ -11835,7 +11835,7 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("30.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) @@ -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("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("5:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("1255.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("0: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[int16]net.IPNet", v.Type()) @@ -11880,7 +11880,7 @@ func TestInt16IPNetMapValue(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("7:0.0.0.256/16") + err = v.Set("6:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("2:0.0.0.0/0") + err = v.Set("0:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("2255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("0:255.255.255.255/19") + err = v.Set("7:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IPNet", v.Type()) @@ -11917,11 +11917,11 @@ func TestInt32IPNetMapValue(t *testing.T) { v := newInt32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.256/16") + err = v.Set("20.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("2:0.0.0.256/16") + err = v.Set("1:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IPNet", v.Type()) @@ -11936,17 +11936,17 @@ func TestInt64IPNetMapValue(t *testing.T) { v := newInt64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.0/0") + err = v.Set("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("6:0.0.0.0/0") + err = v.Set("4:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("3255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("1: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[int64]net.IPNet", v.Type()) @@ -11958,7 +11958,7 @@ func TestInt64IPNetMapValue(t *testing.T) { v := newInt64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.256/16") + err = v.Set("50.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) @@ -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("50.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("0: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("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("5:255.255.255.255/19") + err = v.Set("2: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("10.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("4:0.0.0.256/16") + err = v.Set("2: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("00.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("7:0.0.0.0/0") + err = v.Set("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("3255.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("4: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[uint8]net.IPNet", v.Type()) @@ -12040,11 +12040,11 @@ func TestUint8IPNetMapValue(t *testing.T) { v := newUint8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("50.0.0.256/16") + err = v.Set("20.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("1:0.0.0.256/16") + err = v.Set("4:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]net.IPNet", v.Type()) @@ -12059,17 +12059,17 @@ func TestUint16IPNetMapValue(t *testing.T) { v := newUint16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("10.0.0.0/0") + err = v.Set("70.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) err = v.Set("2:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("0255.255.255.255/19") + err = v.Set("3255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("2:255.255.255.255/19") + err = v.Set("3:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]net.IPNet", v.Type()) @@ -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("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("4:0.0.0.256/16") + err = v.Set("2: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("20.0.0.0/0") + err = v.Set("60.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("2:0.0.0.0/0") + err = v.Set("5:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("1255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("3:255.255.255.255/19") + err = v.Set("7:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IPNet", v.Type()) @@ -12126,7 +12126,7 @@ func TestUint32IPNetMapValue(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("2: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[uint32]net.IPNet", v.Type()) @@ -12147,11 +12147,11 @@ func TestUint64IPNetMapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("2:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("4255.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("4:255.255.255.255/19") + err = v.Set("0: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("50.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("7:0.0.0.256/16") + err = v.Set("2: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()) From f000c725ae48a99933ca86a5b3790e064268de31 Mon Sep 17 00:00:00 2001 From: Naveen Gogineni Date: Wed, 13 Nov 2024 06:14:50 -0500 Subject: [PATCH 2/5] Add new required field for tests --- gen/gcli/gcli_test.go | 15 +- gen/gcli/gcliv3_test.go | 15 +- gen/gkingpin/gkingpin_test.go | 14 +- values_generated_test.go | 2238 ++++++++++++++++----------------- 4 files changed, 1151 insertions(+), 1131 deletions(-) diff --git a/gen/gcli/gcli_test.go b/gen/gcli/gcli_test.go index bb60979..940704c 100644 --- a/gen/gcli/gcli_test.go +++ b/gen/gcli/gcli_test.go @@ -2,6 +2,7 @@ package gcli import ( "errors" + "fmt" "io" "strings" "testing" @@ -13,8 +14,9 @@ import ( ) type cfg1 struct { - StringValue1 string `flag:",required"` + StringValue1 string StringValue2 string `flag:"string-value-two s"` + StringValue3 string `flag:",required"` CounterValue1 sflags.Counter @@ -36,6 +38,7 @@ func TestParse(t *testing.T) { cfg: &cfg1{ StringValue1: "string_value1_value", StringValue2: "string_value2_value", + StringValue3: "string_value3_value", CounterValue1: 1, @@ -44,6 +47,7 @@ func TestParse(t *testing.T) { expCfg: &cfg1{ StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", CounterValue1: 3, @@ -53,6 +57,7 @@ func TestParse(t *testing.T) { args: []string{ "--string-value1", "string_value1_value2", "--string-value-two", "string_value2_value2", + "--string-value3", "string_value3_value2", "--counter-value1", "--counter-value1", "--string-slice-value1", "one2", "--string-slice-value1", "two2", @@ -70,7 +75,7 @@ func TestParse(t *testing.T) { StringValue2: "", }, args: []string{}, - expErr2: errors.New("required flag \"string-value1\" not set"), + expErr2: fmt.Errorf("required flag \"string-value3\" not set"), }, { name: "Test cfg1 short option", @@ -78,12 +83,12 @@ func TestParse(t *testing.T) { StringValue2: "string_value2_value", }, expCfg: &cfg1{ - StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", }, args: []string{ + "--string-value3", "string_value3_value2", "-s=string_value2_value2", - "--string-value1", "string_value1_value2", }, }, { @@ -92,12 +97,14 @@ func TestParse(t *testing.T) { expCfg: &cfg1{ StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", CounterValue1: 3, }, args: []string{ "--string-value1", "string_value1_value2", "--string-value-two", "string_value2_value2", + "--string-value3", "string_value3_value2", "--counter-value1=2", "--counter-value1", }, }, diff --git a/gen/gcli/gcliv3_test.go b/gen/gcli/gcliv3_test.go index a319c6e..284bf50 100644 --- a/gen/gcli/gcliv3_test.go +++ b/gen/gcli/gcliv3_test.go @@ -3,6 +3,7 @@ package gcli import ( "context" "errors" + "fmt" "io" "strings" "testing" @@ -14,8 +15,9 @@ import ( ) type cfg2 struct { - StringValue1 string `flag:",required"` + StringValue1 string StringValue2 string `flag:"string-value-two s"` + StringValue3 string `flag:",required"` CounterValue1 sflags.Counter @@ -37,6 +39,7 @@ func TestParseV3(t *testing.T) { cfg: &cfg2{ StringValue1: "string_value1_value", StringValue2: "string_value2_value", + StringValue3: "string_value3_value", CounterValue1: 1, @@ -45,6 +48,7 @@ func TestParseV3(t *testing.T) { expCfg: &cfg2{ StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", CounterValue1: 3, @@ -54,6 +58,7 @@ func TestParseV3(t *testing.T) { args: []string{ "--string-value1", "string_value1_value2", "--string-value-two", "string_value2_value2", + "--string-value3", "string_value3_value2", "--counter-value1", "--counter-value1", "--string-slice-value1", "one2", "--string-slice-value1", "two2", @@ -71,7 +76,7 @@ func TestParseV3(t *testing.T) { StringValue2: "", }, args: []string{}, - expErr2: errors.New("required flag \"string-value1\" not set"), + expErr2: fmt.Errorf("required flag \"string-value3\" not set"), }, { name: "Test cfg2 short option", @@ -79,12 +84,12 @@ func TestParseV3(t *testing.T) { StringValue2: "string_value2_value", }, expCfg: &cfg2{ - StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", }, args: []string{ + "--string-value3", "string_value3_value2", "-s=string_value2_value2", - "--string-value1", "string_value1_value2", }, }, { @@ -93,12 +98,14 @@ func TestParseV3(t *testing.T) { expCfg: &cfg2{ StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", CounterValue1: 3, }, args: []string{ "--string-value1", "string_value1_value2", "--string-value-two", "string_value2_value2", + "--string-value3", "string_value3_value2", "--counter-value1=2", "--counter-value1", }, }, diff --git a/gen/gkingpin/gkingpin_test.go b/gen/gkingpin/gkingpin_test.go index 92ab781..700189d 100644 --- a/gen/gkingpin/gkingpin_test.go +++ b/gen/gkingpin/gkingpin_test.go @@ -11,8 +11,9 @@ import ( ) type cfg1 struct { - StringValue1 string `flag:",required"` + StringValue1 string StringValue2 string `flag:"string-value-two s"` + StringValue3 string `flag:",required"` CounterValue1 sflags.Counter @@ -34,6 +35,7 @@ func TestParse(t *testing.T) { cfg: &cfg1{ StringValue1: "string_value1_value", StringValue2: "string_value2_value", + StringValue3: "string_value3_value", CounterValue1: 1, @@ -42,6 +44,7 @@ func TestParse(t *testing.T) { expCfg: &cfg1{ StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", CounterValue1: 3, @@ -51,6 +54,7 @@ func TestParse(t *testing.T) { args: []string{ "--string-value1", "string_value1_value2", "--string-value-two", "string_value2_value2", + "--string-value3", "string_value3_value2", "--counter-value1", "--counter-value1", "--string-slice-value1", "one2", "--string-slice-value1", "two2", @@ -68,7 +72,7 @@ func TestParse(t *testing.T) { StringValue2: "", }, args: []string{}, - expErr2: errors.New("required flag(s) '--string-value1' not provided"), + expErr2: errors.New("required flag(s) '--string-value3' not provided"), }, { name: "Test cfg1 short option", @@ -76,12 +80,12 @@ func TestParse(t *testing.T) { StringValue2: "string_value2_value", }, expCfg: &cfg1{ - StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value", }, args: []string{ + "--string-value3", "string_value3_value", "-s", "string_value2_value2", - "--string-value1", "string_value1_value2", }, }, { @@ -90,12 +94,14 @@ func TestParse(t *testing.T) { expCfg: &cfg1{ StringValue1: "string_value1_value2", StringValue2: "string_value2_value2", + StringValue3: "string_value3_value2", CounterValue1: 1, }, args: []string{ "--string-value1", "string_value1_value2", "--string-value-two", "string_value2_value2", + "--string-value3", "string_value3_value2", // kingpin can't pass value for boolean arguments. //"--counter-value1", "2", "--counter-value1", diff --git a/values_generated_test.go b/values_generated_test.go index f1dea87..02ce66b 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("eqJMbval1") + err = v.Set("PjnxHval1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("GOgZJ:val1") + err = v.Set("JGJtB:val1") assert.Nil(t, err) - err = v.Set("UCDQEval2") + err = v.Set("jZFHkval2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("aGgBp:val2") + err = v.Set("iHPlL: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("GxTWJ") + err = v.Set("QhsBt") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BSxvV:") + err = v.Set("Pviem:") 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("4val1") + err = v.Set("6val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("0:val1") + err = v.Set("6: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("1:val2") + err = v.Set("3:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]string", v.Type()) @@ -224,7 +224,7 @@ func TestIntStringMapValue(t *testing.T) { v := newIntStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2") + err = v.Set("3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) @@ -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("0val1") + 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("7:val1") + err = v.Set("1:val1") assert.Nil(t, err) - err = v.Set("2val2") + 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("3: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("3") + 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("5:") 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("1val1") + err = v.Set("2val1") 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("6:val1") assert.Nil(t, err) - err = v.Set("4val2") + 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[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("7") + 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("6:") + err = v.Set("2:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]string", v.Type()) @@ -325,13 +325,13 @@ func TestInt32StringMapValue(t *testing.T) { v := newInt32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0val1") + 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("0:val1") + err = v.Set("1:val1") assert.Nil(t, err) - err = v.Set("2val2") + err = v.Set("1val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) @@ -366,17 +366,17 @@ func TestInt64StringMapValue(t *testing.T) { v := newInt64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4val1") + err = v.Set("6val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("1:val1") + err = v.Set("3: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("5:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]string", v.Type()) @@ -388,11 +388,11 @@ func TestInt64StringMapValue(t *testing.T) { v := newInt64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7") + err = v.Set("0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("6:") + err = v.Set("0:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]string", v.Type()) @@ -407,13 +407,13 @@ func TestUintStringMapValue(t *testing.T) { v := newUintStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5val1") + err = v.Set("6val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("5:val1") + err = v.Set("3:val1") assert.Nil(t, err) - err = v.Set("4val2") + err = v.Set("7val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) @@ -429,11 +429,11 @@ func TestUintStringMapValue(t *testing.T) { v := newUintStringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2") + err = v.Set("3") 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[uint]string", v.Type()) @@ -448,17 +448,17 @@ func TestUint8StringMapValue(t *testing.T) { v := newUint8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5val1") + err = v.Set("3val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("4:val1") + err = v.Set("1:val1") assert.Nil(t, err) err = v.Set("4val2") 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("1:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -470,11 +470,11 @@ func TestUint8StringMapValue(t *testing.T) { v := newUint8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6") + err = v.Set("3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("3:") + err = v.Set("4:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -489,17 +489,17 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3val1") + 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("6: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("3:val2") + err = v.Set("1:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -511,11 +511,11 @@ func TestUint16StringMapValue(t *testing.T) { v := newUint16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1") + err = v.Set("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("4:") + err = v.Set("3:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]string", v.Type()) @@ -530,17 +530,17 @@ func TestUint32StringMapValue(t *testing.T) { v := newUint32StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0val1") + err = v.Set("6val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) err = v.Set("0:val1") assert.Nil(t, err) - err = v.Set("3val2") + 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("5: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("5") + err = v.Set("1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("3:") + err = v.Set("0:") 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("7val1") + err = v.Set("6val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("6:val1") + err = v.Set("4:val1") assert.Nil(t, err) 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("0:val2") + err = v.Set("6:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]string", v.Type()) @@ -593,11 +593,11 @@ func TestUint64StringMapValue(t *testing.T) { v := newUint64StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1") + err = v.Set("5") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("4:") + err = v.Set("2:") 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("npmuPtrue") + err = v.Set("ztFTqtrue") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FfXII:true") + err = v.Set("RjWBg:true") assert.Nil(t, err) - err = v.Set("HoToifalse") + err = v.Set("prfzMfalse") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nZmRn:false") + err = v.Set("kIMOi: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("JTHCNunexpected") + err = v.Set("NBOqcunexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("YDwfu:unexpected") + err = v.Set("tnDZE: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("2true") + 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("2:true") + err = v.Set("1:true") assert.Nil(t, err) - err = v.Set("3false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("1:false") + err = v.Set("5: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("1unexpected") + err = v.Set("4unexpected") 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("3: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()) @@ -889,11 +889,11 @@ func TestInt8BoolMapValue(t *testing.T) { v := newInt8BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3true") + 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("0:true") + err = v.Set("6:true") assert.Nil(t, err) err = v.Set("3false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -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("1unexpected") + err = v.Set("3unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("6: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[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("4true") + err = v.Set("6true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("7:true") + err = v.Set("6:true") assert.Nil(t, err) - err = v.Set("0false") + err = v.Set("2false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("6:false") + err = v.Set("7: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("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("4:unexpected") + err = v.Set("7: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("4true") + 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("2:true") + err = v.Set("0:true") assert.Nil(t, err) err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("3:false") + err = v.Set("0:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]bool", v.Type()) @@ -993,11 +993,11 @@ func TestInt32BoolMapValue(t *testing.T) { v := newInt32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4: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[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("4true") + 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("0:true") + err = v.Set("7:true") assert.Nil(t, err) - err = v.Set("1false") + 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("6:false") + err = v.Set("3:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]bool", v.Type()) @@ -1038,7 +1038,7 @@ func TestInt64BoolMapValue(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("7:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]bool", v.Type()) @@ -1053,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("7true") + err = v.Set("3true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("6:true") + err = v.Set("1:true") assert.Nil(t, err) - err = v.Set("6false") + 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("6:false") + err = v.Set("0: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("3unexpected") + err = v.Set("1unexpected") 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("2: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()) @@ -1098,13 +1098,13 @@ func TestUint8BoolMapValue(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("4:true") assert.Nil(t, err) - err = v.Set("7false") + 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("3: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("2unexpected") + err = v.Set("3unexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":unexpected") assert.NotNil(t, err) - err = v.Set("7:unexpected") + err = v.Set("0:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("4true") + 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("3:true") + err = v.Set("7:true") assert.Nil(t, err) - err = v.Set("7false") + err = v.Set("6false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("2:false") + err = v.Set("4: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("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("2:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]bool", v.Type()) @@ -1176,17 +1176,17 @@ func TestUint32BoolMapValue(t *testing.T) { v := newUint32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7true") + err = v.Set("6true") 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("3: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("2:false") + err = v.Set("4:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]bool", v.Type()) @@ -1198,11 +1198,11 @@ func TestUint32BoolMapValue(t *testing.T) { v := newUint32BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5unexpected") + 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[uint32]bool", v.Type()) @@ -1217,17 +1217,17 @@ func TestUint64BoolMapValue(t *testing.T) { v := newUint64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:true") assert.Nil(t, err) - err = v.Set("5false") + err = v.Set("0false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("2:false") + err = v.Set("1:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]bool", v.Type()) @@ -1239,11 +1239,11 @@ func TestUint64BoolMapValue(t *testing.T) { v := newUint64BoolMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6unexpected") + err = v.Set("1unexpected") 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[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("cXzqA10") + err = v.Set("enuzv10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("dAAYD:10") + err = v.Set("rFKbo:10") assert.Nil(t, err) - err = v.Set("mXjHe20") + err = v.Set("biQMq20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nYdcp:20") + err = v.Set("SDfoO: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("XdMyj-1") + err = v.Set("qwrmY-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("wqwmy:-1") + err = v.Set("lrHNu:-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("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("0: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("3:20") + err = v.Set("1: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("2-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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]uint", v.Type()) @@ -1525,11 +1525,11 @@ func TestInt8UintMapValue(t *testing.T) { v := newInt8UintMapValue(&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("1:10") + err = v.Set("3:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -1547,7 +1547,7 @@ func TestInt8UintMapValue(t *testing.T) { v := newInt8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -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("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("3:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("1: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("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("0:-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[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("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("5:10") + err = v.Set("6: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("3:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint", v.Type()) @@ -1633,7 +1633,7 @@ func TestInt32UintMapValue(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[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("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("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("6:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint", v.Type()) @@ -1670,7 +1670,7 @@ func TestInt64UintMapValue(t *testing.T) { v := newInt64UintMapValue(&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) @@ -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("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("7: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("6:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint", v.Type()) @@ -1711,7 +1711,7 @@ func TestUintUintMapValue(t *testing.T) { v := newUintUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -1734,13 +1734,13 @@ func TestUint8UintMapValue(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("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("3:20") + err = v.Set("2: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("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("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[uint8]uint", v.Type()) @@ -1771,17 +1771,17 @@ func TestUint16UintMapValue(t *testing.T) { v := newUint16UintMapValue(&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("6:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint", v.Type()) @@ -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("6-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[uint16]uint", v.Type()) @@ -1812,17 +1812,17 @@ func TestUint32UintMapValue(t *testing.T) { v := newUint32UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("1: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) - err = v.Set("7:20") + err = v.Set("1: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("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("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[uint32]uint", v.Type()) @@ -1857,13 +1857,13 @@ func TestUint64UintMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("4: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("5:20") + err = v.Set("2: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("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("qvjbJ10") + err = v.Set("qxbQs10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("dbsYg:10") + err = v.Set("FgeYF:10") assert.Nil(t, err) - err = v.Set("UcWrd20") + err = v.Set("tkokN20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("iTbhy:20") + err = v.Set("Yxcii: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("HSMJr-1") + err = v.Set("UUpXP-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("yWXCo:-1") + err = v.Set("rDddw:-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()) @@ -2124,13 +2124,13 @@ func TestIntUint8MapValue(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("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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint8", v.Type()) @@ -2142,11 +2142,11 @@ func TestIntUint8MapValue(t *testing.T) { v := newIntUint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("5:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint8", v.Type()) @@ -2161,17 +2161,17 @@ func TestInt8Uint8MapValue(t *testing.T) { v := newInt8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("6:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint8", v.Type()) @@ -2183,11 +2183,11 @@ func TestInt8Uint8MapValue(t *testing.T) { v := newInt8Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("0:-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("610") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("2: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("0:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint8", v.Type()) @@ -2224,11 +2224,11 @@ func TestInt16Uint8MapValue(t *testing.T) { v := newInt16Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("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("3:-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,17 +2243,17 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&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("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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint8", v.Type()) @@ -2265,11 +2265,11 @@ func TestInt32Uint8MapValue(t *testing.T) { v := newInt32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0-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("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint8", v.Type()) @@ -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("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("6:10") + err = v.Set("2: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("3:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint8", v.Type()) @@ -2306,11 +2306,11 @@ func TestInt64Uint8MapValue(t *testing.T) { v := newInt64Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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]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("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("1:10") + err = v.Set("3:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint8", v.Type()) @@ -2351,7 +2351,7 @@ func TestUintUint8MapValue(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("7:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]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("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("5: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("2: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("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("3:-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("710") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("6: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("2:20") + err = v.Set("7: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("7-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("6:10") + err = v.Set("1: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("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint8", v.Type()) @@ -2470,11 +2470,11 @@ func TestUint32Uint8MapValue(t *testing.T) { v := newUint32Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-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[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("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("2:10") + err = v.Set("3: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("2:20") + err = v.Set("5: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("4-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]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("FeZNk10") + err = v.Set("cCMEf10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Pzulp:10") + err = v.Set("MINCC:10") assert.Nil(t, err) - err = v.Set("RoFAk20") + err = v.Set("Unuhm20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ncRYi:20") + err = v.Set("gHNjr: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("kThJl-1") + err = v.Set("QpOWW-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("lPyBp:-1") + err = v.Set("NKglz:-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("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("2:10") + err = v.Set("1: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("4:20") + err = v.Set("7: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("0-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[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("410") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("2:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint16", v.Type()) @@ -2819,11 +2819,11 @@ func TestInt8Uint16MapValue(t *testing.T) { v := newInt8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("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("2:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint16", v.Type()) @@ -2838,17 +2838,17 @@ func TestInt16Uint16MapValue(t *testing.T) { v := newInt16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint16", v.Type()) @@ -2860,11 +2860,11 @@ func TestInt16Uint16MapValue(t *testing.T) { v := newInt16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("2:-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("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("4:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("0: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("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("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[int32]uint16", v.Type()) @@ -2924,13 +2924,13 @@ func TestInt64Uint16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint16", v.Type()) @@ -2942,11 +2942,11 @@ func TestInt64Uint16MapValue(t *testing.T) { v := newInt64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("6:-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,7 +2961,7 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&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) @@ -2983,11 +2983,11 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[uint]uint16", v.Type()) @@ -3002,17 +3002,17 @@ func TestUint8Uint16MapValue(t *testing.T) { v := newUint8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2: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("6:20") + err = v.Set("7: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("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("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[uint8]uint16", v.Type()) @@ -3043,17 +3043,17 @@ func TestUint16Uint16MapValue(t *testing.T) { v := newUint16Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) err = v.Set("7:10") 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("2:20") + err = v.Set("5: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("2-1") + err = v.Set("7-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("1:-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[uint16]uint16", v.Type()) @@ -3088,9 +3088,9 @@ func TestUint32Uint16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("1: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) @@ -3106,11 +3106,11 @@ func TestUint32Uint16MapValue(t *testing.T) { v := newUint32Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("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("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint16", v.Type()) @@ -3125,13 +3125,13 @@ func TestUint64Uint16MapValue(t *testing.T) { v := newUint64Uint16MapValue(&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("0: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) @@ -3147,11 +3147,11 @@ func TestUint64Uint16MapValue(t *testing.T) { v := newUint64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("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("5:-1") + err = v.Set("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("JKzWs10") + err = v.Set("EVXYF10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("MAaOa:10") + err = v.Set("JjvfF:10") assert.Nil(t, err) - err = v.Set("jVzBM20") + err = v.Set("mwoJb20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gkUOu:20") + err = v.Set("ZFZqU: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("jfkcl-1") + err = v.Set("CZutW-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("pwkZk:-1") + err = v.Set("OWbBF:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint32", v.Type()) @@ -3392,17 +3392,17 @@ func TestIntUint32MapValue(t *testing.T) { v := newIntUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("1: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("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint32", v.Type()) @@ -3414,11 +3414,11 @@ func TestIntUint32MapValue(t *testing.T) { v := newIntUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("710") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("6: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("5:20") + err = v.Set("4: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("2-1") + err = v.Set("5-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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]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("410") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("5: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("0:20") + err = v.Set("5: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("0-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("7:-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[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("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("7:10") + err = v.Set("5: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("7:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint32", v.Type()) @@ -3537,7 +3537,7 @@ func TestInt32Uint32MapValue(t *testing.T) { v := newInt32Uint32MapValue(&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) @@ -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("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("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("3:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint32", v.Type()) @@ -3578,7 +3578,7 @@ func TestInt64Uint32MapValue(t *testing.T) { v := newInt64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -3601,13 +3601,13 @@ func TestUintUint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + 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("5:20") + err = v.Set("2: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("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("7:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3638,13 +3638,13 @@ func TestUint8Uint32MapValue(t *testing.T) { v := newUint8Uint32MapValue(&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("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) @@ -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("5-1") + err = v.Set("6-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint32", v.Type()) @@ -3679,13 +3679,13 @@ func TestUint16Uint32MapValue(t *testing.T) { v := newUint16Uint32MapValue(&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("4:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("5-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("010") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("1: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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint32", v.Type()) @@ -3742,7 +3742,7 @@ func TestUint32Uint32MapValue(t *testing.T) { v := newUint32Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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) @@ -3761,17 +3761,17 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("1: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("5:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint32", v.Type()) @@ -3783,11 +3783,11 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("PnSQV10") + err = v.Set("cfnSM10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ZxrgG:10") + err = v.Set("JNMZa:10") assert.Nil(t, err) - err = v.Set("HqwhS20") + err = v.Set("siCln20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mSUsY:20") + err = v.Set("bAmgS: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("ljxHR-1") + err = v.Set("EbeZl-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("VoBzJ:-1") + err = v.Set("sziRO:-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("310") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("1:10") assert.Nil(t, err) err = v.Set("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("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint64", v.Type()) @@ -4054,7 +4054,7 @@ func TestIntUint64MapValue(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("3:-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()) @@ -4075,11 +4075,11 @@ func TestInt8Uint64MapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint64", v.Type()) @@ -4091,7 +4091,7 @@ func TestInt8Uint64MapValue(t *testing.T) { v := newInt8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -4110,17 +4110,17 @@ func TestInt16Uint64MapValue(t *testing.T) { v := newInt16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("510") 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("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("1:20") + err = v.Set("5: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("4-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("2:-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("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("5: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("4:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint64", v.Type()) @@ -4177,7 +4177,7 @@ func TestInt32Uint64MapValue(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("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint64", v.Type()) @@ -4192,17 +4192,17 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&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("6:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]uint64", v.Type()) @@ -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("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("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[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("610") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("320") + 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("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint64", v.Type()) @@ -4255,11 +4255,11 @@ func TestUintUint64MapValue(t *testing.T) { v := newUintUint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("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("6:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint64", v.Type()) @@ -4274,17 +4274,17 @@ func TestUint8Uint64MapValue(t *testing.T) { v := newUint8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4:10") + err = v.Set("3: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("6:20") + err = v.Set("7: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("2-1") + err = v.Set("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("7:-1") + err = v.Set("1:-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,13 +4315,13 @@ func TestUint16Uint64MapValue(t *testing.T) { v := newUint16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("1: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) @@ -4337,11 +4337,11 @@ func TestUint16Uint64MapValue(t *testing.T) { v := newUint16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[uint16]uint64", v.Type()) @@ -4356,13 +4356,13 @@ func TestUint32Uint64MapValue(t *testing.T) { v := newUint32Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("7: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) @@ -4378,11 +4378,11 @@ func TestUint32Uint64MapValue(t *testing.T) { v := newUint32Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("2:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint64", v.Type()) @@ -4397,17 +4397,17 @@ func TestUint64Uint64MapValue(t *testing.T) { v := newUint64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]uint64", v.Type()) @@ -4419,11 +4419,11 @@ func TestUint64Uint64MapValue(t *testing.T) { v := newUint64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("XggYD10") + err = v.Set("dekJz10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Ggcme:10") + err = v.Set("gGrVM:10") assert.Nil(t, err) - err = v.Set("dpYJD20") + err = v.Set("IWaYa20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("vdRFU:20") + err = v.Set("oFGzL: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("gDmePa") + err = v.Set("PIiQna") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("uKxBv:a") + err = v.Set("nrFzc: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("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("3:10") + err = v.Set("2: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) - err = v.Set("4:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4726,11 +4726,11 @@ func TestIntIntMapValue(t *testing.T) { v := newIntIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("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("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4745,17 +4745,17 @@ func TestInt8IntMapValue(t *testing.T) { v := newInt8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("5:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0: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("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("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[int8]int", v.Type()) @@ -4786,17 +4786,17 @@ func TestInt16IntMapValue(t *testing.T) { v := newInt16IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("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("2: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("5:20") + err = v.Set("4: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("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("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[int16]int", v.Type()) @@ -4827,17 +4827,17 @@ func TestInt32IntMapValue(t *testing.T) { v := newInt32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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("7:20") + err = v.Set("4: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("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("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[int32]int", v.Type()) @@ -4868,17 +4868,17 @@ func TestInt64IntMapValue(t *testing.T) { v := newInt64IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510") + err = v.Set("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") 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("1:20") + err = v.Set("3: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("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("7:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]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("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("2:10") + err = v.Set("1: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("0:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int", v.Type()) @@ -4931,11 +4931,11 @@ func TestUintIntMapValue(t *testing.T) { v := newUintIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[uint]int", v.Type()) @@ -4954,13 +4954,13 @@ func TestUint8IntMapValue(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("4: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("0: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("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("6: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[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("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("2: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) - err = v.Set("4:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int", v.Type()) @@ -5013,11 +5013,11 @@ func TestUint16IntMapValue(t *testing.T) { v := newUint16IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int", v.Type()) @@ -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("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int", v.Type()) @@ -5054,11 +5054,11 @@ func TestUint32IntMapValue(t *testing.T) { v := newUint32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("1:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int", v.Type()) @@ -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("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("5:10") + err = v.Set("4:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") 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[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("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("6:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("fHngP10") + err = v.Set("JCDsl10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kuflq:10") + err = v.Set("OMKzb:10") assert.Nil(t, err) - err = v.Set("lBMHM20") + err = v.Set("nnPAH20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("xERna:20") + err = v.Set("qHaxF: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("FKPNMa") + err = v.Set("zpuHGa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kmNKD:a") + err = v.Set("nQdDX: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("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("3:10") + err = v.Set("4:10") assert.Nil(t, err) err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int8", v.Type()) @@ -5372,7 +5372,7 @@ func TestIntInt8MapValue(t *testing.T) { v := newIntInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -5391,11 +5391,11 @@ func TestInt8Int8MapValue(t *testing.T) { v := newInt8Int8MapValue(&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("5:10") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -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("7a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("510") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("7: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("1:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int8", v.Type()) @@ -5454,11 +5454,11 @@ func TestInt16Int8MapValue(t *testing.T) { v := newInt16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int8", v.Type()) @@ -5473,17 +5473,17 @@ func TestInt32Int8MapValue(t *testing.T) { v := newInt32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("0:10") + err = v.Set("1: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("1:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int8", v.Type()) @@ -5495,11 +5495,11 @@ func TestInt32Int8MapValue(t *testing.T) { v := newInt32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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) - err = v.Set("7: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[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("510") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("620") + 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("3:20") + err = v.Set("1: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("0a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int8", v.Type()) @@ -5555,11 +5555,11 @@ func TestUintInt8MapValue(t *testing.T) { v := newUintInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("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("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -5577,11 +5577,11 @@ func TestUintInt8MapValue(t *testing.T) { v := newUintInt8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[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("110") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int8", v.Type()) @@ -5618,11 +5618,11 @@ func TestUint8Int8MapValue(t *testing.T) { v := newUint8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int8", v.Type()) @@ -5637,17 +5637,17 @@ func TestUint16Int8MapValue(t *testing.T) { v := newUint16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("710") + err = v.Set("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") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("0: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("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("7: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]int8", v.Type()) @@ -5678,13 +5678,13 @@ func TestUint32Int8MapValue(t *testing.T) { v := newUint32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + 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("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) @@ -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("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("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int8", v.Type()) @@ -5719,17 +5719,17 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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("3:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int8", v.Type()) @@ -5741,11 +5741,11 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.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("RupnA10") + err = v.Set("DjljB10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("WYsPG:10") + err = v.Set("TVMGd:10") assert.Nil(t, err) - err = v.Set("BjUIw20") + err = v.Set("lGQiL20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("oiKEV:20") + err = v.Set("OjHTD: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("XtNUQa") + err = v.Set("JUkAGa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XkyFq:a") + err = v.Set("LHQTT: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("310") + err = v.Set("510") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("5: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("0: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("1a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int16", v.Type()) @@ -6037,17 +6037,17 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("5:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int16", v.Type()) @@ -6059,11 +6059,11 @@ func TestInt8Int16MapValue(t *testing.T) { v := newInt8Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("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("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int16", v.Type()) @@ -6078,17 +6078,17 @@ func TestInt16Int16MapValue(t *testing.T) { v := newInt16Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("7:10") assert.Nil(t, err) err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("5: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("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("1: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()) @@ -6119,17 +6119,17 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("6:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int16", v.Type()) @@ -6141,11 +6141,11 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("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.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("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("4:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int16", v.Type()) @@ -6182,11 +6182,11 @@ func TestInt64Int16MapValue(t *testing.T) { v := newInt64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[int64]int16", v.Type()) @@ -6201,17 +6201,17 @@ func TestUintInt16MapValue(t *testing.T) { v := newUintInt16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("320") + 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("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int16", v.Type()) @@ -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("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("2: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("7:20") + err = v.Set("5: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("5a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("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("0:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("320") + 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("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int16", v.Type()) @@ -6305,7 +6305,7 @@ func TestUint16Int16MapValue(t *testing.T) { v := newUint16Int16MapValue(&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) @@ -6328,13 +6328,13 @@ func TestUint32Int16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("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("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6346,11 +6346,11 @@ func TestUint32Int16MapValue(t *testing.T) { v := newUint32Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int16", v.Type()) @@ -6365,13 +6365,13 @@ func TestUint64Int16MapValue(t *testing.T) { v := newUint64Int16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6: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) @@ -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("5a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("ggUNP10") + err = v.Set("xnutA10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("PnhvL:10") + err = v.Set("WCqYP:10") assert.Nil(t, err) - err = v.Set("YnGqd20") + err = v.Set("JSElL20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("yUqin:20") + err = v.Set("uldGZ: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("whQwja") + err = v.Set("nNtMta") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("hMHqT:a") + err = v.Set("gLxNq: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("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("3:10") + err = v.Set("5: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("1:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int32", v.Type()) @@ -6664,11 +6664,11 @@ func TestIntInt32MapValue(t *testing.T) { v := newIntInt32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[int]int32", v.Type()) @@ -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("0:10") + err = v.Set("5: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("0:20") + err = v.Set("1: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("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("4: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]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("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("4:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("1a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("3: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("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("0:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("6: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("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("3: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()) @@ -6810,13 +6810,13 @@ func TestInt64Int32MapValue(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("720") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("4: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("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("0: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("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("5:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("1: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("6a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -6892,13 +6892,13 @@ func TestUint8Int32MapValue(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("2: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("5:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6910,11 +6910,11 @@ func TestUint8Int32MapValue(t *testing.T) { v := newUint8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int32", v.Type()) @@ -6929,17 +6929,17 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("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("1:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]int32", v.Type()) @@ -6951,11 +6951,11 @@ func TestUint16Int32MapValue(t *testing.T) { v := newUint16Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4: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[uint16]int32", v.Type()) @@ -6970,17 +6970,17 @@ func TestUint32Int32MapValue(t *testing.T) { v := newUint32Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("7: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("5:20") + err = v.Set("3: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("7a") + 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("2:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("1: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("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int32", v.Type()) @@ -7033,11 +7033,11 @@ func TestUint64Int32MapValue(t *testing.T) { v := newUint64Int32MapValue(&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("3:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int32", v.Type()) @@ -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("LOWwK10") + err = v.Set("UUWUt10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Amyih:10") + err = v.Set("FbmhA:10") assert.Nil(t, err) - err = v.Set("hojtM20") + err = v.Set("RcqTB20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("RYdwp:20") + err = v.Set("ZoFto: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("LTTISa") + err = v.Set("duzbya") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("EODEu:a") + err = v.Set("XkuLv:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int64", v.Type()) @@ -7288,17 +7288,17 @@ func TestIntInt64MapValue(t *testing.T) { v := newIntInt64MapValue(&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("6:10") + err = v.Set("0: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("0:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int64", v.Type()) @@ -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("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("3:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int64", v.Type()) @@ -7329,17 +7329,17 @@ func TestInt8Int64MapValue(t *testing.T) { v := newInt8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int64", v.Type()) @@ -7351,7 +7351,7 @@ func TestInt8Int64MapValue(t *testing.T) { v := newInt8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("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("6: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("5: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("5a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("1: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("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("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) - err = v.Set("1:20") + err = v.Set("0: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("6a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]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("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("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("5:20") + err = v.Set("1: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("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("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int64", v.Type()) @@ -7493,17 +7493,17 @@ func TestUintInt64MapValue(t *testing.T) { v := newUintInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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") 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("1:20") + err = v.Set("5: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("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int64", v.Type()) @@ -7534,17 +7534,17 @@ func TestUint8Int64MapValue(t *testing.T) { v := newUint8Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("0: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("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("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[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("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("7:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("0: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("1a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - 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[uint16]int64", v.Type()) @@ -7616,17 +7616,17 @@ func TestUint32Int64MapValue(t *testing.T) { v := newUint32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4:10") + err = v.Set("7: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("5:20") + err = v.Set("2: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("0a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("6: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("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("2:10") + err = v.Set("0: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("0: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("2a") + 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("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int64", v.Type()) @@ -7879,13 +7879,13 @@ func TestStringFloat64MapValue(t *testing.T) { v := newStringFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("DfQff10.2") + err = v.Set("FejRb10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("IMUVc:10.2") + err = v.Set("IFhMx:10.2") assert.Nil(t, err) - err = v.Set("yNswP20.99") + err = v.Set("BXidS20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LIHQg:20.99") + err = v.Set("xVHOg: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("zKMmma") + err = v.Set("RuExea") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XhTRg:a") + err = v.Set("TnyDK: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("610.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("1:10.2") + err = v.Set("5: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("0:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]float64", v.Type()) @@ -7936,11 +7936,11 @@ func TestIntFloat64MapValue(t *testing.T) { v := newIntFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[int]float64", v.Type()) @@ -7955,17 +7955,17 @@ func TestInt8Float64MapValue(t *testing.T) { v := newInt8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.2") + err = v.Set("410.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("1: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) - 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[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("6a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5: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[int8]float64", v.Type()) @@ -7996,17 +7996,17 @@ func TestInt16Float64MapValue(t *testing.T) { v := newInt16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010.2") + err = v.Set("510.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("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("3:20.99") + err = v.Set("7:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]float64", v.Type()) @@ -8018,11 +8018,11 @@ func TestInt16Float64MapValue(t *testing.T) { v := newInt16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("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("0: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("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("0:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("4:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float64", v.Type()) @@ -8059,11 +8059,11 @@ func TestInt32Float64MapValue(t *testing.T) { v := newInt32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]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("610.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("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("5:20.99") + err = v.Set("7: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("5a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]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("310.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("4:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("220.99") + err = v.Set("520.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("5:20.99") + err = v.Set("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]float64", v.Type()) @@ -8141,11 +8141,11 @@ func TestUintFloat64MapValue(t *testing.T) { v := newUintFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[uint]float64", v.Type()) @@ -8164,13 +8164,13 @@ func TestUint8Float64MapValue(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("7:10.2") assert.Nil(t, err) - err = v.Set("620.99") + err = v.Set("720.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("5:20.99") + err = v.Set("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float64", v.Type()) @@ -8186,7 +8186,7 @@ func TestUint8Float64MapValue(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("7: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("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") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("220.99") + err = v.Set("120.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("5:20.99") + err = v.Set("0: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("2a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("6:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]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("010.2") + err = v.Set("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("0:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("320.99") + err = v.Set("220.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("4: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("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("4:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float64", v.Type()) @@ -8283,13 +8283,13 @@ func TestUint64Float64MapValue(t *testing.T) { v := newUint64Float64MapValue(&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("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) @@ -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("7a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("7:a") + err = v.Set("5: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("ZixsM10.2") + err = v.Set("wXrlb10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("rzbDB:10.2") + err = v.Set("IMxdl:10.2") assert.Nil(t, err) - err = v.Set("XNUkY20.99") + err = v.Set("hTYoj20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("xXXOh:20.99") + err = v.Set("LmOXw: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("KIxEEa") + err = v.Set("srEnPa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kCglT:a") + err = v.Set("vwhRx: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("310.2") + err = v.Set("010.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("1:10.2") + err = v.Set("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("1:20.99") + err = v.Set("2: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("2a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("210.2") + err = v.Set("410.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("3:10.2") assert.Nil(t, err) - err = v.Set("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("7:20.99") + err = v.Set("5:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float32", v.Type()) @@ -8603,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("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("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[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("310.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("6:10.2") + err = v.Set("7: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("6:20.99") + err = v.Set("4: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("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("7: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[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("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("5:10.2") + err = v.Set("7:10.2") assert.Nil(t, err) - err = v.Set("320.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("0:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float32", v.Type()) @@ -8685,7 +8685,7 @@ func TestInt32Float32MapValue(t *testing.T) { v := newInt32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("710.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("6:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("720.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("6:20.99") + err = v.Set("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]float32", v.Type()) @@ -8726,11 +8726,11 @@ func TestInt64Float32MapValue(t *testing.T) { v := newInt64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6a") + err = v.Set("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("3: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("110.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("2:10.2") + err = v.Set("0: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("2:20.99") + err = v.Set("3: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("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("0: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[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("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("5:10.2") + err = v.Set("4:10.2") assert.Nil(t, err) - err = v.Set("120.99") + err = v.Set("520.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("7:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8808,7 +8808,7 @@ func TestUint8Float32MapValue(t *testing.T) { v := newUint8Float32MapValue(&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) @@ -8827,17 +8827,17 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.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("2:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("220.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("2:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]float32", v.Type()) @@ -8853,7 +8853,7 @@ func TestUint16Float32MapValue(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("3: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("410.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("6:10.2") + err = v.Set("3:10.2") assert.Nil(t, err) - err = v.Set("120.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("0:20.99") + err = v.Set("7: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("6a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1: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[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("410.2") + err = v.Set("010.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("3:10.2") + err = v.Set("4: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("6:20.99") + err = v.Set("3: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("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) - 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[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("NjUZE10s") + err = v.Set("EnGJV10s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Jbnpq:10s") + err = v.Set("hDPTi:10s") assert.Nil(t, err) - err = v.Set("lFyfn30m") + err = v.Set("HMyyo30m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("NpXtF:30m") + err = v.Set("YLaeV: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("mWFjq3l") + err = v.Set("uuEpn3l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("iUceL:3l") + err = v.Set("AMlnf: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("110s") + 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("3:10s") + err = v.Set("1:10s") assert.Nil(t, err) - err = v.Set("730m") + 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("7:30m") + err = v.Set("3: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("63l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("3: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[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("510s") + err = v.Set("110s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("0:10s") + err = v.Set("7:10s") assert.Nil(t, err) err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("4:30m") + err = v.Set("3: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("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("2: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[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("210s") + err = v.Set("610s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("5:10s") + err = v.Set("3:10s") assert.Nil(t, err) - err = v.Set("530m") + 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("7: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("13l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("7: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[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("310s") + 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("3:10s") + err = v.Set("6: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("5:30m") + err = v.Set("6:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]time.Duration", v.Type()) @@ -9301,11 +9301,11 @@ func TestInt32DurationMapValue(t *testing.T) { v := newInt32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("63l") + 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("0: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[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("010s") + err = v.Set("510s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("7:10s") + err = v.Set("6:10s") assert.Nil(t, err) - err = v.Set("730m") + 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("5:30m") + err = v.Set("1: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("43l") + err = v.Set("73l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("1:3l") + 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[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("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("2:10s") + err = v.Set("0:10s") assert.Nil(t, err) err = v.Set("230m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("4:30m") + err = v.Set("0: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("73l") + err = v.Set("23l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("5: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[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("410s") + err = v.Set("510s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("7:10s") + err = v.Set("1:10s") assert.Nil(t, err) - err = v.Set("430m") + 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("5:30m") + err = v.Set("0:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]time.Duration", v.Type()) @@ -9424,7 +9424,7 @@ func TestUint8DurationMapValue(t *testing.T) { v := newUint8DurationMapValue(&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) @@ -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("210s") + err = v.Set("010s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) - err = v.Set("3:10s") + err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("130m") + err = v.Set("030m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("0:30m") + err = v.Set("6:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("23l") + 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("2: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()) @@ -9488,9 +9488,9 @@ func TestUint32DurationMapValue(t *testing.T) { 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("6:10s") assert.Nil(t, err) - err = v.Set("130m") + err = v.Set("430m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) @@ -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("03l") + 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("2: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[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("210s") + 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("2:10s") + err = v.Set("0: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("2:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]time.Duration", v.Type()) @@ -9551,7 +9551,7 @@ func TestUint64DurationMapValue(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("5: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[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("OFOqq127.0.0.1") + err = v.Set("ptmQh127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("dYklF:127.0.0.1") + err = v.Set("agKCM:127.0.0.1") assert.Nil(t, err) - err = v.Set("JFoAd127.0.0.3") + err = v.Set("lyuxY127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("kLdLG:127.0.0.3") + err = v.Set("vapzk: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("CDTPJ127.0.0.1.3") + err = v.Set("yYhXZ127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("zGNum:127.0.0.1.3") + err = v.Set("LTfLc: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("4:127.0.0.1") + err = v.Set("0:127.0.0.1") assert.Nil(t, err) 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("3:127.0.0.3") + err = v.Set("2:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("7127.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("6:127.0.0.1.3") + err = v.Set("3:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("7127.0.0.1") + err = v.Set("0127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("3:127.0.0.1") + err = v.Set("6:127.0.0.1") assert.Nil(t, err) - err = v.Set("1127.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("0: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[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("5127.0.0.1.3") + err = v.Set("1127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("5:127.0.0.1.3") + err = v.Set("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[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("2127.0.0.1") + err = v.Set("5127.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("4:127.0.0.1") assert.Nil(t, err) - err = v.Set("4127.0.0.3") + err = v.Set("2127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("3:127.0.0.3") + err = v.Set("7:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IP", v.Type()) @@ -9876,11 +9876,11 @@ func TestInt16IPMapValue(t *testing.T) { v := newInt16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2127.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("0:127.0.0.1.3") + err = v.Set("3:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IP", v.Type()) @@ -9895,13 +9895,13 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5127.0.0.1") + err = v.Set("7127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) err = v.Set("3: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) @@ -9917,11 +9917,11 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3127.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("7: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[int32]net.IP", v.Type()) @@ -9936,17 +9936,17 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5127.0.0.1") + err = v.Set("1127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("7:127.0.0.1") + err = v.Set("1:127.0.0.1") assert.Nil(t, err) - err = v.Set("1127.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("5:127.0.0.3") + err = v.Set("4:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IP", v.Type()) @@ -9958,11 +9958,11 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3127.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("1: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[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("0127.0.0.1") + err = v.Set("6127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("4:127.0.0.1") + err = v.Set("5:127.0.0.1") assert.Nil(t, err) 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("2: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[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("0127.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("4: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[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("4127.0.0.1") + err = v.Set("5127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1") + err = v.Set("0:127.0.0.1") assert.Nil(t, err) - err = v.Set("3127.0.0.3") + err = v.Set("0127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("0: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[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("3127.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("0:127.0.0.1.3") + err = v.Set("3:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("4127.0.0.1") + err = v.Set("2127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1") + err = v.Set("1:127.0.0.1") assert.Nil(t, err) - err = v.Set("6127.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("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[uint16]net.IP", v.Type()) @@ -10081,7 +10081,7 @@ func TestUint16IPMapValue(t *testing.T) { v := newUint16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4127.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) @@ -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("1:127.0.0.1") + err = v.Set("5:127.0.0.1") assert.Nil(t, err) - err = v.Set("4127.0.0.3") + err = v.Set("2127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("3: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[uint32]net.IP", v.Type()) @@ -10122,7 +10122,7 @@ func TestUint32IPMapValue(t *testing.T) { v := newUint32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3127.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) @@ -10141,17 +10141,17 @@ func TestUint64IPMapValue(t *testing.T) { v := newUint64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1") + err = v.Set("0127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("3:127.0.0.1") + err = v.Set("4:127.0.0.1") assert.Nil(t, err) - err = v.Set("0127.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("6: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[uint64]net.IP", v.Type()) @@ -10167,7 +10167,7 @@ func TestUint64IPMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("4:127.0.0.1.3") + err = v.Set("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[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("EQwESff") + err = v.Set("UWQpwff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("haVbX:ff") + err = v.Set("KViVe:ff") assert.Nil(t, err) - err = v.Set("NNjdyaa") + err = v.Set("PoqYuaa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Lsbaa:aa") + err = v.Set("bqHHM: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("qyNPggg") + err = v.Set("CQsMtgg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("eVhTs:gg") + err = v.Set("wdJPZ: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()) @@ -10414,11 +10414,11 @@ func TestIntHexBytesMapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("0aa") + 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("4:aa") + err = v.Set("1:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]HexBytes", v.Type()) @@ -10434,7 +10434,7 @@ func TestIntHexBytesMapValue(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("3: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()) @@ -10453,13 +10453,13 @@ func TestInt8HexBytesMapValue(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("1:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("3aa") + 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("7:aa") + err = v.Set("0: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("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("7:gg") + err = v.Set("6:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("1ff") + err = v.Set("6ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) err = v.Set("0:ff") assert.Nil(t, err) - err = v.Set("6aa") + err = v.Set("4aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("0:aa") + err = v.Set("6:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]HexBytes", v.Type()) @@ -10512,7 +10512,7 @@ func TestInt16HexBytesMapValue(t *testing.T) { v := newInt16HexBytesMapValue(&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) @@ -10531,7 +10531,7 @@ func TestInt32HexBytesMapValue(t *testing.T) { v := newInt32HexBytesMapValue(&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) @@ -10541,7 +10541,7 @@ func TestInt32HexBytesMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("1:aa") + err = v.Set("2:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]HexBytes", v.Type()) @@ -10553,11 +10553,11 @@ func TestInt32HexBytesMapValue(t *testing.T) { v := newInt32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7gg") + err = v.Set("0gg") 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("3: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,17 +10572,17 @@ func TestInt64HexBytesMapValue(t *testing.T) { v := newInt64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6ff") + err = v.Set("2ff") 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") assert.Nil(t, err) - err = v.Set("2aa") + err = v.Set("4aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("3:aa") + err = v.Set("6:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]HexBytes", v.Type()) @@ -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("3gg") + 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("0:gg") + err = v.Set("6:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("2:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("5aa") + err = v.Set("1aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("4:aa") + err = v.Set("3: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("3gg") + 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("1: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("3ff") + err = v.Set("7ff") 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") assert.Nil(t, err) - err = v.Set("1aa") + 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("3:aa") + err = v.Set("4:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]HexBytes", v.Type()) @@ -10676,7 +10676,7 @@ func TestUint8HexBytesMapValue(t *testing.T) { v := newUint8HexBytesMapValue(&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) @@ -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("5ff") + err = v.Set("2ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("5:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("5aa") + err = v.Set("0aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("1:aa") + err = v.Set("2: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("4gg") + err = v.Set("2gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("3:gg") + err = v.Set("1:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("1ff") + err = v.Set("2ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("6:ff") + err = v.Set("1:ff") assert.Nil(t, err) - err = v.Set("7aa") + err = v.Set("6aa") 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("6:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]HexBytes", v.Type()) @@ -10758,11 +10758,11 @@ func TestUint32HexBytesMapValue(t *testing.T) { v := newUint32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4gg") + err = v.Set("3gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("0:gg") + err = v.Set("4:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]HexBytes", v.Type()) @@ -10777,17 +10777,17 @@ func TestUint64HexBytesMapValue(t *testing.T) { v := newUint64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0ff") + err = v.Set("2ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("3:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("3aa") + err = v.Set("4aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("5:aa") + err = v.Set("2: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("7gg") + err = v.Set("6gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("1: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[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("ETnIjabc.*") + err = v.Set("vTUctabc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XGPPa:abc.*") + err = v.Set("SyjSF:abc.*") assert.Nil(t, err) - err = v.Set("LlWUMxyz.*") + err = v.Set("MHwDCxyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("rZdGR:xyz.*") + err = v.Set("JOyAs: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("GJtWY[abc") + err = v.Set("wVJjb[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LCRop:[abc") + err = v.Set("UVukK:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]*regexp.Regexp", v.Type()) @@ -11024,17 +11024,17 @@ func TestIntRegexpMapValue(t *testing.T) { v := newIntRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0abc.*") + err = v.Set("4abc.*") 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("7:abc.*") assert.Nil(t, err) - err = v.Set("4xyz.*") + 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("5:xyz.*") + err = v.Set("1:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]*regexp.Regexp", v.Type()) @@ -11046,7 +11046,7 @@ func TestIntRegexpMapValue(t *testing.T) { v := newIntRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6[abc") + err = v.Set("3[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) @@ -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("2abc.*") + err = v.Set("4abc.*") 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("0xyz.*") + 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("0:xyz.*") + err = v.Set("4: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("5[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("1:[abc") + err = v.Set("6:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]*regexp.Regexp", v.Type()) @@ -11106,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("4abc.*") + err = v.Set("7abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("4:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) err = v.Set("3xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("0:xyz.*") + err = v.Set("7:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]*regexp.Regexp", v.Type()) @@ -11128,7 +11128,7 @@ func TestInt16RegexpMapValue(t *testing.T) { v := newInt16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4[abc") + err = v.Set("5[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) @@ -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("7abc.*") + 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.*") assert.Nil(t, err) - err = v.Set("6xyz.*") + err = v.Set("1xyz.*") 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[int32]*regexp.Regexp", v.Type()) @@ -11169,11 +11169,11 @@ func TestInt32RegexpMapValue(t *testing.T) { v := newInt32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1[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("6:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("1:abc.*") + err = v.Set("0:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + 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("0:xyz.*") + err = v.Set("6: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("0[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("2:[abc") + err = v.Set("6:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]*regexp.Regexp", v.Type()) @@ -11229,17 +11229,17 @@ func TestUintRegexpMapValue(t *testing.T) { v := newUintRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3abc.*") + 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("6:abc.*") + err = v.Set("3:abc.*") assert.Nil(t, err) - err = v.Set("6xyz.*") + 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("4:xyz.*") + err = v.Set("6: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("5[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("3:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]*regexp.Regexp", v.Type()) @@ -11270,17 +11270,17 @@ func TestUint8RegexpMapValue(t *testing.T) { v := newUint8RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4abc.*") + 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("2:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + 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("0:xyz.*") + err = v.Set("1: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("2[abc") + err = v.Set("5[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("0:[abc") + err = v.Set("2:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]*regexp.Regexp", v.Type()) @@ -11311,17 +11311,17 @@ func TestUint16RegexpMapValue(t *testing.T) { v := newUint16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3abc.*") + 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("7:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) - err = v.Set("4xyz.*") + err = v.Set("0xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("1:xyz.*") + err = v.Set("6:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]*regexp.Regexp", v.Type()) @@ -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("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("6:[abc") + err = v.Set("7:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("2:abc.*") + err = v.Set("5:abc.*") assert.Nil(t, err) - err = v.Set("7xyz.*") + 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("5:xyz.*") + err = v.Set("1: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("0[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("0:[abc") + err = v.Set("7:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]*regexp.Regexp", v.Type()) @@ -11393,13 +11393,13 @@ func TestUint64RegexpMapValue(t *testing.T) { v := newUint64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7abc.*") + 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("6:abc.*") + err = v.Set("3:abc.*") assert.Nil(t, err) - err = v.Set("2xyz.*") + err = v.Set("0xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -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("6[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("5:[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[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("CZNAw0.0.0.0/0") + err = v.Set("tezIO0.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("eyxsx:0.0.0.0/0") + err = v.Set("ZMfFT:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("VbZJj255.255.255.255/19") + err = v.Set("cfBXK255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("vbMJG:255.255.255.255/19") + err = v.Set("cYNEA: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("xwoJN0.0.0.256/16") + err = v.Set("aFRBj0.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("rTiiB:0.0.0.256/16") + err = v.Set("XuYFj: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()) @@ -11778,11 +11778,11 @@ func TestIntIPNetMapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("4:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("3255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("3:255.255.255.255/19") + err = v.Set("7:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IPNet", v.Type()) @@ -11794,11 +11794,11 @@ func TestIntIPNetMapValue(t *testing.T) { v := newIntIPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.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("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[int]net.IPNet", v.Type()) @@ -11813,13 +11813,13 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("60.0.0.0/0") + err = v.Set("00.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("7:0.0.0.0/0") + err = v.Set("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) @@ -11835,11 +11835,11 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("40.0.0.256/16") + err = v.Set("20.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("3:0.0.0.256/16") + err = v.Set("2: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("10.0.0.0/0") + err = v.Set("60.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("5:0.0.0.0/0") + err = v.Set("3:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.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("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[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("50.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("1:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IPNet", v.Type()) @@ -11895,17 +11895,17 @@ func TestInt32IPNetMapValue(t *testing.T) { v := newInt32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.0/0") + err = v.Set("20.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("0:0.0.0.0/0") + err = v.Set("1:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("4255.255.255.255/19") + err = v.Set("5255.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("4:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IPNet", v.Type()) @@ -11917,11 +11917,11 @@ func TestInt32IPNetMapValue(t *testing.T) { v := newInt32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("20.0.0.256/16") + err = v.Set("50.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("1:0.0.0.256/16") + err = v.Set("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[int32]net.IPNet", v.Type()) @@ -11936,17 +11936,17 @@ func TestInt64IPNetMapValue(t *testing.T) { v := newInt64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("70.0.0.0/0") + err = v.Set("50.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("4:0.0.0.0/0") + err = v.Set("7: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("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[int64]net.IPNet", v.Type()) @@ -11958,7 +11958,7 @@ 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.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) @@ -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("20.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("6:0.0.0.0/0") + err = v.Set("5:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.255.255.255/19") + err = v.Set("5255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("2:255.255.255.255/19") + err = v.Set("5:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("30.0.0.256/16") + err = v.Set("50.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("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[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("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("3:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.255.255.255/19") + err = v.Set("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("6: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[uint8]net.IPNet", v.Type()) @@ -12040,11 +12040,11 @@ func TestUint8IPNetMapValue(t *testing.T) { v := newUint8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("20.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("4: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[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("70.0.0.0/0") + err = v.Set("60.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("2:0.0.0.0/0") + err = v.Set("5:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("3255.255.255.255/19") + err = v.Set("4255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) @@ -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("60.0.0.256/16") + err = v.Set("70.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("2:0.0.0.256/16") + err = v.Set("6:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]net.IPNet", v.Type()) @@ -12100,13 +12100,13 @@ func TestUint32IPNetMapValue(t *testing.T) { v := newUint32IPNetMapValue(&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("5: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("5255.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) @@ -12122,7 +12122,7 @@ func TestUint32IPNetMapValue(t *testing.T) { v := newUint32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("20.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) @@ -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("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("2:0.0.0.0/0") + err = v.Set("3: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("0: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[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("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) - err = v.Set("2: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[uint64]net.IPNet", v.Type()) From 00d335b03fa5cd7c7dcd9418e40d21ffa22ce92c Mon Sep 17 00:00:00 2001 From: Naveen Gogineni Date: Wed, 13 Nov 2024 06:20:26 -0500 Subject: [PATCH 3/5] Update README.md for required field --- README.md | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index f936162..cce0b94 100644 --- a/README.md +++ b/README.md @@ -23,14 +23,13 @@ And you can use your favorite flag or cli library! ## Supported libraries and features: -| | | Hidden | Deprecated | Short | Env | +| | | Hidden | Deprecated | Short | Env | Required | | --- | --- |:------:|:----------:|:-----:|:---:| -|
  • [x] [flag]
      • | [example](./examples/flag/main.go) | `-` | `-` | `-` | `-` | -|
      • [x] [kingpin]
      | [example](./examples/kingpin/main.go) |
      • [x]
      |
      • [ ]
      |
      • [x]
      |
      • [x]
      | -|
      • [x] [spf13/pflag]
      | [example](./examples/pflag/main.go) |
      • [x]
      |
      • [x]
      |
      • [x]
      | `-` | -|
      • [x] [spf13/cobra]
      | [example](./examples/cobra/main.go) |
      • [x]
      |
      • [x]
      |
      • [x]
      | `-` | -|
      • [ ] [spf13/viper]
          • | |
          • [ ]
          |
          • [ ]
          |
          • [ ]
          |
          • [ ]
          | -|
          • [x] [urfave/cli]
          | [example](./examples/urfave_cli/main.go) |
          • [x]
          | `-` |
          • [x]
          |
          • [x]
          | +|
          • [x] [flag]
              • | [example](./examples/flag/main.go) | `-` | `-` | `-` | `-` | `-` | +|
              • [x] [kingpin]
              | [example](./examples/kingpin/main.go) |
              • [x]
              |
              • [ ]
              |
              • [x]
              |
              • [x]
              |
              • [x]
              | +|
              • [x] [spf13/pflag]
              | [example](./examples/pflag/main.go) |
              • [x]
              |
              • [x]
              |
              • [x]
              | `-` | `-` | +|
              • [x] [spf13/cobra]
              | [example](./examples/cobra/main.go) |
              • [x]
              |
              • [x]
              |
              • [x]
              | `-` | `-` | +|
              • [x] [urfave/cli]
              | [example](./examples/urfave_cli/main.go) |
              • [x]
              | `-` |
              • [x]
              |
              • [x]
              |
              • [x]
              | - [x] - feature is supported and implemented From 0d27088f9150c5e003fc9f724c5df7ccded62f72 Mon Sep 17 00:00:00 2001 From: Naveen Gogineni Date: Wed, 13 Nov 2024 06:21:18 -0500 Subject: [PATCH 4/5] Update README.md for required field --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index cce0b94..832a6e4 100644 --- a/README.md +++ b/README.md @@ -49,7 +49,7 @@ And you can use your favorite flag or cli library! - [x] Set usage - [x] Long and short forms - [x] Skip field - - [ ] Required + - [x] Required - [ ] Placeholders (by `name`) - [x] Deprecated and hidden options - [ ] Multiple ENV names From a08093ba705ab4f13e0ef21fa3da80f08500cee2 Mon Sep 17 00:00:00 2001 From: dearchap Date: Wed, 13 Nov 2024 07:28:25 -0500 Subject: [PATCH 5/5] Update README.md Co-authored-by: Eng Zer Jun --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 832a6e4..93d5c05 100644 --- a/README.md +++ b/README.md @@ -24,7 +24,7 @@ And you can use your favorite flag or cli library! ## Supported libraries and features: | | | Hidden | Deprecated | Short | Env | Required | -| --- | --- |:------:|:----------:|:-----:|:---:| +| --- | --- |:------:|:----------:|:-----:|:---:|:--------:| |
              • [x] [flag]
                  • | [example](./examples/flag/main.go) | `-` | `-` | `-` | `-` | `-` | |
                  • [x] [kingpin]
                  | [example](./examples/kingpin/main.go) |
                  • [x]
                  |
                  • [ ]
                  |
                  • [x]
                  |
                  • [x]
                  |
                  • [x]
                  | |
                  • [x] [spf13/pflag]
                  | [example](./examples/pflag/main.go) |
                  • [x]
                  |
                  • [x]
                  |
                  • [x]
                  | `-` | `-` |