1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 package org.dbunit.dataset.datatype;
23
24 import static org.assertj.core.api.Assertions.assertThat;
25 import static org.junit.jupiter.api.Assertions.assertThrows;
26 import static org.mockito.Mockito.lenient;
27
28 import java.math.BigDecimal;
29 import java.sql.ResultSet;
30 import java.sql.SQLException;
31
32 import org.dbunit.dataset.ITable;
33 import org.junit.jupiter.api.Test;
34 import org.junit.jupiter.api.extension.ExtendWith;
35 import org.mockito.InOrder;
36 import org.mockito.Mock;
37 import org.mockito.Mockito;
38 import org.mockito.junit.jupiter.MockitoExtension;
39
40
41
42
43
44 @ExtendWith(MockitoExtension.class)
45 public class LongDataTypeTest extends AbstractDataTypeTest
46 {
47 private final static DataType THIS_TYPE = DataType.BIGINT_AUX_LONG;
48
49 @Mock
50 private ResultSet mockedResultSet;
51
52 @Override
53 @Test
54 public void testToString() throws Exception
55 {
56 assertThat(THIS_TYPE.toString()).as("name").isEqualTo("BIGINT");
57 }
58
59 @Override
60 @Test
61 public void testGetTypeClass() throws Exception
62 {
63 assertThat(THIS_TYPE.getTypeClass()).as("class").isEqualTo(Long.class);
64 }
65
66 @Override
67 @Test
68 public void testIsNumber() throws Exception
69 {
70 assertThat(THIS_TYPE.isNumber()).as("is number").isTrue();
71 }
72
73 @Override
74 @Test
75 public void testIsDateTime() throws Exception
76 {
77 assertThat(THIS_TYPE.isDateTime()).as("is date/time").isFalse();
78 }
79
80 @Override
81 @Test
82 public void testTypeCast() throws Exception
83 {
84 final Object[] values = {null, "5", Long.valueOf(1234),
85 Float.valueOf(Long.MAX_VALUE), Float.valueOf(Long.MIN_VALUE),
86 "-7500", Double.valueOf(Long.MAX_VALUE),
87 Double.valueOf(Long.MIN_VALUE), Float.valueOf("0.666"),
88 Double.valueOf(0.666), Double.valueOf(5.49), "-99.9",
89 Double.valueOf(1.5E6), new BigDecimal((double) 1234),};
90
91 final Long[] expected = {null, 5L, 1234L, Long.MAX_VALUE,
92 Long.MIN_VALUE, -7500L, Long.MAX_VALUE, Long.MIN_VALUE, 0L, 0L,
93 5L, -99L, 1500000L, 1234L,};
94
95 assertThat(expected).as("actual vs expected count")
96 .hasSameSizeAs(values);
97
98 for (int i = 0; i < values.length; i++)
99 {
100 assertThat(THIS_TYPE.typeCast(values[i])).as("typecast " + i)
101 .isEqualTo(expected[i]);
102 }
103 }
104
105 @Override
106 @Test
107 public void testTypeCastNone() throws Exception
108 {
109 assertThat(THIS_TYPE.typeCast(ITable.NO_VALUE)).as("typecast").isNull();
110 }
111
112 @Override
113 @Test
114 public void testTypeCastInvalid() throws Exception
115 {
116 final Object[] values = {new Object(), "bla", new java.util.Date()};
117
118 for (int i = 0; i < values.length; i++)
119 {
120 final int id = i;
121 assertThrows(TypeCastException.class,
122 () -> THIS_TYPE.typeCast(values[id]),
123 "Should throw TypeCastException");
124 }
125 }
126
127 @Override
128 @Test
129 public void testCompareEquals() throws Exception
130 {
131 final Object[] values1 = {null, "5", Long.valueOf(1234),
132 Float.valueOf(Long.MAX_VALUE), Float.valueOf(Long.MIN_VALUE),
133 "-7500", Double.valueOf(Long.MAX_VALUE),
134 Double.valueOf(Long.MIN_VALUE), Float.valueOf("0.666"),
135 Double.valueOf(0.666), Double.valueOf(5.49), "-99.9",
136 Double.valueOf(1.5E6), new BigDecimal((double) 1234),};
137
138 final Object[] values2 = {null, Long.valueOf(5), Long.valueOf(1234),
139 Long.valueOf(Long.MAX_VALUE), Long.valueOf(Long.MIN_VALUE),
140 Long.valueOf(-7500), Long.valueOf(Long.MAX_VALUE),
141 Long.valueOf(Long.MIN_VALUE), Long.valueOf(0), Long.valueOf(0),
142 Long.valueOf(5), Long.valueOf(-99), Long.valueOf(1500000),
143 Long.valueOf(1234),};
144
145 assertThat(values2).as("values count").hasSameSizeAs(values1);
146
147 for (int i = 0; i < values1.length; i++)
148 {
149 assertThat(THIS_TYPE.compare(values1[i], values2[i]))
150 .as("compare1 " + i).isZero();
151 assertThat(THIS_TYPE.compare(values2[i], values1[i]))
152 .as("compare2 " + i).isZero();
153 }
154 }
155
156 @Override
157 @Test
158 public void testCompareInvalid() throws Exception
159 {
160 final Object[] values1 = {new Object(), "bla", new java.util.Date()};
161 final Object[] values2 = {null, null, null};
162
163 assertThat(values2).as("values count").hasSameSizeAs(values1);
164
165 for (int i = 0; i < values1.length; i++)
166 {
167 final int id = i;
168 assertThrows(TypeCastException.class,
169 () -> THIS_TYPE.compare(values1[id], values2[id]),
170 "Should throw TypeCastException");
171
172 assertThrows(TypeCastException.class,
173 () -> THIS_TYPE.compare(values2[id], values1[id]),
174 "Should throw TypeCastException");
175 }
176 }
177
178 @Override
179 @Test
180 public void testCompareDifferent() throws Exception
181 {
182 final Object[] less = {null, null, "-7500",};
183
184 final Object[] greater = {"0", Long.valueOf(-5), Long.valueOf(5),};
185
186 assertThat(greater).as("values count").hasSameSizeAs(less);
187
188 for (int i = 0; i < less.length; i++)
189 {
190 assertThat(THIS_TYPE.compare(less[i], greater[i])).as("less " + i)
191 .isNegative();
192 assertThat(THIS_TYPE.compare(greater[i], less[i]))
193 .as("greater " + i).isPositive();
194 }
195 }
196
197 @Override
198 public void testSqlType() throws Exception
199 {
200
201
202
203
204
205
206
207
208
209
210 }
211
212 @Override
213 @Test
214 public void testForObject() throws Exception
215 {
216 final DataType actual = DataType.forObject(Long.valueOf(1234));
217 assertThat(actual).isEqualTo(THIS_TYPE);
218 }
219
220 @Override
221 @Test
222 public void testAsString() throws Exception
223 {
224 final Long[] values = {(long) 1234,};
225
226 final String[] expected = {"1234",};
227
228 assertThat(expected).as("actual vs expected count")
229 .hasSameSizeAs(values);
230
231 for (int i = 0; i < values.length; i++)
232 {
233 assertThat(DataType.asString(values[i])).as("asString " + i)
234 .isEqualTo(expected[i]);
235 }
236 }
237
238 @Override
239 @Test
240 public void testGetSqlValue() throws Exception
241 {
242 final Long[] expected =
243 {null, 5L, 1234L, Long.MAX_VALUE, Long.MIN_VALUE, -7500L, 0L,};
244
245 lenient().when(mockedResultSet.getLong(2)).thenReturn(expected[1]);
246 lenient().when(mockedResultSet.getLong(3)).thenReturn(expected[2]);
247 lenient().when(mockedResultSet.getLong(4)).thenReturn(expected[3]);
248 lenient().when(mockedResultSet.getLong(5)).thenReturn(expected[4]);
249 lenient().when(mockedResultSet.getLong(6)).thenReturn(expected[5]);
250 lenient().when(mockedResultSet.getLong(7)).thenReturn(expected[6]);
251 lenient().when(mockedResultSet.wasNull()).thenReturn(true)
252 .thenReturn(false);
253 for (int i = 0; i < expected.length; i++)
254 {
255 final Object expectedValue = expected[i];
256 final Object actualValue =
257 THIS_TYPE.getSqlValue(i + 1, mockedResultSet);
258 assertThat(actualValue).as("value").isEqualTo(expectedValue);
259 }
260 }
261
262
263
264
265 @Test
266 public void testGetSqlValueCallOrder()
267 throws TypeCastException, SQLException
268 {
269 final int columnIndex = 1;
270
271 DataType.BIGINT_AUX_LONG.getSqlValue(columnIndex, mockedResultSet);
272
273 final InOrder inOrder = Mockito.inOrder(mockedResultSet);
274 inOrder.verify(mockedResultSet).getLong(columnIndex);
275 inOrder.verify(mockedResultSet).wasNull();
276 }
277 }