Ejemplo n.º 1
0
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)
	}
}
Ejemplo n.º 2
0
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)
}
Ejemplo n.º 3
0
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)

}
Ejemplo n.º 4
0
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)
}
Ejemplo n.º 5
0
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)
}
Ejemplo n.º 6
0
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))
}
Ejemplo n.º 7
0
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]
}
Ejemplo n.º 8
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()
}
Ejemplo n.º 9
0
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))

}