Do the same single file consolidation on tests

1 files changed, 0 insertions, 338 deletions

diff --git a/tests/unit/grammar/lexical/compiler_test.go b/tests/unit/grammar/lexical/compiler_test.go
deleted file mode 100644
index b621cd2..0000000
--- a/tests/unit/grammar/lexical/compiler_test.go
+++ /dev/null
@@ -1,338 +0,0 @@
-package lexical
-
-import (
-	"encoding/json"
-	"fmt"
-	"testing"
-
-	spec "urubu/spec/grammar"
-)
-
-func TestLexSpec_Validate(t *testing.T) {
-	// We expect that the spelling inconsistency error will occur.
-	spec := &LexSpec{
-		Entries: []*LexEntry{
-			{
-				Modes: []spec.LexModeName{
-					// 'Default' is the spelling inconsistency because 'default' is predefined.
-					"Default",
-				},
-				Kind:    "foo",
-				Pattern: "foo",
-			},
-		},
-	}
-	err := spec.Validate()
-	if err == nil {
-		t.Fatalf("expected error didn't occur")
-	}
-}
-
-func TestSnakeCaseToUpperCamelCase(t *testing.T) {
-	tests := []struct {
-		snake string
-		camel string
-	}{
-		{
-			snake: "foo",
-			camel: "Foo",
-		},
-		{
-			snake: "foo_bar",
-			camel: "FooBar",
-		},
-		{
-			snake: "foo_bar_baz",
-			camel: "FooBarBaz",
-		},
-		{
-			snake: "Foo",
-			camel: "Foo",
-		},
-		{
-			snake: "fooBar",
-			camel: "FooBar",
-		},
-		{
-			snake: "FOO",
-			camel: "FOO",
-		},
-		{
-			snake: "FOO_BAR",
-			camel: "FOOBAR",
-		},
-		{
-			snake: "_foo_bar_",
-			camel: "FooBar",
-		},
-		{
-			snake: "___foo___bar___",
-			camel: "FooBar",
-		},
-	}
-	for _, tt := range tests {
-		c := SnakeCaseToUpperCamelCase(tt.snake)
-		if c != tt.camel {
-			t.Errorf("unexpected string; want: %v, got: %v", tt.camel, c)
-		}
-	}
-}
-
-func TestFindSpellingInconsistencies(t *testing.T) {
-	tests := []struct {
-		ids        []string
-		duplicated [][]string
-	}{
-		{
-			ids:        []string{"foo", "foo"},
-			duplicated: nil,
-		},
-		{
-			ids:        []string{"foo", "Foo"},
-			duplicated: [][]string{{"Foo", "foo"}},
-		},
-		{
-			ids:        []string{"foo", "foo", "Foo"},
-			duplicated: [][]string{{"Foo", "foo"}},
-		},
-		{
-			ids:        []string{"foo_bar_baz", "FooBarBaz"},
-			duplicated: [][]string{{"FooBarBaz", "foo_bar_baz"}},
-		},
-		{
-			ids:        []string{"foo", "Foo", "bar", "Bar"},
-			duplicated: [][]string{{"Bar", "bar"}, {"Foo", "foo"}},
-		},
-		{
-			ids:        []string{"foo", "Foo", "bar", "Bar", "baz", "bra"},
-			duplicated: [][]string{{"Bar", "bar"}, {"Foo", "foo"}},
-		},
-	}
-	for i, tt := range tests {
-		t.Run(fmt.Sprintf("#%v", i), func(t *testing.T) {
-			duplicated := FindSpellingInconsistencies(tt.ids)
-			if len(duplicated) != len(tt.duplicated) {
-				t.Fatalf("unexpected IDs; want: %#v, got: %#v", tt.duplicated, duplicated)
-			}
-			for i, dupIDs := range duplicated {
-				if len(dupIDs) != len(tt.duplicated[i]) {
-					t.Fatalf("unexpected IDs; want: %#v, got: %#v", tt.duplicated[i], dupIDs)
-				}
-				for j, id := range dupIDs {
-					if id != tt.duplicated[i][j] {
-						t.Fatalf("unexpected IDs; want: %#v, got: %#v", tt.duplicated[i], dupIDs)
-					}
-				}
-			}
-		})
-	}
-}
-
-func TestCompile(t *testing.T) {
-	tests := []struct {
-		Caption string
-		Spec    string
-		Err     bool
-	}{
-		{
-			Caption: "allow duplicates names between fragments and non-fragments",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "kind": "a2z",
-            "pattern": "\\f{a2z}"
-        },
-        {
-            "fragment": true,
-            "kind": "a2z",
-            "pattern": "[a-z]"
-        }
-    ]
-}
-`,
-		},
-		{
-			Caption: "don't allow duplicates names in non-fragments",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "kind": "a2z",
-            "pattern": "a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z"
-        },
-        {
-            "kind": "a2z",
-            "pattern": "[a-z]"
-        }
-    ]
-}
-`,
-			Err: true,
-		},
-		{
-			Caption: "don't allow duplicates names in fragments",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "kind": "a2z",
-            "pattern": "\\f{a2z}"
-        },
-        {
-            "fragments": true,
-            "kind": "a2z",
-            "pattern": "a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z"
-        },
-        {
-            "fragments": true,
-            "kind": "a2z",
-            "pattern": "[a-z]"
-        }
-    ]
-}
-`,
-			Err: true,
-		},
-		{
-			Caption: "don't allow kind names in the same mode to contain spelling inconsistencies",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "kind": "foo_1",
-            "pattern": "foo_1"
-        },
-        {
-            "kind": "foo1",
-            "pattern": "foo1"
-        }
-    ]
-}
-`,
-			Err: true,
-		},
-		{
-			Caption: "don't allow kind names across modes to contain spelling inconsistencies",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "modes": ["default"],
-            "kind": "foo_1",
-            "pattern": "foo_1"
-        },
-        {
-            "modes": ["other_mode"],
-            "kind": "foo1",
-            "pattern": "foo1"
-        }
-    ]
-}
-`,
-			Err: true,
-		},
-		{
-			Caption: "don't allow mode names to contain spelling inconsistencies",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "modes": ["foo_1"],
-            "kind": "a",
-            "pattern": "a"
-        },
-        {
-            "modes": ["foo1"],
-            "kind": "b",
-            "pattern": "b"
-        }
-    ]
-}
-`,
-			Err: true,
-		},
-		{
-			Caption: "allow fragment names in the same mode to contain spelling inconsistencies because fragments will not appear in output files",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "kind": "a",
-            "pattern": "a"
-        },
-        {
-            "fragment": true,
-            "kind": "foo_1",
-            "pattern": "foo_1"
-        },
-        {
-            "fragment": true,
-            "kind": "foo1",
-            "pattern": "foo1"
-        }
-    ]
-}
-`,
-		},
-		{
-			Caption: "allow fragment names across modes to contain spelling inconsistencies because fragments will not appear in output files",
-			Spec: `
-{
-    "name": "test",
-    "entries": [
-        {
-            "modes": ["default"],
-            "kind": "a",
-            "pattern": "a"
-        },
-        {
-            "modes": ["default"],
-            "fragment": true,
-            "kind": "foo_1",
-            "pattern": "foo_1"
-        },
-        {
-            "modes": ["other_mode"],
-            "fragment": true,
-            "kind": "foo1",
-            "pattern": "foo1"
-        }
-    ]
-}
-`,
-		},
-	}
-	for i, tt := range tests {
-		t.Run(fmt.Sprintf("#%v %s", i, tt.Caption), func(t *testing.T) {
-			lspec := &LexSpec{}
-			err := json.Unmarshal([]byte(tt.Spec), lspec)
-			if err != nil {
-				t.Fatalf("%v", err)
-			}
-			clspec, err, _ := Compile(lspec, CompressionLevelMin)
-			if tt.Err {
-				if err == nil {
-					t.Fatalf("expected an error")
-				}
-				if clspec != nil {
-					t.Fatalf("Compile function mustn't return a compiled specification")
-				}
-			} else {
-				if err != nil {
-					t.Fatalf("unexpected error: %v", err)
-				}
-				if clspec == nil {
-					t.Fatalf("Compile function must return a compiled specification")
-				}
-			}
-		})
-	}
-}