user/test/com/google/gwt/emultest/java/lang/IntegerTest.java

/*
 * Copyright 2007 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.emultest.java.lang;

import com.google.gwt.junit.client.GWTTestCase;

/**
 * Unit tests for the Javascript emulation of the Integer/int autoboxed
 * fundamental type.
 */
public class IntegerTest extends GWTTestCase {

  @Override
  public String getModuleName() {
    return "com.google.gwt.emultest.EmulSuite";
  }

  public void testBadStrings() {
    try {
      new Integer("05abcd");
      fail("Constructor should have thrown NumberFormatException");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.decode("05abcd");
      fail("Decode should have thrown NumberFormatException");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt("05abcd");
      fail("parseInt should have thrown NumberFormatException");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt(String.valueOf(Long.MAX_VALUE));
      fail("parseInt should reject numbers greater than the range of int");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt(String.valueOf(Long.MIN_VALUE));
      fail("parseInt should reject numbers less than the range of int");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt(String.valueOf((long) Integer.MAX_VALUE + 1));
      fail("parseInt should reject numbers greater than the range of int");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt(String.valueOf((long) Integer.MIN_VALUE - 1));
      fail("parseInt should reject numbers less than the range of int");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt("-");
      fail("parseInt should reject \"-\"");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt(" -12345");
      fail("parseInt should reject leading whitespace");
    } catch (NumberFormatException e) {
      // Expected behavior
    }

    try {
      Integer.parseInt("-12345 ");
      fail("parseInt should reject trailing whitespace");
    } catch (NumberFormatException e) {
      // Expected behavior
    }
  }

  public void testBinaryString() {
    assertEquals("11000000111001", Integer.toBinaryString(12345));
    assertEquals("0", Integer.toBinaryString(0));
    assertEquals("11111111111111111100111111000111",
        Integer.toBinaryString(-12345));
  }

  public void testBitCount() {
    assertEquals(0, Integer.bitCount(0));
    assertEquals(1, Integer.bitCount(1));
    assertEquals(32, Integer.bitCount(-1));
    assertEquals(31, Integer.bitCount(Integer.MAX_VALUE));
    assertEquals(1, Integer.bitCount(Integer.MIN_VALUE));
  }

  public void testCompare() {
    assertTrue("Integer.compare failed for 1 < 2", Integer.compare(1, 2) < 0);
    assertTrue("Integer.compare failed for 2 > 1", Integer.compare(2, 1) > 0);
    assertEquals(0, Integer.compare(1, 1));
    assertEquals(-1, Integer.compare(Integer.MIN_VALUE, 1));
  }

  public void testCompareTo() {
    assertEquals(-1, new Integer(12345).compareTo(new Integer(12346)));
    assertEquals(1, new Integer("12345").compareTo(new Integer(12344)));
    assertEquals(0, new Integer("12345").compareTo(new Integer(12345)));
  }

  public void testConstants() {
    assertEquals(32, Integer.SIZE);
    assertEquals(0x7fffffff, Integer.MAX_VALUE);
    assertEquals(0x80000000, Integer.MIN_VALUE);
  }

  public void testConstructor() {
    assertEquals(12345, new Integer(12345).intValue());
    assertEquals(12345, new Integer("12345").intValue());
  }

  public void testDecode() {
    assertEquals(Integer.MAX_VALUE, Integer.decode(
        String.valueOf(Integer.MAX_VALUE)).intValue());
    assertEquals(Integer.MIN_VALUE, Integer.decode(
        String.valueOf(Integer.MIN_VALUE)).intValue());
    assertEquals(12345, Integer.decode("12345").intValue());
    assertEquals(12345, Integer.decode("+12345").intValue());
    assertEquals(-12345, Integer.decode("-12345").intValue());
    assertEquals(31, Integer.decode("0x1f").intValue());
    assertEquals(-31, Integer.decode("-0X1F").intValue());
    assertEquals(31, Integer.decode("#1f").intValue());
    assertEquals(10, Integer.decode("012").intValue());
    try {
      Integer.decode("abx");
      fail();
    } catch (NumberFormatException e) {
      // pass
    }
  }

  public void testEquals() {
    assertFalse(new Integer(12345).equals(new Integer(12346)));
    assertEquals(new Integer("12345"), new Integer(12345));
  }

  public void testHashCode() {
    assertEquals(1234, new Integer(1234).hashCode());
  }

