From 5150bc6b744f26f2f01e25e6238a25909cd7824f Mon Sep 17 00:00:00 2001 From: Naveen Gogineni Date: Tue, 12 Nov 2024 06:30:36 -0500 Subject: [PATCH] Rename octago to urfave --- README.md | 6 +- examples/anonymous/main.go | 2 +- examples/cobra/main.go | 4 +- examples/flag/main.go | 4 +- examples/kingpin/main.go | 4 +- examples/pflag/main.go | 4 +- examples/simple_flag/main.go | 2 +- examples/urfave_cli/main.go | 4 +- examples/validator/main.go | 6 +- gen/gcli/gcli.go | 2 +- gen/gcli/gcli_test.go | 2 +- gen/gcli/gcliv3.go | 2 +- gen/gcli/gcliv3_test.go | 2 +- gen/gflag/gflag.go | 2 +- gen/gflag/gflag_test.go | 2 +- gen/gkingpin/gkingpin.go | 2 +- gen/gkingpin/gkingpin_test.go | 2 +- gen/gpflag/gpflag.go | 2 +- gen/gpflag/gpflag_test.go | 2 +- go.mod | 2 +- validator/govalidator/govalidator_test.go | 4 +- values_generated_test.go | 2226 ++++++++++----------- 22 files changed, 1144 insertions(+), 1144 deletions(-) diff --git a/README.md b/README.md index 9626742..6c2b47a 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Flags based on structures [![GoDoc](https://godoc.org/github.com/octago/sflags?status.svg)](http://godoc.org/github.com/octago/sflags) [![Build Status](https://travis-ci.org/octago/sflags.svg?branch=master)](https://travis-ci.org/octago/sflags) [![codecov](https://codecov.io/gh/octago/sflags/branch/master/graph/badge.svg)](https://codecov.io/gh/octago/sflags) [![Go Report Card](https://goreportcard.com/badge/github.com/octago/sflags)](https://goreportcard.com/report/github.com/octago/sflags) +# Flags based on structures [![GoDoc](https://godoc.org/github.com/urfave/sflags?status.svg)](http://godoc.org/github.com/urfave/sflags) [![Build Status](https://travis-ci.org/urfave/sflags.svg?branch=master)](https://travis-ci.org/urfave/sflags) [![codecov](https://codecov.io/gh/urfave/sflags/branch/master/graph/badge.svg)](https://codecov.io/gh/urfave/sflags) [![Go Report Card](https://goreportcard.com/badge/github.com/urfave/sflags)](https://goreportcard.com/report/github.com/urfave/sflags) The sflags package uses structs, reflection and struct field tags to allow you specify command line options. It supports [different types](#supported-types-in-structures) and [features](#features). @@ -55,7 +55,7 @@ And you can use your favorite flag or cli library! - [x] Deprecated and hidden options - [ ] Multiple ENV names - [x] Interface for user types. - - [x] [Validation](https://godoc.org/github.com/octago/sflags/validator/govalidator#New) (using [govalidator](https://github.com/asaskevich/govalidator) package) + - [x] [Validation](https://godoc.org/github.com/urfave/sflags/validator/govalidator#New) (using [govalidator](https://github.com/asaskevich/govalidator) package) - [x] Anonymous nested structure support (anonymous structures flatten by default) ## Supported types in structures: @@ -101,7 +101,7 @@ import ( "log" "time" - "github.com/octago/sflags/gen/gflag" + "github.com/urfave/sflags/gen/gflag" ) type httpConfig struct { diff --git a/examples/anonymous/main.go b/examples/anonymous/main.go index 759db07..713ac64 100644 --- a/examples/anonymous/main.go +++ b/examples/anonymous/main.go @@ -10,7 +10,7 @@ import ( "os" "github.com/davecgh/go-spew/spew" - "github.com/octago/sflags/gen/gflag" + "github.com/urfave/sflags/gen/gflag" ) type httpConfig struct { diff --git a/examples/cobra/main.go b/examples/cobra/main.go index ab39e00..99ed82d 100644 --- a/examples/cobra/main.go +++ b/examples/cobra/main.go @@ -11,9 +11,9 @@ import ( "time" "github.com/davecgh/go-spew/spew" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gpflag" "github.com/spf13/cobra" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gpflag" ) type httpConfig struct { diff --git a/examples/flag/main.go b/examples/flag/main.go index 1518a3d..cea6617 100644 --- a/examples/flag/main.go +++ b/examples/flag/main.go @@ -11,8 +11,8 @@ import ( "time" "github.com/davecgh/go-spew/spew" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gflag" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gflag" ) type httpConfig struct { diff --git a/examples/kingpin/main.go b/examples/kingpin/main.go index 7168170..8408b4f 100644 --- a/examples/kingpin/main.go +++ b/examples/kingpin/main.go @@ -11,8 +11,8 @@ import ( "github.com/alecthomas/kingpin/v2" "github.com/davecgh/go-spew/spew" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gkingpin" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gkingpin" ) type httpConfig struct { diff --git a/examples/pflag/main.go b/examples/pflag/main.go index 3708f29..3f62f11 100644 --- a/examples/pflag/main.go +++ b/examples/pflag/main.go @@ -10,8 +10,8 @@ import ( "time" "github.com/davecgh/go-spew/spew" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gpflag" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gpflag" ) type httpConfig struct { diff --git a/examples/simple_flag/main.go b/examples/simple_flag/main.go index 2f3745f..8cc46be 100644 --- a/examples/simple_flag/main.go +++ b/examples/simple_flag/main.go @@ -8,7 +8,7 @@ import ( "log" "time" - "github.com/octago/sflags/gen/gflag" + "github.com/urfave/sflags/gen/gflag" ) type httpConfig struct { diff --git a/examples/urfave_cli/main.go b/examples/urfave_cli/main.go index df9b7fc..b4797da 100644 --- a/examples/urfave_cli/main.go +++ b/examples/urfave_cli/main.go @@ -10,9 +10,9 @@ import ( "time" "github.com/davecgh/go-spew/spew" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gcli" "github.com/urfave/cli/v2" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gcli" ) type httpConfig struct { diff --git a/examples/validator/main.go b/examples/validator/main.go index 304a7b4..cbcb494 100644 --- a/examples/validator/main.go +++ b/examples/validator/main.go @@ -5,9 +5,9 @@ package main import ( "log" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gflag" - "github.com/octago/sflags/validator/govalidator" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gflag" + "github.com/urfave/sflags/validator/govalidator" ) type config struct { diff --git a/gen/gcli/gcli.go b/gen/gcli/gcli.go index 7202d83..de2472e 100644 --- a/gen/gcli/gcli.go +++ b/gen/gcli/gcli.go @@ -1,8 +1,8 @@ package gcli import ( - "github.com/octago/sflags" "github.com/urfave/cli/v2" + "github.com/urfave/sflags" ) // GenerateTo takes a list of sflag.Flag, diff --git a/gen/gcli/gcli_test.go b/gen/gcli/gcli_test.go index e0c50f8..0c52346 100644 --- a/gen/gcli/gcli_test.go +++ b/gen/gcli/gcli_test.go @@ -5,10 +5,10 @@ import ( "io" "testing" - "github.com/octago/sflags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/urfave/cli/v2" + "github.com/urfave/sflags" ) type cfg1 struct { diff --git a/gen/gcli/gcliv3.go b/gen/gcli/gcliv3.go index 2eef94e..7c6fa9f 100644 --- a/gen/gcli/gcliv3.go +++ b/gen/gcli/gcliv3.go @@ -1,8 +1,8 @@ package gcli import ( - "github.com/octago/sflags" "github.com/urfave/cli/v3" + "github.com/urfave/sflags" ) type boolFlag interface { diff --git a/gen/gcli/gcliv3_test.go b/gen/gcli/gcliv3_test.go index 386fa73..7088f25 100644 --- a/gen/gcli/gcliv3_test.go +++ b/gen/gcli/gcliv3_test.go @@ -6,10 +6,10 @@ import ( "io" "testing" - "github.com/octago/sflags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" "github.com/urfave/cli/v3" + "github.com/urfave/sflags" ) type cfg2 struct { diff --git a/gen/gflag/gflag.go b/gen/gflag/gflag.go index 2b47f72..f7aac4e 100644 --- a/gen/gflag/gflag.go +++ b/gen/gflag/gflag.go @@ -4,7 +4,7 @@ import ( "flag" "os" - "github.com/octago/sflags" + "github.com/urfave/sflags" ) // flagSet describes interface, diff --git a/gen/gflag/gflag_test.go b/gen/gflag/gflag_test.go index da2a085..ac73ad0 100644 --- a/gen/gflag/gflag_test.go +++ b/gen/gflag/gflag_test.go @@ -6,9 +6,9 @@ import ( "os" "testing" - "github.com/octago/sflags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/urfave/sflags" ) type cfg1 struct { diff --git a/gen/gkingpin/gkingpin.go b/gen/gkingpin/gkingpin.go index 0712418..82841dd 100644 --- a/gen/gkingpin/gkingpin.go +++ b/gen/gkingpin/gkingpin.go @@ -4,7 +4,7 @@ import ( "unicode/utf8" "github.com/alecthomas/kingpin/v2" - "github.com/octago/sflags" + "github.com/urfave/sflags" ) type flagger interface { diff --git a/gen/gkingpin/gkingpin_test.go b/gen/gkingpin/gkingpin_test.go index a713165..4dab690 100644 --- a/gen/gkingpin/gkingpin_test.go +++ b/gen/gkingpin/gkingpin_test.go @@ -5,9 +5,9 @@ import ( "testing" "github.com/alecthomas/kingpin/v2" - "github.com/octago/sflags" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/urfave/sflags" ) type cfg1 struct { diff --git a/gen/gpflag/gpflag.go b/gen/gpflag/gpflag.go index bd3dd8a..2116168 100644 --- a/gen/gpflag/gpflag.go +++ b/gen/gpflag/gpflag.go @@ -3,8 +3,8 @@ package gpflag import ( "os" - "github.com/octago/sflags" "github.com/spf13/pflag" + "github.com/urfave/sflags" ) // flagSet describes interface, diff --git a/gen/gpflag/gpflag_test.go b/gen/gpflag/gpflag_test.go index 96cc851..91e4339 100644 --- a/gen/gpflag/gpflag_test.go +++ b/gen/gpflag/gpflag_test.go @@ -8,10 +8,10 @@ import ( "testing" "time" - "github.com/octago/sflags" "github.com/spf13/pflag" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" + "github.com/urfave/sflags" ) type cfg1 struct { diff --git a/go.mod b/go.mod index 607b158..1c84d03 100644 --- a/go.mod +++ b/go.mod @@ -1,4 +1,4 @@ -module github.com/octago/sflags +module github.com/urfave/sflags go 1.21.5 diff --git a/validator/govalidator/govalidator_test.go b/validator/govalidator/govalidator_test.go index 15bd6af..cc857a7 100644 --- a/validator/govalidator/govalidator_test.go +++ b/validator/govalidator/govalidator_test.go @@ -7,9 +7,9 @@ import ( "log" "testing" - "github.com/octago/sflags" - "github.com/octago/sflags/gen/gflag" "github.com/stretchr/testify/assert" + "github.com/urfave/sflags" + "github.com/urfave/sflags/gen/gflag" ) func ExampleNew() { diff --git a/values_generated_test.go b/values_generated_test.go index f150708..282d61b 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("wVWkeval1") + err = v.Set("dzMfxval1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qLcBL:val1") + err = v.Set("XcrRz:val1") assert.Nil(t, err) - err = v.Set("aRnPzval2") + err = v.Set("WjIXlval2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("GLPNd:val2") + err = v.Set("DqGev: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("lyFwg") + err = v.Set("dXmJx") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("hqyuW:") + err = v.Set("jQufn:") 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("0val1") + err = v.Set("3val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("1:val1") + err = v.Set("7:val1") assert.Nil(t, err) - err = v.Set("7val2") + 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("7:val2") + err = v.Set("2: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("7") + 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("6:") + err = v.Set("7:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]string", v.Type()) @@ -243,13 +243,13 @@ func TestInt8StringMapValue(t *testing.T) { v := newInt8StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6val1") + err = v.Set("1val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("5:val1") + err = v.Set("4:val1") assert.Nil(t, err) - err = v.Set("5val2") + err = v.Set("1val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) @@ -269,7 +269,7 @@ func TestInt8StringMapValue(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("1:") + err = v.Set("4:") 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("5val1") + 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("1:val1") + err = v.Set("7:val1") assert.Nil(t, err) - err = v.Set("7val2") + 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("2:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]string", v.Type()) @@ -306,11 +306,11 @@ func TestInt16StringMapValue(t *testing.T) { v := newInt16StringMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2") + 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("3:") + err = v.Set("2:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]string", v.Type()) @@ -329,13 +329,13 @@ func TestInt32StringMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("7:val1") + err = v.Set("4:val1") assert.Nil(t, err) - err = v.Set("6val2") + 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("3:val2") + err = v.Set("4:val2") 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("3val1") + 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("5:val1") + err = v.Set("3:val1") assert.Nil(t, err) - err = v.Set("6val2") + 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("0:val2") + err = v.Set("2: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("4") + 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("7:") 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("7val1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val1") assert.NotNil(t, err) - err = v.Set("4:val1") + err = v.Set("7:val1") assert.Nil(t, err) - err = v.Set("5val2") + err = v.Set("4val2") 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("5") + err = v.Set("2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":") assert.NotNil(t, err) - err = v.Set("1:") + err = v.Set("5:") 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("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("5:val1") + err = v.Set("7:val1") assert.Nil(t, err) - err = v.Set("0val2") + err = v.Set("6val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("3:val2") + err = v.Set("2:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]string", v.Type()) @@ -474,7 +474,7 @@ func TestUint8StringMapValue(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[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("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("0:val1") assert.Nil(t, err) - err = v.Set("7val2") + err = v.Set("5val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) - err = v.Set("2:val2") + err = v.Set("0: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("3") + 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("4:") + err = v.Set("2:") 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("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("5:val1") + err = v.Set("2:val1") assert.Nil(t, err) - err = v.Set("7val2") + 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("7:val2") + err = v.Set("4:val2") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]string", v.Type()) @@ -556,7 +556,7 @@ func TestUint32StringMapValue(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("6:") + err = v.Set("3:") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]string", v.Type()) @@ -571,13 +571,13 @@ func TestUint64StringMapValue(t *testing.T) { v := newUint64StringMapValue(&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("6:val1") + err = v.Set("1:val1") assert.Nil(t, err) - err = v.Set("5val2") + err = v.Set("0val2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":val2") assert.NotNil(t, err) @@ -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("3") + 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("5:") 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("hvZrrtrue") + err = v.Set("kBIsStrue") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("yerAZ:true") + err = v.Set("mcfFU:true") assert.Nil(t, err) - err = v.Set("AEMahfalse") + err = v.Set("apWUZfalse") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("oQbAR:false") + err = v.Set("LwwHu: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("FMIkpunexpected") + err = v.Set("TJTRSunexpected") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BSxrd:unexpected") + err = v.Set("BnMTA: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()) @@ -852,13 +852,13 @@ func TestIntBoolMapValue(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("2:true") + err = v.Set("0:true") assert.Nil(t, err) - err = v.Set("1false") + err = v.Set("4false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("1:false") + err = v.Set("2:false") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]bool", v.Type()) @@ -874,7 +874,7 @@ func TestIntBoolMapValue(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("6: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[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("3true") + 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("3:true") + err = v.Set("6:true") assert.Nil(t, err) - err = v.Set("5false") + 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("0:false") + err = v.Set("2: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("6unexpected") + 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("0: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[int8]bool", v.Type()) @@ -934,13 +934,13 @@ func TestInt16BoolMapValue(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("2:true") + err = v.Set("3:true") assert.Nil(t, err) - err = v.Set("3false") + err = v.Set("1false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("2:false") + err = v.Set("0: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("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("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("1true") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":true") assert.NotNil(t, err) - err = v.Set("6:true") + err = v.Set("1:true") assert.Nil(t, err) - err = v.Set("2false") + err = v.Set("1false") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":false") assert.NotNil(t, err) - err = v.Set("3:false") + err = v.Set("5: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("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("0:unexpected") + err = v.Set("5:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("3:true") + err = v.Set("4:true") assert.Nil(t, err) - err = v.Set("7false") + 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("2:false") + err = v.Set("4: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("6unexpected") + 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("5: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("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("1: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("4:false") + err = v.Set("1: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("0unexpected") + err = v.Set("2unexpected") 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("2true") + 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("0:true") assert.Nil(t, err) - err = v.Set("1false") + 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[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("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("3:unexpected") + err = v.Set("1: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("0true") + 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("7:true") + err = v.Set("2: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("2:false") + err = v.Set("6: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("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("6:unexpected") + err = v.Set("1: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()) @@ -1180,13 +1180,13 @@ func TestUint32BoolMapValue(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("3:true") + err = v.Set("0:true") assert.Nil(t, err) - err = v.Set("4false") + 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("0:false") + err = v.Set("4: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("2:unexpected") + err = v.Set("5:unexpected") assert.EqualError(t, err, "strconv.ParseBool: parsing \"unexpected\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("4true") + 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("0:true") + err = v.Set("6: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("4:false") + err = v.Set("0:false") assert.Nil(t, err) 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("zKbJy10") + err = v.Set("ULDsu10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("eSYjx:10") + err = v.Set("LRHqe:10") assert.Nil(t, err) - err = v.Set("WiVSz20") + err = v.Set("Qvoja20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("RFNPI:20") + err = v.Set("JOzDp: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("prKMT-1") + err = v.Set("aNUHv-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ISXKA:-1") + err = v.Set("FhXzh:-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("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("2: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("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,7 +1506,7 @@ func TestIntUintMapValue(t *testing.T) { v := newIntUintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("7-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) @@ -1525,17 +1525,17 @@ func TestInt8UintMapValue(t *testing.T) { v := newInt8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("0: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("1:20") + err = v.Set("7: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("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("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[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("5:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint", v.Type()) @@ -1592,7 +1592,7 @@ func TestInt16UintMapValue(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[int16]uint", v.Type()) @@ -1607,13 +1607,13 @@ func TestInt32UintMapValue(t *testing.T) { v := newInt32UintMapValue(&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("3:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("4:-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[int32]uint", v.Type()) @@ -1652,9 +1652,9 @@ func TestInt64UintMapValue(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("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) @@ -1670,11 +1670,11 @@ func TestInt64UintMapValue(t *testing.T) { v := newInt64UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("5:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("6:10") + err = v.Set("5: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("5:20") + err = v.Set("3: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("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("1:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint", v.Type()) @@ -1730,17 +1730,17 @@ func TestUint8UintMapValue(t *testing.T) { v := newUint8UintMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("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("4:10") assert.Nil(t, err) err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("7: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("1-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("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("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("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("6: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,7 +1793,7 @@ func TestUint16UintMapValue(t *testing.T) { v := newUint16UintMapValue(&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) @@ -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("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("2:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint", v.Type()) @@ -1838,7 +1838,7 @@ func TestUint32UintMapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("1:-1") + err = v.Set("7:-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("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("3:10") + err = v.Set("2: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("0:20") + err = v.Set("3: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("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("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[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("uDyYv10") + err = v.Set("lkBMJ10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("jCZze:10") + err = v.Set("vMxai:10") assert.Nil(t, err) - err = v.Set("TweqK20") + err = v.Set("NjAmP20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("KYadV:20") + err = v.Set("BqnHu: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("LkFci-1") + err = v.Set("HxRkr-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("HViPd:-1") + err = v.Set("wxdUJ:-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("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("3: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("2:20") + err = v.Set("6: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("3-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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]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("310") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("1: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("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("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint8", v.Type()) @@ -2206,13 +2206,13 @@ func TestInt16Uint8MapValue(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("0:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]uint8", v.Type()) @@ -2224,11 +2224,11 @@ func TestInt16Uint8MapValue(t *testing.T) { v := newInt16Uint8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("1:-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("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("6:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("5: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("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("5:-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()) @@ -2290,11 +2290,11 @@ func TestInt64Uint8MapValue(t *testing.T) { assert.NotNil(t, err) 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("1:20") + err = v.Set("2: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("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[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("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("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("4:20") + err = v.Set("3:20") assert.Nil(t, err) 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("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("0: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("1:20") + err = v.Set("0: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("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("1:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("0:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]uint8", v.Type()) @@ -2429,7 +2429,7 @@ func TestUint16Uint8MapValue(t *testing.T) { v := newUint16Uint8MapValue(&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) @@ -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("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("0:10") + err = v.Set("3: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("1: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("3-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("210") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("4: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("6-1") + err = v.Set("4-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("7:-1") + err = v.Set("5:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("ZWDcG10") + err = v.Set("aWbPd10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("zpSHG:10") + err = v.Set("fxYeD:10") assert.Nil(t, err) - err = v.Set("iZvcw20") + err = v.Set("CzbXP20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("STXEP:20") + err = v.Set("gRoVH: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("laIam-1") + err = v.Set("hyiEE-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("dHqZN:-1") + err = v.Set("tJjLa:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint16", v.Type()) @@ -2756,17 +2756,17 @@ func TestIntUint16MapValue(t *testing.T) { v := newIntUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("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("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[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("3-1") + err = v.Set("7-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("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("6:20") + err = v.Set("1: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("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("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[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("710") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("5: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("5: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("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("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[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("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("4:10") assert.Nil(t, err) err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("5:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint16", v.Type()) @@ -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("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[int32]uint16", v.Type()) @@ -2920,13 +2920,13 @@ func TestInt64Uint16MapValue(t *testing.T) { v := newInt64Uint16MapValue(&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("3: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) @@ -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("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("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[int64]uint16", v.Type()) @@ -2961,17 +2961,17 @@ func TestUintUint16MapValue(t *testing.T) { v := newUintUint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("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("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("7: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("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("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[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("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("2: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("4:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]uint16", v.Type()) @@ -3024,11 +3024,11 @@ func TestUint8Uint16MapValue(t *testing.T) { v := newUint8Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3-1") + err = v.Set("0-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("3:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]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("110") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("1:10") assert.Nil(t, err) err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("4: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("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("5:-1") + err = v.Set("4:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]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("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("0:10") + err = v.Set("6:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]uint16", v.Type()) @@ -3106,7 +3106,7 @@ func TestUint32Uint16MapValue(t *testing.T) { v := newUint32Uint16MapValue(&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) @@ -3125,17 +3125,17 @@ func TestUint64Uint16MapValue(t *testing.T) { v := newUint64Uint16MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("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("5: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("4-1") + err = v.Set("2-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("7:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]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("arnss10") + err = v.Set("rRSCT10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("KaofM:10") + err = v.Set("qCqRG:10") assert.Nil(t, err) - err = v.Set("WvCvL20") + err = v.Set("tgLNl20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("HHaqq:20") + err = v.Set("MfWnI: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("unoWJ-1") + err = v.Set("Ugjzx-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nSNPJ:-1") + err = v.Set("LinnY:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]uint32", v.Type()) @@ -3396,13 +3396,13 @@ func TestIntUint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("4:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("7:20") + err = v.Set("1: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("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("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[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("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("3: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("7:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]uint32", v.Type()) @@ -3455,11 +3455,11 @@ func TestInt8Uint32MapValue(t *testing.T) { v := newInt8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("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("1:10") + err = v.Set("3: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("7:20") + err = v.Set("6: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("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[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("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("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("2:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint32", v.Type()) @@ -3541,7 +3541,7 @@ func TestInt32Uint32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("0:-1") + err = v.Set("7:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint32", v.Type()) @@ -3562,11 +3562,11 @@ func TestInt64Uint32MapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("520") + err = v.Set("120") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("6: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("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("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]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("510") + err = v.Set("410") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + 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("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3619,11 +3619,11 @@ func TestUintUint32MapValue(t *testing.T) { v := newUintUint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5-1") + err = v.Set("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("2:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]uint32", v.Type()) @@ -3638,17 +3638,17 @@ func TestUint8Uint32MapValue(t *testing.T) { v := newUint8Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610") + err = v.Set("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") 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("6:20") + err = v.Set("5: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("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("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[uint8]uint32", v.Type()) @@ -3679,17 +3679,17 @@ func TestUint16Uint32MapValue(t *testing.T) { v := newUint16Uint32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("410") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("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("5: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("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("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("210") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("7: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("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("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[uint32]uint32", v.Type()) @@ -3761,11 +3761,11 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&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("1:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -3783,7 +3783,7 @@ func TestUint64Uint32MapValue(t *testing.T) { v := newUint64Uint32MapValue(&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) @@ -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("MTiCb10") + err = v.Set("Ynkph10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("AjVGx:10") + err = v.Set("JtETa:10") assert.Nil(t, err) - err = v.Set("yMQaj20") + err = v.Set("TIlsU20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LqoQr:20") + err = v.Set("MpMcH: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("CdpKS-1") + err = v.Set("oLfCf-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("dYAvN:-1") + err = v.Set("zJUJB:-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("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("2: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("6:20") + err = v.Set("1: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("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("2:-1") + err = v.Set("0:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]uint64", v.Type()) @@ -4069,13 +4069,13 @@ func TestInt8Uint64MapValue(t *testing.T) { v := newInt8Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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") + err = v.Set("7: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) @@ -4095,7 +4095,7 @@ func TestInt8Uint64MapValue(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("3:-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,11 +4110,11 @@ func TestInt16Uint64MapValue(t *testing.T) { v := newInt16Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("020") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -4136,7 +4136,7 @@ func TestInt16Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("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[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("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("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("5:20") + err = v.Set("7: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("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("3:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]uint64", v.Type()) @@ -4192,13 +4192,13 @@ func TestInt64Uint64MapValue(t *testing.T) { v := newInt64Uint64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("3: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) @@ -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("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("0:-1") + err = v.Set("1:-1") assert.EqualError(t, err, "strconv.ParseUint: parsing \"-1\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("010") + err = v.Set("210") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("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("5: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("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("3:-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[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("710") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("3:10") assert.Nil(t, err) err = v.Set("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("5: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("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("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[uint8]uint64", v.Type()) @@ -4319,13 +4319,13 @@ func TestUint16Uint64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2: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("2:20") + err = v.Set("7: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("1-1") + err = v.Set("3-1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":-1") assert.NotNil(t, err) - err = v.Set("6:-1") + err = v.Set("5:-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()) @@ -4360,13 +4360,13 @@ func TestUint32Uint64MapValue(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("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("5:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("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[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("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("2: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("5:20") + err = v.Set("1: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("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("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[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("rVIJd10") + err = v.Set("HVsTf10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("LrrZI:10") + err = v.Set("qzbLs:10") assert.Nil(t, err) - err = v.Set("wnDyW20") + err = v.Set("fVYzM20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qZDDN:20") + err = v.Set("qPpCS: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("fJBoWa") + err = v.Set("fJUBya") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("HtHNc:a") + err = v.Set("uuoIX: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("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("5:10") + err = v.Set("0:10") assert.Nil(t, err) err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int", v.Type()) @@ -4726,7 +4726,7 @@ func TestIntIntMapValue(t *testing.T) { v := newIntIntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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) @@ -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("610") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("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("4:20") + err = v.Set("3:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int", v.Type()) @@ -4767,11 +4767,11 @@ func TestInt8IntMapValue(t *testing.T) { v := newInt8IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[int8]int", v.Type()) @@ -4786,13 +4786,13 @@ func TestInt16IntMapValue(t *testing.T) { v := newInt16IntMapValue(&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("5:10") + err = v.Set("3: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) @@ -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("5a") + err = v.Set("6a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("4: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("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("320") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int", v.Type()) @@ -4849,11 +4849,11 @@ func TestInt32IntMapValue(t *testing.T) { v := newInt32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("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[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("310") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("0: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("4:20") + err = v.Set("7: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("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("3: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("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("0: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) @@ -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("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("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]int", v.Type()) @@ -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("510") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("7:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("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[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("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int", v.Type()) @@ -4991,11 +4991,11 @@ 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("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("1:10") assert.Nil(t, err) err = v.Set("620") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -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("3a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("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,13 +5032,13 @@ func TestUint32IntMapValue(t *testing.T) { v := newUint32IntMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("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("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[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("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("1:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3: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("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[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("qHgZv10") + err = v.Set("iOPrg10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("RaRQa:10") + err = v.Set("rndrW:10") assert.Nil(t, err) - err = v.Set("blbcP20") + err = v.Set("HxSDh20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("nuxdP:20") + err = v.Set("VaTuR: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("kzsXha") + err = v.Set("PMVjba") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("jLGQx:a") + err = v.Set("kuWVP: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("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("7: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("2:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int8", v.Type()) @@ -5376,7 +5376,7 @@ func TestIntInt8MapValue(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("6:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int8", v.Type()) @@ -5395,13 +5395,13 @@ func TestInt8Int8MapValue(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("5:10") assert.Nil(t, err) - err = v.Set("620") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("4:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int8", v.Type()) @@ -5413,11 +5413,11 @@ func TestInt8Int8MapValue(t *testing.T) { v := newInt8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("0:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]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("110") + err = v.Set("610") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("5:10") + err = v.Set("1:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int8", v.Type()) @@ -5454,7 +5454,7 @@ func TestInt16Int8MapValue(t *testing.T) { v := newInt16Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -5477,9 +5477,9 @@ func TestInt32Int8MapValue(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("1:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) @@ -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("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("4:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]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("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("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("2:20") + err = v.Set("3: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("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("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]int8", v.Type()) @@ -5559,13 +5559,13 @@ func TestUintInt8MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("1:10") + err = v.Set("3:10") assert.Nil(t, err) - err = v.Set("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("2: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("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("7:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("3: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("5:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]int8", v.Type()) @@ -5618,11 +5618,11 @@ func TestUint8Int8MapValue(t *testing.T) { v := newUint8Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("5:a") + err = v.Set("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("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("2:10") + err = v.Set("5:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("520") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("6:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("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]int8", v.Type()) @@ -5678,17 +5678,17 @@ func TestUint32Int8MapValue(t *testing.T) { v := newUint32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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") 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("7:20") + err = v.Set("1:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int8", v.Type()) @@ -5700,11 +5700,11 @@ func TestUint32Int8MapValue(t *testing.T) { v := newUint32Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("3:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]int8", v.Type()) @@ -5719,13 +5719,13 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("010") + err = v.Set("110") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("3:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("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) @@ -5741,7 +5741,7 @@ func TestUint64Int8MapValue(t *testing.T) { v := newUint64Int8MapValue(&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) @@ -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("wuHSc10") + err = v.Set("hAnpH10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("WtNWk:10") + err = v.Set("KVDnT:10") assert.Nil(t, err) - err = v.Set("iXfXk20") + err = v.Set("XCcdg20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("hJVJs:20") + err = v.Set("bBjFj: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("qblTTa") + err = v.Set("rzOnGa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Vilcp:a") + err = v.Set("zJovW:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[string]int16", v.Type()) @@ -6000,13 +6000,13 @@ func TestIntInt16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2: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("5:20") + err = v.Set("1: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("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("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[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("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("6: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("5:20") + err = v.Set("1: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("4a") + err = v.Set("3a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("1: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,13 +6078,13 @@ func TestInt16Int16MapValue(t *testing.T) { v := newInt16Int16MapValue(&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("6:10") + err = v.Set("1: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) @@ -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("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("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[int16]int16", v.Type()) @@ -6119,7 +6119,7 @@ func TestInt32Int16MapValue(t *testing.T) { v := newInt32Int16MapValue(&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) @@ -6129,7 +6129,7 @@ func TestInt32Int16MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("5: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("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("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[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("110") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("6:10") assert.Nil(t, err) err = v.Set("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("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]int16", v.Type()) @@ -6186,7 +6186,7 @@ func TestInt64Int16MapValue(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("2: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("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("6: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[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("3a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("0: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("110") + err = v.Set("310") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("7:10") assert.Nil(t, err) - err = v.Set("720") + err = v.Set("220") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("2: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("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("5:a") + err = v.Set("6:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("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) @@ -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("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.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("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("6:10") + err = v.Set("3: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("0: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("2a") + err = v.Set("0a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("3:10") + err = v.Set("2: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("6:20") + err = v.Set("0: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("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[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("SljxD10") + err = v.Set("OFaXx10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("cXwzs:10") + err = v.Set("bOZZv:10") assert.Nil(t, err) - err = v.Set("ACHMZ20") + err = v.Set("wKMHM20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("QoEiV:20") + err = v.Set("uDqyA: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("yPlyHa") + err = v.Set("FrWVfa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("FxUNj:a") + err = v.Set("glgQW: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("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("1: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("1:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int32", v.Type()) @@ -6664,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("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("2:a") + err = v.Set("4:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]int32", v.Type()) @@ -6683,17 +6683,17 @@ func TestInt8Int32MapValue(t *testing.T) { v := newInt8Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310") + err = v.Set("710") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("0:10") + err = v.Set("5: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("7:20") + err = v.Set("3: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("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("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[int8]int32", v.Type()) @@ -6728,13 +6728,13 @@ func TestInt16Int32MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2:10") assert.Nil(t, err) err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("2:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]int32", v.Type()) @@ -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("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) @@ -6769,13 +6769,13 @@ func TestInt32Int32MapValue(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("0:10") assert.Nil(t, err) err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("0: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("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("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[int32]int32", v.Type()) @@ -6806,17 +6806,17 @@ func TestInt64Int32MapValue(t *testing.T) { v := newInt64Int32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("220") + err = v.Set("420") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("1:20") + err = v.Set("7: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("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("3: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("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("7: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("3: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("5a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("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[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("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("4: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("2:20") + err = v.Set("1: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("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[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("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("2:10") assert.Nil(t, err) - err = v.Set("020") + err = v.Set("320") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("6:20") + err = v.Set("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("1: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,13 +6970,13 @@ func TestUint32Int32MapValue(t *testing.T) { v := newUint32Int32MapValue(&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("7:10") + err = v.Set("3: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) @@ -6996,7 +6996,7 @@ func TestUint32Int32MapValue(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("6: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("210") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("2:10") + err = v.Set("0:10") assert.Nil(t, err) - err = v.Set("120") + err = v.Set("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("2: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("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("5:a") + err = v.Set("3:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("eBZsW10") + err = v.Set("Kwidi10") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BFAwB:10") + err = v.Set("WiqYf:10") assert.Nil(t, err) - err = v.Set("gniQC20") + err = v.Set("zuXZp20") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("IIlTv:20") + err = v.Set("cfcEq: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("MeQeea") + err = v.Set("EGPMBa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("MUlPs:a") + err = v.Set("sbkWa: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("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("0: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("4: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("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("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[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("310") + err = v.Set("010") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10") assert.NotNil(t, err) - err = v.Set("4:10") + err = v.Set("2: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("3:20") + err = v.Set("0:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int64", v.Type()) @@ -7355,7 +7355,7 @@ func TestInt8Int64MapValue(t *testing.T) { assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("4:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]int64", v.Type()) @@ -7370,13 +7370,13 @@ func TestInt16Int64MapValue(t *testing.T) { v := newInt16Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210") + err = v.Set("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("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) @@ -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("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("6: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("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("5:10") + err = v.Set("0: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("2:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int64", v.Type()) @@ -7433,11 +7433,11 @@ func TestInt32Int64MapValue(t *testing.T) { v := newInt32Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4:a") + err = v.Set("2:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]int64", v.Type()) @@ -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("7:10") + err = v.Set("2:10") assert.Nil(t, err) - err = v.Set("420") + err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("0:20") + err = v.Set("7: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("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("4:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("6:10") + err = v.Set("0: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("3:20") + err = v.Set("7:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]int64", v.Type()) @@ -7515,7 +7515,7 @@ func TestUintInt64MapValue(t *testing.T) { v := newUintInt64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5a") + err = v.Set("1a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -7538,13 +7538,13 @@ func TestUint8Int64MapValue(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("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[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("6a") + err = v.Set("4a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("3:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.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("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("0:10") + err = v.Set("3: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("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("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.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("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("4:10") assert.Nil(t, err) err = v.Set("720") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20") assert.NotNil(t, err) - err = v.Set("3:20") + err = v.Set("1: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("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("3:a") + err = v.Set("1:a") assert.EqualError(t, err, "strconv.ParseInt: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]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("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("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("2:20") + err = v.Set("4:20") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]int64", v.Type()) @@ -7679,11 +7679,11 @@ func TestUint64Int64MapValue(t *testing.T) { v := newUint64Int64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("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("3: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("dVhza10.2") + err = v.Set("EfBGI10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("pMsAo:10.2") + err = v.Set("vDVDf:10.2") assert.Nil(t, err) - err = v.Set("xEEAV20.99") + err = v.Set("RuRcq20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("qXQPe:20.99") + err = v.Set("FzABr: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("aRkYla") + err = v.Set("OeYHia") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("pgwVB:a") + err = v.Set("qllmQ: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("510.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("2:10.2") + err = v.Set("7: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("1:20.99") + err = v.Set("6: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("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("4:a") + err = v.Set("7:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]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("310.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("1:10.2") assert.Nil(t, err) - err = v.Set("720.99") + err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("6: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("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("1:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]float64", v.Type()) @@ -7996,13 +7996,13 @@ func TestInt16Float64MapValue(t *testing.T) { v := newInt16Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("510.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("5: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) @@ -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("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("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[int16]float64", v.Type()) @@ -8037,17 +8037,17 @@ func TestInt32Float64MapValue(t *testing.T) { v := newInt32Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("110.2") + err = v.Set("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("1:10.2") + err = v.Set("0: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("5: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("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("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[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("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("4: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("1: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("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("3: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("210.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("4:10.2") + err = v.Set("1: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("6:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]float64", v.Type()) @@ -8141,11 +8141,11 @@ func TestUintFloat64MapValue(t *testing.T) { v := newUintFloat64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("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[uint]float64", v.Type()) @@ -8160,17 +8160,17 @@ func TestUint8Float64MapValue(t *testing.T) { v := newUint8Float64MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("4:10.2") + err = v.Set("0: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("0:20.99") + err = v.Set("4: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("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("4:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float64", v.Type()) @@ -8205,13 +8205,13 @@ func TestUint16Float64MapValue(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("2:10.2") + err = v.Set("0:10.2") assert.Nil(t, err) - err = v.Set("320.99") + err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("5:20.99") + err = v.Set("3: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("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("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[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("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("3:10.2") + err = v.Set("7:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("1:20.99") + err = v.Set("3: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("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("3:a") + err = v.Set("6:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float64", v.Type()) @@ -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("710.2") + err = v.Set("110.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("7:10.2") + err = v.Set("3:10.2") assert.Nil(t, err) - err = v.Set("320.99") + err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("0:20.99") + err = v.Set("5:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]float64", v.Type()) @@ -8305,7 +8305,7 @@ 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("5a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) @@ -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("GrXUf10.2") + err = v.Set("cVZgO10.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("gQrwG:10.2") + err = v.Set("iUebv:10.2") assert.Nil(t, err) - err = v.Set("lztbz20.99") + err = v.Set("hNDye20.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("RXHcI:20.99") + err = v.Set("ybuCc: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("ZQpDxa") + err = v.Set("zMdbsa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("XeJjf:a") + err = v.Set("uvBAw: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()) @@ -8544,13 +8544,13 @@ func TestIntFloat32MapValue(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("3:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("420.99") + err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("0:20.99") + err = v.Set("3: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("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("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[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("510.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("6:10.2") + err = v.Set("7: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("4: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("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("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[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("210.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("4:10.2") assert.Nil(t, err) - err = v.Set("620.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("3: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("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("0: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("110.2") + err = v.Set("310.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("4:10.2") + err = v.Set("2:10.2") assert.Nil(t, err) - err = v.Set("520.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("4:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]float32", v.Type()) @@ -8685,11 +8685,11 @@ func TestInt32Float32MapValue(t *testing.T) { v := newInt32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("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[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("210.2") + err = v.Set("610.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("7:10.2") + err = v.Set("5:10.2") assert.Nil(t, err) - err = v.Set("120.99") + err = v.Set("420.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("4:20.99") + err = v.Set("3: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("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("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[int64]float32", v.Type()) @@ -8745,13 +8745,13 @@ func TestUintFloat32MapValue(t *testing.T) { v := newUintFloat32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("610.2") + err = v.Set("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("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) @@ -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("0a") + err = v.Set("2a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("1:a") + err = v.Set("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("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("2:10.2") + err = v.Set("3: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("2:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8808,11 +8808,11 @@ func TestUint8Float32MapValue(t *testing.T) { v := newUint8Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3a") + err = v.Set("7a") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":a") assert.NotNil(t, err) - err = v.Set("0:a") + err = v.Set("5:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint8]float32", v.Type()) @@ -8827,13 +8827,13 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("310.2") + err = v.Set("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("4:10.2") + err = v.Set("7: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) @@ -8849,11 +8849,11 @@ func TestUint16Float32MapValue(t *testing.T) { v := newUint16Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("7:a") + err = v.Set("0:a") assert.EqualError(t, err, "strconv.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]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("610.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("0:10.2") + err = v.Set("1:10.2") assert.Nil(t, err) - err = v.Set("520.99") + err = v.Set("620.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":20.99") assert.NotNil(t, err) - err = v.Set("2:20.99") + err = v.Set("1:20.99") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float32", v.Type()) @@ -8890,11 +8890,11 @@ func TestUint32Float32MapValue(t *testing.T) { v := newUint32Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2a") + err = v.Set("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.ParseFloat: parsing \"a\": invalid syntax") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]float32", v.Type()) @@ -8909,11 +8909,11 @@ func TestUint64Float32MapValue(t *testing.T) { v := newUint64Float32MapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210.2") + err = v.Set("010.2") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10.2") assert.NotNil(t, err) - err = v.Set("2:10.2") + err = v.Set("7:10.2") assert.Nil(t, err) err = v.Set("020.99") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") @@ -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("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("0: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("RgLTs10s") + err = v.Set("dePor10s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("yROpJ:10s") + err = v.Set("oyNdT:10s") assert.Nil(t, err) - err = v.Set("uXVQl30m") + err = v.Set("EBcbh30m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ARHxL:30m") + err = v.Set("jmcXV: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("qFbQh3l") + err = v.Set("InyIN3l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("IcUSQ:3l") + err = v.Set("mnpPy: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("010s") + 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("1:10s") + err = v.Set("6:10s") assert.Nil(t, err) - err = v.Set("430m") + 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("2:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]time.Duration", v.Type()) @@ -9178,7 +9178,7 @@ func TestIntDurationMapValue(t *testing.T) { v := newIntDurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("33l") + err = v.Set("13l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) @@ -9197,7 +9197,7 @@ func TestInt8DurationMapValue(t *testing.T) { v := newInt8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("210s") + err = v.Set("110s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) @@ -9207,7 +9207,7 @@ func TestInt8DurationMapValue(t *testing.T) { 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[int8]time.Duration", v.Type()) @@ -9219,7 +9219,7 @@ func TestInt8DurationMapValue(t *testing.T) { v := newInt8DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("73l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) @@ -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("010s") + 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("4:10s") + err = v.Set("1:10s") assert.Nil(t, err) - err = v.Set("130m") + err = v.Set("330m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) - err = v.Set("1:30m") + err = v.Set("2: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("23l") + 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("2: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()) @@ -9285,11 +9285,11 @@ func TestInt32DurationMapValue(t *testing.T) { assert.NotNil(t, err) err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("630m") + 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("1:30m") + err = v.Set("7:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]time.Duration", v.Type()) @@ -9301,7 +9301,7 @@ 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("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) @@ -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("210s") + 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("1:10s") + err = v.Set("7:10s") assert.Nil(t, err) - err = v.Set("330m") + 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("6: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("03l") + 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("0:3l") + err = v.Set("1:3l") assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("010s") + 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("4:10s") + err = v.Set("0: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("7:30m") + err = v.Set("2: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("03l") + err = v.Set("33l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("0: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[uint]time.Duration", v.Type()) @@ -9402,13 +9402,13 @@ func TestUint8DurationMapValue(t *testing.T) { v := newUint8DurationMapValue(&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("6:10s") + err = v.Set("5:10s") assert.Nil(t, err) - err = v.Set("230m") + err = v.Set("530m") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":30m") assert.NotNil(t, err) @@ -9428,7 +9428,7 @@ func TestUint8DurationMapValue(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("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[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("210s") + 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("4:10s") assert.Nil(t, err) - err = v.Set("530m") + 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("4:30m") + err = v.Set("1: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("33l") + err = v.Set("43l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("0: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[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("110s") + 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("1:10s") + err = v.Set("3:10s") assert.Nil(t, err) - err = v.Set("630m") + 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("5:30m") + err = v.Set("1:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]time.Duration", v.Type()) @@ -9506,11 +9506,11 @@ func TestUint32DurationMapValue(t *testing.T) { v := newUint32DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("73l") + err = v.Set("03l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("6: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[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("410s") + err = v.Set("610s") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":10s") assert.NotNil(t, err) err = v.Set("2:10s") assert.Nil(t, err) - err = v.Set("230m") + 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("3:30m") + err = v.Set("7:30m") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]time.Duration", v.Type()) @@ -9547,11 +9547,11 @@ func TestUint64DurationMapValue(t *testing.T) { v := newUint64DurationMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("43l") + err = v.Set("03l") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":3l") assert.NotNil(t, err) - err = v.Set("3:3l") + err = v.Set("5:3l") assert.EqualError(t, err, "time: unknown unit \"l\" in duration \"3l\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("QFFBa127.0.0.1") + err = v.Set("hPVqi127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mqHlH:127.0.0.1") + err = v.Set("crRzo:127.0.0.1") assert.Nil(t, err) - err = v.Set("BBiLL127.0.0.3") + err = v.Set("aEsNw127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("PUJSy:127.0.0.3") + err = v.Set("peGOe: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("onkvD127.0.0.1.3") + err = v.Set("reGcf127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ZffwS:127.0.0.1.3") + err = v.Set("bcUTZ: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("5:127.0.0.1") + err = v.Set("6:127.0.0.1") assert.Nil(t, err) - err = v.Set("5127.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("7: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("2127.0.0.1.3") + err = v.Set("7127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("5: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[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("6127.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("0: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("7:127.0.0.3") + err = v.Set("2:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("3127.0.0.1.3") + err = v.Set("0127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("4:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int8]net.IP", v.Type()) @@ -9854,17 +9854,17 @@ func TestInt16IPMapValue(t *testing.T) { v := newInt16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3127.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("7:127.0.0.1") assert.Nil(t, err) - err = v.Set("5127.0.0.3") + err = v.Set("4127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("7:127.0.0.3") + err = v.Set("3:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IP", v.Type()) @@ -9880,7 +9880,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.3") assert.NotNil(t, err) - err = v.Set("4: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[int16]net.IP", v.Type()) @@ -9895,17 +9895,17 @@ func TestInt32IPMapValue(t *testing.T) { v := newInt32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.0.0.1") + err = v.Set("3127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("5:127.0.0.1") + err = v.Set("0:127.0.0.1") assert.Nil(t, err) - err = v.Set("4127.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("5:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]net.IP", v.Type()) @@ -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("5127.0.0.1.3") + err = v.Set("6127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("3: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("2127.0.0.1") + err = v.Set("0127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("1:127.0.0.1") + err = v.Set("4:127.0.0.1") assert.Nil(t, err) 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("4:127.0.0.3") + err = v.Set("1:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int64]net.IP", v.Type()) @@ -9958,11 +9958,11 @@ func TestInt64IPMapValue(t *testing.T) { v := newInt64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0127.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("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("6127.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("6: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("0: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[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("1127.0.0.1.3") + err = v.Set("2127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("3: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[uint]net.IP", v.Type()) @@ -10018,13 +10018,13 @@ func TestUint8IPMapValue(t *testing.T) { v := newUint8IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7127.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("6: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) @@ -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("4127.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("4:127.0.0.1.3") + err = v.Set("2:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("7127.0.0.1") + err = v.Set("4127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("1:127.0.0.1") + err = v.Set("6:127.0.0.1") assert.Nil(t, err) - err = v.Set("6127.0.0.3") + err = v.Set("5127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("6:127.0.0.3") + err = v.Set("7:127.0.0.3") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]net.IP", v.Type()) @@ -10081,11 +10081,11 @@ func TestUint16IPMapValue(t *testing.T) { v := newUint16IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4127.0.0.1.3") + err = v.Set("5127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("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[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("2127.0.0.1") + err = v.Set("4127.0.0.1") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1") assert.NotNil(t, err) - err = v.Set("1:127.0.0.1") + err = v.Set("3:127.0.0.1") assert.Nil(t, err) - err = v.Set("4127.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[uint32]net.IP", v.Type()) @@ -10122,11 +10122,11 @@ func TestUint32IPMapValue(t *testing.T) { v := newUint32IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("1127.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("7:127.0.0.1.3") + err = v.Set("2:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]net.IP", v.Type()) @@ -10141,17 +10141,17 @@ func TestUint64IPMapValue(t *testing.T) { v := newUint64IPMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0127.0.0.1") + err = v.Set("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("2:127.0.0.1") assert.Nil(t, err) - err = v.Set("2127.0.0.3") + err = v.Set("7127.0.0.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.3") assert.NotNil(t, err) - err = v.Set("2: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[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("2127.0.0.1.3") + err = v.Set("7127.0.0.1.3") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":127.0.0.1.3") assert.NotNil(t, err) - err = v.Set("2:127.0.0.1.3") + err = v.Set("1:127.0.0.1.3") assert.EqualError(t, err, "failed to parse IP: \"127.0.0.1.3\"") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("ABWyoff") + err = v.Set("WjNXoff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("RJNHB:ff") + err = v.Set("xOWtq:ff") assert.Nil(t, err) - err = v.Set("KJFGmaa") + err = v.Set("MBoKnaa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("mnere:aa") + err = v.Set("mQySg: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("QMMMPgg") + err = v.Set("cKukagg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("iPFfK:gg") + err = v.Set("PXZLX: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("6ff") + err = v.Set("1ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("6:ff") + err = v.Set("0: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("4:aa") + err = v.Set("7: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("2gg") + err = v.Set("4gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("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[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("6ff") + err = v.Set("1ff") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":ff") assert.NotNil(t, err) - err = v.Set("7:ff") + err = v.Set("1: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("5:aa") + err = v.Set("6: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("3gg") + err = v.Set("1gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("5:gg") + err = v.Set("4:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("2ff") + 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("7:ff") + err = v.Set("2:ff") assert.Nil(t, err) - err = v.Set("1aa") + 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("7: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,11 +10512,11 @@ func TestInt16HexBytesMapValue(t *testing.T) { v := newInt16HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("5:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]HexBytes", v.Type()) @@ -10531,17 +10531,17 @@ func TestInt32HexBytesMapValue(t *testing.T) { v := newInt32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2ff") + 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") + err = v.Set("5:ff") assert.Nil(t, err) - err = v.Set("5aa") + 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("5:aa") + err = v.Set("1:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]HexBytes", v.Type()) @@ -10553,7 +10553,7 @@ func TestInt32HexBytesMapValue(t *testing.T) { v := newInt32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("5gg") + err = v.Set("7gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) @@ -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("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("7:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("1aa") + 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("4: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("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("7: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[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("5ff") + 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("2:ff") + err = v.Set("6:ff") assert.Nil(t, err) - err = v.Set("3aa") + err = v.Set("0aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("6:aa") + err = v.Set("3:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint]HexBytes", v.Type()) @@ -10635,7 +10635,7 @@ func TestUintHexBytesMapValue(t *testing.T) { v := newUintHexBytesMapValue(&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) @@ -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("5ff") + 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("7:ff") + err = v.Set("3:ff") assert.Nil(t, err) err = v.Set("7aa") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":aa") assert.NotNil(t, err) - err = v.Set("6:aa") + err = v.Set("7: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("5gg") + err = v.Set("6gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("1:gg") + err = v.Set("7:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("2:ff") + err = v.Set("7:ff") assert.Nil(t, err) - err = v.Set("5aa") + 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("0: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("6gg") + err = v.Set("4gg") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":gg") assert.NotNil(t, err) - err = v.Set("5:gg") + err = v.Set("0:gg") assert.EqualError(t, err, "encoding/hex: invalid byte: U+0067 'g'") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint16]HexBytes", v.Type()) @@ -10736,17 +10736,17 @@ func TestUint32HexBytesMapValue(t *testing.T) { v := newUint32HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2ff") + err = v.Set("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("2:ff") assert.Nil(t, err) - err = v.Set("0aa") + 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("1:aa") + err = v.Set("3: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("6gg") 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("2: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("4ff") + 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("5: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("5:aa") + err = v.Set("3:aa") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]HexBytes", v.Type()) @@ -10799,11 +10799,11 @@ func TestUint64HexBytesMapValue(t *testing.T) { v := newUint64HexBytesMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6gg") + err = v.Set("1gg") 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("CDpUTabc.*") + err = v.Set("UiAIbabc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("ysOwM:abc.*") + err = v.Set("wLRMC:abc.*") assert.Nil(t, err) - err = v.Set("nwZIsxyz.*") + err = v.Set("HokCexyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("pUbMr:xyz.*") + err = v.Set("AktfY: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("IaMKg[abc") + err = v.Set("ezNXi[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("Wwbwj:[abc") + err = v.Set("jFqCQ:[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("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("2:abc.*") + err = v.Set("6:abc.*") assert.Nil(t, err) - err = v.Set("7xyz.*") + 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("5:xyz.*") + err = v.Set("2: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("1[abc") + err = v.Set("0[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("2:[abc") + err = v.Set("6:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]*regexp.Regexp", v.Type()) @@ -11065,17 +11065,17 @@ func TestInt8RegexpMapValue(t *testing.T) { v := newInt8RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0abc.*") + 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("1:abc.*") assert.Nil(t, err) - err = v.Set("0xyz.*") + 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("2:xyz.*") + err = v.Set("0: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("7[abc") + err = v.Set("3[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("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[int8]*regexp.Regexp", v.Type()) @@ -11106,13 +11106,13 @@ func TestInt16RegexpMapValue(t *testing.T) { v := newInt16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("6:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("5xyz.*") + err = v.Set("4xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -11128,11 +11128,11 @@ func TestInt16RegexpMapValue(t *testing.T) { v := newInt16RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6[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("3:[abc") + err = v.Set("4:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]*regexp.Regexp", v.Type()) @@ -11147,13 +11147,13 @@ func TestInt32RegexpMapValue(t *testing.T) { v := newInt32RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("3abc.*") + err = v.Set("1abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("4:abc.*") + err = v.Set("7:abc.*") assert.Nil(t, err) - err = v.Set("3xyz.*") + err = v.Set("6xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -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("5[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("7:[abc") + err = v.Set("5:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int32]*regexp.Regexp", v.Type()) @@ -11188,17 +11188,17 @@ func TestInt64RegexpMapValue(t *testing.T) { v := newInt64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("6abc.*") + err = v.Set("5abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("5:abc.*") + err = v.Set("4:abc.*") assert.Nil(t, err) - err = v.Set("0xyz.*") + err = v.Set("2xyz.*") 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("1: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("4[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("6:[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[int64]*regexp.Regexp", v.Type()) @@ -11229,13 +11229,13 @@ func TestUintRegexpMapValue(t *testing.T) { v := newUintRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("2abc.*") + err = v.Set("6abc.*") 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("3:abc.*") assert.Nil(t, err) - err = v.Set("4xyz.*") + err = v.Set("7xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -11251,7 +11251,7 @@ func TestUintRegexpMapValue(t *testing.T) { v := newUintRegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("7[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) @@ -11270,13 +11270,13 @@ func TestUint8RegexpMapValue(t *testing.T) { v := newUint8RegexpMapValue(&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("5:abc.*") + err = v.Set("2:abc.*") assert.Nil(t, err) - err = v.Set("5xyz.*") + err = v.Set("0xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) @@ -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("4[abc") + err = v.Set("2[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("3:[abc") + err = v.Set("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("5abc.*") + err = v.Set("1abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("5:abc.*") + err = v.Set("4: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[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("7[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("4:[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("3abc.*") + err = v.Set("1abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) err = v.Set("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("6:xyz.*") + err = v.Set("4: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("3[abc") + err = v.Set("0[abc") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":[abc") assert.NotNil(t, err) - err = v.Set("2:[abc") + err = v.Set("3:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint32]*regexp.Regexp", v.Type()) @@ -11393,17 +11393,17 @@ func TestUint64RegexpMapValue(t *testing.T) { v := newUint64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("0abc.*") + err = v.Set("5abc.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":abc.*") assert.NotNil(t, err) - err = v.Set("3:abc.*") + err = v.Set("6:abc.*") assert.Nil(t, err) - err = v.Set("3xyz.*") + err = v.Set("4xyz.*") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":xyz.*") assert.NotNil(t, err) - err = v.Set("6:xyz.*") + err = v.Set("3:xyz.*") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]*regexp.Regexp", v.Type()) @@ -11415,11 +11415,11 @@ func TestUint64RegexpMapValue(t *testing.T) { v := newUint64RegexpMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("4[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("6:[abc") + err = v.Set("5:[abc") assert.EqualError(t, err, "error parsing regexp: missing closing ]: `[abc`") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("GMqSh0.0.0.0/0") + err = v.Set("FMUiB0.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("BXpUO:0.0.0.0/0") + err = v.Set("URLpf:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("xbIVx255.255.255.255/19") + err = v.Set("GDCxB255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("GHLzG:255.255.255.255/19") + err = v.Set("AjRnv: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("DXcEz0.0.0.256/16") + err = v.Set("jtsGD0.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") - err = v.Set("SMSwS:0.0.0.256/16") + err = v.Set("UbvdA: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("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("3:0.0.0.0/0") + err = v.Set("6: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("6:255.255.255.255/19") + err = v.Set("5:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("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("5:0.0.0.256/16") + err = v.Set("3:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int]net.IPNet", v.Type()) @@ -11813,17 +11813,17 @@ func TestInt8IPNetMapValue(t *testing.T) { v := newInt8IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("50.0.0.0/0") + err = v.Set("10.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("6:0.0.0.0/0") + err = v.Set("1:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("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("5:255.255.255.255/19") + err = v.Set("4:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("70.0.0.256/16") + err = v.Set("30.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) @@ -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("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("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("2255.255.255.255/19") + err = v.Set("1255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("7:255.255.255.255/19") + err = v.Set("0: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("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("1:0.0.0.256/16") + err = v.Set("7:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[int16]net.IPNet", v.Type()) @@ -11899,13 +11899,13 @@ func TestInt32IPNetMapValue(t *testing.T) { 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("2:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("0255.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("0: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("60.0.0.256/16") + err = v.Set("10.0.0.256/16") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.256/16") assert.NotNil(t, err) - err = v.Set("1: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[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("20.0.0.0/0") + err = v.Set("10.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("5:0.0.0.0/0") + err = v.Set("6:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("4255.255.255.255/19") + err = v.Set("3255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - err = v.Set("3:255.255.255.255/19") + err = v.Set("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,11 +11958,11 @@ func TestInt64IPNetMapValue(t *testing.T) { v := newInt64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("7: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[int64]net.IPNet", v.Type()) @@ -11981,13 +11981,13 @@ func TestUintIPNetMapValue(t *testing.T) { 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("0:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("7255.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("7: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("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) - err = v.Set("6:0.0.0.256/16") + err = v.Set("4:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("20.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("3:0.0.0.0/0") + err = v.Set("7:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("6255.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("5:255.255.255.255/19") + err = v.Set("4:255.255.255.255/19") assert.Nil(t, err) assert.Equal(t, a, v.Get()) assert.Equal(t, "map[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("00.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("4: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[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("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("2:0.0.0.0/0") assert.Nil(t, err) - err = v.Set("4255.255.255.255/19") + err = v.Set("0255.255.255.255/19") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":255.255.255.255/19") assert.NotNil(t, err) - 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[uint16]net.IPNet", v.Type()) @@ -12081,7 +12081,7 @@ func TestUint16IPNetMapValue(t *testing.T) { v := newUint16IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("20.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) @@ -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("00.0.0.0/0") + err = v.Set("20.0.0.0/0") assert.EqualError(t, err, "invalid map flag syntax, use -map=key1:val1") err = v.Set(":0.0.0.0/0") assert.NotNil(t, err) - err = v.Set("6:0.0.0.0/0") + err = v.Set("2: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("6: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[uint32]net.IPNet", v.Type()) @@ -12122,11 +12122,11 @@ func TestUint32IPNetMapValue(t *testing.T) { v := newUint32IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("00.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("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[uint32]net.IPNet", v.Type()) @@ -12141,17 +12141,17 @@ func TestUint64IPNetMapValue(t *testing.T) { v := newUint64IPNetMapValue(&a) assert.Equal(t, parseGeneratedMap(&a), v) assert.True(t, v.IsCumulative()) - err = v.Set("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("2: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("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[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("00.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("1:0.0.0.256/16") + err = v.Set("7:0.0.0.256/16") assert.EqualError(t, err, "invalid CIDR address: 0.0.0.256/16") assert.Equal(t, a, v.Get()) assert.Equal(t, "map[uint64]net.IPNet", v.Type())