diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/tre.go | 223 |
1 files changed, 221 insertions, 2 deletions
diff --git a/tests/tre.go b/tests/tre.go index 9029259..8c14feb 100644 --- a/tests/tre.go +++ b/tests/tre.go @@ -245,8 +245,8 @@ func TestCompressor_Compress(t *testing.T) { allCompressors := func() []Compressor { return []Compressor{ - NewUniqueEntriesTable(), - NewRowDisplacementTable(x), + NewCompressorUniqueEntriesTable(), + NewCompressorRowDisplacementTable(x), } } @@ -356,6 +356,219 @@ func TestCompressor_Compress(t *testing.T) { } } +var idTests = []struct { + id string + invalid bool +}{ + { + id: "foo", + }, + { + id: "foo2", + }, + { + id: "foo_bar_baz", + }, + { + id: "f_o_o", + }, + { + id: "Foo", + invalid: true, + }, + { + id: "foo_Bar", + invalid: true, + }, + { + id: "2foo", + invalid: true, + }, + { + id: "_foo", + invalid: true, + }, + { + id: "foo_", + invalid: true, + }, + { + id: "foo__bar", + invalid: true, + }, +} + +func TestValidateIdentifier(t *testing.T) { + for _, tt := range idTests { + t.Run(tt.id, func(t *testing.T) { + err := validateIdentifier(tt.id) + if tt.invalid { + if err == nil { + t.Errorf("expected error didn't occur") + } + } else { + if err != nil { + t.Errorf("unexpected error occurred: %v", err) + } + } + }) + } +} + +func TestLexKindName_validate(t *testing.T) { + for _, tt := range idTests { + t.Run(tt.id, func(t *testing.T) { + err := LexKindName(tt.id).validate() + if tt.invalid { + if err == nil { + t.Errorf("expected error didn't occur") + } + } else { + if err != nil { + t.Errorf("unexpected error occurred: %v", err) + } + } + }) + } +} + +func TestLexModeName_validate(t *testing.T) { + for _, tt := range idTests { + t.Run(tt.id, func(t *testing.T) { + err := LexModeName(tt.id).validate() + if tt.invalid { + if err == nil { + t.Errorf("expected error didn't occur") + } + } else { + if err != nil { + t.Errorf("unexpected error occurred: %v", err) + } + } + }) + } +} + +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 TestLexSpec_Validate(t *testing.T) { + // We expect that the spelling inconsistency error will occur. + spec := &LexSpec{ + Entries: []*LexEntry{ + { + Modes: []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 MainTest() { @@ -363,6 +576,12 @@ func MainTest() { { "TestGenCharBlocksWellFormed", TestGenCharBlocksWellFormed }, { "TestGenCharBlocksIllFormed", TestGenCharBlocksIllFormed }, { "TestCompressor_Compress", TestCompressor_Compress }, + { "TestValidateIdentifier", TestValidateIdentifier }, + { "TestLexKindName_validate", TestLexKindName_validate }, + { "TestLexModeName_validate", TestLexModeName_validate }, + { "TestSnakeCaseToUpperCamelCase", TestSnakeCaseToUpperCamelCase }, + { "TestFindSpellingInconsistencies", TestFindSpellingInconsistencies }, + { "TestLexSpec_Validate", TestLexSpec_Validate }, } deps := testdeps.TestDeps{} |