  public void testHighestOneBit() {
    assertEquals(0, Integer.highestOneBit(0));
    assertEquals(Integer.MIN_VALUE, Integer.highestOneBit(-1));
    assertEquals(Integer.MIN_VALUE, Integer.highestOneBit(-256));
    assertEquals(1, Integer.highestOneBit(1));
    assertEquals(0x80, Integer.highestOneBit(0x88));
    assertEquals(0x40000000, Integer.highestOneBit(Integer.MAX_VALUE));
  }

  public void testLowestOneBit() {
    assertEquals(0, Integer.lowestOneBit(0));
    assertEquals(1, Integer.lowestOneBit(-1));
    assertEquals(0x100, Integer.lowestOneBit(-256));
    assertEquals(1, Integer.lowestOneBit(1));
    assertEquals(0x80, Integer.lowestOneBit(0x880));
    assertEquals(0x80000000, Integer.lowestOneBit(Integer.MIN_VALUE));
  }

  public void testNumberOfLeadingZeros() {
    assertEquals(32, Integer.numberOfLeadingZeros(0));
    assertEquals(31, Integer.numberOfLeadingZeros(1));
    assertEquals(0, Integer.numberOfLeadingZeros(-1));
    assertEquals(16, Integer.numberOfLeadingZeros(0x8000));
    assertEquals(1, Integer.numberOfLeadingZeros(Integer.MAX_VALUE));
    assertEquals(0, Integer.numberOfLeadingZeros(Integer.MIN_VALUE));
    assertEquals(0, Integer.numberOfLeadingZeros(-0x8000));
  }

  public void testNumberOfTrailingZeros() {
    assertEquals(32, Integer.numberOfTrailingZeros(0));
    assertEquals(0, Integer.numberOfTrailingZeros(1));
    assertEquals(0, Integer.numberOfTrailingZeros(-1));
    assertEquals(15, Integer.numberOfTrailingZeros(0x8000));
    assertEquals(0, Integer.numberOfTrailingZeros(Integer.MAX_VALUE));
    assertEquals(31, Integer.numberOfTrailingZeros(Integer.MIN_VALUE));
    assertEquals(4, Integer.numberOfTrailingZeros(-0x7ff0));
  }

  public void testReverse() {
    assertEquals(0, Integer.reverse(0));
    assertEquals(-1, Integer.reverse(-1));
    assertEquals(Integer.MIN_VALUE, Integer.reverse(1));
    assertEquals(1, Integer.reverse(Integer.MIN_VALUE));
    assertEquals(0xaaaaaaaa, Integer.reverse(0x55555555));
    assertEquals(0xaaaa0000, Integer.reverse(0x00005555));
    assertEquals(0xaa00aa00, Integer.reverse(0x00550055));
    assertEquals(0x55555555, Integer.reverse(0xaaaaaaaa));
    assertEquals(0x00005555, Integer.reverse(0xaaaa0000));
    assertEquals(0x00550055, Integer.reverse(0xaa00aa00));
  }

  public void testReverseBytes() {
    assertEquals(0, Integer.reverseBytes(0));
    // two-complement bugs?
    assertEquals(0x84218421, Integer.reverseBytes(0x21842184));
    assertEquals(0x12481248, Integer.reverseBytes(0x48124812));
    assertEquals(0x21436587, Integer.reverseBytes(0x87654321));
  }

  public void testRotateLeft() {
    assertEquals(0, Integer.rotateLeft(0, 4));
    assertEquals(0x2, Integer.rotateLeft(1, 1));
    assertEquals(0x10, Integer.rotateLeft(1, 4));
    assertEquals(-1, Integer.rotateLeft(-1, 4));
    assertEquals(Integer.MIN_VALUE, Integer.rotateLeft(0x40000000, 1));
    assertEquals(1, Integer.rotateLeft(Integer.MIN_VALUE, 1));
  }

  public void testRotateRight() {
    assertEquals(0, Integer.rotateRight(0, 4));
    assertEquals(Integer.MIN_VALUE, Integer.rotateRight(1, 1));
    assertEquals(0x10000000, Integer.rotateRight(1, 4));
    assertEquals(-1, Integer.rotateRight(-1, 4));
  }

  public void testSignum() {
    assertEquals(0, Integer.signum(0));
    assertEquals(1, Integer.signum(1));
    assertEquals(-1, Integer.signum(-1));
    assertEquals(1, Integer.signum(Integer.MAX_VALUE));
    assertEquals(-1, Integer.signum(Integer.MIN_VALUE));
  }

