ms/config
2
0
Fork 0
Code Actions

Выполнен рефакторинг тестов, обновлена документация.
All checks were successful
test / test (push) Successful in 58s
Details

Browse Source
This commit is contained in:
Алексей Бадяев 2024-10-21 18:55:14 +07:00
parent 7d6bc833a3
commit ce3402b295
Signed by: alexey
GPG Key ID: 686FBC1363E4AFAE
4 changed files with 168 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
README.md
View File

@ -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"`
}
```

2
cli_test.go
View File

@ -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) {}

31
config_test.go
View File

@ -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) {

251
env_test.go
View File

@ -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])
}