1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.lang3.mutable;
18
19 import static org.junit.jupiter.api.Assertions.assertEquals;
20 import static org.junit.jupiter.api.Assertions.assertNotEquals;
21 import static org.junit.jupiter.api.Assertions.assertThrows;
22 import static org.junit.jupiter.api.Assertions.assertTrue;
23
24 import org.apache.commons.lang3.AbstractLangTest;
25 import org.junit.jupiter.api.Test;
26
27
28
29
30
31
32 public class MutableDoubleTest extends AbstractLangTest {
33
34 @Test
35 public void testAddAndGetValueObject() {
36 final MutableDouble mutableDouble = new MutableDouble(7.5d);
37 final double result = mutableDouble.addAndGet(Double.valueOf(-2.5d));
38
39 assertEquals(5d, result, 0.01d);
40 assertEquals(5d, mutableDouble.doubleValue(), 0.01d);
41 }
42
43 @Test
44 public void testAddAndGetValuePrimitive() {
45 final MutableDouble mutableDouble = new MutableDouble(10.5d);
46 final double result = mutableDouble.addAndGet(-0.5d);
47
48 assertEquals(10d, result, 0.01d);
49 assertEquals(10d, mutableDouble.doubleValue(), 0.01d);
50 }
51
52 @Test
53 public void testAddValueObject() {
54 final MutableDouble mutNum = new MutableDouble(1);
55 mutNum.add(Double.valueOf(1.1d));
56
57 assertEquals(2.1d, mutNum.doubleValue(), 0.01d);
58 }
59
60 @Test
61 public void testAddValuePrimitive() {
62 final MutableDouble mutNum = new MutableDouble(1);
63 mutNum.add(1.1d);
64
65 assertEquals(2.1d, mutNum.doubleValue(), 0.01d);
66 }
67
68 @Test
69 public void testCompareTo() {
70 final MutableDouble mutNum = new MutableDouble(0d);
71
72 assertEquals(0, mutNum.compareTo(new MutableDouble(0d)));
73 assertEquals(+1, mutNum.compareTo(new MutableDouble(-1d)));
74 assertEquals(-1, mutNum.compareTo(new MutableDouble(1d)));
75 }
76
77 @Test
78 public void testCompareToNull() {
79 final MutableDouble mutNum = new MutableDouble(0d);
80 assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
81 }
82
83 @Test
84 public void testConstructorNull() {
85 assertThrows(NullPointerException.class, () -> new MutableDouble((Number) null));
86 }
87
88 @Test
89 public void testConstructors() {
90 assertEquals(0d, new MutableDouble().doubleValue(), 0.0001d);
91
92 assertEquals(1d, new MutableDouble(1d).doubleValue(), 0.0001d);
93
94 assertEquals(2d, new MutableDouble(Double.valueOf(2d)).doubleValue(), 0.0001d);
95 assertEquals(3d, new MutableDouble(new MutableDouble(3d)).doubleValue(), 0.0001d);
96
97 assertEquals(2d, new MutableDouble("2.0").doubleValue(), 0.0001d);
98
99 }
100
101 @Test
102 public void testDecrement() {
103 final MutableDouble mutNum = new MutableDouble(1);
104 mutNum.decrement();
105
106 assertEquals(0, mutNum.intValue());
107 assertEquals(0L, mutNum.longValue());
108 }
109
110 @Test
111 public void testDecrementAndGet() {
112 final MutableDouble mutNum = new MutableDouble(1d);
113 final double result = mutNum.decrementAndGet();
114
115 assertEquals(0d, result, 0.01d);
116 assertEquals(0, mutNum.intValue());
117 assertEquals(0L, mutNum.longValue());
118 }
119
120 @Test
121 public void testEquals() {
122 final MutableDouble mutNumA = new MutableDouble(0d);
123 final MutableDouble mutNumB = new MutableDouble(0d);
124 final MutableDouble mutNumC = new MutableDouble(1d);
125
126 assertEquals(mutNumA, mutNumA);
127 assertEquals(mutNumA, mutNumB);
128 assertEquals(mutNumB, mutNumA);
129 assertEquals(mutNumB, mutNumB);
130 assertNotEquals(mutNumA, mutNumC);
131 assertNotEquals(mutNumB, mutNumC);
132 assertEquals(mutNumC, mutNumC);
133 assertNotEquals(null, mutNumA);
134 assertNotEquals(mutNumA, Double.valueOf(0d));
135 assertNotEquals("0", mutNumA);
136 }
137
138 @Test
139 public void testGetAndAddValueObject() {
140 final MutableDouble mutableDouble = new MutableDouble(0.5d);
141 final double result = mutableDouble.getAndAdd(Double.valueOf(2d));
142
143 assertEquals(0.5d, result, 0.01d);
144 assertEquals(2.5d, mutableDouble.doubleValue(), 0.01d);
145 }
146
147 @Test
148 public void testGetAndAddValuePrimitive() {
149 final MutableDouble mutableDouble = new MutableDouble(0.5d);
150 final double result = mutableDouble.getAndAdd(1d);
151
152 assertEquals(0.5d, result, 0.01d);
153 assertEquals(1.5d, mutableDouble.doubleValue(), 0.01d);
154 }
155
156 @Test
157 public void testGetAndDecrement() {
158 final MutableDouble mutNum = new MutableDouble(1d);
159 final double result = mutNum.getAndDecrement();
160
161 assertEquals(1d, result, 0.01d);
162 assertEquals(0, mutNum.intValue());
163 assertEquals(0L, mutNum.longValue());
164 }
165
166 @Test
167 public void testGetAndIncrement() {
168 final MutableDouble mutNum = new MutableDouble(1d);
169 final double result = mutNum.getAndIncrement();
170
171 assertEquals(1d, result, 0.01d);
172 assertEquals(2, mutNum.intValue());
173 assertEquals(2L, mutNum.longValue());
174 }
175
176 @Test
177 public void testGetSet() {
178 final MutableDouble mutNum = new MutableDouble(0d);
179 assertEquals(0d, new MutableDouble().doubleValue(), 0.0001d);
180 assertEquals(Double.valueOf(0), new MutableDouble().getValue());
181
182 mutNum.setValue(1);
183 assertEquals(1d, mutNum.doubleValue(), 0.0001d);
184 assertEquals(Double.valueOf(1d), mutNum.getValue());
185
186 mutNum.setValue(Double.valueOf(2d));
187 assertEquals(2d, mutNum.doubleValue(), 0.0001d);
188 assertEquals(Double.valueOf(2d), mutNum.getValue());
189
190 mutNum.setValue(new MutableDouble(3d));
191 assertEquals(3d, mutNum.doubleValue(), 0.0001d);
192 assertEquals(Double.valueOf(3d), mutNum.getValue());
193 }
194
195 @Test
196 public void testHashCode() {
197 final MutableDouble mutNumA = new MutableDouble(0d);
198 final MutableDouble mutNumB = new MutableDouble(0d);
199 final MutableDouble mutNumC = new MutableDouble(1d);
200
201 assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
202 assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
203 assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
204 assertEquals(mutNumA.hashCode(), Double.valueOf(0d).hashCode());
205 }
206
207 @Test
208 public void testIncrement() {
209 final MutableDouble mutNum = new MutableDouble(1);
210 mutNum.increment();
211
212 assertEquals(2, mutNum.intValue());
213 assertEquals(2L, mutNum.longValue());
214 }
215
216 @Test
217 public void testIncrementAndGet() {
218 final MutableDouble mutNum = new MutableDouble(1d);
219 final double result = mutNum.incrementAndGet();
220
221 assertEquals(2d, result, 0.01d);
222 assertEquals(2, mutNum.intValue());
223 assertEquals(2L, mutNum.longValue());
224 }
225
226 @Test
227 public void testNanInfinite() {
228 MutableDouble mutNum = new MutableDouble(Double.NaN);
229 assertTrue(mutNum.isNaN());
230
231 mutNum = new MutableDouble(Double.POSITIVE_INFINITY);
232 assertTrue(mutNum.isInfinite());
233
234 mutNum = new MutableDouble(Double.NEGATIVE_INFINITY);
235 assertTrue(mutNum.isInfinite());
236 }
237
238 @Test
239 public void testPrimitiveValues() {
240 final MutableDouble mutNum = new MutableDouble(1.7);
241 assertEquals(1.7F, mutNum.floatValue());
242 assertEquals(1.7, mutNum.doubleValue());
243 assertEquals( (byte) 1, mutNum.byteValue() );
244 assertEquals( (short) 1, mutNum.shortValue() );
245 assertEquals( 1, mutNum.intValue() );
246 assertEquals( 1L, mutNum.longValue() );
247 }
248
249 @Test
250 public void testSetNull() {
251 final MutableDouble mutNum = new MutableDouble(0d);
252 assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
253 }
254
255 @Test
256 public void testSubtractValueObject() {
257 final MutableDouble mutNum = new MutableDouble(1);
258 mutNum.subtract(Double.valueOf(0.9d));
259
260 assertEquals(0.1d, mutNum.doubleValue(), 0.01d);
261 }
262
263 @Test
264 public void testSubtractValuePrimitive() {
265 final MutableDouble mutNum = new MutableDouble(1);
266 mutNum.subtract(0.9d);
267
268 assertEquals(0.1d, mutNum.doubleValue(), 0.01d);
269 }
270
271 @Test
272 public void testToDouble() {
273 assertEquals(Double.valueOf(0d), new MutableDouble(0d).toDouble());
274 assertEquals(Double.valueOf(12.3d), new MutableDouble(12.3d).toDouble());
275 }
276
277 @Test
278 public void testToString() {
279 assertEquals("0.0", new MutableDouble(0d).toString());
280 assertEquals("10.0", new MutableDouble(10d).toString());
281 assertEquals("-123.0", new MutableDouble(-123d).toString());
282 }
283
284 }