View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  package org.apache.juneau.commons.lang;
18  
19  import static org.apache.juneau.commons.utils.CollectionUtils.*;
20  import static org.apache.juneau.junit.bct.BctAssertions.*;
21  import static org.junit.jupiter.api.Assertions.*;
22  
23  import org.apache.juneau.*;
24  import org.junit.jupiter.api.*;
25  
26  class LongValue_Test extends TestBase {
27  
28  	//-----------------------------------------------------------------------------------------------------------------
29  	// Basic tests
30  	//-----------------------------------------------------------------------------------------------------------------
31  
32  	@Test
33  	void a01_create() {
34  		var v = LongValue.create();
35  		assertEquals(0L, v.get());
36  	}
37  
38  	@Test
39  	void a02_of() {
40  		var v = LongValue.of(42L);
41  		assertEquals(42L, v.get());
42  	}
43  
44  	@Test
45  	void a03_constructor() {
46  		var v = new LongValue(100L);
47  		assertEquals(100L, v.get());
48  	}
49  
50  	@Test
51  	void a04_constructor_withNull() {
52  		var v = new LongValue(null);
53  		assertNull(v.get());
54  	}
55  
56  	//-----------------------------------------------------------------------------------------------------------------
57  	// getAndIncrement()
58  	//-----------------------------------------------------------------------------------------------------------------
59  
60  	@Test
61  	void b01_getAndIncrement_basic() {
62  		var v = LongValue.of(5L);
63  		assertEquals(5L, v.getAndIncrement());
64  		assertEquals(6L, v.get());
65  	}
66  
67  	@Test
68  	void b02_getAndIncrement_fromZero() {
69  		var v = LongValue.create();
70  		assertEquals(0L, v.getAndIncrement());
71  		assertEquals(1L, v.get());
72  	}
73  
74  	@Test
75  	void b03_getAndIncrement_multiple() {
76  		var v = LongValue.of(1L);
77  		assertEquals(1L, v.getAndIncrement());
78  		assertEquals(2L, v.getAndIncrement());
79  		assertEquals(3L, v.getAndIncrement());
80  		assertEquals(4L, v.get());
81  	}
82  
83  	@Test
84  	void b04_getAndIncrement_withNull() {
85  		var v = new LongValue(null);
86  		assertEquals(0L, v.getAndIncrement());
87  		assertEquals(1L, v.get());
88  	}
89  
90  	@Test
91  	void b05_getAndIncrement_largeValues() {
92  		var v = LongValue.of(Long.MAX_VALUE - 2);
93  		assertEquals(Long.MAX_VALUE - 2, v.getAndIncrement());
94  		assertEquals(Long.MAX_VALUE - 1, v.getAndIncrement());
95  		assertEquals(Long.MAX_VALUE, v.get());
96  	}
97  
98  	//-----------------------------------------------------------------------------------------------------------------
99  	// Inherited Value<Long> methods
100 	//-----------------------------------------------------------------------------------------------------------------
101 
102 	@Test
103 	void c01_set() {
104 		var v = LongValue.create();
105 		v.set(50L);
106 		assertEquals(50L, v.get());
107 	}
108 
109 	@Test
110 	void c02_setIfEmpty() {
111 		var v = new LongValue(null);
112 		v.setIfEmpty(10L);
113 		assertEquals(10L, v.get());
114 
115 		v.setIfEmpty(20L);
116 		assertEquals(10L, v.get()); // Should not change
117 	}
118 
119 	@Test
120 	void c03_orElse() {
121 		var v = new LongValue(null);
122 		assertEquals(99L, v.orElse(99L));
123 
124 		v.set(42L);
125 		assertEquals(42L, v.orElse(99L));
126 	}
127 
128 	@Test
129 	void c04_map() {
130 		var v = LongValue.of(5L);
131 		var v2 = v.map(x -> x * 2);
132 		assertEquals(10L, v2.get());
133 	}
134 
135 	@Test
136 	void c05_ifPresent() {
137 		var v = LongValue.of(7L);
138 		var sb = new StringBuilder();
139 		v.ifPresent(x -> sb.append(x));
140 		assertEquals("7", sb.toString());
141 	}
142 
143 	@Test
144 	void c06_isPresent() {
145 		var v = new LongValue(null);
146 		assertFalse(v.isPresent());
147 
148 		v.set(1L);
149 		assertTrue(v.isPresent());
150 	}
151 
152 	@Test
153 	void c07_isEmpty() {
154 		var v = new LongValue(null);
155 		assertEmpty(v);
156 
157 		v.set(1L);
158 		assertNotEmpty(v);
159 	}
160 
161 	@Test
162 	void c08_getAndSet() {
163 		var v = LongValue.of(10L);
164 		assertEquals(10L, v.getAndSet(20L));
165 		assertEquals(20L, v.get());
166 	}
167 
168 	@Test
169 	void c09_getAndUnset() {
170 		var v = LongValue.of(15L);
171 		assertEquals(15L, v.getAndUnset());
172 		assertNull(v.get());
173 	}
174 
175 	//-----------------------------------------------------------------------------------------------------------------
176 	// Use case scenarios
177 	//-----------------------------------------------------------------------------------------------------------------
178 
179 	@Test
180 	void d01_countingInLambda() {
181 		var counter = LongValue.create();
182 
183 		l(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).forEach(x -> {
184 			if (x % 2 == 0) {
185 				counter.getAndIncrement();
186 			}
187 		});
188 
189 		assertEquals(5L, counter.get());
190 	}
191 
192 	@Test
193 	void d02_trackingBytesProcessed() {
194 		var bytesProcessed = LongValue.create();
195 
196 		l(1024L, 2048L, 512L, 4096L).forEach(bytes -> {
197 			bytesProcessed.set(bytesProcessed.get() + bytes);
198 		});
199 
200 		assertEquals(7680L, bytesProcessed.get());
201 	}
202 
203 	@Test
204 	void d03_trackingMaxTimestamp() {
205 		var maxTimestamp = LongValue.of(0L);
206 
207 		l(1000L, 5000L, 3000L, 8000L, 2000L).forEach(timestamp -> {
208 			if (timestamp > maxTimestamp.get()) {
209 				maxTimestamp.set(timestamp);
210 			}
211 		});
212 
213 		assertEquals(8000L, maxTimestamp.get());
214 	}
215 
216 	//-----------------------------------------------------------------------------------------------------------------
217 	// Increment/Decrement operations
218 	//-----------------------------------------------------------------------------------------------------------------
219 
220 	@Test
221 	void e01_increment() {
222 		var v = LongValue.of(5L);
223 		v.increment();
224 		assertEquals(6L, v.get());
225 	}
226 
227 	@Test
228 	void e02_increment_fromNull() {
229 		var v = new LongValue(null);
230 		v.increment();
231 		assertEquals(1L, v.get());  // null treated as 0, so 0+1 = 1
232 	}
233 
234 	@Test
235 	void e03_increment_largeValue() {
236 		var v = LongValue.of(Long.MAX_VALUE - 1);
237 		v.increment();
238 		assertEquals(Long.MAX_VALUE, v.get());
239 	}
240 
241 	@Test
242 	void e04_decrement() {
243 		var v = LongValue.of(5L);
244 		v.decrement();
245 		assertEquals(4L, v.get());
246 	}
247 
248 	@Test
249 	void e05_decrement_fromNull() {
250 		var v = new LongValue(null);
251 		v.decrement();
252 		assertEquals(-1L, v.get());  // null treated as 0, so 0-1 = -1
253 	}
254 
255 	@Test
256 	void e06_decrement_minValue() {
257 		var v = LongValue.of(Long.MIN_VALUE + 1);
258 		v.decrement();
259 		assertEquals(Long.MIN_VALUE, v.get());
260 	}
261 
262 	@Test
263 	void e07_incrementAndGet() {
264 		var v = LongValue.of(5L);
265 		var result = v.incrementAndGet();
266 		assertEquals(6L, result);
267 		assertEquals(6L, v.get());
268 	}
269 
270 	@Test
271 	void e08_incrementAndGet_fromNull() {
272 		var v = new LongValue(null);
273 		var result = v.incrementAndGet();
274 		assertEquals(1L, result);
275 		assertEquals(1L, v.get());
276 	}
277 
278 	@Test
279 	void e09_decrementAndGet() {
280 		var v = LongValue.of(5L);
281 		var result = v.decrementAndGet();
282 		assertEquals(4L, result);
283 		assertEquals(4L, v.get());
284 	}
285 
286 	@Test
287 	void e10_decrementAndGet_fromNull() {
288 		var v = new LongValue(null);
289 		var result = v.decrementAndGet();
290 		assertEquals(-1L, result);
291 		assertEquals(-1L, v.get());
292 	}
293 
294 	//-----------------------------------------------------------------------------------------------------------------
295 	// Add operations
296 	//-----------------------------------------------------------------------------------------------------------------
297 
298 	@Test
299 	void f01_add() {
300 		var v = LongValue.of(10L);
301 		v.add(5L);
302 		assertEquals(15L, v.get());
303 	}
304 
305 	@Test
306 	void f02_add_withNullValue() {
307 		var v = LongValue.of(10L);
308 		v.add(null);
309 		assertEquals(10L, v.get());  // null treated as 0, so 10+0 = 10
310 	}
311 
312 	@Test
313 	void f03_add_toNullValue() {
314 		var v = new LongValue(null);
315 		v.add(5L);
316 		assertEquals(5L, v.get());  // null treated as 0, so 0+5 = 5
317 	}
318 
319 	@Test
320 	void f04_add_bothNull() {
321 		var v = new LongValue(null);
322 		v.add(null);
323 		assertEquals(0L, v.get());  // null+null = 0+0 = 0
324 	}
325 
326 	@Test
327 	void f05_add_largeValues() {
328 		var v = LongValue.of(Long.MAX_VALUE - 100);
329 		v.add(50L);
330 		assertEquals(Long.MAX_VALUE - 50, v.get());
331 	}
332 
333 	@Test
334 	void f06_addAndGet() {
335 		var v = LongValue.of(10L);
336 		var result = v.addAndGet(5L);
337 		assertEquals(15L, result);
338 		assertEquals(15L, v.get());
339 	}
340 
341 	@Test
342 	void f07_addAndGet_withNullValue() {
343 		var v = LongValue.of(10L);
344 		var result = v.addAndGet(null);
345 		assertEquals(10L, result);
346 		assertEquals(10L, v.get());
347 	}
348 
349 	@Test
350 	void f08_addAndGet_toNullValue() {
351 		var v = new LongValue(null);
352 		var result = v.addAndGet(5L);
353 		assertEquals(5L, result);
354 		assertEquals(5L, v.get());
355 	}
356 
357 	@Test
358 	void f09_addAndGet_negative() {
359 		var v = LongValue.of(10L);
360 		var result = v.addAndGet(-3L);
361 		assertEquals(7L, result);
362 		assertEquals(7L, v.get());
363 	}
364 
365 	//-----------------------------------------------------------------------------------------------------------------
366 	// Comparison operations
367 	//-----------------------------------------------------------------------------------------------------------------
368 
369 	@Test
370 	void g01_is() {
371 		var v = LongValue.of(42L);
372 		assertTrue(v.is(42L));
373 		assertFalse(v.is(43L));
374 		assertFalse(v.is(null));
375 	}
376 
377 	@Test
378 	void g02_is_withNullValue() {
379 		var v = new LongValue(null);
380 		assertFalse(v.is(42L));
381 		assertTrue(v.is(null));
382 	}
383 
384 	@Test
385 	void g03_isAny() {
386 		var v = LongValue.of(5L);
387 		assertTrue(v.isAny(3L, 5L, 7L));
388 		assertTrue(v.isAny(5L));
389 		assertFalse(v.isAny(1L, 2L));
390 		assertFalse(v.isAny());
391 	}
392 
393 	@Test
394 	void g04_isAny_nullValue() {
395 		var v = new LongValue(null);
396 		assertFalse(v.isAny(1L, 2L, 3L));
397 		assertTrue(v.isAny((Long)null));
398 		assertTrue(v.isAny(1L, null, 2L));
399 	}
400 
401 	@Test
402 	void g05_isAny_largeValues() {
403 		var v = LongValue.of(Long.MAX_VALUE);
404 		assertTrue(v.isAny(Long.MAX_VALUE, 1L, 2L));
405 		assertFalse(v.isAny(Long.MIN_VALUE, 0L, 1L));
406 	}
407 }
408