Do the same single file consolidation on tests

6 files changed, 703 insertions, 1062 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")
-				}
-			}
-		})
-	}
-}
diff --git a/tests/unit/grammar/lexical/dfa/tree_test.go b/tests/unit/grammar/lexical/dfa.go
index de3ebbb..1a3e16a 100644
--- a/tests/unit/grammar/lexical/dfa/tree_test.go
+++ b/tests/unit/grammar/lexical/dfa.go
@@ -9,6 +9,191 @@ import (
 	spec "urubu/spec/grammar"
 )
 
+func TestGenDFA(t *testing.T) {
+	p := parser.NewParser(spec.LexKindName("test"), strings.NewReader("(a|b)*abb"))
+	cpt, err := p.Parse()
+	if err != nil {
+		t.Fatal(err)
+	}
+	bt, symTab, err := ConvertCPTreeToByteTree(map[spec.LexModeKindID]parser.CPTree{
+		spec.LexModeKindIDMin: cpt,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	dfa := GenDFA(bt, symTab)
+	if dfa == nil {
+		t.Fatalf("DFA is nil")
+	}
+
+	symPos := func(n uint16) symbolPosition {
+		pos, err := newSymbolPosition(n, false)
+		if err != nil {
+			panic(err)
+		}
+		return pos
+	}
+
+	endPos := func(n uint16) symbolPosition {
+		pos, err := newSymbolPosition(n, true)
+		if err != nil {
+			panic(err)
+		}
+		return pos
+	}
+
+	s0 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3))
+	s1 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3)).add(symPos(4))
+	s2 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3)).add(symPos(5))
+	s3 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3)).add(endPos(6))
+
+	rune2Int := func(char rune, index int) uint8 {
+		return uint8([]byte(string(char))[index])
+	}
+
+	tranS0 := [256]string{}
+	tranS0[rune2Int('a', 0)] = s1.hash()
+	tranS0[rune2Int('b', 0)] = s0.hash()
+
+	tranS1 := [256]string{}
+	tranS1[rune2Int('a', 0)] = s1.hash()
+	tranS1[rune2Int('b', 0)] = s2.hash()
+
+	tranS2 := [256]string{}
+	tranS2[rune2Int('a', 0)] = s1.hash()
+	tranS2[rune2Int('b', 0)] = s3.hash()
+
+	tranS3 := [256]string{}
+	tranS3[rune2Int('a', 0)] = s1.hash()
+	tranS3[rune2Int('b', 0)] = s0.hash()
+
+	expectedTranTab := map[string][256]string{
+		s0.hash(): tranS0,
+		s1.hash(): tranS1,
+		s2.hash(): tranS2,
+		s3.hash(): tranS3,
+	}
+	if len(dfa.TransitionTable) != len(expectedTranTab) {
+		t.Errorf("transition table is mismatched: want: %v entries, got: %v entries", len(expectedTranTab), len(dfa.TransitionTable))
+	}
+	for h, eTranTab := range expectedTranTab {
+		tranTab, ok := dfa.TransitionTable[h]
+		if !ok {
+			t.Errorf("no entry; hash: %v", h)
+			continue
+		}
+		if len(tranTab) != len(eTranTab) {
+			t.Errorf("transition table is mismatched: hash: %v, want: %v entries, got: %v entries", h, len(eTranTab), len(tranTab))
+		}
+		for c, eNext := range eTranTab {
+			if eNext == "" {
+				continue
+			}
+
+			next := tranTab[c]
+			if next == "" {
+				t.Errorf("no enatry: hash: %v, char: %v", h, c)
+			}
+			if next != eNext {
+				t.Errorf("next state is mismatched: want: %v, got: %v", eNext, next)
+			}
+		}
+	}
+
+	if dfa.InitialState != s0.hash() {
+		t.Errorf("initial state is mismatched: want: %v, got: %v", s0.hash(), dfa.InitialState)
+	}
+
+	accTab := map[string]spec.LexModeKindID{
+		s3.hash(): 1,
+	}
+	if len(dfa.AcceptingStatesTable) != len(accTab) {
+		t.Errorf("accepting states are mismatched: want: %v entries, got: %v entries", len(accTab), len(dfa.AcceptingStatesTable))
+	}
+	for eState, eID := range accTab {
+		id, ok := dfa.AcceptingStatesTable[eState]
+		if !ok {
+			t.Errorf("accepting state is not found: state: %v", eState)
+		}
+		if id != eID {
+			t.Errorf("ID is mismatched: state: %v, want: %v, got: %v", eState, eID, id)
+		}
+	}
+}
+
+func TestNewSymbolPosition(t *testing.T) {
+	tests := []struct {
+		n       uint16
+		endMark bool
+		err     bool
+	}{
+		{
+			n:       0,
+			endMark: false,
+			err:     true,
+		},
+		{
+			n:       0,
+			endMark: true,
+			err:     true,
+		},
+		{
+			n:       symbolPositionMin - 1,
+			endMark: false,
+			err:     true,
+		},
+		{
+			n:       symbolPositionMin - 1,
+			endMark: true,
+			err:     true,
+		},
+		{
+			n:       symbolPositionMin,
+			endMark: false,
+		},
+		{
+			n:       symbolPositionMin,
+			endMark: true,
+		},
+		{
+			n:       symbolPositionMax,
+			endMark: false,
+		},
+		{
+			n:       symbolPositionMax,
+			endMark: true,
+		},
+		{
+			n:       symbolPositionMax + 1,
+			endMark: false,
+			err:     true,
+		},
+		{
+			n:       symbolPositionMax + 1,
+			endMark: true,
+			err:     true,
+		},
+	}
+	for i, tt := range tests {
+		t.Run(fmt.Sprintf("#%v n: %v, endMark: %v", i, tt.n, tt.endMark), func(t *testing.T) {
+			pos, err := newSymbolPosition(tt.n, tt.endMark)
+			if tt.err {
+				if err == nil {
+					t.Fatal("err is nil")
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			n, endMark := pos.describe()
+			if n != tt.n || endMark != tt.endMark {
+				t.Errorf("unexpected symbol position: want: n: %v, endMark: %v, got: n: %v, endMark: %v", tt.n, tt.endMark, n, endMark)
+			}
+		})
+	}
+}
+
 func TestByteTree(t *testing.T) {
 	tests := []struct {
 		root     byteTree
diff --git a/tests/unit/grammar/lexical/dfa/dfa_test.go b/tests/unit/grammar/lexical/dfa/dfa_test.go
deleted file mode 100644
index 38577cf..0000000
--- a/tests/unit/grammar/lexical/dfa/dfa_test.go
+++ /dev/null
@@ -1,121 +0,0 @@
-package dfa
-
-import (
-	"strings"
-	"testing"
-
-	"urubu/grammar/lexical/parser"
-	spec "urubu/spec/grammar"
-)
-
-func TestGenDFA(t *testing.T) {
-	p := parser.NewParser(spec.LexKindName("test"), strings.NewReader("(a|b)*abb"))
-	cpt, err := p.Parse()
-	if err != nil {
-		t.Fatal(err)
-	}
-	bt, symTab, err := ConvertCPTreeToByteTree(map[spec.LexModeKindID]parser.CPTree{
-		spec.LexModeKindIDMin: cpt,
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	dfa := GenDFA(bt, symTab)
-	if dfa == nil {
-		t.Fatalf("DFA is nil")
-	}
-
-	symPos := func(n uint16) symbolPosition {
-		pos, err := newSymbolPosition(n, false)
-		if err != nil {
-			panic(err)
-		}
-		return pos
-	}
-
-	endPos := func(n uint16) symbolPosition {
-		pos, err := newSymbolPosition(n, true)
-		if err != nil {
-			panic(err)
-		}
-		return pos
-	}
-
-	s0 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3))
-	s1 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3)).add(symPos(4))
-	s2 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3)).add(symPos(5))
-	s3 := newSymbolPositionSet().add(symPos(1)).add(symPos(2)).add(symPos(3)).add(endPos(6))
-
-	rune2Int := func(char rune, index int) uint8 {
-		return uint8([]byte(string(char))[index])
-	}
-
-	tranS0 := [256]string{}
-	tranS0[rune2Int('a', 0)] = s1.hash()
-	tranS0[rune2Int('b', 0)] = s0.hash()
-
-	tranS1 := [256]string{}
-	tranS1[rune2Int('a', 0)] = s1.hash()
-	tranS1[rune2Int('b', 0)] = s2.hash()
-
-	tranS2 := [256]string{}
-	tranS2[rune2Int('a', 0)] = s1.hash()
-	tranS2[rune2Int('b', 0)] = s3.hash()
-
-	tranS3 := [256]string{}
-	tranS3[rune2Int('a', 0)] = s1.hash()
-	tranS3[rune2Int('b', 0)] = s0.hash()
-
-	expectedTranTab := map[string][256]string{
-		s0.hash(): tranS0,
-		s1.hash(): tranS1,
-		s2.hash(): tranS2,
-		s3.hash(): tranS3,
-	}
-	if len(dfa.TransitionTable) != len(expectedTranTab) {
-		t.Errorf("transition table is mismatched: want: %v entries, got: %v entries", len(expectedTranTab), len(dfa.TransitionTable))
-	}
-	for h, eTranTab := range expectedTranTab {
-		tranTab, ok := dfa.TransitionTable[h]
-		if !ok {
-			t.Errorf("no entry; hash: %v", h)
-			continue
-		}
-		if len(tranTab) != len(eTranTab) {
-			t.Errorf("transition table is mismatched: hash: %v, want: %v entries, got: %v entries", h, len(eTranTab), len(tranTab))
-		}
-		for c, eNext := range eTranTab {
-			if eNext == "" {
-				continue
-			}
-
-			next := tranTab[c]
-			if next == "" {
-				t.Errorf("no enatry: hash: %v, char: %v", h, c)
-			}
-			if next != eNext {
-				t.Errorf("next state is mismatched: want: %v, got: %v", eNext, next)
-			}
-		}
-	}
-
-	if dfa.InitialState != s0.hash() {
-		t.Errorf("initial state is mismatched: want: %v, got: %v", s0.hash(), dfa.InitialState)
-	}
-
-	accTab := map[string]spec.LexModeKindID{
-		s3.hash(): 1,
-	}
-	if len(dfa.AcceptingStatesTable) != len(accTab) {
-		t.Errorf("accepting states are mismatched: want: %v entries, got: %v entries", len(accTab), len(dfa.AcceptingStatesTable))
-	}
-	for eState, eID := range accTab {
-		id, ok := dfa.AcceptingStatesTable[eState]
-		if !ok {
-			t.Errorf("accepting state is not found: state: %v", eState)
-		}
-		if id != eID {
-			t.Errorf("ID is mismatched: state: %v, want: %v, got: %v", eState, eID, id)
-		}
-	}
-}
diff --git a/tests/unit/grammar/lexical/dfa/symbol_position_test.go b/tests/unit/grammar/lexical/dfa/symbol_position_test.go
deleted file mode 100644
index c867f64..0000000
--- a/tests/unit/grammar/lexical/dfa/symbol_position_test.go
+++ /dev/null
@@ -1,79 +0,0 @@
-package dfa
-
-import (
-	"fmt"
-	"testing"
-)
-
-func TestNewSymbolPosition(t *testing.T) {
-	tests := []struct {
-		n       uint16
-		endMark bool
-		err     bool
-	}{
-		{
-			n:       0,
-			endMark: false,
-			err:     true,
-		},
-		{
-			n:       0,
-			endMark: true,
-			err:     true,
-		},
-		{
-			n:       symbolPositionMin - 1,
-			endMark: false,
-			err:     true,
-		},
-		{
-			n:       symbolPositionMin - 1,
-			endMark: true,
-			err:     true,
-		},
-		{
-			n:       symbolPositionMin,
-			endMark: false,
-		},
-		{
-			n:       symbolPositionMin,
-			endMark: true,
-		},
-		{
-			n:       symbolPositionMax,
-			endMark: false,
-		},
-		{
-			n:       symbolPositionMax,
-			endMark: true,
-		},
-		{
-			n:       symbolPositionMax + 1,
-			endMark: false,
-			err:     true,
-		},
-		{
-			n:       symbolPositionMax + 1,
-			endMark: true,
-			err:     true,
-		},
-	}
-	for i, tt := range tests {
-		t.Run(fmt.Sprintf("#%v n: %v, endMark: %v", i, tt.n, tt.endMark), func(t *testing.T) {
-			pos, err := newSymbolPosition(tt.n, tt.endMark)
-			if tt.err {
-				if err == nil {
-					t.Fatal("err is nil")
-				}
-				return
-			}
-			if err != nil {
-				t.Fatal(err)
-			}
-			n, endMark := pos.describe()
-			if n != tt.n || endMark != tt.endMark {
-				t.Errorf("unexpected symbol position: want: n: %v, endMark: %v, got: n: %v, endMark: %v", tt.n, tt.endMark, n, endMark)
-			}
-		})
-	}
-}
diff --git a/tests/unit/grammar/lexical/parser/parser_test.go b/tests/unit/grammar/lexical/parser.go
index 4c9557d..d5d7039 100644
--- a/tests/unit/grammar/lexical/parser/parser_test.go
+++ b/tests/unit/grammar/lexical/parser.go
@@ -10,6 +10,524 @@ import (
 	"urubu/ucd"
 )
 
