Skip to content

Commit 14e908d

Browse files
SiyaoIsHidingSiyaoIsHiding
committed
more tests and try to fix toString
1 parent 6422932 commit 14e908d

File tree

4 files changed

+111
-103
lines changed

4 files changed

+111
-103
lines changed

‎core/src/main/java/com/datastax/oss/driver/api/core/data/CqlVector.java‎

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,7 @@
1818
package com.datastax.oss.driver.api.core.data;
1919

2020
import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
21+
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
2122
import com.datastax.oss.driver.internal.core.type.codec.ParseUtils;
2223
import com.datastax.oss.driver.shaded.guava.common.base.Preconditions;
2324
import com.datastax.oss.driver.shaded.guava.common.base.Predicates;
@@ -34,6 +35,7 @@
3435
import java.util.Iterator;
3536
import java.util.List;
3637
import java.util.Objects;
38+
import java.util.stream.Collectors;
3739
import java.util.stream.Stream;
3840

3941
/**
@@ -230,7 +232,8 @@ public int hashCode() {
230232

231233
@Override
232234
public String toString() {
233-
return Iterables.toString(this.list);
235+
TypeCodec<T> subcodec = CodecRegistry.DEFAULT.codecFor(list.get(0));
236+
return this.list.stream().map(subcodec::format).collect(Collectors.joining(", ", "[", "]"));
234237
}
235238

236239
/**

‎core/src/main/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodec.java‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -105,7 +105,6 @@ public CqlVector<SubtypeT> decode(
105105
@Override
106106
public String format(CqlVector<SubtypeT> value) {
107107
if (value == null) return "NULL";
108-
109108
return value.stream().map(subtypeCodec::format).collect(Collectors.joining(", ", "[", "]"));
110109
}
111110

‎core/src/test/java/com/datastax/oss/driver/api/core/data/CqlVectorTest.java‎

Lines changed: 83 additions & 69 deletions
Original file line numberDiff line numberDiff line change
@@ -21,58 +21,77 @@
2121
import static org.assertj.core.api.Assertions.assertThatThrownBy;
2222
import static org.assertj.core.api.Assertions.fail;
2323

24+
import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
2425
import com.datastax.oss.driver.api.core.type.codec.TypeCodecs;
26+
import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
2527
import com.datastax.oss.driver.internal.SerializationHelper;
2628
import com.datastax.oss.driver.shaded.guava.common.collect.Iterators;
2729
import java.io.ByteArrayInputStream;
2830
import java.io.ObjectInputStream;
2931
import java.io.ObjectStreamException;
32+
import java.time.LocalTime;
3033
import java.util.AbstractList;
3134
import java.util.ArrayList;
3235
import java.util.Arrays;
3336
import java.util.Collections;
37+
import java.util.Iterator;
3438
import java.util.List;
3539
import java.util.stream.Collectors;
40+
41+
import com.tngtech.java.junit.dataprovider.DataProvider;
42+
import com.tngtech.java.junit.dataprovider.DataProviderRunner;
43+
import com.tngtech.java.junit.dataprovider.UseDataProvider;
3644
import org.apache.commons.codec.DecoderException;
3745
import org.apache.commons.codec.binary.Hex;
3846
import org.assertj.core.util.Lists;
3947
import org.junit.Test;
48+
import org.junit.runner.RunWith;
4049

50+
@RunWith(DataProviderRunner.class)
4151
public class CqlVectorTest {
4252

4353
private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
4454

45-
private void validate_built_vector(CqlVector<Float> vec) {
55+
@DataProvider
56+
public static Object[][] dataProvider() {
57+
return new Object[][]{
58+
{new Float[]{1.0f, 2.5f}},
59+
{new LocalTime[]{LocalTime.of(1, 2), LocalTime.of(3, 4)}},
60+
{new List[]{Arrays.asList(1, 2), Arrays.asList(3, 4)}},
61+
{new CqlVector[]{CqlVector.newInstance("a", "bc"), CqlVector.newInstance("d", "ef")}}
62+
};
63+
}
4664

65+
private void validate_built_vector(CqlVector<?> vec, Object[] expectedVals) {
4766
assertThat(vec.size()).isEqualTo(2);
4867
assertThat(vec.isEmpty()).isFalse();
49-
assertThat(vec.get(0)).isEqualTo(VECTOR_ARGS[0]);
50-
assertThat(vec.get(1)).isEqualTo(VECTOR_ARGS[1]);
68+
assertThat(vec.get(0)).isEqualTo(expectedVals[0]);
69+
assertThat(vec.get(1)).isEqualTo(expectedVals[1]);
5170
}
5271

72+
@UseDataProvider("dataProvider")
5373
@Test
54-
public void should_build_vector_from_elements() {
55-
56-
validate_built_vector(CqlVector.newInstance(VECTOR_ARGS));
74+
public void should_build_vector_from_elements(Object[] vals) {
75+
validate_built_vector(CqlVector.newInstance(vals), vals);
5776
}
5877

5978
@Test
60-
public void should_build_vector_from_list() {
61-
62-
validate_built_vector(CqlVector.newInstance(Lists.newArrayList(VECTOR_ARGS)));
79+
@UseDataProvider("dataProvider")
80+
public void should_build_vector_from_list(Object[] vals) {
81+
validate_built_vector(CqlVector.newInstance(Lists.newArrayList(vals)), vals);
6382
}
6483

6584
@Test
66-
public void should_build_vector_from_tostring_output() {
67-
68-
CqlVector<Float> vector1 = CqlVector.newInstance(VECTOR_ARGS);
69-
CqlVector<Float> vector2 = CqlVector.from(vector1.toString(), TypeCodecs.FLOAT);
85+
@UseDataProvider("dataProvider")
86+
public void should_build_vector_from_tostring_output(Object[] vals) {
87+
CqlVector<?> vector1 = CqlVector.newInstance(vals);
88+
TypeCodec<?> codec = CodecRegistry.DEFAULT.codecFor(vals[0]);
89+
CqlVector<?> vector2 = CqlVector.from(vector1.toString(), codec);
7090
assertThat(vector2).isEqualTo(vector1);
7191
}
7292

7393
@Test
7494
public void should_throw_from_null_string() {
75-
7695
assertThatThrownBy(
7796
() -> {
7897
CqlVector.from(null, TypeCodecs.FLOAT);
@@ -123,94 +142,89 @@ public void should_build_empty_vector() {
123142
}
124143

125144
@Test
126-
public void should_behave_mostly_like_a_list() {
127-
128-
CqlVector<Float> vector = CqlVector.newInstance(VECTOR_ARGS);
129-
assertThat(vector.get(0)).isEqualTo(VECTOR_ARGS[0]);
130-
Float newVal = VECTOR_ARGS[0] * 2;
131-
vector.set(0, newVal);
132-
assertThat(vector.get(0)).isEqualTo(newVal);
145+
@UseDataProvider("dataProvider")
146+
public <T> void should_behave_mostly_like_a_list(T[] vals) {
147+
CqlVector<T> vector = CqlVector.newInstance(vals);
148+
assertThat(vector.get(0)).isEqualTo(vals[0]);
149+
vector.set(0, vals[1]);
150+
assertThat(vector.get(0)).isEqualTo(vals[1]);
133151
assertThat(vector.isEmpty()).isFalse();
134152
assertThat(vector.size()).isEqualTo(2);
135-
assertThat(Iterators.toArray(vector.iterator(), Float.class)).isEqualTo(VECTOR_ARGS);
153+
Iterator<?> iterator = vector.iterator();
154+
assertThat(iterator.next()).isEqualTo(vals[1]);
155+
assertThat(iterator.next()).isEqualTo(vals[1]);
136156
}
137157

138158
@Test
139-
public void should_play_nicely_with_streams() {
140-
141-
CqlVector<Float> vector = CqlVector.newInstance(VECTOR_ARGS);
142-
List<Float> results =
159+
@UseDataProvider("dataProvider")
160+
public <T> void should_play_nicely_with_streams(T[] vals) {
161+
CqlVector<T> vector = CqlVector.newInstance(vals);
162+
List<String> results =
143163
vector.stream()
144-
.map((f) -> f * 2)
145-
.collect(Collectors.toCollection(() -> new ArrayList<Float>()));
164+
.map(Object::toString)
165+
.collect(Collectors.toCollection(() -> new ArrayList<String>()));
146166
for (int i = 0; i < vector.size(); ++i) {
147-
assertThat(results.get(i)).isEqualTo(vector.get(i) * 2);
167+
assertThat(results.get(i)).isEqualTo(vector.get(i).toString());
148168
}
149169
}
150170

151171
@Test
152-
public void should_reflect_changes_to_mutable_list() {
153-
154-
List<Float> theList = Lists.newArrayList(1.1f, 2.2f, 3.3f);
155-
CqlVector<Float> vector = CqlVector.newInstance(theList);
156-
assertThat(vector.size()).isEqualTo(3);
157-
assertThat(vector.get(2)).isEqualTo(3.3f);
158-
159-
float newVal1 = 4.4f;
160-
theList.set(2, newVal1);
161-
assertThat(vector.size()).isEqualTo(3);
162-
assertThat(vector.get(2)).isEqualTo(newVal1);
163-
164-
float newVal2 = 5.5f;
165-
theList.add(newVal2);
166-
assertThat(vector.size()).isEqualTo(4);
167-
assertThat(vector.get(3)).isEqualTo(newVal2);
172+
@UseDataProvider("dataProvider")
173+
public <T> void should_reflect_changes_to_mutable_list(T[] vals) {
174+
List<T> theList = Lists.newArrayList(vals);
175+
CqlVector<T> vector = CqlVector.newInstance(theList);
176+
assertThat(vector.size()).isEqualTo(2);
177+
assertThat(vector.get(1)).isEqualTo(vals[1]);
178+
179+
T newVal = vals[0];
180+
theList.set(1, newVal);
181+
assertThat(vector.size()).isEqualTo(2);
182+
assertThat(vector.get(1)).isEqualTo(newVal);
168183
}
169184

170185
@Test
171-
public void should_reflect_changes_to_array() {
172-
173-
Float[] theArray = new Float[] {1.1f, 2.2f, 3.3f};
174-
CqlVector<Float> vector = CqlVector.newInstance(theArray);
175-
assertThat(vector.size()).isEqualTo(3);
176-
assertThat(vector.get(2)).isEqualTo(3.3f);
186+
@UseDataProvider("dataProvider")
187+
public <T> void should_reflect_changes_to_array(T[] theArray) {
188+
CqlVector<T> vector = CqlVector.newInstance(theArray);
189+
assertThat(vector.size()).isEqualTo(2);
190+
assertThat(vector.get(1)).isEqualTo(theArray[1]);
177191

178-
float newVal1 = 4.4f;
179-
theArray[2] = newVal1;
180-
assertThat(vector.size()).isEqualTo(3);
181-
assertThat(vector.get(2)).isEqualTo(newVal1);
192+
T newVal = theArray[0];
193+
theArray[1] = newVal;
194+
assertThat(vector.size()).isEqualTo(2);
195+
assertThat(vector.get(1)).isEqualTo(newVal);
182196
}
183197

184198
@Test
185-
public void should_correctly_compare_vectors() {
186-
187-
Float[] args = VECTOR_ARGS.clone();
188-
CqlVector<Float> vector1 = CqlVector.newInstance(args);
189-
CqlVector<Float> vector2 = CqlVector.newInstance(args);
190-
CqlVector<Float> vector3 = CqlVector.newInstance(Lists.newArrayList(args));
199+
@UseDataProvider("dataProvider")
200+
public <T> void should_correctly_compare_vectors(T[] vals) {
201+
CqlVector<T> vector1 = CqlVector.newInstance(vals);
202+
CqlVector<T> vector2 = CqlVector.newInstance(vals);
203+
CqlVector<T> vector3 = CqlVector.newInstance(Lists.newArrayList(vals));
191204
assertThat(vector1).isNotSameAs(vector2);
192205
assertThat(vector1).isEqualTo(vector2);
193206
assertThat(vector1).isNotSameAs(vector3);
194207
assertThat(vector1).isEqualTo(vector3);
195208

196-
Float[] differentArgs = args.clone();
197-
float newVal = differentArgs[0] * 2;
209+
T[] differentArgs = Arrays.copyOf(vals, vals.length);
210+
T newVal = differentArgs[1];
198211
differentArgs[0] = newVal;
199-
CqlVector<Float> vector4 = CqlVector.newInstance(differentArgs);
212+
CqlVector<T> vector4 = CqlVector.newInstance(differentArgs);
200213
assertThat(vector1).isNotSameAs(vector4);
201214
assertThat(vector1).isNotEqualTo(vector4);
202215

203-
Float[] biggerArgs = Arrays.copyOf(args, args.length + 1);
216+
T[] biggerArgs = Arrays.copyOf(vals, vals.length + 1);
204217
biggerArgs[biggerArgs.length - 1] = newVal;
205-
CqlVector<Float> vector5 = CqlVector.newInstance(biggerArgs);
218+
CqlVector<T> vector5 = CqlVector.newInstance(biggerArgs);
206219
assertThat(vector1).isNotSameAs(vector5);
207220
assertThat(vector1).isNotEqualTo(vector5);
208221
}
209222

210223
@Test
211-
public void should_serialize_and_deserialize() throws Exception {
212-
CqlVector<Float> initial = CqlVector.newInstance(VECTOR_ARGS);
213-
CqlVector<Float> deserialized = SerializationHelper.serializeAndDeserialize(initial);
224+
@UseDataProvider("dataProvider")
225+
public <T> void should_serialize_and_deserialize(T[] vals) throws Exception {
226+
CqlVector<T> initial = CqlVector.newInstance(vals);
227+
CqlVector<T> deserialized = SerializationHelper.serializeAndDeserialize(initial);
214228
assertThat(deserialized).isEqualTo(initial);
215229
}
216230

‎core/src/test/java/com/datastax/oss/driver/internal/core/type/codec/VectorCodecTest.java‎

Lines changed: 24 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,8 @@
3333
import com.tngtech.java.junit.dataprovider.DataProvider;
3434
import com.tngtech.java.junit.dataprovider.DataProviderRunner;
3535
import com.tngtech.java.junit.dataprovider.UseDataProvider;
36+
37+
import java.nio.Buffer;
3638
import java.nio.ByteBuffer;
3739
import java.time.LocalTime;
3840
import java.util.HashMap;
@@ -41,20 +43,7 @@
4143
import org.junit.runner.RunWith;
4244

4345
@RunWith(DataProviderRunner.class)
44-
public class VectorCodecTest extends CodecTestBase<CqlVector<Float>> {
45-
46-
private static final Float[] VECTOR_ARGS = {1.0f, 2.5f};
47-
48-
private static final CqlVector<Float> VECTOR = CqlVector.newInstance(VECTOR_ARGS);
49-
50-
private static final String VECTOR_HEX_STRING = "0x" + "3f800000" + "40200000";
51-
52-
private static final String FORMATTED_VECTOR = "[1.0, 2.5]";
53-
54-
public VectorCodecTest() {
55-
VectorType vectorType = DataTypes.vectorOf(DataTypes.FLOAT, 2);
56-
this.codec = TypeCodecs.vectorOf(vectorType, TypeCodecs.FLOAT);
57-
}
46+
public class VectorCodecTest {
5847

5948
@DataProvider
6049
public static Object[][] dataProvider() {
@@ -138,8 +127,6 @@ public void should_encode(
138127
TypeCodec<CqlVector<Object>> codec = getCodec(dataType);
139128
CqlVector<Object> vector = CqlVector.newInstance(values);
140129
assertThat(codec.encode(vector, ProtocolVersion.DEFAULT)).isEqualTo(bytes);
141-
142-
// assertThat(encode(null)).isNull();
143130
}
144131

145132
/** Too few elements will cause an exception, extra elements will be silently ignored */
@@ -153,12 +140,6 @@ public void should_throw_on_encode_with_too_few_elements(
153140
.isInstanceOf(IllegalArgumentException.class);
154141
}
155142

