scfg: Remove tests for now

3 files changed, 0 insertions, 593 deletions

diff --git a/internal/scfg/reader_test.go b/internal/scfg/reader_test.go
deleted file mode 100644
index 3041e70..0000000
--- a/internal/scfg/reader_test.go
+++ /dev/null
@@ -1,178 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (c) 2020 Simon Ser <https://emersion.fr>
-
-package scfg
-
-import (
-	"reflect"
-	"strings"
-	"testing"
-
-	"github.com/davecgh/go-spew/spew"
-)
-
-var readTests = []struct {
-	name string
-	src  string
-	want Block
-}{
-	{
-		name: "flat",
-		src: `dir1 param1 param2 "" param3
-dir2
-dir3 param1
-
-# comment
-dir4 "param 1" 'param 2'`,
-		want: Block{
-			{Name: "dir1", Params: []string{"param1", "param2", "", "param3"}},
-			{Name: "dir2", Params: []string{}},
-			{Name: "dir3", Params: []string{"param1"}},
-			{Name: "dir4", Params: []string{"param 1", "param 2"}},
-		},
-	},
-	{
-		name: "simpleBlocks",
-		src: `block1 {
-	dir1 param1 param2
-	dir2 param1
-}
-
-block2 {
-}
-
-block3 {
-	# comment
-}
-
-block4 param1 "param2" {
-	dir1
-}`,
-		want: Block{
-			{
-				Name:   "block1",
-				Params: []string{},
-				Children: Block{
-					{Name: "dir1", Params: []string{"param1", "param2"}},
-					{Name: "dir2", Params: []string{"param1"}},
-				},
-			},
-			{Name: "block2", Params: []string{}, Children: Block{}},
-			{Name: "block3", Params: []string{}, Children: Block{}},
-			{
-				Name:   "block4",
-				Params: []string{"param1", "param2"},
-				Children: Block{
-					{Name: "dir1", Params: []string{}},
-				},
-			},
-		},
-	},
-	{
-		name: "nested",
-		src: `block1 {
-	block2 {
-		dir1 param1
-	}
-
-	block3 {
-	}
-}
-
-block4 {
-	block5 {
-		block6 param1 {
-			dir1
-		}
-	}
-
-	dir1
-}`,
-		want: Block{
-			{
-				Name:   "block1",
-				Params: []string{},
-				Children: Block{
-					{
-						Name:   "block2",
-						Params: []string{},
-						Children: Block{
-							{Name: "dir1", Params: []string{"param1"}},
-						},
-					},
-					{
-						Name:     "block3",
-						Params:   []string{},
-						Children: Block{},
-					},
-				},
-			},
-			{
-				Name:   "block4",
-				Params: []string{},
-				Children: Block{
-					{
-						Name:   "block5",
-						Params: []string{},
-						Children: Block{{
-							Name:   "block6",
-							Params: []string{"param1"},
-							Children: Block{{
-								Name:   "dir1",
-								Params: []string{},
-							}},
-						}},
-					},
-					{
-						Name:   "dir1",
-						Params: []string{},
-					},
-				},
-			},
-		},
-	},
-	{
-		name: "quotes",
-		src:  `"a \b ' \" c" 'd \e \' " f' a\"b`,
-		want: Block{
-			{Name: "a b ' \" c", Params: []string{"d e ' \" f", "a\"b"}},
-		},
-	},
-	{
-		name: "quotes-2",
-		src:  `dir arg1 "arg2" ` + `\"\"`,
-		want: Block{
-			{Name: "dir", Params: []string{"arg1", "arg2", "\"\""}},
-		},
-	},
-	{
-		name: "quotes-3",
-		src:  `dir arg1 "\"\"\"\"" arg3`,
-		want: Block{
-			{Name: "dir", Params: []string{"arg1", `"` + "\"\"" + `"`, "arg3"}},
-		},
-	},
-}
-
-func TestRead(t *testing.T) {
-	for _, test := range readTests {
-		t.Run(test.name, func(t *testing.T) {
-			r := strings.NewReader(test.src)
-			got, err := Read(r)
-			if err != nil {
-				t.Fatalf("Read() = %v", err)
-			}
-			stripLineno(got)
-			if !reflect.DeepEqual(got, test.want) {
-				t.Error(spew.Sprintf("Read() = \n %v \n but want \n %v", got, test.want))
-			}
-		})
-	}
-}
-
-func stripLineno(block Block) {
-	for _, dir := range block {
-		dir.lineno = 0
-		stripLineno(dir.Children)
-	}
-}
diff --git a/internal/scfg/unmarshal_test.go b/internal/scfg/unmarshal_test.go
deleted file mode 100644
index 24893cf..0000000
--- a/internal/scfg/unmarshal_test.go
+++ /dev/null
@@ -1,254 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (c) 2020 Simon Ser <https://emersion.fr>
-
-package scfg_test
-
-import (
-	"fmt"
-	"log"
-	"reflect"
-	"strings"
-	"testing"
-
-	"go.lindenii.runxiyu.org/forge/internal/scfg"
-)
-
-func ExampleDecoder() {
-	var data struct {
-		Foo int `scfg:"foo"`
-		Bar struct {
-			Param string `scfg:",param"`
-			Baz   string `scfg:"baz"`
-		} `scfg:"bar"`
-	}
-
-	raw := `foo 42
-bar asdf {
-	baz hello
-}
-`
-
-	r := strings.NewReader(raw)
-	if err := scfg.NewDecoder(r).Decode(&data); err != nil {
-		log.Fatal(err)
-	}
-
-	fmt.Printf("Foo = %v\n", data.Foo)
-	fmt.Printf("Bar.Param = %v\n", data.Bar.Param)
-	fmt.Printf("Bar.Baz = %v\n", data.Bar.Baz)
-
-	// Output:
-	// Foo = 42
-	// Bar.Param = asdf
-	// Bar.Baz = hello
-}
-
-type nestedStructInner struct {
-	Bar string `scfg:"bar"`
-}
-
-type structParams struct {
-	Params []string `scfg:",param"`
-	Bar    string
-}
-
-type textUnmarshaler struct {
-	text string
-}
-
-func (tu *textUnmarshaler) UnmarshalText(text []byte) error {
-	tu.text = string(text)
-	return nil
-}
-
-type textUnmarshalerParams struct {
-	Params []textUnmarshaler `scfg:",param"`
-}
-
-var barStr = "bar"
-
-var unmarshalTests = []struct {
-	name string
-	raw  string
-	want interface{}
-}{
-	{
-		name: "stringMap",
-		raw: `hello world
-foo bar`,
-		want: map[string]string{
-			"hello": "world",
-			"foo":   "bar",
-		},
-	},
-	{
-		name: "simpleStruct",
-		raw: `MyString asdf
-MyBool true
-MyInt -42
-MyUint 42
-MyFloat 3.14`,
-		want: struct {
-			MyString string
-			MyBool   bool
-			MyInt    int
-			MyUint   uint
-			MyFloat  float32
-		}{
-			MyString: "asdf",
-			MyBool:   true,
-			MyInt:    -42,
-			MyUint:   42,
-			MyFloat:  3.14,
-		},
-	},
-	{
-		name: "simpleStructTag",
-		raw:  `foo bar`,
-		want: struct {
-			Foo string `scfg:"foo"`
-		}{
-			Foo: "bar",
-		},
-	},
-	{
-		name: "sliceParams",
-		raw:  `Foo a s d f`,
-		want: struct {
-			Foo []string
-		}{
-			Foo: []string{"a", "s", "d", "f"},
-		},
-	},
-	{
-		name: "arrayParams",
-		raw:  `Foo a s d f`,
-		want: struct {
-			Foo [4]string
-		}{
-			Foo: [4]string{"a", "s", "d", "f"},
-		},
-	},
-	{
-		name: "pointers",
-		raw:  `Foo bar`,
-		want: struct {
-			Foo *string
-		}{
-			Foo: &barStr,
-		},
-	},
-	{
-		name: "nestedMap",
-		raw: `foo {
-	bar baz
-}`,
-		want: struct {
-			Foo map[string]string `scfg:"foo"`
-		}{
-			Foo: map[string]string{"bar": "baz"},
-		},
-	},
-	{
-		name: "nestedStruct",
-		raw: `foo {
-	bar baz
-}`,
-		want: struct {
-			Foo nestedStructInner `scfg:"foo"`
-		}{
-			Foo: nestedStructInner{
-				Bar: "baz",
-			},
-		},
-	},
-	{
-		name: "structParams",
-		raw: `Foo param1 param2 {
-	Bar baz
-}`,
-		want: struct {
-			Foo structParams
-		}{
-			Foo: structParams{
-				Params: []string{"param1", "param2"},
-				Bar:    "baz",
-			},
-		},
-	},
-	{
-		name: "textUnmarshaler",
-		raw: `Foo param1
-Bar param2
-Baz param3`,
-		want: struct {
-			Foo []textUnmarshaler
-			Bar *textUnmarshaler
-			Baz textUnmarshalerParams
-		}{
-			Foo: []textUnmarshaler{{"param1"}},
-			Bar: &textUnmarshaler{"param2"},
-			Baz: textUnmarshalerParams{
-				Params: []textUnmarshaler{{"param3"}},
-			},
-		},
-	},
-	{
-		name: "directiveStructSlice",
-		raw: `Foo param1 param2 {
-	Bar baz
-}
-Foo param3 param4`,
-		want: struct {
-			Foo []structParams
-		}{
-			Foo: []structParams{
-				{
-					Params: []string{"param1", "param2"},
-					Bar:    "baz",
-				},
-				{
-					Params: []string{"param3", "param4"},
-				},
-			},
-		},
-	},
-	{
-		name: "directiveMapSlice",
-		raw: `Foo {
-	key1 param1
-}
-Foo {
-	key2 param2
-}`,
-		want: struct {
-			Foo []map[string]string
-		}{
-			Foo: []map[string]string{
-				{"key1": "param1"},
-				{"key2": "param2"},
-			},
-		},
-	},
-}
-
-func TestUnmarshal(t *testing.T) {
-	for _, tc := range unmarshalTests {
-		tc := tc // capture variable
-		t.Run(tc.name, func(t *testing.T) {
-			testUnmarshal(t, tc.raw, tc.want)
-		})
-	}
-}
-
-func testUnmarshal(t *testing.T, raw string, want interface{}) {
-	out := reflect.New(reflect.TypeOf(want))
-	r := strings.NewReader(raw)
-	if err := scfg.NewDecoder(r).Decode(out.Interface()); err != nil {
-		t.Fatalf("Decode() = %v", err)
-	}
-	got := out.Elem().Interface()
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("Decode() = \n%#v\n but want \n%#v", got, want)
-	}
-}
diff --git a/internal/scfg/writer_test.go b/internal/scfg/writer_test.go
deleted file mode 100644
index 59881da..0000000
--- a/internal/scfg/writer_test.go
+++ /dev/null
@@ -1,161 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (c) 2020 Simon Ser <https://emersion.fr>
-
-package scfg
-
-import (
-	"bytes"
-	"testing"
-)
-
-func TestWrite(t *testing.T) {
-	for _, tc := range []struct {
-		src  Block
-		want string
-		err  error
-	}{
-		{
-			src:  Block{},
-			want: "",
-		},
-		{
-			src: Block{{
-				Name: "dir",
-				Children: Block{{
-					Name:   "blk1",
-					Params: []string{"p1", `"p2"`},
-					Children: Block{
-						{
-							Name:   "sub1",
-							Params: []string{"arg11", "arg12"},
-						},
-						{
-							Name:   "sub2",
-							Params: []string{"arg21", "arg22"},
-						},
-						{
-							Name:   "sub3",
-							Params: []string{"arg31", "arg32"},
-							Children: Block{
-								{
-									Name: "sub-sub1",
-								},
-								{
-									Name:   "sub-sub2",
-									Params: []string{"arg321", "arg322"},
-								},
-							},
-						},
-					},
-				}},
-			}},
-			want: `dir {
-	blk1 p1 "\"p2\"" {
-		sub1 arg11 arg12
-		sub2 arg21 arg22
-		sub3 arg31 arg32 {
-			sub-sub1
-			sub-sub2 arg321 arg322
-		}
-	}
-}
-`,
-		},
-		{
-			src:  Block{{Name: "dir1"}},
-			want: "dir1\n",
-		},
-		{
-			src:  Block{{Name: "dir\"1"}},
-			want: "\"dir\\\"1\"\n",
-		},
-		{
-			src:  Block{{Name: "dir'1"}},
-			want: "\"dir'1\"\n",
-		},
-		{
-			src:  Block{{Name: "dir:}"}},
-			want: "\"dir:}\"\n",
-		},
-		{
-			src:  Block{{Name: "dir:{"}},
-			want: "\"dir:{\"\n",
-		},
-		{
-			src:  Block{{Name: "dir\t1"}},
-			want: `"dir` + "\t" + `1"` + "\n",
-		},
-		{
-			src:  Block{{Name: "dir 1"}},
-			want: "\"dir 1\"\n",
-		},
-		{
-			src:  Block{{Name: "dir1", Params: []string{"arg1", "arg2", `"arg3"`}}},
-			want: "dir1 arg1 arg2 " + `"\"arg3\""` + "\n",
-		},
-		{
-			src:  Block{{Name: "dir1", Params: []string{"arg1", "arg 2", "arg'3"}}},
-			want: "dir1 arg1 \"arg 2\" \"arg'3\"\n",
-		},
-		{
-			src:  Block{{Name: "dir1", Params: []string{"arg1", "", "arg3"}}},
-			want: "dir1 arg1 \"\" arg3\n",
-		},
-		{
-			src:  Block{{Name: "dir1", Params: []string{"arg1", `"` + "\"\"" + `"`, "arg3"}}},
-			want: "dir1 arg1 " + `"\"\"\"\""` + " arg3\n",
-		},
-		{
-			src: Block{{
-				Name: "dir1",
-				Children: Block{
-					{Name: "sub1"},
-					{Name: "sub2", Params: []string{"arg1", "arg2"}},
-				},
-			}},
-			want: `dir1 {
-	sub1
-	sub2 arg1 arg2
-}
-`,
-		},
-		{
-			src: Block{{Name: ""}},
-			err: errDirEmptyName,
-		},
-		{
-			src: Block{{
-				Name: "dir",
-				Children: Block{
-					{Name: "sub1"},
-					{Name: "", Children: Block{{Name: "sub21"}}},
-				},
-			}},
-			err: errDirEmptyName,
-		},
-	} {
-		t.Run("", func(t *testing.T) {
-			var buf bytes.Buffer
-			err := Write(&buf, tc.src)
-			switch {
-			case err != nil && tc.err != nil:
-				if got, want := err.Error(), tc.err.Error(); got != want {
-					t.Fatalf("invalid error:\ngot= %q\nwant=%q", got, want)
-				}
-				return
-			case err == nil && tc.err != nil:
-				t.Fatalf("got err=nil, want=%q", tc.err.Error())
-			case err != nil && tc.err == nil:
-				t.Fatalf("could not marshal: %+v", err)
-			case err == nil && tc.err == nil:
-				// ok.
-			}
-			if got, want := buf.String(), tc.want; got != want {
-				t.Fatalf(
-					"invalid marshal representation:\ngot:\n%s\nwant:\n%s\n---",
-					got, want,
-				)
-			}
-		})
-	}
-}