Home | History | Annotate | Download | only in primitives 
      1 /*
      2  * Copyright (C) 2011 The Guava Authors
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
      5  * in compliance with the License. You may obtain a copy of the License at
      6  *
      7  * http://www.apache.org/licenses/LICENSE-2.0
      8  *
      9  * Unless required by applicable law or agreed to in writing, software distributed under the
     10  * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
     11  * express or implied. See the License for the specific language governing permissions and
     12  * limitations under the License.
     13  */
     14 
     15 package com.google.common.primitives;
     16 
     17 import com.google.common.annotations.GwtCompatible;
     18 import com.google.common.annotations.GwtIncompatible;
     19 import com.google.common.collect.ImmutableSet;
     20 import com.google.common.testing.EqualsTester;
     21 import com.google.common.testing.NullPointerTester;
     22 import com.google.common.testing.SerializableTester;
     23 
     24 import junit.framework.TestCase;
     25 
     26 import java.math.BigInteger;
     27 
     28 /**
     29  * Tests for {@code UnsignedInteger}.
     30  *
     31  * @author Louis Wasserman
     32  */
     33 @GwtCompatible(emulated = true)
     34 public class UnsignedIntegerTest extends TestCase {
     35   private static final ImmutableSet<Integer> TEST_INTS;
     36   private static final ImmutableSet<Long> TEST_LONGS;
     37 
     38   private static int force32(int value) {
     39     // GWT doesn't consistently overflow values to make them 32-bit, so we need to force it.
     40     return value & 0xffffffff;
     41   }
     42 
     43   static {
     44     ImmutableSet.Builder<Integer> testIntsBuilder = ImmutableSet.builder();
     45     ImmutableSet.Builder<Long> testLongsBuilder = ImmutableSet.builder();
     46     for (int i = -3; i <= 3; i++) {
     47       testIntsBuilder
     48         .add(i)
     49         .add(force32(Integer.MIN_VALUE + i))
     50         .add(force32(Integer.MAX_VALUE + i));
     51       testLongsBuilder
     52         .add((long) i)
     53         .add((long) Integer.MIN_VALUE + i)
     54         .add((long) Integer.MAX_VALUE + i)
     55         .add((1L << 32) + i);
     56     }
     57     TEST_INTS = testIntsBuilder.build();
     58     TEST_LONGS = testLongsBuilder.build();
     59   }
     60 
     61   public void testFromIntBitsAndIntValueAreInverses() {
     62     for (int value : TEST_INTS) {
     63       assertEquals(UnsignedInts.toString(value), value, UnsignedInteger.fromIntBits(value)
     64           .intValue());
     65     }
     66   }
     67 
     68   public void testFromIntBitsLongValue() {
     69     for (int value : TEST_INTS) {
     70       long expected = value & 0xffffffffL;
     71       assertEquals(UnsignedInts.toString(value), expected, UnsignedInteger.fromIntBits(value)
     72           .longValue());
     73     }
     74   }
     75 
     76   public void testValueOfLong() {
     77     long min = 0;
     78     long max = (1L << 32) - 1;
     79     for (long value : TEST_LONGS) {
     80       boolean expectSuccess = value >= min && value <= max;
     81       try {
     82         assertEquals(value, UnsignedInteger.valueOf(value).longValue());
     83         assertTrue(expectSuccess);
     84       } catch (IllegalArgumentException e) {
     85         assertFalse(expectSuccess);
     86       }
     87     }
     88   }
     89 
     90   public void testValueOfBigInteger() {
     91     long min = 0;
     92     long max = (1L << 32) - 1;
     93     for (long value : TEST_LONGS) {
     94       boolean expectSuccess = value >= min && value <= max;
     95       try {
     96         assertEquals(value, UnsignedInteger.valueOf(BigInteger.valueOf(value))
     97             .longValue());
     98         assertTrue(expectSuccess);
     99       } catch (IllegalArgumentException e) {
    100         assertFalse(expectSuccess);
    101       }
    102     }
    103   }
    104 
    105   public void testToString() {
    106     for (int value : TEST_INTS) {
    107       UnsignedInteger unsignedValue = UnsignedInteger.fromIntBits(value);
    108       assertEquals(unsignedValue.bigIntegerValue().toString(), unsignedValue.toString());
    109     }
    110   }
    111 
    112   @GwtIncompatible("too slow")
    113   public void testToStringRadix() {
    114     for (int radix = Character.MIN_RADIX; radix <= Character.MAX_RADIX; radix++) {
    115       for (int l : TEST_INTS) {
    116         UnsignedInteger value = UnsignedInteger.fromIntBits(l);
    117         assertEquals(value.bigIntegerValue().toString(radix), value.toString(radix));
    118       }
    119     }
    120   }
    121 
    122   public void testToStringRadixQuick() {
    123     int[] radices = {2, 3, 5, 7, 10, 12, 16, 21, 31, 36};
    124     for (int radix : radices) {
    125       for (int l : TEST_INTS) {
    126         UnsignedInteger value = UnsignedInteger.fromIntBits(l);
    127         assertEquals(value.bigIntegerValue().toString(radix), value.toString(radix));
    128       }
    129     }
    130   }
    131 
    132   public void testFloatValue() {
    133     for (int value : TEST_INTS) {
    134       UnsignedInteger unsignedValue = UnsignedInteger.fromIntBits(value);
    135       assertEquals(unsignedValue.bigIntegerValue().floatValue(), unsignedValue.floatValue());
    136     }
    137   }
    138 
    139   public void testDoubleValue() {
    140     for (int value : TEST_INTS) {
    141       UnsignedInteger unsignedValue = UnsignedInteger.fromIntBits(value);
    142       assertEquals(unsignedValue.bigIntegerValue().doubleValue(), unsignedValue.doubleValue());
    143     }
    144   }
    145 
    146   public void testPlus() {
    147     for (int a : TEST_INTS) {
    148       for (int b : TEST_INTS) {
    149         UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    150         UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
    151         int expected = aUnsigned.bigIntegerValue().add(bUnsigned.bigIntegerValue()).intValue();
    152         UnsignedInteger unsignedSum = aUnsigned.plus(bUnsigned);
    153         assertEquals(expected, unsignedSum.intValue());
    154       }
    155     }
    156   }
    157 
    158   public void testMinus() {
    159     for (int a : TEST_INTS) {
    160       for (int b : TEST_INTS) {
    161         UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    162         UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
    163         int expected =
    164             force32(aUnsigned.bigIntegerValue().subtract(bUnsigned.bigIntegerValue()).intValue());
    165         UnsignedInteger unsignedSub = aUnsigned.minus(bUnsigned);
    166         assertEquals(expected, unsignedSub.intValue());
    167       }
    168     }
    169   }
    170 
    171   @GwtIncompatible("multiply")
    172   public void testTimes() {
    173     for (int a : TEST_INTS) {
    174       for (int b : TEST_INTS) {
    175         UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    176         UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
    177         int expected =
    178             force32(aUnsigned.bigIntegerValue().multiply(bUnsigned.bigIntegerValue()).intValue());
    179         UnsignedInteger unsignedMul = aUnsigned.times(bUnsigned);
    180         assertEquals(aUnsigned + " * " + bUnsigned, expected, unsignedMul.intValue());
    181       }
    182     }
    183   }
    184 
    185   public void testDividedBy() {
    186     for (int a : TEST_INTS) {
    187       for (int b : TEST_INTS) {
    188         if (b != 0) {
    189           UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    190           UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
    191           int expected =
    192               aUnsigned.bigIntegerValue().divide(bUnsigned.bigIntegerValue()).intValue();
    193           UnsignedInteger unsignedDiv = aUnsigned.dividedBy(bUnsigned);
    194           assertEquals(expected, unsignedDiv.intValue());
    195         }
    196       }
    197     }
    198   }
    199 
    200   public void testDivideByZeroThrows() {
    201     for (int a : TEST_INTS) {
    202       try {
    203         UnsignedInteger ignored =
    204             UnsignedInteger.fromIntBits(a).dividedBy(UnsignedInteger.ZERO);
    205         fail("Expected ArithmeticException");
    206       } catch (ArithmeticException expected) {}
    207     }
    208   }
    209 
    210   public void testMod() {
    211     for (int a : TEST_INTS) {
    212       for (int b : TEST_INTS) {
    213         if (b != 0) {
    214           UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    215           UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
    216           int expected =
    217               aUnsigned.bigIntegerValue().mod(bUnsigned.bigIntegerValue()).intValue();
    218           UnsignedInteger unsignedRem = aUnsigned.mod(bUnsigned);
    219           assertEquals(expected, unsignedRem.intValue());
    220         }
    221       }
    222     }
    223   }
    224 
    225   @SuppressWarnings("ReturnValueIgnored")
    226   public void testModByZero() {
    227     for (int a : TEST_INTS) {
    228       try {
    229         UnsignedInteger.fromIntBits(a).mod(UnsignedInteger.ZERO);
    230         fail("Expected ArithmeticException");
    231       } catch (ArithmeticException expected) {}
    232     }
    233   }
    234 
    235   public void testCompare() {
    236     for (int a : TEST_INTS) {
    237       for (int b : TEST_INTS) {
    238         UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    239         UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);
    240         assertEquals(aUnsigned.bigIntegerValue().compareTo(bUnsigned.bigIntegerValue()),
    241             aUnsigned.compareTo(bUnsigned));
    242       }
    243     }
    244   }
    245 
    246   @GwtIncompatible("too slow")
    247   public void testEquals() {
    248     EqualsTester equalsTester = new EqualsTester();
    249     for (int a : TEST_INTS) {
    250       long value = a & 0xffffffffL;
    251       equalsTester.addEqualityGroup(UnsignedInteger.fromIntBits(a), UnsignedInteger.valueOf(value),
    252           UnsignedInteger.valueOf(Long.toString(value)),
    253           UnsignedInteger.valueOf(Long.toString(value, 16), 16));
    254     }
    255     equalsTester.testEquals();
    256   }
    257 
    258   public void testIntValue() {
    259     for (int a : TEST_INTS) {
    260       UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
    261       int intValue = aUnsigned.bigIntegerValue().intValue();
    262       assertEquals(intValue, aUnsigned.intValue());
    263     }
    264   }
    265 
    266   @GwtIncompatible("serialization")
    267   public void testSerialization() {
    268     for (int a : TEST_INTS) {
    269       SerializableTester.reserializeAndAssert(UnsignedInteger.fromIntBits(a));
    270     }
    271   }
    272 
    273   @GwtIncompatible("NullPointerTester")
    274   public void testNulls() {
    275     new NullPointerTester().testAllPublicStaticMethods(UnsignedInteger.class);
    276   }
    277 }
    278