/* 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));
}
}
}
|