156-
@Test
157-
public void should_throw_on_encode_with_empty_list() {
158-
assertThatThrownBy(() -> encode(CqlVector.newInstance()))
159-
.isInstanceOf(IllegalArgumentException.class);
160-
}
161-
162143
@Test
163144
@UseDataProvider("dataProvider")
164145
public void should_throw_on_encode_with_too_many_elements(
@@ -176,8 +157,6 @@ public void should_decode(
176157
TypeCodec<CqlVector<Object>> codec = getCodec(dataType);
177158
assertThat(codec.decode(bytes, ProtocolVersion.DEFAULT))
178159
.isEqualTo(CqlVector.newInstance(values));
179-
// assertThat(decode("0x")).isNull();
180-
// assertThat(decode(null)).isNull();
181160
}
182161

183162
@Test
@@ -211,18 +190,13 @@ public void should_format(
211190
TypeCodec<CqlVector<Object>> codec = getCodec(dataType);
212191
CqlVector<Object> vector = CqlVector.newInstance(values);
213192
assertThat(codec.format(vector)).isEqualTo(formatted);
214-
// assertThat(format(null)).isEqualTo("NULL");
215193
}
216194

217195
@Test
218196
@UseDataProvider("dataProvider")
219197
public void should_parse(DataType dataType, Object[] values, String formatted, ByteBuffer bytes) {
220198
TypeCodec<CqlVector<Object>> codec = getCodec(dataType);
221199
assertThat(codec.parse(formatted)).isEqualTo(CqlVector.newInstance(values));
222-
// assertThat(parse("NULL")).isNull();
223-
// assertThat(parse("null")).isNull();
224-
// assertThat(parse("")).isNull();
225-
// assertThat(parse(null)).isNull();
226200
}
227201

228202
@Test
@@ -253,17 +227,35 @@ public void should_accept_generic_type(
253227
}
254228

255229
@Test
256-
public void should_accept_raw_type() {
230+
@UseDataProvider("dataProvider")
231+
public void should_accept_raw_type(DataType dataType, Object[] values, String formatted, ByteBuffer bytes) {
232+
TypeCodec<CqlVector<Object>> codec = getCodec(dataType);
257233
assertThat(codec.accepts(CqlVector.class)).isTrue();
258234
assertThat(codec.accepts(Integer.class)).isFalse();
259235
}
260236

261237
@Test
262-
public void should_accept_object() {
263-
assertThat(codec.accepts(VECTOR)).isTrue();
238+
@UseDataProvider("dataProvider")
239+
public void should_accept_object(DataType dataType, Object[] values, String formatted, ByteBuffer bytes) {
240+
TypeCodec<CqlVector<Object>> codec = getCodec(dataType);
241+
CqlVector<?> vector = CqlVector.newInstance(values);
242+
assertThat(codec.accepts(vector)).isTrue();
264243
assertThat(codec.accepts(Integer.MIN_VALUE)).isFalse();
265244
}
266245

246+
@Test
247+
public void should_handle_null_and_empty() {
248+
TypeCodec<CqlVector<Object>> codec = getCodec(DataTypes.FLOAT);
249+
assertThat(codec.encode(null, ProtocolVersion.DEFAULT)).isNull();
250+
assertThat(codec.decode(Bytes.fromHexString("0x"), ProtocolVersion.DEFAULT)).isNull();
251+
assertThat(codec.format(null)).isEqualTo("NULL");
252+
assertThat(codec.parse("NULL")).isNull();
253+
assertThat(codec.parse("null")).isNull();
254+
assertThat(codec.parse("")).isNull();
255+
assertThat(codec.parse(null)).isNull();
256+
assertThatThrownBy(() -> codec.encode(CqlVector.newInstance(), ProtocolVersion.DEFAULT))
257+
.isInstanceOf(IllegalArgumentException.class);
258+
}
267259
private static TypeCodec<CqlVector<Object>> getCodec(DataType dataType) {
268260
return TypeCodecs.vectorOf(
269261
DataTypes.vectorOf(dataType, 2), CodecRegistry.DEFAULT.codecFor(dataType));

0 commit comments

Comments
 (0)