227 lines
6.4 KiB
Go
227 lines
6.4 KiB
Go
package paramsparser
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
func TestParamsParserBasic(t *testing.T) {
|
|
input := "name:'myname' host:'localhost' port:25 secure:1 reset:1"
|
|
parser := New()
|
|
err := parser.ParseString(input)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse input: %v", err)
|
|
}
|
|
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
expected string
|
|
}{
|
|
{"string value", "name", "myname"},
|
|
{"another string value", "host", "localhost"},
|
|
{"numeric value", "port", "25"},
|
|
{"boolean-like value", "secure", "1"},
|
|
{"another boolean-like value", "reset", "1"},
|
|
{"non-existent key", "nonexistent", ""},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := parser.Get(tt.key); got != tt.expected {
|
|
t.Errorf("ParamsParser.Get(%q) = %q, want %q", tt.key, got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParamsParserMultiline(t *testing.T) {
|
|
input := "name:'myname' description:'\n\t\ta description can be multiline\n\n\t\tlike this\n'"
|
|
parser := New()
|
|
err := parser.Parse(input)
|
|
if err != nil {
|
|
t.Fatalf("Failed to parse input: %v", err)
|
|
}
|
|
|
|
// Check the name parameter
|
|
if got := parser.Get("name"); got != "myname" {
|
|
t.Errorf("ParamsParser.Get(\"name\") = %q, want %q", got, "myname")
|
|
}
|
|
|
|
// Check the multiline description
|
|
expectedDesc := "\n\t\ta description can be multiline\n\n\t\tlike this\n"
|
|
if got := parser.Get("description"); got != expectedDesc {
|
|
t.Errorf("ParamsParser.Get(\"description\") = %q, want %q", got, expectedDesc)
|
|
}
|
|
}
|
|
|
|
func TestParamsParserDefaults(t *testing.T) {
|
|
parser := New()
|
|
parser.SetDefault("key1", "default1")
|
|
parser.SetDefaults(map[string]string{
|
|
"key2": "default2",
|
|
"key3": "default3",
|
|
})
|
|
|
|
// Override one default
|
|
parser.Set("key2", "override")
|
|
|
|
tests := []struct {
|
|
name string
|
|
key string
|
|
expected string
|
|
}{
|
|
{"default value", "key1", "default1"},
|
|
{"overridden value", "key2", "override"},
|
|
{"another default", "key3", "default3"},
|
|
{"non-existent key", "key4", ""},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
if got := parser.Get(tt.key); got != tt.expected {
|
|
t.Errorf("ParamsParser.Get(%q) = %q, want %q", tt.key, got, tt.expected)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestParamsParserTypes(t *testing.T) {
|
|
parser := New()
|
|
parser.Set("int", "123")
|
|
parser.Set("float", "3.14")
|
|
parser.Set("bool_true", "true")
|
|
parser.Set("bool_yes", "yes")
|
|
parser.Set("bool_1", "1")
|
|
parser.Set("bool_false", "false")
|
|
parser.Set("invalid_int", "not_an_int")
|
|
parser.Set("invalid_float", "not_a_float")
|
|
|
|
t.Run("GetInt", func(t *testing.T) {
|
|
if val, err := parser.GetInt("int"); err != nil || val != 123 {
|
|
t.Errorf("GetInt(\"int\") = %d, %v, want 123, nil", val, err)
|
|
}
|
|
if val, err := parser.GetInt("invalid_int"); err == nil {
|
|
t.Errorf("GetInt(\"invalid_int\") = %d, %v, want error", val, err)
|
|
}
|
|
if val, err := parser.GetInt("nonexistent"); err == nil {
|
|
t.Errorf("GetInt(\"nonexistent\") = %d, %v, want error", val, err)
|
|
}
|
|
})
|
|
|
|
t.Run("GetIntDefault", func(t *testing.T) {
|
|
if val := parser.GetIntDefault("int", 0); val != 123 {
|
|
t.Errorf("GetIntDefault(\"int\", 0) = %d, want 123", val)
|
|
}
|
|
if val := parser.GetIntDefault("invalid_int", 42); val != 42 {
|
|
t.Errorf("GetIntDefault(\"invalid_int\", 42) = %d, want 42", val)
|
|
}
|
|
if val := parser.GetIntDefault("nonexistent", 42); val != 42 {
|
|
t.Errorf("GetIntDefault(\"nonexistent\", 42) = %d, want 42", val)
|
|
}
|
|
})
|
|
|
|
t.Run("GetFloat", func(t *testing.T) {
|
|
if val, err := parser.GetFloat("float"); err != nil || val != 3.14 {
|
|
t.Errorf("GetFloat(\"float\") = %f, %v, want 3.14, nil", val, err)
|
|
}
|
|
if val, err := parser.GetFloat("invalid_float"); err == nil {
|
|
t.Errorf("GetFloat(\"invalid_float\") = %f, %v, want error", val, err)
|
|
}
|
|
if val, err := parser.GetFloat("nonexistent"); err == nil {
|
|
t.Errorf("GetFloat(\"nonexistent\") = %f, %v, want error", val, err)
|
|
}
|
|
})
|
|
|
|
t.Run("GetFloatDefault", func(t *testing.T) {
|
|
if val := parser.GetFloatDefault("float", 0.0); val != 3.14 {
|
|
t.Errorf("GetFloatDefault(\"float\", 0.0) = %f, want 3.14", val)
|
|
}
|
|
if val := parser.GetFloatDefault("invalid_float", 2.71); val != 2.71 {
|
|
t.Errorf("GetFloatDefault(\"invalid_float\", 2.71) = %f, want 2.71", val)
|
|
}
|
|
if val := parser.GetFloatDefault("nonexistent", 2.71); val != 2.71 {
|
|
t.Errorf("GetFloatDefault(\"nonexistent\", 2.71) = %f, want 2.71", val)
|
|
}
|
|
})
|
|
|
|
t.Run("GetBool", func(t *testing.T) {
|
|
if val := parser.GetBool("bool_true"); !val {
|
|
t.Errorf("GetBool(\"bool_true\") = %v, want true", val)
|
|
}
|
|
if val := parser.GetBool("bool_yes"); !val {
|
|
t.Errorf("GetBool(\"bool_yes\") = %v, want true", val)
|
|
}
|
|
if val := parser.GetBool("bool_1"); !val {
|
|
t.Errorf("GetBool(\"bool_1\") = %v, want true", val)
|
|
}
|
|
if val := parser.GetBool("bool_false"); val {
|
|
t.Errorf("GetBool(\"bool_false\") = %v, want false", val)
|
|
}
|
|
if val := parser.GetBool("nonexistent"); val {
|
|
t.Errorf("GetBool(\"nonexistent\") = %v, want false", val)
|
|
}
|
|
})
|
|
|
|
t.Run("GetBoolDefault", func(t *testing.T) {
|
|
if val := parser.GetBoolDefault("bool_true", false); !val {
|
|
t.Errorf("GetBoolDefault(\"bool_true\", false) = %v, want true", val)
|
|
}
|
|
if val := parser.GetBoolDefault("nonexistent", true); !val {
|
|
t.Errorf("GetBoolDefault(\"nonexistent\", true) = %v, want true", val)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestParamsParserGetAll(t *testing.T) {
|
|
parser := New()
|
|
parser.SetDefault("key1", "default1")
|
|
parser.SetDefault("key2", "default2")
|
|
parser.Set("key2", "override")
|
|
parser.Set("key3", "value3")
|
|
|
|
all := parser.GetAll()
|
|
|
|
expected := map[string]string{
|
|
"key1": "default1",
|
|
"key2": "override",
|
|
"key3": "value3",
|
|
}
|
|
|
|
if len(all) != len(expected) {
|
|
t.Errorf("GetAll() returned map with %d entries, want %d", len(all), len(expected))
|
|
}
|
|
|
|
for k, v := range expected {
|
|
if all[k] != v {
|
|
t.Errorf("GetAll()[%q] = %q, want %q", k, all[k], v)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParamsParserMustGet(t *testing.T) {
|
|
parser := New()
|
|
parser.Set("key", "value")
|
|
parser.Set("int", "123")
|
|
parser.Set("float", "3.14")
|
|
|
|
defer func() {
|
|
if r := recover(); r == nil {
|
|
t.Errorf("MustGet on non-existent key did not panic")
|
|
}
|
|
}()
|
|
|
|
// These should not panic
|
|
if val := parser.MustGet("key"); val != "value" {
|
|
t.Errorf("MustGet(\"key\") = %q, want \"value\"", val)
|
|
}
|
|
if val := parser.MustGetInt("int"); val != 123 {
|
|
t.Errorf("MustGetInt(\"int\") = %d, want 123", val)
|
|
}
|
|
if val := parser.MustGetFloat("float"); val != 3.14 {
|
|
t.Errorf("MustGetFloat(\"float\") = %f, want 3.14", val)
|
|
}
|
|
|
|
// This should panic
|
|
parser.MustGet("nonexistent")
|
|
}
|