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 MutableFloat
31   */
32  public class MutableFloatTest extends AbstractLangTest {
33  
34      @Test
35      public void testAddAndGetValueObject() {
36          final MutableFloat mutableFloat = new MutableFloat(5f);
37          final float result = mutableFloat.addAndGet(Float.valueOf(2.5f));
38  
39          assertEquals(7.5f, result, 0.01f);
40          assertEquals(7.5f, mutableFloat.floatValue(), 0.01f);
41      }
42  
43      @Test
44      public void testAddAndGetValuePrimitive() {
45          final MutableFloat mutableFloat = new MutableFloat(0.5f);
46          final float result = mutableFloat.addAndGet(1f);
47  
48          assertEquals(1.5f, result, 0.01f);
49          assertEquals(1.5f, mutableFloat.floatValue(), 0.01f);
50      }
51  
52      @Test
53      public void testAddValueObject() {
54          final MutableFloat mutNum = new MutableFloat(1);
55          mutNum.add(Float.valueOf(1.1f));
56  
57          assertEquals(2.1f, mutNum.floatValue(), 0.01f);
58      }
59  
60      @Test
61      public void testAddValuePrimitive() {
62          final MutableFloat mutNum = new MutableFloat(1);
63          mutNum.add(1.1f);
64  
65          assertEquals(2.1f, mutNum.floatValue(), 0.01f);
66      }
67  
68      @Test
69      public void testCompareTo() {
70          final MutableFloat mutNum = new MutableFloat(0f);
71  
72          assertEquals(0, mutNum.compareTo(new MutableFloat(0f)));
73          assertEquals(+1, mutNum.compareTo(new MutableFloat(-1f)));
74          assertEquals(-1, mutNum.compareTo(new MutableFloat(1f)));
75      }
76  
77      @Test
78      public void testCompareToNull() {
79          final MutableFloat mutNum = new MutableFloat(0f);
80          assertThrows(NullPointerException.class, () -> mutNum.compareTo(null));
81      }
82  
83      @Test
84      public void testConstructorNull() {
85          assertThrows(NullPointerException.class, () -> new MutableFloat((Number) null));
86      }
87  
88      @Test
89      public void testConstructors() {
90          assertEquals(0f, new MutableFloat().floatValue(), 0.0001f);
91  
92          assertEquals(1f, new MutableFloat(1f).floatValue(), 0.0001f);
93  
94          assertEquals(2f, new MutableFloat(Float.valueOf(2f)).floatValue(), 0.0001f);
95          assertEquals(3f, new MutableFloat(new MutableFloat(3f)).floatValue(), 0.0001f);
96  
97          assertEquals(2f, new MutableFloat("2.0").floatValue(), 0.0001f);
98  
99      }
100 
101     @Test
102     public void testDecrement() {
103         final MutableFloat mutNum = new MutableFloat(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 MutableFloat mutNum = new MutableFloat(1f);
113         final float result = mutNum.decrementAndGet();
114 
115         assertEquals(0f, result, 0.01f);
116         assertEquals(0, mutNum.intValue());
117         assertEquals(0L, mutNum.longValue());
118     }
119 
120     @Test
121     public void testEquals() {
122         final MutableFloat mutNumA = new MutableFloat(0f);
123         final MutableFloat mutNumB = new MutableFloat(0f);
124         final MutableFloat mutNumC = new MutableFloat(1f);
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, Float.valueOf(0f));
135         assertNotEquals("0", mutNumA);
136     }
137 
138     @Test
139     public void testGetAndAddValueObject() {
140         final MutableFloat mutableFloat = new MutableFloat(7.75f);
141         final float result = mutableFloat.getAndAdd(Float.valueOf(2.25f));
142 
143         assertEquals(7.75f, result, 0.01f);
144         assertEquals(10f, mutableFloat.floatValue(), 0.01f);
145     }
146 
147     @Test
148     public void testGetAndAddValuePrimitive() {
149         final MutableFloat mutableFloat = new MutableFloat(1.25f);
150         final float result = mutableFloat.getAndAdd(0.75f);
151 
152         assertEquals(1.25f, result, 0.01f);
153         assertEquals(2f, mutableFloat.floatValue(), 0.01f);
154     }
155 
156     @Test
157     public void testGetAndDecrement() {
158         final MutableFloat mutNum = new MutableFloat(1f);
159         final float result = mutNum.getAndDecrement();
160 
161         assertEquals(1f, result, 0.01f);
162         assertEquals(0, mutNum.intValue());
163         assertEquals(0L, mutNum.longValue());
164     }
165 
166     @Test
167     public void testGetAndIncrement() {
168         final MutableFloat mutNum = new MutableFloat(1f);
169         final float result = mutNum.getAndIncrement();
170 
171         assertEquals(1f, result, 0.01f);
172         assertEquals(2, mutNum.intValue());
173         assertEquals(2L, mutNum.longValue());
174     }
175 
176     @Test
177     public void testGetSet() {
178         final MutableFloat mutNum = new MutableFloat(0f);
179         assertEquals(0f, new MutableFloat().floatValue(), 0.0001f);
180         assertEquals(Float.valueOf(0), new MutableFloat().getValue());
181 
182         mutNum.setValue(1);
183         assertEquals(1f, mutNum.floatValue(), 0.0001f);
184         assertEquals(Float.valueOf(1f), mutNum.getValue());
185 
186         mutNum.setValue(Float.valueOf(2f));
187         assertEquals(2f, mutNum.floatValue(), 0.0001f);
188         assertEquals(Float.valueOf(2f), mutNum.getValue());
189 
190         mutNum.setValue(new MutableFloat(3f));
191         assertEquals(3f, mutNum.floatValue(), 0.0001f);
192         assertEquals(Float.valueOf(3f), mutNum.getValue());
193     }
194 
195     @Test
196     public void testHashCode() {
197         final MutableFloat mutNumA = new MutableFloat(0f);
198         final MutableFloat mutNumB = new MutableFloat(0f);
199         final MutableFloat mutNumC = new MutableFloat(1f);
200 
201         assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
202         assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
203         assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
204         assertEquals(mutNumA.hashCode(), Float.valueOf(0f).hashCode());
205     }
206 
207     @Test
208     public void testIncrement() {
209         final MutableFloat mutNum = new MutableFloat(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 MutableFloat mutNum = new MutableFloat(1f);
219         final float result = mutNum.incrementAndGet();
220 
221         assertEquals(2f, result, 0.01f);
222         assertEquals(2, mutNum.intValue());
223         assertEquals(2L, mutNum.longValue());
224     }
225 
226     @Test
227     public void testNanInfinite() {
228         MutableFloat mutNum = new MutableFloat(Float.NaN);
229         assertTrue(mutNum.isNaN());
230 
231         mutNum = new MutableFloat(Float.POSITIVE_INFINITY);
232         assertTrue(mutNum.isInfinite());
233 
234         mutNum = new MutableFloat(Float.NEGATIVE_INFINITY);
235         assertTrue(mutNum.isInfinite());
236     }
237 
238     @Test
239     public void testPrimitiveValues() {
240         final MutableFloat mutNum = new MutableFloat(1.7F);
241 
242         assertEquals( 1, mutNum.intValue() );
243         assertEquals( 1.7, mutNum.doubleValue(), 0.00001 );
244         assertEquals( (byte) 1, mutNum.byteValue() );
245         assertEquals( (short) 1, mutNum.shortValue() );
246         assertEquals( 1, mutNum.intValue() );
247         assertEquals( 1L, mutNum.longValue() );
248     }
249 
250     @Test
251     public void testSetNull() {
252         final MutableFloat mutNum = new MutableFloat(0f);
253         assertThrows(NullPointerException.class, () -> mutNum.setValue(null));
254     }
255 
256     @Test
257     public void testSubtractValueObject() {
258         final MutableFloat mutNum = new MutableFloat(1);
259         mutNum.subtract(Float.valueOf(0.9f));
260 
261         assertEquals(0.1f, mutNum.floatValue(), 0.01f);
262     }
263 
264     @Test
265     public void testSubtractValuePrimitive() {
266         final MutableFloat mutNum = new MutableFloat(1);
267         mutNum.subtract(0.9f);
268 
269         assertEquals(0.1f, mutNum.floatValue(), 0.01f);
270     }
271 
272     @Test
273     public void testToFloat() {
274         assertEquals(Float.valueOf(0f), new MutableFloat(0f).toFloat());
275         assertEquals(Float.valueOf(12.3f), new MutableFloat(12.3f).toFloat());
276     }
277 
278     @Test
279     public void testToString() {
280         assertEquals("0.0", new MutableFloat(0f).toString());
281         assertEquals("10.0", new MutableFloat(10f).toString());
282         assertEquals("-123.0", new MutableFloat(-123f).toString());
283     }
284 
285 }