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