  public void testStaticValueOf() {
    assertEquals(Integer.MIN_VALUE,
        Integer.valueOf(Integer.MIN_VALUE).intValue());
    assertEquals(Integer.MAX_VALUE,
        Integer.valueOf(Integer.MAX_VALUE).intValue());
  }

  public void testToBinaryString() {
    assertEquals("1111111111111111111111111111111", Integer.toBinaryString(Integer.MAX_VALUE));
    assertEquals("10000000000000000000000000000000", Integer.toBinaryString(Integer.MIN_VALUE));
  }

  public void testToHexString() {
    assertEquals("12345", Integer.toHexString(0x12345));
    assertEquals("fff12345", Integer.toHexString(0xFFF12345));
    assertEquals("7fffffff", Integer.toHexString(Integer.MAX_VALUE));
    assertEquals("80000000", Integer.toHexString(Integer.MIN_VALUE));
    assertEquals("ffffffff", Integer.toHexString(-1));

    String[] hexDigits = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
        "a", "b", "c", "d", "e", "f" };
    for (int i = 0; i < hexDigits.length; i++) {
      assertEquals(hexDigits[i], Integer.toHexString(i));
    }
  }

  public void testToOctalString() {
    assertEquals("17777777777", Integer.toOctalString(Integer.MAX_VALUE));
    assertEquals("20000000000", Integer.toOctalString(Integer.MIN_VALUE));
  }

  public void testToString() {
    assertEquals("12345", new Integer(12345).toString());
    assertEquals("-12345", new Integer("-12345").toString());

    assertEquals("-80765", Integer.toString(-80765));
    assertEquals("2147483647", Integer.toString(Integer.MAX_VALUE));
    assertEquals("-2147483647", Integer.toString(-Integer.MAX_VALUE));
    assertEquals("-2147483648", Integer.toString(Integer.MIN_VALUE));
    assertEquals("0", Integer.toString(0));

    assertEquals("17777777777", Integer.toString(2147483647, 8));
    assertEquals("7fffffff", Integer.toString(2147483647, 16));
    assertEquals("1111111111111111111111111111111", Integer.toString(2147483647, 2));
    assertEquals("2147483647", Integer.toString(2147483647, 10));
    assertEquals("-17777777777", Integer.toString(-2147483647, 8));
    assertEquals("-7fffffff", Integer.toString(-2147483647, 16));
    assertEquals("-1111111111111111111111111111111", Integer.toString(-2147483647, 2));
    assertEquals("-2147483647", Integer.toString(-2147483647, 10));
    assertEquals("-20000000000", Integer.toString(-2147483648, 8));
    assertEquals("-80000000", Integer.toString(-2147483648, 16));
    assertEquals("-10000000000000000000000000000000", Integer.toString(-2147483648, 2));
    assertEquals("-2147483648", Integer.toString(-2147483648, 10));
  }

  public void testValueOf() {
    assertEquals(new Integer(12345), Integer.valueOf("12345"));
    assertEquals(new Integer(1865), Integer.valueOf("12345", 6));
  }

  public void testParseInt() {
    assertEquals(12345, Integer.parseInt("12345"));
    assertEquals(12345, Integer.parseInt("+12345"));
    assertEquals(-12345, Integer.parseInt("-12345"));
    assertEquals(1865, Integer.parseInt("12345", 6));
    assertEquals(0, Integer.parseInt("0"));
    assertEquals(Integer.MAX_VALUE,
        Integer.parseInt(String.valueOf(Integer.MAX_VALUE)));
    assertEquals(Integer.MIN_VALUE,
        Integer.parseInt(String.valueOf(Integer.MIN_VALUE)));
  }

  public void testXValue() {
    assertEquals("short", (short) 12345, new Integer(12345).shortValue());
    assertEquals("long", 1234567890L, new Integer(1234567890).longValue());
    assertEquals("double", 12345d, new Integer(12345).doubleValue(), 0.001);
    assertEquals("float", 12345f, new Integer(12345).floatValue(), 0.01);
    assertEquals("byte", (byte) 123, new Integer(123).byteValue());
    assertEquals("integer", 123, new Integer(123).intValue());
    assertEquals("short overflow", (short) 10713,
        new Integer(1234512345).shortValue());
    assertEquals("double2", 1234512345d, new Integer(1234512345).doubleValue(),
        0.001);
    // Invalid test right now; we don't coerce to single precision
    // assertEquals("float2",1234512345f, new
    // Integer(1234512345).floatValue(),0.001);
    assertEquals("byte overflow", (byte) -13, new Integer(123123).byteValue());
  }
}