/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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 dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargetClass;

import junit.framework.TestCase;

import java.util.Properties;

@TestTargetClass(Long.class) 
public class LongTest extends TestCase {
    private Properties orgProps;
    
    @Override
    protected void setUp() {
        orgProps = System.getProperties();
    }

    @Override
    protected void tearDown() {
        System.setProperties(orgProps);
    }

    /**
     * @tests java.lang.Long#byteValue()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks bounary values.",
        method = "byteValue",
        args = {}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "compareTo",
        args = {java.lang.Long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "decode",
        args = {java.lang.String.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getLong",
        args = {java.lang.String.class}
    )
    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");
        tProps.put("testIncLong", "string");
        System.setProperties(tProps);
        assertTrue("returned incorrect Long", Long.getLong("testLong").equals(
                new Long(99)));
        assertNull("returned incorrect default Long",
                Long.getLong("ff"));
        assertNull("returned incorrect default Long",
                Long.getLong("testIncLong"));        
    }

    /**
     * @tests java.lang.Long#getLong(java.lang.String, long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getLong",
        args = {java.lang.String.class, long.class}
    )
    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");
        tProps.put("testIncLong", "string");        
        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)));
        assertTrue("returned incorrect default Long", Long.getLong("testIncLong", 4L)
                .equals(new Long(4)));        
    }

    /**
     * @tests java.lang.Long#getLong(java.lang.String, java.lang.Long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "getLong",
        args = {java.lang.String.class, java.lang.Long.class}
    )
    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");
        tProps.put("testIncLong", "string");         
        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)));
        assertTrue("returned incorrect default Long", Long.getLong("testIncLong",
                new Long(4)).equals(new Long(4)));        
    }

    /**
     * @tests java.lang.Long#parseLong(java.lang.String)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Checks boundary values and exceptions.",
        method = "parseLong",
        args = {java.lang.String.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "parseLong",
        args = {java.lang.String.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toBinaryString",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toHexString",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toOctalString",
        args = {long.class}
    )
    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()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {long.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "valueOf",
        args = {java.lang.String.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "valueOf",
        args = {java.lang.String.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "valueOf",
        args = {long.class}
    )
    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()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "hashCode",
        args = {}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Long",
        args = {java.lang.String.class}
    )
    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
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "Long",
        args = {long.class}
    )
    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()
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Doesn't check boundary values.",
        method = "byteValue",
        args = {}
    )
    public void test_byteValue2() {
        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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "equals",
        args = {java.lang.Object.class}
    )
    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()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {}
    )
    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
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "toString",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "valueOf",
        args = {java.lang.String.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "valueOf",
        args = {java.lang.String.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Doesn't check boundary values.",
        method = "parseLong",
        args = {java.lang.String.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.PARTIAL,
        notes = "Doesn't check boundary values.",
        method = "parseLong",
        args = {java.lang.String.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "decode",
        args = {java.lang.String.class}
    )
    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()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "doubleValue",
        args = {}
    )
    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()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "floatValue",
        args = {}
    )
    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);
        
        assertEquals(Long.MAX_VALUE, new Long(Long.MAX_VALUE).floatValue(), 0F);
        assertEquals(Long.MIN_VALUE, new Long(Long.MIN_VALUE).floatValue(), 0F);        
    }
    
    /**
     * @tests java.lang.Long#intValue()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "intValue",
        args = {}
    )
    public void test_intValue() {
        assertEquals(-1, new Long(-1).intValue());
        assertEquals(0, new Long(0).intValue());
        assertEquals(1, new Long(1).intValue());
        
        assertEquals(-1, new Long(Long.MAX_VALUE).intValue());
        assertEquals(0, new Long(Long.MIN_VALUE).intValue());        
    }
    
    /**
     * @tests java.lang.Long#longValue()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "longValue",
        args = {}
    )
    public void test_longValue() {
        assertEquals(-1L, new Long(-1).longValue());
        assertEquals(0L, new Long(0).longValue());
        assertEquals(1L, new Long(1).longValue());
        
        assertEquals(Long.MAX_VALUE, new Long(Long.MAX_VALUE).longValue());
        assertEquals(Long.MIN_VALUE, new Long(Long.MIN_VALUE).longValue());
    }
    
    /**
     * @tests java.lang.Long#shortValue()
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "shortValue",
        args = {}
    )
    public void test_shortValue() {
        assertEquals(-1, new Long(-1).shortValue());
        assertEquals(0, new Long(0).shortValue());
        assertEquals(1, new Long(1).shortValue());
        
        assertEquals(-1, new Long(Long.MAX_VALUE).shortValue());
        assertEquals(0, new Long(Long.MIN_VALUE).shortValue());        
    }
    /**
     * @tests java.lang.Long#highestOneBit(long)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "highestOneBit",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "lowestOneBit",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "numberOfLeadingZeros",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "numberOfTrailingZeros",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "bitCount",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "rotateLeft",
        args = {long.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "rotateRight",
        args = {long.class, int.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "reverseBytes",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "reverse",
        args = {long.class}
    )
    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)
     */
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "",
        method = "signum",
        args = {long.class}
    )
    public void test_signumJ() {
        for (int i = -128; i<0; i++) {
            assertEquals(-1, Long.signum(i));
        }
        assertEquals(0, Long.signum(0));
        for (int i = 1; i<=127; i++) {
            assertEquals(1, Long.signum(i));
        }
    }
}
