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.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   * JUnit tests.
29   *
30   * @see MutableDouble
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 }