pkg.re/essentialkaos/ek.10@v12.41.0+incompatible/pluralize/pluralize_test.go (about) 1 package pluralize 2 3 // ////////////////////////////////////////////////////////////////////////////////// // 4 // // 5 // Copyright (c) 2022 ESSENTIAL KAOS // 6 // Apache License, Version 2.0 <https://www.apache.org/licenses/LICENSE-2.0> // 7 // // 8 // ////////////////////////////////////////////////////////////////////////////////// // 9 10 import ( 11 "testing" 12 13 . "pkg.re/essentialkaos/check.v1" 14 ) 15 16 // ////////////////////////////////////////////////////////////////////////////////// // 17 18 func Test(t *testing.T) { TestingT(t) } 19 20 type PluralizeSuite struct{} 21 22 // ////////////////////////////////////////////////////////////////////////////////// // 23 24 var _ = Suite(&PluralizeSuite{}) 25 26 func (s *PluralizeSuite) TestBasic(c *C) { 27 data := []string{"A", "B"} 28 29 c.Assert(P("%d %s", 1, data...), Equals, "1 A") 30 c.Assert(P("%s %d", 2, data...), Equals, "B 2") 31 c.Assert(PS(En, "%s %d", 2, data...), Equals, "B 2") 32 33 c.Assert(P("%d %s", int32(1), data...), Equals, "1 A") 34 c.Assert(P("%d %s", int64(1), data...), Equals, "1 A") 35 c.Assert(P("%d %s", uint(1), data...), Equals, "1 A") 36 c.Assert(P("%d %s", uint32(1), data...), Equals, "1 A") 37 c.Assert(P("%d %s", uint64(1), data...), Equals, "1 A") 38 c.Assert(P("%g %s", 1.1, data...), Equals, "1.1 A") 39 c.Assert(P("%g %s", float32(1.1), data...), Equals, "1.1 A") 40 c.Assert(P("%g %s", "", data...), Equals, "%g %s") 41 } 42 43 func (s *PluralizeSuite) TestAf(c *C) { 44 data := []string{"A", "B"} 45 46 c.Assert(Pluralize(1, data...), Equals, "A") 47 c.Assert(Pluralize(2), Equals, "") 48 c.Assert(PluralizeSpecial(Af, 1, data...), Equals, "A") 49 c.Assert(PluralizeSpecial(Af, 2, data...), Equals, "B") 50 } 51 52 func (s *PluralizeSuite) TestAch(c *C) { 53 data := []string{"A", "B"} 54 55 c.Assert(PluralizeSpecial(Ach, 0, data...), Equals, "A") 56 c.Assert(PluralizeSpecial(Ach, 1, data...), Equals, "A") 57 c.Assert(PluralizeSpecial(Ach, 3, data...), Equals, "B") 58 } 59 60 func (s *PluralizeSuite) TestBe(c *C) { 61 data := []string{"A", "B", "C"} 62 63 c.Assert(PluralizeSpecial(Be, 1, data...), Equals, "A") 64 c.Assert(PluralizeSpecial(Be, 2, data...), Equals, "B") 65 c.Assert(PluralizeSpecial(Be, 9, data...), Equals, "C") 66 } 67 68 func (s *PluralizeSuite) TestAr(c *C) { 69 data := []string{"A", "B", "C", "D", "E", "F"} 70 71 c.Assert(PluralizeSpecial(Ar, 0, data...), Equals, "A") 72 c.Assert(PluralizeSpecial(Ar, 1, data...), Equals, "B") 73 c.Assert(PluralizeSpecial(Ar, 2, data...), Equals, "C") 74 c.Assert(PluralizeSpecial(Ar, 3, data...), Equals, "D") 75 c.Assert(PluralizeSpecial(Ar, 12, data...), Equals, "E") 76 c.Assert(PluralizeSpecial(Ar, 100, data...), Equals, "F") 77 } 78 79 func (s *PluralizeSuite) TestAy(c *C) { 80 data := []string{"A"} 81 82 c.Assert(PluralizeSpecial(Ay, 1, data...), Equals, "A") 83 c.Assert(PluralizeSpecial(Ay, 2, data...), Equals, "A") 84 c.Assert(PluralizeSpecial(Ay, 9, data...), Equals, "A") 85 } 86 87 func (s *PluralizeSuite) TestCs(c *C) { 88 data := []string{"A", "B", "C"} 89 90 c.Assert(PluralizeSpecial(Cs, 1, data...), Equals, "A") 91 c.Assert(PluralizeSpecial(Cs, 3, data...), Equals, "B") 92 c.Assert(PluralizeSpecial(Cs, 5, data...), Equals, "C") 93 } 94 95 func (s *PluralizeSuite) TestCsb(c *C) { 96 data := []string{"A", "B", "C"} 97 98 c.Assert(PluralizeSpecial(Csb, 1, data...), Equals, "A") 99 c.Assert(PluralizeSpecial(Csb, 3, data...), Equals, "B") 100 c.Assert(PluralizeSpecial(Csb, 25, data...), Equals, "C") 101 } 102 103 func (s *PluralizeSuite) TestCy(c *C) { 104 data := []string{"A", "B", "C", "D"} 105 106 c.Assert(PluralizeSpecial(Cy, 1, data...), Equals, "A") 107 c.Assert(PluralizeSpecial(Cy, 2, data...), Equals, "B") 108 c.Assert(PluralizeSpecial(Cy, 5, data...), Equals, "C") 109 c.Assert(PluralizeSpecial(Cy, 8, data...), Equals, "D") 110 } 111 112 func (s *PluralizeSuite) TestGa(c *C) { 113 data := []string{"A", "B", "C", "D", "E"} 114 115 c.Assert(PluralizeSpecial(Ga, 1, data...), Equals, "A") 116 c.Assert(PluralizeSpecial(Ga, 2, data...), Equals, "B") 117 c.Assert(PluralizeSpecial(Ga, 5, data...), Equals, "C") 118 c.Assert(PluralizeSpecial(Ga, 8, data...), Equals, "D") 119 c.Assert(PluralizeSpecial(Ga, 14, data...), Equals, "E") 120 } 121 122 func (s *PluralizeSuite) TestGd(c *C) { 123 data := []string{"A", "B", "C", "D"} 124 125 c.Assert(PluralizeSpecial(Gd, 1, data...), Equals, "A") 126 c.Assert(PluralizeSpecial(Gd, 11, data...), Equals, "A") 127 c.Assert(PluralizeSpecial(Gd, 2, data...), Equals, "B") 128 c.Assert(PluralizeSpecial(Gd, 12, data...), Equals, "B") 129 c.Assert(PluralizeSpecial(Gd, 3, data...), Equals, "C") 130 c.Assert(PluralizeSpecial(Gd, 25, data...), Equals, "D") 131 } 132 133 func (s *PluralizeSuite) TestIs(c *C) { 134 data := []string{"A", "B"} 135 136 c.Assert(PluralizeSpecial(Is, 11, data...), Equals, "B") 137 c.Assert(PluralizeSpecial(Is, 1, data...), Equals, "A") 138 } 139 140 func (s *PluralizeSuite) TestKw(c *C) { 141 data := []string{"A", "B", "C", "D"} 142 143 c.Assert(PluralizeSpecial(Kw, 1, data...), Equals, "A") 144 c.Assert(PluralizeSpecial(Kw, 2, data...), Equals, "B") 145 c.Assert(PluralizeSpecial(Kw, 3, data...), Equals, "C") 146 c.Assert(PluralizeSpecial(Kw, 4, data...), Equals, "D") 147 } 148 149 func (s *PluralizeSuite) TestLv(c *C) { 150 data := []string{"A", "B", "C"} 151 152 c.Assert(PluralizeSpecial(Lv, 1, data...), Equals, "A") 153 c.Assert(PluralizeSpecial(Lv, 3, data...), Equals, "B") 154 c.Assert(PluralizeSpecial(Lv, 0, data...), Equals, "C") 155 } 156 157 func (s *PluralizeSuite) TestMk(c *C) { 158 data := []string{"A", "B"} 159 160 c.Assert(PluralizeSpecial(Mk, 1, data...), Equals, "A") 161 c.Assert(PluralizeSpecial(Mk, 11, data...), Equals, "A") 162 c.Assert(PluralizeSpecial(Mk, 2, data...), Equals, "B") 163 } 164 165 func (s *PluralizeSuite) TestMnk(c *C) { 166 data := []string{"A", "B", "C"} 167 168 c.Assert(PluralizeSpecial(Mnk, 0, data...), Equals, "A") 169 c.Assert(PluralizeSpecial(Mnk, 1, data...), Equals, "B") 170 c.Assert(PluralizeSpecial(Mnk, 5, data...), Equals, "C") 171 } 172 173 func (s *PluralizeSuite) TestMt(c *C) { 174 data := []string{"A", "B", "C", "D"} 175 176 c.Assert(PluralizeSpecial(Mt, 1, data...), Equals, "A") 177 c.Assert(PluralizeSpecial(Mt, 0, data...), Equals, "B") 178 c.Assert(PluralizeSpecial(Mt, 5, data...), Equals, "B") 179 c.Assert(PluralizeSpecial(Mt, 13, data...), Equals, "C") 180 c.Assert(PluralizeSpecial(Mt, 22, data...), Equals, "D") 181 } 182 183 func (s *PluralizeSuite) TestRo(c *C) { 184 data := []string{"A", "B", "C"} 185 186 c.Assert(PluralizeSpecial(Ro, 1, data...), Equals, "A") 187 c.Assert(PluralizeSpecial(Ro, 0, data...), Equals, "B") 188 c.Assert(PluralizeSpecial(Ro, 15, data...), Equals, "B") 189 c.Assert(PluralizeSpecial(Ro, 25, data...), Equals, "C") 190 } 191 192 func (s *PluralizeSuite) TestSk(c *C) { 193 data := []string{"A", "B", "C"} 194 195 c.Assert(PluralizeSpecial(Sk, 1, data...), Equals, "A") 196 c.Assert(PluralizeSpecial(Sk, 3, data...), Equals, "B") 197 c.Assert(PluralizeSpecial(Sk, 5, data...), Equals, "C") 198 } 199 200 func (s *PluralizeSuite) TestSl(c *C) { 201 data := []string{"A", "B", "C", "D"} 202 203 c.Assert(PluralizeSpecial(Sl, 1, data...), Equals, "B") 204 c.Assert(PluralizeSpecial(Sl, 2, data...), Equals, "C") 205 c.Assert(PluralizeSpecial(Sl, 3, data...), Equals, "D") 206 c.Assert(PluralizeSpecial(Sl, 4, data...), Equals, "A") 207 }