harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From smish...@apache.org
Subject svn commit: r437974 [10/19] - /incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/
Date Tue, 29 Aug 2006 05:40:47 GMT
Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java?rev=437974&r1=437973&r2=437974&view=diff
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java (original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java Mon Aug 28 22:40:44 2006
@@ -1,1038 +1,1038 @@
-/* Copyright 2006 The Apache Software Foundation or its licensors, as applicable
- * 
- * 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 org.apache.harmony.luni.tests.java.lang;
-
-import java.util.Properties;
-
-import junit.framework.TestCase;
-
-public class LongTest extends TestCase {
-    private Properties orgProps;
-    
-    protected void setUp() {
-        orgProps = System.getProperties();
-    }
-
-    protected void tearDown() {
-        System.setProperties(orgProps);
-    }
-
-    /**
-     * @tests java.lang.Long#byteValue()
-     */
-    public void test_byteValue() {
-        // Test for method byte java.lang.Long.byteValue()
-        Long l = new Long(127);
-        assertEquals("Returned incorrect byte value", 127, l.byteValue());
-        assertEquals("Returned incorrect byte value", -1, new Long(Long.MAX_VALUE)
-                .byteValue());
-    }
-
-    /**
-     * @tests java.lang.Long#compareTo(java.lang.Long)
-     */
-    public void test_compareToLjava_lang_Long() {
-        // Test for method int java.lang.Long.compareTo(java.lang.Long)
-        assertTrue("-2 compared to 1 gave non-negative answer", new Long(-2L)
-                .compareTo(new Long(1L)) < 0);
-        assertEquals("-2 compared to -2 gave non-zero answer", 0, new Long(-2L)
-                .compareTo(new Long(-2L)));
-        assertTrue("3 compared to 2 gave non-positive answer", new Long(3L)
-                .compareTo(new Long(2L)) > 0);
-        
-        try {
-            new Long(0).compareTo(null);
-            fail("No NPE");
-        } catch (NullPointerException e) {
-        }
-    }
-
-    /**
-     * @tests java.lang.Long#decode(java.lang.String)
-     */
-    public void test_decodeLjava_lang_String2() {
-        // Test for method java.lang.Long
-        // java.lang.Long.decode(java.lang.String)
-        assertEquals("Returned incorrect value for hex string", 255L, Long.decode(
-                "0xFF").longValue());
-        assertEquals("Returned incorrect value for dec string", -89000L, Long.decode(
-                "-89000").longValue());
-        assertEquals("Returned incorrect value for 0 decimal", 0, Long.decode("0")
-                .longValue());
-        assertEquals("Returned incorrect value for 0 hex", 0, Long.decode("0x0")
-                .longValue());
-        assertTrue(
-                "Returned incorrect value for most negative value decimal",
-                Long.decode("-9223372036854775808").longValue() == 0x8000000000000000L);
-        assertTrue(
-                "Returned incorrect value for most negative value hex",
-                Long.decode("-0x8000000000000000").longValue() == 0x8000000000000000L);
-        assertTrue(
-                "Returned incorrect value for most positive value decimal",
-                Long.decode("9223372036854775807").longValue() == 0x7fffffffffffffffL);
-        assertTrue(
-                "Returned incorrect value for most positive value hex",
-                Long.decode("0x7fffffffffffffff").longValue() == 0x7fffffffffffffffL);
-        assertTrue("Failed for 07654321765432", Long.decode("07654321765432")
-                .longValue() == 07654321765432l);
-
-        boolean exception = false;
-        try {
-            Long
-                    .decode("999999999999999999999999999999999999999999999999999999");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for value > ilong", exception);
-
-        exception = false;
-        try {
-            Long.decode("9223372036854775808");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
-
-        exception = false;
-        try {
-            Long.decode("-9223372036854775809");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
-
-        exception = false;
-        try {
-            Long.decode("0x8000000000000000");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception);
-
-        exception = false;
-        try {
-            Long.decode("-0x8000000000000001");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception);
-
-        exception = false;
-        try {
-            Long.decode("42325917317067571199");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for 42325917317067571199",
-                exception);
-    }
-
-     /**
-     * @tests java.lang.Long#getLong(java.lang.String)
-     */
-    public void test_getLongLjava_lang_String() {
-        // Test for method java.lang.Long
-        // java.lang.Long.getLong(java.lang.String)
-        Properties tProps = new Properties();
-        tProps.put("testLong", "99");
-        System.setProperties(tProps);
-        assertTrue("returned incorrect Long", Long.getLong("testLong").equals(
-                new Long(99)));
-        assertNull("returned incorrect default Long",
-                Long.getLong("ff"));
-    }
-
-    /**
-     * @tests java.lang.Long#getLong(java.lang.String, long)
-     */
-    public void test_getLongLjava_lang_StringJ() {
-        // Test for method java.lang.Long
-        // java.lang.Long.getLong(java.lang.String, long)
-        Properties tProps = new Properties();
-        tProps.put("testLong", "99");
-        System.setProperties(tProps);
-        assertTrue("returned incorrect Long", Long.getLong("testLong", 4L)
-                .equals(new Long(99)));
-        assertTrue("returned incorrect default Long", Long.getLong("ff", 4L)
-                .equals(new Long(4)));
-    }
-
-    /**
-     * @tests java.lang.Long#getLong(java.lang.String, java.lang.Long)
-     */
-    public void test_getLongLjava_lang_StringLjava_lang_Long() {
-        // Test for method java.lang.Long
-        // java.lang.Long.getLong(java.lang.String, java.lang.Long)
-        Properties tProps = new Properties();
-        tProps.put("testLong", "99");
-        System.setProperties(tProps);
-        assertTrue("returned incorrect Long", Long.getLong("testLong",
-                new Long(4)).equals(new Long(99)));
-        assertTrue("returned incorrect default Long", Long.getLong("ff",
-                new Long(4)).equals(new Long(4)));
-    }
-
-    /**
-     * @tests java.lang.Long#parseLong(java.lang.String)
-     */
-    public void test_parseLongLjava_lang_String2() {
-        // Test for method long java.lang.Long.parseLong(java.lang.String)
-
-        long l = Long.parseLong("89000000005");
-        assertEquals("Parsed to incorrect long value", 89000000005L, l);
-        assertEquals("Returned incorrect value for 0", 0, Long.parseLong("0"));
-        assertTrue("Returned incorrect value for most negative value", Long
-                .parseLong("-9223372036854775808") == 0x8000000000000000L);
-        assertTrue("Returned incorrect value for most positive value", Long
-                .parseLong("9223372036854775807") == 0x7fffffffffffffffL);
-
-        boolean exception = false;
-        try {
-            Long.parseLong("9223372036854775808");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
-
-        exception = false;
-        try {
-            Long.parseLong("-9223372036854775809");
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
-    }
-
-    /**
-     * @tests java.lang.Long#parseLong(java.lang.String, int)
-     */
-    public void test_parseLongLjava_lang_StringI() {
-        // Test for method long java.lang.Long.parseLong(java.lang.String, int)
-        assertEquals("Returned incorrect value",
-                100000000L, Long.parseLong("100000000", 10));
-        assertEquals("Returned incorrect value from hex string", 68719476735L, Long.parseLong(
-                "FFFFFFFFF", 16));
-        assertTrue("Returned incorrect value from octal string: "
-                + Long.parseLong("77777777777"), Long.parseLong("77777777777",
-                8) == 8589934591L);
-        assertEquals("Returned incorrect value for 0 hex", 0, Long
-                .parseLong("0", 16));
-        assertTrue("Returned incorrect value for most negative value hex", Long
-                .parseLong("-8000000000000000", 16) == 0x8000000000000000L);
-        assertTrue("Returned incorrect value for most positive value hex", Long
-                .parseLong("7fffffffffffffff", 16) == 0x7fffffffffffffffL);
-        assertEquals("Returned incorrect value for 0 decimal", 0, Long.parseLong(
-                "0", 10));
-        assertTrue(
-                "Returned incorrect value for most negative value decimal",
-                Long.parseLong("-9223372036854775808", 10) == 0x8000000000000000L);
-        assertTrue(
-                "Returned incorrect value for most positive value decimal",
-                Long.parseLong("9223372036854775807", 10) == 0x7fffffffffffffffL);
-
-        boolean exception = false;
-        try {
-            Long.parseLong("999999999999", 8);
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-
-        exception = false;
-        try {
-            Long.parseLong("9223372036854775808", 10);
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
-
-        exception = false;
-        try {
-            Long.parseLong("-9223372036854775809", 10);
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
-
-        exception = false;
-        try {
-            Long.parseLong("8000000000000000", 16);
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception);
-
-        exception = false;
-        try {
-            Long.parseLong("-8000000000000001", 16);
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for hex MIN_VALUE + 1", exception);
-
-        exception = false;
-        try {
-            Long.parseLong("42325917317067571199", 10);
-        } catch (NumberFormatException e) {
-            // Correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception for 42325917317067571199",
-                exception);
-    }
-
-    /**
-     * @tests java.lang.Long#toBinaryString(long)
-     */
-    public void test_toBinaryStringJ() {
-        // Test for method java.lang.String java.lang.Long.toBinaryString(long)
-        assertEquals("Incorrect binary string returned", "11011001010010010000", Long.toBinaryString(
-                890000L));
-        assertEquals("Incorrect binary string returned",
-                
-                                "1000000000000000000000000000000000000000000000000000000000000000", Long
-                        .toBinaryString(Long.MIN_VALUE)
-                        );
-        assertEquals("Incorrect binary string returned",
-                
-                                "111111111111111111111111111111111111111111111111111111111111111", Long
-                        .toBinaryString(Long.MAX_VALUE)
-                        );
-    }
-
-    /**
-     * @tests java.lang.Long#toHexString(long)
-     */
-    public void test_toHexStringJ() {
-        // Test for method java.lang.String java.lang.Long.toHexString(long)
-        assertEquals("Incorrect hex string returned", "54e0845", Long.toHexString(89000005L)
-                );
-        assertEquals("Incorrect hex string returned", "8000000000000000", Long.toHexString(
-                Long.MIN_VALUE));
-        assertEquals("Incorrect hex string returned", "7fffffffffffffff", Long.toHexString(
-                Long.MAX_VALUE));
-    }
-
-    /**
-     * @tests java.lang.Long#toOctalString(long)
-     */
-    public void test_toOctalStringJ() {
-        // Test for method java.lang.String java.lang.Long.toOctalString(long)
-        assertEquals("Returned incorrect oct string", "77777777777", Long.toOctalString(
-                8589934591L));
-        assertEquals("Returned incorrect oct string", "1000000000000000000000", Long.toOctalString(
-                Long.MIN_VALUE));
-        assertEquals("Returned incorrect oct string", "777777777777777777777", Long.toOctalString(
-                Long.MAX_VALUE));
-    }
-
-    /**
-     * @tests java.lang.Long#toString()
-     */
-    public void test_toString2() {
-        // Test for method java.lang.String java.lang.Long.toString()
-        Long l = new Long(89000000005L);
-        assertEquals("Returned incorrect String", 
-                "89000000005", l.toString());
-        assertEquals("Returned incorrect String", "-9223372036854775808", new Long(Long.MIN_VALUE)
-                .toString());
-        assertEquals("Returned incorrect String", "9223372036854775807", new Long(Long.MAX_VALUE)
-                .toString());
-    }
-
-    /**
-     * @tests java.lang.Long#toString(long)
-     */
-    public void test_toStringJ2() {
-        // Test for method java.lang.String java.lang.Long.toString(long)
-
-        assertEquals("Returned incorrect String", "89000000005", Long.toString(89000000005L)
-                );
-        assertEquals("Returned incorrect String", "-9223372036854775808", Long.toString(Long.MIN_VALUE)
-                );
-        assertEquals("Returned incorrect String", "9223372036854775807", Long.toString(Long.MAX_VALUE)
-                );
-    }
-
-    /**
-     * @tests java.lang.Long#toString(long, int)
-     */
-    public void test_toStringJI() {
-        // Test for method java.lang.String java.lang.Long.toString(long, int)
-        assertEquals("Returned incorrect dec string", "100000000", Long.toString(100000000L,
-                10));
-        assertEquals("Returned incorrect hex string", "fffffffff", Long.toString(68719476735L,
-                16));
-        assertEquals("Returned incorrect oct string", "77777777777", Long.toString(8589934591L,
-                8));
-        assertEquals("Returned incorrect bin string", 
-                "1111111111111111111111111111111111111111111", Long.toString(
-                8796093022207L, 2));
-        assertEquals("Returned incorrect min string", "-9223372036854775808", Long.toString(
-                0x8000000000000000L, 10));
-        assertEquals("Returned incorrect max string", "9223372036854775807", Long.toString(
-                0x7fffffffffffffffL, 10));
-        assertEquals("Returned incorrect min string", "-8000000000000000", Long.toString(
-                0x8000000000000000L, 16));
-        assertEquals("Returned incorrect max string", "7fffffffffffffff", Long.toString(
-                0x7fffffffffffffffL, 16));
-    }
-
-    /**
-     * @tests java.lang.Long#valueOf(java.lang.String)
-     */
-    public void test_valueOfLjava_lang_String2() {
-        // Test for method java.lang.Long
-        // java.lang.Long.valueOf(java.lang.String)
-        assertEquals("Returned incorrect value", 100000000L, Long.valueOf("100000000")
-                .longValue());
-        assertTrue("Returned incorrect value", Long.valueOf(
-                "9223372036854775807").longValue() == Long.MAX_VALUE);
-        assertTrue("Returned incorrect value", Long.valueOf(
-                "-9223372036854775808").longValue() == Long.MIN_VALUE);
-
-        boolean exception = false;
-        try {
-            Long
-                    .valueOf("999999999999999999999999999999999999999999999999999999999999");
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-
-        exception = false;
-        try {
-            Long.valueOf("9223372036854775808");
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-
-        exception = false;
-        try {
-            Long.valueOf("-9223372036854775809");
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-    }
-
-    /**
-     * @tests java.lang.Long#valueOf(java.lang.String, int)
-     */
-    public void test_valueOfLjava_lang_StringI() {
-        // Test for method java.lang.Long
-        // java.lang.Long.valueOf(java.lang.String, int)
-        assertEquals("Returned incorrect value", 100000000L, Long.valueOf("100000000", 10)
-                .longValue());
-        assertEquals("Returned incorrect value from hex string", 68719476735L, Long.valueOf(
-                "FFFFFFFFF", 16).longValue());
-        assertTrue("Returned incorrect value from octal string: "
-                + Long.valueOf("77777777777", 8).toString(), Long.valueOf(
-                "77777777777", 8).longValue() == 8589934591L);
-        assertTrue("Returned incorrect value", Long.valueOf(
-                "9223372036854775807", 10).longValue() == Long.MAX_VALUE);
-        assertTrue("Returned incorrect value", Long.valueOf(
-                "-9223372036854775808", 10).longValue() == Long.MIN_VALUE);
-        assertTrue("Returned incorrect value", Long.valueOf("7fffffffffffffff",
-                16).longValue() == Long.MAX_VALUE);
-        assertTrue("Returned incorrect value", Long.valueOf(
-                "-8000000000000000", 16).longValue() == Long.MIN_VALUE);
-
-        boolean exception = false;
-        try {
-            Long.valueOf("999999999999", 8);
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-
-        exception = false;
-        try {
-            Long.valueOf("9223372036854775808", 10);
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-
-        exception = false;
-        try {
-            Long.valueOf("-9223372036854775809", 10);
-        } catch (NumberFormatException e) {
-            // correct
-            exception = true;
-        }
-        assertTrue("Failed to throw exception when passed invalid string",
-                exception);
-    }
-    /**
-     * @tests java.lang.Long#valueOf(long)
-     */
-    public void test_valueOfJ() {
-        assertEquals(new Long(Long.MIN_VALUE), Long.valueOf(Long.MIN_VALUE));
-        assertEquals(new Long(Long.MAX_VALUE), Long.valueOf(Long.MAX_VALUE));
-        assertEquals(new Long( 0), Long.valueOf( 0));
-
-        long lng = -128;
-        while (lng < 128) {
-            assertEquals(new Long(lng), Long.valueOf(lng));
-            assertSame(Long.valueOf(lng), Long.valueOf(lng));
-            lng++;
-        }
-    }
-    
-    /**
-     * @tests java.lang.Long#hashCode()
-     */
-    public void test_hashCode() {
-        assertEquals((int)(1L ^ (1L >>> 32)), new Long(1).hashCode());
-        assertEquals((int)(2L ^ (2L >>> 32)), new Long(2).hashCode());
-        assertEquals((int)(0L ^ (0L >>> 32)), new Long(0).hashCode());
-        assertEquals((int)(-1L ^ (-1L >>> 32)), new Long(-1).hashCode());
-    }
-
-    /**
-     * @tests java.lang.Long#Long(String)
-     */
-    public void test_ConstructorLjava_lang_String() {
-        assertEquals(new Long(0), new Long("0"));
-        assertEquals(new Long(1), new Long("1"));
-        assertEquals(new Long(-1), new Long("-1"));
-        
-        try {
-            new Long("0x1");
-            fail("Expected NumberFormatException with hex string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            new Long("9.2");
-            fail("Expected NumberFormatException with floating point string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            new Long("");
-            fail("Expected NumberFormatException with empty string.");
-        } catch (NumberFormatException e) {}
-        
-        try {
-            new Long(null);
-            fail("Expected NumberFormatException with null string.");
-        } catch (NumberFormatException e) {}
-    }
-
-    /**
-     * @tests java.lang.Long#Long
-     */
-    public void test_ConstructorJ() {
-        assertEquals(1, new Long(1).intValue());
-        assertEquals(2, new Long(2).intValue());
-        assertEquals(0, new Long(0).intValue());
-        assertEquals(-1, new Long(-1).intValue());
-    }
-
-    /**
-     * @tests java.lang.Long#byteValue()
-     */
-    public void test_booleanValue() {
-        assertEquals(1, new Long(1).byteValue());    
-        assertEquals(2, new Long(2).byteValue());
-        assertEquals(0, new Long(0).byteValue());
-        assertEquals(-1, new Long(-1).byteValue());
-    }
-
-    /**
-     * @tests java.lang.Long#equals(Object)
-     */
-    public void test_equalsLjava_lang_Object() {
-        assertEquals(new Long(0), Long.valueOf(0));
-        assertEquals(new Long(1), Long.valueOf(1));
-        assertEquals(new Long(-1), Long.valueOf(-1));
-        
-        Long fixture = new Long(25);
-        assertEquals(fixture, fixture);
-        assertFalse(fixture.equals(null));
-        assertFalse(fixture.equals("Not a Long"));
-    }
-
-    /**
-     * @tests java.lang.Long#toString()
-     */
-    public void test_toString() {
-        assertEquals("-1", new Long(-1).toString());
-        assertEquals("0", new Long(0).toString());
-        assertEquals("1", new Long(1).toString());
-        assertEquals("-1", new Long(0xFFFFFFFF).toString());
-    }
-
-    /**
-     * @tests java.lang.Long#toString
-     */
-    public void test_toStringJ() {
-        assertEquals("-1", Long.toString(-1));
-        assertEquals("0", Long.toString(0));
-        assertEquals("1", Long.toString(1));
-        assertEquals("-1", Long.toString(0xFFFFFFFF));
-    }
-
-    /**
-     * @tests java.lang.Long#valueOf(String)
-     */
-    public void test_valueOfLjava_lang_String() {
-        assertEquals(new Long(0), Long.valueOf("0"));
-        assertEquals(new Long(1), Long.valueOf("1"));
-        assertEquals(new Long(-1), Long.valueOf("-1"));
-        
-        try {
-            Long.valueOf("0x1");
-            fail("Expected NumberFormatException with hex string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.valueOf("9.2");
-            fail("Expected NumberFormatException with floating point string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.valueOf("");
-            fail("Expected NumberFormatException with empty string.");
-        } catch (NumberFormatException e) {}
-        
-        try {
-            Long.valueOf(null);
-            fail("Expected NumberFormatException with null string.");
-        } catch (NumberFormatException e) {}
-    }
-    
-    /**
-     * @tests java.lang.Long#valueOf(String,long)
-     */
-    public void test_valueOfLjava_lang_StringJ() {
-        assertEquals(new Long(0), Long.valueOf("0", 10));
-        assertEquals(new Long(1), Long.valueOf("1", 10));
-        assertEquals(new Long(-1), Long.valueOf("-1", 10));
-        
-        //must be consistent with Character.digit()
-        assertEquals(Character.digit('1', 2), Long.valueOf("1", 2).byteValue());
-        assertEquals(Character.digit('F', 16), Long.valueOf("F", 16).byteValue());
-        
-        try {
-            Long.valueOf("0x1", 10);
-            fail("Expected NumberFormatException with hex string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.valueOf("9.2", 10);
-            fail("Expected NumberFormatException with floating point string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.valueOf("", 10);
-            fail("Expected NumberFormatException with empty string.");
-        } catch (NumberFormatException e) {}
-        
-        try {
-            Long.valueOf(null, 10);
-            fail("Expected NumberFormatException with null string.");
-        } catch (NumberFormatException e) {}
-    }
-    
-    /**
-     * @tests java.lang.Long#parseLong(String)
-     */
-    public void test_parseLongLjava_lang_String() {
-        assertEquals(0, Long.parseLong("0"));
-        assertEquals(1, Long.parseLong("1"));
-        assertEquals(-1, Long.parseLong("-1"));
-        
-        try {
-            Long.parseLong("0x1");
-            fail("Expected NumberFormatException with hex string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.parseLong("9.2");
-            fail("Expected NumberFormatException with floating point string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.parseLong("");
-            fail("Expected NumberFormatException with empty string.");
-        } catch (NumberFormatException e) {}
-        
-        try {
-            Long.parseLong(null);
-            fail("Expected NumberFormatException with null string.");
-        } catch (NumberFormatException e) {}
-    }
-    
-    /**
-     * @tests java.lang.Long#parseLong(String,long)
-     */
-    public void test_parseLongLjava_lang_StringJ() {
-        assertEquals(0, Long.parseLong("0", 10));
-        assertEquals(1, Long.parseLong("1", 10));
-        assertEquals(-1, Long.parseLong("-1", 10));
-        
-        //must be consistent with Character.digit()
-        assertEquals(Character.digit('1', 2), Long.parseLong("1", 2));
-        assertEquals(Character.digit('F', 16), Long.parseLong("F", 16));
-        
-        try {
-            Long.parseLong("0x1", 10);
-            fail("Expected NumberFormatException with hex string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.parseLong("9.2", 10);
-            fail("Expected NumberFormatException with floating point string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.parseLong("", 10);
-            fail("Expected NumberFormatException with empty string.");
-        } catch (NumberFormatException e) {}
-        
-        try {
-            Long.parseLong(null, 10);
-            fail("Expected NumberFormatException with null string.");
-        } catch (NumberFormatException e) {}
-    }
-    
-    /**
-     * @tests java.lang.Long#decode(String)
-     */
-    public void test_decodeLjava_lang_String() {
-        assertEquals(new Long(0), Long.decode("0"));
-        assertEquals(new Long(1), Long.decode("1"));
-        assertEquals(new Long(-1), Long.decode("-1"));
-        assertEquals(new Long(0xF), Long.decode("0xF"));
-        assertEquals(new Long(0xF), Long.decode("#F"));
-        assertEquals(new Long(0xF), Long.decode("0XF"));
-        assertEquals(new Long(07), Long.decode("07"));
-        
-        try {
-            Long.decode("9.2");
-            fail("Expected NumberFormatException with floating point string.");
-        } catch (NumberFormatException e) {}
-
-        try {
-            Long.decode("");
-            fail("Expected NumberFormatException with empty string.");
-        } catch (NumberFormatException e) {}
-        
-        try {
-            Long.decode(null);
-            //undocumented NPE, but seems consistent across JREs
-            fail("Expected NullPointerException with null string.");
-        } catch (NullPointerException e) {}
-    }
-    
-    /**
-     * @tests java.lang.Long#doubleValue()
-     */
-    public void test_doubleValue() {
-        assertEquals(-1D, new Long(-1).doubleValue(), 0D);
-        assertEquals(0D, new Long(0).doubleValue(), 0D);
-        assertEquals(1D, new Long(1).doubleValue(), 0D);
-    }
-    
-    /**
-     * @tests java.lang.Long#floatValue()
-     */
-    public void test_floatValue() {
-        assertEquals(-1F, new Long(-1).floatValue(), 0F);
-        assertEquals(0F, new Long(0).floatValue(), 0F);
-        assertEquals(1F, new Long(1).floatValue(), 0F);
-    }
-    
-    /**
-     * @tests java.lang.Long#intValue()
-     */
-    public void test_intValue() {
-        assertEquals(-1, new Long(-1).intValue());
-        assertEquals(0, new Long(0).intValue());
-        assertEquals(1, new Long(1).intValue());
-    }
-    
-    /**
-     * @tests java.lang.Long#longValue()
-     */
-    public void test_longValue() {
-        assertEquals(-1L, new Long(-1).longValue());
-        assertEquals(0L, new Long(0).longValue());
-        assertEquals(1L, new Long(1).longValue());
-    }
-    
-    /**
-     * @tests java.lang.Long#shortValue()
-     */
-    public void test_shortValue() {
-        assertEquals(-1, new Long(-1).shortValue());
-        assertEquals(0, new Long(0).shortValue());
-        assertEquals(1, new Long(1).shortValue());
-    }
-    /**
-     * @tests java.lang.Long#highestOneBit(long)
-     */
-    public void test_highestOneBitJ() {
-        assertEquals(0x08, Long.highestOneBit(0x0A));
-        assertEquals(0x08, Long.highestOneBit(0x0B));
-        assertEquals(0x08, Long.highestOneBit(0x0C));
-        assertEquals(0x08, Long.highestOneBit(0x0F));
-        assertEquals(0x80, Long.highestOneBit(0xFF));
-        
-        assertEquals(0x080000, Long.highestOneBit(0x0F1234));
-        assertEquals(0x800000, Long.highestOneBit(0xFF9977));
-        
-        assertEquals(0x8000000000000000L, Long.highestOneBit(0xFFFFFFFFFFFFFFFFL));
-        
-        assertEquals(0, Long.highestOneBit(0));
-        assertEquals(1, Long.highestOneBit(1));
-        assertEquals(0x8000000000000000L, Long.highestOneBit(-1));
-    }
-    
-    /**
-     * @tests java.lang.Long#lowestOneBit(long)
-     */
-    public void test_lowestOneBitJ() {
-        assertEquals(0x10, Long.lowestOneBit(0xF0));
-        
-        assertEquals(0x10, Long.lowestOneBit(0x90));
-        assertEquals(0x10, Long.lowestOneBit(0xD0));
-        
-        assertEquals(0x10, Long.lowestOneBit(0x123490));
-        assertEquals(0x10, Long.lowestOneBit(0x1234D0));
-        
-        assertEquals(0x100000, Long.lowestOneBit(0x900000));
-        assertEquals(0x100000, Long.lowestOneBit(0xD00000));
-        
-        assertEquals(0x40, Long.lowestOneBit(0x40));
-        assertEquals(0x40, Long.lowestOneBit(0xC0));
-        
-        assertEquals(0x4000, Long.lowestOneBit(0x4000));
-        assertEquals(0x4000, Long.lowestOneBit(0xC000));
-        
-        assertEquals(0x4000, Long.lowestOneBit(0x99994000));
-        assertEquals(0x4000, Long.lowestOneBit(0x9999C000));
-        
-        assertEquals(0, Long.lowestOneBit(0));
-        assertEquals(1, Long.lowestOneBit(1));
-        assertEquals(1, Long.lowestOneBit(-1));
-    }
-    /**
-     * @tests java.lang.Long#numberOfLeadingZeros(long)
-     */
-    public void test_numberOfLeadingZerosJ() {
-        assertEquals(64, Long.numberOfLeadingZeros(0x0L));
-        assertEquals(63, Long.numberOfLeadingZeros(0x1));
-        assertEquals(62, Long.numberOfLeadingZeros(0x2));
-        assertEquals(62, Long.numberOfLeadingZeros(0x3));
-        assertEquals(61, Long.numberOfLeadingZeros(0x4));
-        assertEquals(61, Long.numberOfLeadingZeros(0x5));
-        assertEquals(61, Long.numberOfLeadingZeros(0x6));
-        assertEquals(61, Long.numberOfLeadingZeros(0x7));
-        assertEquals(60, Long.numberOfLeadingZeros(0x8));
-        assertEquals(60, Long.numberOfLeadingZeros(0x9));
-        assertEquals(60, Long.numberOfLeadingZeros(0xA));
-        assertEquals(60, Long.numberOfLeadingZeros(0xB));
-        assertEquals(60, Long.numberOfLeadingZeros(0xC));
-        assertEquals(60, Long.numberOfLeadingZeros(0xD));
-        assertEquals(60, Long.numberOfLeadingZeros(0xE));
-        assertEquals(60, Long.numberOfLeadingZeros(0xF));
-        assertEquals(59, Long.numberOfLeadingZeros(0x10));
-        assertEquals(56, Long.numberOfLeadingZeros(0x80));
-        assertEquals(56, Long.numberOfLeadingZeros(0xF0));
-        assertEquals(55, Long.numberOfLeadingZeros(0x100));
-        assertEquals(52, Long.numberOfLeadingZeros(0x800));
-        assertEquals(52, Long.numberOfLeadingZeros(0xF00));
-        assertEquals(51, Long.numberOfLeadingZeros(0x1000));
-        assertEquals(48, Long.numberOfLeadingZeros(0x8000));
-        assertEquals(48, Long.numberOfLeadingZeros(0xF000));
-        assertEquals(47, Long.numberOfLeadingZeros(0x10000));
-        assertEquals(44, Long.numberOfLeadingZeros(0x80000));
-        assertEquals(44, Long.numberOfLeadingZeros(0xF0000));
-        assertEquals(43, Long.numberOfLeadingZeros(0x100000));
-        assertEquals(40, Long.numberOfLeadingZeros(0x800000));
-        assertEquals(40, Long.numberOfLeadingZeros(0xF00000));
-        assertEquals(39, Long.numberOfLeadingZeros(0x1000000));
-        assertEquals(36, Long.numberOfLeadingZeros(0x8000000));
-        assertEquals(36, Long.numberOfLeadingZeros(0xF000000));
-        assertEquals(35, Long.numberOfLeadingZeros(0x10000000));
-        assertEquals(0, Long.numberOfLeadingZeros(0x80000000));
-        assertEquals(0, Long.numberOfLeadingZeros(0xF0000000));
-        
-        assertEquals(1, Long.numberOfLeadingZeros(Long.MAX_VALUE));
-        assertEquals(0, Long.numberOfLeadingZeros(Long.MIN_VALUE));
-    }
-    
-    /**
-     * @tests java.lang.Long#numberOfTrailingZeros(long)
-     */
-    public void test_numberOfTrailingZerosJ() {
-        assertEquals(64, Long.numberOfTrailingZeros(0x0));
-        assertEquals(63, Long.numberOfTrailingZeros(Long.MIN_VALUE));
-        assertEquals(0, Long.numberOfTrailingZeros(Long.MAX_VALUE));
-        
-        assertEquals(0, Long.numberOfTrailingZeros(0x1));
-        assertEquals(3, Long.numberOfTrailingZeros(0x8));
-        assertEquals(0, Long.numberOfTrailingZeros(0xF));
-        
-        assertEquals(4, Long.numberOfTrailingZeros(0x10));
-        assertEquals(7, Long.numberOfTrailingZeros(0x80));
-        assertEquals(4, Long.numberOfTrailingZeros(0xF0));
-        
-        assertEquals(8, Long.numberOfTrailingZeros(0x100));
-        assertEquals(11, Long.numberOfTrailingZeros(0x800));
-        assertEquals(8, Long.numberOfTrailingZeros(0xF00));
-        
-        assertEquals(12, Long.numberOfTrailingZeros(0x1000));
-        assertEquals(15, Long.numberOfTrailingZeros(0x8000));
-        assertEquals(12, Long.numberOfTrailingZeros(0xF000));
-        
-        assertEquals(16, Long.numberOfTrailingZeros(0x10000));
-        assertEquals(19, Long.numberOfTrailingZeros(0x80000));
-        assertEquals(16, Long.numberOfTrailingZeros(0xF0000));
-        
-        assertEquals(20, Long.numberOfTrailingZeros(0x100000));
-        assertEquals(23, Long.numberOfTrailingZeros(0x800000));
-        assertEquals(20, Long.numberOfTrailingZeros(0xF00000));
-        
-        assertEquals(24, Long.numberOfTrailingZeros(0x1000000));
-        assertEquals(27, Long.numberOfTrailingZeros(0x8000000));
-        assertEquals(24, Long.numberOfTrailingZeros(0xF000000));
-        
-        assertEquals(28, Long.numberOfTrailingZeros(0x10000000));
-        assertEquals(31, Long.numberOfTrailingZeros(0x80000000));
-        assertEquals(28, Long.numberOfTrailingZeros(0xF0000000));
-    }
-    
-    /**
-     * @tests java.lang.Long#bitCount(long)
-     */
-    public void test_bitCountJ() {
-        assertEquals(0, Long.bitCount(0x0));
-        assertEquals(1, Long.bitCount(0x1));
-        assertEquals(1, Long.bitCount(0x2));
-        assertEquals(2, Long.bitCount(0x3));
-        assertEquals(1, Long.bitCount(0x4));
-        assertEquals(2, Long.bitCount(0x5));
-        assertEquals(2, Long.bitCount(0x6));
-        assertEquals(3, Long.bitCount(0x7));
-        assertEquals(1, Long.bitCount(0x8));
-        assertEquals(2, Long.bitCount(0x9));
-        assertEquals(2, Long.bitCount(0xA));
-        assertEquals(3, Long.bitCount(0xB));
-        assertEquals(2, Long.bitCount(0xC));
-        assertEquals(3, Long.bitCount(0xD));
-        assertEquals(3, Long.bitCount(0xE));
-        assertEquals(4, Long.bitCount(0xF));
-        
-        assertEquals(8, Long.bitCount(0xFF));
-        assertEquals(12, Long.bitCount(0xFFF));
-        assertEquals(16, Long.bitCount(0xFFFF));
-        assertEquals(20, Long.bitCount(0xFFFFF));
-        assertEquals(24, Long.bitCount(0xFFFFFF));
-        assertEquals(28, Long.bitCount(0xFFFFFFF));
-        assertEquals(64, Long.bitCount(0xFFFFFFFFFFFFFFFFL));
-    }
-    
-    /**
-     * @tests java.lang.Long#rotateLeft(long,long)
-     */
-    public void test_rotateLeftJI() {
-        assertEquals(0xF, Long.rotateLeft(0xF, 0));
-        assertEquals(0xF0, Long.rotateLeft(0xF, 4));
-        assertEquals(0xF00, Long.rotateLeft(0xF, 8));
-        assertEquals(0xF000, Long.rotateLeft(0xF, 12));
-        assertEquals(0xF0000, Long.rotateLeft(0xF, 16));
-        assertEquals(0xF00000, Long.rotateLeft(0xF, 20));
-        assertEquals(0xF000000, Long.rotateLeft(0xF, 24));
-        assertEquals(0xF0000000L, Long.rotateLeft(0xF, 28));
-        assertEquals(0xF000000000000000L, Long.rotateLeft(0xF000000000000000L, 64));
-    }
-    
-    /**
-     * @tests java.lang.Long#rotateRight(long,long)
-     */
-    public void test_rotateRightJI() {
-        assertEquals(0xF, Long.rotateRight(0xF0, 4));
-        assertEquals(0xF, Long.rotateRight(0xF00, 8));
-        assertEquals(0xF, Long.rotateRight(0xF000, 12));
-        assertEquals(0xF, Long.rotateRight(0xF0000, 16));
-        assertEquals(0xF, Long.rotateRight(0xF00000, 20));
-        assertEquals(0xF, Long.rotateRight(0xF000000, 24));
-        assertEquals(0xF, Long.rotateRight(0xF0000000L, 28));
-        assertEquals(0xF000000000000000L, Long.rotateRight(0xF000000000000000L, 64));
-        assertEquals(0xF000000000000000L, Long.rotateRight(0xF000000000000000L, 0));
-        
-    }
-    
-    /**
-     * @tests java.lang.Long#reverseBytes(long)
-     */
-    public void test_reverseBytesJ() {
-        assertEquals(0xAABBCCDD00112233L, Long.reverseBytes(0x33221100DDCCBBAAL));
-        assertEquals(0x1122334455667788L, Long.reverseBytes(0x8877665544332211L));
-        assertEquals(0x0011223344556677L, Long.reverseBytes(0x7766554433221100L));
-        assertEquals(0x2000000000000002L, Long.reverseBytes(0x0200000000000020L));
-    }
-    
-    /**
-     * @tests java.lang.Long#reverse(long)
-     */
-    public void test_reverseJ() {
-        assertEquals(0, Long.reverse(0));
-        assertEquals(-1, Long.reverse(-1));
-        assertEquals(0x8000000000000000L,Long.reverse(1));
-    }
-    
-    /**
-     * @tests java.lang.Long#signum(long)
-     */
-    public void test_signumJ() {
-        for (int i = -128; i<0; i++) {
-            assertEquals(-1, Long.signum((long)i));
-        }
-        assertEquals(0, Long.signum((long)0));
-        for (int i = 1; i<=127; i++) {
-            assertEquals(1, Long.signum((long)i));
-        }
-    }
+/* Copyright 2006 The Apache Software Foundation or its licensors, as applicable
+ * 
+ * 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 org.apache.harmony.luni.tests.java.lang;
+
+import java.util.Properties;
+
+import junit.framework.TestCase;
+
+public class LongTest extends TestCase {
+    private Properties orgProps;
+    
+    protected void setUp() {
+        orgProps = System.getProperties();
+    }
+
+    protected void tearDown() {
+        System.setProperties(orgProps);
+    }
+
+    /**
+     * @tests java.lang.Long#byteValue()
+     */
+    public void test_byteValue() {
+        // Test for method byte java.lang.Long.byteValue()
+        Long l = new Long(127);
+        assertEquals("Returned incorrect byte value", 127, l.byteValue());
+        assertEquals("Returned incorrect byte value", -1, new Long(Long.MAX_VALUE)
+                .byteValue());
+    }
+
+    /**
+     * @tests java.lang.Long#compareTo(java.lang.Long)
+     */
+    public void test_compareToLjava_lang_Long() {
+        // Test for method int java.lang.Long.compareTo(java.lang.Long)
+        assertTrue("-2 compared to 1 gave non-negative answer", new Long(-2L)
+                .compareTo(new Long(1L)) < 0);
+        assertEquals("-2 compared to -2 gave non-zero answer", 0, new Long(-2L)
+                .compareTo(new Long(-2L)));
+        assertTrue("3 compared to 2 gave non-positive answer", new Long(3L)
+                .compareTo(new Long(2L)) > 0);
+        
+        try {
+            new Long(0).compareTo(null);
+            fail("No NPE");
+        } catch (NullPointerException e) {
+        }
+    }
+
+    /**
+     * @tests java.lang.Long#decode(java.lang.String)
+     */
+    public void test_decodeLjava_lang_String2() {
+        // Test for method java.lang.Long
+        // java.lang.Long.decode(java.lang.String)
+        assertEquals("Returned incorrect value for hex string", 255L, Long.decode(
+                "0xFF").longValue());
+        assertEquals("Returned incorrect value for dec string", -89000L, Long.decode(
+                "-89000").longValue());
+        assertEquals("Returned incorrect value for 0 decimal", 0, Long.decode("0")
+                .longValue());
+        assertEquals("Returned incorrect value for 0 hex", 0, Long.decode("0x0")
+                .longValue());
+        assertTrue(
+                "Returned incorrect value for most negative value decimal",
+                Long.decode("-9223372036854775808").longValue() == 0x8000000000000000L);
+        assertTrue(
+                "Returned incorrect value for most negative value hex",
+                Long.decode("-0x8000000000000000").longValue() == 0x8000000000000000L);
+        assertTrue(
+                "Returned incorrect value for most positive value decimal",
+                Long.decode("9223372036854775807").longValue() == 0x7fffffffffffffffL);
+        assertTrue(
+                "Returned incorrect value for most positive value hex",
+                Long.decode("0x7fffffffffffffff").longValue() == 0x7fffffffffffffffL);
+        assertTrue("Failed for 07654321765432", Long.decode("07654321765432")
+                .longValue() == 07654321765432l);
+
+        boolean exception = false;
+        try {
+            Long
+                    .decode("999999999999999999999999999999999999999999999999999999");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for value > ilong", exception);
+
+        exception = false;
+        try {
+            Long.decode("9223372036854775808");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
+
+        exception = false;
+        try {
+            Long.decode("-9223372036854775809");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
+
+        exception = false;
+        try {
+            Long.decode("0x8000000000000000");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception);
+
+        exception = false;
+        try {
+            Long.decode("-0x8000000000000001");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception);
+
+        exception = false;
+        try {
+            Long.decode("42325917317067571199");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for 42325917317067571199",
+                exception);
+    }
+
+     /**
+     * @tests java.lang.Long#getLong(java.lang.String)
+     */
+    public void test_getLongLjava_lang_String() {
+        // Test for method java.lang.Long
+        // java.lang.Long.getLong(java.lang.String)
+        Properties tProps = new Properties();
+        tProps.put("testLong", "99");
+        System.setProperties(tProps);
+        assertTrue("returned incorrect Long", Long.getLong("testLong").equals(
+                new Long(99)));
+        assertNull("returned incorrect default Long",
+                Long.getLong("ff"));
+    }
+
+    /**
+     * @tests java.lang.Long#getLong(java.lang.String, long)
+     */
+    public void test_getLongLjava_lang_StringJ() {
+        // Test for method java.lang.Long
+        // java.lang.Long.getLong(java.lang.String, long)
+        Properties tProps = new Properties();
+        tProps.put("testLong", "99");
+        System.setProperties(tProps);
+        assertTrue("returned incorrect Long", Long.getLong("testLong", 4L)
+                .equals(new Long(99)));
+        assertTrue("returned incorrect default Long", Long.getLong("ff", 4L)
+                .equals(new Long(4)));
+    }
+
+    /**
+     * @tests java.lang.Long#getLong(java.lang.String, java.lang.Long)
+     */
+    public void test_getLongLjava_lang_StringLjava_lang_Long() {
+        // Test for method java.lang.Long
+        // java.lang.Long.getLong(java.lang.String, java.lang.Long)
+        Properties tProps = new Properties();
+        tProps.put("testLong", "99");
+        System.setProperties(tProps);
+        assertTrue("returned incorrect Long", Long.getLong("testLong",
+                new Long(4)).equals(new Long(99)));
+        assertTrue("returned incorrect default Long", Long.getLong("ff",
+                new Long(4)).equals(new Long(4)));
+    }
+
+    /**
+     * @tests java.lang.Long#parseLong(java.lang.String)
+     */
+    public void test_parseLongLjava_lang_String2() {
+        // Test for method long java.lang.Long.parseLong(java.lang.String)
+
+        long l = Long.parseLong("89000000005");
+        assertEquals("Parsed to incorrect long value", 89000000005L, l);
+        assertEquals("Returned incorrect value for 0", 0, Long.parseLong("0"));
+        assertTrue("Returned incorrect value for most negative value", Long
+                .parseLong("-9223372036854775808") == 0x8000000000000000L);
+        assertTrue("Returned incorrect value for most positive value", Long
+                .parseLong("9223372036854775807") == 0x7fffffffffffffffL);
+
+        boolean exception = false;
+        try {
+            Long.parseLong("9223372036854775808");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
+
+        exception = false;
+        try {
+            Long.parseLong("-9223372036854775809");
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
+    }
+
+    /**
+     * @tests java.lang.Long#parseLong(java.lang.String, int)
+     */
+    public void test_parseLongLjava_lang_StringI() {
+        // Test for method long java.lang.Long.parseLong(java.lang.String, int)
+        assertEquals("Returned incorrect value",
+                100000000L, Long.parseLong("100000000", 10));
+        assertEquals("Returned incorrect value from hex string", 68719476735L, Long.parseLong(
+                "FFFFFFFFF", 16));
+        assertTrue("Returned incorrect value from octal string: "
+                + Long.parseLong("77777777777"), Long.parseLong("77777777777",
+                8) == 8589934591L);
+        assertEquals("Returned incorrect value for 0 hex", 0, Long
+                .parseLong("0", 16));
+        assertTrue("Returned incorrect value for most negative value hex", Long
+                .parseLong("-8000000000000000", 16) == 0x8000000000000000L);
+        assertTrue("Returned incorrect value for most positive value hex", Long
+                .parseLong("7fffffffffffffff", 16) == 0x7fffffffffffffffL);
+        assertEquals("Returned incorrect value for 0 decimal", 0, Long.parseLong(
+                "0", 10));
+        assertTrue(
+                "Returned incorrect value for most negative value decimal",
+                Long.parseLong("-9223372036854775808", 10) == 0x8000000000000000L);
+        assertTrue(
+                "Returned incorrect value for most positive value decimal",
+                Long.parseLong("9223372036854775807", 10) == 0x7fffffffffffffffL);
+
+        boolean exception = false;
+        try {
+            Long.parseLong("999999999999", 8);
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+
+        exception = false;
+        try {
+            Long.parseLong("9223372036854775808", 10);
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
+
+        exception = false;
+        try {
+            Long.parseLong("-9223372036854775809", 10);
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
+
+        exception = false;
+        try {
+            Long.parseLong("8000000000000000", 16);
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception);
+
+        exception = false;
+        try {
+            Long.parseLong("-8000000000000001", 16);
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for hex MIN_VALUE + 1", exception);
+
+        exception = false;
+        try {
+            Long.parseLong("42325917317067571199", 10);
+        } catch (NumberFormatException e) {
+            // Correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception for 42325917317067571199",
+                exception);
+    }
+
+    /**
+     * @tests java.lang.Long#toBinaryString(long)
+     */
+    public void test_toBinaryStringJ() {
+        // Test for method java.lang.String java.lang.Long.toBinaryString(long)
+        assertEquals("Incorrect binary string returned", "11011001010010010000", Long.toBinaryString(
+                890000L));
+        assertEquals("Incorrect binary string returned",
+                
+                                "1000000000000000000000000000000000000000000000000000000000000000", Long
+                        .toBinaryString(Long.MIN_VALUE)
+                        );
+        assertEquals("Incorrect binary string returned",
+                
+                                "111111111111111111111111111111111111111111111111111111111111111", Long
+                        .toBinaryString(Long.MAX_VALUE)
+                        );
+    }
+
+    /**
+     * @tests java.lang.Long#toHexString(long)
+     */
+    public void test_toHexStringJ() {
+        // Test for method java.lang.String java.lang.Long.toHexString(long)
+        assertEquals("Incorrect hex string returned", "54e0845", Long.toHexString(89000005L)
+                );
+        assertEquals("Incorrect hex string returned", "8000000000000000", Long.toHexString(
+                Long.MIN_VALUE));
+        assertEquals("Incorrect hex string returned", "7fffffffffffffff", Long.toHexString(
+                Long.MAX_VALUE));
+    }
+
+    /**
+     * @tests java.lang.Long#toOctalString(long)
+     */
+    public void test_toOctalStringJ() {
+        // Test for method java.lang.String java.lang.Long.toOctalString(long)
+        assertEquals("Returned incorrect oct string", "77777777777", Long.toOctalString(
+                8589934591L));
+        assertEquals("Returned incorrect oct string", "1000000000000000000000", Long.toOctalString(
+                Long.MIN_VALUE));
+        assertEquals("Returned incorrect oct string", "777777777777777777777", Long.toOctalString(
+                Long.MAX_VALUE));
+    }
+
+    /**
+     * @tests java.lang.Long#toString()
+     */
+    public void test_toString2() {
+        // Test for method java.lang.String java.lang.Long.toString()
+        Long l = new Long(89000000005L);
+        assertEquals("Returned incorrect String", 
+                "89000000005", l.toString());
+        assertEquals("Returned incorrect String", "-9223372036854775808", new Long(Long.MIN_VALUE)
+                .toString());
+        assertEquals("Returned incorrect String", "9223372036854775807", new Long(Long.MAX_VALUE)
+                .toString());
+    }
+
+    /**
+     * @tests java.lang.Long#toString(long)
+     */
+    public void test_toStringJ2() {
+        // Test for method java.lang.String java.lang.Long.toString(long)
+
+        assertEquals("Returned incorrect String", "89000000005", Long.toString(89000000005L)
+                );
+        assertEquals("Returned incorrect String", "-9223372036854775808", Long.toString(Long.MIN_VALUE)
+                );
+        assertEquals("Returned incorrect String", "9223372036854775807", Long.toString(Long.MAX_VALUE)
+                );
+    }
+
+    /**
+     * @tests java.lang.Long#toString(long, int)
+     */
+    public void test_toStringJI() {
+        // Test for method java.lang.String java.lang.Long.toString(long, int)
+        assertEquals("Returned incorrect dec string", "100000000", Long.toString(100000000L,
+                10));
+        assertEquals("Returned incorrect hex string", "fffffffff", Long.toString(68719476735L,
+                16));
+        assertEquals("Returned incorrect oct string", "77777777777", Long.toString(8589934591L,
+                8));
+        assertEquals("Returned incorrect bin string", 
+                "1111111111111111111111111111111111111111111", Long.toString(
+                8796093022207L, 2));
+        assertEquals("Returned incorrect min string", "-9223372036854775808", Long.toString(
+                0x8000000000000000L, 10));
+        assertEquals("Returned incorrect max string", "9223372036854775807", Long.toString(
+                0x7fffffffffffffffL, 10));
+        assertEquals("Returned incorrect min string", "-8000000000000000", Long.toString(
+                0x8000000000000000L, 16));
+        assertEquals("Returned incorrect max string", "7fffffffffffffff", Long.toString(
+                0x7fffffffffffffffL, 16));
+    }
+
+    /**
+     * @tests java.lang.Long#valueOf(java.lang.String)
+     */
+    public void test_valueOfLjava_lang_String2() {
+        // Test for method java.lang.Long
+        // java.lang.Long.valueOf(java.lang.String)
+        assertEquals("Returned incorrect value", 100000000L, Long.valueOf("100000000")
+                .longValue());
+        assertTrue("Returned incorrect value", Long.valueOf(
+                "9223372036854775807").longValue() == Long.MAX_VALUE);
+        assertTrue("Returned incorrect value", Long.valueOf(
+                "-9223372036854775808").longValue() == Long.MIN_VALUE);
+
+        boolean exception = false;
+        try {
+            Long
+                    .valueOf("999999999999999999999999999999999999999999999999999999999999");
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+
+        exception = false;
+        try {
+            Long.valueOf("9223372036854775808");
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+
+        exception = false;
+        try {
+            Long.valueOf("-9223372036854775809");
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+    }
+
+    /**
+     * @tests java.lang.Long#valueOf(java.lang.String, int)
+     */
+    public void test_valueOfLjava_lang_StringI() {
+        // Test for method java.lang.Long
+        // java.lang.Long.valueOf(java.lang.String, int)
+        assertEquals("Returned incorrect value", 100000000L, Long.valueOf("100000000", 10)
+                .longValue());
+        assertEquals("Returned incorrect value from hex string", 68719476735L, Long.valueOf(
+                "FFFFFFFFF", 16).longValue());
+        assertTrue("Returned incorrect value from octal string: "
+                + Long.valueOf("77777777777", 8).toString(), Long.valueOf(
+                "77777777777", 8).longValue() == 8589934591L);
+        assertTrue("Returned incorrect value", Long.valueOf(
+                "9223372036854775807", 10).longValue() == Long.MAX_VALUE);
+        assertTrue("Returned incorrect value", Long.valueOf(
+                "-9223372036854775808", 10).longValue() == Long.MIN_VALUE);
+        assertTrue("Returned incorrect value", Long.valueOf("7fffffffffffffff",
+                16).longValue() == Long.MAX_VALUE);
+        assertTrue("Returned incorrect value", Long.valueOf(
+                "-8000000000000000", 16).longValue() == Long.MIN_VALUE);
+
+        boolean exception = false;
+        try {
+            Long.valueOf("999999999999", 8);
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+
+        exception = false;
+        try {
+            Long.valueOf("9223372036854775808", 10);
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+
+        exception = false;
+        try {
+            Long.valueOf("-9223372036854775809", 10);
+        } catch (NumberFormatException e) {
+            // correct
+            exception = true;
+        }
+        assertTrue("Failed to throw exception when passed invalid string",
+                exception);
+    }
+    /**
+     * @tests java.lang.Long#valueOf(long)
+     */
+    public void test_valueOfJ() {
+        assertEquals(new Long(Long.MIN_VALUE), Long.valueOf(Long.MIN_VALUE));
+        assertEquals(new Long(Long.MAX_VALUE), Long.valueOf(Long.MAX_VALUE));
+        assertEquals(new Long( 0), Long.valueOf( 0));
+
+        long lng = -128;
+        while (lng < 128) {
+            assertEquals(new Long(lng), Long.valueOf(lng));
+            assertSame(Long.valueOf(lng), Long.valueOf(lng));
+            lng++;
+        }
+    }
+    
+    /**
+     * @tests java.lang.Long#hashCode()
+     */
+    public void test_hashCode() {
+        assertEquals((int)(1L ^ (1L >>> 32)), new Long(1).hashCode());
+        assertEquals((int)(2L ^ (2L >>> 32)), new Long(2).hashCode());
+        assertEquals((int)(0L ^ (0L >>> 32)), new Long(0).hashCode());
+        assertEquals((int)(-1L ^ (-1L >>> 32)), new Long(-1).hashCode());
+    }
+
+    /**
+     * @tests java.lang.Long#Long(String)
+     */
+    public void test_ConstructorLjava_lang_String() {
+        assertEquals(new Long(0), new Long("0"));
+        assertEquals(new Long(1), new Long("1"));
+        assertEquals(new Long(-1), new Long("-1"));
+        
+        try {
+            new Long("0x1");
+            fail("Expected NumberFormatException with hex string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            new Long("9.2");
+            fail("Expected NumberFormatException with floating point string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            new Long("");
+            fail("Expected NumberFormatException with empty string.");
+        } catch (NumberFormatException e) {}
+        
+        try {
+            new Long(null);
+            fail("Expected NumberFormatException with null string.");
+        } catch (NumberFormatException e) {}
+    }
+
+    /**
+     * @tests java.lang.Long#Long
+     */
+    public void test_ConstructorJ() {
+        assertEquals(1, new Long(1).intValue());
+        assertEquals(2, new Long(2).intValue());
+        assertEquals(0, new Long(0).intValue());
+        assertEquals(-1, new Long(-1).intValue());
+    }
+
+    /**
+     * @tests java.lang.Long#byteValue()
+     */
+    public void test_booleanValue() {
+        assertEquals(1, new Long(1).byteValue());    
+        assertEquals(2, new Long(2).byteValue());
+        assertEquals(0, new Long(0).byteValue());
+        assertEquals(-1, new Long(-1).byteValue());
+    }
+
+    /**
+     * @tests java.lang.Long#equals(Object)
+     */
+    public void test_equalsLjava_lang_Object() {
+        assertEquals(new Long(0), Long.valueOf(0));
+        assertEquals(new Long(1), Long.valueOf(1));
+        assertEquals(new Long(-1), Long.valueOf(-1));
+        
+        Long fixture = new Long(25);
+        assertEquals(fixture, fixture);
+        assertFalse(fixture.equals(null));
+        assertFalse(fixture.equals("Not a Long"));
+    }
+
+    /**
+     * @tests java.lang.Long#toString()
+     */
+    public void test_toString() {
+        assertEquals("-1", new Long(-1).toString());
+        assertEquals("0", new Long(0).toString());
+        assertEquals("1", new Long(1).toString());
+        assertEquals("-1", new Long(0xFFFFFFFF).toString());
+    }
+
+    /**
+     * @tests java.lang.Long#toString
+     */
+    public void test_toStringJ() {
+        assertEquals("-1", Long.toString(-1));
+        assertEquals("0", Long.toString(0));
+        assertEquals("1", Long.toString(1));
+        assertEquals("-1", Long.toString(0xFFFFFFFF));
+    }
+
+    /**
+     * @tests java.lang.Long#valueOf(String)
+     */
+    public void test_valueOfLjava_lang_String() {
+        assertEquals(new Long(0), Long.valueOf("0"));
+        assertEquals(new Long(1), Long.valueOf("1"));
+        assertEquals(new Long(-1), Long.valueOf("-1"));
+        
+        try {
+            Long.valueOf("0x1");
+            fail("Expected NumberFormatException with hex string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.valueOf("9.2");
+            fail("Expected NumberFormatException with floating point string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.valueOf("");
+            fail("Expected NumberFormatException with empty string.");
+        } catch (NumberFormatException e) {}
+        
+        try {
+            Long.valueOf(null);
+            fail("Expected NumberFormatException with null string.");
+        } catch (NumberFormatException e) {}
+    }
+    
+    /**
+     * @tests java.lang.Long#valueOf(String,long)
+     */
+    public void test_valueOfLjava_lang_StringJ() {
+        assertEquals(new Long(0), Long.valueOf("0", 10));
+        assertEquals(new Long(1), Long.valueOf("1", 10));
+        assertEquals(new Long(-1), Long.valueOf("-1", 10));
+        
+        //must be consistent with Character.digit()
+        assertEquals(Character.digit('1', 2), Long.valueOf("1", 2).byteValue());
+        assertEquals(Character.digit('F', 16), Long.valueOf("F", 16).byteValue());
+        
+        try {
+            Long.valueOf("0x1", 10);
+            fail("Expected NumberFormatException with hex string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.valueOf("9.2", 10);
+            fail("Expected NumberFormatException with floating point string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.valueOf("", 10);
+            fail("Expected NumberFormatException with empty string.");
+        } catch (NumberFormatException e) {}
+        
+        try {
+            Long.valueOf(null, 10);
+            fail("Expected NumberFormatException with null string.");
+        } catch (NumberFormatException e) {}
+    }
+    
+    /**
+     * @tests java.lang.Long#parseLong(String)
+     */
+    public void test_parseLongLjava_lang_String() {
+        assertEquals(0, Long.parseLong("0"));
+        assertEquals(1, Long.parseLong("1"));
+        assertEquals(-1, Long.parseLong("-1"));
+        
+        try {
+            Long.parseLong("0x1");
+            fail("Expected NumberFormatException with hex string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.parseLong("9.2");
+            fail("Expected NumberFormatException with floating point string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.parseLong("");
+            fail("Expected NumberFormatException with empty string.");
+        } catch (NumberFormatException e) {}
+        
+        try {
+            Long.parseLong(null);
+            fail("Expected NumberFormatException with null string.");
+        } catch (NumberFormatException e) {}
+    }
+    
+    /**
+     * @tests java.lang.Long#parseLong(String,long)
+     */
+    public void test_parseLongLjava_lang_StringJ() {
+        assertEquals(0, Long.parseLong("0", 10));
+        assertEquals(1, Long.parseLong("1", 10));
+        assertEquals(-1, Long.parseLong("-1", 10));
+        
+        //must be consistent with Character.digit()
+        assertEquals(Character.digit('1', 2), Long.parseLong("1", 2));
+        assertEquals(Character.digit('F', 16), Long.parseLong("F", 16));
+        
+        try {
+            Long.parseLong("0x1", 10);
+            fail("Expected NumberFormatException with hex string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.parseLong("9.2", 10);
+            fail("Expected NumberFormatException with floating point string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.parseLong("", 10);
+            fail("Expected NumberFormatException with empty string.");
+        } catch (NumberFormatException e) {}
+        
+        try {
+            Long.parseLong(null, 10);
+            fail("Expected NumberFormatException with null string.");
+        } catch (NumberFormatException e) {}
+    }
+    
+    /**
+     * @tests java.lang.Long#decode(String)
+     */
+    public void test_decodeLjava_lang_String() {
+        assertEquals(new Long(0), Long.decode("0"));
+        assertEquals(new Long(1), Long.decode("1"));
+        assertEquals(new Long(-1), Long.decode("-1"));
+        assertEquals(new Long(0xF), Long.decode("0xF"));
+        assertEquals(new Long(0xF), Long.decode("#F"));
+        assertEquals(new Long(0xF), Long.decode("0XF"));
+        assertEquals(new Long(07), Long.decode("07"));
+        
+        try {
+            Long.decode("9.2");
+            fail("Expected NumberFormatException with floating point string.");
+        } catch (NumberFormatException e) {}
+
+        try {
+            Long.decode("");
+            fail("Expected NumberFormatException with empty string.");
+        } catch (NumberFormatException e) {}
+        
+        try {
+            Long.decode(null);
+            //undocumented NPE, but seems consistent across JREs
+            fail("Expected NullPointerException with null string.");
+        } catch (NullPointerException e) {}
+    }
+    
+    /**
+     * @tests java.lang.Long#doubleValue()
+     */
+    public void test_doubleValue() {
+        assertEquals(-1D, new Long(-1).doubleValue(), 0D);
+        assertEquals(0D, new Long(0).doubleValue(), 0D);
+        assertEquals(1D, new Long(1).doubleValue(), 0D);
+    }
+    
+    /**
+     * @tests java.lang.Long#floatValue()
+     */
+    public void test_floatValue() {
+        assertEquals(-1F, new Long(-1).floatValue(), 0F);
+        assertEquals(0F, new Long(0).floatValue(), 0F);
+        assertEquals(1F, new Long(1).floatValue(), 0F);
+    }
+    
+    /**
+     * @tests java.lang.Long#intValue()
+     */
+    public void test_intValue() {
+        assertEquals(-1, new Long(-1).intValue());
+        assertEquals(0, new Long(0).intValue());
+        assertEquals(1, new Long(1).intValue());
+    }
+    
+    /**
+     * @tests java.lang.Long#longValue()
+     */
+    public void test_longValue() {
+        assertEquals(-1L, new Long(-1).longValue());
+        assertEquals(0L, new Long(0).longValue());
+        assertEquals(1L, new Long(1).longValue());
+    }
+    
+    /**
+     * @tests java.lang.Long#shortValue()
+     */
+    public void test_shortValue() {
+        assertEquals(-1, new Long(-1).shortValue());
+        assertEquals(0, new Long(0).shortValue());
+        assertEquals(1, new Long(1).shortValue());
+    }
+    /**
+     * @tests java.lang.Long#highestOneBit(long)
+     */
+    public void test_highestOneBitJ() {
+        assertEquals(0x08, Long.highestOneBit(0x0A));
+        assertEquals(0x08, Long.highestOneBit(0x0B));
+        assertEquals(0x08, Long.highestOneBit(0x0C));
+        assertEquals(0x08, Long.highestOneBit(0x0F));
+        assertEquals(0x80, Long.highestOneBit(0xFF));
+        
+        assertEquals(0x080000, Long.highestOneBit(0x0F1234));
+        assertEquals(0x800000, Long.highestOneBit(0xFF9977));
+        
+        assertEquals(0x8000000000000000L, Long.highestOneBit(0xFFFFFFFFFFFFFFFFL));
+        
+        assertEquals(0, Long.highestOneBit(0));
+        assertEquals(1, Long.highestOneBit(1));
+        assertEquals(0x8000000000000000L, Long.highestOneBit(-1));
+    }
+    
+    /**
+     * @tests java.lang.Long#lowestOneBit(long)
+     */
+    public void test_lowestOneBitJ() {
+        assertEquals(0x10, Long.lowestOneBit(0xF0));
+        
+        assertEquals(0x10, Long.lowestOneBit(0x90));
+        assertEquals(0x10, Long.lowestOneBit(0xD0));
+        
+        assertEquals(0x10, Long.lowestOneBit(0x123490));
+        assertEquals(0x10, Long.lowestOneBit(0x1234D0));
+        
+        assertEquals(0x100000, Long.lowestOneBit(0x900000));
+        assertEquals(0x100000, Long.lowestOneBit(0xD00000));
+        
+        assertEquals(0x40, Long.lowestOneBit(0x40));
+        assertEquals(0x40, Long.lowestOneBit(0xC0));
+        
+        assertEquals(0x4000, Long.lowestOneBit(0x4000));
+        assertEquals(0x4000, Long.lowestOneBit(0xC000));
+        
+        assertEquals(0x4000, Long.lowestOneBit(0x99994000));
+        assertEquals(0x4000, Long.lowestOneBit(0x9999C000));
+        
+        assertEquals(0, Long.lowestOneBit(0));
+        assertEquals(1, Long.lowestOneBit(1));
+        assertEquals(1, Long.lowestOneBit(-1));
+    }
+    /**
+     * @tests java.lang.Long#numberOfLeadingZeros(long)
+     */
+    public void test_numberOfLeadingZerosJ() {
+        assertEquals(64, Long.numberOfLeadingZeros(0x0L));
+        assertEquals(63, Long.numberOfLeadingZeros(0x1));
+        assertEquals(62, Long.numberOfLeadingZeros(0x2));
+        assertEquals(62, Long.numberOfLeadingZeros(0x3));
+        assertEquals(61, Long.numberOfLeadingZeros(0x4));
+        assertEquals(61, Long.numberOfLeadingZeros(0x5));
+        assertEquals(61, Long.numberOfLeadingZeros(0x6));
+        assertEquals(61, Long.numberOfLeadingZeros(0x7));
+        assertEquals(60, Long.numberOfLeadingZeros(0x8));
+        assertEquals(60, Long.numberOfLeadingZeros(0x9));
+        assertEquals(60, Long.numberOfLeadingZeros(0xA));
+        assertEquals(60, Long.numberOfLeadingZeros(0xB));
+        assertEquals(60, Long.numberOfLeadingZeros(0xC));
+        assertEquals(60, Long.numberOfLeadingZeros(0xD));
+        assertEquals(60, Long.numberOfLeadingZeros(0xE));
+        assertEquals(60, Long.numberOfLeadingZeros(0xF));
+        assertEquals(59, Long.numberOfLeadingZeros(0x10));
+        assertEquals(56, Long.numberOfLeadingZeros(0x80));
+        assertEquals(56, Long.numberOfLeadingZeros(0xF0));
+        assertEquals(55, Long.numberOfLeadingZeros(0x100));
+        assertEquals(52, Long.numberOfLeadingZeros(0x800));
+        assertEquals(52, Long.numberOfLeadingZeros(0xF00));
+        assertEquals(51, Long.numberOfLeadingZeros(0x1000));
+        assertEquals(48, Long.numberOfLeadingZeros(0x8000));
+        assertEquals(48, Long.numberOfLeadingZeros(0xF000));
+        assertEquals(47, Long.numberOfLeadingZeros(0x10000));
+        assertEquals(44, Long.numberOfLeadingZeros(0x80000));
+        assertEquals(44, Long.numberOfLeadingZeros(0xF0000));
+        assertEquals(43, Long.numberOfLeadingZeros(0x100000));
+        assertEquals(40, Long.numberOfLeadingZeros(0x800000));
+        assertEquals(40, Long.numberOfLeadingZeros(0xF00000));
+        assertEquals(39, Long.numberOfLeadingZeros(0x1000000));
+        assertEquals(36, Long.numberOfLeadingZeros(0x8000000));
+        assertEquals(36, Long.numberOfLeadingZeros(0xF000000));
+        assertEquals(35, Long.numberOfLeadingZeros(0x10000000));
+        assertEquals(0, Long.numberOfLeadingZeros(0x80000000));
+        assertEquals(0, Long.numberOfLeadingZeros(0xF0000000));
+        
+        assertEquals(1, Long.numberOfLeadingZeros(Long.MAX_VALUE));
+        assertEquals(0, Long.numberOfLeadingZeros(Long.MIN_VALUE));
+    }
+    
+    /**
+     * @tests java.lang.Long#numberOfTrailingZeros(long)
+     */
+    public void test_numberOfTrailingZerosJ() {
+        assertEquals(64, Long.numberOfTrailingZeros(0x0));
+        assertEquals(63, Long.numberOfTrailingZeros(Long.MIN_VALUE));
+        assertEquals(0, Long.numberOfTrailingZeros(Long.MAX_VALUE));
+        
+        assertEquals(0, Long.numberOfTrailingZeros(0x1));
+        assertEquals(3, Long.numberOfTrailingZeros(0x8));
+        assertEquals(0, Long.numberOfTrailingZeros(0xF));
+        
+        assertEquals(4, Long.numberOfTrailingZeros(0x10));
+        assertEquals(7, Long.numberOfTrailingZeros(0x80));
+        assertEquals(4, Long.numberOfTrailingZeros(0xF0));
+        
+        assertEquals(8, Long.numberOfTrailingZeros(0x100));
+        assertEquals(11, Long.numberOfTrailingZeros(0x800));
+        assertEquals(8, Long.numberOfTrailingZeros(0xF00));
+        
+        assertEquals(12, Long.numberOfTrailingZeros(0x1000));
+        assertEquals(15, Long.numberOfTrailingZeros(0x8000));
+        assertEquals(12, Long.numberOfTrailingZeros(0xF000));
+        
+        assertEquals(16, Long.numberOfTrailingZeros(0x10000));
+        assertEquals(19, Long.numberOfTrailingZeros(0x80000));
+        assertEquals(16, Long.numberOfTrailingZeros(0xF0000));
+        
+        assertEquals(20, Long.numberOfTrailingZeros(0x100000));
+        assertEquals(23, Long.numberOfTrailingZeros(0x800000));
+        assertEquals(20, Long.numberOfTrailingZeros(0xF00000));
+        
+        assertEquals(24, Long.numberOfTrailingZeros(0x1000000));
+        assertEquals(27, Long.numberOfTrailingZeros(0x8000000));
+        assertEquals(24, Long.numberOfTrailingZeros(0xF000000));
+        
+        assertEquals(28, Long.numberOfTrailingZeros(0x10000000));
+        assertEquals(31, Long.numberOfTrailingZeros(0x80000000));
+        assertEquals(28, Long.numberOfTrailingZeros(0xF0000000));
+    }
+    
+    /**
+     * @tests java.lang.Long#bitCount(long)
+     */
+    public void test_bitCountJ() {
+        assertEquals(0, Long.bitCount(0x0));
+        assertEquals(1, Long.bitCount(0x1));
+        assertEquals(1, Long.bitCount(0x2));
+        assertEquals(2, Long.bitCount(0x3));
+        assertEquals(1, Long.bitCount(0x4));
+        assertEquals(2, Long.bitCount(0x5));
+        assertEquals(2, Long.bitCount(0x6));
+        assertEquals(3, Long.bitCount(0x7));
+        assertEquals(1, Long.bitCount(0x8));
+        assertEquals(2, Long.bitCount(0x9));
+        assertEquals(2, Long.bitCount(0xA));
+        assertEquals(3, Long.bitCount(0xB));
+        assertEquals(2, Long.bitCount(0xC));
+        assertEquals(3, Long.bitCount(0xD));
+        assertEquals(3, Long.bitCount(0xE));
+        assertEquals(4, Long.bitCount(0xF));
+        
+        assertEquals(8, Long.bitCount(0xFF));
+        assertEquals(12, Long.bitCount(0xFFF));
+        assertEquals(16, Long.bitCount(0xFFFF));
+        assertEquals(20, Long.bitCount(0xFFFFF));
+        assertEquals(24, Long.bitCount(0xFFFFFF));
+        assertEquals(28, Long.bitCount(0xFFFFFFF));
+        assertEquals(64, Long.bitCount(0xFFFFFFFFFFFFFFFFL));
+    }
+    
+    /**
+     * @tests java.lang.Long#rotateLeft(long,long)
+     */
+    public void test_rotateLeftJI() {
+        assertEquals(0xF, Long.rotateLeft(0xF, 0));
+        assertEquals(0xF0, Long.rotateLeft(0xF, 4));
+        assertEquals(0xF00, Long.rotateLeft(0xF, 8));
+        assertEquals(0xF000, Long.rotateLeft(0xF, 12));
+        assertEquals(0xF0000, Long.rotateLeft(0xF, 16));
+        assertEquals(0xF00000, Long.rotateLeft(0xF, 20));
+        assertEquals(0xF000000, Long.rotateLeft(0xF, 24));
+        assertEquals(0xF0000000L, Long.rotateLeft(0xF, 28));
+        assertEquals(0xF000000000000000L, Long.rotateLeft(0xF000000000000000L, 64));
+    }
+    
+    /**
+     * @tests java.lang.Long#rotateRight(long,long)
+     */
+    public void test_rotateRightJI() {
+        assertEquals(0xF, Long.rotateRight(0xF0, 4));
+        assertEquals(0xF, Long.rotateRight(0xF00, 8));
+        assertEquals(0xF, Long.rotateRight(0xF000, 12));
+        assertEquals(0xF, Long.rotateRight(0xF0000, 16));
+        assertEquals(0xF, Long.rotateRight(0xF00000, 20));
+        assertEquals(0xF, Long.rotateRight(0xF000000, 24));
+        assertEquals(0xF, Long.rotateRight(0xF0000000L, 28));
+        assertEquals(0xF000000000000000L, Long.rotateRight(0xF000000000000000L, 64));
+        assertEquals(0xF000000000000000L, Long.rotateRight(0xF000000000000000L, 0));
+        
+    }
+    
+    /**
+     * @tests java.lang.Long#reverseBytes(long)
+     */
+    public void test_reverseBytesJ() {
+        assertEquals(0xAABBCCDD00112233L, Long.reverseBytes(0x33221100DDCCBBAAL));
+        assertEquals(0x1122334455667788L, Long.reverseBytes(0x8877665544332211L));
+        assertEquals(0x0011223344556677L, Long.reverseBytes(0x7766554433221100L));
+        assertEquals(0x2000000000000002L, Long.reverseBytes(0x0200000000000020L));
+    }
+    
+    /**
+     * @tests java.lang.Long#reverse(long)
+     */
+    public void test_reverseJ() {
+        assertEquals(0, Long.reverse(0));
+        assertEquals(-1, Long.reverse(-1));
+        assertEquals(0x8000000000000000L,Long.reverse(1));
+    }
+    
+    /**
+     * @tests java.lang.Long#signum(long)
+     */
+    public void test_signumJ() {
+        for (int i = -128; i<0; i++) {
+            assertEquals(-1, Long.signum((long)i));
+        }
+        assertEquals(0, Long.signum((long)0));
+        for (int i = 1; i<=127; i++) {
+            assertEquals(1, Long.signum((long)i));
+        }
+    }
 }

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message