| // Copyright 2015 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package search |
| |
| import ( |
| "reflect" |
| "strings" |
| "testing" |
| |
| "golang.org/x/text/language" |
| ) |
| |
| func TestCompile(t *testing.T) { |
| for i, tc := range []struct { |
| desc string |
| pattern string |
| options []Option |
| n int |
| }{{ |
| desc: "empty", |
| pattern: "", |
| n: 0, |
| }, { |
| desc: "single", |
| pattern: "a", |
| n: 1, |
| }, { |
| desc: "keep modifier", |
| pattern: "a\u0300", // U+0300: COMBINING GRAVE ACCENT |
| n: 2, |
| }, { |
| desc: "remove modifier", |
| pattern: "a\u0300", // U+0300: COMBINING GRAVE ACCENT |
| options: []Option{IgnoreDiacritics}, |
| n: 1, |
| }, { |
| desc: "single with double collation element", |
| pattern: "ä", |
| n: 2, |
| }, { |
| desc: "leading variable", |
| pattern: " a", |
| n: 2, |
| }, { |
| desc: "trailing variable", |
| pattern: "aa ", |
| n: 3, |
| }, { |
| desc: "leading and trailing variable", |
| pattern: " äb ", |
| n: 5, |
| }, { |
| desc: "keep interior variable", |
| pattern: " ä b ", |
| n: 6, |
| }, { |
| desc: "keep interior variables", |
| pattern: " b ä ", |
| n: 7, |
| }, { |
| desc: "remove ignoreables (zero-weights across the board)", |
| pattern: "\u009Db\u009Dä\u009D", // U+009D: OPERATING SYSTEM COMMAND |
| n: 3, |
| }} { |
| m := New(language.Und, tc.options...) |
| p := m.CompileString(tc.pattern) |
| if len(p.ce) != tc.n { |
| t.Errorf("%d:%s: Compile(%+q): got %d; want %d", i, tc.desc, tc.pattern, len(p.ce), tc.n) |
| } |
| } |
| } |
| |
| func TestNorm(t *testing.T) { |
| // U+0300: COMBINING GRAVE ACCENT (CCC=230) |
| // U+031B: COMBINING HORN (CCC=216) |
| for _, tc := range []struct { |
| desc string |
| a string |
| b string |
| want bool // a and b compile into the same pattern? |
| }{{ |
| "simple", |
| "eee\u0300\u031b", |
| "eee\u031b\u0300", |
| true, |
| }, { |
| "large number of modifiers in pattern", |
| strings.Repeat("\u0300", 29) + "\u0318", |
| "\u0318" + strings.Repeat("\u0300", 29), |
| true, |
| }, { |
| "modifier overflow in pattern", |
| strings.Repeat("\u0300", 30) + "\u0318", |
| "\u0318" + strings.Repeat("\u0300", 30), |
| false, |
| }} { |
| m := New(language.Und) |
| a := m.CompileString(tc.a) |
| b := m.CompileString(tc.b) |
| if got := reflect.DeepEqual(a, b); got != tc.want { |
| t.Errorf("Compile(a) == Compile(b) == %v; want %v", got, tc.want) |
| } |
| } |
| } |
| |
| func TestForwardSearch(t *testing.T) { |
| for i, tc := range []struct { |
| desc string |
| tag string |
| options []Option |
| pattern string |
| text string |
| want []int |
| }{{ |
| // The semantics of an empty search is to match nothing. |
| // TODO: change this to be in line with strings.Index? It is quite a |
| // different beast, so not sure yet. |
| |
| desc: "empty pattern and text", |
| tag: "und", |
| pattern: "", |
| text: "", |
| want: nil, // TODO: consider: []int{0, 0}, |
| }, { |
| desc: "non-empty pattern and empty text", |
| tag: "und", |
| pattern: " ", |
| text: "", |
| want: nil, |
| }, { |
| desc: "empty pattern and non-empty text", |
| tag: "und", |
| pattern: "", |
| text: "abc", |
| want: nil, // TODO: consider: []int{0, 0, 1, 1, 2, 2, 3, 3}, |
| }, { |
| // Variable-only patterns. We don't support variables at the moment, |
| // but verify that, given this, the behavior is indeed as expected. |
| |
| desc: "exact match of variable", |
| tag: "und", |
| pattern: " ", |
| text: " ", |
| want: []int{0, 1}, |
| }, { |
| desc: "variables not handled by default", |
| tag: "und", |
| pattern: "- ", |
| text: " -", |
| want: nil, // Would be (1, 2) for a median match with variable}. |
| }, { |
| desc: "multiple subsequent identical variables", |
| tag: "und", |
| pattern: " ", |
| text: " ", |
| want: []int{0, 1, 1, 2, 2, 3, 3, 4}, |
| }, { |
| desc: "text with variables", |
| tag: "und", |
| options: []Option{IgnoreDiacritics}, |
| pattern: "abc", |
| text: "3 abc 3", |
| want: []int{2, 5}, |
| }, { |
| desc: "pattern with interior variables", |
| tag: "und", |
| options: []Option{IgnoreDiacritics}, |
| pattern: "a b c", |
| text: "3 a b c abc a b c 3", |
| want: []int{2, 7}, // Would have 3 matches using variable. |
| |
| // TODO: Different variable handling settings. |
| }, { |
| // Options. |
| |
| desc: "match all levels", |
| tag: "und", |
| pattern: "Abc", |
| text: "abcAbcABCÁbcábc", |
| want: []int{3, 6}, |
| }, { |
| desc: "ignore diacritics in text", |
| tag: "und", |
| options: []Option{IgnoreDiacritics}, |
| pattern: "Abc", |
| text: "Ábc", |
| want: []int{0, 4}, |
| }, { |
| desc: "ignore diacritics in pattern", |
| tag: "und", |
| options: []Option{IgnoreDiacritics}, |
| pattern: "Ábc", |
| text: "Abc", |
| want: []int{0, 3}, |
| }, { |
| desc: "ignore diacritics", |
| tag: "und", |
| options: []Option{IgnoreDiacritics}, |
| pattern: "Abc", |
| text: "abcAbcABCÁbcábc", |
| want: []int{3, 6, 9, 13}, |
| }, { |
| desc: "ignore case", |
| tag: "und", |
| options: []Option{IgnoreCase}, |
| pattern: "Abc", |
| text: "abcAbcABCÁbcábc", |
| want: []int{0, 3, 3, 6, 6, 9}, |
| }, { |
| desc: "ignore case and diacritics", |
| tag: "und", |
| options: []Option{IgnoreCase, IgnoreDiacritics}, |
| pattern: "Abc", |
| text: "abcAbcABCÁbcábc", |
| want: []int{0, 3, 3, 6, 6, 9, 9, 13, 13, 17}, |
| }, { |
| desc: "ignore width to fullwidth", |
| tag: "und", |
| options: []Option{IgnoreWidth}, |
| pattern: "abc", |
| text: "123 \uFF41\uFF42\uFF43 123", // U+FF41-3: FULLWIDTH LATIN SMALL LETTER A-C |
| want: []int{4, 13}, |
| }, { |
| // TODO: distinguish between case and width. |
| desc: "don't ignore width to fullwidth, ignoring only case", |
| tag: "und", |
| options: []Option{IgnoreCase}, |
| pattern: "abc", |
| text: "123 \uFF41\uFF42\uFF43 123", // U+FF41-3: FULLWIDTH LATIN SMALL LETTER A-C |
| want: []int{4, 13}, |
| }, { |
| desc: "ignore width to fullwidth and diacritics", |
| tag: "und", |
| options: []Option{IgnoreWidth, IgnoreDiacritics}, |
| pattern: "abc", |
| text: "123 \uFF41\uFF42\uFF43 123", // U+FF41-3: FULLWIDTH LATIN SMALL LETTER A-C |
| want: []int{4, 13}, |
| }, { |
| desc: "whole grapheme, single rune", |
| tag: "und", |
| pattern: "eee", |
| text: "123 eeé 123", |
| want: nil, |
| }, { |
| // Note: rules on when to apply contractions may, for certain languages, |
| // differ between search and collation. For example, "ch" is not |
| // considered a contraction for the purpose of searching in Spanish. |
| // Therefore, be careful picking this test. |
| desc: "whole grapheme, contractions", |
| tag: "da", |
| pattern: "aba", |
| // Fails at the primary level, because "aa" is a contraction. |
| text: "123 abaa 123", |
| want: []int{}, |
| }, { |
| desc: "whole grapheme, trailing modifier", |
| tag: "und", |
| pattern: "eee", |
| text: "123 eee\u0300 123", // U+0300: COMBINING GRAVE ACCENT |
| want: nil, |
| }, { |
| // Language-specific matching. |
| |
| desc: "", |
| tag: "da", |
| options: []Option{IgnoreCase}, |
| pattern: "Århus", |
| text: "AarhusÅrhus Århus ", |
| want: []int{0, 6, 6, 12, 14, 20}, |
| }, { |
| desc: "", |
| tag: "da", |
| options: []Option{IgnoreCase}, |
| pattern: "Aarhus", |
| text: "Århus Aarhus", |
| want: []int{0, 6, 7, 13}, |
| }, { |
| desc: "", |
| tag: "en", // Å does not match A for English. |
| options: []Option{IgnoreCase}, |
| pattern: "Aarhus", |
| text: "Århus", |
| want: nil, |
| }, { |
| desc: "ignore modifier in text", |
| options: []Option{IgnoreDiacritics}, |
| tag: "und", |
| pattern: "eee", |
| text: "123 eee\u0300 123", // U+0300: COMBINING GRAVE ACCENT |
| want: []int{4, 9}, // Matches on grapheme boundary. |
| }, { |
| desc: "ignore multiple modifiers in text", |
| options: []Option{IgnoreDiacritics}, |
| tag: "und", |
| pattern: "eee", |
| text: "123 eee\u0300\u0300 123", // U+0300: COMBINING GRAVE ACCENT |
| want: []int{4, 11}, // Matches on grapheme boundary. |
| }, { |
| desc: "ignore modifier in pattern", |
| options: []Option{IgnoreDiacritics}, |
| tag: "und", |
| pattern: "eee\u0300", // U+0300: COMBINING GRAVE ACCENT |
| text: "123 eee 123", |
| want: []int{4, 7}, |
| }, { |
| desc: "ignore multiple modifiers in pattern", |
| options: []Option{IgnoreDiacritics}, |
| tag: "und", |
| pattern: "eee\u0300\u0300", // U+0300: COMBINING GRAVE ACCENT |
| text: "123 eee 123", |
| want: []int{4, 7}, |
| }, { |
| desc: "match non-normalized pattern", |
| tag: "und", |
| // U+0300: COMBINING GRAVE ACCENT (CCC=230) |
| // U+031B: COMBINING HORN (CCC=216) |
| pattern: "eee\u0300\u031b", |
| text: "123 eee\u031b\u0300 123", |
| want: []int{4, 11}, |
| }, { |
| desc: "match non-normalized text", |
| tag: "und", |
| // U+0300: COMBINING GRAVE ACCENT (CCC=230) |
| // U+031B: COMBINING HORN (CCC=216) |
| pattern: "eee\u031b\u0300", |
| text: "123 eee\u0300\u031b 123", |
| want: []int{4, 11}, |
| }} { |
| m := New(language.MustParse(tc.tag), tc.options...) |
| p := m.CompileString(tc.pattern) |
| for j := 0; j < len(tc.text); { |
| start, end := p.IndexString(tc.text[j:]) |
| if start == -1 && end == -1 { |
| j++ |
| continue |
| } |
| start += j |
| end += j |
| j = end |
| if len(tc.want) == 0 { |
| t.Errorf("%d:%s: found unexpected result [%d %d]", i, tc.desc, start, end) |
| break |
| } |
| if tc.want[0] != start || tc.want[1] != end { |
| t.Errorf("%d:%s: got [%d %d]; want %v", i, tc.desc, start, end, tc.want[:2]) |
| tc.want = tc.want[2:] |
| break |
| } |
| tc.want = tc.want[2:] |
| } |
| if len(tc.want) != 0 { |
| t.Errorf("%d:%s: %d extra results", i, tc.desc, len(tc.want)/2) |
| } |
| } |
| } |
