1705 lines
41 KiB
Go
1705 lines
41 KiB
Go
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)
|
|
}
|
|
}
|