1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
package com.yahoo.searchlib.expression;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
/**
* @author Ulf Lilleengen
* @since 5.1
*/
public class ResultNodeVectorTestCase extends ResultNodeTest {
@Test
public void testClassId() {
assertEquals(IntegerResultNodeVector.classId, new IntegerResultNodeVector().getClassId());
assertEquals(Int32ResultNodeVector.classId, new Int32ResultNodeVector().getClassId());
assertEquals(Int16ResultNodeVector.classId, new Int16ResultNodeVector().getClassId());
assertEquals(Int8ResultNodeVector.classId, new Int8ResultNodeVector().getClassId());
assertEquals(FloatResultNodeVector.classId, new FloatResultNodeVector().getClassId());
assertEquals(BoolResultNodeVector.classId, new BoolResultNodeVector().getClassId());
}
@Test
public void testVectorAdd() {
BoolResultNodeVector b = new BoolResultNodeVector();
b.add(new BoolResultNode(true));
b.add(new BoolResultNode(false));
b.add((ResultNode)new BoolResultNode(false));
assertEquals(3, b.getVector().size());
Int8ResultNodeVector i8 = new Int8ResultNodeVector();
i8.add(new Int8ResultNode((byte)9));
i8.add(new Int8ResultNode((byte)2));
i8.add((ResultNode)new Int8ResultNode((byte)5));
assertEquals(3, i8.getVector().size());
Int16ResultNodeVector i16 = new Int16ResultNodeVector();
i16.add(new Int16ResultNode((short)9));
i16.add(new Int16ResultNode((short)2));
i16.add((ResultNode)new Int16ResultNode((short)5));
assertEquals(3, i16.getVector().size());
Int32ResultNodeVector i32 = new Int32ResultNodeVector();
i32.add(new Int32ResultNode(9));
i32.add(new Int32ResultNode(2));
i32.add((ResultNode)new Int32ResultNode(5));
assertEquals(3, i32.getVector().size());
IntegerResultNodeVector ieger = new IntegerResultNodeVector();
ieger.add(new IntegerResultNode(9));
ieger.add(new IntegerResultNode(2));
ieger.add((ResultNode)new IntegerResultNode(5));
assertEquals(3, ieger.getVector().size());
FloatResultNodeVector floatvec = new FloatResultNodeVector();
floatvec.add(new FloatResultNode(3.3));
floatvec.add(new FloatResultNode(3.4));
floatvec.add((ResultNode)new FloatResultNode(3.5));
assertEquals(3, floatvec.getVector().size());
}
@Test
public void testCmp() {
ResultNodeVector int8vec = new Int8ResultNodeVector().add(new Int8ResultNode((byte) 2));
ResultNodeVector int8veclarge = new Int8ResultNodeVector().add(new Int8ResultNode((byte) 2)).add(new Int8ResultNode((byte) 5));
ResultNodeVector int8vecsmall = new Int8ResultNodeVector().add(new Int8ResultNode((byte) 1));
ResultNodeVector int16vec = new Int16ResultNodeVector().add(new Int16ResultNode((short) 2));
ResultNodeVector int16veclarge = new Int16ResultNodeVector().add(new Int16ResultNode((short) 2)).add(new Int16ResultNode((short) 5));
ResultNodeVector int16vecsmall = new Int16ResultNodeVector().add(new Int16ResultNode((short) 1));
ResultNodeVector int32vec = new Int32ResultNodeVector().add(new Int32ResultNode(2));
ResultNodeVector int32veclarge = new Int32ResultNodeVector().add(new Int32ResultNode(2)).add(new Int32ResultNode(5));
ResultNodeVector int32vecsmall = new Int32ResultNodeVector().add(new Int32ResultNode(1));
ResultNodeVector intvec = new IntegerResultNodeVector().add(new IntegerResultNode(2));
ResultNodeVector intveclarge = new IntegerResultNodeVector().add(new IntegerResultNode(2)).add(new IntegerResultNode(5));
ResultNodeVector intvecsmall = new IntegerResultNodeVector().add(new IntegerResultNode(1));
FloatResultNodeVector floatvec = new FloatResultNodeVector().add(new FloatResultNode(2.2));
FloatResultNodeVector floatveclarge = new FloatResultNodeVector().add(new FloatResultNode(2.2)).add(new FloatResultNode(5.5));
FloatResultNodeVector floatvecsmall = new FloatResultNodeVector().add(new FloatResultNode(1.2));
StringResultNodeVector strvec = new StringResultNodeVector().add(new StringResultNode("foo"));
StringResultNodeVector strveclarge = new StringResultNodeVector().add(new StringResultNode("foolio"));
StringResultNodeVector strvecsmall = new StringResultNodeVector().add(new StringResultNode("bario"));
RawResultNodeVector rawvec = new RawResultNodeVector().add(new RawResultNode(new byte[]{6, 9}));
RawResultNodeVector rawveclarge = new RawResultNodeVector().add(new RawResultNode(new byte[]{9, 6}));
RawResultNodeVector rawvecsmall = new RawResultNodeVector().add(new RawResultNode(new byte[]{6, 6}));
assertClassCmp(int8vec);
assertClassCmp(int16vec);
assertClassCmp(int32vec);
assertClassCmp(intvec);
assertClassCmp(floatvec);
assertClassCmp(strvec);
assertClassCmp(rawvec);
assertVecEqual(int8vec, int8vec);
assertVecLt(int8vec, int8veclarge);
assertVecGt(int8veclarge, int8vec);
assertVecGt(int8vec, int8vecsmall);
assertVecLt(int8vecsmall, int8vec);
assertVecEqual(int16vec, int16vec);
assertVecLt(int16vec, int16veclarge);
assertVecGt(int16veclarge, int16vec);
assertVecGt(int16vec, int16vecsmall);
assertVecLt(int16vecsmall, int16vec);
assertVecEqual(int32vec, int32vec);
assertVecLt(int32vec, int32veclarge);
assertVecGt(int32veclarge, int32vec);
assertVecGt(int32vec, int32vecsmall);
assertVecLt(int32vecsmall, int32vec);
assertVecEqual(intvec, intvec);
assertVecLt(intvec, intveclarge);
assertVecGt(intveclarge, intvec);
assertVecGt(intvec, intvecsmall);
assertVecLt(intvecsmall, intvec);
assertVecEqual(floatvec, floatvec);
assertVecLt(floatvec, floatveclarge);
assertVecGt(floatveclarge, floatvec);
assertVecGt(floatvec, floatvecsmall);
assertVecLt(floatvecsmall, floatvec);
assertVecEqual(strvec, strvec);
assertVecLt(strvec, strveclarge);
assertVecGt(strveclarge, strvec);
assertVecGt(strvec, strvecsmall);
assertVecLt(strvecsmall, strvec);
assertVecEqual(rawvec, rawvec);
assertVecLt(rawvec, rawveclarge);
assertVecGt(rawveclarge, rawvec);
assertVecGt(rawvec, rawvecsmall);
assertVecLt(rawvecsmall, rawvec);
}
private void assertVecLt(ResultNodeVector vec1, ResultNodeVector vec2) {
assertTrue(vec1.onCmp(vec2) < 0);
}
private void assertVecGt(ResultNodeVector vec1, ResultNodeVector vec2) {
assertTrue(vec1.onCmp(vec2) > 0);
}
private void assertVecEqual(ResultNodeVector vec1, ResultNodeVector vec2) {
assertEquals(0, vec1.onCmp(vec2));
}
private void assertClassCmp(ResultNodeVector add) {
assertNotEquals(0, add.onCmp(new NullResultNode()));
}
@Test
public void testSerialize() throws InstantiationException, IllegalAccessException {
assertCorrectSerialization(new FloatResultNodeVector().add(new FloatResultNode(1.1)).add(new FloatResultNode(3.3)), new FloatResultNodeVector());
assertCorrectSerialization(new IntegerResultNodeVector().add(new IntegerResultNode(1)).add(new IntegerResultNode(3)), new IntegerResultNodeVector());
assertCorrectSerialization(new Int16ResultNodeVector().add(new Int16ResultNode((short) 1)).add(new Int16ResultNode((short) 3)), new Int16ResultNodeVector());
assertCorrectSerialization(new Int8ResultNodeVector().add(new Int8ResultNode((byte) 1)).add(new Int8ResultNode((byte) 3)), new Int8ResultNodeVector());
assertCorrectSerialization(new StringResultNodeVector().add(new StringResultNode("foo")).add(new StringResultNode("bar")), new StringResultNodeVector());
assertCorrectSerialization(new RawResultNodeVector().add(new RawResultNode(new byte[]{6, 9})).add(new RawResultNode(new byte[]{9, 6})), new RawResultNodeVector());
assertCorrectSerialization(new BoolResultNodeVector().add(new BoolResultNode(true)).add(new BoolResultNode(false)), new BoolResultNodeVector());
}
}
|
