replace zxq.co/ripple/hanayo

vendor/github.com/thehowl/conf/conf_test.go

@@ -0,0 +1,377 @@
+package conf
+
+import (
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+)
+
+const sampleForParsing = `Key1=Value
+Test=Xd
+What=1294; This be a comment.
+; This be another comment.
+
+
+Multi=Line\
+                String!
+Key\=With\=Equal=Indeed!
+ShouldNotOutput=
+=ShouldNotOutput
+ShouldNotOutput
+
+Can=Contain\;Semicolons!
+EqualSign=Can also = not = be = escaped!
+
+ThisShouldComeUp=Yup`
+
+func TestParse(t *testing.T) {
+	kvs := Parse([]byte(sampleForParsing))
+	t.Log("Result:")
+	for _, v := range kvs {
+		t.Logf("  %s - %s\n", v.Field, v.Value)
+	}
+}
+
+func BenchmarkParseWithSample(b *testing.B) {
+	sp := []byte(sampleForParsing)
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		Parse(sp)
+	}
+}
+
+const (
+	escapeOriginal = `;aqsdwe103====aa\a\\aa!a;a
+
+xd|`
+	escapeExpected = `\;aqsdwe103\=\=\=\=aa\\a\\\\aa!a\;a\
+\
+xd|`
+)
+
+func TestEscape(t *testing.T) {
+	escaped := Escape(escapeOriginal)
+	if escaped != escapeExpected {
+		t.Fatalf("Expected Escape to return '%s', got '%s' instead.", escapeExpected, escaped)
+	}
+}
+
+func BenchmarkEscape(b *testing.B) {
+	for n := 0; n < b.N; n++ {
+		Escape(escapeOriginal)
+	}
+}
+
+const sampleForUnmarshaling = `
+; Welcome to hell.
+; As we have to try every single possible value a struct can have, all of this is required.
+; Fuck.
+TestInt=1510591
+TestInt8=-100
+TestInt16=-12844
+TestInt32=-3211
+TestInt64=410491
+
+TestUint=284129419
+TestUint8=255
+TestUint16=65535
+TestUint32=151529;Can't remember the max value. Won't bother googling.
+TestUint64=24148999
+
+TestFloat32=24.1123
+TestFloat64=110.134141223
+
+TestBool=1
+
+TestString=How much wood would a woodchuck chuck if a woodchuck could chuck wood?
+TestEmpty=
+`
+
+type sampleTest struct {
+	TestInt   int
+	TestInt8  int8
+	TestInt16 int16
+	TestInt32 int32
+	TestInt64 int64
+
+	TestUint   uint
+	TestUint8  uint8
+	TestUint16 uint16
+	TestUint32 uint32
+	TestUint64 uint64
+
+	TestFloat32 float32
+	TestFloat64 float64
+
+	TestBool bool
+
+	TestString string
+	TestEmpty  string
+}
+
+func (si sampleTest) check(t *testing.T) {
+	if true &&
+		si.TestInt == 1510591 &&
+		si.TestInt8 == -100 &&
+		si.TestInt16 == -12844 &&
+		si.TestInt32 == -3211 &&
+		si.TestInt64 == 410491 &&
+
+		si.TestUint == 284129419 &&
+		si.TestUint8 == 255 &&
+		si.TestUint16 == 65535 &&
+		si.TestUint32 == 151529 &&
+		si.TestUint64 == 24148999 &&
+
+		si.TestFloat32 == 24.1123 &&
+		si.TestFloat64 == 110.134141223 &&
+
+		si.TestBool == true &&
+
+		si.TestString == "How much wood would a woodchuck chuck if a woodchuck could chuck wood?" &&
+		si.TestEmpty == "" {
+		t.Log("It surprisingly worked.")
+	} else {
+		t.Log("Nope.")
+		t.Fatalf("%#v", si)
+	}
+}
+
+func TestLoad(t *testing.T) {
+	// Prepare file
+	err := ioutil.WriteFile("test.conf", []byte(sampleForUnmarshaling), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove("test.conf")
+
+	// Prepare struct
+	si := sampleTest{}
+
+	// Load
+	err = Load(&si, "test.conf")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Check for all values to be valid.
+	si.check(t)
+}
+
+func TestLoadShouldErrNotAStruct(t *testing.T) {
+	if err := Load(2, "test.conf"); err != ErrNotAStruct {
+		t.Fatalf("Should have panicked with ErrNotAStruct, got error '%s' instead.", err)
+	}
+}
+
+func TestLoadShouldErrNoFile(t *testing.T) {
+	si := sampleTest{}
+	if err := Load(&si, "test.conf"); err != ErrNoFile {
+		t.Fatalf("Should have panicked with ErrNoFile, got error '%s' instead.", err)
+	}
+}
+
+func TestMustLoadShouldPanic(t *testing.T) {
+	defer func() {
+		c := recover()
+		if c == nil {
+			t.Fatal("MustLoad with wrong values didn't panic!")
+		}
+	}()
+	MustLoad(2, "test.conf")
+}
+
+func TestFailBool(t *testing.T) {
+	// Prepare file
+	err := ioutil.WriteFile("test.conf", []byte(`TestBool=Lolno.`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove("test.conf")
+
+	// Prepare struct
+	si := sampleTest{}
+
+	// Load
+	err = Load(&si, "test.conf")
+	if err == nil {
+		t.Fatal("Should have returned an error, didn't")
+	}
+}
+
+func TestFailInt(t *testing.T) {
+	// Prepare file
+	err := ioutil.WriteFile("test.conf", []byte(`TestInt=10934104912049120491204912031301293102`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove("test.conf")
+
+	// Prepare struct
+	si := sampleTest{}
+
+	// Load
+	err = Load(&si, "test.conf")
+	if err == nil {
+		t.Fatal("Should have returned an error, didn't")
+	}
+}
+
+func TestFailFloat(t *testing.T) {
+	// Prepare file
+	err := ioutil.WriteFile("test.conf", []byte(`TestFloat32=2931.23111aaddfffeep`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove("test.conf")
+
+	// Prepare struct
+	si := sampleTest{}
+
+	// Load
+	err = Load(&si, "test.conf")
+	if err == nil {
+		t.Fatal("Should have returned an error, didn't")
+	}
+}
+
+func TestFailUint(t *testing.T) {
+	// Prepare file
+	err := ioutil.WriteFile("test.conf", []byte(`TestUint8=asd`), 0644)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove("test.conf")
+
+	// Prepare struct
+	si := sampleTest{}
+
+	// Load
+	err = Load(&si, "test.conf")
+	if err == nil {
+		t.Fatal("Should have returned an error, didn't")
+	}
+}
+
+func TestLoadRaw(t *testing.T) {
+	si := sampleTest{}
+
+	LoadRaw(&si, []byte(sampleForUnmarshaling))
+	si.check(t)
+}
+
+func TestMustLoadRawShouldPanic(t *testing.T) {
+	defer func() {
+		c := recover()
+		if c == nil {
+			t.Fatal("MustLoad with wrong values didn't panic!")
+		}
+	}()
+	MustLoadRaw(2, []byte("a"))
+}
+
+func BenchmarkLoadRaw(b *testing.B) {
+	si := &sampleTest{}
+	data := []byte(sampleForUnmarshaling)
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		LoadRaw(si, data)
+	}
+}
+
+type exportTypeTest struct {
+	Name string
+	Age  int `description:"The age of the patient.\nDescriptions can be multi-line."`
+}
+
+const expectedExportType = `Name=Jack
+; The age of the patient.
+; Descriptions can be multi-line.
+Age=19
+`
+
+func TestMustExportRaw(t *testing.T) {
+	defer func() {
+		c := recover()
+		if c != nil {
+			t.Fatal(c)
+		}
+	}()
+	e := &exportTypeTest{
+		Name: "Jack",
+		Age:  19,
+	}
+	data := MustExportRaw(e)
+	if string(data) != expectedExportType {
+		t.Fatalf("Expected '%s', got '%s'", expectedExportType, string(data))
+	}
+}
+
+func TestMustExportShouldPanic(t *testing.T) {
+	defer func() {
+		c := recover()
+		if c == nil {
+			t.Fatal(c)
+		}
+	}()
+	MustExport(2, "a.conf")
+}
+
+func TestMustExportRawShouldPanic(t *testing.T) {
+	defer func() {
+		c := recover()
+		if c == nil {
+			t.Fatal(c)
+		}
+	}()
+	MustExportRaw(2)
+}
+
+type exportWithInvalidType struct {
+	InvalidType []byte
+	Name        string
+}
+
+func TestExport(t *testing.T) {
+	err := Export(exportWithInvalidType{
+		InvalidType: []byte("well"),
+		Name:        "xd",
+	}, "test.conf")
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.Remove("test.conf")
+}
+
+func TestFullChain(t *testing.T) {
+	initial := exportTypeTest{
+		Name: "Pisellone",
+		Age:  133337,
+	}
+	c := MustExportRaw(initial)
+	secondary := exportTypeTest{}
+	MustLoadRaw(&secondary, c)
+	if !reflect.DeepEqual(initial, secondary) {
+		t.Fatalf("Initial struct %#v is not the same as the derivate %#v.", initial, secondary)
+	}
+}
+
+func TestCRLF(t *testing.T) {
+	const w = "Key1=Nice\r\nKey2=Meme"
+	vals := Parse([]byte(w))
+	for _, i := range vals {
+		switch i.Field {
+		case "Key1":
+			if i.Value != "Nice" {
+				t.Fatalf("Expected '%s', got '%s'", "Nice", i.Value)
+			}
+		case "Key2":
+			if i.Value != "Meme" {
+				t.Fatalf("Expected '%s', got '%s'", "Meme", i.Value)
+			}
+		default:
+			t.Fatalf("Unexpected key '%s'", i.Field)
+		}
+	}
+}