tamtam-vagrant-reload 1.1.2 → 1.2.1

data/vendor/cache/vagrant-2092df529ae7/internal/flags/flag_test.go

@@ -0,0 +1,1704 @@
+package flags
+
+import (
+	"errors"
+	"os"
+	"testing"
+)
+
+func testSet() *Set {
+	return NewSet("testing-set")
+}
+
+func testGroup() *Group {
+	return testSet().DefaultGroup()
+}
+
+func testFlag(g *Group) *Flag {
+	return newFlag("test-flag", StringType, g)
+}
+
+func Test_newFlag(t *testing.T) {
+	g := testGroup()
+	f := newFlag("my-flag", StringType, g)
+	if f.longName != "my-flag" {
+		t.Errorf("invalid name - my-flag != %s", f.longName)
+	}
+	if f.kind != StringType {
+		t.Errorf("invalid kind - String != %s", f.kind.String())
+	}
+	if f.called {
+		t.Errorf("invalid called - true != false")
+	}
+	if f.group != g {
+		t.Errorf("invalid group - %v != %v", g, f.group)
+	}
+	if f.envVar != "" {
+		t.Errorf("invalid envVar - \"\" != %s", f.envVar)
+	}
+	if f.hidden {
+		t.Errorf("invalid hidden - true != false")
+	}
+	if f.ptr {
+		t.Errorf("invalid ptr - true != false")
+	}
+	if f.required {
+		t.Errorf("invalid required - true != false")
+	}
+	if f.shortName != 0 {
+		t.Errorf("invalid shortName - 0 != %d", f.shortName)
+	}
+	if f.subkind != UnsetType {
+		t.Errorf("invalid subkind - %s != %s", UnsetType.String(), f.subkind.String())
+	}
+	if f.updated {
+		t.Errorf("invalid updated - true != false")
+	}
+	if f.value != nil {
+		t.Errorf("invalid value - nil != %v", f.value)
+	}
+}
+
+func Test_Alias(t *testing.T) {
+	f := testFlag(testGroup())
+	aliases := []string{"your-flag", "their-flag"}
+	fn := Alias(aliases...)
+	fn(f)
+	if len(f.aliases) != len(aliases) {
+		t.Errorf("invalid aliases - %v != %v", aliases, f.aliases)
+	}
+	for i, a := range aliases {
+		if a != f.aliases[i] {
+			t.Errorf("invalid alias @ %d - %v != %v", i, a, f.aliases[i])
+		}
+	}
+}
+
+func Test_Required(t *testing.T) {
+	f := testFlag(testGroup())
+	f.required = false
+	fn := Required()
+	fn(f)
+	if !f.required {
+		t.Errorf("invalid required - false != true")
+	}
+}
+
+func Test_Optional(t *testing.T) {
+	f := testFlag(testGroup())
+	f.required = true
+	fn := Optional()
+	fn(f)
+	if f.required {
+		t.Errorf("invalid required - true != false")
+	}
+}
+
+func Test_Hidden(t *testing.T) {
+	f := testFlag(testGroup())
+	f.hidden = false
+	fn := Hidden()
+	fn(f)
+	if !f.hidden {
+		t.Errorf("invalid hidden - false != true")
+	}
+}
+
+func Test_DefaultValue(t *testing.T) {
+	f := testFlag(testGroup())
+	v := "my default value"
+	fn := DefaultValue(v)
+	fn(f)
+	if f.defaultValue != v {
+		t.Errorf("invalid default value - %s != %s", v, f.defaultValue)
+	}
+}
+
+func Test_DefaultValue_invalid_type(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("panic expected but did not occur")
+		}
+	}()
+	f := testFlag(testGroup())
+	f.kind = IntegerType
+	v := "my default value"
+	fn := DefaultValue(v)
+	fn(f)
+}
+
+func Test_EnvVar(t *testing.T) {
+	f := testFlag(testGroup())
+	v := "MY_VAR"
+	fn := EnvVar(v)
+	fn(f)
+	if f.envVar != v {
+		t.Errorf("invalid env var - %s != %s", v, f.envVar)
+	}
+}
+
+func Test_ShortName(t *testing.T) {
+	f := testFlag(testGroup())
+	fn := ShortName('t')
+	fn(f)
+	if f.shortName != 't' {
+		t.Fatalf("invalid shortName - t != %c", f.shortName)
+	}
+}
+
+func Test_Subtype(t *testing.T) {
+	f := testFlag(testGroup())
+	fn := SetSubtype(IntegerType)
+	fn(f)
+	if f.subkind != IntegerType {
+		t.Errorf("invalid subkind - %s != %s", IntegerType.String(), f.subkind.String())
+	}
+}
+
+func Test_AddProcessor(t *testing.T) {
+	f := testFlag(testGroup())
+	AddProcessor(func(f *Flag, v interface{}) (interface{}, error) {
+		return v.(string) + "-modified", nil
+	})(f)
+	if err := f.setValue("test-value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value() != "test-value-modified" {
+		t.Errorf("invalid value - test-value-modified != %#v", f.Value())
+	}
+}
+
+func Test_AddProcessor_error(t *testing.T) {
+	f := testFlag(testGroup())
+	AddProcessor(func(f *Flag, v interface{}) (interface{}, error) {
+		return nil, errors.New("processor error")
+	})(f)
+	if err := f.setValue("test-value"); err == nil {
+		t.Errorf("expected error but no error returned")
+	}
+}
+
+func Test_AddCallback(t *testing.T) {
+	f := testFlag(testGroup())
+	mark := false
+	AddCallback(func(f *Flag) error {
+		mark = true
+		return nil
+	})(f)
+	if err := f.setValue("test-value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if !mark {
+		t.Errorf("callback did not set mark")
+	}
+}
+
+func Test_AddCallback_error(t *testing.T) {
+	f := testFlag(testGroup())
+	AddCallback(func(f *Flag) error {
+		return errors.New("callback error")
+	})(f)
+	if err := f.setValue("test-value"); err == nil {
+		t.Errorf("expected error but no error returned")
+	}
+}
+
+func Test_customVar(t *testing.T) {
+	var v string
+	f := testFlag(testGroup())
+	fn := customVar(&v)
+	fn(f)
+	tv := "custom-test-value"
+	f.setValue(tv)
+	if f.Value() != tv {
+		t.Errorf("invalid value - %s != %s", tv, f.Value())
+	}
+}
+
+func Test_Flag_Aliases(t *testing.T) {
+	f := testFlag(testGroup())
+	if len(f.Aliases()) != 0 {
+		t.Errorf("invalid Aliases length - 0 != %d", len(f.Aliases()))
+	}
+	f.aliases = []string{"my-alias"}
+	if len(f.Aliases()) != 1 {
+		t.Fatalf("invalid Aliases length - 1 != %d", len(f.Aliases()))
+	}
+	if f.aliases[0] != "my-alias" {
+		t.Errorf("invalid Aliases entry - my-aliase != %s", f.aliases[0])
+	}
+}
+
+func Test_Flag_Called(t *testing.T) {
+	f := testFlag(testGroup())
+	if f.Called() {
+		t.Errorf("invalid Called - true != false")
+	}
+	f.called = true
+	if !f.Called() {
+		t.Errorf("invalid Called - false != true")
+	}
+}
+
+func Test_Flag_DefaultValue(t *testing.T) {
+	f := testFlag(testGroup())
+	val := "test-default-value"
+	f.defaultValue = val
+	if f.DefaultValue() != val {
+		t.Errorf("invalid DefaultValue - %s != %s", val, f.DefaultValue())
+	}
+}
+
+func Test_Flag_EnvVar(t *testing.T) {
+	f := testFlag(testGroup())
+	val := "TEST_ENV_VAR"
+	f.envVar = val
+	if f.EnvVar() != val {
+		t.Errorf("invalid EnvVar - %s != %s", val, f.EnvVar())
+	}
+}
+
+func Test_Flag_Group(t *testing.T) {
+	g := testGroup()
+	f := testFlag(g)
+	if f.Group() != g {
+		t.Errorf("invalid Group - %#v != %#v", g, f.Group())
+	}
+}
+
+func Test_Flag_Hidden(t *testing.T) {
+	f := testFlag(testGroup())
+	if f.Hidden() {
+		t.Errorf("invalid Hidden - true != false")
+	}
+	f.hidden = true
+	if !f.Hidden() {
+		t.Errorf("invalid Hidden - false != true")
+	}
+}
+
+func Test_Flag_LongName(t *testing.T) {
+	f := testFlag(testGroup())
+	if f.LongName() != f.longName {
+		t.Errorf("invalid LongName - %s != %s", f.longName, f.LongName())
+	}
+}
+
+func Test_Flag_Required(t *testing.T) {
+	f := testFlag(testGroup())
+	if f.Required() {
+		t.Errorf("invalid Required - true != false")
+	}
+	f.required = true
+	if !f.Required() {
+		t.Errorf("invalid Required - false != true")
+	}
+}
+
+func Test_Flag_ShortName(t *testing.T) {
+	f := testFlag(testGroup())
+	if f.ShortName() != 0 {
+		t.Errorf("invalid ShortName - 0 != %d", f.ShortName())
+	}
+	f.shortName = 't'
+	if f.ShortName() != 't' {
+		t.Errorf("invalid ShortName - t != %c", f.ShortName())
+	}
+}
+
+func Test_Flag_Updated(t *testing.T) {
+	f := testFlag(testGroup())
+	if f.Updated() {
+		t.Errorf("invalid Updated - true != false")
+	}
+	f.updated = true
+	if !f.Updated() {
+		t.Errorf("invalid Updated - false != true")
+	}
+}
+
+func Test_Flag_Value(t *testing.T) {
+	f := testFlag(testGroup())
+	val := "test-val"
+	f.value = val
+	if f.Value() != val {
+		t.Errorf("invalid Value - %s != %s", val, f.Value())
+	}
+}
+
+func Test_Flag_Value_Boolean(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = BooleanType
+	f.value = true
+	if f.Value() != true {
+		t.Errorf("invalid Value - false != true")
+	}
+	f.value = false
+	if f.Value() != false {
+		t.Errorf("invalid Value - true != false")
+	}
+}
+
+func Test_Flag_Value_Float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = FloatType
+	f.value = 3.4
+	if f.Value() != 3.4 {
+		t.Errorf("invalid Value - 3.4 != %f", f.Value())
+	}
+}
+
+func Test_Flag_Value_String(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = IntegerType
+	f.value = 10
+	if f.Value() != 10 {
+		t.Errorf("invalid Value - 10 != %d", f.Value())
+	}
+}
+
+func Test_Flag_markCalled(t *testing.T) {
+	f := testFlag(testGroup())
+	f.markCalled("test-flag")
+	if f.matchedName != "test-flag" {
+		t.Errorf("invalid matchedName - test-flag != %s", f.matchedName)
+	}
+	if !f.updated {
+		t.Errorf("invalid updated - true != false")
+	}
+	if !f.called {
+		t.Errorf("invalid called - true != false")
+	}
+}
+
+func Test_Flag_markCalled_invalid(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("panic expected but did not occur")
+		}
+	}()
+	f := testFlag(testGroup())
+	f.markCalled("invalid-name")
+}
+
+func Test_Flag_markCalled_short(t *testing.T) {
+	f := testFlag(testGroup())
+	f.shortName = 't'
+	f.markCalled("t")
+	if !f.called {
+		t.Errorf("invalid called - true != false")
+	}
+}
+
+func Test_Flag_markCalled_alias(t *testing.T) {
+	f := testFlag(testGroup())
+	f.aliases = []string{"otherflag", "real-name"}
+	f.markCalled("real-name")
+	if !f.called {
+		t.Errorf("invalid called - true != false")
+	}
+}
+
+func Test_Flag_init(t *testing.T) {
+	f := testFlag(testGroup())
+	err := f.init()
+	if err != nil {
+		t.Errorf("unexpected error: %s", err)
+	}
+	if f.value != "" {
+		t.Errorf("invalid value - empty string != %#v", f.value)
+	}
+}
+
+func Test_Flag_init_used(t *testing.T) {
+	f := testFlag(testGroup())
+	f.updated = true
+	err := f.init()
+	if err == nil {
+		t.Error("expected error but did not occur")
+	}
+}
+
+func Test_Flag_init_array_bool(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = BooleanType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.([]bool); !ok {
+		t.Errorf("invalid value - []bool != %T", f.value)
+	}
+}
+
+func Test_Flag_init_array_float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = FloatType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.([]float64); !ok {
+		t.Errorf("invalid value - []float64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_array_integer(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = IntegerType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.([]int64); !ok {
+		t.Errorf("invalid value - []int64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_array_string(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = StringType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.([]string); !ok {
+		t.Errorf("invalid value - []string != %T", f.value)
+	}
+}
+
+func Test_Flag_init_boolean(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = BooleanType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(bool); !ok {
+		t.Errorf("invalid value - bool != %T", f.value)
+	}
+}
+
+func Test_Flag_init_float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = FloatType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(float64); !ok {
+		t.Errorf("invalid value - float64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_increment(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = IncrementType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(int64); !ok {
+		t.Errorf("invalid value - int64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_integer(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = IntegerType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(int64); !ok {
+		t.Errorf("invalid value - int64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_map_bool(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = BooleanType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(map[string]bool); !ok {
+		t.Errorf("invalid value - map[string]bool != %T", f.value)
+	}
+}
+
+func Test_Flag_init_map_float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = FloatType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(map[string]float64); !ok {
+		t.Errorf("invalid value - map[string]float64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_map_integer(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = IntegerType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(map[string]int64); !ok {
+		t.Errorf("invalid value - map[string]int64 != %T", f.value)
+	}
+}
+
+func Test_Flag_init_map_string(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = StringType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(map[string]string); !ok {
+		t.Errorf("invalid value - map[string]string != %T", f.value)
+	}
+}
+
+func Test_Flag_init_string(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = StringType
+	err := f.init()
+	if err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if _, ok := f.value.(string); !ok {
+		t.Errorf("invalid value - string != %T", f.value)
+	}
+}
+
+func Test_Flag_init_map_invalid(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("panic expected but did not occur")
+		}
+	}()
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = ArrayType
+	f.init()
+}
+
+func Test_Flag_init_array_invalid(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("panic expected but did not occur")
+		}
+	}()
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = MapType
+	f.init()
+}
+
+func Test_Flag_init_envVar(t *testing.T) {
+	defer func() {
+		os.Setenv("FLAG_ENV_TEST", "")
+	}()
+	f := testFlag(testGroup())
+	f.envVar = "FLAG_ENV_TEST"
+	val := "env-test-value"
+	if err := os.Setenv("FLAG_ENV_TEST", val); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.init(); err != nil {
+		t.Errorf("unexpected error: %s", err)
+	}
+	if f.value != val {
+		t.Errorf("invalid value - %s != %s", val, f.value)
+	}
+}
+
+func Test_Flag_setValue_array_bool(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = BooleanType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("true"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]bool)
+	if !ok {
+		t.Errorf("invalid value type - []bool != %T", f.Value())
+	}
+	if !v[0] {
+		t.Errorf("invalid array value - true != false")
+	}
+}
+
+func Test_Flag_setValue_array_bool_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = BooleanType
+	val := []bool{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("true"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]bool)
+	if !ok {
+		t.Errorf("invalid value type - []bool != %T", f.Value())
+	}
+	if !v[0] {
+		t.Errorf("invalid array value - true != false")
+	}
+	if !val[0] {
+		t.Errorf("invalid array value - true != false")
+	}
+}
+
+func Test_Flag_setValue_array_bool_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = BooleanType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("true"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("false"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]bool)
+	if !ok {
+		t.Errorf("invalid value type - []bool != %T", f.Value())
+	}
+	if !v[0] {
+		t.Errorf("invalid array value - true != false")
+	}
+	if v[1] {
+		t.Errorf("invalid array value - false != true")
+	}
+}
+
+func Test_Flag_setValue_array_bool_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = BooleanType
+	val := []bool{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("true"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("false"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]bool)
+	if !ok {
+		t.Errorf("invalid value type - []bool != %T", f.Value())
+	}
+	if !v[0] {
+		t.Errorf("invalid array value - true != false")
+	}
+	if v[1] {
+		t.Errorf("invalid array value - false != true")
+	}
+	if !val[0] {
+		t.Errorf("invalid array value - true != false")
+	}
+	if val[1] {
+		t.Errorf("invalid array value - false != true")
+	}
+}
+
+func Test_Flag_setValue_array_float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = FloatType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("4.2"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]float64)
+	if !ok {
+		t.Errorf("invalid value type - []float64 != %T", f.Value())
+	}
+	if v[0] != 4.2 {
+		t.Errorf("invalid array value - 4.2 != %#v", v[0])
+	}
+}
+
+func Test_Flag_setValue_array_float_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = FloatType
+	val := []float64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("4.2"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]float64)
+	if !ok {
+		t.Errorf("invalid value type - []float64 != %T", f.Value())
+	}
+	if v[0] != 4.2 {
+		t.Errorf("invalid array value - 4.2 != %#v", v[0])
+	}
+	if val[0] != 4.2 {
+		t.Errorf("invalid array value - 4.2 != %#v", val[0])
+	}
+}
+
+func Test_Flag_setValue_array_float_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = FloatType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("4.2"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("10.5"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]float64)
+	if !ok {
+		t.Errorf("invalid value type - []float64 != %T", f.Value())
+	}
+	if v[0] != 4.2 {
+		t.Errorf("invalid array value - 4.2 != %#v", v[0])
+	}
+	if v[1] != 10.5 {
+		t.Errorf("invalid array value - 10.5 != %#v", v[1])
+	}
+}
+
+func Test_Flag_setValue_array_float_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = FloatType
+	val := []float64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("4.2"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("10.5"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]float64)
+	if !ok {
+		t.Errorf("invalid value type - []float64 != %T", f.Value())
+	}
+	if v[0] != 4.2 {
+		t.Errorf("invalid array value - 4.2 != %#v", v[0])
+	}
+	if v[1] != 10.5 {
+		t.Errorf("invalid array value - 10.5 != %#v", v[1])
+	}
+	if val[0] != 4.2 {
+		t.Errorf("invalid array value - 4.2 != %#v", val[0])
+	}
+	if val[1] != 10.5 {
+		t.Errorf("invalid array value - 10.5 != %#v", val[1])
+	}
+}
+
+func Test_Flag_setValue_array_integer(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = IntegerType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("100"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]int64)
+	if !ok {
+		t.Errorf("invalid value type - []int64 != %T", f.Value())
+	}
+	if v[0] != 100 {
+		t.Errorf("invalid array value - 100 != %#v", v[0])
+	}
+}
+
+func Test_Flag_setValue_array_integer_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = IntegerType
+	val := []int64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("100"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]int64)
+	if !ok {
+		t.Errorf("invalid value type - []int64 != %T", f.Value())
+	}
+	if v[0] != 100 {
+		t.Errorf("invalid array value - 100 != %#v", v[0])
+	}
+	if val[0] != 100 {
+		t.Errorf("invalid array value - 100 != %#v", val[0])
+	}
+}
+
+func Test_Flag_setValue_array_integer_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = IntegerType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("100"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("-22"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]int64)
+	if !ok {
+		t.Errorf("invalid value type - []int64 != %T", f.Value())
+	}
+	if v[0] != 100 {
+		t.Errorf("invalid array value - 100 != %#v", v[0])
+	}
+	if v[1] != -22 {
+		t.Errorf("invalid array value - -22 != %#v", v[1])
+	}
+}
+
+func Test_Flag_setValue_array_integer_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = IntegerType
+	val := []int64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("100"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("-22"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]int64)
+	if !ok {
+		t.Errorf("invalid value type - []int64 != %T", f.Value())
+	}
+	if v[0] != 100 {
+		t.Errorf("invalid array value - 100 != %#v", v[0])
+	}
+	if v[1] != -22 {
+		t.Errorf("invalid array value - -22 != %#v", v[1])
+	}
+	if val[0] != 100 {
+		t.Errorf("invalid array value - 100 != %#v", val[0])
+	}
+	if val[1] != -22 {
+		t.Errorf("invalid array value - -22 != %#v", val[1])
+	}
+}
+
+func Test_Flag_setValue_array_string(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = StringType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("test value"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]string)
+	if !ok {
+		t.Errorf("invalid value type - []string != %T", f.Value())
+	}
+	if v[0] != "test value" {
+		t.Errorf("invalid array value - test value != %#v", v[0])
+	}
+}
+
+func Test_Flag_setValue_array_string_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = StringType
+	val := []string{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("test value"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]string)
+	if !ok {
+		t.Errorf("invalid value type - []string != %T", f.Value())
+	}
+	if v[0] != "test value" {
+		t.Errorf("invalid array value - test value != %#v", v[0])
+	}
+	if val[0] != "test value" {
+		t.Errorf("invalid array value - test value != %#v", val[0])
+	}
+}
+
+func Test_Flag_setValue_array_string_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = StringType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("test value"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("second test value"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]string)
+	if !ok {
+		t.Errorf("invalid value type - []string != %T", f.Value())
+	}
+	if v[0] != "test value" {
+		t.Errorf("invalid array value - test value != %#v", v[0])
+	}
+	if v[1] != "second test value" {
+		t.Errorf("invalid array value - second test value != %#v", v[1])
+	}
+}
+
+func Test_Flag_setValue_array_string_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = ArrayType
+	f.subkind = StringType
+	val := []string{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("test value"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	if err := f.setValue("second test value"); err != nil {
+		t.Errorf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().([]string)
+	if !ok {
+		t.Errorf("invalid value type - []string != %T", f.Value())
+	}
+	if v[0] != "test value" {
+		t.Errorf("invalid array value - test value != %#v", v[0])
+	}
+	if v[1] != "second test value" {
+		t.Errorf("invalid array value - second test value != %#v", v[1])
+	}
+	if val[0] != "test value" {
+		t.Errorf("invalid array value - test value != %#v", val[0])
+	}
+	if val[1] != "second test value" {
+		t.Errorf("invalid array value - second test value != %#v", val[1])
+	}
+}
+
+func Test_Flag_setValue_map_bool(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = BooleanType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=true"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]bool)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]bool != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if !v["ack"] {
+		t.Errorf("invalid map value - true != false")
+	}
+}
+
+func Test_Flag_setValue_map_bool_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = BooleanType
+	val := map[string]bool{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=true"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]bool)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]bool != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if !v["ack"] {
+		t.Errorf("invalid map value - true != false")
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if !val["ack"] {
+		t.Errorf("invalid map value - true != false")
+	}
+}
+
+func Test_Flag_setValue_map_bool_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = BooleanType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=true"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=false"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]bool)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]bool != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if !v["ack"] {
+		t.Errorf("invalid map value - true != false")
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] {
+		t.Errorf("invalid map value - false != true")
+	}
+}
+
+func Test_Flag_setValue_map_bool_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = BooleanType
+	val := map[string]bool{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=true"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=false"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]bool)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]bool != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if !v["ack"] {
+		t.Errorf("invalid map value - true != false")
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] {
+		t.Errorf("invalid map value - false != true")
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if !val["ack"] {
+		t.Errorf("invalid map value - true != false")
+	}
+	if _, ok := val["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["bar"] {
+		t.Errorf("invalid map value - false != true")
+	}
+}
+
+func Test_Flag_setValue_map_float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = FloatType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2.2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]float64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]float64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2.2 {
+		t.Errorf("invalid map value - 2.2 != %#v", v["ack"])
+	}
+}
+
+func Test_Flag_setValue_map_float_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = FloatType
+	val := map[string]float64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2.2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]float64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]float64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2.2 {
+		t.Errorf("invalid map value - 2.2 != %#v", v["ack"])
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["ack"] != 2.2 {
+		t.Errorf("invalid map value - 2.2 != %#v", val["ack"])
+	}
+}
+
+func Test_Flag_setValue_map_float_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = FloatType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2.2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=10"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]float64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]float64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2.2 {
+		t.Errorf("invalid map value - 2.2 != %#v", v["ack"])
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] != 10 {
+		t.Errorf("invalid map value - 10 != %#v", v["bar"])
+	}
+}
+
+func Test_Flag_setValue_map_float_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = FloatType
+	val := map[string]float64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2.2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=10"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]float64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]float64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2.2 {
+		t.Errorf("invalid map value - 2.2 != %#v", v["ack"])
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] != 10 {
+		t.Errorf("invalid map value - 10 != %#v", v["bar"])
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["ack"] != 2.2 {
+		t.Errorf("invalid map value - 2.2 != %#v", val["ack"])
+	}
+	if _, ok := val["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["bar"] != 10 {
+		t.Errorf("invalid map value - 10 != %#v", val["bar"])
+	}
+}
+
+func Test_Flag_setValue_map_integer(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = IntegerType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]int64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]int64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2 {
+		t.Errorf("invalid map value - 2 != %#v", v["ack"])
+	}
+}
+
+func Test_Flag_setValue_map_integer_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = IntegerType
+	val := map[string]int64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]int64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]int64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2 {
+		t.Errorf("invalid map value - 2 != %#v", v["ack"])
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["ack"] != 2 {
+		t.Errorf("invalid map value - 2 != %#v", val["ack"])
+	}
+}
+
+func Test_Flag_setValue_map_integer_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = IntegerType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=10"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]int64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]int64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2 {
+		t.Errorf("invalid map value - 2 != %#v", v["ack"])
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] != 10 {
+		t.Errorf("invalid map value - 10 != %#v", v["bar"])
+	}
+}
+
+func Test_Flag_setValue_map_integer_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = IntegerType
+	val := map[string]int64{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=10"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]int64)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]float64 != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != 2 {
+		t.Errorf("invalid map value - 2 != %#v", v["ack"])
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] != 10 {
+		t.Errorf("invalid map value - 10 != %#v", v["bar"])
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["ack"] != 2 {
+		t.Errorf("invalid map value - 2 != %#v", val["ack"])
+	}
+	if _, ok := val["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["bar"] != 10 {
+		t.Errorf("invalid map value - 10 != %#v", val["bar"])
+	}
+}
+
+func Test_Flag_setValue_map_string(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = StringType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=test value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]string)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]string != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != "test value" {
+		t.Errorf("invalid map value - test value != %#v", v["ack"])
+	}
+}
+
+func Test_Flag_setValue_map_string_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = StringType
+	val := map[string]string{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=test value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]string)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]string != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != "test value" {
+		t.Errorf("invalid map value - test value != %#v", v["ack"])
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["ack"] != "test value" {
+		t.Errorf("invalid map value - test value != %#v", val["ack"])
+	}
+}
+
+func Test_Flag_setValue_map_string_multi(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = StringType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=test value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=another thing"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]string)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]string != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != "test value" {
+		t.Errorf("invalid map value - test value != %#v", v["ack"])
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] != "another thing" {
+		t.Errorf("invalid map value - another thing != %#v", v["bar"])
+	}
+}
+
+func Test_Flag_setValue_map_string_multi_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = MapType
+	f.subkind = StringType
+	val := map[string]string{}
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("ack=test value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if err := f.setValue("bar=another thing"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	v, ok := f.Value().(map[string]string)
+	if !ok {
+		t.Fatalf("invalid value type - map[string]string != %T", f.Value())
+	}
+	if _, ok := v["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["ack"] != "test value" {
+		t.Errorf("invalid map value - test value != %#v", v["ack"])
+	}
+	if _, ok := v["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if v["bar"] != "another thing" {
+		t.Errorf("invalid map value - another thing != %#v", v["bar"])
+	}
+	if _, ok := val["ack"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["ack"] != "test value" {
+		t.Errorf("invalid map value - test value != %#v", val["ack"])
+	}
+	if _, ok := val["bar"]; !ok {
+		t.Fatalf("invalid map value - key does not exist")
+	}
+	if val["bar"] != "another thing" {
+		t.Errorf("invalid map value - another thing != %#v", val["bar"])
+	}
+}
+
+func Test_Flag_setValue_bool(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = BooleanType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("false"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(bool) {
+		t.Errorf("invalid value - false != true")
+	}
+	if err := f.setValue("true"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if !f.Value().(bool) {
+		t.Errorf("invalid value - true != false")
+	}
+}
+
+func Test_Flag_setValue_bool_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = BooleanType
+	var val bool
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("false"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(bool) {
+		t.Errorf("invalid value - false != true")
+	}
+	if val {
+		t.Errorf("invalid value - false != true")
+	}
+	if err := f.setValue("true"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if !f.Value().(bool) {
+		t.Errorf("invalid value - true != false")
+	}
+	if !val {
+		t.Errorf("invalid value - false != true")
+	}
+}
+
+func Test_Flag_setValue_float(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = FloatType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("2.2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(float64) != 2.2 {
+		t.Errorf("invalid value - 2.2 != %#v", f.Value())
+	}
+}
+
+func Test_Flag_setValue_float_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = FloatType
+	var val float64
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("2.2"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(float64) != 2.2 {
+		t.Errorf("invalid value - 2.2 != %#v", f.Value())
+	}
+	if val != 2.2 {
+		t.Errorf("invalid value - 2.2 != %#v", val)
+	}
+}
+
+func Test_Flag_setValue_increment(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = IncrementType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("1"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(int64) != 1 {
+		t.Errorf("invalid value - 1 != %#v", f.Value())
+	}
+	if err := f.setValue("1"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(int64) != 2 {
+		t.Errorf("invalid value - 2 != %#v", f.Value())
+	}
+}
+
+func Test_Flag_setValue_increment_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = IncrementType
+	var val int64
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("1"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(int64) != 1 {
+		t.Errorf("invalid value - 1 != %#v", f.Value())
+	}
+	if val != 1 {
+		t.Errorf("invalid value - 1 != %#v", val)
+	}
+	if err := f.setValue("1"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(int64) != 2 {
+		t.Errorf("invalid value - 2 != %#v", f.Value())
+	}
+	if val != 2 {
+		t.Errorf("invalid value - 2 != %#v", val)
+	}
+}
+
+func Test_Flag_setValue_string(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = StringType
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("test-value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(string) != "test-value" {
+		t.Errorf("invalid value - test-value != %#v", f.Value())
+	}
+}
+
+func Test_Flag_setValue_string_ptr(t *testing.T) {
+	f := testFlag(testGroup())
+	f.kind = StringType
+	var val string
+	customVar(&val)(f)
+	if err := f.init(); err != nil {
+		t.Fatalf("unexpected error: %s", err)
+	}
+	if err := f.setValue("test-value"); err != nil {
+		t.Fatalf("failed to set value: %s", err)
+	}
+	if f.Value().(string) != "test-value" {
+		t.Errorf("invalid value - test-value != %#v", f.Value())
+	}
+	if val != "test-value" {
+		t.Errorf("invalid value - test-value != %#v", val)
+	}
+}