summaryrefslogtreecommitdiffstats
path: root/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go')
-rw-r--r--vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go733
1 files changed, 733 insertions, 0 deletions
diff --git a/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go
new file mode 100644
index 000000000..34931b7bb
--- /dev/null
+++ b/vendor/github.com/nicksnyder/go-i18n/i18n/language/pluralspec_test.go
@@ -0,0 +1,733 @@
+package language
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+ "testing"
+)
+
+const onePlusEpsilon = "1.00000000000000000000000000000001"
+
+func TestGetPluralSpec(t *testing.T) {
+ tests := []struct {
+ src string
+ spec *PluralSpec
+ }{
+ {"pl", pluralSpecs["pl"]},
+ {"en", pluralSpecs["en"]},
+ {"en-US", pluralSpecs["en"]},
+ {"en_US", pluralSpecs["en"]},
+ {"en-GB", pluralSpecs["en"]},
+ {"zh-CN", pluralSpecs["zh"]},
+ {"zh-TW", pluralSpecs["zh"]},
+ {"pt-BR", pluralSpecs["pt"]},
+ {"pt_BR", pluralSpecs["pt"]},
+ {"pt-PT", pluralSpecs["pt-pt"]},
+ {"pt_PT", pluralSpecs["pt-pt"]},
+ {"zh-Hans-CN", pluralSpecs["zh"]},
+ {"zh-Hant-TW", pluralSpecs["zh"]},
+ {"zh-CN", pluralSpecs["zh"]},
+ {"zh-TW", pluralSpecs["zh"]},
+ {"zh-Hans", pluralSpecs["zh"]},
+ {"zh-Hant", pluralSpecs["zh"]},
+ {"ko-KR", pluralSpecs["ko"]},
+ {"ko_KR", pluralSpecs["ko"]},
+ {"ko-KP", pluralSpecs["ko"]},
+ {"ko_KP", pluralSpecs["ko"]},
+ {"en-US-en-US", pluralSpecs["en"]},
+ {"th", pluralSpecs["th"]},
+ {"th-TH", pluralSpecs["th"]},
+ {"hr", pluralSpecs["hr"]},
+ {"bs", pluralSpecs["bs"]},
+ {"sr", pluralSpecs["sr"]},
+ {"ti", pluralSpecs["ti"]},
+ {"vi", pluralSpecs["vi"]},
+ {"vi-VN", pluralSpecs["vi"]},
+ {"mk", pluralSpecs["mk"]},
+ {"mk-MK", pluralSpecs["mk"]},
+ {"lv", pluralSpecs["lv"]},
+ {"lv-LV", pluralSpecs["lv"]},
+ {".en-US..en-US.", nil},
+ {"zh, en-gb;q=0.8, en;q=0.7", nil},
+ {"zh,en-gb;q=0.8,en;q=0.7", nil},
+ {"xx, en-gb;q=0.8, en;q=0.7", nil},
+ {"xx,en-gb;q=0.8,en;q=0.7", nil},
+ {"xx-YY,xx;q=0.8,en-US,en;q=0.8,de;q=0.6,nl;q=0.4", nil},
+ {"/foo/es/en.json", nil},
+ {"xx-Yyen-US", nil},
+ {"en US", nil},
+ {"", nil},
+ {"-", nil},
+ {"_", nil},
+ {".", nil},
+ {"-en", nil},
+ {"_en", nil},
+ {"-en-", nil},
+ {"_en_", nil},
+ {"xx", nil},
+ }
+ for _, test := range tests {
+ spec := getPluralSpec(test.src)
+ if spec != test.spec {
+ t.Errorf("getPluralSpec(%q) = %q expected %q", test.src, spec, test.spec)
+ }
+ }
+}
+
+type pluralTest struct {
+ num interface{}
+ plural Plural
+}
+
+func appendIntegerTests(tests []pluralTest, plural Plural, examples []string) []pluralTest {
+ for _, ex := range expandExamples(examples) {
+ i, err := strconv.ParseInt(ex, 10, 64)
+ if err != nil {
+ panic(err)
+ }
+ tests = append(tests, pluralTest{ex, plural}, pluralTest{i, plural})
+ }
+ return tests
+}
+
+func appendDecimalTests(tests []pluralTest, plural Plural, examples []string) []pluralTest {
+ for _, ex := range expandExamples(examples) {
+ tests = append(tests, pluralTest{ex, plural})
+ }
+ return tests
+}
+
+func expandExamples(examples []string) []string {
+ var expanded []string
+ for _, ex := range examples {
+ if parts := strings.Split(ex, "~"); len(parts) == 2 {
+ for ex := parts[0]; ; ex = increment(ex) {
+ expanded = append(expanded, ex)
+ if ex == parts[1] {
+ break
+ }
+ }
+ } else {
+ expanded = append(expanded, ex)
+ }
+ }
+ return expanded
+}
+
+func increment(dec string) string {
+ runes := []rune(dec)
+ carry := true
+ for i := len(runes) - 1; carry && i >= 0; i-- {
+ switch runes[i] {
+ case '.':
+ continue
+ case '9':
+ runes[i] = '0'
+ default:
+ runes[i]++
+ carry = false
+ }
+ }
+ if carry {
+ runes = append([]rune{'1'}, runes...)
+ }
+ return string(runes)
+}
+
+//
+// Below here are tests that were manually written before tests were automatically generated.
+// These are kept around as sanity checks for our code generation.
+//
+
+func TestArabic(t *testing.T) {
+ tests := []pluralTest{
+ {0, Zero},
+ {"0", Zero},
+ {"0.0", Zero},
+ {"0.00", Zero},
+ {1, One},
+ {"1", One},
+ {"1.0", One},
+ {"1.00", One},
+ {onePlusEpsilon, Other},
+ {2, Two},
+ {"2", Two},
+ {"2.0", Two},
+ {"2.00", Two},
+ {3, Few},
+ {"3", Few},
+ {"3.0", Few},
+ {"3.00", Few},
+ {10, Few},
+ {"10", Few},
+ {"10.0", Few},
+ {"10.00", Few},
+ {103, Few},
+ {"103", Few},
+ {"103.0", Few},
+ {"103.00", Few},
+ {110, Few},
+ {"110", Few},
+ {"110.0", Few},
+ {"110.00", Few},
+ {11, Many},
+ {"11", Many},
+ {"11.0", Many},
+ {"11.00", Many},
+ {99, Many},
+ {"99", Many},
+ {"99.0", Many},
+ {"99.00", Many},
+ {111, Many},
+ {"111", Many},
+ {"111.0", Many},
+ {"111.00", Many},
+ {199, Many},
+ {"199", Many},
+ {"199.0", Many},
+ {"199.00", Many},
+ {100, Other},
+ {"100", Other},
+ {"100.0", Other},
+ {"100.00", Other},
+ {102, Other},
+ {"102", Other},
+ {"102.0", Other},
+ {"102.00", Other},
+ {200, Other},
+ {"200", Other},
+ {"200.0", Other},
+ {"200.00", Other},
+ {202, Other},
+ {"202", Other},
+ {"202.0", Other},
+ {"202.00", Other},
+ }
+ tests = appendFloatTests(tests, 0.1, 0.9, Other)
+ tests = appendFloatTests(tests, 1.1, 1.9, Other)
+ tests = appendFloatTests(tests, 2.1, 2.9, Other)
+ tests = appendFloatTests(tests, 3.1, 3.9, Other)
+ tests = appendFloatTests(tests, 4.1, 4.9, Other)
+ runTests(t, "ar", tests)
+}
+
+func TestBelarusian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Many},
+ {1, One},
+ {2, Few},
+ {3, Few},
+ {4, Few},
+ {5, Many},
+ {19, Many},
+ {20, Many},
+ {21, One},
+ {11, Many},
+ {52, Few},
+ {101, One},
+ {"0.1", Other},
+ {"0.7", Other},
+ {"1.5", Other},
+ {"1.0", One},
+ {onePlusEpsilon, Other},
+ {"2.0", Few},
+ {"10.0", Many},
+ }
+ runTests(t, "be", tests)
+}
+
+func TestBurmese(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "my", tests)
+}
+
+func TestCatalan(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {"0", Other},
+ {1, One},
+ {"1", One},
+ {"1.0", Other},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ {"2", Other},
+ }
+ tests = appendIntTests(tests, 2, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "ca", tests)
+}
+
+func TestChinese(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "zh", tests)
+}
+
+func TestCzech(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {"0", Other},
+ {1, One},
+ {"1", One},
+ {onePlusEpsilon, Many},
+ {2, Few},
+ {"2", Few},
+ {3, Few},
+ {"3", Few},
+ {4, Few},
+ {"4", Few},
+ {5, Other},
+ {"5", Other},
+ }
+ tests = appendFloatTests(tests, 0, 10, Many)
+ runTests(t, "cs", tests)
+}
+
+func TestDanish(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {onePlusEpsilon, One},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.1, 1.9, One)
+ tests = appendFloatTests(tests, 2.0, 10.0, Other)
+ runTests(t, "da", tests)
+}
+
+func TestDutch(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 10.0, Other)
+ runTests(t, "nl", tests)
+}
+
+func TestEnglish(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 10.0, Other)
+ runTests(t, "en", tests)
+}
+
+func TestFrench(t *testing.T) {
+ tests := []pluralTest{
+ {0, One},
+ {1, One},
+ {onePlusEpsilon, One},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 1.9, One)
+ tests = appendFloatTests(tests, 2.0, 10.0, Other)
+ runTests(t, "fr", tests)
+}
+
+func TestGerman(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 10.0, Other)
+ runTests(t, "de", tests)
+}
+
+func TestIcelandic(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {2, Other},
+ {11, Other},
+ {21, One},
+ {111, Other},
+ {"0.0", Other},
+ {"0.1", One},
+ {"2.0", Other},
+ }
+ runTests(t, "is", tests)
+}
+
+func TestIndonesian(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "id", tests)
+}
+
+func TestItalian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 10.0, Other)
+ runTests(t, "it", tests)
+}
+
+func TestKorean(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "ko", tests)
+}
+
+func TestLatvian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Zero},
+ {"0", Zero},
+ {"0.1", One},
+ {1, One},
+ {"1", One},
+ {onePlusEpsilon, One},
+ {"10.0", Zero},
+ {"10.1", One},
+ {"10.2", Other},
+ {21, One},
+ }
+ tests = appendFloatTests(tests, 0.2, 0.9, Other)
+ tests = appendFloatTests(tests, 1.2, 1.9, Other)
+ tests = appendIntTests(tests, 2, 9, Other)
+ tests = appendIntTests(tests, 10, 20, Zero)
+ tests = appendIntTests(tests, 22, 29, Other)
+ runTests(t, "lv", tests)
+}
+
+func TestJapanese(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "ja", tests)
+}
+
+func TestLithuanian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {2, Few},
+ {3, Few},
+ {9, Few},
+ {10, Other},
+ {11, Other},
+ {"0.1", Many},
+ {"0.7", Many},
+ {"1.0", One},
+ {onePlusEpsilon, Many},
+ {"2.0", Few},
+ {"10.0", Other},
+ }
+ runTests(t, "lt", tests)
+}
+
+func TestMalay(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "ms", tests)
+}
+
+func TestPolish(t *testing.T) {
+ tests := []pluralTest{
+ {0, Many},
+ {1, One},
+ {2, Few},
+ {3, Few},
+ {4, Few},
+ {5, Many},
+ {19, Many},
+ {20, Many},
+ {10, Many},
+ {11, Many},
+ {52, Few},
+ {"0.1", Other},
+ {"0.7", Other},
+ {"1.5", Other},
+ {"1.0", Other},
+ {onePlusEpsilon, Other},
+ {"2.0", Other},
+ {"10.0", Other},
+ }
+ runTests(t, "pl", tests)
+}
+
+func TestPortuguese(t *testing.T) {
+ tests := []pluralTest{
+ {0, One},
+ {"0.0", One},
+ {1, One},
+ {"1.0", One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.1, 0.9, Other)
+ tests = appendFloatTests(tests, 1.1, 10.0, Other)
+ runTests(t, "pt", tests)
+}
+
+func TestMacedonian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {"1.1", One},
+ {"2.1", One},
+ {onePlusEpsilon, One},
+ {2, Other},
+ {"2.2", Other},
+ {11, One},
+ }
+ runTests(t, "mk", tests)
+}
+
+func TestPortugueseEuropean(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {"0.0", Other},
+ {"0.1", Other},
+ {"0.01", Other},
+ {1, One},
+ {"1", One},
+ {"1.1", Other},
+ {"1.01", Other},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 2.0, 10.0, Other)
+ runTests(t, "pt-pt", tests)
+}
+
+func TestRussian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Many},
+ {1, One},
+ {2, Few},
+ {3, Few},
+ {4, Few},
+ {5, Many},
+ {19, Many},
+ {20, Many},
+ {21, One},
+ {11, Many},
+ {52, Few},
+ {101, One},
+ {"0.1", Other},
+ {"0.7", Other},
+ {"1.5", Other},
+ {"1.0", Other},
+ {onePlusEpsilon, Other},
+ {"2.0", Other},
+ {"10.0", Other},
+ }
+ runTests(t, "ru", tests)
+}
+
+func TestSpanish(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {"1", One},
+ {"1.0", One},
+ {"1.00", One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 0.9, Other)
+ tests = appendFloatTests(tests, 1.1, 10.0, Other)
+ runTests(t, "es", tests)
+}
+
+func TestNorweigan(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {"1", One},
+ {"1.0", One},
+ {"1.00", One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 0.9, Other)
+ tests = appendFloatTests(tests, 1.1, 10.0, Other)
+ runTests(t, "no", tests)
+}
+
+func TestBulgarian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {2, Other},
+ {3, Other},
+ {9, Other},
+ {10, Other},
+ {11, Other},
+ {"0.1", Other},
+ {"0.7", Other},
+ {"1.0", One},
+ {"1.001", Other},
+ {onePlusEpsilon, Other},
+ {"1.1", Other},
+ {"2.0", Other},
+ {"10.0", Other},
+ }
+ runTests(t, "bg", tests)
+}
+
+func TestSwedish(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ }
+ tests = appendFloatTests(tests, 0.0, 10.0, Other)
+ runTests(t, "sv", tests)
+}
+
+func TestThai(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "th", tests)
+}
+
+func TestVietnamese(t *testing.T) {
+ tests := appendIntTests(nil, 0, 10, Other)
+ tests = appendFloatTests(tests, 0, 10, Other)
+ runTests(t, "vi", tests)
+}
+
+func TestTurkish(t *testing.T) {
+ tests := []pluralTest{
+ {0, Other},
+ {1, One},
+ {"1", One},
+ {"1.0", One},
+ {"1.00", One},
+ {"1.001", Other},
+ {"1.100", Other},
+ {"1.101", Other},
+ {onePlusEpsilon, Other},
+ {2, Other},
+ {"0.7", Other},
+ {"2.0", Other},
+ }
+ runTests(t, "tr", tests)
+}
+
+func TestUkrainian(t *testing.T) {
+ tests := []pluralTest{
+ {0, Many},
+ {1, One},
+ {2, Few},
+ {3, Few},
+ {4, Few},
+ {5, Many},
+ {19, Many},
+ {20, Many},
+ {21, One},
+ {11, Many},
+ {52, Few},
+ {101, One},
+ {"0.1", Other},
+ {"0.7", Other},
+ {"1.5", Other},
+ {"1.0", Other},
+ {onePlusEpsilon, Other},
+ {"2.0", Other},
+ {"10.0", Other},
+ }
+ runTests(t, "uk", tests)
+}
+
+func TestCroatian(t *testing.T) {
+ tests := makeCroatianBosnianSerbianTests()
+ runTests(t, "hr", tests)
+}
+
+func TestBosnian(t *testing.T) {
+ tests := makeCroatianBosnianSerbianTests()
+ runTests(t, "bs", tests)
+}
+
+func TestSerbian(t *testing.T) {
+ tests := makeCroatianBosnianSerbianTests()
+ runTests(t, "sr", tests)
+}
+
+func makeCroatianBosnianSerbianTests() []pluralTest {
+ return []pluralTest{
+ {1, One},
+ {"0.1", One},
+ {21, One},
+ {101, One},
+ {1001, One},
+ {51, One},
+ {"1.1", One},
+ {"5.1", One},
+ {"100.1", One},
+ {"1000.1", One},
+ {2, Few},
+ {"0.2", Few},
+ {22, Few},
+ {"1.2", Few},
+ {24, Few},
+ {"2.4", Few},
+ {102, Few},
+ {"100.2", Few},
+ {1002, Few},
+ {"1000.2", Few},
+ {5, Other},
+ {"0.5", Other},
+ {0, Other},
+ {100, Other},
+ {19, Other},
+ {"0.0", Other},
+ {"100.0", Other},
+ {"1000.0", Other},
+ }
+}
+
+func TestTigrinya(t *testing.T) {
+ tests := []pluralTest{
+ {0, One},
+ {1, One},
+ }
+ tests = appendIntTests(tests, 2, 10, Other)
+ tests = appendFloatTests(tests, 1.1, 10.0, Other)
+ runTests(t, "ti", tests)
+}
+
+func appendIntTests(tests []pluralTest, from, to int, p Plural) []pluralTest {
+ for i := from; i <= to; i++ {
+ tests = append(tests, pluralTest{i, p})
+ }
+ return tests
+}
+
+func appendFloatTests(tests []pluralTest, from, to float64, p Plural) []pluralTest {
+ stride := 0.1
+ format := "%.1f"
+ for f := from; f < to; f += stride {
+ tests = append(tests, pluralTest{fmt.Sprintf(format, f), p})
+ }
+ tests = append(tests, pluralTest{fmt.Sprintf(format, to), p})
+ return tests
+}
+
+func runTests(t *testing.T, pluralSpecID string, tests []pluralTest) {
+ pluralSpecID = normalizePluralSpecID(pluralSpecID)
+ if spec := pluralSpecs[pluralSpecID]; spec != nil {
+ for _, test := range tests {
+ if plural, err := spec.Plural(test.num); plural != test.plural {
+ t.Errorf("%s: PluralCategory(%#v) returned %s, %v; expected %s", pluralSpecID, test.num, plural, err, test.plural)
+ }
+ }
+ } else {
+ t.Errorf("could not find plural spec for locale %s", pluralSpecID)
+ }
+
+}
generated by cgit v1.2.3-1-g7c22 (git 2.25.1) at 2024-06-01 10:18:25 +0000