+func TestLexer(t *testing.T) {
+	tests := []struct {
+		caption string
+		src     string
+		tokens  []*token
+		err     error
+	}{
+		{
+			caption: "lexer can recognize ordinaly characters",
+			src:     "123abcいろは",
+			tokens: []*token{
+				newToken(tokenKindChar, '1'),
+				newToken(tokenKindChar, '2'),
+				newToken(tokenKindChar, '3'),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindChar, 'b'),
+				newToken(tokenKindChar, 'c'),
+				newToken(tokenKindChar, 'い'),
+				newToken(tokenKindChar, 'ろ'),
+				newToken(tokenKindChar, 'は'),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "lexer can recognize the special characters in default mode",
+			src:     ".*+?|()[\\u",
+			tokens: []*token{
+				newToken(tokenKindAnyChar, nullChar),
+				newToken(tokenKindRepeat, nullChar),
+				newToken(tokenKindRepeatOneOrMore, nullChar),
+				newToken(tokenKindOption, nullChar),
+				newToken(tokenKindAlt, nullChar),
+				newToken(tokenKindGroupOpen, nullChar),
+				newToken(tokenKindGroupClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "lexer can recognize the escape sequences in default mode",
+			src:     "\\\\\\.\\*\\+\\?\\|\\(\\)\\[",
+			tokens: []*token{
+				newToken(tokenKindChar, '\\'),
+				newToken(tokenKindChar, '.'),
+				newToken(tokenKindChar, '*'),
+				newToken(tokenKindChar, '+'),
+				newToken(tokenKindChar, '?'),
+				newToken(tokenKindChar, '|'),
+				newToken(tokenKindChar, '('),
+				newToken(tokenKindChar, ')'),
+				newToken(tokenKindChar, '['),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "], {, and } are treated as an ordinary character in default mode",
+			src:     "]{}",
+			tokens: []*token{
+				newToken(tokenKindChar, ']'),
+				newToken(tokenKindChar, '{'),
+				newToken(tokenKindChar, '}'),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "lexer can recognize the special characters in bracket expression mode",
+			src:     "[a-z\\u{09AF}][^a-z\\u{09abcf}]",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindCharRange, nullChar),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("09AF"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindCharRange, nullChar),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("09abcf"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "lexer can recognize the escape sequences in bracket expression mode",
+			src:     "[\\^a\\-z]",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '^'),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "in a bracket expression, the special characters are also handled as normal characters",
+			src:     "[\\\\.*+?|()[",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '\\'),
+				newToken(tokenKindChar, '.'),
+				newToken(tokenKindChar, '*'),
+				newToken(tokenKindChar, '+'),
+				newToken(tokenKindChar, '?'),
+				newToken(tokenKindChar, '|'),
+				newToken(tokenKindChar, '('),
+				newToken(tokenKindChar, ')'),
+				newToken(tokenKindChar, '['),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "hyphen symbols that appear in bracket expressions are handled as the character range symbol or ordinary characters",
+			// [...-...][...-][-...][-]
+			//  ~~~~~~~     ~  ~     ~
+			//     ^        ^  ^     ^
+			//     |        |  |     `-- Ordinary Character (b)
+			//     |        |  `-- Ordinary Character (b)
+			//     |        `-- Ordinary Character (b)
+			//     `-- Character Range (a)
+			//
+			// a. *-* is handled as a character-range expression.
+			// b. *-, -*, or - are handled as ordinary characters.
+			src: "[a-z][a-][-z][-][--][---][^a-z][^a-][^-z][^-][^--][^---]",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindCharRange, nullChar),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindCharRange, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindCharRange, nullChar),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, 'a'),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindChar, 'z'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindCharRange, nullChar),
+				newToken(tokenKindChar, '-'),
+				newToken(tokenKindBExpClose, nullChar),
+
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "caret symbols that appear in bracket expressions are handled as the logical inverse symbol or ordinary characters",
+			// [^...^...][^]
+			// ~~   ~    ~~
+			// ^    ^    ^^
+			// |    |    |`-- Ordinary Character (c)
+			// |    |    `-- Bracket Expression
+			// |    `-- Ordinary Character (b)
+			// `-- Inverse Bracket Expression (a)
+			//
+			// a. Bracket expressions that have a caret symbol at the beginning are handled as logical inverse expressions.
+			// b. caret symbols that appear as the second and the subsequent symbols are handled as ordinary symbols.
+			// c. When a bracket expression has just one symbol, a caret symbol at the beginning is handled as an ordinary character.
+			src: "[^^][^]",
+			tokens: []*token{
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindChar, '^'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindChar, '^'),
+				newToken(tokenKindBExpClose, nullChar),
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "lexer raises an error when an invalid escape sequence appears",
+			src:     "\\@",
+			err:     synErrInvalidEscSeq,
+		},
+		{
+			caption: "lexer raises an error when the incomplete escape sequence (EOF following \\) appears",
+			src:     "\\",
+			err:     synErrIncompletedEscSeq,
+		},
+		{
+			caption: "lexer raises an error when an invalid escape sequence appears",
+			src:     "[\\@",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+			},
+			err: synErrInvalidEscSeq,
+		},
+		{
+			caption: "lexer raises an error when the incomplete escape sequence (EOF following \\) appears",
+			src:     "[\\",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+			},
+			err: synErrIncompletedEscSeq,
+		},
+		{
+			caption: "lexer can recognize the special characters and code points in code point expression mode",
+			src:     "\\u{0123}\\u{4567}\\u{89abcd}\\u{efAB}\\u{CDEF01}[\\u{0123}\\u{4567}\\u{89abcd}\\u{efAB}\\u{CDEF01}][^\\u{0123}\\u{4567}\\u{89abcd}\\u{efAB}\\u{CDEF01}]",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("0123"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("4567"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("89abcd"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("efAB"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("CDEF01"),
+				newToken(tokenKindRBrace, nullChar),
+
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("0123"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("4567"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("89abcd"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("efAB"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("CDEF01"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindBExpClose, nullChar),
+
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("0123"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("4567"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("89abcd"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("efAB"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("CDEF01"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindBExpClose, nullChar),
+
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "a one digit hex string isn't a valid code point",
+			src:     "\\u{0",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "a two digits hex string isn't a valid code point",
+			src:     "\\u{01",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "a three digits hex string isn't a valid code point",
+			src:     "\\u{012",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "a four digits hex string is a valid code point",
+			src:     "\\u{0123}",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("0123"),
+				newToken(tokenKindRBrace, nullChar),
+			},
+		},
+		{
+			caption: "a five digits hex string isn't a valid code point",
+			src:     "\\u{01234",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "a six digits hex string is a valid code point",
+			src:     "\\u{012345}",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCodePointToken("012345"),
+				newToken(tokenKindRBrace, nullChar),
+			},
+		},
+		{
+			caption: "a seven digits hex string isn't a valid code point",
+			src:     "\\u{0123456",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "a code point must be hex digits",
+			src:     "\\u{g",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "a code point must be hex digits",
+			src:     "\\u{G",
+			tokens: []*token{
+				newToken(tokenKindCodePointLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+			},
+			err: synErrInvalidCodePoint,
+		},
+		{
+			caption: "lexer can recognize the special characters and symbols in character property expression mode",
+			src:     "\\p{Letter}\\p{General_Category=Letter}[\\p{Letter}\\p{General_Category=Letter}][^\\p{Letter}\\p{General_Category=Letter}]",
+			tokens: []*token{
+				newToken(tokenKindCharPropLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCharPropSymbolToken("Letter"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCharPropLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCharPropSymbolToken("General_Category"),
+				newToken(tokenKindEqual, nullChar),
+				newCharPropSymbolToken("Letter"),
+				newToken(tokenKindRBrace, nullChar),
+
+				newToken(tokenKindBExpOpen, nullChar),
+				newToken(tokenKindCharPropLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCharPropSymbolToken("Letter"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCharPropLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCharPropSymbolToken("General_Category"),
+				newToken(tokenKindEqual, nullChar),
+				newCharPropSymbolToken("Letter"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindBExpClose, nullChar),
+
+				newToken(tokenKindInverseBExpOpen, nullChar),
+				newToken(tokenKindCharPropLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCharPropSymbolToken("Letter"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindCharPropLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newCharPropSymbolToken("General_Category"),
+				newToken(tokenKindEqual, nullChar),
+				newCharPropSymbolToken("Letter"),
+				newToken(tokenKindRBrace, nullChar),
+				newToken(tokenKindBExpClose, nullChar),
+
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "lexer can recognize the special characters and symbols in fragment expression mode",
+			src:     "\\f{integer}",
+			tokens: []*token{
+				newToken(tokenKindFragmentLeader, nullChar),
+				newToken(tokenKindLBrace, nullChar),
+				newFragmentSymbolToken("integer"),
+				newToken(tokenKindRBrace, nullChar),
+
+				newToken(tokenKindEOF, nullChar),
+			},
+		},
+		{
+			caption: "a fragment expression is not supported in a bracket expression",
+			src:     "[\\f",
+			tokens: []*token{
+				newToken(tokenKindBExpOpen, nullChar),
+			},
+			err: synErrInvalidEscSeq,
+		},
+		{
+			caption: "a fragment expression is not supported in an inverse bracket expression",
+			src:     "[^\\f",
+			tokens: []*token{
+				newToken(tokenKindInverseBExpOpen, nullChar),
+			},
+			err: synErrInvalidEscSeq,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.caption, func(t *testing.T) {
+			lex := newLexer(strings.NewReader(tt.src))
+			var err error
+			var tok *token
+			i := 0
+			for {
+				tok, err = lex.next()
+				if err != nil {
+					break
+				}
+				if i >= len(tt.tokens) {
+					break
+				}
+				eTok := tt.tokens[i]
+				i++
+				testToken(t, tok, eTok)
+
+				if tok.kind == tokenKindEOF {
+					break
+				}
+			}
+			if tt.err != nil {
+				if err != ParseErr {
+					t.Fatalf("unexpected error: want: %v, got: %v", ParseErr, err)
+				}
+				detail, cause := lex.error()
+				if cause != tt.err {
+					t.Fatalf("unexpected error: want: %v, got: %v (%v)", tt.err, cause, detail)
+				}
+			} else {
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+			}
+			if i < len(tt.tokens) {
+				t.Fatalf("expecte more tokens")
+			}
+		})
+	}
+}
+
+func testToken(t *testing.T, a, e *token) {
+	t.Helper()
+	if e.kind != a.kind || e.char != a.char || e.codePoint != a.codePoint {
+		t.Fatalf("unexpected token: want: %+v, got: %+v", e, a)
+	}
+}
+
 func TestParse(t *testing.T) {
 	tests := []struct {
 		pattern     string
diff --git a/tests/unit/grammar/lexical/parser/lexer_test.go b/tests/unit/grammar/lexical/parser/lexer_test.go
deleted file mode 100644
index 055466e..0000000
--- a/tests/unit/grammar/lexical/parser/lexer_test.go
+++ /dev/null
@@ -1,524 +0,0 @@
-package parser
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestLexer(t *testing.T) {
-	tests := []struct {
-		caption string
-		src     string
-		tokens  []*token
-		err     error
-	}{
-		{
-			caption: "lexer can recognize ordinaly characters",
-			src:     "123abcいろは",
-			tokens: []*token{
-				newToken(tokenKindChar, '1'),
-				newToken(tokenKindChar, '2'),
-				newToken(tokenKindChar, '3'),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindChar, 'b'),
-				newToken(tokenKindChar, 'c'),
-				newToken(tokenKindChar, 'い'),
-				newToken(tokenKindChar, 'ろ'),
-				newToken(tokenKindChar, 'は'),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "lexer can recognize the special characters in default mode",
-			src:     ".*+?|()[\\u",
-			tokens: []*token{
-				newToken(tokenKindAnyChar, nullChar),
-				newToken(tokenKindRepeat, nullChar),
-				newToken(tokenKindRepeatOneOrMore, nullChar),
-				newToken(tokenKindOption, nullChar),
-				newToken(tokenKindAlt, nullChar),
-				newToken(tokenKindGroupOpen, nullChar),
-				newToken(tokenKindGroupClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "lexer can recognize the escape sequences in default mode",
-			src:     "\\\\\\.\\*\\+\\?\\|\\(\\)\\[",
-			tokens: []*token{
-				newToken(tokenKindChar, '\\'),
-				newToken(tokenKindChar, '.'),
-				newToken(tokenKindChar, '*'),
-				newToken(tokenKindChar, '+'),
-				newToken(tokenKindChar, '?'),
-				newToken(tokenKindChar, '|'),
-				newToken(tokenKindChar, '('),
-				newToken(tokenKindChar, ')'),
-				newToken(tokenKindChar, '['),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "], {, and } are treated as an ordinary character in default mode",
-			src:     "]{}",
-			tokens: []*token{
-				newToken(tokenKindChar, ']'),
-				newToken(tokenKindChar, '{'),
-				newToken(tokenKindChar, '}'),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "lexer can recognize the special characters in bracket expression mode",
-			src:     "[a-z\\u{09AF}][^a-z\\u{09abcf}]",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindCharRange, nullChar),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("09AF"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindCharRange, nullChar),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("09abcf"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "lexer can recognize the escape sequences in bracket expression mode",
-			src:     "[\\^a\\-z]",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '^'),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "in a bracket expression, the special characters are also handled as normal characters",
-			src:     "[\\\\.*+?|()[",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '\\'),
-				newToken(tokenKindChar, '.'),
-				newToken(tokenKindChar, '*'),
-				newToken(tokenKindChar, '+'),
-				newToken(tokenKindChar, '?'),
-				newToken(tokenKindChar, '|'),
-				newToken(tokenKindChar, '('),
-				newToken(tokenKindChar, ')'),
-				newToken(tokenKindChar, '['),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "hyphen symbols that appear in bracket expressions are handled as the character range symbol or ordinary characters",
-			// [...-...][...-][-...][-]
-			//  ~~~~~~~     ~  ~     ~
-			//     ^        ^  ^     ^
-			//     |        |  |     `-- Ordinary Character (b)
-			//     |        |  `-- Ordinary Character (b)
-			//     |        `-- Ordinary Character (b)
-			//     `-- Character Range (a)
-			//
-			// a. *-* is handled as a character-range expression.
-			// b. *-, -*, or - are handled as ordinary characters.
-			src: "[a-z][a-][-z][-][--][---][^a-z][^a-][^-z][^-][^--][^---]",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindCharRange, nullChar),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindCharRange, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindCharRange, nullChar),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, 'a'),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindChar, 'z'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindCharRange, nullChar),
-				newToken(tokenKindChar, '-'),
-				newToken(tokenKindBExpClose, nullChar),
-
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "caret symbols that appear in bracket expressions are handled as the logical inverse symbol or ordinary characters",
-			// [^...^...][^]
-			// ~~   ~    ~~
-			// ^    ^    ^^
-			// |    |    |`-- Ordinary Character (c)
-			// |    |    `-- Bracket Expression
-			// |    `-- Ordinary Character (b)
-			// `-- Inverse Bracket Expression (a)
-			//
-			// a. Bracket expressions that have a caret symbol at the beginning are handled as logical inverse expressions.
-			// b. caret symbols that appear as the second and the subsequent symbols are handled as ordinary symbols.
-			// c. When a bracket expression has just one symbol, a caret symbol at the beginning is handled as an ordinary character.
-			src: "[^^][^]",
-			tokens: []*token{
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindChar, '^'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindChar, '^'),
-				newToken(tokenKindBExpClose, nullChar),
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "lexer raises an error when an invalid escape sequence appears",
-			src:     "\\@",
-			err:     synErrInvalidEscSeq,
-		},
-		{
-			caption: "lexer raises an error when the incomplete escape sequence (EOF following \\) appears",
-			src:     "\\",
-			err:     synErrIncompletedEscSeq,
-		},
-		{
-			caption: "lexer raises an error when an invalid escape sequence appears",
-			src:     "[\\@",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-			},
-			err: synErrInvalidEscSeq,
-		},
-		{
-			caption: "lexer raises an error when the incomplete escape sequence (EOF following \\) appears",
-			src:     "[\\",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-			},
-			err: synErrIncompletedEscSeq,
-		},
-		{
-			caption: "lexer can recognize the special characters and code points in code point expression mode",
-			src:     "\\u{0123}\\u{4567}\\u{89abcd}\\u{efAB}\\u{CDEF01}[\\u{0123}\\u{4567}\\u{89abcd}\\u{efAB}\\u{CDEF01}][^\\u{0123}\\u{4567}\\u{89abcd}\\u{efAB}\\u{CDEF01}]",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("0123"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("4567"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("89abcd"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("efAB"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("CDEF01"),
-				newToken(tokenKindRBrace, nullChar),
-
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("0123"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("4567"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("89abcd"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("efAB"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("CDEF01"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindBExpClose, nullChar),
-
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("0123"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("4567"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("89abcd"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("efAB"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("CDEF01"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindBExpClose, nullChar),
-
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "a one digit hex string isn't a valid code point",
-			src:     "\\u{0",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "a two digits hex string isn't a valid code point",
-			src:     "\\u{01",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "a three digits hex string isn't a valid code point",
-			src:     "\\u{012",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "a four digits hex string is a valid code point",
-			src:     "\\u{0123}",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("0123"),
-				newToken(tokenKindRBrace, nullChar),
-			},
-		},
-		{
-			caption: "a five digits hex string isn't a valid code point",
-			src:     "\\u{01234",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "a six digits hex string is a valid code point",
-			src:     "\\u{012345}",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCodePointToken("012345"),
-				newToken(tokenKindRBrace, nullChar),
-			},
-		},
-		{
-			caption: "a seven digits hex string isn't a valid code point",
-			src:     "\\u{0123456",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "a code point must be hex digits",
-			src:     "\\u{g",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "a code point must be hex digits",
-			src:     "\\u{G",
-			tokens: []*token{
-				newToken(tokenKindCodePointLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-			},
-			err: synErrInvalidCodePoint,
-		},
-		{
-			caption: "lexer can recognize the special characters and symbols in character property expression mode",
-			src:     "\\p{Letter}\\p{General_Category=Letter}[\\p{Letter}\\p{General_Category=Letter}][^\\p{Letter}\\p{General_Category=Letter}]",
-			tokens: []*token{
-				newToken(tokenKindCharPropLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCharPropSymbolToken("Letter"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCharPropLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCharPropSymbolToken("General_Category"),
-				newToken(tokenKindEqual, nullChar),
-				newCharPropSymbolToken("Letter"),
-				newToken(tokenKindRBrace, nullChar),
-
-				newToken(tokenKindBExpOpen, nullChar),
-				newToken(tokenKindCharPropLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCharPropSymbolToken("Letter"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCharPropLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCharPropSymbolToken("General_Category"),
-				newToken(tokenKindEqual, nullChar),
-				newCharPropSymbolToken("Letter"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindBExpClose, nullChar),
-
-				newToken(tokenKindInverseBExpOpen, nullChar),
-				newToken(tokenKindCharPropLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCharPropSymbolToken("Letter"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindCharPropLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newCharPropSymbolToken("General_Category"),
-				newToken(tokenKindEqual, nullChar),
-				newCharPropSymbolToken("Letter"),
-				newToken(tokenKindRBrace, nullChar),
-				newToken(tokenKindBExpClose, nullChar),
-
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "lexer can recognize the special characters and symbols in fragment expression mode",
-			src:     "\\f{integer}",
-			tokens: []*token{
-				newToken(tokenKindFragmentLeader, nullChar),
-				newToken(tokenKindLBrace, nullChar),
-				newFragmentSymbolToken("integer"),
-				newToken(tokenKindRBrace, nullChar),
-
-				newToken(tokenKindEOF, nullChar),
-			},
-		},
-		{
-			caption: "a fragment expression is not supported in a bracket expression",
-			src:     "[\\f",
-			tokens: []*token{
-				newToken(tokenKindBExpOpen, nullChar),
-			},
-			err: synErrInvalidEscSeq,
-		},
-		{
-			caption: "a fragment expression is not supported in an inverse bracket expression",
-			src:     "[^\\f",
-			tokens: []*token{
-				newToken(tokenKindInverseBExpOpen, nullChar),
-			},
-			err: synErrInvalidEscSeq,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.caption, func(t *testing.T) {
-			lex := newLexer(strings.NewReader(tt.src))
-			var err error
-			var tok *token
-			i := 0
-			for {
-				tok, err = lex.next()
-				if err != nil {
-					break
-				}
-				if i >= len(tt.tokens) {
-					break
-				}
-				eTok := tt.tokens[i]
-				i++
-				testToken(t, tok, eTok)
-
-				if tok.kind == tokenKindEOF {
-					break
-				}
-			}
-			if tt.err != nil {
-				if err != ParseErr {
-					t.Fatalf("unexpected error: want: %v, got: %v", ParseErr, err)
-				}
-				detail, cause := lex.error()
-				if cause != tt.err {
-					t.Fatalf("unexpected error: want: %v, got: %v (%v)", tt.err, cause, detail)
-				}
-			} else {
-				if err != nil {
-					t.Fatalf("unexpected error: %v", err)
-				}
-			}
-			if i < len(tt.tokens) {
-				t.Fatalf("expecte more tokens")
-			}
-		})
-	}
-}
-
-func testToken(t *testing.T, a, e *token) {
-	t.Helper()
-	if e.kind != a.kind || e.char != a.char || e.codePoint != a.codePoint {
-		t.Fatalf("unexpected token: want: %+v, got: %+v", e, a)
-	}
-}