func TestSize(t *testing.T) {
t1 := test.New(t)
hum := GetBytenHumanize([]string{"B", "KB", "MB", "GB", "TB", "PB", "EB"})
for _, pair := range tests {
t1.Eq(hum(pair.Size), pair.Result)
}
}
func Test_IsNil(t *testing.T) {
t1 = test.New(t)
type (
T struct {
f1 string
}
)
var (
m map[string]string
i int
obj interface{}
tt *T
)
// true
t1.Eq(IsNil(m), true)
t1.Eq(IsNil(obj), true)
t1.Eq(IsNil(tt), true)
// false
m = make(map[string]string)
tt = new(T)
obj = tt
t1.Eq(IsNil(i), false)
t1.Eq(IsNil(m), false)
t1.Eq(IsNil(tt), false)
t1.Eq(IsNil(obj), false)
// from interface{}
tt = nil
obj = tt
t1.Eq(obj == nil, false)
t1.Eq(IsNil(obj), true)
}
func Test_IsEmpty(t *testing.T) {
t1 = test.New(t)
var (
v1 int
v2 uint
v3 float32
v4 []string
)
t1.Eq(IsEmpty(v1), true)
t1.Eq(IsEmpty(v2), true)
t1.Eq(IsEmpty(v3), true)
t1.Eq(IsEmpty(v4), true)
v1 = 1
v2 = 1
v3 = -1
v4 = make([]string, 1)
t1.Eq(IsEmpty(v1), false)
t1.Eq(IsEmpty(v2), false)
t1.Eq(IsEmpty(v3), false)
t1.Eq(IsEmpty(v4), false)
}
func Test_MapKeysEq_ok1(t *testing.T) {
t1 = test.New(t)
obj := "nnn"
v.Push(obj)
a := v.Pop()
t1.Eq(a, obj)
a = v.Pop()
t1.Eq(a, nil)
}
func Test1(t *testing.T) {
var fullpath bool
t1 := test.New(t)
v, fullpath := LookupI(V, strings.Split("point.Val1", "."))
t1.Eq(v.(string), "стр")
t1.Eq(fullpath, true)
v, fullpath = LookupI(V, strings.Split("point.Val2.2.SliceVar.1", "."))
t1.Eq(v.(string), "ctr2")
t1.Eq(fullpath, true)
v, fullpath = LookupI(V, strings.Split("point.Val1.ogoPath", "."))
t1.Eq(v.(string), "стр")
t1.Eq(fullpath, false)
}
func Test_1(t *testing.T) {
t1 = test.New(t)
stack.Push(elem)
stack.Push(elem)
stack.Push(elem)
a = stack.PopVal()
t1.Eq(a, elem)
stack.Push(elem)
a = stack.PopVal()
t1.Eq(a, elem)
a = stack.PopPoint()
t1.Eq(a, elem)
a = stack.PopPoint()
t1.Eq(a, elem)
a = stack.PopVal()
t1.Eq(a, []byte(nil))
a = stack.PopPoint()
t1.Eq(a, []byte(nil))
}
func TestED(t *testing.T) {
var (
buf, buf1 []byte
)
t1 := test.New(t)
buf = Encode(buf, inInt)
buf1, _ = json.Marshal(inInt)
t1.Eq(buf, buf1)
buf = buf[:0]
buf = Encode(buf, inSlice)
buf1, _ = json.Marshal(inSlice)
t1.Eq(buf, buf1)
buf = buf[:0]
buf = Encode(buf, inStruct)
buf1, _ = json.Marshal(inStruct)
t1.Eq(buf, buf1)
fmt.Println("nn", string(buf))
fmt.Println("nn", string(buf1))
buf = buf[:0]
}
func TestED(t *testing.T) {
t1 := test.New(t)
Decoder := NewDecoder(buf)
Decoder.Register(&t2{}, tt{})
Encode(buf, inInt)
Decoder.Decode(&outInt)
t1.Eq(inInt, outInt)
buf.ReadWriteReset()
Encode(buf, inStr)
Decoder.Decode(&outStr)
t1.Eq(inStr, outStr)
buf.ReadWriteReset()
Encode(buf, inStr1)
Decoder.Decode(&outStr)
t1.Eq(inStr1, outStr)
buf.ReadWriteReset()
Encode(buf, inBoolf)
Decoder.Decode(&outBool)
t1.Eq(inBoolf, outBool)
buf.ReadWriteReset()
Encode(buf, inBoolt)
Decoder.Decode(&outBool)
t1.Eq(inBoolt, outBool)
buf.ReadWriteReset()
Encode(buf, inCopmlex128)
Decoder.Decode(&outComplex128)
t1.Eq(inCopmlex128, outComplex128)
buf.ReadWriteReset()
Encode(buf, inSlice)
Decoder.Decode(&outSlice)
t1.Eq(inSlice, outSlice)
buf.ReadWriteReset()
Encode(buf, inSlice1)
Decoder.Decode(&outSlice1)
t1.Eq(inSlice1, outSlice1)
buf.ReadWriteReset()
Encode(buf, inArray)
Decoder.Decode(&outArray)
t1.Eq(inArray, outArray)
buf.ReadWriteReset()
Encode(buf, inArray1)
Decoder.Decode(&outArray1)
t1.Eq(inArray1, outArray1)
buf.ReadWriteReset()
Encode(buf, inStruct)
Decoder.Decode(&outStruct)
t1.Eq(inStruct, outStruct)
buf.ReadWriteReset()
Encode(buf, inMap)
Decoder.Decode(&outMap)
t1.Eq(inMap, outMap)
buf.ReadWriteReset()
Encode(buf, inMap1)
Decoder.Decode(&outMap1)
t1.Eq(inMap1, outMap1)
buf.ReadWriteReset()
Encode(buf, inMap2)
Decoder.Decode(&outMap2)
t1.Eq(inMap2, outMap2)
buf.ReadWriteReset()
Encode(buf, inMapN)
Decoder.Decode(&outMapN)
t1.Eq(inMapN, outMapN)
buf.ReadWriteReset()
Encode(buf, inMapInterface)
Decoder.Decode(&outMapInterface)
t1.Eq(inMapInterface, outMapInterface)
buf.ReadWriteReset()
Encode(buf, inSliceInterface)
Decoder.Decode(&outSliceInterface)
t1.Eq(inSliceInterface, outSliceInterface)
buf.ReadWriteReset()
}
func Test_main(t *testing.T) {
t1 = test.New(t)
//_________________ isInt
// positive test cases
t1.Eq(isInt(float64(0)), true)
t1.Eq(isInt(float64(1)), true)
t1.Eq(isInt(float64(0.0)), true)
t1.Eq(isInt(float64(1.0000)), true)
t1.Eq(isInt(float64(-50)), true)
// negative
t1.Eq(isInt(float64(0.1)), false)
t1.Eq(isInt(float64(-0.1)), false)
t1.Eq(isInt(float64(0.00000000000001)), false)
//_________________ pluralRule1
t1.Eq(pluralRule1(float64(0)), uint8(0))
t1.Eq(pluralRule1(float64(0.5)), uint8(0))
t1.Eq(pluralRule1(float64(100)), uint8(0))
//_________________ pluralRule2A
// first form
t1.Eq(pluralRule2A(float64(-1)), uint8(0))
t1.Eq(pluralRule2A(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule2A(float64(0)), uint8(1))
t1.Eq(pluralRule2A(float64(0.5)), uint8(1))
t1.Eq(pluralRule2A(float64(2)), uint8(1))
//_________________ pluralRule2B
// first form
t1.Eq(pluralRule2B(float64(-1)), uint8(0))
t1.Eq(pluralRule2B(float64(0)), uint8(0))
t1.Eq(pluralRule2B(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule2B(float64(0.5)), uint8(1))
t1.Eq(pluralRule2B(float64(2)), uint8(1))
//_________________ pluralRule2C
// first form
t1.Eq(pluralRule2C(float64(-1)), uint8(0))
t1.Eq(pluralRule2C(float64(0)), uint8(0))
t1.Eq(pluralRule2C(float64(0.5)), uint8(0))
t1.Eq(pluralRule2C(float64(1)), uint8(0))
t1.Eq(pluralRule2C(float64(1.5)), uint8(0))
// second form
t1.Eq(pluralRule2C(float64(2)), uint8(1))
t1.Eq(pluralRule2C(float64(2.5)), uint8(1))
t1.Eq(pluralRule2C(float64(100)), uint8(1))
//_________________ pluralRule2D
// first form
t1.Eq(pluralRule2D(float64(-1)), uint8(0))
t1.Eq(pluralRule2D(float64(1)), uint8(0))
t1.Eq(pluralRule2D(float64(21)), uint8(0))
// second form
t1.Eq(pluralRule2D(float64(0)), uint8(1))
t1.Eq(pluralRule2D(float64(0.5)), uint8(1))
t1.Eq(pluralRule2D(float64(2)), uint8(1))
t1.Eq(pluralRule2D(float64(11)), uint8(1))
//_________________ pluralRule2E
// first form
t1.Eq(pluralRule2E(float64(-1)), uint8(0))
t1.Eq(pluralRule2E(float64(0)), uint8(0))
t1.Eq(pluralRule2E(float64(1)), uint8(0))
t1.Eq(pluralRule2E(float64(11)), uint8(0))
t1.Eq(pluralRule2E(float64(12)), uint8(0))
t1.Eq(pluralRule2E(float64(98)), uint8(0))
t1.Eq(pluralRule2E(float64(99)), uint8(0))
// second form
t1.Eq(pluralRule2E(float64(0.5)), uint8(1))
t1.Eq(pluralRule2E(float64(2)), uint8(1))
t1.Eq(pluralRule2E(float64(10)), uint8(1))
t1.Eq(pluralRule2E(float64(100)), uint8(1))
//_________________ pluralRule2F
// first form
t1.Eq(pluralRule2F(float64(-1)), uint8(0))
t1.Eq(pluralRule2F(float64(0)), uint8(0))
t1.Eq(pluralRule2F(float64(1)), uint8(0))
t1.Eq(pluralRule2F(float64(2)), uint8(0))
t1.Eq(pluralRule2F(float64(11)), uint8(0))
t1.Eq(pluralRule2F(float64(12)), uint8(0))
t1.Eq(pluralRule2F(float64(20)), uint8(0))
t1.Eq(pluralRule2F(float64(40)), uint8(0))
// second form
t1.Eq(pluralRule2F(float64(0.5)), uint8(1))
t1.Eq(pluralRule2F(float64(3)), uint8(1))
t1.Eq(pluralRule2F(float64(10)), uint8(1))
//_________________ pluralRule3A
// first form
t1.Eq(pluralRule3A(float64(0)), uint8(0))
// second form
t1.Eq(pluralRule3A(float64(-1)), uint8(1))
t1.Eq(pluralRule3A(float64(1)), uint8(1))
t1.Eq(pluralRule3A(float64(21)), uint8(1))
// third form
t1.Eq(pluralRule3A(float64(0.5)), uint8(2))
t1.Eq(pluralRule3A(float64(2)), uint8(2))
t1.Eq(pluralRule3A(float64(10)), uint8(2))
t1.Eq(pluralRule3A(float64(11)), uint8(2))
//_________________ pluralRule3B
// first form
t1.Eq(pluralRule3B(float64(-1)), uint8(0))
t1.Eq(pluralRule3B(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule3B(float64(-2)), uint8(1))
t1.Eq(pluralRule3B(float64(2)), uint8(1))
// third form
t1.Eq(pluralRule3B(float64(0)), uint8(2))
t1.Eq(pluralRule3B(float64(0.5)), uint8(2))
t1.Eq(pluralRule3B(float64(3)), uint8(2))
t1.Eq(pluralRule3B(float64(11)), uint8(2))
//_________________ pluralRule3C
// first form
t1.Eq(pluralRule3C(float64(-1)), uint8(0))
t1.Eq(pluralRule3C(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule3C(float64(0)), uint8(1))
t1.Eq(pluralRule3C(float64(-11)), uint8(1))
t1.Eq(pluralRule3C(float64(11)), uint8(1))
t1.Eq(pluralRule3C(float64(19)), uint8(1))
t1.Eq(pluralRule3C(float64(111)), uint8(1))
t1.Eq(pluralRule3C(float64(119)), uint8(1))
// third form
t1.Eq(pluralRule3C(float64(0.5)), uint8(2))
t1.Eq(pluralRule3C(float64(20)), uint8(2))
t1.Eq(pluralRule3C(float64(21)), uint8(2))
//_________________ pluralRule3D
// first form
t1.Eq(pluralRule3D(float64(-1)), uint8(0))
t1.Eq(pluralRule3D(float64(1)), uint8(0))
t1.Eq(pluralRule3D(float64(21)), uint8(0))
// second form
t1.Eq(pluralRule3D(float64(-2)), uint8(1))
t1.Eq(pluralRule3D(float64(2)), uint8(1))
t1.Eq(pluralRule3D(float64(9)), uint8(1))
t1.Eq(pluralRule3D(float64(22)), uint8(1))
t1.Eq(pluralRule3D(float64(29)), uint8(1))
// third form
t1.Eq(pluralRule3D(float64(0)), uint8(2))
t1.Eq(pluralRule3D(float64(0.5)), uint8(2))
t1.Eq(pluralRule3D(float64(11)), uint8(2))
t1.Eq(pluralRule3D(float64(19)), uint8(2))
//_________________ pluralRule3E
// first form
t1.Eq(pluralRule3E(float64(-1)), uint8(0))
t1.Eq(pluralRule3E(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule3E(float64(-2)), uint8(1))
t1.Eq(pluralRule3E(float64(2)), uint8(1))
t1.Eq(pluralRule3E(float64(3)), uint8(1))
t1.Eq(pluralRule3E(float64(4)), uint8(1))
// third form
t1.Eq(pluralRule3E(float64(0)), uint8(2))
t1.Eq(pluralRule3E(float64(0.5)), uint8(2))
t1.Eq(pluralRule3E(float64(5)), uint8(2))
t1.Eq(pluralRule3E(float64(9)), uint8(2))
t1.Eq(pluralRule3E(float64(11)), uint8(2))
t1.Eq(pluralRule3E(float64(12)), uint8(2))
t1.Eq(pluralRule3E(float64(14)), uint8(2))
//_________________ pluralRule3F
// first form
t1.Eq(pluralRule3F(float64(0)), uint8(0))
// second form
t1.Eq(pluralRule3F(float64(-0.5)), uint8(1))
t1.Eq(pluralRule3F(float64(0.5)), uint8(1))
t1.Eq(pluralRule3F(float64(1)), uint8(1))
t1.Eq(pluralRule3F(float64(1.5)), uint8(1))
// third form
t1.Eq(pluralRule3F(float64(-2)), uint8(2))
t1.Eq(pluralRule3F(float64(2)), uint8(2))
t1.Eq(pluralRule3F(float64(3)), uint8(2))
//_________________ pluralRule3G
// first form
t1.Eq(pluralRule3G(float64(-0.5)), uint8(0))
t1.Eq(pluralRule3G(float64(0)), uint8(0))
t1.Eq(pluralRule3G(float64(0.5)), uint8(0))
t1.Eq(pluralRule3G(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule3G(float64(-2)), uint8(1))
t1.Eq(pluralRule3G(float64(2)), uint8(1))
t1.Eq(pluralRule3G(float64(3)), uint8(1))
t1.Eq(pluralRule3G(float64(9)), uint8(1))
t1.Eq(pluralRule3G(float64(10)), uint8(1))
// third
t1.Eq(pluralRule3G(float64(1.5)), uint8(2))
t1.Eq(pluralRule3G(float64(11)), uint8(2))
t1.Eq(pluralRule3G(float64(12)), uint8(2))
//_________________ pluralRule3H
// first form
t1.Eq(pluralRule3H(float64(0)), uint8(0))
// second form
t1.Eq(pluralRule3H(float64(-1)), uint8(1))
t1.Eq(pluralRule3H(float64(1)), uint8(1))
// third form
t1.Eq(pluralRule3H(float64(0.5)), uint8(2))
t1.Eq(pluralRule3H(float64(1.5)), uint8(2))
t1.Eq(pluralRule3H(float64(2)), uint8(2))
t1.Eq(pluralRule3H(float64(10)), uint8(2))
t1.Eq(pluralRule3H(float64(11)), uint8(2))
//_________________ pluralRule3I
// first form
t1.Eq(pluralRule3I(float64(-1)), uint8(0))
t1.Eq(pluralRule3I(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule3I(float64(-2)), uint8(1))
t1.Eq(pluralRule3I(float64(2)), uint8(1))
t1.Eq(pluralRule3I(float64(3)), uint8(1))
t1.Eq(pluralRule3I(float64(4)), uint8(1))
t1.Eq(pluralRule3I(float64(22)), uint8(1))
t1.Eq(pluralRule3I(float64(23)), uint8(1))
t1.Eq(pluralRule3I(float64(24)), uint8(1))
// third form
t1.Eq(pluralRule3I(float64(0)), uint8(2))
t1.Eq(pluralRule3I(float64(0.5)), uint8(2))
t1.Eq(pluralRule3I(float64(5)), uint8(2))
t1.Eq(pluralRule3I(float64(9)), uint8(2))
t1.Eq(pluralRule3I(float64(12)), uint8(2))
t1.Eq(pluralRule3I(float64(13)), uint8(2))
t1.Eq(pluralRule3I(float64(14)), uint8(2))
t1.Eq(pluralRule3I(float64(15)), uint8(2))
//_________________ pluralRule4A
// first form
t1.Eq(pluralRule4A(float64(-1)), uint8(0))
t1.Eq(pluralRule4A(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule4A(float64(-2)), uint8(1))
t1.Eq(pluralRule4A(float64(2)), uint8(1))
// third form
t1.Eq(pluralRule4A(float64(-10)), uint8(2))
t1.Eq(pluralRule4A(float64(10)), uint8(2))
t1.Eq(pluralRule4A(float64(20)), uint8(2))
t1.Eq(pluralRule4A(float64(100)), uint8(2))
// fourth form
t1.Eq(pluralRule4A(float64(0)), uint8(3))
t1.Eq(pluralRule4A(float64(0.5)), uint8(3))
t1.Eq(pluralRule4A(float64(3)), uint8(3))
t1.Eq(pluralRule4A(float64(9)), uint8(3))
t1.Eq(pluralRule4A(float64(11)), uint8(3))
//_________________ pluralRule4B
// first form
t1.Eq(pluralRule4B(float64(-1)), uint8(0))
t1.Eq(pluralRule4B(float64(1)), uint8(0))
t1.Eq(pluralRule4B(float64(21)), uint8(0))
// second form
t1.Eq(pluralRule4B(float64(-2)), uint8(1))
t1.Eq(pluralRule4B(float64(2)), uint8(1))
t1.Eq(pluralRule4B(float64(3)), uint8(1))
t1.Eq(pluralRule4B(float64(4)), uint8(1))
t1.Eq(pluralRule4B(float64(22)), uint8(1))
t1.Eq(pluralRule4B(float64(23)), uint8(1))
t1.Eq(pluralRule4B(float64(24)), uint8(1))
// third form
t1.Eq(pluralRule4B(float64(-5)), uint8(2))
t1.Eq(pluralRule4B(float64(0)), uint8(2))
t1.Eq(pluralRule4B(float64(5)), uint8(2))
t1.Eq(pluralRule4B(float64(6)), uint8(2))
t1.Eq(pluralRule4B(float64(8)), uint8(2))
t1.Eq(pluralRule4B(float64(9)), uint8(2))
t1.Eq(pluralRule4B(float64(11)), uint8(2))
t1.Eq(pluralRule4B(float64(12)), uint8(2))
t1.Eq(pluralRule4B(float64(13)), uint8(2))
t1.Eq(pluralRule4B(float64(14)), uint8(2))
// fourth form
t1.Eq(pluralRule4B(float64(0.5)), uint8(3))
t1.Eq(pluralRule4B(float64(1.5)), uint8(3))
//_________________ pluralRule4C
// first form
t1.Eq(pluralRule4C(float64(-1)), uint8(0))
t1.Eq(pluralRule4C(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule4C(float64(-2)), uint8(1))
t1.Eq(pluralRule4C(float64(2)), uint8(1))
t1.Eq(pluralRule4C(float64(3)), uint8(1))
t1.Eq(pluralRule4C(float64(4)), uint8(1))
t1.Eq(pluralRule4C(float64(22)), uint8(1))
t1.Eq(pluralRule4C(float64(23)), uint8(1))
t1.Eq(pluralRule4C(float64(24)), uint8(1))
// third form
t1.Eq(pluralRule4C(float64(-10)), uint8(2))
t1.Eq(pluralRule4C(float64(10)), uint8(2))
t1.Eq(pluralRule4C(float64(11)), uint8(2))
t1.Eq(pluralRule4C(float64(12)), uint8(2))
t1.Eq(pluralRule4C(float64(13)), uint8(2))
t1.Eq(pluralRule4C(float64(14)), uint8(2))
t1.Eq(pluralRule4C(float64(15)), uint8(2))
t1.Eq(pluralRule4C(float64(16)), uint8(2))
t1.Eq(pluralRule4C(float64(17)), uint8(2))
t1.Eq(pluralRule4C(float64(18)), uint8(2))
t1.Eq(pluralRule4C(float64(19)), uint8(2))
t1.Eq(pluralRule4C(float64(20)), uint8(2))
t1.Eq(pluralRule4C(float64(21)), uint8(2))
t1.Eq(pluralRule4C(float64(25)), uint8(2))
t1.Eq(pluralRule4C(float64(26)), uint8(2))
t1.Eq(pluralRule4C(float64(28)), uint8(2))
t1.Eq(pluralRule4C(float64(29)), uint8(2))
// fourth form
t1.Eq(pluralRule4C(float64(0.5)), uint8(3))
t1.Eq(pluralRule4C(float64(1.5)), uint8(3))
//_________________ pluralRule4D
// first form
t1.Eq(pluralRule4D(float64(-1)), uint8(0))
t1.Eq(pluralRule4D(float64(1)), uint8(0))
t1.Eq(pluralRule4D(float64(101)), uint8(0))
// second form
t1.Eq(pluralRule4D(float64(-2)), uint8(1))
t1.Eq(pluralRule4D(float64(2)), uint8(1))
t1.Eq(pluralRule4D(float64(102)), uint8(1))
// third form
t1.Eq(pluralRule4D(float64(-3)), uint8(2))
t1.Eq(pluralRule4D(float64(3)), uint8(2))
t1.Eq(pluralRule4D(float64(4)), uint8(2))
t1.Eq(pluralRule4D(float64(103)), uint8(2))
t1.Eq(pluralRule4D(float64(104)), uint8(2))
// fourth form
t1.Eq(pluralRule4D(float64(0)), uint8(3))
t1.Eq(pluralRule4D(float64(0.5)), uint8(3))
t1.Eq(pluralRule4D(float64(5)), uint8(3))
t1.Eq(pluralRule4D(float64(10)), uint8(3))
t1.Eq(pluralRule4D(float64(11)), uint8(3))
t1.Eq(pluralRule4D(float64(12)), uint8(3))
t1.Eq(pluralRule4D(float64(13)), uint8(3))
t1.Eq(pluralRule4D(float64(14)), uint8(3))
//_________________ pluralRule4E
// first form
t1.Eq(pluralRule4E(float64(-1)), uint8(0))
t1.Eq(pluralRule4E(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule4E(float64(-2)), uint8(1))
t1.Eq(pluralRule4E(float64(0)), uint8(1))
t1.Eq(pluralRule4E(float64(2)), uint8(1))
t1.Eq(pluralRule4E(float64(10)), uint8(1))
t1.Eq(pluralRule4E(float64(102)), uint8(1))
t1.Eq(pluralRule4E(float64(110)), uint8(1))
// third form
t1.Eq(pluralRule4E(float64(-11)), uint8(2))
t1.Eq(pluralRule4E(float64(11)), uint8(2))
t1.Eq(pluralRule4E(float64(19)), uint8(2))
t1.Eq(pluralRule4E(float64(111)), uint8(2))
t1.Eq(pluralRule4E(float64(119)), uint8(2))
// fourth form
t1.Eq(pluralRule4E(float64(0.5)), uint8(3))
t1.Eq(pluralRule4E(float64(20)), uint8(3))
t1.Eq(pluralRule4E(float64(21)), uint8(3))
t1.Eq(pluralRule4E(float64(22)), uint8(3))
t1.Eq(pluralRule4E(float64(29)), uint8(3))
//_________________ pluralRule4F
// first form
t1.Eq(pluralRule4F(float64(-1)), uint8(0))
t1.Eq(pluralRule4F(float64(1)), uint8(0))
t1.Eq(pluralRule4F(float64(11)), uint8(0))
// second form
t1.Eq(pluralRule4F(float64(-2)), uint8(1))
t1.Eq(pluralRule4F(float64(2)), uint8(1))
t1.Eq(pluralRule4F(float64(12)), uint8(1))
// third form
t1.Eq(pluralRule4F(float64(-3)), uint8(2))
t1.Eq(pluralRule4F(float64(3)), uint8(2))
t1.Eq(pluralRule4F(float64(10)), uint8(2))
t1.Eq(pluralRule4F(float64(13)), uint8(2))
t1.Eq(pluralRule4F(float64(19)), uint8(2))
// fourth form
t1.Eq(pluralRule4F(float64(0)), uint8(3))
t1.Eq(pluralRule4F(float64(0.5)), uint8(3))
t1.Eq(pluralRule4F(float64(20)), uint8(3))
t1.Eq(pluralRule4F(float64(21)), uint8(3))
t1.Eq(pluralRule4F(float64(22)), uint8(3))
t1.Eq(pluralRule4F(float64(23)), uint8(3))
t1.Eq(pluralRule4F(float64(29)), uint8(3))
t1.Eq(pluralRule4F(float64(101)), uint8(3))
t1.Eq(pluralRule4F(float64(102)), uint8(3))
t1.Eq(pluralRule4F(float64(103)), uint8(3))
t1.Eq(pluralRule4F(float64(109)), uint8(3))
//_________________ pluralRule5A
// first form
t1.Eq(pluralRule5A(float64(-1)), uint8(0))
t1.Eq(pluralRule5A(float64(1)), uint8(0))
// second form
t1.Eq(pluralRule5A(float64(-2)), uint8(1))
t1.Eq(pluralRule5A(float64(2)), uint8(1))
// third form
t1.Eq(pluralRule5A(float64(-3)), uint8(2))
t1.Eq(pluralRule5A(float64(3)), uint8(2))
t1.Eq(pluralRule5A(float64(4)), uint8(2))
t1.Eq(pluralRule5A(float64(5)), uint8(2))
t1.Eq(pluralRule5A(float64(6)), uint8(2))
// fourth form
t1.Eq(pluralRule5A(float64(-7)), uint8(3))
t1.Eq(pluralRule5A(float64(7)), uint8(3))
t1.Eq(pluralRule5A(float64(8)), uint8(3))
t1.Eq(pluralRule5A(float64(9)), uint8(3))
t1.Eq(pluralRule5A(float64(10)), uint8(3))
// fifth form
t1.Eq(pluralRule5A(float64(0)), uint8(4))
t1.Eq(pluralRule5A(float64(0.5)), uint8(4))
t1.Eq(pluralRule5A(float64(11)), uint8(4))
t1.Eq(pluralRule5A(float64(12)), uint8(4))
t1.Eq(pluralRule5A(float64(13)), uint8(4))
t1.Eq(pluralRule5A(float64(14)), uint8(4))
t1.Eq(pluralRule5A(float64(15)), uint8(4))
t1.Eq(pluralRule5A(float64(16)), uint8(4))
t1.Eq(pluralRule5A(float64(17)), uint8(4))
t1.Eq(pluralRule5A(float64(18)), uint8(4))
t1.Eq(pluralRule5A(float64(19)), uint8(4))
t1.Eq(pluralRule5A(float64(20)), uint8(4))
//_________________ pluralRule5B
// first form
t1.Eq(pluralRule5B(float64(-1)), uint8(0))
t1.Eq(pluralRule5B(float64(1)), uint8(0))
t1.Eq(pluralRule5B(float64(21)), uint8(0))
t1.Eq(pluralRule5B(float64(61)), uint8(0))
t1.Eq(pluralRule5B(float64(81)), uint8(0))
t1.Eq(pluralRule5B(float64(101)), uint8(0))
// second form
t1.Eq(pluralRule5B(float64(-2)), uint8(1))
t1.Eq(pluralRule5B(float64(2)), uint8(1))
t1.Eq(pluralRule5B(float64(22)), uint8(1))
t1.Eq(pluralRule5B(float64(62)), uint8(1))
t1.Eq(pluralRule5B(float64(82)), uint8(1))
t1.Eq(pluralRule5B(float64(102)), uint8(1))
// third form
t1.Eq(pluralRule5B(float64(-3)), uint8(2))
t1.Eq(pluralRule5B(float64(3)), uint8(2))
t1.Eq(pluralRule5B(float64(4)), uint8(2))
t1.Eq(pluralRule5B(float64(9)), uint8(2))
t1.Eq(pluralRule5B(float64(23)), uint8(2))
t1.Eq(pluralRule5B(float64(24)), uint8(2))
t1.Eq(pluralRule5B(float64(29)), uint8(2))
t1.Eq(pluralRule5B(float64(63)), uint8(2))
t1.Eq(pluralRule5B(float64(64)), uint8(2))
t1.Eq(pluralRule5B(float64(69)), uint8(2))
t1.Eq(pluralRule5B(float64(83)), uint8(2))
t1.Eq(pluralRule5B(float64(84)), uint8(2))
t1.Eq(pluralRule5B(float64(89)), uint8(2))
t1.Eq(pluralRule5B(float64(103)), uint8(2))
t1.Eq(pluralRule5B(float64(104)), uint8(2))
t1.Eq(pluralRule5B(float64(109)), uint8(2))
// fourth form
t1.Eq(pluralRule5B(float64(-1000000)), uint8(3))
t1.Eq(pluralRule5B(float64(1000000)), uint8(3))
t1.Eq(pluralRule5B(float64(2000000)), uint8(3))
t1.Eq(pluralRule5B(float64(10000000)), uint8(3))
// fourth form
t1.Eq(pluralRule5B(float64(0)), uint8(4))
t1.Eq(pluralRule5B(float64(0.5)), uint8(4))
t1.Eq(pluralRule5B(float64(10)), uint8(4))
t1.Eq(pluralRule5B(float64(11)), uint8(4))
t1.Eq(pluralRule5B(float64(12)), uint8(4))
t1.Eq(pluralRule5B(float64(13)), uint8(4))
t1.Eq(pluralRule5B(float64(14)), uint8(4))
t1.Eq(pluralRule5B(float64(19)), uint8(4))
t1.Eq(pluralRule5B(float64(20)), uint8(4))
t1.Eq(pluralRule5B(float64(71)), uint8(4))
t1.Eq(pluralRule5B(float64(72)), uint8(4))
t1.Eq(pluralRule5B(float64(73)), uint8(4))
t1.Eq(pluralRule5B(float64(74)), uint8(4))
t1.Eq(pluralRule5B(float64(79)), uint8(4))
t1.Eq(pluralRule5B(float64(91)), uint8(4))
t1.Eq(pluralRule5B(float64(92)), uint8(4))
t1.Eq(pluralRule5B(float64(93)), uint8(4))
t1.Eq(pluralRule5B(float64(94)), uint8(4))
t1.Eq(pluralRule5B(float64(99)), uint8(4))
t1.Eq(pluralRule5B(float64(100)), uint8(4))
t1.Eq(pluralRule5B(float64(1000)), uint8(4))
t1.Eq(pluralRule5B(float64(10000)), uint8(4))
t1.Eq(pluralRule5B(float64(100000)), uint8(4))
//_________________ pluralRule6A
// first form
t1.Eq(pluralRule6A(float64(0)), uint8(0))
// second form
t1.Eq(pluralRule6A(float64(-1)), uint8(1))
t1.Eq(pluralRule6A(float64(1)), uint8(1))
// third form
t1.Eq(pluralRule6A(float64(-2)), uint8(2))
t1.Eq(pluralRule6A(float64(2)), uint8(2))
// fourth form
t1.Eq(pluralRule6A(float64(-3)), uint8(3))
t1.Eq(pluralRule6A(float64(3)), uint8(3))
t1.Eq(pluralRule6A(float64(4)), uint8(3))
t1.Eq(pluralRule6A(float64(9)), uint8(3))
t1.Eq(pluralRule6A(float64(10)), uint8(3))
t1.Eq(pluralRule6A(float64(103)), uint8(3))
t1.Eq(pluralRule6A(float64(109)), uint8(3))
t1.Eq(pluralRule6A(float64(110)), uint8(3))
// fifth form
t1.Eq(pluralRule6A(float64(-11)), uint8(4))
t1.Eq(pluralRule6A(float64(11)), uint8(4))
t1.Eq(pluralRule6A(float64(12)), uint8(4))
t1.Eq(pluralRule6A(float64(98)), uint8(4))
t1.Eq(pluralRule6A(float64(99)), uint8(4))
t1.Eq(pluralRule6A(float64(111)), uint8(4))
t1.Eq(pluralRule6A(float64(112)), uint8(4))
t1.Eq(pluralRule6A(float64(198)), uint8(4))
t1.Eq(pluralRule6A(float64(199)), uint8(4))
// sixth form
t1.Eq(pluralRule6A(float64(0.5)), uint8(5))
t1.Eq(pluralRule6A(float64(100)), uint8(5))
t1.Eq(pluralRule6A(float64(102)), uint8(5))
t1.Eq(pluralRule6A(float64(200)), uint8(5))
t1.Eq(pluralRule6A(float64(202)), uint8(5))
//_________________ pluralRule6B
// first form
t1.Eq(pluralRule6B(float64(0)), uint8(0))
// second form
t1.Eq(pluralRule6B(float64(-1)), uint8(1))
t1.Eq(pluralRule6B(float64(1)), uint8(1))
// third form
t1.Eq(pluralRule6B(float64(-2)), uint8(2))
t1.Eq(pluralRule6B(float64(2)), uint8(2))
// fourth form
t1.Eq(pluralRule6B(float64(-3)), uint8(3))
t1.Eq(pluralRule6B(float64(3)), uint8(3))
// fifth form
t1.Eq(pluralRule6B(float64(-6)), uint8(4))
t1.Eq(pluralRule6B(float64(6)), uint8(4))
// sixth form
t1.Eq(pluralRule6B(float64(0.5)), uint8(5))
t1.Eq(pluralRule6B(float64(4)), uint8(5))
t1.Eq(pluralRule6B(float64(5)), uint8(5))
t1.Eq(pluralRule6B(float64(7)), uint8(5))
t1.Eq(pluralRule6B(float64(8)), uint8(5))
t1.Eq(pluralRule6B(float64(9)), uint8(5))
t1.Eq(pluralRule6B(float64(10)), uint8(5))
t1.Eq(pluralRule6B(float64(11)), uint8(5))
t1.Eq(pluralRule6B(float64(12)), uint8(5))
t1.Eq(pluralRule6B(float64(13)), uint8(5))
t1.Eq(pluralRule6B(float64(16)), uint8(5))
//_________________ pluralRuleRu
// first form
t1.Eq(pluralRuleRu(float64(-1)), uint8(0))
t1.Eq(pluralRuleRu(float64(1)), uint8(0))
t1.Eq(pluralRuleRu(float64(21)), uint8(0))
t1.Eq(pluralRuleRu(float64(31)), uint8(0))
t1.Eq(pluralRuleRu(float64(101)), uint8(0))
// second form
t1.Eq(pluralRuleRu(float64(0)), uint8(1))
t1.Eq(pluralRuleRu(float64(-5)), uint8(1))
t1.Eq(pluralRuleRu(float64(6)), uint8(1))
t1.Eq(pluralRuleRu(float64(7)), uint8(1))
t1.Eq(pluralRuleRu(float64(11)), uint8(1))
// third form
t1.Eq(pluralRuleRu(float64(-2)), uint8(2))
t1.Eq(pluralRuleRu(float64(22)), uint8(2))
t1.Eq(pluralRuleRu(float64(1.5)), uint8(2))
t1.Eq(pluralRuleRu(float64(101.1)), uint8(2))
}