/* 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;
//@TestTargetClass(Short.class)
public class ShortTest extends TestCase {
private Short sp = new Short((short) 18000);
private Short sn = new Short((short) -19000);
/**
* @tests java.lang.Short#byteValue()
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks boundary values.",
method = "byteValue",
args = {}
)
*/
public void test_byteValue() {
// Test for method byte java.lang.Short.byteValue()
assertEquals("Returned incorrect byte value", 0, new Short(Short.MIN_VALUE)
.byteValue());
assertEquals("Returned incorrect byte value", -1, new Short(Short.MAX_VALUE)
.byteValue());
}
/**
* @tests java.lang.Short#compareTo(java.lang.Short)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "compareTo",
args = {java.lang.Short.class}
)
*/
public void test_compareToLjava_lang_Short() {
// Test for method int java.lang.Short.compareTo(java.lang.Short)
Short s = new Short((short) 1);
Short x = new Short((short) 3);
assertTrue(
"Should have returned negative value when compared to greater short",
s.compareTo(x) < 0);
x = new Short((short) -1);
assertTrue(
"Should have returned positive value when compared to lesser short",
s.compareTo(x) > 0);
x = new Short((short) 1);
assertEquals("Should have returned zero when compared to equal short",
0, s.compareTo(x));
try {
new Short((short)0).compareTo(null);
fail("No NPE");
} catch (NullPointerException e) {
}
}
/**
* @tests java.lang.Short#decode(java.lang.String)
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "Doesn't check that no whitespace characters are permitted in the String. ",
method = "decode",
args = {java.lang.String.class}
)
*/
public void test_decodeLjava_lang_String2() {
// Test for method java.lang.Short
// java.lang.Short.decode(java.lang.String)
assertTrue("Did not decode -1 correctly", Short.decode("-1")
.shortValue() == (short) -1);
assertTrue("Did not decode -100 correctly", Short.decode("-100")
.shortValue() == (short) -100);
assertTrue("Did not decode 23 correctly", Short.decode("23")
.shortValue() == (short) 23);
assertTrue("Did not decode 0x10 correctly", Short.decode("0x10")
.shortValue() == (short) 16);
assertTrue("Did not decode 32767 correctly", Short.decode("32767")
.shortValue() == (short) 32767);
assertTrue("Did not decode -32767 correctly", Short.decode("-32767")
.shortValue() == (short) -32767);
assertTrue("Did not decode -32768 correctly", Short.decode("-32768")
.shortValue() == (short) -32768);
boolean exception = false;
try {
Short.decode("123s");
} catch (NumberFormatException e) {
// correct
exception = true;
}
assertTrue("Did not throw NumberFormatException decoding 123s",
exception);
exception = false;
try {
Short.decode("32768");
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
exception = false;
try {
Short.decode("-32769");
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
exception = false;
try {
Short.decode("0x8000");
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception);
exception = false;
try {
Short.decode("-0x8001");
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception);
}
/**
* @tests java.lang.Short#parseShort(java.lang.String)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "parseShort",
args = {java.lang.String.class}
)
*/
public void test_parseShortLjava_lang_String2() {
// Test for method short java.lang.Short.parseShort(java.lang.String)
short sp = Short.parseShort("32746");
short sn = Short.parseShort("-32746");
assertTrue("Incorrect parse of short", sp == (short) 32746
&& (sn == (short) -32746));
assertEquals("Returned incorrect value for 0", 0, Short.parseShort("0"));
assertTrue("Returned incorrect value for most negative value", Short
.parseShort("-32768") == (short) 0x8000);
assertTrue("Returned incorrect value for most positive value", Short
.parseShort("32767") == 0x7fff);
boolean exception = false;
try {
Short.parseShort("32768");
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
exception = false;
try {
Short.parseShort("-32769");
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
}
/**
* @tests java.lang.Short#parseShort(java.lang.String, int)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "parseShort",
args = {java.lang.String.class, int.class}
)
*/
public void test_parseShortLjava_lang_StringI2() {
// Test for method short java.lang.Short.parseShort(java.lang.String,
// int)
boolean aThrow = true;
assertEquals("Incorrectly parsed hex string",
255, Short.parseShort("FF", 16));
assertEquals("Incorrectly parsed oct string",
16, Short.parseShort("20", 8));
assertEquals("Incorrectly parsed dec string",
20, Short.parseShort("20", 10));
assertEquals("Incorrectly parsed bin string",
4, Short.parseShort("100", 2));
assertEquals("Incorrectly parsed -hex string", -255, Short
.parseShort("-FF", 16));
assertEquals("Incorrectly parsed -oct string",
-16, Short.parseShort("-20", 8));
assertEquals("Incorrectly parsed -bin string", -4, Short
.parseShort("-100", 2));
assertEquals("Returned incorrect value for 0 hex", 0, Short.parseShort("0",
16));
assertTrue("Returned incorrect value for most negative value hex",
Short.parseShort("-8000", 16) == (short) 0x8000);
assertTrue("Returned incorrect value for most positive value hex",
Short.parseShort("7fff", 16) == 0x7fff);
assertEquals("Returned incorrect value for 0 decimal", 0, Short.parseShort(
"0", 10));
assertTrue("Returned incorrect value for most negative value decimal",
Short.parseShort("-32768", 10) == (short) 0x8000);
assertTrue("Returned incorrect value for most positive value decimal",
Short.parseShort("32767", 10) == 0x7fff);
try {
Short.parseShort("FF", 2);
} catch (NumberFormatException e) {
// Correct
aThrow = false;
}
if (aThrow) {
fail(
"Failed to throw exception when passed hex string and base 2 radix");
}
boolean exception = false;
try {
Short.parseShort("10000000000", 10);
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue(
"Failed to throw exception when passed string larger than 16 bits",
exception);
exception = false;
try {
Short.parseShort("32768", 10);
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for MAX_VALUE + 1", exception);
exception = false;
try {
Short.parseShort("-32769", 10);
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for MIN_VALUE - 1", exception);
exception = false;
try {
Short.parseShort("8000", 16);
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception);
exception = false;
try {
Short.parseShort("-8001", 16);
} catch (NumberFormatException e) {
// Correct
exception = true;
}
assertTrue("Failed to throw exception for hex MIN_VALUE + 1", exception);
}
/**
* @tests java.lang.Short#toString()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
*/
public void test_toString2() {
// Test for method java.lang.String java.lang.Short.toString()
assertTrue("Invalid string returned", sp.toString().equals("18000")
&& (sn.toString().equals("-19000")));
assertEquals("Returned incorrect string", "32767", new Short((short) 32767)
.toString());
assertEquals("Returned incorrect string", "-32767", new Short((short) -32767)
.toString());
assertEquals("Returned incorrect string", "-32768", new Short((short) -32768)
.toString());
}
/**
* @tests java.lang.Short#toString(short)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "toString",
args = {short.class}
)
*/
public void test_toStringS2() {
// Test for method java.lang.String java.lang.Short.toString(short)
assertEquals("Returned incorrect string", "32767", Short.toString((short) 32767)
);
assertEquals("Returned incorrect string", "-32767", Short.toString((short) -32767)
);
assertEquals("Returned incorrect string", "-32768", Short.toString((short) -32768)
);
}
/**
* @tests java.lang.Short#valueOf(java.lang.String)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Checks boundary values.",
method = "valueOf",
args = {java.lang.String.class}
)
*/
public void test_valueOfLjava_lang_String2() {
// Test for method java.lang.Short
// java.lang.Short.valueOf(java.lang.String)
assertEquals("Returned incorrect short", -32768, Short.valueOf("-32768")
.shortValue());
assertEquals("Returned incorrect short", 32767, Short.valueOf("32767")
.shortValue());
}
/**
* @tests java.lang.Short#valueOf(java.lang.String, int)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "valueOf",
args = {java.lang.String.class, int.class}
)
*/
public void test_valueOfLjava_lang_StringI2() {
// Test for method java.lang.Short
// java.lang.Short.valueOf(java.lang.String, int)
boolean aThrow = true;
assertEquals("Incorrectly parsed hex string", 255, Short.valueOf("FF", 16)
.shortValue());
assertEquals("Incorrectly parsed oct string", 16, Short.valueOf("20", 8)
.shortValue());
assertEquals("Incorrectly parsed dec string", 20, Short.valueOf("20", 10)
.shortValue());
assertEquals("Incorrectly parsed bin string", 4, Short.valueOf("100", 2)
.shortValue());
assertEquals("Incorrectly parsed -hex string", -255, Short.valueOf("-FF", 16)
.shortValue());
assertEquals("Incorrectly parsed -oct string", -16, Short.valueOf("-20", 8)
.shortValue());
assertEquals("Incorrectly parsed -bin string", -4, Short.valueOf("-100", 2)
.shortValue());
assertTrue("Did not decode 32767 correctly", Short.valueOf("32767", 10)
.shortValue() == (short) 32767);
assertTrue("Did not decode -32767 correctly", Short.valueOf("-32767",
10).shortValue() == (short) -32767);
assertTrue("Did not decode -32768 correctly", Short.valueOf("-32768",
10).shortValue() == (short) -32768);
try {
Short.valueOf("FF", 2);
} catch (NumberFormatException e) {
// Correct
aThrow = false;
}
if (aThrow) {
fail(
"Failed to throw exception when passed hex string and base 2 radix");
}
try {
Short.valueOf("10000000000", 10);
} catch (NumberFormatException e) {
// Correct
return;
}
fail(
"Failed to throw exception when passed string larger than 16 bits");
}
/**
* @tests java.lang.Short#valueOf(short)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "valueOf",
args = {short.class}
)
*/
public void test_valueOfS() {
assertEquals(new Short(Short.MIN_VALUE), Short.valueOf(Short.MIN_VALUE));
assertEquals(new Short(Short.MAX_VALUE), Short.valueOf(Short.MAX_VALUE));
assertEquals(new Short((short) 0), Short.valueOf((short) 0));
short s = -128;
while (s < 128) {
assertEquals(new Short(s), Short.valueOf(s));
assertSame(Short.valueOf(s), Short.valueOf(s));
s++;
}
}
/**
* @tests java.lang.Short#hashCode()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "hashCode",
args = {}
)
*/
public void test_hashCode() {
assertEquals(1, new Short((short)1).hashCode());
assertEquals(2, new Short((short)2).hashCode());
assertEquals(0, new Short((short)0).hashCode());
assertEquals(-1, new Short((short)-1).hashCode());
}
/**
* @tests java.lang.Short#Short(String)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "Short",
args = {java.lang.String.class}
)
*/
public void test_ConstructorLjava_lang_String() {
assertEquals(new Short((short)0), new Short("0"));
assertEquals(new Short((short)1), new Short("1"));
assertEquals(new Short((short)-1), new Short("-1"));
try {
new Short("0x1");
fail("Expected NumberFormatException with hex string.");
} catch (NumberFormatException e) {}
try {
new Short("9.2");
fail("Expected NumberFormatException with floating point string.");
} catch (NumberFormatException e) {}
try {
new Short("");
fail("Expected NumberFormatException with empty string.");
} catch (NumberFormatException e) {}
try {
new Short(null);
fail("Expected NumberFormatException with null string.");
} catch (NumberFormatException e) {}
}
/**
* @tests java.lang.Short#Short(short)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "Short",
args = {short.class}
)
*/
public void test_ConstructorS() {
assertEquals(1, new Short((short)1).shortValue());
assertEquals(2, new Short((short)2).shortValue());
assertEquals(0, new Short((short)0).shortValue());
assertEquals(-1, new Short((short)-1).shortValue());
}
/**
* @tests java.lang.Short#byteValue()
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't check boundary values.",
method = "byteValue",
args = {}
)
*/
public void test_byteValue1() {
assertEquals(1, new Short((short)1).byteValue());
assertEquals(2, new Short((short)2).byteValue());
assertEquals(0, new Short((short)0).byteValue());
assertEquals(-1, new Short((short)-1).byteValue());
}
/**
* @tests java.lang.Short#equals(Object)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "equals",
args = {java.lang.Object.class}
)
*/
public void test_equalsLjava_lang_Object() {
assertEquals(new Short((short)0), Short.valueOf((short)0));
assertEquals(new Short((short)1), Short.valueOf((short)1));
assertEquals(new Short((short)-1), Short.valueOf((short)-1));
Short fixture = new Short((short)25);
assertEquals(fixture, fixture);
assertFalse(fixture.equals(null));
assertFalse(fixture.equals("Not a Short"));
}
/**
* @tests java.lang.Short#toString()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "toString",
args = {}
)
*/
public void test_toString() {
assertEquals("-1", new Short((short)-1).toString());
assertEquals("0", new Short((short)0).toString());
assertEquals("1", new Short((short)1).toString());
assertEquals("-1", new Short((short)0xFFFF).toString());
}
/**
* @tests java.lang.Short#toString(short)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "toString",
args = {short.class}
)
*/
public void test_toStringS() {
assertEquals("-1", Short.toString((short)-1));
assertEquals("0", Short.toString((short)0));
assertEquals("1", Short.toString((short)1));
assertEquals("-1", Short.toString((short)0xFFFF));
}
/**
* @tests java.lang.Short#valueOf(String)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't check boundary values.",
method = "valueOf",
args = {java.lang.String.class}
)
*/
public void test_valueOfLjava_lang_String() {
assertEquals(new Short((short)0), Short.valueOf("0"));
assertEquals(new Short((short)1), Short.valueOf("1"));
assertEquals(new Short((short)-1), Short.valueOf("-1"));
try {
Short.valueOf("0x1");
fail("Expected NumberFormatException with hex string.");
} catch (NumberFormatException e) {}
try {
Short.valueOf("9.2");
fail("Expected NumberFormatException with floating point string.");
} catch (NumberFormatException e) {}
try {
Short.valueOf("");
fail("Expected NumberFormatException with empty string.");
} catch (NumberFormatException e) {}
try {
Short.valueOf(null);
fail("Expected NumberFormatException with null string.");
} catch (NumberFormatException e) {}
}
/**
* @tests java.lang.Short#valueOf(String,int)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "valueOf",
args = {java.lang.String.class, int.class}
)
*/
public void test_valueOfLjava_lang_StringI() {
assertEquals(new Short((short)0), Short.valueOf("0", 10));
assertEquals(new Short((short)1), Short.valueOf("1", 10));
assertEquals(new Short((short)-1), Short.valueOf("-1", 10));
//must be consistent with Character.digit()
assertEquals(Character.digit('1', 2), Short.valueOf("1", 2).byteValue());
assertEquals(Character.digit('F', 16), Short.valueOf("F", 16).byteValue());
try {
Short.valueOf("0x1", 10);
fail("Expected NumberFormatException with hex string.");
} catch (NumberFormatException e) {}
try {
Short.valueOf("9.2", 10);
fail("Expected NumberFormatException with floating point string.");
} catch (NumberFormatException e) {}
try {
Short.valueOf("", 10);
fail("Expected NumberFormatException with empty string.");
} catch (NumberFormatException e) {}
try {
Short.valueOf(null, 10);
fail("Expected NumberFormatException with null string.");
} catch (NumberFormatException e) {}
}
/**
* @tests java.lang.Short#parseShort(String)
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "Doesn't check boundary values, unicodes.",
method = "parseShort",
args = {java.lang.String.class}
)
*/
public void test_parseShortLjava_lang_String() {
assertEquals(0, Short.parseShort("0"));
assertEquals(1, Short.parseShort("1"));
assertEquals(-1, Short.parseShort("-1"));
try {
Short.parseShort("0x1");
fail("Expected NumberFormatException with hex string.");
} catch (NumberFormatException e) {}
try {
Short.parseShort("9.2");
fail("Expected NumberFormatException with floating point string.");
} catch (NumberFormatException e) {}
try {
Short.parseShort("");
fail("Expected NumberFormatException with empty string.");
} catch (NumberFormatException e) {}
try {
Short.parseShort(null);
fail("Expected NumberFormatException with null string.");
} catch (NumberFormatException e) {}
}
/**
* @tests java.lang.Short#parseShort(String,int)
@TestTargetNew(
level = TestLevel.PARTIAL,
notes = "Doesn't check boundary values.",
method = "parseShort",
args = {java.lang.String.class, int.class}
)
*/
public void test_parseShortLjava_lang_StringI() {
assertEquals(0, Short.parseShort("0", 10));
assertEquals(1, Short.parseShort("1", 10));
assertEquals(-1, Short.parseShort("-1", 10));
//must be consistent with Character.digit()
assertEquals(Character.digit('1', 2), Short.parseShort("1", 2));
assertEquals(Character.digit('F', 16), Short.parseShort("F", 16));
try {
Short.parseShort("0x1", 10);
fail("Expected NumberFormatException with hex string.");
} catch (NumberFormatException e) {}
try {
Short.parseShort("9.2", 10);
fail("Expected NumberFormatException with floating point string.");
} catch (NumberFormatException e) {}
try {
Short.parseShort("", 10);
fail("Expected NumberFormatException with empty string.");
} catch (NumberFormatException e) {}
try {
Short.parseShort(null, 10);
fail("Expected NumberFormatException with null string.");
} catch (NumberFormatException e) {}
}
/**
* @tests java.lang.Short#decode(String)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "decode",
args = {java.lang.String.class}
)
*/
public void test_decodeLjava_lang_String() {
assertEquals(new Short((short)0), Short.decode("0"));
assertEquals(new Short((short)1), Short.decode("1"));
assertEquals(new Short((short)-1), Short.decode("-1"));
assertEquals(new Short((short)0xF), Short.decode("0xF"));
assertEquals(new Short((short)0xF), Short.decode("#F"));
assertEquals(new Short((short)0xF), Short.decode("0XF"));
assertEquals(new Short((short)07), Short.decode("07"));
try {
Short.decode(" 0 ");
fail("NumberFormatException is not thrown.");
} catch(NumberFormatException nfe) {
//expected
}
try {
Short.decode("9.2");
fail("Expected NumberFormatException with floating point string.");
} catch (NumberFormatException e) {}
try {
Short.decode("");
fail("Expected NumberFormatException with empty string.");
} catch (NumberFormatException e) {}
try {
Short.decode(null);
//undocumented NPE, but seems consistent across JREs
fail("Expected NullPointerException with null string.");
} catch (NullPointerException e) {}
}
/**
* @tests java.lang.Short#doubleValue()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "doubleValue",
args = {}
)
*/
public void test_doubleValue() {
assertEquals(-1D, new Short((short)-1).doubleValue(), 0D);
assertEquals(0D, new Short((short)0).doubleValue(), 0D);
assertEquals(1D, new Short((short)1).doubleValue(), 0D);
}
/**
* @tests java.lang.Short#floatValue()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "floatValue",
args = {}
)
*/
public void test_floatValue() {
assertEquals(-1F, new Short((short)-1).floatValue(), 0F);
assertEquals(0F, new Short((short)0).floatValue(), 0F);
assertEquals(1F, new Short((short)1).floatValue(), 0F);
}
/**
* @tests java.lang.Short#intValue()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "intValue",
args = {}
)
*/
public void test_intValue() {
assertEquals(-1, new Short((short)-1).intValue());
assertEquals(0, new Short((short)0).intValue());
assertEquals(1, new Short((short)1).intValue());
}
/**
* @tests java.lang.Short#longValue()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "longValue",
args = {}
)
*/
public void test_longValue() {
assertEquals(-1L, new Short((short)-1).longValue());
assertEquals(0L, new Short((short)0).longValue());
assertEquals(1L, new Short((short)1).longValue());
}
/**
* @tests java.lang.Short#shortValue()
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "shortValue",
args = {}
)
*/
public void test_shortValue() {
assertEquals(-1, new Short((short)-1).shortValue());
assertEquals(0, new Short((short)0).shortValue());
assertEquals(1, new Short((short)1).shortValue());
}
/**
* @tests java.lang.Short#reverseBytes(short)
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "reverseBytes",
args = {short.class}
)
*/
public void test_reverseBytesS() {
assertEquals((short)0xABCD, Short.reverseBytes((short)0xCDAB));
assertEquals((short)0x1234, Short.reverseBytes((short)0x3412));
assertEquals((short)0x0011, Short.reverseBytes((short)0x1100));
assertEquals((short)0x2002, Short.reverseBytes((short)0x0220));
}
}