plural

package module

v0.0.0-...-00841d0 Latest Latest Go to latest Published: Apr 1, 2020 License: BSD-2-Clause Imports: 5 Imported by: 1

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/louischan-oursky/gomakeplural

Links

Open Source Insights

Documentation ¶

Index ¶

Variables
func GetFunc(culture language.Tag) (func(interface{}, bool) string, error)
type Case
type Cases
- func (s Cases) ToMap() (m map[string]*Case)
type Culture
type PluralInfo
type Symbol
type UnitTest
type UnitTests
type Var
- func (v Var) Name() string

Constants ¶

This section is empty.

Variables ¶

View Source

var Info = PluralInfo{
	Cultures: []Culture{
		{
			Langs: []string{"af", "an", "bg", "ce", "el", "es", "eu", "gsw", "ky", "ml", "mn", "nb", "ps", "sd", "ta", "te", "tr", "uz"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ak", "bho", "guw", "ln", "mg", "nso", "ti", "wa"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "p && n >= 0 && n <= 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.0", "0.00", "1.00", "0.000", "1.000", "0.0000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"am", "fa", "kn", "zu"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 0 || n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.0", "0.00", "0.04"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"1.1", "2.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ar"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "zero", Cond: "n == 0"},
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2"},
				{Form: "few", Cond: "p && n100 >= 3 && n100 <= 10"},
				{Form: "many", Cond: "p && n100 >= 11 && n100 <= 99"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
						Decimals: []string{"2.0", "2.00", "2.000", "2.0000"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "10", "103", "110", "1003"},
						Decimals: []string{"3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "103.0", "1003.0"},
					},
					{
						Expected: "many",
						Integers: []string{"11", "26", "111", "1011"},
						Decimals: []string{"11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "111.0", "1011.0"},
					},
					{
						Expected: "zero",
						Integers: []string{"0"},
						Decimals: []string{"0.0", "0.00", "0.000", "0.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"100", "102", "200", "202", "300", "302", "400", "402", "500", "502", "600", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ars"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "zero", Cond: "n == 0"},
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2"},
				{Form: "few", Cond: "p && n100 >= 3 && n100 <= 10"},
				{Form: "many", Cond: "p && n100 >= 11 && n100 <= 99"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
						Decimals: []string{"2.0", "2.00", "2.000", "2.0000"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "10", "103", "110", "1003"},
						Decimals: []string{"3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "103.0", "1003.0"},
					},
					{
						Expected: "many",
						Integers: []string{"11", "26", "111", "1011"},
						Decimals: []string{"11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "111.0", "1011.0"},
					},
					{
						Expected: "zero",
						Integers: []string{"0"},
						Decimals: []string{"0.0", "0.00", "0.000", "0.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"100", "102", "200", "202", "300", "302", "400", "402", "500", "502", "600", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"as", "bn"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 0 || n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1 || n == 5 || n == 7 || n == 8 || n == 9 || n == 10"},
				{Form: "two", Cond: "n == 2 || n == 3"},
				{Form: "few", Cond: "n == 4"},
				{Form: "many", Cond: "n == 6"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.0", "0.00", "0.04"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"1.1", "2.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "5", "7", "10"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "3"},
					},
					{
						Expected: "few",
						Integers: []string{"4"},
					},
					{
						Expected: "many",
						Integers: []string{"6"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "11", "25", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"asa", "bem", "bez", "brx", "cgg", "chr", "ckb", "dv", "ee", "eo", "fo", "fur", "ha", "haw", "jgo", "jmc", "kaj", "kcg", "kkj", "kl", "ks", "ksb", "ku", "lb", "lg", "mas", "mgo", "nah", "nd", "nn", "nnh", "no", "nr", "ny", "nyn", "om", "os", "pap", "rm", "rof", "rwk", "saq", "sdh", "seh", "sn", "so", "ss", "ssy", "st", "syr", "teo", "tig", "tn", "ts", "ug", "ve", "vo", "vun", "wae", "xh", "xog"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"ast", "io", "ji", "pt-PT", "yi"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"az"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "i10 == 1 || i10 == 2 || i10 == 5 || i10 == 7 || i10 == 8 || i100 == 20 || i100 == 50 || i100 == 70 || i100 == 80"},
				{Form: "few", Cond: "i10 == 3 || i10 == 4 || i1000 == 100 || i1000 == 200 || i1000 == 300 || i1000 == 400 || i1000 == 500 || i1000 == 600 || i1000 == 700 || i1000 == 800 || i1000 == 900"},
				{Form: "many", Cond: "i == 0 || i10 == 6 || i100 == 40 || i100 == 60 || i100 == 90"},
			},
			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
				{Symbol: I, Mod: 1000},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "2", "5", "7", "8", "11", "12", "15", "17", "18", "20", "22", "25", "101", "1001"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "4", "13", "14", "23", "24", "33", "34", "43", "44", "53", "54", "63", "64", "73", "74", "100", "1003"},
					},
					{
						Expected: "many",
						Integers: []string{"0", "6", "16", "26", "36", "40", "46", "56", "106", "1006"},
					},
					{
						Expected: "other",
						Integers: []string{"9", "10", "19", "29", "30", "39", "49", "59", "69", "79", "109", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"be"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n10 == 1 && n100 != 11"},
				{Form: "few", Cond: "p && n10 >= 2 && n10 <= 4 && (n100 < 12 || n100 > 14)"},
				{Form: "many", Cond: "n10 == 0 || p && n10 >= 5 && n10 <= 9 || p && n100 >= 11 && n100 <= 14"},
			},
			Ordinal: Cases{
				{Form: "few", Cond: "(n10 == 2 || n10 == 3) && n100 != 12 && n100 != 13"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
						Decimals: []string{"1.0", "21.0", "31.0", "41.0", "51.0", "61.0", "71.0", "81.0", "101.0", "1001.0"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "4", "22", "24", "32", "34", "42", "44", "52", "54", "62", "102", "1002"},
						Decimals: []string{"2.0", "3.0", "4.0", "22.0", "23.0", "24.0", "32.0", "33.0", "102.0", "1002.0"},
					},
					{
						Expected: "many",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "11.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",

						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.1", "100.1", "1000.1"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "few",
						Integers: []string{"2", "3", "22", "23", "32", "33", "42", "43", "52", "53", "62", "63", "72", "73", "82", "83", "102", "1002"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "1", "4", "17", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"br"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n10 == 1 && n100 != 11 && n100 != 71 && n100 != 91"},
				{Form: "two", Cond: "n10 == 2 && n100 != 12 && n100 != 72 && n100 != 92"},
				{Form: "few", Cond: "p && (p && n10 >= 3 && n10 <= 4 || n10 == 9) && (n100 < 10 || n100 > 19) && (n100 < 70 || n100 > 79) && (n100 < 90 || n100 > 99)"},
				{Form: "many", Cond: "n != 0 && n1000000 == 0"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
				{Symbol: N, Mod: 1000000},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "81", "101", "1001"},
						Decimals: []string{"1.0", "21.0", "31.0", "41.0", "51.0", "61.0", "81.0", "101.0", "1001.0"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "22", "32", "42", "52", "62", "82", "102", "1002"},
						Decimals: []string{"2.0", "22.0", "32.0", "42.0", "52.0", "62.0", "82.0", "102.0", "1002.0"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "4", "9", "23", "24", "29", "33", "34", "39", "43", "44", "49", "103", "1003"},
						Decimals: []string{"3.0", "4.0", "9.0", "23.0", "24.0", "29.0", "33.0", "34.0", "103.0", "1003.0"},
					},
					{
						Expected: "many",
						Integers: []string{"1000000"},
						Decimals: []string{"1000000.0", "1000000.00", "1000000.000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "8", "10", "20", "100", "1000", "10000", "100000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"bs", "hr", "sh", "sr", "sr-Latn"},
			F:     F, I: I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11"},
				{Form: "few", Cond: "v == 0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14) || f10 >= 2 && f10 <= 4 && (f100 < 12 || f100 > 14)"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
				{Symbol: F, Mod: 10},
				{Symbol: F, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
						Decimals: []string{"0.1", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "4", "22", "24", "32", "34", "42", "44", "52", "54", "62", "102", "1002"},
						Decimals: []string{"0.2", "0.4", "1.2", "1.4", "2.2", "2.4", "3.2", "3.4", "4.2", "4.4", "5.2", "10.2", "100.2", "1000.2"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.5", "1.0", "1.5", "2.0", "2.5", "2.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ca"},
			I:     I, N: N, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1 || n == 3"},
				{Form: "two", Cond: "n == 2"},
				{Form: "few", Cond: "n == 4"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "3"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
					},
					{
						Expected: "few",
						Integers: []string{"4"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ceb"},
			F:     F, I: I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && (i == 1 || i == 2 || i == 3) || v == 0 && i10 != 4 && i10 != 6 && i10 != 9 || v != 0 && f10 != 4 && f10 != 6 && f10 != 9"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: F, Mod: 10},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "3", "5", "7", "8", "10", "13", "15", "17", "18", "20", "21", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.3", "0.5", "0.7", "0.8", "1.0", "1.3", "1.5", "1.7", "1.8", "2.0", "2.1", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"4", "6", "9", "14", "16", "19", "24", "26", "104", "1004"},
						Decimals: []string{"0.4", "0.6", "0.9", "1.4", "1.6", "1.9", "2.4", "2.6", "10.4", "100.4", "1000.4"},
					},
				},
			},
		},
		{
			Langs: []string{"cs", "sk"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
				{Form: "few", Cond: "i >= 2 && i <= 4 && v == 0"},
				{Form: "many", Cond: "v != 0"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "4"},
					},
					{
						Expected: "many",

						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"cy"},
			N:     N,
			Cardinal: Cases{
				{Form: "zero", Cond: "n == 0"},
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2"},
				{Form: "few", Cond: "n == 3"},
				{Form: "many", Cond: "n == 6"},
			},
			Ordinal: Cases{
				{Form: "zero", Cond: "n == 0 || n == 7 || n == 8 || n == 9"},
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2"},
				{Form: "few", Cond: "n == 3 || n == 4"},
				{Form: "many", Cond: "n == 5 || n == 6"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
						Decimals: []string{"2.0", "2.00", "2.000", "2.0000"},
					},
					{
						Expected: "few",
						Integers: []string{"3"},
						Decimals: []string{"3.0", "3.00", "3.000", "3.0000"},
					},
					{
						Expected: "many",
						Integers: []string{"6"},
						Decimals: []string{"6.0", "6.00", "6.000", "6.0000"},
					},
					{
						Expected: "zero",
						Integers: []string{"0"},
						Decimals: []string{"0.0", "0.00", "0.000", "0.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"4", "5", "7", "20", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "4"},
					},
					{
						Expected: "many",
						Integers: []string{"5", "6"},
					},
					{
						Expected: "zero",
						Integers: []string{"0", "7", "9"},
					},
					{
						Expected: "other",
						Integers: []string{"10", "25", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"da"},
			I:     I, N: N, T: T,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1 || t != 0 && (i == 0 || i == 1)"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"0.1", "1.6"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "2.0", "3.4", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"de", "et", "fi", "fy", "gl", "ia", "nl", "sw", "ur"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"dsb", "hsb"},
			F:     F, I: I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i100 == 1 || f100 == 1"},
				{Form: "two", Cond: "v == 0 && i100 == 2 || f100 == 2"},
				{Form: "few", Cond: "v == 0 && i100 >= 3 && i100 <= 4 || f100 >= 3 && f100 <= 4"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 100},
				{Symbol: F, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "101", "201", "301", "401", "501", "601", "701", "1001"},
						Decimals: []string{"0.1", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "102", "202", "302", "402", "502", "602", "702", "1002"},
						Decimals: []string{"0.2", "1.2", "2.2", "3.2", "4.2", "5.2", "6.2", "7.2", "10.2", "100.2", "1000.2"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "4", "103", "104", "203", "204", "303", "304", "403", "404", "503", "504", "603", "604", "703", "704", "1003"},
						Decimals: []string{"0.3", "0.4", "1.3", "1.4", "2.3", "2.4", "3.3", "3.4", "4.3", "4.4", "5.3", "5.4", "6.3", "6.4", "7.3", "7.4", "10.3", "100.3", "1000.3"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.5", "1.0", "1.5", "2.0", "2.5", "2.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"en"},
			I:     I, N: N, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n10 == 1 && n100 != 11"},
				{Form: "two", Cond: "n10 == 2 && n100 != 12"},
				{Form: "few", Cond: "n10 == 3 && n100 != 13"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "22", "32", "42", "52", "62", "72", "82", "102", "1002"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "23", "33", "43", "53", "63", "73", "83", "103", "1003"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "4", "18", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ff", "kab"},
			I:     I,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 0 || i == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.5"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"2.0", "3.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"fil", "tl"},
			F:     F, I: I, N: N, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && (i == 1 || i == 2 || i == 3) || v == 0 && i10 != 4 && i10 != 6 && i10 != 9 || v != 0 && f10 != 4 && f10 != 6 && f10 != 9"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: F, Mod: 10},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "3", "5", "7", "8", "10", "13", "15", "17", "18", "20", "21", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.3", "0.5", "0.7", "0.8", "1.0", "1.3", "1.5", "1.7", "1.8", "2.0", "2.1", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"4", "6", "9", "14", "16", "19", "24", "26", "104", "1004"},
						Decimals: []string{"0.4", "0.6", "0.9", "1.4", "1.6", "1.9", "2.4", "2.6", "10.4", "100.4", "1000.4"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"fr", "hy"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 0 || i == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.5"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"2.0", "3.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ga"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2"},
				{Form: "few", Cond: "p && n >= 3 && n <= 6"},
				{Form: "many", Cond: "p && n >= 7 && n <= 10"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
						Decimals: []string{"2.0", "2.00", "2.000", "2.0000"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "6"},
						Decimals: []string{"3.0", "4.0", "5.0", "6.0", "3.00", "4.00", "5.00", "6.00", "3.000", "4.000", "5.000", "6.000", "3.0000", "4.0000", "5.0000", "6.0000"},
					},
					{
						Expected: "many",
						Integers: []string{"7", "10"},
						Decimals: []string{"7.0", "8.0", "9.0", "10.0", "7.00", "8.00", "9.00", "10.00", "7.000", "8.000", "9.000", "10.000", "7.0000", "8.0000", "9.0000", "10.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "11", "25", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"gd"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1 || n == 11"},
				{Form: "two", Cond: "n == 2 || n == 12"},
				{Form: "few", Cond: "p && n >= 3 && n <= 10 || p && n >= 13 && n <= 19"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1 || n == 11"},
				{Form: "two", Cond: "n == 2 || n == 12"},
				{Form: "few", Cond: "n == 3 || n == 13"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "11"},
						Decimals: []string{"1.0", "11.0", "1.00", "11.00", "1.000", "11.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "12"},
						Decimals: []string{"2.0", "12.0", "2.00", "12.00", "2.000", "12.000", "2.0000"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "10", "13", "19"},
						Decimals: []string{"3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "19.0", "3.00"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "20", "34", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "11"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "12"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "13"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "4", "10", "14", "21", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"gu", "hi"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 0 || n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2 || n == 3"},
				{Form: "few", Cond: "n == 4"},
				{Form: "many", Cond: "n == 6"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.0", "0.00", "0.04"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"1.1", "2.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "3"},
					},
					{
						Expected: "few",
						Integers: []string{"4"},
					},
					{
						Expected: "many",
						Integers: []string{"6"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "7", "20", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"gv"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i10 == 1"},
				{Form: "two", Cond: "v == 0 && i10 == 2"},
				{Form: "few", Cond: "v == 0 && (i100 == 0 || i100 == 20 || i100 == 40 || i100 == 60 || i100 == 80)"},
				{Form: "many", Cond: "v != 0"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "11", "21", "31", "41", "51", "61", "71", "101", "1001"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "12", "22", "32", "42", "52", "62", "72", "102", "1002"},
					},
					{
						Expected: "few",
						Integers: []string{"0", "20", "40", "60", "80", "100", "120", "140", "1000", "10000", "100000", "1000000"},
					},
					{
						Expected: "many",

						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"3", "10", "13", "19", "23", "103", "1003"},
					},
				},
			},
		},
		{
			Langs: []string{"he", "iw"},
			I:     I, N: N, V: V, W: W, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
				{Form: "two", Cond: "i == 2 && v == 0"},
				{Form: "many", Cond: "p && v == 0 && (n < 0 || n > 10) && n10 == 0"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 10},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
					},
					{
						Expected: "many",
						Integers: []string{"20", "30", "40", "50", "60", "70", "80", "90", "100", "1000", "10000", "100000", "1000000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "3", "17", "101", "1001"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"hu"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1 || n == 5"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "5"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "4", "6", "17", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"is"},
			I:     I, T: T,
			Cardinal: Cases{
				{Form: "one", Cond: "t == 0 && i10 == 1 && i100 != 11 || t != 0"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
						Decimals: []string{"0.1", "1.6", "10.1", "100.1", "1000.1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"it", "sc", "scn"},
			I:     I, N: N, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
			},
			Ordinal: Cases{
				{Form: "many", Cond: "n == 11 || n == 8 || n == 80 || n == 800"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "many",
						Integers: []string{"8", "11", "80", "800"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "7", "9", "10", "12", "17", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"iu", "naq", "se", "sma", "smi", "smj", "smn", "sms"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2"},
						Decimals: []string{"2.0", "2.00", "2.000", "2.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "3", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"ka"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "i == 1"},
				{Form: "many", Cond: "i == 0 || i100 >= 2 && i100 <= 20 || i100 == 40 || i100 == 60 || i100 == 80"},
			},
			Vars: []Var{
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "many",
						Integers: []string{"0", "2", "16", "102", "1002"},
					},
					{
						Expected: "other",
						Integers: []string{"21", "36", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"kk"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "many", Cond: "n10 == 6 || n10 == 9 || n10 == 0 && n != 0"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "many",
						Integers: []string{"6", "9", "10", "16", "19", "20", "26", "29", "30", "36", "39", "40", "100", "1000", "10000", "100000", "1000000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "7", "8", "11", "15", "17", "18", "21", "101", "1001"},
					},
				},
			},
		},
		{
			Langs: []string{"ksh"},
			N:     N,
			Cardinal: Cases{
				{Form: "zero", Cond: "n == 0"},
				{Form: "one", Cond: "n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "zero",
						Integers: []string{"0"},
						Decimals: []string{"0.0", "0.00", "0.000", "0.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"kw"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "zero", Cond: "n == 0"},
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n100 == 2 || n100 == 22 || n100 == 42 || n100 == 62 || n100 == 82"},
				{Form: "few", Cond: "n100 == 3 || n100 == 23 || n100 == 43 || n100 == 63 || n100 == 83"},
				{Form: "many", Cond: "n != 1 && (n100 == 1 || n100 == 21 || n100 == 41 || n100 == 61 || n100 == 81)"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "p && n >= 1 && n <= 4 || p && n100 >= 1 && n100 <= 4 || p && n100 >= 21 && n100 <= 24 || p && n100 >= 41 && n100 <= 44 || p && n100 >= 61 && n100 <= 64 || p && n100 >= 81 && n100 <= 84"},
				{Form: "many", Cond: "n == 5 || n100 == 5"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "22", "42", "62", "82", "102", "122", "142", "1002"},
						Decimals: []string{"2.0", "22.0", "42.0", "62.0", "82.0", "102.0", "122.0", "142.0", "1002.0"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "23", "43", "63", "83", "103", "123", "143", "1003"},
						Decimals: []string{"3.0", "23.0", "43.0", "63.0", "83.0", "103.0", "123.0", "143.0", "1003.0"},
					},
					{
						Expected: "many",
						Integers: []string{"21", "41", "61", "81", "101", "121", "141", "161", "1001"},
						Decimals: []string{"21.0", "41.0", "61.0", "81.0", "101.0", "121.0", "141.0", "161.0", "1001.0"},
					},
					{
						Expected: "zero",
						Integers: []string{"0"},
						Decimals: []string{"0.0", "0.00", "0.000", "0.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"4", "19", "100", "1004", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.0", "100.0", "1000.1", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "4", "21", "24", "41", "44", "61", "64", "101", "1001"},
					},
					{
						Expected: "many",
						Integers: []string{"5", "105", "205", "305", "405", "505", "605", "705", "1005"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "6", "20", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"lag"},
			I:     I, N: N,
			Cardinal: Cases{
				{Form: "zero", Cond: "n == 0"},
				{Form: "one", Cond: "(i == 0 || i == 1) && n != 0"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"0.1", "1.6"},
					},
					{
						Expected: "zero",
						Integers: []string{"0"},
						Decimals: []string{"0.0", "0.00", "0.000", "0.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"2.0", "3.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"lo", "ms", "vi"},
			N:     N,

			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"lt"},
			F:     F, N: N, W: W, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "p && n10 == 1 && (n100 < 11 || n100 > 19)"},
				{Form: "few", Cond: "p && n10 >= 2 && n10 <= 9 && (n100 < 11 || n100 > 19)"},
				{Form: "many", Cond: "f != 0"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
						Decimals: []string{"1.0", "21.0", "31.0", "41.0", "51.0", "61.0", "71.0", "81.0", "101.0", "1001.0"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "9", "22", "29", "102", "1002"},
						Decimals: []string{"2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "22.0", "102.0", "1002.0"},
					},
					{
						Expected: "many",

						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.1", "100.1", "1000.1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "10", "20", "30", "40", "50", "60", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "10.0", "11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"lv", "prg"},
			F:     F, N: N, V: V, W: W, P: P,
			Cardinal: Cases{
				{Form: "zero", Cond: "n10 == 0 || p && n100 >= 11 && n100 <= 19 || v == 2 && f100 >= 11 && f100 <= 19"},
				{Form: "one", Cond: "n10 == 1 && n100 != 11 || v == 2 && f10 == 1 && f100 != 11 || v != 2 && f10 == 1"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
				{Symbol: F, Mod: 100},
				{Symbol: F, Mod: 10},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
						Decimals: []string{"0.1", "1.0", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"},
					},
					{
						Expected: "zero",
						Integers: []string{"0", "10", "20", "30", "40", "50", "60", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "10.0", "11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "9", "22", "29", "102", "1002"},
						Decimals: []string{"0.2", "0.9", "1.2", "1.9", "10.2", "100.2", "1000.2"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"mk"},
			F:     F, I: I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i10 == 1 && i100 != 11 || f10 == 1 && f100 != 11"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "i10 == 1 && i100 != 11"},
				{Form: "two", Cond: "i10 == 2 && i100 != 12"},
				{Form: "many", Cond: "(i10 == 7 || i10 == 8) && i100 != 17 && i100 != 18"},
			},
			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
				{Symbol: F, Mod: 10},
				{Symbol: F, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
						Decimals: []string{"0.1", "1.1", "2.1", "3.1", "4.1", "5.1", "6.1", "7.1", "10.1", "100.1", "1000.1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.2", "1.0", "1.2", "1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "22", "32", "42", "52", "62", "72", "82", "102", "1002"},
					},
					{
						Expected: "many",
						Integers: []string{"7", "8", "27", "28", "37", "38", "47", "48", "57", "58", "67", "68", "77", "78", "87", "88", "107", "1007"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "3", "6", "9", "19", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"mo", "ro", "ro-MD"},
			I:     I, N: N, V: V, W: W, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
				{Form: "few", Cond: "v != 0 || n == 0 || p && n100 >= 2 && n100 <= 19"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "few",
						Integers: []string{"0", "2", "16", "102", "1002"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"20", "35", "100", "1000", "10000", "100000", "1000000"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"mr"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
				{Form: "two", Cond: "n == 2 || n == 3"},
				{Form: "few", Cond: "n == 4"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "3"},
					},
					{
						Expected: "few",
						Integers: []string{"4"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"mt"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
				{Form: "few", Cond: "n == 0 || p && n100 >= 2 && n100 <= 10"},
				{Form: "many", Cond: "p && n100 >= 11 && n100 <= 19"},
			},

			Vars: []Var{
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "few",
						Integers: []string{"0", "2", "10", "102", "107", "1002"},
						Decimals: []string{"0.0", "2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "10.0", "102.0", "1002.0"},
					},
					{
						Expected: "many",
						Integers: []string{"11", "19", "111", "117", "1011"},
						Decimals: []string{"11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "111.0", "1011.0"},
					},
					{
						Expected: "other",
						Integers: []string{"20", "35", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"ne"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "p && n >= 1 && n <= 4"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "4"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"or"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1 || n == 5 || p && n >= 7 && n <= 9"},
				{Form: "two", Cond: "n == 2 || n == 3"},
				{Form: "few", Cond: "n == 4"},
				{Form: "many", Cond: "n == 6"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "5", "7", "9"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "3"},
					},
					{
						Expected: "few",
						Integers: []string{"4"},
					},
					{
						Expected: "many",
						Integers: []string{"6"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "10", "24", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"pa"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "p && n >= 0 && n <= 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.0", "0.00", "1.00", "0.000", "1.000", "0.0000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"pl"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
				{Form: "few", Cond: "v == 0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14)"},
				{Form: "many", Cond: "v == 0 && i != 1 && i10 >= 0 && i10 <= 1 || v == 0 && i10 >= 5 && i10 <= 9 || v == 0 && i100 >= 12 && i100 <= 14"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "4", "22", "24", "32", "34", "42", "44", "52", "54", "62", "102", "1002"},
					},
					{
						Expected: "many",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
					{
						Expected: "other",

						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"pt"},
			I:     I,
			Cardinal: Cases{
				{Form: "one", Cond: "i >= 0 && i <= 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.5"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"2.0", "3.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"ru"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i10 == 1 && i100 != 11"},
				{Form: "few", Cond: "v == 0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14)"},
				{Form: "many", Cond: "v == 0 && i10 == 0 || v == 0 && i10 >= 5 && i10 <= 9 || v == 0 && i100 >= 11 && i100 <= 14"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "4", "22", "24", "32", "34", "42", "44", "52", "54", "62", "102", "1002"},
					},
					{
						Expected: "many",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
					{
						Expected: "other",

						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"shi"},
			I:     I, N: N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 0 || n == 1"},
				{Form: "few", Cond: "p && n >= 2 && n <= 10"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "1.0", "0.00", "0.04"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "10"},
						Decimals: []string{"2.0", "3.0", "4.0", "5.0", "6.0", "7.0", "8.0", "9.0", "10.0", "2.00", "3.00", "4.00", "5.00", "6.00", "7.00", "8.00"},
					},
					{
						Expected: "other",
						Integers: []string{"11", "26", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"1.1", "1.9", "2.1", "2.7", "10.1", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"si"},
			F:     F, I: I, N: N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 0 || n == 1 || i == 0 && f == 1"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1"},
						Decimals: []string{"0.0", "0.1", "1.0", "0.00", "0.01", "1.00", "0.000", "0.001", "1.000", "0.0000", "0.0001", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "17", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.2", "0.9", "1.1", "1.8", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"sl"},
			I:     I, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i100 == 1"},
				{Form: "two", Cond: "v == 0 && i100 == 2"},
				{Form: "few", Cond: "v == 0 && i100 >= 3 && i100 <= 4 || v != 0"},
			},

			Vars: []Var{
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "101", "201", "301", "401", "501", "601", "701", "1001"},
					},
					{
						Expected: "two",
						Integers: []string{"2", "102", "202", "302", "402", "502", "602", "702", "1002"},
					},
					{
						Expected: "few",
						Integers: []string{"3", "4", "103", "104", "203", "204", "303", "304", "403", "404", "503", "504", "603", "604", "703", "704", "1003"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "other",
						Integers: []string{"0", "15", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"sq"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "n == 1"},
				{Form: "many", Cond: "n10 == 4 && n100 != 14"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "many",
						Integers: []string{"4", "24", "34", "44", "54", "64", "74", "84", "104", "1004"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "3", "5", "17", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"sv"},
			I:     I, N: N, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "i == 1 && v == 0"},
			},
			Ordinal: Cases{
				{Form: "one", Cond: "(n10 == 1 || n10 == 2) && n100 != 11 && n100 != 12"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "2", "21", "22", "31", "32", "41", "42", "51", "52", "61", "62", "71", "72", "81", "82", "101", "1001"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "3", "17", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"tk"},
			N:     N,
			Cardinal: Cases{
				{Form: "one", Cond: "n == 1"},
			},
			Ordinal: Cases{
				{Form: "few", Cond: "n10 == 6 || n10 == 9 || n == 10"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1"},
						Decimals: []string{"1.0", "1.00", "1.000", "1.0000"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "16", "100", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.0", "0.9", "1.1", "1.6", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "few",
						Integers: []string{"6", "9", "10", "16", "19", "26", "29", "36", "39", "106", "1006"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "5", "7", "8", "11", "15", "17", "18", "20", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
		{
			Langs: []string{"tzm"},
			N:     N, P: P,
			Cardinal: Cases{
				{Form: "one", Cond: "p && n >= 0 && n <= 1 || p && n >= 11 && n <= 99"},
			},

			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"0", "1", "11", "24"},
						Decimals: []string{"0.0", "1.0", "11.0", "12.0", "13.0", "14.0", "15.0", "16.0", "17.0", "18.0", "19.0", "20.0", "21.0", "22.0", "23.0", "24.0"},
					},
					{
						Expected: "other",
						Integers: []string{"2", "10", "100", "106", "1000", "10000", "100000", "1000000"},
						Decimals: []string{"0.1", "0.9", "1.1", "1.7", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
			},
		},
		{
			Langs: []string{"uk"},
			I:     I, N: N, V: V,
			Cardinal: Cases{
				{Form: "one", Cond: "v == 0 && i10 == 1 && i100 != 11"},
				{Form: "few", Cond: "v == 0 && i10 >= 2 && i10 <= 4 && (i100 < 12 || i100 > 14)"},
				{Form: "many", Cond: "v == 0 && i10 == 0 || v == 0 && i10 >= 5 && i10 <= 9 || v == 0 && i100 >= 11 && i100 <= 14"},
			},
			Ordinal: Cases{
				{Form: "few", Cond: "n10 == 3 && n100 != 13"},
			},
			Vars: []Var{
				{Symbol: N, Mod: 10},
				{Symbol: N, Mod: 100},
				{Symbol: I, Mod: 10},
				{Symbol: I, Mod: 100},
			},
			Tests: UnitTests{
				Cardinal: []UnitTest{
					{
						Expected: "one",
						Integers: []string{"1", "21", "31", "41", "51", "61", "71", "81", "101", "1001"},
					},
					{
						Expected: "few",
						Integers: []string{"2", "4", "22", "24", "32", "34", "42", "44", "52", "54", "62", "102", "1002"},
					},
					{
						Expected: "many",
						Integers: []string{"0", "5", "19", "100", "1000", "10000", "100000", "1000000"},
					},
					{
						Expected: "other",

						Decimals: []string{"0.0", "1.5", "10.0", "100.0", "1000.0", "10000.0", "100000.0", "1000000.0"},
					},
				},
				Ordinal: []UnitTest{
					{
						Expected: "few",
						Integers: []string{"3", "23", "33", "43", "53", "63", "73", "83", "103", "1003"},
					},
					{
						Expected: "other",
						Integers: []string{"0", "2", "4", "16", "100", "1000", "10000", "100000", "1000000"},
					},
				},
			},
		},
	},
	Others: []string{"bm", "bo", "dz", "id", "ig", "ii", "in", "ja", "jbo", "jv", "jw", "kde", "kea", "km", "ko", "lkt", "my", "nqo", "osa", "root", "sah", "ses", "sg", "su", "th", "to", "wo", "yo", "yue", "zh"},
}

Functions ¶

func GetFunc ¶

func GetFunc(culture language.Tag) (func(interface{}, bool) string, error)

Types ¶

type Case ¶

type Case struct {
	Form string
	Cond string
}

type Cases ¶

type Cases []Case

func (Cases) ToMap ¶

func (s Cases) ToMap() (m map[string]*Case)

type Culture ¶

type Culture struct {
	Langs []string

	// Symbols plus P
	F, I, N, V, T, W, P Symbol

	// Cardinal defines the plural rules for numbers indicating quantities.
	Cardinal Cases

	// Ordinal defines the plural rules for numbers indicating position
	// (first, second, etc.).
	Ordinal Cases

	// Vars only come from mod
	Vars []Var

	Tests UnitTests
}

func (Culture) HasCardinal ¶

func (c Culture) HasCardinal() bool

func (Culture) HasCardinalTest ¶

func (c Culture) HasCardinalTest() bool

func (Culture) HasOrdinal ¶

func (c Culture) HasOrdinal() bool

func (Culture) HasOrdinalTest ¶

func (c Culture) HasOrdinalTest() bool

func (Culture) HasTest ¶

func (c Culture) HasTest() bool

func (Culture) HasVars ¶

func (c Culture) HasVars() bool

func (Culture) NeedFinvtw ¶

func (c Culture) NeedFinvtw() bool

type PluralInfo ¶

type PluralInfo struct {
	Cultures []Culture
	Others   []string
	// contains filtered or unexported fields
}

func (*PluralInfo) CulturesMap ¶

func (pi *PluralInfo) CulturesMap() map[language.Tag]*Culture

func (*PluralInfo) Find ¶

func (pi *PluralInfo) Find(lang language.Tag) (c *Culture, on language.Tag, found bool)

func (*PluralInfo) IsOthers ¶

func (pi *PluralInfo) IsOthers(cultrue language.Tag) bool

func (*PluralInfo) Langs ¶

func (pi *PluralInfo) Langs() []string

func (*PluralInfo) Validate ¶

func (pi *PluralInfo) Validate(langs []string) (parseFailed, findFailed []string, ok bool)

type Symbol ¶

type Symbol byte

const U, F, I, N, V, T, W, P Symbol = 0, 'f', 'i', 'n', 'v', 't', 'w', 'p'

where

n  absolute value of the source number (integer and decimals)

input

	i  integer digits of n.
	v  number of visible fraction digits in n, with trailing zeros.
	w  number of visible fraction digits in n, without trailing zeros.
	f  visible fractional digits in n, with trailing zeros (f = t * 10^(v-w))
	t  visible fractional digits in n, without trailing zeros.
 p := w == 0

func (Symbol) Name ¶

func (s Symbol) Name() string

func (Symbol) String ¶

func (i Symbol) String() string

func (Symbol) Use ¶

func (s Symbol) Use() bool

type UnitTest ¶

type UnitTest struct {
	Expected string
	Integers []string
	Decimals []string
}

type UnitTests ¶

type UnitTests struct {
	Cardinal []UnitTest
	Ordinal  []UnitTest
}

type Var ¶

type Var struct {
	Symbol Symbol
	Mod    int
}

func (Var) Name ¶

func (v Var) Name() string

Source Files ¶

View all Source files

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL