diff --git a/README.md b/README.md index 23db482..9ce5ec2 100644 --- a/README.md +++ b/README.md @@ -62,8 +62,8 @@ Like parsing JSON object, using **json** keyword to define configuration name: type Database struct { Host string `json:"host"` Port int `json:"port"` - Username string `json:"username" default:"admin"` - Password string `json:"password" default:"admin"` + Username string `default:"admin" json:"username"` + Password string `default:"admin" json:"password"` Log Log `json:"log"` } ``` @@ -91,8 +91,8 @@ Like parsing Yaml object, using **yaml** keyword to define configuration name type Database struct { Host string `yaml:"host"` Port int `yaml:"port"` - Username string `yaml:"username" default:"admin"` - Password string `yaml:"password" default:"admin"` + Username string `default:"admin" yaml:"username"` + Password string `default:"admin" yaml:"password"` Log Log `yaml:"log"` } ``` @@ -117,8 +117,8 @@ Using **env** keyword to define configuration name type Database struct { Host string `env:"DB_HOST"` Port int `env:"DB_PORT"` - Username string `env:"DB_USER" default:"admin"` - Password string `env:"DB_PASSWORD" default:"admin"` + Username string `default:"admin" env:"DB_USER"` + Password string `default:"admin" env:"DB_PASSWORD"` Log Log `env:"DB_LOG_"` } ``` @@ -142,7 +142,7 @@ be used, that means the `Path` will be mapped to `PATH`. #### 6. Defines configuration name for Command line -Using **cli** keyword to define configuration name +Using **cli** keyword to define configuration name: ```golang type Database struct { @@ -154,19 +154,19 @@ Using **cli** keyword to define configuration name } ``` -For **cli** definition, the string before the first space is command line argument, -the rest string are the command line usage and will be outputted when printing usage +For **cli** definition, the string is command line argument, and the **usage** +tag are the command line usage and will be outputted when printing usage. Corresponding command line: ```shell - ./main -host test.db.hostname -port 8080 -username admin -password admin log -path /var/logs/db -level debug + ./main --host test.db.hostname --port 8080 --username admin --password admin --log-path /var/logs/db --log-level debug ``` or ```shell - ./main -host=test.db.hostname -port=8080 -username=admin -password=admin log -path=/var/logs/db -level=debug + ./main --host=test.db.hostname --port=8080 --username=admin --password=admin --log-path=/var/logs/db --log-level=debug ``` #### 7. Defines configuration name as a slice type @@ -175,12 +175,12 @@ Using **separator** to split string as a slice: ```golang type Log struct { - Levels []string `env:"LEVELS" cli:"levels log levels" separator:";"` + Levels []string `env:"LEVELS" cli:"levels" separator:";" usage:"log levels"` } ``` If the separator is not given, its default is **:**, The separator only works on -**env** and **cli** tags +**env** and **cli** tags. ```golang logConfig := Log{} @@ -271,16 +271,16 @@ Examples: ```golang type Log struct { - Path string `json:"path" yaml:"path" env:"PATH" cli:"path log path" default:"/var/logs"` - Levels string `json:"levels" yaml:"levels" env:"LEVELS" cli:"levels log levels" default:"debug;error"` + Path string `cli:"path" default:"/var/logs" env:"PATH" json:"path" usage:"log path" yaml:"path"` + Levels string `cli:"levels" default:"debug;error" env:"LEVELS" json:"levels" usage:"log levels" yaml:"levels"` } type Database struct { - Host string `json:"host" yaml:"host" env:"DB_HOST" cli:"host database host name"` - Port int `json:"port" yaml:"port" env:"DB_PORT" cli:"port database port"` - Username string `json:"user" yaml" user" env:"DB_USER" cli:"username database username" default:"admin"` - Password string `json:"passwd" yaml:"passwd" env:"DB_PASSWD" cli:"password database password" default:"admin"` - Log Log `json:"log" yaml:"log" env:"DB_LOG_" cli:"log database log configurations"` + Host string `cli:"host" env:"DB_HOST" json:"host" usage:"database host name" yaml:"host"` + Port int `cli:"port" env:"DB_PORT" json:"port" usage:"database port" yaml:"port"` + Username string `cli:"username" default:"admin" env:"DB_USER" json:"user" usage:"database username" yaml" user"` + Password string `cli:"password" default:"admin" env:"DB_PASSWD" json:"passwd" usage:"database password" yaml:"passwd"` + Log Log `cli:"log" env:"DB_LOG_" json:"log" usage:"database log configurations" yaml:"log"` } ``` diff --git a/cli_test.go b/cli_test.go index 2eafb38..60e4a09 100644 --- a/cli_test.go +++ b/cli_test.go @@ -256,3 +256,5 @@ func TestCommandWithSlices(t *testing.T) { assert.Equal(200, conf.Values[1]) assert.Equal(300, conf.Values[2]) } + +func TestUsage(t *testing.T) {} diff --git a/config_test.go b/config_test.go index 498b361..f7c075f 100644 --- a/config_test.go +++ b/config_test.go @@ -43,27 +43,28 @@ func TestDefaultValueConfig(t *testing.T) { } func TestEnvConfig(t *testing.T) { - dbLogPrefix := "LOG_" - var err error + dbLogPrefix := "LOG_" + assert := assert.New(t) + err = os.Setenv("HOST", DB_HOST) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv("PORT", strconv.Itoa(DB_PORT)) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv("USER", DB_USER) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv("PASSWORD", DB_PASSWORD) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL) - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv("HOST") }() defer func() { _ = os.Unsetenv("PORT") }() @@ -73,13 +74,13 @@ func TestEnvConfig(t *testing.T) { defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }() conf := test.DBConfig{} - assert.NoError(t, ParseEnv(&conf)) - assert.Equal(t, DB_HOST, conf.Host) - assert.Equal(t, DB_PORT, conf.Port) - assert.Equal(t, DB_USER, conf.User) - assert.Equal(t, DB_PASSWORD, conf.Password) - assert.Equal(t, DB_LOG_PATH, conf.Log.Path) - assert.Equal(t, DB_LOG_LEVEL, conf.Log.Level) + assert.NoError(ParseEnv(&conf)) + assert.Equal(DB_HOST, conf.Host) + assert.Equal(DB_PORT, conf.Port) + assert.Equal(DB_USER, conf.User) + assert.Equal(DB_PASSWORD, conf.Password) + assert.Equal(DB_LOG_PATH, conf.Log.Path) + assert.Equal(DB_LOG_LEVEL, conf.Log.Level) } func TestJSONConfigFile(t *testing.T) { diff --git a/env_test.go b/env_test.go index 541ba3b..fedb65d 100644 --- a/env_test.go +++ b/env_test.go @@ -42,38 +42,42 @@ const ( func TestLoginConfigEnv(t *testing.T) { var err error + assert := assert.New(t) + err = os.Setenv("USER", LOGIN_USER) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv("PASSWORD", LOGIN_PASSWORD) - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv("USER") }() defer func() { _ = os.Unsetenv("PASSWORD") }() loginConfig := test.LoginConfig{} - assert.NoError(t, ParseEnv(&loginConfig)) + assert.NoError(ParseEnv(&loginConfig)) - assert.Equal(t, LOGIN_USER, loginConfig.User) - assert.Equal(t, LOGIN_PASSWORD, loginConfig.Password) + assert.Equal(LOGIN_USER, loginConfig.User) + assert.Equal(LOGIN_PASSWORD, loginConfig.Password) } func TestLoginConfigEnvWithPrefix(t *testing.T) { var err error + assert := assert.New(t) + err = os.Setenv("DB_USER", LOGIN_USER) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv("DB_PASSWORD", LOGIN_PASSWORD) - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv("DB_USER") }() defer func() { _ = os.Unsetenv("DB_PASSWORD") }() loginConfig := test.LoginConfig{} - assert.NoError(t, ParseEnvWith(&loginConfig, "DB_")) - assert.Equal(t, LOGIN_USER, loginConfig.User) - assert.Equal(t, LOGIN_PASSWORD, loginConfig.Password) + assert.NoError(ParseEnvWith(&loginConfig, "DB_")) + assert.Equal(LOGIN_USER, loginConfig.User) + assert.Equal(LOGIN_PASSWORD, loginConfig.Password) } func TestServiceConfigEnv(t *testing.T) { @@ -81,36 +85,37 @@ func TestServiceConfigEnv(t *testing.T) { serviceLogPrefix := servicePrefix + "LOG_" dbPrefix := servicePrefix + "DB_" dbLogPrefix := dbPrefix + "LOG_" + assert := assert.New(t) err := os.Setenv(servicePrefix+"HOST", SERVICE_HOST) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(servicePrefix+"PORT", strconv.Itoa(SERVICE_PORT)) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(serviceLogPrefix+"PATH", SERVICE_LOG_PATH) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(serviceLogPrefix+"LEVEL", SERVICE_LOG_LEVEL) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbPrefix+"HOST", DB_HOST) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbPrefix+"PORT", strconv.Itoa(DB_PORT)) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbPrefix+"USER", DB_USER) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbPrefix+"PASSWORD", DB_PASSWORD) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL) - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv(servicePrefix + "HOST") }() defer func() { _ = os.Unsetenv(servicePrefix + "PORT") }() @@ -124,85 +129,87 @@ func TestServiceConfigEnv(t *testing.T) { defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }() serviceConfig := test.ServiceConfig{} - assert.NoError(t, ParseEnv(&serviceConfig)) - assert.Equal(t, SERVICE_HOST, serviceConfig.Host) - assert.Equal(t, SERVICE_PORT, serviceConfig.Port) - assert.Equal(t, SERVICE_LOG_PATH, serviceConfig.Log.Path) - assert.Equal(t, SERVICE_LOG_LEVEL, serviceConfig.Log.Level) - assert.Equal(t, DB_HOST, serviceConfig.DBConfig.Host) - assert.Equal(t, DB_PORT, serviceConfig.DBConfig.Port) - assert.Equal(t, DB_USER, serviceConfig.DBConfig.User) - assert.Equal(t, DB_PASSWORD, serviceConfig.DBConfig.Password) - assert.Equal(t, DB_LOG_PATH, serviceConfig.DBConfig.Log.Path) - assert.Equal(t, DB_LOG_LEVEL, serviceConfig.DBConfig.Log.Level) + assert.NoError(ParseEnv(&serviceConfig)) + assert.Equal(SERVICE_HOST, serviceConfig.Host) + assert.Equal(SERVICE_PORT, serviceConfig.Port) + assert.Equal(SERVICE_LOG_PATH, serviceConfig.Log.Path) + assert.Equal(SERVICE_LOG_LEVEL, serviceConfig.Log.Level) + assert.Equal(DB_HOST, serviceConfig.DBConfig.Host) + assert.Equal(DB_PORT, serviceConfig.DBConfig.Port) + assert.Equal(DB_USER, serviceConfig.DBConfig.User) + assert.Equal(DB_PASSWORD, serviceConfig.DBConfig.Password) + assert.Equal(DB_LOG_PATH, serviceConfig.DBConfig.Log.Path) + assert.Equal(DB_LOG_LEVEL, serviceConfig.DBConfig.Log.Level) } func TestServiceLoginConfigEnv(t *testing.T) { var err error serviceLoginPrefix := "CONFIG_TEST_SERVICE_LOGIN_" + assert := assert.New(t) err = os.Setenv(serviceLoginPrefix+"USER", LOGIN_USER) - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(serviceLoginPrefix+"PASSWORD", LOGIN_PASSWORD) - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv(serviceLoginPrefix + "USER") }() defer func() { _ = os.Unsetenv(serviceLoginPrefix + "PASSWORD") }() serviceConfig := test.ServiceConfig{Login: &test.LoginConfig{}} - assert.NoError(t, ParseEnv(&serviceConfig)) - assert.Equal(t, LOGIN_USER, serviceConfig.Login.User) - assert.Equal(t, LOGIN_PASSWORD, serviceConfig.Login.Password) + assert.NoError(ParseEnv(&serviceConfig)) + assert.Equal(LOGIN_USER, serviceConfig.Login.User) + assert.Equal(LOGIN_PASSWORD, serviceConfig.Login.Password) } func TestTypesConfigEnv(t *testing.T) { var err error typesPrefix := "CONFIG_TEST_" + assert := assert.New(t) err = os.Setenv(typesPrefix+"BOOL", "true") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"STR", "test-string") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT8", "100") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT16", "1000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT", "10000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT32", "100000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT64", "1000000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT8", "200") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT16", "2000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT", "20000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT32", "200000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT64", "2000000") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"FLOAT32", "1.234") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"FLOAT64", "2222.33333") - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }() defer func() { _ = os.Unsetenv(typesPrefix + "STR") }() @@ -222,22 +229,22 @@ func TestTypesConfigEnv(t *testing.T) { typesConfig := test.TypesConfig{} err = ParseEnv(&typesConfig) - assert.NoError(t, err) + assert.NoError(err) - assert.True(t, typesConfig.BoolValue) - assert.Equal(t, "test-string", typesConfig.StrValue) - assert.Equal(t, int8(100), typesConfig.Int8Value) - assert.Equal(t, int16(1000), typesConfig.Int16Value) - assert.Equal(t, 10000, typesConfig.IntValue) - assert.Equal(t, int32(100000), typesConfig.Int32Value) - assert.Equal(t, int64(1000000), typesConfig.Int64Value) - assert.Equal(t, uint8(200), typesConfig.Uint8Value) - assert.Equal(t, uint16(2000), typesConfig.Uint16Value) - assert.Equal(t, uint(20000), typesConfig.UintValue) - assert.Equal(t, uint32(200000), typesConfig.Uint32Value) - assert.Equal(t, uint64(2000000), typesConfig.Uint64Value) - assert.Equal(t, float32(1.234), typesConfig.Float32Value) - assert.Equal(t, float64(2222.33333), typesConfig.Float64Value) + assert.True(typesConfig.BoolValue) + assert.Equal("test-string", typesConfig.StrValue) + assert.Equal(int8(100), typesConfig.Int8Value) + assert.Equal(int16(1000), typesConfig.Int16Value) + assert.Equal(10000, typesConfig.IntValue) + assert.Equal(int32(100000), typesConfig.Int32Value) + assert.Equal(int64(1000000), typesConfig.Int64Value) + assert.Equal(uint8(200), typesConfig.Uint8Value) + assert.Equal(uint16(2000), typesConfig.Uint16Value) + assert.Equal(uint(20000), typesConfig.UintValue) + assert.Equal(uint32(200000), typesConfig.Uint32Value) + assert.Equal(uint64(2000000), typesConfig.Uint64Value) + assert.Equal(float32(1.234), typesConfig.Float32Value) + assert.Equal(float64(2222.33333), typesConfig.Float64Value) } func TestTypesConfigWithErrorEnv(t *testing.T) { @@ -245,110 +252,111 @@ func TestTypesConfigWithErrorEnv(t *testing.T) { typesConfig := test.TypesConfig{} typesPrefix := "CONFIG_TEST_" + assert := assert.New(t) err = os.Setenv(typesPrefix+"BOOL", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "BOOL") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT8", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "INT8") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT16", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "INT16") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "INT") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT32", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "INT32") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"INT64", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "INT64") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT8", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "UINT8") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT16", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "UINT16") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "UINT") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT32", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "UINT32") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"UINT64", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "UINT64") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"FLOAT32", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "FLOAT32") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(typesPrefix+"FLOAT64", "xxx") - assert.NoError(t, err) + assert.NoError(err) - assert.Error(t, ParseEnv(&typesConfig)) + assert.Error(ParseEnv(&typesConfig)) err = os.Unsetenv(typesPrefix + "FLOAT64") - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }() defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }() @@ -369,33 +377,34 @@ func TestSlicesConfigEnv(t *testing.T) { var err error prefix := "CONFIG_TEST_SLICES_" + assert := assert.New(t) err = os.Setenv(prefix+"PATHS", "/var:/usr:/home") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(prefix+"DEBUG", "/root;/log;/opt") - assert.NoError(t, err) + assert.NoError(err) err = os.Setenv(prefix+"VALUES", "1,2,4,5") - assert.NoError(t, err) + assert.NoError(err) defer func() { _ = os.Unsetenv(prefix + "PATHS") }() defer func() { _ = os.Unsetenv(prefix + "DEBUG") }() defer func() { _ = os.Unsetenv(prefix + "VALUES") }() conf := test.SlicesConfig{} - assert.NoError(t, ParseEnv(&conf)) - assert.Equal(t, 3, len(conf.Paths)) - assert.Equal(t, "/var", conf.Paths[0]) - assert.Equal(t, "/usr", conf.Paths[1]) - assert.Equal(t, "/home", conf.Paths[2]) - assert.Equal(t, 3, len(conf.Debugs)) - assert.Equal(t, "/root", conf.Debugs[0]) - assert.Equal(t, "/log", conf.Debugs[1]) - assert.Equal(t, "/opt", conf.Debugs[2]) - assert.Equal(t, 4, len(conf.Values)) - assert.Equal(t, 1, conf.Values[0]) - assert.Equal(t, 2, conf.Values[1]) - assert.Equal(t, 4, conf.Values[2]) - assert.Equal(t, 5, conf.Values[3]) + assert.NoError(ParseEnv(&conf)) + assert.Equal(3, len(conf.Paths)) + assert.Equal("/var", conf.Paths[0]) + assert.Equal("/usr", conf.Paths[1]) + assert.Equal("/home", conf.Paths[2]) + assert.Equal(3, len(conf.Debugs)) + assert.Equal("/root", conf.Debugs[0]) + assert.Equal("/log", conf.Debugs[1]) + assert.Equal("/opt", conf.Debugs[2]) + assert.Equal(4, len(conf.Values)) + assert.Equal(1, conf.Values[0]) + assert.Equal(2, conf.Values[1]) + assert.Equal(4, conf.Values[2]) + assert.Equal(5, conf.Values[3]) }