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    *      https://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.apache.commons.lang3.LangAssertions.assertNullPointerException;
20  import static org.junit.jupiter.api.Assertions.assertEquals;
21  import static org.junit.jupiter.api.Assertions.assertNotEquals;
22  
23  import org.apache.commons.lang3.AbstractLangTest;
24  import org.junit.jupiter.api.Test;
25  
26  /**
27   * JUnit tests.
28   *
29   * @see MutableInt
30   */
31  class MutableIntTest extends AbstractLangTest {
32  
33      @Test
34      void testAddAndGetValueObject() {
35          final MutableInt mutableInteger = new MutableInt(0);
36          final int result = mutableInteger.addAndGet(Integer.valueOf(1));
37  
38          assertEquals(1, result);
39          assertEquals(1, mutableInteger.intValue());
40      }
41  
42      @Test
43      void testAddAndGetValuePrimitive() {
44          final MutableInt mutableInteger = new MutableInt(0);
45          final int result = mutableInteger.addAndGet(1);
46  
47          assertEquals(1, result);
48          assertEquals(1, mutableInteger.intValue());
49      }
50  
51      @Test
52      void testAddValueObject() {
53          final MutableInt mutNum = new MutableInt(1);
54          mutNum.add(Integer.valueOf(1));
55  
56          assertEquals(2, mutNum.intValue());
57          assertEquals(2L, mutNum.longValue());
58      }
59  
60      @Test
61      void testAddValuePrimitive() {
62          final MutableInt mutNum = new MutableInt(1);
63          mutNum.add(1);
64  
65          assertEquals(2, mutNum.intValue());
66          assertEquals(2L, mutNum.longValue());
67      }
68  
69      @Test
70      void testCompareTo() {
71          final MutableInt mutNum = new MutableInt(0);
72  
73          assertEquals(0, mutNum.compareTo(new MutableInt(0)));
74          assertEquals(+1, mutNum.compareTo(new MutableInt(-1)));
75          assertEquals(-1, mutNum.compareTo(new MutableInt(1)));
76      }
77  
78      @Test
79      void testCompareToNull() {
80          final MutableInt mutNum = new MutableInt(0);
81          assertNullPointerException(() -> mutNum.compareTo(null));
82      }
83  
84      @Test
85      void testConstructorNull() {
86          assertNullPointerException(() -> new MutableInt((Number) null));
87      }
88  
89      @Test
90      void testConstructors() {
91          assertEquals(0, new MutableInt().intValue());
92  
93          assertEquals(1, new MutableInt(1).intValue());
94  
95          assertEquals(2, new MutableInt(Integer.valueOf(2)).intValue());
96          assertEquals(3, new MutableInt(new MutableLong(3)).intValue());
97  
98          assertEquals(2, new MutableInt("2").intValue());
99  
100     }
101 
102     @Test
103     void testDecrement() {
104         final MutableInt mutNum = new MutableInt(1);
105         mutNum.decrement();
106 
107         assertEquals(0, mutNum.intValue());
108         assertEquals(0L, mutNum.longValue());
109     }
110 
111     @Test
112     void testDecrementAndGet() {
113         final MutableInt mutNum = new MutableInt(1);
114         final int result = mutNum.decrementAndGet();
115 
116         assertEquals(0, result);
117         assertEquals(0, mutNum.intValue());
118         assertEquals(0L, mutNum.longValue());
119     }
120 
121     @Test
122     void testEquals() {
123         this.testEquals(new MutableInt(0), new MutableInt(0), new MutableInt(1));
124         // Should Numbers be supported? GaryG July-21-2005.
125         //this.testEquals(mutNumA, Integer.valueOf(0), mutNumC);
126     }
127 
128     /**
129      * @param numA must not be a 0 Integer; must not equal numC.
130      * @param numB must equal numA; must not equal numC.
131      * @param numC must not equal numA; must not equal numC.
132      */
133     void testEquals(final Number numA, final Number numB, final Number numC) {
134         assertEquals(numA, numA);
135         assertEquals(numA, numB);
136         assertEquals(numB, numA);
137         assertEquals(numB, numB);
138         assertNotEquals(numA, numC);
139         assertNotEquals(numB, numC);
140         assertEquals(numC, numC);
141         assertNotEquals(null, numA);
142         assertNotEquals(numA, Integer.valueOf(0));
143         assertNotEquals("0", numA);
144     }
145 
146     @Test
147     void testGetAndAddValueObject() {
148         final MutableInt mutableInteger = new MutableInt(0);
149         final int result = mutableInteger.getAndAdd(Integer.valueOf(1));
150 
151         assertEquals(0, result);
152         assertEquals(1, mutableInteger.intValue());
153     }
154 
155     @Test
156     void testGetAndAddValuePrimitive() {
157         final MutableInt mutableInteger = new MutableInt(0);
158         final int result = mutableInteger.getAndAdd(1);
159 
160         assertEquals(0, result);
161         assertEquals(1, mutableInteger.intValue());
162     }
163 
164     @Test
165     void testGetAndDecrement() {
166         final MutableInt mutNum = new MutableInt(1);
167         final int result = mutNum.getAndDecrement();
168 
169         assertEquals(1, result);
170         assertEquals(0, mutNum.intValue());
171         assertEquals(0L, mutNum.longValue());
172     }
173 
174     @Test
175     void testGetAndIncrement() {
176         final MutableInt mutNum = new MutableInt(1);
177         final int result = mutNum.getAndIncrement();
178 
179         assertEquals(1, result);
180         assertEquals(2, mutNum.intValue());
181         assertEquals(2L, mutNum.longValue());
182     }
183 
184     @Test
185     void testGetSet() {
186         final MutableInt mutNum = new MutableInt(0);
187         assertEquals(0, new MutableInt().intValue());
188         assertEquals(Integer.valueOf(0), new MutableInt().get());
189         assertEquals(Integer.valueOf(0), new MutableInt().getValue());
190 
191         mutNum.setValue(1);
192         assertEquals(1, mutNum.intValue());
193         assertEquals(Integer.valueOf(1), mutNum.get());
194         assertEquals(Integer.valueOf(1), mutNum.getValue());
195 
196         mutNum.setValue(Integer.valueOf(2));
197         assertEquals(2, mutNum.intValue());
198         assertEquals(Integer.valueOf(2), mutNum.get());
199         assertEquals(Integer.valueOf(2), mutNum.getValue());
200 
201         mutNum.setValue(new MutableLong(3));
202         assertEquals(3, mutNum.intValue());
203         assertEquals(Integer.valueOf(3), mutNum.get());
204         assertEquals(Integer.valueOf(3), mutNum.getValue());
205     }
206 
207     @Test
208     void testHashCode() {
209         final MutableInt mutNumA = new MutableInt(0);
210         final MutableInt mutNumB = new MutableInt(0);
211         final MutableInt mutNumC = new MutableInt(1);
212 
213         assertEquals(mutNumA.hashCode(), mutNumA.hashCode());
214         assertEquals(mutNumA.hashCode(), mutNumB.hashCode());
215         assertNotEquals(mutNumA.hashCode(), mutNumC.hashCode());
216         assertEquals(mutNumA.hashCode(), Integer.valueOf(0).hashCode());
217     }
218 
219     @Test
220     void testIncrement() {
221         final MutableInt mutNum = new MutableInt(1);
222         mutNum.increment();
223 
224         assertEquals(2, mutNum.intValue());
225         assertEquals(2L, mutNum.longValue());
226     }
227 
228     @Test
229     void testIncrementAndGet() {
230         final MutableInt mutNum = new MutableInt(1);
231         final int result = mutNum.incrementAndGet();
232 
233         assertEquals(2, result);
234         assertEquals(2, mutNum.intValue());
235         assertEquals(2L, mutNum.longValue());
236     }
237 
238     @Test
239     void testPrimitiveValues() {
240         final MutableInt mutNum = new MutableInt(1);
241         assertEquals((byte) 1, mutNum.byteValue());
242         assertEquals((short) 1, mutNum.shortValue());
243         assertEquals(1.0F, mutNum.floatValue());
244         assertEquals(1.0, mutNum.doubleValue());
245         assertEquals(1L, mutNum.longValue());
246     }
247 
248     @Test
249     void testSetNull() {
250         final MutableInt mutNum = new MutableInt(0);
251         assertNullPointerException(() -> mutNum.setValue(null));
252     }
253 
254     @Test
255     void testSubtractValueObject() {
256         final MutableInt mutNum = new MutableInt(1);
257         mutNum.subtract(Integer.valueOf(1));
258 
259         assertEquals(0, mutNum.intValue());
260         assertEquals(0L, mutNum.longValue());
261     }
262 
263     @Test
264     void testSubtractValuePrimitive() {
265         final MutableInt mutNum = new MutableInt(1);
266         mutNum.subtract(1);
267 
268         assertEquals(0, mutNum.intValue());
269         assertEquals(0L, mutNum.longValue());
270     }
271 
272     @Test
273     void testToInteger() {
274         assertEquals(Integer.valueOf(0), new MutableInt(0).toInteger());
275         assertEquals(Integer.valueOf(123), new MutableInt(123).toInteger());
276     }
277 
278     @Test
279     void testToString() {
280         assertEquals("0", new MutableInt(0).toString());
281         assertEquals("10", new MutableInt(10).toString());
282         assertEquals("-123", new MutableInt(-123).toString());
283     }
284 
285 }