diff options
116 files changed, 2576 insertions, 24087 deletions
diff --git a/expectations/brokentests.txt b/expectations/brokentests.txt index 70c82cd..213b519 100644 --- a/expectations/brokentests.txt +++ b/expectations/brokentests.txt @@ -844,9 +844,9 @@ description: "These tests expect to be able to load resources from the file system", result: EXEC_FAILED, names: [ - "org.apache.harmony.luni.tests.java.lang.ClassTest#test_getResourceAsStreamLjava_lang_String", - "org.apache.harmony.luni.tests.java.lang.ClassTest#test_getResourceAsStream_withSharpChar", - "org.apache.harmony.luni.tests.java.lang.ClassTest#test_getResourceLjava_lang_String" + "libcore.java.lang.OldClassTest#test_getResourceAsStreamLjava_lang_String", + "libcore.java.lang.OldClassTest#test_getResourceAsStream_withSharpChar", + "libcore.java.lang.OldClassTest#test_getResourceLjava_lang_String" ] }, { diff --git a/expectations/knownfailures.txt b/expectations/knownfailures.txt index d7a1a19..72df746 100644 --- a/expectations/knownfailures.txt +++ b/expectations/knownfailures.txt @@ -152,7 +152,7 @@ }, { description: "Double.parseDouble().toString does wrong rounding", - name: "org.apache.harmony.luni.tests.java.lang.DoubleTest#test_parseDoubleLjava_lang_String", + name: "libcore.java.lang.OldDoubleTest#test_parseDoubleLjava_lang_String", bug: 1607938 }, { @@ -226,18 +226,18 @@ { description: "Defining classes from byte[] not supported in Android", result: EXEC_FAILED, - name: "org.apache.harmony.luni.tests.java.lang.ClassTest#test_getClasses_subtest0" + name: "libcore.java.lang.OldClassTest#test_getClasses_subtest0" }, { description: "There is no protection domain set in Android.", result: EXEC_FAILED, - name: "org.apache.harmony.luni.tests.java.lang.ClassTest#test_getProtectionDomain" + name: "libcore.java.lang.OldClassTest#test_getProtectionDomain" }, { description: "Fails in CTS but passes under run-core-tests", result: EXEC_FAILED, names: [ - "org.apache.harmony.luni.tests.java.lang.RuntimeTest#test_traceMethodCalls", + "libcore.java.lang.OldRuntimeTest#test_traceMethodCalls", "tests.api.java.net.MulticastSocketTest#test_joinGroupLjava_net_SocketAddressLjava_net_NetworkInterface", "tests.api.java.util.FormatterTest#test_formatLjava_lang_String$Ljava_lang_Object_DateTimeConversion" ] diff --git a/luni/src/main/java/java/io/ObjectOutputStream.java b/luni/src/main/java/java/io/ObjectOutputStream.java index e2e5c75..d074350 100644 --- a/luni/src/main/java/java/io/ObjectOutputStream.java +++ b/luni/src/main/java/java/io/ObjectOutputStream.java @@ -1045,7 +1045,6 @@ public class ObjectOutputStream extends OutputStream implements ObjectOutput, * @see #writeObject(Object) */ private void writeFieldValues(Object obj, ObjectStreamClass classDesc) throws IOException { - Class<?> declaringClass = classDesc.forClass(); for (ObjectStreamField fieldDesc : classDesc.fields()) { try { Field field = classDesc.getReflectionField(fieldDesc); @@ -1873,11 +1872,10 @@ public class ObjectOutputStream extends OutputStream implements ObjectOutput, objectsWritten.put(object, handle); ObjectStreamField[] fields = classDesc.getSuperclass().fields(); - Class<?> declaringClass = classDesc.getSuperclass().forClass(); // Only write field "name" for enum class, which is the second field of // enum, that is fields[1]. Ignore all non-fields and fields.length < 2 if (fields != null && fields.length > 1) { - Field field = classDesc.getReflectionField(fields[1]); + Field field = classDesc.getSuperclass().getReflectionField(fields[1]); if (field == null) { throw new NoSuchFieldError(); } diff --git a/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/http/HttpURLConnectionImpl.java b/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/http/HttpURLConnectionImpl.java index 22f933f..dad0e64 100644 --- a/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/http/HttpURLConnectionImpl.java +++ b/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/http/HttpURLConnectionImpl.java @@ -134,7 +134,7 @@ public class HttpURLConnectionImpl extends HttpURLConnection { private AbstractHttpOutputStream requestBodyOut; - private InputStream responseBodyIn; + protected InputStream responseBodyIn; private ResponseCache responseCache; diff --git a/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/https/HttpsURLConnectionImpl.java b/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/https/HttpsURLConnectionImpl.java index 1137a3a..3f28aa8 100644 --- a/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/https/HttpsURLConnectionImpl.java +++ b/luni/src/main/java/org/apache/harmony/luni/internal/net/www/protocol/https/HttpsURLConnectionImpl.java @@ -371,6 +371,16 @@ public class HttpsURLConnectionImpl extends HttpsURLConnection { return httpsEngine.toString(); } + @Override + public void setFixedLengthStreamingMode(int contentLength) { + httpsEngine.setFixedLengthStreamingMode(contentLength); + } + + @Override + public void setChunkedStreamingMode(int chunkLength) { + httpsEngine.setChunkedStreamingMode(chunkLength); + } + private final class HttpsEngine extends HttpURLConnectionImpl { protected HttpsEngine(URL url, int port) { @@ -382,6 +392,12 @@ public class HttpsURLConnectionImpl extends HttpsURLConnection { } @Override public void makeConnection() throws IOException { + connected = true; + + if (connection != null || responseBodyIn != null) { + return; + } + /* * Short-circuit a reentrant call. The first step in doing SSL with * an HTTP proxy requires calling retrieveResponse() which calls diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalAccessErrorTest.java b/luni/src/test/java/libcore/java/lang/OldCharacterSubsetTest.java index 5b032e1..215747b 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalAccessErrorTest.java +++ b/luni/src/test/java/libcore/java/lang/OldCharacterSubsetTest.java @@ -15,28 +15,25 @@ * limitations under the License. */ -package org.apache.harmony.luni.tests.java.lang; +package libcore.java.lang; import junit.framework.TestCase; -public class IllegalAccessErrorTest extends TestCase { +public class OldCharacterSubsetTest extends TestCase { - /** - * @tests java.lang.IllegalAccessError#IllegalAccessError() - */ - public void test_Constructor() { - IllegalAccessError e = new IllegalAccessError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); + public void test_equals() { + Character.Subset subset1 = new Character.Subset("name") { }; + assertTrue(subset1.equals(subset1)); + assertFalse(subset1.equals(new Character.Subset("name") {})); + assertFalse(subset1.equals(new Character.Subset("name1") {})); + assertFalse(subset1.equals(new Integer(0))); } - /** - * @tests java.lang.IllegalAccessError#IllegalAccessError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IllegalAccessError e = new IllegalAccessError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); + public void test_hashCode() { + Character.Subset subset1 = new Character.Subset("name") {}; + Character.Subset subset2 = new Character.Subset("name") {}; + Character.Subset subset3 = new Character.Subset("name1") {}; + assertFalse(subset1.hashCode() == subset2.hashCode()); + assertFalse(subset1.hashCode() == subset3.hashCode()); } } diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/OldCharacterTest.java b/luni/src/test/java/libcore/java/lang/OldCharacterTest.java index 73e0405..8e6f9ab 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/OldCharacterTest.java +++ b/luni/src/test/java/libcore/java/lang/OldCharacterTest.java @@ -14,13 +14,12 @@ * limitations under the License. */ -package org.apache.harmony.luni.tests.java.lang; +package libcore.java.lang; import junit.framework.TestCase; public class OldCharacterTest extends TestCase { - public void test_codePointCountLjava_lang_CharArrayII() { assertEquals(1, Character.codePointCount("\uD800\uDC00".toCharArray(), diff --git a/luni/src/test/java/libcore/java/lang/OldClassTest.java b/luni/src/test/java/libcore/java/lang/OldClassTest.java new file mode 100644 index 0000000..c516467 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldClassTest.java @@ -0,0 +1,1024 @@ +/* + * 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 libcore.java.lang; + +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.Serializable; +import java.lang.annotation.Annotation; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.Method; +import java.lang.reflect.ParameterizedType; +import java.lang.reflect.Type; +import java.lang.reflect.TypeVariable; +import java.net.URL; +import java.net.URLClassLoader; +import java.util.AbstractList; +import java.util.Collection; +import java.util.List; +import java.util.Vector; +import tests.support.Support_ClassLoader; +import tests.support.resource.Support_Resources; + +@SuppressWarnings("deprecation") +public class OldClassTest extends junit.framework.TestCase { + + public static final String FILENAME = + OldClassTest.class.getPackage().getName().replace('.', '/') + + "/test#.properties"; + + final String packageName = getClass().getPackage().getName(); + final String classNameInitError1 = packageName + ".TestClass1"; + final String classNameInitError2 = packageName + ".TestClass1B"; + final String classNameLinkageError = packageName + ".TestClass"; + final String sourceJARfile = "illegalClasses.jar"; + final String illegalClassName = "illegalClass"; + + @Retention(RetentionPolicy.RUNTIME) + public @interface TestAnnotation { + String value(); + } + + public static class TestClass1C { + static TestClass2 tc = new TestClass2(0); + + TestClass1C() { + } + + } + + public static class TestClass2 { + + public TestClass2(int i) throws IllegalArgumentException { + throw new IllegalArgumentException(); + } + } + + public static class TestClass3 { + private TestClass3() {} + } + + interface TestInterface { + public static int TEST_INTERFACE_FIELD = 0; + + int getCount(); + void setCount(int value); + } + + static class StaticMember$Class { + class Member2$A { + } + } + + class Member$Class { + class Member3$B { + } + } + + @Deprecated + @TestAnnotation("libcore.java.lang.OldClassTest$ExtendTestClass") + public static class ExtendTestClass extends PublicTestClass { + + private static final long serialVersionUID = 1L; + + public enum enumExm {ONE, TWO, THREE}; + @Override + public void setCount(int value) { + + } + } + + public class ExtendTestClass1 extends ExtendTestClass { + + } + + @TestAnnotation("libcore.java.lang.OldClassTest$PublicTestClass") + public static class PublicTestClass implements TestInterface, Serializable, Cloneable { + + private static final long serialVersionUID = 1L; + + public static String TEST_FIELD = "test field"; + + Object clazz; + + public PublicTestClass() { + class LocalClass { } + + clazz = new LocalClass(); + } + + public Object getLocalClass() { + class LocalClass {} + Object returnedObject = new LocalClass(); + return returnedObject; + } + + int count = 0; + + public int getCount() { + return count; + } + + public void setCount(int value) { + count = value; + } + + private class PrivateClass1 { + + public String toString() { + return "PrivateClass0"; + } + } + + public class PrivateClass2 { + + public String toString() { + return "PrivateClass1"; + } + } + } + + public static class TestClass { + @SuppressWarnings("unused") + private int privField = 1; + + public int pubField = 2; + + private Object cValue = null; + + public Object ack = new Object(); + + @SuppressWarnings("unused") + private int privMethod() { + return 1; + } + + public int pubMethod() { + return 2; + } + + public Object cValue() { + return cValue; + } + + public TestClass() { + } + + @SuppressWarnings("unused") + private TestClass(Object o) { + } + } + + public static class SubTestClass extends TestClass { + } + + interface Intf1 { + public int field1 = 1; + public int field2 = 1; + void test(); + } + + interface Intf2 { + public int field1 = 1; + void test(); + } + + interface Intf3 extends Intf1 { + public int field1 = 1; + } + + interface Intf4 extends Intf1, Intf2 { + public int field1 = 1; + void test2(int a, Object b); + } + + interface Intf5 extends Intf1 { + } + + class Cls1 implements Intf2 { + public int field1 = 2; + public int field2 = 2; + public void test() { + } + } + + class Cls2 extends Cls1 implements Intf1 { + public int field1 = 2; + @Override + public void test() { + } + } + + class Cls3 implements Intf3, Intf4 { + public void test() { + } + public void test2(int a, Object b) { + } + } + + static class Cls4 { + + } + + public void test_getAnnotations() { + Annotation [] annotations = PublicTestClass.class.getAnnotations(); + assertEquals(1, annotations.length); + assertEquals(TestAnnotation.class, annotations[0].annotationType()); + + annotations = ExtendTestClass.class.getAnnotations(); + assertEquals(2, annotations.length); + + for(int i = 0; i < annotations.length; i++) { + Class<? extends Annotation> type = annotations[i].annotationType(); + assertTrue("Annotation's type " + i + ": " + type, + type.equals(Deprecated.class) || + type.equals(TestAnnotation.class)); + } + } + + public void test_forNameLjava_lang_StringLbooleanLClassLoader() throws Exception { + + ClassLoader pcl = getClass().getClassLoader(); + + Class<?> [] classes = {PublicTestClass.class, ExtendTestClass.class, + ExtendTestClass1.class, TestInterface.class, String.class}; + + for(int i = 0; i < classes.length; i++) { + Class<?> clazz = Class.forName(classes[i].getName(), true, pcl); + assertEquals(classes[i], clazz); + + clazz = Class.forName(classes[i].getName(), false, pcl); + assertEquals(classes[i], clazz); + } + + Class<?> [] systemClasses = {String.class, Integer.class, Object.class, + Object[].class}; + + for(int i = 0; i < systemClasses.length; i++) { + Class<?> clazz = Class.forName(systemClasses[i].getName(), true, + ClassLoader.getSystemClassLoader()); + assertEquals(systemClasses[i], clazz); + + clazz = Class.forName(systemClasses[i].getName(), false, + ClassLoader.getSystemClassLoader()); + assertEquals(systemClasses[i], clazz); + } + + try { + Class.forName(null, true, pcl); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + Class.forName("NotExistClass", true, pcl); + fail("ClassNotFoundException is not thrown for non existent class."); + } catch(ClassNotFoundException cnfe) { + //expected + } + + try { + Class.forName("String", false, pcl); + fail("ClassNotFoundException is not thrown for non existent class."); + } catch(ClassNotFoundException cnfe) { + //expected + } + + try { + Class.forName("libcore.java.lang.NonexistentClass", false, pcl); + fail("ClassNotFoundException is not thrown for non existent class."); + } catch(ClassNotFoundException cnfe) { + //expected + } + } + + // AndroidOnly: Class.forName method throws ClassNotFoundException on Android. + public void test_forNameLjava_lang_StringLbooleanLClassLoader_AndroidOnly() throws Exception { + + // Android doesn't support loading class files from a jar. + try { + + URL url = getClass().getClassLoader().getResource( + packageName.replace(".", "/") + "/" + sourceJARfile); + + ClassLoader loader = new URLClassLoader(new URL[] { url }, + getClass().getClassLoader()); + try { + Class.forName(classNameLinkageError, true, loader); + fail("LinkageError or ClassNotFoundException expected."); + } catch (java.lang.LinkageError le) { + // Expected for the RI. + } catch (java.lang.ClassNotFoundException ce) { + // Expected for Android. + } + } catch(Exception e) { + fail("Unexpected exception was thrown: " + e.toString()); + } + + try { + Class.forName(classNameInitError2, + true, getClass().getClassLoader()); + fail("ExceptionInInitializerError or ClassNotFoundException " + + "should be thrown."); + } catch (java.lang.ExceptionInInitializerError ie) { + // Expected for the RI. + // Remove this comment to let the test pass on Android. + } catch (java.lang.ClassNotFoundException ce) { + // Expected for Android. + } + } + + public void test_getAnnotation() { + TestAnnotation target = PublicTestClass.class.getAnnotation(TestAnnotation.class); + assertEquals(target.value(), PublicTestClass.class.getName()); + + assertNull(PublicTestClass.class.getAnnotation(Deprecated.class)); + + Deprecated target2 = ExtendTestClass.class.getAnnotation(Deprecated.class); + assertNotNull(target2); + } + + public void test_getDeclaredAnnotations() { + Annotation [] annotations = PublicTestClass.class.getDeclaredAnnotations(); + assertEquals(1, annotations.length); + + annotations = ExtendTestClass.class.getDeclaredAnnotations(); + assertEquals(2, annotations.length); + + annotations = TestInterface.class.getDeclaredAnnotations(); + assertEquals(0, annotations.length); + + annotations = String.class.getDeclaredAnnotations(); + assertEquals(0, annotations.length); + } + + public void test_getEnclosingClass() { + Class clazz = OldClassTest.class.getEnclosingClass(); + assertNull(clazz); + + assertEquals(getClass(), Cls1.class.getEnclosingClass()); + assertEquals(getClass(), Intf1.class.getEnclosingClass()); + assertEquals(getClass(), Cls4.class.getEnclosingClass()); + } + + public void test_getEnclosingMethod() { + Method clazz = ExtendTestClass.class.getEnclosingMethod(); + assertNull(clazz); + + PublicTestClass ptc = new PublicTestClass(); + try { + assertEquals("getEnclosingMethod returns incorrect method.", + PublicTestClass.class.getMethod("getLocalClass", + (Class []) null), + ptc.getLocalClass().getClass().getEnclosingMethod()); + } catch(NoSuchMethodException nsme) { + fail("NoSuchMethodException was thrown."); + } + } + + public void test_getEnclosingConstructor() { + + PublicTestClass ptc = new PublicTestClass(); + + assertEquals("getEnclosingConstructor method returns incorrect class.", + PublicTestClass.class.getConstructors()[0], + ptc.clazz.getClass().getEnclosingConstructor()); + + assertNull("getEnclosingConstructor should return null for local " + + "class declared in method.", + ptc.getLocalClass().getClass().getEnclosingConstructor()); + + assertNull("getEnclosingConstructor should return null for local " + + "class declared in method.", + ExtendTestClass.class.getEnclosingConstructor()); + } + + + public void test_getEnumConstants() { + Object [] clazz = ExtendTestClass.class.getEnumConstants(); + assertNull(clazz); + Object [] constants = TestEnum.class.getEnumConstants(); + assertEquals(TestEnum.values().length, constants.length); + for(int i = 0; i < constants.length; i++) { + assertEquals(TestEnum.values()[i], constants[i]); + } + assertEquals(0, TestEmptyEnum.class.getEnumConstants().length); + } + public enum TestEnum { + ONE, TWO, THREE + } + public enum TestEmptyEnum { + } + + public void test_getGenericInterfaces() { + Type [] types = ExtendTestClass1.class.getGenericInterfaces(); + assertEquals(0, types.length); + + Class [] interfaces = {TestInterface.class, Serializable.class, + Cloneable.class}; + types = PublicTestClass.class.getGenericInterfaces(); + assertEquals(interfaces.length, types.length); + for(int i = 0; i < types.length; i++) { + assertEquals(interfaces[i], types[i]); + } + + types = TestInterface.class.getGenericInterfaces(); + assertEquals(0, types.length); + + types = List.class.getGenericInterfaces(); + assertEquals(1, types.length); + assertEquals(Collection.class, ((ParameterizedType)types[0]).getRawType()); + + assertEquals(0, int.class.getGenericInterfaces().length); + assertEquals(0, void.class.getGenericInterfaces().length); + } + + public void test_getGenericSuperclass () { + assertEquals(PublicTestClass.class, + ExtendTestClass.class.getGenericSuperclass()); + assertEquals(ExtendTestClass.class, + ExtendTestClass1.class.getGenericSuperclass()); + assertEquals(Object.class, PublicTestClass.class.getGenericSuperclass()); + assertEquals(Object.class, String.class.getGenericSuperclass()); + assertEquals(null, TestInterface.class.getGenericSuperclass()); + + ParameterizedType type = (ParameterizedType) Vector.class.getGenericSuperclass(); + assertEquals(AbstractList.class, type.getRawType()); + } + + // AndroidOnly: Uses dalvik.system.PathClassLoader. + // Different behavior between cts host and run-core-test") + public void test_getPackage() { + + Package thisPackage = getClass().getPackage(); + assertEquals("libcore.java.lang", + thisPackage.getName()); + + Package stringPackage = String.class.getPackage(); + assertNotNull("java.lang", stringPackage.getName()); + + String hyts_package_name = "hyts_package_dex.jar"; + File resources = Support_Resources.createTempFolder(); + Support_Resources.copyFile(resources, "Package", hyts_package_name); + + String resPath = resources.toString(); + if (resPath.charAt(0) == '/' || resPath.charAt(0) == '\\') + resPath = resPath.substring(1); + + try { + + URL resourceURL = new URL("file:/" + resPath + "/Package/" + + hyts_package_name); + + ClassLoader cl = Support_ClassLoader.getInstance(resourceURL, + getClass().getClassLoader()); + + Class clazz = cl.loadClass("C"); + assertNull("getPackage for C.class should return null", + clazz.getPackage()); + + clazz = cl.loadClass("a.b.C"); + Package cPackage = clazz.getPackage(); + assertNotNull("getPackage for a.b.C.class should not return null", + cPackage); + + /* + * URLClassLoader doesn't work on Android for jar files + * + * URL url = getClass().getClassLoader().getResource( + * packageName.replace(".", "/") + "/" + sourceJARfile); + * + * ClassLoader loader = new URLClassLoader(new URL[] { url }, null); + * + * try { + * Class<?> clazz = loader.loadClass(illegalClassName); + * Package pack = clazz.getPackage(); + * assertNull(pack); + * } catch(ClassNotFoundException cne) { + * fail("ClassNotFoundException was thrown for " + illegalClassName); + * } + */ + } catch(Exception e) { + fail("Unexpected exception was thrown: " + e.toString()); + } + } + + public void test_getSigners() { + assertNull(void.class.getSigners()); + assertNull(PublicTestClass.class.getSigners()); + } + + public void test_getSimpleName() { + assertEquals("PublicTestClass", PublicTestClass.class.getSimpleName()); + assertEquals("void", void.class.getSimpleName()); + assertEquals("int[]", int[].class.getSimpleName()); + } + + public void test_getTypeParameters() { + assertEquals(0, PublicTestClass.class.getTypeParameters().length); + TypeVariable [] tv = TempTestClass1.class.getTypeParameters(); + assertEquals(1, tv.length); + assertEquals(Object.class, tv[0].getBounds()[0]); + + TempTestClass2<String> tc = new TempTestClass2<String>(); + tv = tc.getClass().getTypeParameters(); + assertEquals(1, tv.length); + assertEquals(String.class, tv[0].getBounds()[0]); + } + + class TempTestClass1<T> { + } + + class TempTestClass2<S extends String> extends TempTestClass1<S> { + } + + public void test_isAnnotation() { + assertTrue(Deprecated.class.isAnnotation()); + assertTrue(TestAnnotation.class.isAnnotation()); + assertFalse(PublicTestClass.class.isAnnotation()); + assertFalse(String.class.isAnnotation()); + } + + public void test_isAnnotationPresent() { + assertTrue(PublicTestClass.class.isAnnotationPresent(TestAnnotation.class)); + assertFalse(ExtendTestClass1.class.isAnnotationPresent(TestAnnotation.class)); + assertFalse(String.class.isAnnotationPresent(Deprecated.class)); + assertTrue(ExtendTestClass.class.isAnnotationPresent(TestAnnotation.class)); + assertTrue(ExtendTestClass.class.isAnnotationPresent(Deprecated.class)); + } + + public void test_isAnonymousClass() { + assertFalse(PublicTestClass.class.isAnonymousClass()); + assertTrue((new Thread() {}).getClass().isAnonymousClass()); + } + + public void test_isEnum() { + assertFalse(PublicTestClass.class.isEnum()); + assertFalse(ExtendTestClass.class.isEnum()); + assertTrue(TestEnum.ONE.getClass().isEnum()); + assertTrue(TestEnum.class.isEnum()); + } + + public void test_isLocalClass() { + assertFalse(ExtendTestClass.class.isLocalClass()); + assertFalse(TestInterface.class.isLocalClass()); + assertFalse(TestEnum.class.isLocalClass()); + class InternalClass {} + assertTrue(InternalClass.class.isLocalClass()); + } + + public void test_isMemberClass() { + assertFalse(OldClassTest.class.isMemberClass()); + assertFalse(String.class.isMemberClass()); + assertTrue(TestEnum.class.isMemberClass()); + assertTrue(StaticMember$Class.class.isMemberClass()); + } + + public void test_isSynthetic() { + assertFalse("Returned true for non synthetic class.", + ExtendTestClass.class.isSynthetic()); + assertFalse("Returned true for non synthetic class.", + TestInterface.class.isSynthetic()); + assertFalse("Returned true for non synthetic class.", + String.class.isSynthetic()); + } + + public void test_getCanonicalName() { + Class [] classArray = { int.class, int[].class, String.class, + PublicTestClass.class, TestInterface.class, + ExtendTestClass.class }; + String [] classNames = {"int", "int[]", "java.lang.String", + "libcore.java.lang.OldClassTest.PublicTestClass", + "libcore.java.lang.OldClassTest.TestInterface", + "libcore.java.lang.OldClassTest.ExtendTestClass"}; + + for(int i = 0; i < classArray.length; i++) { + assertEquals(classNames[i], classArray[i].getCanonicalName()); + } + } + + public void test_getClassLoader() { + assertEquals(ExtendTestClass.class.getClassLoader(), + PublicTestClass.class.getClassLoader()); + + assertNull(int.class.getClassLoader()); + assertNull(void.class.getClassLoader()); + } + + public void test_getClasses() { + assertEquals("Incorrect class array returned", + 11, OldClassTest.class.getClasses().length); + } + + public void test_getDeclaredClasses() { + Class [] declClasses = Object.class.getDeclaredClasses(); + assertEquals("Incorrect length of declared classes array is returned " + + "for Object.", 0, declClasses.length); + + declClasses = PublicTestClass.class.getDeclaredClasses(); + assertEquals(2, declClasses.length); + + assertEquals(0, int.class.getDeclaredClasses().length); + assertEquals(0, void.class.getDeclaredClasses().length); + + for(int i = 0; i < declClasses.length; i++) { + Constructor<?> constr = declClasses[i].getDeclaredConstructors()[0]; + constr.setAccessible(true); + PublicTestClass publicClazz = new PublicTestClass(); + try { + Object o = constr.newInstance(publicClazz); + assertTrue("Returned incorrect class: " + o.toString(), + o.toString().startsWith("PrivateClass")); + } catch(Exception e) { + fail("Unexpected exception was thrown: " + e.toString()); + } + } + + declClasses = TestInterface.class.getDeclaredClasses(); + assertEquals(0, declClasses.length); + } + + public void test_getDeclaredConstructor$Ljava_lang_Class() throws Exception { + try { + TestClass.class.getDeclaredConstructor(String.class); + fail("NoSuchMethodException should be thrown."); + } catch(NoSuchMethodException nsme) { + //expected + } + } + + public void test_getDeclaredFieldLjava_lang_String() throws Exception { + try { + TestClass.class.getDeclaredField(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + TestClass.class.getDeclaredField("NonExistentField"); + fail("NoSuchFieldException is not thrown."); + } catch(NoSuchFieldException nsfe) { + //expected + } + } + + public void test_getDeclaredMethodLjava_lang_String$Ljava_lang_Class() throws Exception { + try { + TestClass.class.getDeclaredMethod(null, new Class[0]); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + TestClass.class.getDeclaredMethod("NonExistentMethod", new Class[0]); + fail("NoSuchMethodException is not thrown."); + } catch(NoSuchMethodException nsme) { + //expected + } + } + + public void test_getMethodLjava_lang_String$Ljava_lang_Class() throws Exception { + Method m = ExtendTestClass1.class.getMethod("getCount", new Class[0]); + assertEquals("Returned incorrect method", 0, ((Integer) (m.invoke(new ExtendTestClass1()))) + .intValue()); + + try { + m = TestClass.class.getMethod("init", new Class[0]); + fail("Failed to throw exception accessing to init method"); + } catch (NoSuchMethodException e) { + // Correct + return; + } + + try { + TestClass.class.getMethod("pubMethod", new Class[0]); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_getDeclaringClass() { + assertNull(OldClassTest.class.getDeclaringClass()); + assertNotNull(PublicTestClass.class.getDeclaringClass()); + } + + public void test_getFieldLjava_lang_String() throws Exception { + Field f = TestClass.class.getField("pubField"); + assertEquals("Returned incorrect field", 2, f.getInt(new TestClass())); + + f = PublicTestClass.class.getField("TEST_FIELD"); + assertEquals("Returned incorrect field", "test field", + f.get(new PublicTestClass())); + + f = PublicTestClass.class.getField("TEST_INTERFACE_FIELD"); + assertEquals("Returned incorrect field", 0, + f.getInt(new PublicTestClass())); + + try { + TestClass.class.getField(null); + fail("NullPointerException is thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_getFields2() throws Exception { + Field[] f; + Field expected = null; + + f = PublicTestClass.class.getFields(); + assertEquals("Test 1: Incorrect number of fields;", 2, f.length); + + f = Cls2.class.getFields(); + assertEquals("Test 2: Incorrect number of fields;", 6, f.length); + + f = Cls3.class.getFields(); + assertEquals("Test 2: Incorrect number of fields;", 5, f.length); + + for (Field field : f) { + if (field.toString().equals("public static final int " + + "libcore.java.lang.OldClassTest$Intf3.field1")) { + expected = field; + break; + } + } + if (expected == null) { + fail("Test 3: getFields() did not return all fields."); + } + assertEquals("Test 4: Incorrect field;", expected, + Cls3.class.getField("field1")); + + expected = null; + for (Field field : f) { + if(field.toString().equals("public static final int " + + "libcore.java.lang.OldClassTest$Intf1.field2")) { + expected = field; + break; + } + } + if (expected == null) { + fail("Test 5: getFields() did not return all fields."); + } + assertEquals("Test 6: Incorrect field;", expected, + Cls3.class.getField("field2")); + } + + public void test_getFields() throws Exception { + Field expected = null; + Field[] fields = Cls2.class.getFields(); + for (Field field : fields) { + if(field.toString().equals("public int libcore.java.lang.OldClassTest$Cls2.field1")) { + expected = field; + break; + } + } + if (expected == null) { + fail("getFields() did not return all fields"); + } + assertEquals(expected, Cls2.class.getField("field1")); + } + + public void test_getInterfaces() { + Class [] interfaces1 = Cls1.class.getInterfaces(); + assertEquals(1, interfaces1.length); + assertEquals(Intf2.class, interfaces1[0]); + + Class [] interfaces2 = Cls2.class.getInterfaces(); + assertEquals(1, interfaces2.length); + assertEquals(Intf1.class, interfaces2[0]); + + Class [] interfaces3 = Cls3.class.getInterfaces(); + assertEquals(2, interfaces3.length); + assertEquals(Intf3.class, interfaces3[0]); + assertEquals(Intf4.class, interfaces3[1]); + + Class [] interfaces4 = Cls4.class.getInterfaces(); + assertEquals(0, interfaces4.length); + } + + public void test_getMethods() throws Exception { + assertEquals("Incorrect number of methods", 10, + Cls2.class.getMethods().length); + assertEquals("Incorrect number of methods", 11, + Cls3.class.getMethods().length); + + Method expected = null; + Method[] methods = Cls2.class.getMethods(); + for (Method method : methods) { + if(method.toString().equals("public void libcore.java.lang.OldClassTest$Cls2.test()")) { + expected = method; + break; + } + } + if (expected == null) { + fail("getMethods() did not return all methods"); + } + assertEquals(expected, Cls2.class.getMethod("test")); + + expected = null; + methods = Cls3.class.getMethods(); + for (Method method : methods) { + if(method.toString().equals("public void libcore.java.lang.OldClassTest$Cls3.test()")) { + expected = method; + break; + } + } + if (expected == null) { + fail("getMethods() did not return all methods"); + } + assertEquals(expected, Cls3.class.getMethod("test")); + + expected = null; + methods = Cls3.class.getMethods(); + for (Method method : methods) { + if(method.toString().equals("public void libcore.java.lang.OldClassTest$Cls3.test2(int," + + "java.lang.Object)")) { + expected = method; + break; + } + } + if (expected == null) { + fail("getMethods() did not return all methods"); + } + + assertEquals(expected, Cls3.class.getMethod("test2", int.class, + Object.class)); + + assertEquals("Incorrect number of methods", 1, + Intf5.class.getMethods().length); + } + + public void test_getResourceLjava_lang_String() { + assertNull(getClass().getResource( + "libcore/java/lang/NonExistentResource")); + assertNull(getClass().getResource(getClass().getName() + "NonExistentResource")); + } + + public void test_getResourceAsStreamLjava_lang_String() throws Exception { + String name = "/HelloWorld.txt"; + assertNotNull("the file " + name + " can not be found in this " + + "directory", getClass().getResourceAsStream(name)); + + final String nameBadURI = "org/apache/harmony/luni/tests/test_resource.txt"; + assertNull("the file " + nameBadURI + " should not be found in this directory", + getClass().getResourceAsStream(nameBadURI)); + + ClassLoader pcl = getClass().getClassLoader(); + Class<?> clazz = pcl.loadClass("libcore.java.lang.OldClassTest"); + assertNotNull(clazz.getResourceAsStream("HelloWorld1.txt")); + + try { + getClass().getResourceAsStream(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_isAssignableFromLjava_lang_Class() { + assertFalse("returned true not assignable classes", + Integer.class.isAssignableFrom(String.class)); + + try { + Runnable.class.isAssignableFrom(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_newInstance() throws Exception { + try { + TestClass3.class.newInstance(); + fail("IllegalAccessException is not thrown."); + } catch(IllegalAccessException iae) { + //expected + } + + try { + TestClass1C.class.newInstance(); + fail("ExceptionInInitializerError should be thrown."); + } catch (java.lang.ExceptionInInitializerError ie) { + //expected + } + } + + public void test_asSubclass1() { + assertEquals(ExtendTestClass.class, + ExtendTestClass.class.asSubclass(PublicTestClass.class)); + + assertEquals(PublicTestClass.class, + PublicTestClass.class.asSubclass(TestInterface.class)); + + assertEquals(ExtendTestClass1.class, + ExtendTestClass1.class.asSubclass(PublicTestClass.class)); + + assertEquals(PublicTestClass.class, + PublicTestClass.class.asSubclass(PublicTestClass.class)); + } + + public void test_asSubclass2() { + try { + PublicTestClass.class.asSubclass(ExtendTestClass.class); + fail("Test 1: ClassCastException expected."); + } catch(ClassCastException cce) { + // Expected. + } + + try { + PublicTestClass.class.asSubclass(String.class); + fail("Test 2: ClassCastException expected."); + } catch(ClassCastException cce) { + // Expected. + } + } + + public void test_cast() { + Object o = PublicTestClass.class.cast(new ExtendTestClass()); + assertTrue(o instanceof ExtendTestClass); + + try { + ExtendTestClass.class.cast(new PublicTestClass()); + fail("Test 1: ClassCastException expected."); + } catch(ClassCastException cce) { + //expected + } + + try { + ExtendTestClass.class.cast(new String()); + fail("ClassCastException is not thrown."); + } catch(ClassCastException cce) { + //expected + } + } + + public void test_desiredAssertionStatus() { + Class [] classArray = { Object.class, Integer.class, + String.class, PublicTestClass.class, + ExtendTestClass.class, ExtendTestClass1.class}; + + for(int i = 0; i < classArray.length; i++) { + assertFalse("assertion status for " + classArray[i], + classArray[i].desiredAssertionStatus()); + } + } + + public void testGetResourceAsStream1() throws IOException { + Class clazz = getClass(); + + InputStream stream = clazz.getResourceAsStream("HelloWorld.txt"); + assert(stream != null); + + byte[] buffer = new byte[20]; + int length = stream.read(buffer); + String s = new String(buffer, 0, length); + assert("Hello, World.".equals(s)); + + stream.close(); + } + + public void testGetResourceAsStream2() throws IOException { + Class clazz = getClass(); + + InputStream stream = clazz.getResourceAsStream("/libcore/java/lang/HelloWorld.txt"); + assert(stream != null); + + byte[] buffer = new byte[20]; + int length = stream.read(buffer); + String s = new String(buffer, 0, length); + assert("Hello, World.".equals(s)); + + stream.close(); + + try { + clazz.getResourceAsStream(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + assertNull(clazz.getResourceAsStream("/NonExistentResource")); + assertNull(clazz.getResourceAsStream("libcore/java/lang/HelloWorld.txt")); + } +} diff --git a/luni/src/test/java/libcore/java/lang/OldDoubleTest.java b/luni/src/test/java/libcore/java/lang/OldDoubleTest.java new file mode 100644 index 0000000..dacb521 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldDoubleTest.java @@ -0,0 +1,79 @@ +/* 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 libcore.java.lang; + +import junit.framework.TestCase; + +public class OldDoubleTest extends TestCase { + + public void test_byteValue() { + Double d = new Double(Byte.MAX_VALUE); + assertEquals("Returned incorrect byte value", Byte.MAX_VALUE, d.byteValue()); + d= new Double(Byte.MIN_VALUE); + assertEquals("Returned incorrect byte value", Byte.MIN_VALUE, d.byteValue()); + d= new Double(Double.MAX_VALUE); + assertEquals("Returned incorrect byte value", -1, d.byteValue()); + } + + public void test_doubleToLongBitsD() { + assertEquals(0x7ff8000000000000L, Double.doubleToLongBits(Double.NaN)); + assertEquals(0x7ff0000000000000L, Double.doubleToLongBits(Double.POSITIVE_INFINITY)); + assertEquals(0xfff0000000000000L, Double.doubleToLongBits(Double.NEGATIVE_INFINITY)); + } + + public void test_doubleToRawLongBitsD() { + assertEquals(0x7ff8000000000000L, Double.doubleToLongBits(Double.NaN)); + assertEquals(0x7ff0000000000000L, Double.doubleToLongBits(Double.POSITIVE_INFINITY)); + assertEquals(0xfff0000000000000L, Double.doubleToLongBits(Double.NEGATIVE_INFINITY)); + } + + public void test_doubleValue() { + assertEquals(Double.POSITIVE_INFINITY, new Double("1.7976931348623159E308").doubleValue()); + assertEquals(Double.NEGATIVE_INFINITY, new Double("-1.7976931348623159E308").doubleValue()); + assertEquals(Double.MAX_VALUE, new Double("1.7976931348623157E308").doubleValue()); + assertEquals(Double.MIN_VALUE, new Double("4.9E-324").doubleValue()); + } + + public void test_floatValue() { + assertEquals(Float.POSITIVE_INFINITY, new Double("3.4028236E38").floatValue()); + assertEquals(Float.NEGATIVE_INFINITY, new Double("-3.4028236E38").floatValue()); + assertEquals(Float.MAX_VALUE, new Double("3.4028235E38").floatValue()); + assertEquals(Float.MIN_VALUE, new Double("1.4E-45").floatValue()); + } + + public void test_intValue() { + assertEquals("Returned incorrect int value", Integer.MAX_VALUE, + new Double(2147483648d).intValue()); + assertEquals("Returned incorrect int value", Integer.MIN_VALUE, + new Double(-2147483649d).intValue()); + } + + public void test_isNaND() { + assertFalse("Doesn't return false value", Double.isNaN(new Double(Double.MAX_VALUE))); + } + + // Regression test for hotfix in native code of double parser. + public void test_parseDouble_LString_AndroidRegression() { + // Android regression test + long startTime = System.currentTimeMillis(); + double actual = Double.parseDouble("9e551027"); + assertTrue("parsing double 9e551027 took too long.", + (System.currentTimeMillis() - startTime) < 1000); + assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, + actual, 0.0D); + } +} diff --git a/luni/src/test/java/libcore/java/lang/OldFloatTest.java b/luni/src/test/java/libcore/java/lang/OldFloatTest.java new file mode 100644 index 0000000..1bbac12 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldFloatTest.java @@ -0,0 +1,92 @@ +/* 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 libcore.java.lang; + +import junit.framework.TestCase; + +public class OldFloatTest extends TestCase { + + public void test_ConstructorLjava_lang_String() { + try { + new Float("900.89ff"); + fail("NumberFormatException is not thrown."); + } catch(NumberFormatException nfe) { + //expected + } + } + + public void test_ConstructorD() { + Float f = new Float(Double.MAX_VALUE); + assertTrue("Created incorrect float", f.floatValue() == Float.POSITIVE_INFINITY); + } + + public void test_parseFloatLExceptions() { + String [] incorrectStrings = {"", ";", "99999999EE999999", "99999l", + "0x1.f.ffffep127"}; + for(int i = 0; i < incorrectStrings.length; i++) { + try { + Float.parseFloat(incorrectStrings[i]); + fail("NumberFormatException is not thrown for string: " + + incorrectStrings[i]); + } catch(NumberFormatException nfe) { + //expected + } + } + } + + public void test_floatToIntBitsF() { + assertEquals(0x7f800000, Float.floatToIntBits(Float.POSITIVE_INFINITY)); + assertEquals(0xff800000, Float.floatToIntBits(Float.NEGATIVE_INFINITY)); + assertEquals(0x7fc00000, Float.floatToIntBits(Float.NaN)); + } + + public void test_floatToRawIntBitsF() { + assertEquals(0x7f800000, Float.floatToRawIntBits(Float.POSITIVE_INFINITY)); + assertEquals(0xff800000, Float.floatToRawIntBits(Float.NEGATIVE_INFINITY)); + assertEquals(0x7fc00000, Float.floatToRawIntBits(Float.NaN)); + } + + public void test_hashCode() { + assertTrue(new Float(Float.MAX_VALUE).hashCode() != new Float(Float.MIN_VALUE).hashCode()); + } + + public void test_intBitsToFloatI() { + assertEquals(Float.POSITIVE_INFINITY, Float.intBitsToFloat(0x7f800000)); + assertEquals(Float.NEGATIVE_INFINITY, Float.intBitsToFloat(0xff800000)); + + assertEquals(Float.NaN, Float.intBitsToFloat(0x7f800001)); + assertEquals(Float.NaN, Float.intBitsToFloat(0x7fffffff)); + assertEquals(Float.NaN, Float.intBitsToFloat(0xff800001)); + assertEquals(Float.NaN, Float.intBitsToFloat(0xffffffff)); + } + + public void test_intValue() { + assertEquals(Integer.MAX_VALUE, new Float(Float.MAX_VALUE).intValue()); + assertEquals(0, new Float(Float.MIN_VALUE).intValue()); + } + + public void test_isNaNF() { + assertFalse(Float.isNaN(12.09f)); + assertFalse(Float.isNaN(Float.MAX_VALUE)); + assertFalse(Float.isNaN(Float.MIN_VALUE)); + } + + public void test_longValue() { + assertEquals(Long.MAX_VALUE, new Float(Float.MAX_VALUE).longValue()); + assertEquals(0, new Float(Float.MIN_VALUE).longValue()); + } +} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InheritableThreadLocalTest.java b/luni/src/test/java/libcore/java/lang/OldInheritableThreadLocalTest.java index 752aaec..dd9b9f4 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InheritableThreadLocalTest.java +++ b/luni/src/test/java/libcore/java/lang/OldInheritableThreadLocalTest.java @@ -15,52 +15,40 @@ * 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; +package libcore.java.lang; import junit.framework.TestCase; -@TestTargetClass(InheritableThreadLocal.class) -public class InheritableThreadLocalTest extends TestCase { +public class OldInheritableThreadLocalTest extends TestCase { - /** - * @tests java.lang.InheritableThreadLocal#InheritableThreadLocal() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "InheritableThreadLocal", - args = {} - ) - public void test_Constructor() { - InheritableThreadLocal<String> itl = new InheritableThreadLocal<String>(); - assertNull(itl.get()); - } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "initialValue", - args = {} - ) - public void test_initialValue() { - InheritableThreadLocal<String> itl = new InheritableThreadLocal<String>() { + public void test_Ljava_lang_InheritableThreadLocal() + throws InterruptedException { + final Object value = new Object(); + final Object inheritedValue = new Object(); + final ThreadLocal<Object> threadLocal + = new InheritableThreadLocal<Object>() { @Override - protected String initialValue() { - return "initial"; + protected Object childValue(Object parentValue) { + assertSame(value, parentValue); + return inheritedValue; } }; - assertEquals("initial", itl.get()); + threadLocal.set(value); + final Object[] holder = new Object[1]; + Thread thread = new Thread() { + public void run() { + holder[0] = threadLocal.get(); + } + }; + thread.start(); + thread.join(); + assertSame(value, threadLocal.get()); + assertSame(inheritedValue, holder[0]); + + // Cleanup properly, so other tests are not affected. + threadLocal.remove(); } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "childValue", - args = {java.lang.Object.class} - ) + public void test_childValue() { InheritableThreadLocal<String> itl = new InheritableThreadLocal<String>() { @Override diff --git a/luni/src/test/java/libcore/java/lang/OldIntegerTest.java b/luni/src/test/java/libcore/java/lang/OldIntegerTest.java new file mode 100644 index 0000000..462ee19 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldIntegerTest.java @@ -0,0 +1,69 @@ +/* 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 libcore.java.lang; + +import java.util.Properties; +import junit.framework.TestCase; + +public class OldIntegerTest extends TestCase { + private Properties orgProps; + + @Override + protected void setUp() { + orgProps = System.getProperties(); + } + + @Override + protected void tearDown() { + System.setProperties(orgProps); + } + + public void test_getIntegerLjava_lang_StringI() { + // Test for method java.lang.Integer + // java.lang.Integer.getInteger(java.lang.String, int) + Properties tProps = new Properties(); + tProps.put("testIncInt", "notInt"); + System.setProperties(tProps); + assertTrue("returned incorrect default Integer", Integer.getInteger( + "testIncInt", 4).equals(new Integer(4))); + } + + public void test_getIntegerLjava_lang_StringLjava_lang_Integer() { + // Test for method java.lang.Integer + // java.lang.Integer.getInteger(java.lang.String, java.lang.Integer) + Properties tProps = new Properties(); + tProps.put("testIncInt", "notInt"); + System.setProperties(tProps); + assertTrue("returned incorrect default Integer", Integer.getInteger( + "testIncInt", new Integer(4)).equals(new Integer(4))); + } + + public void test_intValue() { + assertEquals(Integer.MAX_VALUE, new Integer(Integer.MAX_VALUE).intValue()); + assertEquals(Integer.MIN_VALUE, new Integer(Integer.MIN_VALUE).intValue()); + } + + public void test_longValue() { + assertEquals(Integer.MAX_VALUE, new Integer(Integer.MAX_VALUE).longValue()); + assertEquals(Integer.MIN_VALUE, new Integer(Integer.MIN_VALUE).longValue()); + } + + public void test_shortValue() { + assertEquals(-1, new Integer(Integer.MAX_VALUE).shortValue()); + assertEquals(0, new Integer(Integer.MIN_VALUE).shortValue()); + } +} diff --git a/luni/src/test/java/libcore/java/lang/OldLongTest.java b/luni/src/test/java/libcore/java/lang/OldLongTest.java new file mode 100644 index 0000000..6fb7d49 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldLongTest.java @@ -0,0 +1,83 @@ +/* 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 libcore.java.lang; + +import java.util.Properties; +import junit.framework.TestCase; + +public class OldLongTest extends TestCase { + private Properties orgProps; + + @Override + protected void setUp() { + orgProps = System.getProperties(); + } + + @Override + protected void tearDown() { + System.setProperties(orgProps); + } + + public void test_getLongLjava_lang_String() { + Properties tProps = new Properties(); + tProps.put("testLong", "99"); + tProps.put("testIncLong", "string"); + System.setProperties(tProps); + assertNull("returned incorrect default Long", + Long.getLong("testIncLong")); + } + + 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("testIncLong", "string"); + System.setProperties(tProps); + assertTrue("returned incorrect default Long", Long.getLong("testIncLong", 4L) + .equals(new Long(4))); + } + + 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("testIncLong", "string"); + System.setProperties(tProps); + assertTrue("returned incorrect default Long", Long.getLong("testIncLong", + new Long(4)).equals(new Long(4))); + } + + public void test_floatValue() { + assertEquals(Long.MAX_VALUE, new Long(Long.MAX_VALUE).floatValue(), 0F); + assertEquals(Long.MIN_VALUE, new Long(Long.MIN_VALUE).floatValue(), 0F); + } + + public void test_intValue() { + assertEquals(-1, new Long(Long.MAX_VALUE).intValue()); + assertEquals(0, new Long(Long.MIN_VALUE).intValue()); + } + + public void test_longValue() { + assertEquals(Long.MAX_VALUE, new Long(Long.MAX_VALUE).longValue()); + assertEquals(Long.MIN_VALUE, new Long(Long.MIN_VALUE).longValue()); + } + + public void test_shortValue() { + assertEquals(-1, new Long(Long.MAX_VALUE).shortValue()); + assertEquals(0, new Long(Long.MIN_VALUE).shortValue()); + } +} diff --git a/luni/src/test/java/libcore/java/lang/OldObjectTest.java b/luni/src/test/java/libcore/java/lang/OldObjectTest.java new file mode 100644 index 0000000..dd0e217 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldObjectTest.java @@ -0,0 +1,250 @@ +/* + * 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 libcore.java.lang; + +import dalvik.annotation.SideEffect; +import java.util.Vector; +import junit.framework.TestCase; + +public class OldObjectTest extends TestCase { + + public boolean isCalled = false; + + /** + * Test objects. + */ + Object obj1 = new Object(); + + /** + * Generic state indicator. + */ + int status = 0; + + int ready = 0; + TestThread1 thr1; + TestThread2 thr2; + + + @SideEffect("Causes OutOfMemoryError to test finalization") + public void test_finalize() { + isCalled = false; + class TestObject extends Object { + + Vector<StringBuffer> v = new Vector<StringBuffer>(); + public void add() { + v.add(new StringBuffer(10000)); + } + + protected void finalize() throws Throwable { + isCalled = true; + super.finalize(); + } + } + + TestObject to = new TestObject(); + + try { + while(true) { + to.add(); + } + } catch(OutOfMemoryError oome) { + //expected + to = null; + } + System.gc(); + System.runFinalization(); + assertTrue(isCalled); + } + + public void test_clone() { + MockCloneableObject mco = new MockCloneableObject(); + try { + assertFalse(mco.equals(mco.clone())); + assertEquals(mco.getClass(), mco.clone().getClass()); + } catch(CloneNotSupportedException cnse) { + fail("CloneNotSupportedException was thrown."); + } + + MockObject mo = new MockObject(); + try { + mo.clone(); + fail("CloneNotSupportedException was not thrown."); + } catch(CloneNotSupportedException cnse) { + //expected + } + } + + class MockCloneableObject extends Object implements Cloneable { + public Object clone() throws CloneNotSupportedException { + return super.clone(); + } + } + + class MockObject extends Object { + + boolean isCalled = false; + + public void finalize() throws Throwable { + super.finalize(); + isCalled = true; + } + + public Object clone() throws CloneNotSupportedException { + return super.clone(); + } + } + + public void test_notify() { + try { + Object obj = new Object(); + obj.notify(); + fail("IllegalMonitorStateException was not thrown."); + } catch(IllegalMonitorStateException imse) { + //expected + } + } + + public void test_notifyAll() { + try { + Object obj = new Object(); + obj.notifyAll(); + fail("IllegalMonitorStateException was not thrown."); + } catch(IllegalMonitorStateException imse) { + //expected + } + } + + public void test_wait() { + + try { + Object obj = new Object(); + obj.wait(); + fail("IllegalMonitorStateException was not thrown."); + } catch(IllegalMonitorStateException imse) { + //expected + } catch(InterruptedException ex) { + fail("InterruptedException was thrown."); + } + + try { + thr1 = new TestThread1(TestThread1.CASE_WAIT); + thr2 = new TestThread2(); + thr1.start(); + thr2.start(); + thr2.join(); + thr1.join(); + thr1 = null; + thr2 = null; + } catch(InterruptedException e) { + fail("InterruptedException was thrown."); + } + assertEquals(3, status); + } + + class TestThread1 extends Thread { + + static final int CASE_WAIT = 0; + static final int CASE_WAIT_LONG = 1; + static final int CASE_WAIT_LONG_INT = 2; + + int testCase = CASE_WAIT; + + public TestThread1(int option) { + testCase = option; + } + + public void run() { + synchronized (obj1) { + try { + switch(testCase) { + case CASE_WAIT: + obj1.wait();// Wait for ever. + break; + case CASE_WAIT_LONG: + obj1.wait(5000L); + break; + case CASE_WAIT_LONG_INT: + obj1.wait(10000L, 999999); + break; + } + + } catch (InterruptedException ex) { + status = 3; + } + } + } + } + + class TestThread2 extends Thread { + public void run() { + thr1.interrupt(); + } + } + + public void test_waitJI() { + try { + Object obj = new Object(); + obj.wait(5000L, 1); + fail("IllegalMonitorStateException was not thrown."); + } catch(IllegalMonitorStateException imse) { + //expected + } catch(InterruptedException ex) { + fail("InterruptedException was thrown."); + } + + try { + thr1 = new TestThread1(TestThread1.CASE_WAIT_LONG_INT); + thr2 = new TestThread2(); + thr1.start(); + thr2.start(); + thr2.join(); + thr1.join(); + thr1 = null; + thr2 = null; + } catch(InterruptedException e) { + fail("InterruptedException was thrown."); + } + assertEquals(3, status); + + } + + public void test_waitJ() { + try { + Object obj = new Object(); + obj.wait(5000L); + fail("IllegalMonitorStateException was not thrown."); + } catch(IllegalMonitorStateException imse) { + //expected + } catch(InterruptedException ex) { + fail("InterruptedException was thrown."); + } + + try { + thr1 = new TestThread1(TestThread1.CASE_WAIT_LONG); + thr2 = new TestThread2(); + thr1.start(); + thr2.start(); + thr2.join(); + thr1.join(); + thr1 = null; + thr2 = null; + } catch(InterruptedException e) { + fail("InterruptedException was thrown."); + } + assertEquals(3, status); + } +} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimeExceptionTest.java b/luni/src/test/java/libcore/java/lang/OldRuntimeExceptionTest.java index 94e01ed..8004124 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimeExceptionTest.java +++ b/luni/src/test/java/libcore/java/lang/OldRuntimeExceptionTest.java @@ -15,55 +15,12 @@ * 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; +package libcore.java.lang; import junit.framework.TestCase; -@TestTargetClass(RuntimeException.class) -public class RuntimeExceptionTest extends TestCase { - - /** - * @tests java.lang.RuntimeException#RuntimeException() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "RuntimeException", - args = {} - ) - public void test_Constructor() { - RuntimeException e = new RuntimeException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.RuntimeException#RuntimeException(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "RuntimeException", - args = {java.lang.String.class} - ) - public void test_ConstructorLjava_lang_String() { - RuntimeException e = new RuntimeException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } +public class OldRuntimeExceptionTest extends TestCase { - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "RuntimeException", - args = {java.lang.String.class, java.lang.Throwable.class} - ) public void test_ConstructorLStringLThrowable() { String message = "Test message"; NullPointerException npe = new NullPointerException(); @@ -78,12 +35,6 @@ public class RuntimeExceptionTest extends TestCase { assertNull(re.getCause()); } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "RuntimeException", - args = {java.lang.Throwable.class} - ) public void test_ConstructorLThrowable() { NullPointerException npe = new NullPointerException(); RuntimeException re = new RuntimeException(npe); diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimeTest.java b/luni/src/test/java/libcore/java/lang/OldRuntimeTest.java index f276ec7..4b692d7 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimeTest.java +++ b/luni/src/test/java/libcore/java/lang/OldRuntimeTest.java @@ -15,94 +15,26 @@ * limitations under the License. */ -package org.apache.harmony.luni.tests.java.lang; +package libcore.java.lang; import dalvik.annotation.KnownFailure; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargetClass; - import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; -import java.io.UnsupportedEncodingException; import java.security.Permission; import java.util.Arrays; import java.util.Vector; - import tests.support.resource.Support_Resources; -@TestTargetClass(Runtime.class) -public class RuntimeTest extends junit.framework.TestCase { +public class OldRuntimeTest extends junit.framework.TestCase { Runtime r = Runtime.getRuntime(); InputStream is; - String s; - - static boolean flag = false; - - static boolean ranFinalize = false; - - int statusCode = -1; - - class HasFinalizer { - String internalString; - - HasFinalizer(String s) { - internalString = s; - } - - @Override - protected void finalize() { - internalString = "hit"; - } - } - - @Override - protected void finalize() { - if (flag) - ranFinalize = true; - } - - protected RuntimeTest createInstance() { - return new RuntimeTest("FT"); - } - - @Override protected void tearDown() throws Exception { - super.tearDown(); - } - - /** - * @tests java.lang.Runtime#exec(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.ADDITIONAL, - notes = "", - method = "exec", - args = {java.lang.String.class} - ) - public void test_exec() { - /* successful exec's are tested by java.lang.Process */ - try { - Runtime.getRuntime().exec("AnInexistentProgram"); - fail("failed to throw IOException when exec'ed inexistent program"); - } catch (IOException e) { /* expected */ } - } - - /** - * @tests java.lang.Runtime#freeMemory() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "freeMemory", - args = {} - ) public void test_freeMemory() { // Heap might grow or do GC at any time, // so we can't really test a lot. Hence @@ -125,97 +57,11 @@ public class RuntimeTest extends junit.framework.TestCase { after != before); } - /** - * @tests java.lang.Runtime#gc() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "gc", - args = {} - ) - public void test_gc() { - // Test for method void java.lang.Runtime.gc() - try { - r.gc(); // ensure all garbage objects have been collected - r.gc(); // two GCs force collection phase to complete - long firstRead = r.totalMemory() - r.freeMemory(); - Vector<StringBuffer> v = new Vector<StringBuffer>(); - for (int i = 1; i < 10; i++) - v.addElement(new StringBuffer(10000)); - long secondRead = r.totalMemory() - r.freeMemory(); - v = null; - r.gc(); - r.gc(); - assertTrue("object memory did not grow", secondRead > firstRead); - assertTrue("space was not reclaimed", (r.totalMemory() - r - .freeMemory()) < secondRead); - } catch (Throwable t) { - System.out.println("Out of memory during gc test"); - r.gc(); - r.gc(); - } - } - - /** - * @tests java.lang.Runtime#getRuntime() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "getRuntime method is verified in initial setup for other tests.", - method = "getRuntime", - args = {} - ) public void test_getRuntime() { // Test for method java.lang.Runtime java.lang.Runtime.getRuntime() assertNotNull(Runtime.getRuntime()); } - /** - * @tests java.lang.Runtime#runFinalization() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "runFinalization", - args = {} - ) - public void test_runFinalization() { - // Test for method void java.lang.Runtime.runFinalization() - - flag = true; - createInstance(); - int count = 10; - // the gc below likely bogosifies the test, but will have to do for - // the moment - while (!ranFinalize && count-- > 0) { - r.gc(); - r.runFinalization(); - } - assertTrue("Failed to run finalization", ranFinalize); - } - - /** - * @tests java.lang.Runtime#totalMemory() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "totalMemory", - args = {} - ) - public void test_totalMemory() { - // Test for method long java.lang.Runtime.totalMemory() - assertTrue("totalMemory returned nonsense value", r.totalMemory() >= r - .freeMemory()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "addShutdownHook", - args = {java.lang.Thread.class} - ) public void test_addShutdownHook() { Thread thrException = new Thread () { public void run() { @@ -260,24 +106,12 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "availableProcessors", - args = {} - ) public void test_availableProcessors() { assertTrue(Runtime.getRuntime().availableProcessors() > 0); } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "exec", - args = {java.lang.String.class, java.lang.String[].class} - ) - public void test_execLjava_lang_StringLjava_lang_StringArray() { + public void test_execLjava_lang_StringLjava_lang_StringArray() { String [] envp = getEnv(); checkExec(0, envp, null); @@ -315,12 +149,6 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "exec", - args = {java.lang.String[].class, java.lang.String[].class} - ) public void test_execLjava_lang_StringArrayLjava_lang_StringArray() { String [] envp = getEnv(); @@ -373,12 +201,6 @@ public class RuntimeTest extends junit.framework.TestCase { } catch (IOException e) { /* expected */ } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "exec", - args = {java.lang.String.class, java.lang.String[].class, java.io.File.class} - ) public void test_execLjava_lang_StringLjava_lang_StringArrayLjava_io_File() { String [] envp = getEnv(); @@ -420,12 +242,6 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "exec", - args = {java.lang.String[].class, java.lang.String[].class, java.io.File.class} - ) public void test_execLjava_lang_StringArrayLjava_lang_StringArrayLjava_io_File() { String [] envp = getEnv(); @@ -530,12 +346,6 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "exec", - args = {java.lang.String.class} - ) public void test_execLjava_lang_String() { checkExec(1, null, null); @@ -558,12 +368,6 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "exec", - args = {java.lang.String[].class} - ) public void test_execLjava_lang_StringArray() { checkExec(3, null, null); @@ -603,22 +407,10 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "runFinalizersOnExit", - args = {boolean.class} - ) public void test_runFinalizersOnExit() { Runtime.getRuntime().runFinalizersOnExit(true); } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "removeShutdownHook", - args = {java.lang.Thread.class} - ) public void test_removeShutdownHookLjava_lang_Thread() { Thread thr1 = new Thread () { public void run() { @@ -660,34 +452,16 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "maxMemory", - args = {} - ) public void test_maxMemory() { assertTrue(Runtime.getRuntime().maxMemory() < Long.MAX_VALUE); } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "traceInstructions", - args = {boolean.class} - ) public void test_traceInstructions() { Runtime.getRuntime().traceInstructions(false); Runtime.getRuntime().traceInstructions(true); Runtime.getRuntime().traceInstructions(false); } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "traceMethodCalls", - args = {boolean.class} - ) @KnownFailure("Fails in CTS but passes under run-core-tests") public void test_traceMethodCalls() { try { @@ -705,12 +479,6 @@ public class RuntimeTest extends junit.framework.TestCase { } @SuppressWarnings("deprecation") - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getLocalizedInputStream", - args = {java.io.InputStream.class} - ) public void test_getLocalizedInputStream() throws Exception { String simpleString = "Heart \u2f3c"; byte[] expected = simpleString.getBytes("UTF-8"); @@ -728,12 +496,6 @@ public class RuntimeTest extends junit.framework.TestCase { } @SuppressWarnings("deprecation") - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "", - method = "getLocalizedOutputStream", - args = {java.io.OutputStream.class} - ) public void test_getLocalizedOutputStream() throws IOException { String simpleString = "Heart \u2f3c"; byte[] expected = simpleString.getBytes("UTF-8"); @@ -754,14 +516,7 @@ public class RuntimeTest extends junit.framework.TestCase { } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "load", - args = {java.lang.String.class} - ) public void test_load() { - try { Runtime.getRuntime().load("nonExistentLibrary"); fail("UnsatisfiedLinkError was not thrown."); @@ -777,12 +532,6 @@ public class RuntimeTest extends junit.framework.TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "loadLibrary", - args = {java.lang.String.class} - ) public void test_loadLibrary() { try { Runtime.getRuntime().loadLibrary("nonExistentLibrary"); @@ -798,11 +547,4 @@ public class RuntimeTest extends junit.framework.TestCase { //expected } } - - public RuntimeTest() { - } - - public RuntimeTest(String name) { - super(name); - } } diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackTraceElementTest.java b/luni/src/test/java/libcore/java/lang/OldStackTraceElementTest.java index f095a76..9a09c45 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackTraceElementTest.java +++ b/luni/src/test/java/libcore/java/lang/OldStackTraceElementTest.java @@ -14,22 +14,26 @@ * 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; +package libcore.java.lang; import junit.framework.TestCase; -@TestTargetClass(StackTraceElement.class) -public class StackTraceElementTest extends TestCase { - private StackTraceElementOriginal original; +public class OldStackTraceElementTest extends TestCase { + + public class Original extends TestCase { + + public void pureJavaMethod(Object test) throws Exception { + throw new Exception("pure java method"); + } + + native public void pureNativeMethod(Object test); + } + + private Original original; @Override protected void setUp() throws Exception { - original = new StackTraceElementOriginal(); + original = new Original(); super.setUp(); } @@ -38,21 +42,11 @@ public class StackTraceElementTest extends TestCase { super.tearDown(); } - /** - * @tests java.lang.StackTraceElement#StackTraceElement(java.lang.String, - * java.lang.String, java.lang.String, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "StackTraceElement", - args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, int.class} - ) - public void - test_ConstructorLjava_lang_StringLjava_lang_StringLjava_lang_StringI() { + public void test_ConstructorLjava_lang_StringLjava_lang_StringLjava_lang_StringI() { StackTraceElement ste2 = null; try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { StackTraceElement ste1 = e.getStackTrace()[0]; ste2 = new StackTraceElement(ste1.getClassName(), @@ -97,18 +91,10 @@ public class StackTraceElementTest extends TestCase { } } - /** - * @tests java.lang.StackTraceElement#equals(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) public void test_equalsLjava_lang_Object() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { StackTraceElement ste1 = e.getStackTrace()[0]; StackTraceElement ste2 = @@ -120,82 +106,48 @@ public class StackTraceElementTest extends TestCase { } } - /** - * @tests java.lang.StackTraceElement#getClassName() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getClassName", - args = {} - ) public void test_getClassName() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { assertEquals("Incorrect class name", - getClass().getPackage().getName() + - ".StackTraceElementOriginal", + "libcore.java.lang.OldStackTraceElementTest$Original", e.getStackTrace()[0].getClassName()); assertEquals("Incorrect class name", - getClass().getPackage().getName() + - ".StackTraceElementTest", + "libcore.java.lang.OldStackTraceElementTest", e.getStackTrace()[1].getClassName()); } } - /** - * @tests java.lang.StackTraceElement#getFileName() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getFileName", - args = {} - ) public void test_getFileName() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { assertEquals("Incorrect file name", - "StackTraceElementOriginal.java", + "OldStackTraceElementTest.java", e.getStackTrace()[0].getFileName()); assertEquals("Incorrect file name", - "StackTraceElementTest.java", + "OldStackTraceElementTest.java", e.getStackTrace()[1].getFileName()); } } - /** - * @tests java.lang.StackTraceElement#getLineNumber() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getLineNumber", - args = {} - ) public void test_getLineNumber() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { assertEquals("Incorrect line number", 26, e.getStackTrace()[0].getLineNumber()); } } - /** - * @tests java.lang.StackTraceElement#getMethodName() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMethodName", - args = {} - ) public void test_getMethodName() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { assertEquals("Incorrect method name", "pureJavaMethod", @@ -206,18 +158,10 @@ public class StackTraceElementTest extends TestCase { } } - /** - * @tests java.lang.StackTraceElement#hashCode() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) public void test_hashCode() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { StackTraceElement ste1 = e.getStackTrace()[0]; StackTraceElement ste2 = @@ -232,50 +176,35 @@ public class StackTraceElementTest extends TestCase { } } - /** - * @tests java.lang.StackTraceElement#isNativeMethod() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isNativeMethod", - args = {} - ) public void test_isNativeMethod() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { assertFalse("Incorrect method type", e.getStackTrace()[0].isNativeMethod()); } try { original.pureNativeMethod(new Object()); + fail(); } catch (Error e) { assertTrue("Incorrect method type", e.getStackTrace()[0].isNativeMethod()); } } - /** - * @tests java.lang.StackTraceElement#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) public void test_toString() { try { original.pureJavaMethod(new Object()); + fail(); } catch (Exception e) { StackTraceElement ste = e.getStackTrace()[0]; assertTrue("String representation doesn't contain a package name", ste.toString().contains(getClass().getPackage().getName())); assertTrue("String representation doesn't contain a class name", - ste.toString().contains("StackTraceElementOriginal")); + ste.toString().contains("Original")); assertTrue("String representation doesn't contain a file name", - ste.toString().contains("StackTraceElementOriginal.java")); + ste.toString().contains("OldStackTraceElementTest.java")); assertTrue("String representation doesn't contain a line number", ste.toString().contains("26")); assertTrue("String representation doesn't contain a method name", diff --git a/luni/src/test/java/libcore/java/lang/OldStringBufferTest.java b/luni/src/test/java/libcore/java/lang/OldStringBufferTest.java new file mode 100644 index 0000000..84828c4 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldStringBufferTest.java @@ -0,0 +1,329 @@ +/* + * 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 libcore.java.lang; + +public class OldStringBufferTest extends junit.framework.TestCase { + + StringBuffer testBuffer = new StringBuffer("This is a test buffer"); + + public void test_deleteCharAtI() { + try { + testBuffer.deleteCharAt(testBuffer.length() + 1); + fail("StringIndexOutOfBoundsException was not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.deleteCharAt(-1); + fail("StringIndexOutOfBoundsException was not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_ensureCapacityI() { + // Test for method void java.lang.StringBuffer.ensureCapacity(int) + StringBuffer sb = new StringBuffer(10); + + sb.ensureCapacity(-2); + assertEquals("Failed to increase capacity.", 10, sb.capacity()); + + + try { + sb.ensureCapacity(Integer.MAX_VALUE); + fail("OutOfMemoryError should be thrown."); + } catch(java.lang.OutOfMemoryError oome) { + //expected + } + } + + public void test_getCharsII$CI() { + StringBuffer buf2 = new StringBuffer(""); + try { + buf2.getChars(-1, 0, new char[5], 2); + fail("IndexOutOfBoundsException is not thrown."); + } catch (IndexOutOfBoundsException e) { + //expected + } + + try { + buf2.getChars(0, -1, new char[5], 2); + fail("IndexOutOfBoundsException is not thrown."); + } catch (IndexOutOfBoundsException e) { + //expected + } + + try { + buf2.getChars(0, -1, new char[5], 2); + fail("IndexOutOfBoundsException is not thrown."); + } catch (IndexOutOfBoundsException e) { + //expected + } + + try { + buf2.getChars(2, 1, new char[5], 2); + fail("IndexOutOfBoundsException is not thrown."); + } catch (IndexOutOfBoundsException e) { + //expected + } + + try { + buf2.getChars(0, 6, new char[5], 2); + fail("IndexOutOfBoundsException is not thrown."); + } catch (IndexOutOfBoundsException e) { + //expected + } + + try { + buf2.getChars(0, 6, new char[10], 5); + fail("IndexOutOfBoundsException is not thrown."); + } catch (IndexOutOfBoundsException e) { + //expected + } + } + + public void test_insertID() { + try { + testBuffer.insert(-1, Double.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(testBuffer.length() + 1, Double.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_insertIF() { + try { + testBuffer.insert(-1, Float.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(testBuffer.length() + 1, Float.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_insertII() { + try { + testBuffer.insert(-1, Integer.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(testBuffer.length() + 1, Integer.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_insertIJ() { + try { + testBuffer.insert(-1, Long.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(testBuffer.length() + 1, Long.MAX_VALUE); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_insertILjava_lang_Object() { + Object obj1 = new Object(); + try { + testBuffer.insert(-1, obj1); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(testBuffer.length() + 1, obj1); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_insertILjava_lang_String() { + try { + testBuffer.insert(-1, ""); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(testBuffer.length() + 1, ""); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_insertIZ() { + try { + testBuffer.insert(testBuffer.length() + 1, true); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.insert(-1, true); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_replaceIILjava_lang_String() { + try { + testBuffer.replace(-1, 0, "text"); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.replace(0, -1, "text"); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.replace(2, 1, "text"); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + + try { + testBuffer.replace(testBuffer.length() + 1, testBuffer.length() + 1, + "text"); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException sioobe) { + //expected + } + } + + public void test_setCharAtIC() { + StringBuffer s = new StringBuffer("HelloWorld"); + try { + s.setCharAt(-1, 'Z'); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + try { + s.setCharAt(s.length() + 1, 'Z'); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + } + + public void test_substringI() { + try { + testBuffer.substring(testBuffer.length() + 1); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException oobe) { + //expected + } + + try { + testBuffer.substring(-1); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException oobe) { + //expected + } + } + + public void test_substringII() { + try { + testBuffer.substring(-1, testBuffer.length()); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException oobe) { + //expected + } + + try { + testBuffer.substring(0, -1); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException oobe) { + //expected + } + + try { + testBuffer.substring(2, 1); + fail("StringIndexOutOfBoundsException is not thrown."); + } catch(StringIndexOutOfBoundsException oobe) { + //expected + } + } + + public void test_subSequence() { + assertEquals("Incorrect substring returned", " is", + testBuffer.subSequence(4, 7)); + assertEquals("Incorrect substring returned", "test buffer", + testBuffer.subSequence(10, 21)); + assertEquals("not identical", "This is a test buffer", + testBuffer.subSequence(0, testBuffer.length())); + + try { + testBuffer.subSequence(0, Integer.MAX_VALUE); + fail("IndexOutOfBoundsException was not thrown."); + } catch (IndexOutOfBoundsException ioobe) { + //expected + } + + try { + testBuffer.subSequence(Integer.MAX_VALUE, testBuffer.length()); + fail("IndexOutOfBoundsException was not thrown."); + } catch (IndexOutOfBoundsException ioobe) { + //expected + } + + try { + testBuffer.subSequence(-1, testBuffer.length()); + fail("IndexOutOfBoundsException was not thrown."); + } catch (IndexOutOfBoundsException ioobe) { + //expected + } + } +} diff --git a/luni/src/test/java/libcore/java/lang/OldStringTest.java b/luni/src/test/java/libcore/java/lang/OldStringTest.java index 42eb048..33c3215 100644 --- a/luni/src/test/java/libcore/java/lang/OldStringTest.java +++ b/luni/src/test/java/libcore/java/lang/OldStringTest.java @@ -93,24 +93,21 @@ public class OldStringTest extends junit.framework.TestCase { try { "Hello World".getBytes(-1, 1, null, 0); fail("Expected IndexOutOfBoundsException"); - } catch (IndexOutOfBoundsException e) { - //expected - } catch (NullPointerException e) { - fail("Threw wrong exception"); + } catch (IndexOutOfBoundsException expected) { + } catch (NullPointerException expected) { } try { "Hello World".getBytes(6, 2, null, 0); fail("IndexOutOfBoundsException was not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected + } catch (IndexOutOfBoundsException expected) { + } catch (NullPointerException expected) { } try { "Hello World".getBytes(2, 10, new byte[10], 4); fail("IndexOutOfBoundsException was not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected + } catch (IndexOutOfBoundsException expected) { } } @@ -118,24 +115,21 @@ public class OldStringTest extends junit.framework.TestCase { try { "Hello World".getChars(-1, 1, null, 0); fail("Expected IndexOutOfBoundsException"); - } catch (IndexOutOfBoundsException e) { - //expected - } catch (NullPointerException e) { - fail("Threw wrong exception"); + } catch (IndexOutOfBoundsException expected) { + } catch (NullPointerException expected) { } try { "Hello World".getChars(6, 2, null, 0); fail("IndexOutOfBoundsException was not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected + } catch (IndexOutOfBoundsException expected) { + } catch (NullPointerException expected) { } try { "Hello World".getChars(2, 10, new char[10], 4); fail("IndexOutOfBoundsException was not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected + } catch (IndexOutOfBoundsException expected) { } } diff --git a/luni/src/test/java/libcore/java/lang/OldSystemTest.java b/luni/src/test/java/libcore/java/lang/OldSystemTest.java new file mode 100644 index 0000000..dee5bdd --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldSystemTest.java @@ -0,0 +1,362 @@ +/* + * 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 libcore.java.lang; + +import java.io.IOException; +import java.nio.channels.Channel; +import java.nio.channels.spi.SelectorProvider; +import java.util.Map; +import java.util.Properties; +import java.util.Vector; + +public class OldSystemTest extends junit.framework.TestCase { + + public void test_arraycopyLjava_lang_ObjectILjava_lang_ObjectII() { + // Test for method void java.lang.System.arraycopy(java.lang.Object, + // int, java.lang.Object, int, int) + Integer a[] = new Integer[20]; + Integer b[] = new Integer[20]; + + try { + // copy from non array object into Object array + System.arraycopy(new Object(), 0, b, 0, 0); + fail("ArrayStoreException is not thrown."); + } catch(ArrayStoreException ase) { + //expected + } + + try { + // copy from Object array into non array object + System.arraycopy(a, 0, new Object(), 0, 0); + fail("ArrayStoreException is not thrown."); + } catch(ArrayStoreException ase) { + //expected + } + + try { + // copy from primitive array into object array + System.arraycopy(new char[] {'a'}, 0, new String[1], 0, 1); + fail("ArrayStoreException is not thrown."); + } catch(ArrayStoreException ase) { + //expected + } + + try { + // copy from object array into primitive array + System.arraycopy(new String[] {"a"}, 0, new char[1], 0, 1); + fail("ArrayStoreException is not thrown."); + } catch(ArrayStoreException ase) { + //expected + } + + try { + // copy from primitive array into an array of another primitive type + System.arraycopy(new char[] {'a'}, 0, new int[1], 0, 1); + fail("ArrayStoreException is not thrown."); + } catch(ArrayStoreException ase) { + //expected + } + + try { + // copy from object array into an array of another Object type + System.arraycopy(new Character[] {'a'}, 0, new Integer[1], 0, 1); + fail("ArrayStoreException is not thrown."); + } catch(ArrayStoreException ase) { + //expected + } + + try { + // copy from null into an array of a primitive type + System.arraycopy(null, 0, new int[1], 0, 1); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + // copy from a primitive array into null + System.arraycopy(new int[]{'1'}, 0, null, 0, 1); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + System.arraycopy(a, a.length + 1, b, 0, 1); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, -1, b, 0, 1); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, 0, b, -1, 1); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, 0, b, 0, -1); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, 11, b, 0, 10); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, Integer.MAX_VALUE, b, 0, 10); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, 0, b, Integer.MAX_VALUE, 10); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + + try { + System.arraycopy(a, 0, b, 10, Integer.MAX_VALUE); + fail("IndexOutOfBoundsException is not thrown."); + } catch(IndexOutOfBoundsException ioobe) { + //expected + } + } + + public void test_currentTimeMillis() { + // Test for method long java.lang.System.currentTimeMillis() + try { + long firstRead = System.currentTimeMillis(); + try { + Thread.sleep(150); + } catch (InterruptedException e) { + } + long secondRead = System.currentTimeMillis(); + assertTrue("Incorrect times returned: " + firstRead + ", " + + secondRead, firstRead < secondRead); + } catch (Exception e) { + fail("Exception during test: " + e.toString()); + } + } + + public void test_getProperties() { + String [] props = {"java.vendor.url", + "java.class.path", "user.home", + "java.class.version", "os.version", + "java.vendor", "user.dir", + /*"user.timezone",*/ "path.separator", + "os.name", "os.arch", + "line.separator", "file.separator", + "user.name", "java.version", "java.home" }; + + Properties p = System.getProperties(); + assertTrue(p.size() > 0); + + // Ensure spec'ed properties are non-null. See System.getProperties() + // spec. + + for (String prop : props) { + assertNotNull("There is no property among returned properties: " + + prop, p.getProperty(prop)); + assertNotNull("System property is null: " + prop, + System.getProperty(prop)); + } + } + + public void test_getPropertyLjava_lang_String() { + try { + System.getProperty(null); + fail("NullPointerException should be thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + System.getProperty(""); + fail("IllegalArgumentException should be thrown."); + } catch(IllegalArgumentException iae) { + //expected + } + } + + public void test_getPropertyLjava_lang_StringLjava_lang_String() { + try { + System.getProperty(null, "0.0"); + fail("NullPointerException should be thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + System.getProperty("", "0"); + fail("IllegalArgumentException should be thrown."); + } catch(IllegalArgumentException iae) { + //expected + } + } + + public void test_inheritedChannel() throws IOException { + Channel iChannel = System.inheritedChannel(); + assertNull("Incorrect value of channel", iChannel); + SelectorProvider sp = SelectorProvider.provider(); + assertEquals("Incorrect value of channel", + sp.inheritedChannel(), iChannel); + } + + public void test_clearProperty() { + System.setProperty("test", "value"); + System.clearProperty("test"); + assertNull("Property was not deleted.", System.getProperty("test")); + + try { + System.clearProperty(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + + try { + System.clearProperty(""); + fail("IllegalArgumentException is not thrown."); + } catch(IllegalArgumentException iae) { + //expected + } + } + + public void test_gc() { + Runtime rt = Runtime.getRuntime(); + Vector<StringBuffer> vec = new Vector<StringBuffer>(); + long beforeTest = rt.freeMemory(); + while(rt.freeMemory() < beforeTest * 2/3) { + vec.add(new StringBuffer(1000)); + } + long beforeGC = rt.freeMemory(); + System.gc(); + long afterGC = rt.freeMemory(); + assertTrue("memory was not released after calling System.gc()." + + "before gc: " + beforeGC + "; after gc: " + afterGC, + beforeGC < afterGC); + } + + public void test_getenv() { + // String[] props = { "PATH", "HOME", "USER"}; + // only PATH of these three exists on android + String[] props = { "PATH" }; + + Map<String,String> envMap = System.getenv(); + assertFalse("environment map is empty.", envMap.isEmpty()); + assertTrue("env map contains less than 3 keys.", + props.length < envMap.keySet().size()); + for (String prop : props) { + assertNotNull("There is no property: " + prop, + envMap.get(prop)); + } + } + + public void test_getenvLString() { + assertNotNull("PATH environment variable is not found", + System.getenv("PATH")); + + assertNull("Doesn't return NULL for non existent property", + System.getenv("nonexistent.property")); + + try { + System.getenv(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_load() { + try { + Runtime.getRuntime().load("nonExistentLibrary"); + fail("UnsatisfiedLinkError was not thrown."); + } catch(UnsatisfiedLinkError e) { + //expected + } + + try { + System.load("nonExistentLibrary"); + fail("UnsatisfiedLinkError was not thrown."); + } catch(UnsatisfiedLinkError ule) { + //expected + } + + try { + System.load(null); + fail("NullPointerException was not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_loadLibrary() { + try { + System.loadLibrary("nonExistentLibrary"); + fail("UnsatisfiedLinkError was not thrown."); + } catch(UnsatisfiedLinkError ule) { + //expected + } + + try { + System.loadLibrary(null); + fail("NullPointerException was not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_mapLibraryName() { + assertEquals("libname.so", System.mapLibraryName("name")); + + try { + System.mapLibraryName(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException npe) { + //expected + } + } + + public void test_nanoTime() { + long sleepTime = 5000; + long beginTime = System.nanoTime(); + try { + Thread.sleep(sleepTime); + } catch(Exception e) { + fail("Unknown exception was thrown."); + } + long endTime = System.nanoTime(); + assertTrue((endTime - beginTime) > sleepTime * 1000000); + } +} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadStateTest.java b/luni/src/test/java/libcore/java/lang/OldThreadStateTest.java index 1ae2c27..855655e 100644 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadStateTest.java +++ b/luni/src/test/java/libcore/java/lang/OldThreadStateTest.java @@ -14,28 +14,16 @@ * limitations under the License. */ -package org.apache.harmony.luni.tests.java.lang; +package libcore.java.lang; import junit.framework.TestCase; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargetClass; - -@TestTargetClass(Thread.State.class) -public class ThreadStateTest extends TestCase { +public class OldThreadStateTest extends TestCase { Thread.State [] exStates = { Thread.State.NEW, Thread.State.RUNNABLE, Thread.State.BLOCKED, Thread.State.WAITING, Thread.State.TIMED_WAITING, Thread.State.TERMINATED }; - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "valueOf", - args = {java.lang.String.class} - ) public void test_valueOfLString(){ String [] spNames = {"NEW", "RUNNABLE", "BLOCKED", "WAITING", "TIMED_WAITING", "TERMINATED"}; @@ -55,20 +43,12 @@ public class ThreadStateTest extends TestCase { } } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "values", - args = {} - ) public void test_values() { - Thread.State [] thStates = Thread.State.values(); assertEquals(exStates.length, thStates.length); for(Thread.State ts:thStates) { assertTrue(isContain(ts)); } - } boolean isContain(Thread.State state) { diff --git a/luni/src/test/java/libcore/java/lang/OldThrowableTest.java b/luni/src/test/java/libcore/java/lang/OldThrowableTest.java new file mode 100644 index 0000000..a616855 --- /dev/null +++ b/luni/src/test/java/libcore/java/lang/OldThrowableTest.java @@ -0,0 +1,131 @@ +/* + * 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 libcore.java.lang; + +import junit.framework.TestCase; + +public class OldThrowableTest extends TestCase { + + public void test_ConstructorLStringLThrowable() { + String message = "Test message"; + NullPointerException npe = new NullPointerException(); + Throwable thr = new Throwable(message, npe); + assertEquals("message is incorrect.", message, thr.getMessage()); + assertEquals("cause is incorrect.", npe, thr.getCause()); + + thr = new Throwable(null, npe); + assertNull("message is not null.", thr.getMessage()); + assertEquals("cause is incorrect.", npe, thr.getCause()); + + thr = new Throwable(message, null); + assertEquals("message is incorrect.", message, thr.getMessage()); + assertNull("cause is not null.", thr.getCause()); + } + + public void test_ConstructorLThrowable() { + + NullPointerException npe = new NullPointerException(); + Throwable thr = new Throwable(npe); + + assertEquals("Returned cause is incorrect.", npe, thr.getCause()); + + thr = new Throwable((Throwable) null); + assertNull("The cause is not null.", thr.getCause()); + } + + public void test_getLocalizedMessage() { + String testMessage = "Test message"; + Throwable e = new Throwable(testMessage); + assertEquals("Returned incorrect localized message.", + testMessage, e.getLocalizedMessage()); + + TestThrowable tt = new TestThrowable(testMessage); + assertEquals("localized message", tt.getLocalizedMessage()); + } + + class TestThrowable extends Throwable { + + public TestThrowable(String message) { + super(message); + } + + public String getLocalizedMessage() { + return "localized message"; + } + } + + public void test_getStackTrace() { + String message = "Test message"; + NullPointerException npe = new NullPointerException(); + Throwable thr = new Throwable(message, npe); + StackTraceElement[] ste = thr.getStackTrace(); + assertNotNull("Returned stack trace is empty", ste.length != 0); + } + + public void test_initCause() { + String message = "Test message"; + NullPointerException npe = new NullPointerException(); + IllegalArgumentException iae = new IllegalArgumentException(); + Throwable thr = new Throwable(); + thr.initCause(iae); + assertEquals("getCause returns incorrect cause.", iae, thr.getCause()); + + thr = new Throwable("message"); + thr.initCause(npe); + assertEquals("getCause returns incorrect cause.", npe, thr.getCause()); + + thr = new Throwable(message, npe); + try { + thr.initCause(iae); + fail("IllegalStateException was not thrown."); + } catch(IllegalStateException ise) { + //expected + } + + thr = new Throwable(npe); + try { + thr.initCause(iae); + fail("IllegalStateException was not thrown."); + } catch(IllegalStateException ise) { + //expected + } + + thr = new Throwable(); + try { + thr.initCause(thr); + fail("IllegalArgumentException was not thrown."); + } catch(IllegalArgumentException ise) { + //expected + } + } + + public void test_setStackTrace() { + NullPointerException npe = new NullPointerException(); + Throwable thr = new Throwable(npe); + StackTraceElement[] ste = thr.getStackTrace(); + Throwable thr1 = new Throwable(npe); + thr1.setStackTrace(ste); + assertEquals(ste.length, thr1.getStackTrace().length); + + try { + thr.setStackTrace(null); + fail("NullPointerException is not thrown."); + } catch(NullPointerException np) { + //expected + } + } +} diff --git a/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java b/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java index b6606b5..07e0897 100644 --- a/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java +++ b/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java @@ -1148,7 +1148,7 @@ public class OldDatagramSocketTest extends junit.framework./*Socket*/TestCase { return null; } } - InetSocketAddress sa = InetSocketAddress.createUnresolved("localhost", 0); + InetSocketAddress sa = new InetSocketAddress(InetAddress.getLocalHost(), 0); //no exception expected for next line new testDatagramSocket(new testDatagramSocketImpl()).send(new DatagramPacket(new byte[272], 3, sa)); diff --git a/luni/src/test/java/libcore/java/net/URLConnectionTest.java b/luni/src/test/java/libcore/java/net/URLConnectionTest.java index 1a11bd9..019c085 100644 --- a/luni/src/test/java/libcore/java/net/URLConnectionTest.java +++ b/luni/src/test/java/libcore/java/net/URLConnectionTest.java @@ -18,7 +18,6 @@ package libcore.java.net; import java.io.BufferedReader; import java.io.ByteArrayOutputStream; -import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; @@ -33,8 +32,6 @@ import java.net.PasswordAuthentication; import java.net.Proxy; import java.net.ResponseCache; import java.net.SecureCacheResponse; -import java.net.ServerSocket; -import java.net.Socket; import java.net.SocketTimeoutException; import java.net.URI; import java.net.URISyntaxException; @@ -1173,6 +1170,48 @@ public class URLConnectionTest extends junit.framework.TestCase { assertEquals(Arrays.toString(requestBody), Arrays.toString(request.getBody())); } + public void testSecureFixedLengthStreaming() throws Exception { + testSecureStreamingPost(StreamingMode.FIXED_LENGTH); + } + + public void testSecureChunkedStreaming() throws Exception { + testSecureStreamingPost(StreamingMode.CHUNKED); + } + + /** + * Users have reported problems using HTTPS with streaming request bodies. + * http://code.google.com/p/android/issues/detail?id=12860 + */ + private void testSecureStreamingPost(StreamingMode streamingMode) throws Exception { + TestSSLContext testSSLContext = TestSSLContext.create(); + server.useHttps(testSSLContext.serverContext.getSocketFactory(), false); + server.enqueue(new MockResponse().setBody("Success!")); + server.play(); + + HttpsURLConnection connection = (HttpsURLConnection) server.getUrl("/").openConnection(); + connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory()); + connection.setDoOutput(true); + byte[] requestBody = { 'A', 'B', 'C', 'D' }; + if (streamingMode == StreamingMode.FIXED_LENGTH) { + connection.setFixedLengthStreamingMode(requestBody.length); + } else if (streamingMode == StreamingMode.CHUNKED) { + connection.setChunkedStreamingMode(0); + } + OutputStream outputStream = connection.getOutputStream(); + outputStream.write(requestBody); + outputStream.close(); + assertEquals("Success!", readAscii(connection.getInputStream(), Integer.MAX_VALUE)); + + RecordedRequest request = server.takeRequest(); + assertEquals("POST / HTTP/1.1", request.getRequestLine()); + if (streamingMode == StreamingMode.FIXED_LENGTH) { + assertEquals(Collections.<Integer>emptyList(), request.getChunkSizes()); + } else if (streamingMode == StreamingMode.CHUNKED) { + assertEquals(Arrays.asList(4), request.getChunkSizes()); + } + assertEquals(Arrays.toString(requestBody), Arrays.toString(request.getBody())); + } + enum StreamingMode { FIXED_LENGTH, CHUNKED } diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/AllTests.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/AllTests.java deleted file mode 100644 index 9f5b1b3..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/AllTests.java +++ /dev/null @@ -1,115 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -import junit.framework.Test; -import junit.framework.TestSuite; -import junit.textui.TestRunner; - -/** - * Listing of all the tests that are to be run. - */ -public class AllTests { - - public static void run() { - TestRunner.main(new String[] { AllTests.class.getName() }); - } - - public static Test suite() { - TestSuite suite = new TestSuite("Tests for java.lang"); - - suite.addTestSuite(ArithmeticExceptionTest.class); - suite.addTestSuite(ArrayIndexOutOfBoundsExceptionTest.class); - suite.addTestSuite(ArrayStoreExceptionTest.class); - suite.addTestSuite(AssertionErrorTest.class); - suite.addTestSuite(BooleanTest.class); - suite.addTestSuite(ByteTest.class); - suite.addTestSuite(Character_SubsetTest.class); - suite.addTestSuite(OldCharacterTest.class); - suite.addTestSuite(Character_UnicodeBlockTest.class); - suite.addTestSuite(ClassCastExceptionTest.class); - suite.addTestSuite(ClassCircularityErrorTest.class); - suite.addTestSuite(ClassFormatErrorTest.class); - suite.addTestSuite(ClassLoaderTest.class); - suite.addTestSuite(ClassNotFoundExceptionTest.class); - suite.addTestSuite(ClassTest.class); - suite.addTestSuite(ClassTest2.class); - suite.addTestSuite(CloneNotSupportedExceptionTest.class); - suite.addTestSuite(CompilerTest.class); - suite.addTestSuite(DoubleTest.class); - suite.addTestSuite(EnumConstantNotPresentExceptionTest.class); - suite.addTestSuite(ErrorTest.class); - suite.addTestSuite(ExceptionInInitializerErrorTest.class); - suite.addTestSuite(ExceptionTest.class); - suite.addTestSuite(FloatTest.class); - suite.addTestSuite(IllegalAccessErrorTest.class); - suite.addTestSuite(IllegalAccessExceptionTest.class); - suite.addTestSuite(IllegalArgumentExceptionTest.class); - suite.addTestSuite(IllegalMonitorStateExceptionTest.class); - suite.addTestSuite(IllegalStateExceptionTest.class); - suite.addTestSuite(IllegalThreadStateExceptionTest.class); - suite.addTestSuite(IncompatibleClassChangeErrorTest.class); - suite.addTestSuite(IndexOutOfBoundsExceptionTest.class); - suite.addTestSuite(InheritableThreadLocalTest.class); - suite.addTestSuite(InstantiationErrorTest.class); - suite.addTestSuite(InstantiationExceptionTest.class); - suite.addTestSuite(IntegerTest.class); - suite.addTestSuite(InternalErrorTest.class); - suite.addTestSuite(InterruptedExceptionTest.class); - suite.addTestSuite(LinkageErrorTest.class); - suite.addTestSuite(LongTest.class); - suite.addTestSuite(MathTest.class); - suite.addTestSuite(NegativeArraySizeExceptionTest.class); - suite.addTestSuite(NoClassDefFoundErrorTest.class); - suite.addTestSuite(NoSuchFieldErrorTest.class); - suite.addTestSuite(NoSuchFieldExceptionTest.class); - suite.addTestSuite(NoSuchMethodErrorTest.class); - suite.addTestSuite(NoSuchMethodExceptionTest.class); - suite.addTestSuite(NullPointerExceptionTest.class); - suite.addTestSuite(NumberFormatExceptionTest.class); - suite.addTestSuite(NumberTest.class); - suite.addTestSuite(ObjectTest.class); - suite.addTestSuite(OutOfMemoryErrorTest.class); - suite.addTestSuite(RuntimeExceptionTest.class); - suite.addTestSuite(RuntimePermissionTest.class); - suite.addTestSuite(RuntimeTest.class); - suite.addTestSuite(SecurityExceptionTest.class); - suite.addTestSuite(SecurityManagerTest.class); - suite.addTestSuite(ShortTest.class); - suite.addTestSuite(StackOverflowErrorTest.class); - suite.addTestSuite(StackTraceElementTest.class); - suite.addTestSuite(StrictMathTest.class); - suite.addTestSuite(StringBuffer2Test.class); - suite.addTestSuite(StringBufferTest.class); - suite.addTestSuite(StringBuilderTest.class); - suite.addTestSuite(StringIndexOutOfBoundsExceptionTest.class); - suite.addTestSuite(SystemTest.class); - suite.addTestSuite(ThreadDeathTest.class); - suite.addTestSuite(ThreadLocalTest.class); - suite.addTestSuite(ThreadStateTest.class); - suite.addTestSuite(ThrowableTest.class); - suite.addTestSuite(TypeNotPresentExceptionTest.class); - suite.addTestSuite(UnknownErrorTest.class); - suite.addTestSuite(UnsatisfiedLinkErrorTest.class); - suite.addTestSuite(UnsupportedOperationExceptionTest.class); - suite.addTestSuite(UnsupportedClassVersionErrorTest.class); - suite.addTestSuite(VerifyErrorTest.class); - suite.addTestSuite(VirtualMachineErrorTest.class); - - return suite; - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArithmeticExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArithmeticExceptionTest.java deleted file mode 100644 index f99be20..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArithmeticExceptionTest.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class ArithmeticExceptionTest extends TestCase { - - /** - * @tests java.lang.ArithmeticException#ArithmeticException() - */ - public void test_Constructor() { - ArithmeticException e = new ArithmeticException(); - assertNull(e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ArithmeticException#ArithmeticException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - ArithmeticException e = new ArithmeticException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArrayIndexOutOfBoundsExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArrayIndexOutOfBoundsExceptionTest.java deleted file mode 100644 index c7537c0..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArrayIndexOutOfBoundsExceptionTest.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class ArrayIndexOutOfBoundsExceptionTest extends TestCase { - - /** - * @tests java.lang.ArrayIndexOutOfBoundsException#ArrayIndexOutOfBoundsException(int) - */ - public void test_ConstructorI() { - ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException(-1); - assertNotNull(e.getMessage()); - assertTrue("Unable to find index value in 'message' property.", e.getMessage().indexOf( - "-1", 0) >= 0); - - } - - /** - * @tests java.lang.ArrayIndexOutOfBoundsException#ArrayIndexOutOfBoundsException() - */ - public void test_Constructor() { - ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException(); - assertNull(e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ArrayIndexOutOfBoundsException#ArrayIndexOutOfBoundsException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - ArrayIndexOutOfBoundsException e = new ArrayIndexOutOfBoundsException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArrayStoreExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArrayStoreExceptionTest.java deleted file mode 100644 index c8979d0..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ArrayStoreExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class ArrayStoreExceptionTest extends TestCase { - - /** - * @tests java.lang.ArrayStoreException#ArrayStoreException() - */ - public void test_Constructor() { - ArrayStoreException e = new ArrayStoreException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ArrayStoreException#ArrayStoreException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - ArrayStoreException e = new ArrayStoreException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/AssertionErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/AssertionErrorTest.java deleted file mode 100644 index ce196ba..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/AssertionErrorTest.java +++ /dev/null @@ -1,78 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class AssertionErrorTest extends TestCase { - - public void test_Constructor() { - AssertionError e = new AssertionError(); - assertNull(e.getMessage()); - assertNull(e.getCause()); - } - - public void test_ConstructorObject() { - Object obj = "toString"; - AssertionError e = new AssertionError(obj); - assertEquals("toString", e.getMessage()); - assertNull(e.getCause()); - - NullPointerException npe = new NullPointerException("null value"); - e = new AssertionError(npe); - assertEquals(npe.toString(), e.getMessage()); - assertSame(npe, e.getCause()); - } - - public void test_ConstructorBoolean() { - AssertionError e = new AssertionError(true); - assertEquals("true", e.getMessage()); - assertNull(e.getCause()); - } - - public void test_ConstructorChar() { - AssertionError e = new AssertionError('a'); - assertEquals("a", e.getMessage()); - assertNull(e.getCause()); - } - - public void test_ConstructorInt() { - AssertionError e = new AssertionError(1); - assertEquals("1", e.getMessage()); - assertNull(e.getCause()); - } - - public void test_ConstructorLong() { - AssertionError e = new AssertionError(1L); - assertEquals("1", e.getMessage()); - assertNull(e.getCause()); - } - - public void test_ConstructorFloat() { - AssertionError e = new AssertionError(1.0F); - assertEquals("1.0", e.getMessage()); - assertNull(e.getCause()); - } - - public void test_ConstructorDouble() { - AssertionError e = new AssertionError(1.0D); - assertEquals("1.0", e.getMessage()); - assertNull(e.getCause()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/BooleanTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/BooleanTest.java deleted file mode 100644 index d6dbb64..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/BooleanTest.java +++ /dev/null @@ -1,157 +0,0 @@ -/* 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 junit.framework.TestCase; - -public class BooleanTest extends TestCase { - - /** - * @tests java.lang.Boolean#hashCode() - */ - public void test_hashCode() { - assertEquals(1231, Boolean.TRUE.hashCode()); - assertEquals(1237, Boolean.FALSE.hashCode()); - } - - /** - * @tests java.lang.Boolean#Boolean(String) - */ - public void test_ConstructorLjava_lang_String() { - assertEquals(Boolean.TRUE, new Boolean("TRUE")); - assertEquals(Boolean.TRUE, new Boolean("true")); - assertEquals(Boolean.TRUE, new Boolean("True")); - - assertEquals(Boolean.FALSE, new Boolean("yes")); - assertEquals(Boolean.FALSE, new Boolean("false")); - } - - /** - * @tests java.lang.Boolean#Boolean(boolean) - */ - public void test_ConstructorZ() { - assertEquals(Boolean.TRUE, new Boolean(true)); - assertEquals(Boolean.FALSE, new Boolean(false)); - } - - /** - * @tests java.lang.Boolean#booleanValue() - */ - public void test_booleanValue() { - assertTrue(Boolean.TRUE.booleanValue()); - assertFalse(Boolean.FALSE.booleanValue()); - } - - /** - * @tests java.lang.Boolean#equals(Object) - */ - public void test_equalsLjava_lang_Object() { - assertTrue(Boolean.TRUE.equals(Boolean.TRUE)); - assertTrue(Boolean.TRUE.equals(new Boolean(true))); - assertFalse(Boolean.TRUE.equals("true")); - assertFalse(Boolean.TRUE.equals(null)); - assertFalse(Boolean.FALSE.equals(Boolean.TRUE)); - assertTrue(Boolean.FALSE.equals(Boolean.FALSE)); - assertTrue(Boolean.FALSE.equals(new Boolean(false))); - } - - /** - * @tests java.lang.Boolean#getBoolean(String) - */ - public void test_getBooleanLjava_lang_String() { - System.setProperty(getClass().getName(), "true"); - assertTrue(Boolean.getBoolean(getClass().getName())); - - System.setProperty(getClass().getName(), "TRUE"); - assertTrue(Boolean.getBoolean(getClass().getName())); - - System.setProperty(getClass().getName(), "false"); - assertFalse(Boolean.getBoolean(getClass().getName())); - } - - /** - * @tests java.lang.Boolean#toString() - */ - public void test_toString() { - assertEquals("true", Boolean.TRUE.toString()); - assertEquals("false", Boolean.FALSE.toString()); - } - - /** - * @tests java.lang.Boolean#toString(boolean) - */ - public void test_toStringZ() { - assertEquals("true", Boolean.toString(true)); - assertEquals("false", Boolean.toString(false)); - } - - /** - * @tests java.lang.Boolean#valueOf(String) - */ - public void test_valueOfLjava_lang_String() { - assertEquals(Boolean.TRUE, Boolean.valueOf("true")); - assertEquals(Boolean.FALSE, Boolean.valueOf("false")); - - assertEquals(Boolean.TRUE, Boolean.valueOf("TRUE")); - assertEquals(Boolean.FALSE, Boolean.valueOf("false")); - - assertEquals(Boolean.FALSE, Boolean.valueOf(null)); - assertEquals(Boolean.FALSE, Boolean.valueOf("")); - assertEquals(Boolean.FALSE, Boolean.valueOf("invalid")); - - assertTrue("Failed to parse true to true", Boolean.valueOf("true").booleanValue()); - assertTrue("Failed to parse mixed case true to true", Boolean.valueOf("TrUe") - .booleanValue()); - assertTrue("parsed non-true to true", !Boolean.valueOf("ddddd").booleanValue()); - } - - /** - * @tests java.lang.Boolean#valueOf(boolean) - */ - public void test_valueOfZ() { - assertEquals(Boolean.TRUE, Boolean.valueOf(true)); - assertEquals(Boolean.FALSE, Boolean.valueOf(false)); - } - - /** - * @tests java.lang.Boolean#parseBoolean(String) - */ - public void test_parseBooleanLjava_lang_String() { - assertTrue(Boolean.parseBoolean("true")); - assertTrue(Boolean.parseBoolean("TRUE")); - assertFalse(Boolean.parseBoolean("false")); - assertFalse(Boolean.parseBoolean(null)); - assertFalse(Boolean.parseBoolean("")); - assertFalse(Boolean.parseBoolean("invalid")); - } - - /** - * @tests java.lang.Boolean#compareTo(Boolean) - */ - public void test_compareToLjava_lang_Boolean() { - assertTrue(Boolean.TRUE.compareTo(Boolean.TRUE) == 0); - assertTrue(Boolean.FALSE.compareTo(Boolean.FALSE) == 0); - assertTrue(Boolean.TRUE.compareTo(Boolean.FALSE) > 0); - assertTrue(Boolean.FALSE.compareTo(Boolean.TRUE) < 0); - - try { - Boolean.TRUE.compareTo(null); - fail("No NPE"); - } catch (NullPointerException e) { - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ByteTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ByteTest.java deleted file mode 100644 index 3e14b2b..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ByteTest.java +++ /dev/null @@ -1,672 +0,0 @@ -/* 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 junit.framework.TestCase; - -public class ByteTest extends TestCase { - - /** - * @tests java.lang.Byte#valueOf(byte) - */ - public void test_valueOfB() { - assertEquals(new Byte(Byte.MIN_VALUE), Byte.valueOf(Byte.MIN_VALUE)); - assertEquals(new Byte(Byte.MAX_VALUE), Byte.valueOf(Byte.MAX_VALUE)); - assertEquals(new Byte((byte) 0), Byte.valueOf((byte) 0)); - - byte b = Byte.MIN_VALUE + 1; - while (b < Byte.MAX_VALUE) { - assertEquals(new Byte(b), Byte.valueOf(b)); - assertSame(Byte.valueOf(b), Byte.valueOf(b)); - b++; - } - } - - /** - * @tests java.lang.Byte#hashCode() - */ - public void test_hashCode() { - assertEquals(1, new Byte((byte) 1).hashCode()); - assertEquals(2, new Byte((byte) 2).hashCode()); - assertEquals(0, new Byte((byte) 0).hashCode()); - assertEquals(-1, new Byte((byte) -1).hashCode()); - } - - /** - * @tests java.lang.Byte#Byte(String) - */ - public void test_ConstructorLjava_lang_String() { - assertEquals(new Byte((byte) 0), new Byte("0")); - assertEquals(new Byte((byte) 1), new Byte("1")); - assertEquals(new Byte((byte) -1), new Byte("-1")); - - try { - new Byte("0x1"); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) { - } - - try { - new Byte("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) { - } - - try { - new Byte(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) { - } - - try { - new Byte(null); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#Byte(byte) - */ - public void test_ConstructorB() { - assertEquals(1, new Byte((byte) 1).byteValue()); - assertEquals(2, new Byte((byte) 2).byteValue()); - assertEquals(0, new Byte((byte) 0).byteValue()); - assertEquals(-1, new Byte((byte) -1).byteValue()); - } - - /** - * @tests java.lang.Byte#byteValue() - */ - public void test_booleanValue() { - assertEquals(1, new Byte((byte) 1).byteValue()); - assertEquals(2, new Byte((byte) 2).byteValue()); - assertEquals(0, new Byte((byte) 0).byteValue()); - assertEquals(-1, new Byte((byte) -1).byteValue()); - } - - /** - * @tests java.lang.Byte#equals(Object) - */ - public void test_equalsLjava_lang_Object() { - assertEquals(new Byte((byte) 0), Byte.valueOf((byte) 0)); - assertEquals(new Byte((byte) 1), Byte.valueOf((byte) 1)); - assertEquals(new Byte((byte) -1), Byte.valueOf((byte) -1)); - - Byte fixture = new Byte((byte) 25); - assertEquals(fixture, fixture); - assertFalse(fixture.equals(null)); - assertFalse(fixture.equals("Not a Byte")); - } - - /** - * @tests java.lang.Byte#toString() - */ - public void test_toString() { - assertEquals("-1", new Byte((byte) -1).toString()); - assertEquals("0", new Byte((byte) 0).toString()); - assertEquals("1", new Byte((byte) 1).toString()); - assertEquals("-1", new Byte((byte) 0xFF).toString()); - } - - /** - * @tests java.lang.Byte#toString(byte) - */ - public void test_toStringB() { - assertEquals("-1", Byte.toString((byte) -1)); - assertEquals("0", Byte.toString((byte) 0)); - assertEquals("1", Byte.toString((byte) 1)); - assertEquals("-1", Byte.toString((byte) 0xFF)); - } - - /** - * @tests java.lang.Byte#valueOf(String) - */ - public void test_valueOfLjava_lang_String() { - assertEquals(new Byte((byte) 0), Byte.valueOf("0")); - assertEquals(new Byte((byte) 1), Byte.valueOf("1")); - assertEquals(new Byte((byte) -1), Byte.valueOf("-1")); - - try { - Byte.valueOf("0x1"); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) { - } - - try { - Byte.valueOf("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) { - } - - try { - Byte.valueOf(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) { - } - - try { - Byte.valueOf(null); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#valueOf(String,int) - */ - public void test_valueOfLjava_lang_StringI() { - assertEquals(new Byte((byte) 0), Byte.valueOf("0", 10)); - assertEquals(new Byte((byte) 1), Byte.valueOf("1", 10)); - assertEquals(new Byte((byte) -1), Byte.valueOf("-1", 10)); - - //must be consistent with Character.digit() - assertEquals(Character.digit('1', 2), Byte.valueOf("1", 2).byteValue()); - assertEquals(Character.digit('F', 16), Byte.valueOf("F", 16).byteValue()); - - try { - Byte.valueOf("0x1", 10); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) { - } - - try { - Byte.valueOf("9.2", 10); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) { - } - - try { - Byte.valueOf("", 10); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) { - } - - try { - Byte.valueOf(null, 10); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#parseByte(String) - */ - public void test_parseByteLjava_lang_String() { - assertEquals(0, Byte.parseByte("0")); - assertEquals(1, Byte.parseByte("1")); - assertEquals(-1, Byte.parseByte("-1")); - - try { - Byte.parseByte("0x1"); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte(null); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#parseByte(String,int) - */ - public void test_parseByteLjava_lang_StringI() { - assertEquals(0, Byte.parseByte("0", 10)); - assertEquals(1, Byte.parseByte("1", 10)); - assertEquals(-1, Byte.parseByte("-1", 10)); - - //must be consistent with Character.digit() - assertEquals(Character.digit('1', 2), Byte.parseByte("1", 2)); - assertEquals(Character.digit('F', 16), Byte.parseByte("F", 16)); - - try { - Byte.parseByte("0x1", 10); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("9.2", 10); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("", 10); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte(null, 10); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#decode(String) - */ - public void test_decodeLjava_lang_String() { - assertEquals(new Byte((byte) 0), Byte.decode("0")); - assertEquals(new Byte((byte) 1), Byte.decode("1")); - assertEquals(new Byte((byte) -1), Byte.decode("-1")); - assertEquals(new Byte((byte) 0xF), Byte.decode("0xF")); - assertEquals(new Byte((byte) 0xF), Byte.decode("#F")); - assertEquals(new Byte((byte) 0xF), Byte.decode("0XF")); - assertEquals(new Byte((byte) 07), Byte.decode("07")); - - try { - Byte.decode("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) { - } - - try { - Byte.decode(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) { - } - - try { - Byte.decode(null); - //undocumented NPE, but seems consistent across JREs - fail("Expected NullPointerException with null string."); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Byte#doubleValue() - */ - public void test_doubleValue() { - assertEquals(-1D, new Byte((byte) -1).doubleValue(), 0D); - assertEquals(0D, new Byte((byte) 0).doubleValue(), 0D); - assertEquals(1D, new Byte((byte) 1).doubleValue(), 0D); - } - - /** - * @tests java.lang.Byte#floatValue() - */ - public void test_floatValue() { - assertEquals(-1F, new Byte((byte) -1).floatValue(), 0F); - assertEquals(0F, new Byte((byte) 0).floatValue(), 0F); - assertEquals(1F, new Byte((byte) 1).floatValue(), 0F); - } - - /** - * @tests java.lang.Byte#intValue() - */ - public void test_intValue() { - assertEquals(-1, new Byte((byte) -1).intValue()); - assertEquals(0, new Byte((byte) 0).intValue()); - assertEquals(1, new Byte((byte) 1).intValue()); - } - - /** - * @tests java.lang.Byte#longValue() - */ - public void test_longValue() { - assertEquals(-1L, new Byte((byte) -1).longValue()); - assertEquals(0L, new Byte((byte) 0).longValue()); - assertEquals(1L, new Byte((byte) 1).longValue()); - } - - /** - * @tests java.lang.Byte#shortValue() - */ - public void test_shortValue() { - assertEquals(-1, new Byte((byte) -1).shortValue()); - assertEquals(0, new Byte((byte) 0).shortValue()); - assertEquals(1, new Byte((byte) 1).shortValue()); - } - - /** - * @tests java.lang.Byte#compareTo(Byte) - */ - public void test_compareToLjava_lang_Byte() { - final Byte min = new Byte(Byte.MIN_VALUE); - final Byte zero = new Byte((byte) 0); - final Byte max = new Byte(Byte.MAX_VALUE); - - assertTrue(max.compareTo(max) == 0); - assertTrue(min.compareTo(min) == 0); - assertTrue(zero.compareTo(zero) == 0); - - assertTrue(max.compareTo(zero) > 0); - assertTrue(max.compareTo(min) > 0); - - assertTrue(zero.compareTo(max) < 0); - assertTrue(zero.compareTo(min) > 0); - - assertTrue(min.compareTo(zero) < 0); - assertTrue(min.compareTo(max) < 0); - - try { - min.compareTo(null); - fail("No NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Byte#Byte(byte) - */ - public void test_ConstructorB2() { - // Test for method java.lang.Byte(byte) - - Byte b = new Byte((byte) 127); - assertTrue("Byte creation failed", b.byteValue() == (byte) 127); - } - - /** - * @tests java.lang.Byte#Byte(java.lang.String) - */ - public void test_ConstructorLjava_lang_String2() { - // Test for method java.lang.Byte(java.lang.String) - - Byte b = new Byte("127"); - Byte nb = new Byte("-128"); - assertTrue("Incorrect Byte Object created", b.byteValue() == (byte) 127 - && (nb.byteValue() == (byte) -128)); - - } - - /** - * @tests java.lang.Byte#byteValue() - */ - public void test_byteValue() { - // Test for method byte java.lang.Byte.byteValue() - assertTrue("Returned incorrect byte value", - new Byte((byte) 127).byteValue() == (byte) (127)); - } - - /** - * @tests java.lang.Byte#compareTo(java.lang.Byte) - */ - public void test_compareToLjava_lang_Byte2() { - // Test for method int java.lang.Byte.compareTo(java.lang.Byte) - assertTrue("Comparison failed", new Byte((byte) 1).compareTo(new Byte((byte) 2)) < 0); - assertTrue("Comparison failed", new Byte((byte) 1).compareTo(new Byte((byte) -2)) > 0); - assertEquals("Comparison failed", 0, new Byte((byte) 1).compareTo(new Byte((byte) 1))); - } - - /** - * @tests java.lang.Byte#decode(java.lang.String) - */ - public void test_decodeLjava_lang_String2() { - // Test for method java.lang.Byte - // java.lang.Byte.decode(java.lang.String) - assertTrue("String decoded incorrectly, wanted: 1 got: " + Byte.decode("1").toString(), - Byte.decode("1").equals(new Byte((byte) 1))); - assertTrue("String decoded incorrectly, wanted: -1 got: " - + Byte.decode("-1").toString(), Byte.decode("-1").equals(new Byte((byte) -1))); - assertTrue("String decoded incorrectly, wanted: 127 got: " - + Byte.decode("127").toString(), Byte.decode("127") - .equals(new Byte((byte) 127))); - assertTrue("String decoded incorrectly, wanted: -128 got: " - + Byte.decode("-128").toString(), Byte.decode("-128").equals( - new Byte((byte) -128))); - assertTrue("String decoded incorrectly, wanted: 127 got: " - + Byte.decode("0x7f").toString(), Byte.decode("0x7f").equals( - new Byte((byte) 127))); - assertTrue("String decoded incorrectly, wanted: -128 got: " - + Byte.decode("-0x80").toString(), Byte.decode("-0x80").equals( - new Byte((byte) -128))); - - boolean exception = false; - try { - Byte.decode("128"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); - - exception = false; - try { - Byte.decode("-129"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); - - exception = false; - try { - Byte.decode("0x80"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); - - exception = false; - try { - Byte.decode("-0x81"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception); - } - - /** - * @tests java.lang.Byte#doubleValue() - */ - public void test_doubleValue2() { - assertEquals(127D, new Byte((byte) 127).doubleValue(), 0.0); - } - - /** - * @tests java.lang.Byte#equals(java.lang.Object) - */ - public void test_equalsLjava_lang_Object2() { - // Test for method boolean java.lang.Byte.equals(java.lang.Object) - Byte b1 = new Byte((byte) 90); - Byte b2 = new Byte((byte) 90); - Byte b3 = new Byte((byte) -90); - assertTrue("Equality test failed", b1.equals(b2)); - assertTrue("Equality test failed", !b1.equals(b3)); - } - - /** - * @tests java.lang.Byte#floatValue() - */ - public void test_floatValue2() { - assertEquals(127F, new Byte((byte) 127).floatValue(), 0.0); - } - - /** - * @tests java.lang.Byte#hashCode() - */ - public void test_hashCode2() { - // Test for method int java.lang.Byte.hashCode() - assertEquals("Incorrect hash returned", 127, new Byte((byte) 127).hashCode()); - } - - /** - * @tests java.lang.Byte#intValue() - */ - public void test_intValue2() { - // Test for method int java.lang.Byte.intValue() - assertEquals("Returned incorrect int value", 127, new Byte((byte) 127).intValue()); - } - - /** - * @tests java.lang.Byte#longValue() - */ - public void test_longValue2() { - // Test for method long java.lang.Byte.longValue() - assertEquals("Returned incorrect long value", 127L, new Byte((byte) 127).longValue()); - } - - /** - * @tests java.lang.Byte#parseByte(java.lang.String) - */ - public void test_parseByteLjava_lang_String2() { - assertEquals((byte)127, Byte.parseByte("127")); - assertEquals((byte)-128, Byte.parseByte("-128")); - assertEquals((byte)0, Byte.parseByte("0")); - assertEquals((byte)0x80, Byte.parseByte("-128")); - assertEquals((byte)0x7F, Byte.parseByte("127")); - - try { - Byte.parseByte("-1000"); - fail("No NumberFormatException"); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("128"); - fail("No NumberFormatException"); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("-129"); - fail("No NumberFormatException"); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#parseByte(java.lang.String, int) - */ - public void test_parseByteLjava_lang_StringI2() { - // Test for method byte java.lang.Byte.parseByte(java.lang.String, int) - byte b = Byte.parseByte("127", 10); - byte bn = Byte.parseByte("-128", 10); - assertTrue("Invalid parse of dec byte", b == (byte) 127 && (bn == (byte) -128)); - assertEquals("Failed to parse hex value", 10, Byte.parseByte("A", 16)); - assertEquals("Returned incorrect value for 0 hex", 0, Byte.parseByte("0", 16)); - assertTrue("Returned incorrect value for most negative value hex", Byte.parseByte( - "-80", 16) == (byte) 0x80); - assertTrue("Returned incorrect value for most positive value hex", Byte.parseByte("7f", - 16) == 0x7f); - assertEquals("Returned incorrect value for 0 decimal", 0, Byte.parseByte("0", 10)); - assertTrue("Returned incorrect value for most negative value decimal", Byte.parseByte( - "-128", 10) == (byte) 0x80); - assertTrue("Returned incorrect value for most positive value decimal", Byte.parseByte( - "127", 10) == 0x7f); - - try { - Byte.parseByte("-1000", 10); - fail("Failed to throw exception"); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("128", 10); - fail("Failed to throw exception for MAX_VALUE + 1"); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("-129", 10); - fail("Failed to throw exception for MIN_VALUE - 1"); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("80", 16); - fail("Failed to throw exception for hex MAX_VALUE + 1"); - } catch (NumberFormatException e) { - } - - try { - Byte.parseByte("-81", 16); - fail("Failed to throw exception for hex MIN_VALUE + 1"); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#shortValue() - */ - public void test_shortValue2() { - assertEquals((short)127, new Byte((byte)127).shortValue()); - } - - /** - * @tests java.lang.Byte#toString() - */ - public void test_toString2() { - assertEquals("Returned incorrect String", "127", new Byte((byte) 127).toString()); - assertEquals("Returned incorrect String", "-127", new Byte((byte) -127).toString()); - assertEquals("Returned incorrect String", "-128", new Byte((byte) -128).toString()); - } - - /** - * @tests java.lang.Byte#toString(byte) - */ - public void test_toStringB2() { - assertEquals("Returned incorrect String", "127", Byte.toString((byte) 127)); - assertEquals("Returned incorrect String", "-127", Byte.toString((byte) -127)); - assertEquals("Returned incorrect String", "-128", Byte.toString((byte) -128)); - } - - /** - * @tests java.lang.Byte#valueOf(java.lang.String) - */ - public void test_valueOfLjava_lang_String2() { - assertEquals("Returned incorrect byte", 0, Byte.valueOf("0").byteValue()); - assertEquals("Returned incorrect byte", 127, Byte.valueOf("127").byteValue()); - assertEquals("Returned incorrect byte", -127, Byte.valueOf("-127").byteValue()); - assertEquals("Returned incorrect byte", -128, Byte.valueOf("-128").byteValue()); - - try { - Byte.valueOf("128"); - fail("Failed to throw exception when passes value > byte"); - } catch (NumberFormatException e) { - } - } - - /** - * @tests java.lang.Byte#valueOf(java.lang.String, int) - */ - public void test_valueOfLjava_lang_StringI2() { - assertEquals("Returned incorrect byte", 10, Byte.valueOf("A", 16).byteValue()); - assertEquals("Returned incorrect byte", 127, Byte.valueOf("127", 10).byteValue()); - assertEquals("Returned incorrect byte", -127, Byte.valueOf("-127", 10).byteValue()); - assertEquals("Returned incorrect byte", -128, Byte.valueOf("-128", 10).byteValue()); - assertEquals("Returned incorrect byte", 127, Byte.valueOf("7f", 16).byteValue()); - assertEquals("Returned incorrect byte", -127, Byte.valueOf("-7f", 16).byteValue()); - assertEquals("Returned incorrect byte", -128, Byte.valueOf("-80", 16).byteValue()); - - try { - Byte.valueOf("128", 10); - fail("Failed to throw exception when passes value > byte"); - } catch (NumberFormatException e) { - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/Character_SubsetTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/Character_SubsetTest.java deleted file mode 100644 index 6845396..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/Character_SubsetTest.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * 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(Character.Subset.class) -public class Character_SubsetTest extends TestCase { - - /** - * @tests java.lang.Character.Subset#Character.Subset(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Subset", - args = {java.lang.String.class} - ) - public void test_Ctor() { - - try { - // Regression for HARMONY-888 - new Character.Subset(null) { - }; - fail("No expected NullPointerException"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Character.Subset#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - - String name = "name"; - Character.Subset subset = new Character.Subset(name) { - }; - assertSame(name, subset.toString()); - } - - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) - public void test_equals() { - Character.Subset subset1 = new Character.Subset("name") { }; - assertTrue(subset1.equals(subset1)); - assertFalse(subset1.equals(new Character.Subset("name") {})); - assertFalse(subset1.equals(new Character.Subset("name1") {})); - assertFalse(subset1.equals(new Integer(0))); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) - public void test_hashCode() { - Character.Subset subset1 = new Character.Subset("name") {}; - Character.Subset subset2 = new Character.Subset("name") {}; - Character.Subset subset3 = new Character.Subset("name1") {}; - assertFalse(subset1.hashCode() == subset2.hashCode()); - assertFalse(subset1.hashCode() == subset3.hashCode()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/Character_UnicodeBlockTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/Character_UnicodeBlockTest.java deleted file mode 100644 index fa6bc9f..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/Character_UnicodeBlockTest.java +++ /dev/null @@ -1,879 +0,0 @@ -/* 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 junit.framework.TestCase; - -public class Character_UnicodeBlockTest extends TestCase { - - public void test_ofC() { - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.of((char)0x0)); - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.of((char)0x7f)); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.of((char)0x80)); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.of((char)0xff)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.of((char)0x100)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.of((char)0x17f)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.of((char)0x180)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.of((char)0x24f)); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.of((char)0x250)); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.of((char)0x2af)); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.of((char)0x2b0)); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.of((char)0x2ff)); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.of((char)0x300)); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.of((char)0x36f)); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.of((char)0x370)); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.of((char)0x3ff)); - assertEquals(Character.UnicodeBlock.CYRILLIC, Character.UnicodeBlock.of((char)0x400)); - assertEquals(Character.UnicodeBlock.CYRILLIC, Character.UnicodeBlock.of((char)0x4ff)); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.of((char)0x500)); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.of((char)0x52f)); - assertEquals(Character.UnicodeBlock.ARMENIAN, Character.UnicodeBlock.of((char)0x530)); - assertEquals(Character.UnicodeBlock.ARMENIAN, Character.UnicodeBlock.of((char)0x58f)); - assertEquals(Character.UnicodeBlock.HEBREW, Character.UnicodeBlock.of((char)0x590)); - assertEquals(Character.UnicodeBlock.HEBREW, Character.UnicodeBlock.of((char)0x5ff)); - assertEquals(Character.UnicodeBlock.ARABIC, Character.UnicodeBlock.of((char)0x600)); - assertEquals(Character.UnicodeBlock.ARABIC, Character.UnicodeBlock.of((char)0x6ff)); - assertEquals(Character.UnicodeBlock.SYRIAC, Character.UnicodeBlock.of((char)0x700)); - assertEquals(Character.UnicodeBlock.SYRIAC, Character.UnicodeBlock.of((char)0x74f)); - assertNull(Character.UnicodeBlock.of((char)0x750)); - assertNull(Character.UnicodeBlock.of((char)0x77f)); - assertEquals(Character.UnicodeBlock.THAANA, Character.UnicodeBlock.of((char)0x780)); - assertEquals(Character.UnicodeBlock.THAANA, Character.UnicodeBlock.of((char)0x7bf)); - assertNull(Character.UnicodeBlock.of((char)0x7c0)); - assertNull(Character.UnicodeBlock.of((char)0x8ff)); - assertEquals(Character.UnicodeBlock.DEVANAGARI, Character.UnicodeBlock.of((char)0x900)); - assertEquals(Character.UnicodeBlock.DEVANAGARI, Character.UnicodeBlock.of((char)0x97f)); - assertEquals(Character.UnicodeBlock.BENGALI, Character.UnicodeBlock.of((char)0x980)); - assertEquals(Character.UnicodeBlock.BENGALI, Character.UnicodeBlock.of((char)0x9ff)); - assertEquals(Character.UnicodeBlock.GURMUKHI, Character.UnicodeBlock.of((char)0xa00)); - assertEquals(Character.UnicodeBlock.GURMUKHI, Character.UnicodeBlock.of((char)0xa7f)); - assertEquals(Character.UnicodeBlock.GUJARATI, Character.UnicodeBlock.of((char)0xa80)); - assertEquals(Character.UnicodeBlock.GUJARATI, Character.UnicodeBlock.of((char)0xaff)); - assertEquals(Character.UnicodeBlock.ORIYA, Character.UnicodeBlock.of((char)0xb00)); - assertEquals(Character.UnicodeBlock.ORIYA, Character.UnicodeBlock.of((char)0xb7f)); - assertEquals(Character.UnicodeBlock.TAMIL, Character.UnicodeBlock.of((char)0xb80)); - assertEquals(Character.UnicodeBlock.TAMIL, Character.UnicodeBlock.of((char)0xbff)); - assertEquals(Character.UnicodeBlock.TELUGU, Character.UnicodeBlock.of((char)0xc00)); - assertEquals(Character.UnicodeBlock.TELUGU, Character.UnicodeBlock.of((char)0xc7f)); - assertEquals(Character.UnicodeBlock.KANNADA, Character.UnicodeBlock.of((char)0xc80)); - assertEquals(Character.UnicodeBlock.KANNADA, Character.UnicodeBlock.of((char)0xcff)); - assertEquals(Character.UnicodeBlock.MALAYALAM, Character.UnicodeBlock.of((char)0xd00)); - assertEquals(Character.UnicodeBlock.MALAYALAM, Character.UnicodeBlock.of((char)0xd7f)); - assertEquals(Character.UnicodeBlock.SINHALA, Character.UnicodeBlock.of((char)0xd80)); - assertEquals(Character.UnicodeBlock.SINHALA, Character.UnicodeBlock.of((char)0xdff)); - assertEquals(Character.UnicodeBlock.THAI, Character.UnicodeBlock.of((char)0xe00)); - assertEquals(Character.UnicodeBlock.THAI, Character.UnicodeBlock.of((char)0xe7f)); - assertEquals(Character.UnicodeBlock.LAO, Character.UnicodeBlock.of((char)0xe80)); - assertEquals(Character.UnicodeBlock.LAO, Character.UnicodeBlock.of((char)0xeff)); - assertEquals(Character.UnicodeBlock.TIBETAN, Character.UnicodeBlock.of((char)0xf00)); - assertEquals(Character.UnicodeBlock.TIBETAN, Character.UnicodeBlock.of((char)0xfff)); - assertEquals(Character.UnicodeBlock.MYANMAR, Character.UnicodeBlock.of((char)0x1000)); - assertEquals(Character.UnicodeBlock.MYANMAR, Character.UnicodeBlock.of((char)0x109f)); - assertEquals(Character.UnicodeBlock.GEORGIAN, Character.UnicodeBlock.of((char)0x10a0)); - assertEquals(Character.UnicodeBlock.GEORGIAN, Character.UnicodeBlock.of((char)0x10ff)); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.of((char)0x1100)); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.of((char)0x11ff)); - assertEquals(Character.UnicodeBlock.ETHIOPIC, Character.UnicodeBlock.of((char)0x1200)); - assertEquals(Character.UnicodeBlock.ETHIOPIC, Character.UnicodeBlock.of((char)0x137f)); - assertNull(Character.UnicodeBlock.of((char)0x1380)); - assertNull(Character.UnicodeBlock.of((char)0x139f)); - assertEquals(Character.UnicodeBlock.CHEROKEE, Character.UnicodeBlock.of((char)0x13a0)); - assertEquals(Character.UnicodeBlock.CHEROKEE, Character.UnicodeBlock.of((char)0x13ff)); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.of((char)0x1400)); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.of((char)0x167f)); - assertEquals(Character.UnicodeBlock.OGHAM, Character.UnicodeBlock.of((char)0x1680)); - assertEquals(Character.UnicodeBlock.OGHAM, Character.UnicodeBlock.of((char)0x169f)); - assertEquals(Character.UnicodeBlock.RUNIC, Character.UnicodeBlock.of((char)0x16a0)); - assertEquals(Character.UnicodeBlock.RUNIC, Character.UnicodeBlock.of((char)0x16ff)); - assertEquals(Character.UnicodeBlock.TAGALOG, Character.UnicodeBlock.of((char)0x1700)); - assertEquals(Character.UnicodeBlock.TAGALOG, Character.UnicodeBlock.of((char)0x171f)); - assertEquals(Character.UnicodeBlock.HANUNOO, Character.UnicodeBlock.of((char)0x1720)); - assertEquals(Character.UnicodeBlock.HANUNOO, Character.UnicodeBlock.of((char)0x173f)); - assertEquals(Character.UnicodeBlock.BUHID, Character.UnicodeBlock.of((char)0x1740)); - assertEquals(Character.UnicodeBlock.BUHID, Character.UnicodeBlock.of((char)0x175f)); - assertEquals(Character.UnicodeBlock.TAGBANWA, Character.UnicodeBlock.of((char)0x1760)); - assertEquals(Character.UnicodeBlock.TAGBANWA, Character.UnicodeBlock.of((char)0x177f)); - assertEquals(Character.UnicodeBlock.KHMER, Character.UnicodeBlock.of((char)0x1780)); - assertEquals(Character.UnicodeBlock.KHMER, Character.UnicodeBlock.of((char)0x17ff)); - assertEquals(Character.UnicodeBlock.MONGOLIAN, Character.UnicodeBlock.of((char)0x1800)); - assertEquals(Character.UnicodeBlock.MONGOLIAN, Character.UnicodeBlock.of((char)0x18af)); - assertNull(Character.UnicodeBlock.of((char)0x18b0)); - assertNull(Character.UnicodeBlock.of((char)0x18ff)); - assertEquals(Character.UnicodeBlock.LIMBU, Character.UnicodeBlock.of((char)0x1900)); - assertEquals(Character.UnicodeBlock.LIMBU, Character.UnicodeBlock.of((char)0x194f)); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.of((char)0x1950)); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.of((char)0x197f)); - assertNull(Character.UnicodeBlock.of((char)0x1980)); - assertNull(Character.UnicodeBlock.of((char)0x19df)); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.of((char)0x19e0)); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.of((char)0x19ff)); - assertNull(Character.UnicodeBlock.of((char)0x1a00)); - assertNull(Character.UnicodeBlock.of((char)0x1cff)); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.of((char)0x1d00)); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.of((char)0x1d7f)); - assertNull(Character.UnicodeBlock.of((char)0x1d80)); - assertNull(Character.UnicodeBlock.of((char)0x1dff)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.of((char)0x1e00)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.of((char)0x1eff)); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.of((char)0x1f00)); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.of((char)0x1fff)); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.of((char)0x2000)); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.of((char)0x206f)); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.of((char)0x2070)); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.of((char)0x209f)); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.of((char)0x20a0)); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.of((char)0x20cf)); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.of((char)0x20d0)); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.of((char)0x20ff)); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.of((char)0x2100)); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.of((char)0x214f)); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.of((char)0x2150)); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.of((char)0x218f)); - assertEquals(Character.UnicodeBlock.ARROWS, Character.UnicodeBlock.of((char)0x2190)); - assertEquals(Character.UnicodeBlock.ARROWS, Character.UnicodeBlock.of((char)0x21ff)); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of((char)0x2200)); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of((char)0x22ff)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.of((char)0x2300)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.of((char)0x23ff)); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.of((char)0x2400)); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.of((char)0x243f)); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.of((char)0x2440)); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.of((char)0x245f)); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.of((char)0x2460)); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.of((char)0x24ff)); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.of((char)0x2500)); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.of((char)0x257f)); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.of((char)0x2580)); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.of((char)0x259f)); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.of((char)0x25a0)); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.of((char)0x25ff)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.of((char)0x2600)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.of((char)0x26ff)); - assertEquals(Character.UnicodeBlock.DINGBATS, Character.UnicodeBlock.of((char)0x2700)); - assertEquals(Character.UnicodeBlock.DINGBATS, Character.UnicodeBlock.of((char)0x27bf)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.of((char)0x27c0)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.of((char)0x27ef)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.of((char)0x27f0)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.of((char)0x27ff)); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.of((char)0x2800)); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.of((char)0x28ff)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.of((char)0x2900)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.of((char)0x297f)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.of((char)0x2980)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.of((char)0x29ff)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of((char)0x2a00)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of((char)0x2aff)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.of((char)0x2b00)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.of((char)0x2bff)); - assertNull(Character.UnicodeBlock.of((char)0x2c00)); - assertNull(Character.UnicodeBlock.of((char)0x2e7f)); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.of((char)0x2e80)); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.of((char)0x2eff)); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.of((char)0x2f00)); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.of((char)0x2fdf)); - assertNull(Character.UnicodeBlock.of((char)0x2fe0)); - assertNull(Character.UnicodeBlock.of((char)0x2fef)); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.of((char)0x2ff0)); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.of((char)0x2fff)); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.of((char)0x3000)); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.of((char)0x303f)); - assertEquals(Character.UnicodeBlock.HIRAGANA, Character.UnicodeBlock.of((char)0x3040)); - assertEquals(Character.UnicodeBlock.HIRAGANA, Character.UnicodeBlock.of((char)0x309f)); - assertEquals(Character.UnicodeBlock.KATAKANA, Character.UnicodeBlock.of((char)0x30a0)); - assertEquals(Character.UnicodeBlock.KATAKANA, Character.UnicodeBlock.of((char)0x30ff)); - assertEquals(Character.UnicodeBlock.BOPOMOFO, Character.UnicodeBlock.of((char)0x3100)); - assertEquals(Character.UnicodeBlock.BOPOMOFO, Character.UnicodeBlock.of((char)0x312f)); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.of((char)0x3130)); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.of((char)0x318f)); - assertEquals(Character.UnicodeBlock.KANBUN, Character.UnicodeBlock.of((char)0x3190)); - assertEquals(Character.UnicodeBlock.KANBUN, Character.UnicodeBlock.of((char)0x319f)); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.of((char)0x31a0)); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.of((char)0x31bf)); - assertNull(Character.UnicodeBlock.of((char)0x31c0)); - assertNull(Character.UnicodeBlock.of((char)0x31ef)); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.of((char)0x31f0)); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.of((char)0x31ff)); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.of((char)0x3200)); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.of((char)0x32ff)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.of((char)0x3300)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.of((char)0x33ff)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.of((char)0x3400)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.of((char)0x4dbf)); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.of((char)0x4dc0)); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.of((char)0x4dff)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.of((char)0x4e00)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.of((char)0x9fff)); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.of((char)0xa000)); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.of((char)0xa48f)); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.of((char)0xa490)); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.of((char)0xa4cf)); - assertNull(Character.UnicodeBlock.of((char)0xa4d0)); - assertNull(Character.UnicodeBlock.of((char)0xabff)); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.of((char)0xac00)); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.of((char)0xd7af)); - assertNull(Character.UnicodeBlock.of((char)0xd7b0)); - assertNull(Character.UnicodeBlock.of((char)0xd7ff)); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.of((char)0xd800)); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.of((char)0xdb7f)); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.of((char)0xdb80)); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.of((char)0xdbff)); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.of((char)0xdc00)); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.of((char)0xdfff)); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.of((char)0xe000)); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.of((char)0xf8ff)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.of((char)0xf900)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.of((char)0xfaff)); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.of((char)0xfb00)); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.of((char)0xfb4f)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.of((char)0xfb50)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.of((char)0xfdff)); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.of((char)0xfe00)); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.of((char)0xfe0f)); - assertNull(Character.UnicodeBlock.of((char)0xfe10)); - assertNull(Character.UnicodeBlock.of((char)0xfe1f)); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.of((char)0xfe20)); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.of((char)0xfe2f)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.of((char)0xfe30)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.of((char)0xfe4f)); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.of((char)0xfe50)); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.of((char)0xfe6f)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.of((char)0xfe70)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.of((char)0xfeff)); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.of((char)0xff00)); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.of((char)0xffef)); - assertEquals(Character.UnicodeBlock.SPECIALS, Character.UnicodeBlock.of((char)0xfff0)); - assertEquals(Character.UnicodeBlock.SPECIALS, Character.UnicodeBlock.of((char)0xffff)); - } - public void test_ofI() { - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.of(0x0)); - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.of(0x7f)); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.of(0x80)); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.of(0xff)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.of(0x100)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.of(0x17f)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.of(0x180)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.of(0x24f)); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.of(0x250)); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.of(0x2af)); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.of(0x2b0)); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.of(0x2ff)); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.of(0x300)); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.of(0x36f)); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.of(0x370)); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.of(0x3ff)); - assertEquals(Character.UnicodeBlock.CYRILLIC, Character.UnicodeBlock.of(0x400)); - assertEquals(Character.UnicodeBlock.CYRILLIC, Character.UnicodeBlock.of(0x4ff)); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.of(0x500)); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.of(0x52f)); - assertEquals(Character.UnicodeBlock.ARMENIAN, Character.UnicodeBlock.of(0x530)); - assertEquals(Character.UnicodeBlock.ARMENIAN, Character.UnicodeBlock.of(0x58f)); - assertEquals(Character.UnicodeBlock.HEBREW, Character.UnicodeBlock.of(0x590)); - assertEquals(Character.UnicodeBlock.HEBREW, Character.UnicodeBlock.of(0x5ff)); - assertEquals(Character.UnicodeBlock.ARABIC, Character.UnicodeBlock.of(0x600)); - assertEquals(Character.UnicodeBlock.ARABIC, Character.UnicodeBlock.of(0x6ff)); - assertEquals(Character.UnicodeBlock.SYRIAC, Character.UnicodeBlock.of(0x700)); - assertEquals(Character.UnicodeBlock.SYRIAC, Character.UnicodeBlock.of(0x74f)); - assertNull(Character.UnicodeBlock.of(0x750)); - assertNull(Character.UnicodeBlock.of(0x77f)); - assertEquals(Character.UnicodeBlock.THAANA, Character.UnicodeBlock.of(0x780)); - assertEquals(Character.UnicodeBlock.THAANA, Character.UnicodeBlock.of(0x7bf)); - assertNull(Character.UnicodeBlock.of(0x7c0)); - assertNull(Character.UnicodeBlock.of(0x8ff)); - assertEquals(Character.UnicodeBlock.DEVANAGARI, Character.UnicodeBlock.of(0x900)); - assertEquals(Character.UnicodeBlock.DEVANAGARI, Character.UnicodeBlock.of(0x97f)); - assertEquals(Character.UnicodeBlock.BENGALI, Character.UnicodeBlock.of(0x980)); - assertEquals(Character.UnicodeBlock.BENGALI, Character.UnicodeBlock.of(0x9ff)); - assertEquals(Character.UnicodeBlock.GURMUKHI, Character.UnicodeBlock.of(0xa00)); - assertEquals(Character.UnicodeBlock.GURMUKHI, Character.UnicodeBlock.of(0xa7f)); - assertEquals(Character.UnicodeBlock.GUJARATI, Character.UnicodeBlock.of(0xa80)); - assertEquals(Character.UnicodeBlock.GUJARATI, Character.UnicodeBlock.of(0xaff)); - assertEquals(Character.UnicodeBlock.ORIYA, Character.UnicodeBlock.of(0xb00)); - assertEquals(Character.UnicodeBlock.ORIYA, Character.UnicodeBlock.of(0xb7f)); - assertEquals(Character.UnicodeBlock.TAMIL, Character.UnicodeBlock.of(0xb80)); - assertEquals(Character.UnicodeBlock.TAMIL, Character.UnicodeBlock.of(0xbff)); - assertEquals(Character.UnicodeBlock.TELUGU, Character.UnicodeBlock.of(0xc00)); - assertEquals(Character.UnicodeBlock.TELUGU, Character.UnicodeBlock.of(0xc7f)); - assertEquals(Character.UnicodeBlock.KANNADA, Character.UnicodeBlock.of(0xc80)); - assertEquals(Character.UnicodeBlock.KANNADA, Character.UnicodeBlock.of(0xcff)); - assertEquals(Character.UnicodeBlock.MALAYALAM, Character.UnicodeBlock.of(0xd00)); - assertEquals(Character.UnicodeBlock.MALAYALAM, Character.UnicodeBlock.of(0xd7f)); - assertEquals(Character.UnicodeBlock.SINHALA, Character.UnicodeBlock.of(0xd80)); - assertEquals(Character.UnicodeBlock.SINHALA, Character.UnicodeBlock.of(0xdff)); - assertEquals(Character.UnicodeBlock.THAI, Character.UnicodeBlock.of(0xe00)); - assertEquals(Character.UnicodeBlock.THAI, Character.UnicodeBlock.of(0xe7f)); - assertEquals(Character.UnicodeBlock.LAO, Character.UnicodeBlock.of(0xe80)); - assertEquals(Character.UnicodeBlock.LAO, Character.UnicodeBlock.of(0xeff)); - assertEquals(Character.UnicodeBlock.TIBETAN, Character.UnicodeBlock.of(0xf00)); - assertEquals(Character.UnicodeBlock.TIBETAN, Character.UnicodeBlock.of(0xfff)); - assertEquals(Character.UnicodeBlock.MYANMAR, Character.UnicodeBlock.of(0x1000)); - assertEquals(Character.UnicodeBlock.MYANMAR, Character.UnicodeBlock.of(0x109f)); - assertEquals(Character.UnicodeBlock.GEORGIAN, Character.UnicodeBlock.of(0x10a0)); - assertEquals(Character.UnicodeBlock.GEORGIAN, Character.UnicodeBlock.of(0x10ff)); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.of(0x1100)); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.of(0x11ff)); - assertEquals(Character.UnicodeBlock.ETHIOPIC, Character.UnicodeBlock.of(0x1200)); - assertEquals(Character.UnicodeBlock.ETHIOPIC, Character.UnicodeBlock.of(0x137f)); - assertNull(Character.UnicodeBlock.of(0x1380)); - assertNull(Character.UnicodeBlock.of(0x139f)); - assertEquals(Character.UnicodeBlock.CHEROKEE, Character.UnicodeBlock.of(0x13a0)); - assertEquals(Character.UnicodeBlock.CHEROKEE, Character.UnicodeBlock.of(0x13ff)); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.of(0x1400)); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.of(0x167f)); - assertEquals(Character.UnicodeBlock.OGHAM, Character.UnicodeBlock.of(0x1680)); - assertEquals(Character.UnicodeBlock.OGHAM, Character.UnicodeBlock.of(0x169f)); - assertEquals(Character.UnicodeBlock.RUNIC, Character.UnicodeBlock.of(0x16a0)); - assertEquals(Character.UnicodeBlock.RUNIC, Character.UnicodeBlock.of(0x16ff)); - assertEquals(Character.UnicodeBlock.TAGALOG, Character.UnicodeBlock.of(0x1700)); - assertEquals(Character.UnicodeBlock.TAGALOG, Character.UnicodeBlock.of(0x171f)); - assertEquals(Character.UnicodeBlock.HANUNOO, Character.UnicodeBlock.of(0x1720)); - assertEquals(Character.UnicodeBlock.HANUNOO, Character.UnicodeBlock.of(0x173f)); - assertEquals(Character.UnicodeBlock.BUHID, Character.UnicodeBlock.of(0x1740)); - assertEquals(Character.UnicodeBlock.BUHID, Character.UnicodeBlock.of(0x175f)); - assertEquals(Character.UnicodeBlock.TAGBANWA, Character.UnicodeBlock.of(0x1760)); - assertEquals(Character.UnicodeBlock.TAGBANWA, Character.UnicodeBlock.of(0x177f)); - assertEquals(Character.UnicodeBlock.KHMER, Character.UnicodeBlock.of(0x1780)); - assertEquals(Character.UnicodeBlock.KHMER, Character.UnicodeBlock.of(0x17ff)); - assertEquals(Character.UnicodeBlock.MONGOLIAN, Character.UnicodeBlock.of(0x1800)); - assertEquals(Character.UnicodeBlock.MONGOLIAN, Character.UnicodeBlock.of(0x18af)); - assertNull(Character.UnicodeBlock.of(0x18b0)); - assertNull(Character.UnicodeBlock.of(0x18ff)); - assertEquals(Character.UnicodeBlock.LIMBU, Character.UnicodeBlock.of(0x1900)); - assertEquals(Character.UnicodeBlock.LIMBU, Character.UnicodeBlock.of(0x194f)); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.of(0x1950)); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.of(0x197f)); - assertNull(Character.UnicodeBlock.of(0x1980)); - assertNull(Character.UnicodeBlock.of(0x19df)); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.of(0x19e0)); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.of(0x19ff)); - assertNull(Character.UnicodeBlock.of(0x1a00)); - assertNull(Character.UnicodeBlock.of(0x1cff)); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.of(0x1d00)); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.of(0x1d7f)); - assertNull(Character.UnicodeBlock.of(0x1d80)); - assertNull(Character.UnicodeBlock.of(0x1dff)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.of(0x1e00)); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.of(0x1eff)); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.of(0x1f00)); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.of(0x1fff)); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.of(0x2000)); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.of(0x206f)); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.of(0x2070)); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.of(0x209f)); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.of(0x20a0)); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.of(0x20cf)); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.of(0x20d0)); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.of(0x20ff)); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.of(0x2100)); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.of(0x214f)); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.of(0x2150)); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.of(0x218f)); - assertEquals(Character.UnicodeBlock.ARROWS, Character.UnicodeBlock.of(0x2190)); - assertEquals(Character.UnicodeBlock.ARROWS, Character.UnicodeBlock.of(0x21ff)); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of(0x2200)); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of(0x22ff)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.of(0x2300)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.of(0x23ff)); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.of(0x2400)); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.of(0x243f)); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.of(0x2440)); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.of(0x245f)); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.of(0x2460)); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.of(0x24ff)); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.of(0x2500)); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.of(0x257f)); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.of(0x2580)); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.of(0x259f)); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.of(0x25a0)); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.of(0x25ff)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.of(0x2600)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.of(0x26ff)); - assertEquals(Character.UnicodeBlock.DINGBATS, Character.UnicodeBlock.of(0x2700)); - assertEquals(Character.UnicodeBlock.DINGBATS, Character.UnicodeBlock.of(0x27bf)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.of(0x27c0)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.of(0x27ef)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.of(0x27f0)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.of(0x27ff)); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.of(0x2800)); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.of(0x28ff)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.of(0x2900)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.of(0x297f)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.of(0x2980)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.of(0x29ff)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of(0x2a00)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.of(0x2aff)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.of(0x2b00)); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.of(0x2bff)); - assertNull(Character.UnicodeBlock.of(0x2c00)); - assertNull(Character.UnicodeBlock.of(0x2e7f)); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.of(0x2e80)); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.of(0x2eff)); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.of(0x2f00)); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.of(0x2fdf)); - assertNull(Character.UnicodeBlock.of(0x2fe0)); - assertNull(Character.UnicodeBlock.of(0x2fef)); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.of(0x2ff0)); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.of(0x2fff)); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.of(0x3000)); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.of(0x303f)); - assertEquals(Character.UnicodeBlock.HIRAGANA, Character.UnicodeBlock.of(0x3040)); - assertEquals(Character.UnicodeBlock.HIRAGANA, Character.UnicodeBlock.of(0x309f)); - assertEquals(Character.UnicodeBlock.KATAKANA, Character.UnicodeBlock.of(0x30a0)); - assertEquals(Character.UnicodeBlock.KATAKANA, Character.UnicodeBlock.of(0x30ff)); - assertEquals(Character.UnicodeBlock.BOPOMOFO, Character.UnicodeBlock.of(0x3100)); - assertEquals(Character.UnicodeBlock.BOPOMOFO, Character.UnicodeBlock.of(0x312f)); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.of(0x3130)); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.of(0x318f)); - assertEquals(Character.UnicodeBlock.KANBUN, Character.UnicodeBlock.of(0x3190)); - assertEquals(Character.UnicodeBlock.KANBUN, Character.UnicodeBlock.of(0x319f)); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.of(0x31a0)); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.of(0x31bf)); - assertNull(Character.UnicodeBlock.of(0x31c0)); - assertNull(Character.UnicodeBlock.of(0x31ef)); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.of(0x31f0)); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.of(0x31ff)); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.of(0x3200)); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.of(0x32ff)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.of(0x3300)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.of(0x33ff)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.of(0x3400)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.of(0x4dbf)); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.of(0x4dc0)); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.of(0x4dff)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.of(0x4e00)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.of(0x9fff)); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.of(0xa000)); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.of(0xa48f)); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.of(0xa490)); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.of(0xa4cf)); - assertNull(Character.UnicodeBlock.of(0xa4d0)); - assertNull(Character.UnicodeBlock.of(0xabff)); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.of(0xac00)); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.of(0xd7af)); - assertNull(Character.UnicodeBlock.of(0xd7b0)); - assertNull(Character.UnicodeBlock.of(0xd7ff)); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.of(0xd800)); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.of(0xdb7f)); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.of(0xdb80)); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.of(0xdbff)); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.of(0xdc00)); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.of(0xdfff)); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.of(0xe000)); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.of(0xf8ff)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.of(0xf900)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.of(0xfaff)); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.of(0xfb00)); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.of(0xfb4f)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.of(0xfb50)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.of(0xfdff)); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.of(0xfe00)); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.of(0xfe0f)); - assertNull(Character.UnicodeBlock.of(0xfe10)); - assertNull(Character.UnicodeBlock.of(0xfe1f)); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.of(0xfe20)); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.of(0xfe2f)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.of(0xfe30)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.of(0xfe4f)); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.of(0xfe50)); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.of(0xfe6f)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.of(0xfe70)); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.of(0xfeff)); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.of(0xff00)); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.of(0xffef)); - assertEquals(Character.UnicodeBlock.SPECIALS, Character.UnicodeBlock.of(0xfff0)); - assertEquals(Character.UnicodeBlock.SPECIALS, Character.UnicodeBlock.of(0xffff)); - assertEquals(Character.UnicodeBlock.LINEAR_B_SYLLABARY, Character.UnicodeBlock.of(0x10000)); - assertEquals(Character.UnicodeBlock.LINEAR_B_SYLLABARY, Character.UnicodeBlock.of(0x1007f)); - assertEquals(Character.UnicodeBlock.LINEAR_B_IDEOGRAMS, Character.UnicodeBlock.of(0x10080)); - assertEquals(Character.UnicodeBlock.LINEAR_B_IDEOGRAMS, Character.UnicodeBlock.of(0x100ff)); - assertEquals(Character.UnicodeBlock.AEGEAN_NUMBERS, Character.UnicodeBlock.of(0x10100)); - assertEquals(Character.UnicodeBlock.AEGEAN_NUMBERS, Character.UnicodeBlock.of(0x1013f)); - assertNull(Character.UnicodeBlock.of(0x10140)); - assertNull(Character.UnicodeBlock.of(0x102ff)); - assertEquals(Character.UnicodeBlock.OLD_ITALIC, Character.UnicodeBlock.of(0x10300)); - assertEquals(Character.UnicodeBlock.OLD_ITALIC, Character.UnicodeBlock.of(0x1032f)); - assertEquals(Character.UnicodeBlock.GOTHIC, Character.UnicodeBlock.of(0x10330)); - assertEquals(Character.UnicodeBlock.GOTHIC, Character.UnicodeBlock.of(0x1034f)); - assertNull(Character.UnicodeBlock.of(0x10350)); - assertNull(Character.UnicodeBlock.of(0x1037f)); - assertEquals(Character.UnicodeBlock.UGARITIC, Character.UnicodeBlock.of(0x10380)); - assertEquals(Character.UnicodeBlock.UGARITIC, Character.UnicodeBlock.of(0x1039f)); - assertNull(Character.UnicodeBlock.of(0x103a0)); - assertNull(Character.UnicodeBlock.of(0x103ff)); - assertEquals(Character.UnicodeBlock.DESERET, Character.UnicodeBlock.of(0x10400)); - assertEquals(Character.UnicodeBlock.DESERET, Character.UnicodeBlock.of(0x1044f)); - assertEquals(Character.UnicodeBlock.SHAVIAN, Character.UnicodeBlock.of(0x10450)); - assertEquals(Character.UnicodeBlock.SHAVIAN, Character.UnicodeBlock.of(0x1047f)); - assertEquals(Character.UnicodeBlock.OSMANYA, Character.UnicodeBlock.of(0x10480)); - assertEquals(Character.UnicodeBlock.OSMANYA, Character.UnicodeBlock.of(0x104af)); - assertNull(Character.UnicodeBlock.of(0x104b0)); - assertNull(Character.UnicodeBlock.of(0x107ff)); - assertEquals(Character.UnicodeBlock.CYPRIOT_SYLLABARY, Character.UnicodeBlock.of(0x10800)); - assertEquals(Character.UnicodeBlock.CYPRIOT_SYLLABARY, Character.UnicodeBlock.of(0x1083f)); - assertNull(Character.UnicodeBlock.of(0x10840)); - assertNull(Character.UnicodeBlock.of(0x1cfff)); - assertEquals(Character.UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS, Character.UnicodeBlock.of(0x1d000)); - assertEquals(Character.UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS, Character.UnicodeBlock.of(0x1d0ff)); - assertEquals(Character.UnicodeBlock.MUSICAL_SYMBOLS, Character.UnicodeBlock.of(0x1d100)); - assertEquals(Character.UnicodeBlock.MUSICAL_SYMBOLS, Character.UnicodeBlock.of(0x1d1ff)); - assertNull(Character.UnicodeBlock.of(0x1d200)); - assertNull(Character.UnicodeBlock.of(0x1d2ff)); - assertEquals(Character.UnicodeBlock.TAI_XUAN_JING_SYMBOLS, Character.UnicodeBlock.of(0x1d300)); - assertEquals(Character.UnicodeBlock.TAI_XUAN_JING_SYMBOLS, Character.UnicodeBlock.of(0x1d35f)); - assertNull(Character.UnicodeBlock.of(0x1d360)); - assertNull(Character.UnicodeBlock.of(0x1d3ff)); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_ALPHANUMERIC_SYMBOLS, Character.UnicodeBlock.of(0x1d400)); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_ALPHANUMERIC_SYMBOLS, Character.UnicodeBlock.of(0x1d7ff)); - assertNull(Character.UnicodeBlock.of(0x1d800)); - assertNull(Character.UnicodeBlock.of(0x1ffff)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, Character.UnicodeBlock.of(0x20000)); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, Character.UnicodeBlock.of(0x2a6df)); - assertNull(Character.UnicodeBlock.of(0x2a6e0)); - assertNull(Character.UnicodeBlock.of(0x2f7ff)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, Character.UnicodeBlock.of(0x2f800)); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, Character.UnicodeBlock.of(0x2fa1f)); - assertNull(Character.UnicodeBlock.of(0x2fa20)); - assertNull(Character.UnicodeBlock.of(0xdffff)); - assertEquals(Character.UnicodeBlock.TAGS, Character.UnicodeBlock.of(0xe0000)); - assertEquals(Character.UnicodeBlock.TAGS, Character.UnicodeBlock.of(0xe007f)); - assertNull(Character.UnicodeBlock.of(0xe0080)); - assertNull(Character.UnicodeBlock.of(0xe00ff)); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS_SUPPLEMENT, Character.UnicodeBlock.of(0xe0100)); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS_SUPPLEMENT, Character.UnicodeBlock.of(0xe01ef)); - assertNull(Character.UnicodeBlock.of(0xe01f0)); - assertNull(Character.UnicodeBlock.of(0xeffff)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_A, Character.UnicodeBlock.of(0xf0000)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_A, Character.UnicodeBlock.of(0xfffff)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B, Character.UnicodeBlock.of(0x100000)); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B, Character.UnicodeBlock.of(0x10ffff)); - } - - public void test_ofIExceptions() { - try { - Character.UnicodeBlock.of(Character.MAX_CODE_POINT + 1); - fail("No illegal argument exception"); - } catch(IllegalArgumentException e) { - } - } - - @SuppressWarnings("deprecation") - public void test_forNameLjava_lang_String() { - assertEquals(Character.UnicodeBlock.SURROGATES_AREA, Character.UnicodeBlock.forName("SURROGATES_AREA")); - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.forName("BASIC_LATIN")); - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.forName("Basic Latin")); - assertEquals(Character.UnicodeBlock.BASIC_LATIN, Character.UnicodeBlock.forName("BasicLatin")); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.forName("LATIN_1_SUPPLEMENT")); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.forName("Latin-1 Supplement")); - assertEquals(Character.UnicodeBlock.LATIN_1_SUPPLEMENT, Character.UnicodeBlock.forName("Latin-1Supplement")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.forName("LATIN_EXTENDED_A")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.forName("Latin Extended-A")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_A, Character.UnicodeBlock.forName("LatinExtended-A")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.forName("LATIN_EXTENDED_B")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.forName("Latin Extended-B")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_B, Character.UnicodeBlock.forName("LatinExtended-B")); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.forName("IPA_EXTENSIONS")); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.forName("IPA Extensions")); - assertEquals(Character.UnicodeBlock.IPA_EXTENSIONS, Character.UnicodeBlock.forName("IPAExtensions")); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.forName("SPACING_MODIFIER_LETTERS")); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.forName("Spacing Modifier Letters")); - assertEquals(Character.UnicodeBlock.SPACING_MODIFIER_LETTERS, Character.UnicodeBlock.forName("SpacingModifierLetters")); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.forName("COMBINING_DIACRITICAL_MARKS")); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.forName("Combining Diacritical Marks")); - assertEquals(Character.UnicodeBlock.COMBINING_DIACRITICAL_MARKS, Character.UnicodeBlock.forName("CombiningDiacriticalMarks")); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.forName("GREEK")); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.forName("Greek and Coptic")); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.forName("GreekandCoptic")); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.forName("Greek")); - assertEquals(Character.UnicodeBlock.GREEK, Character.UnicodeBlock.forName("Greek")); - assertEquals(Character.UnicodeBlock.CYRILLIC, Character.UnicodeBlock.forName("CYRILLIC")); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.forName("CYRILLIC_SUPPLEMENTARY")); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.forName("Cyrillic Supplementary")); - assertEquals(Character.UnicodeBlock.CYRILLIC_SUPPLEMENTARY, Character.UnicodeBlock.forName("CyrillicSupplementary")); - assertEquals(Character.UnicodeBlock.ARMENIAN, Character.UnicodeBlock.forName("ARMENIAN")); - assertEquals(Character.UnicodeBlock.HEBREW, Character.UnicodeBlock.forName("HEBREW")); - assertEquals(Character.UnicodeBlock.ARABIC, Character.UnicodeBlock.forName("ARABIC")); - assertEquals(Character.UnicodeBlock.SYRIAC, Character.UnicodeBlock.forName("SYRIAC")); - assertEquals(Character.UnicodeBlock.THAANA, Character.UnicodeBlock.forName("THAANA")); - assertEquals(Character.UnicodeBlock.DEVANAGARI, Character.UnicodeBlock.forName("DEVANAGARI")); - assertEquals(Character.UnicodeBlock.BENGALI, Character.UnicodeBlock.forName("BENGALI")); - assertEquals(Character.UnicodeBlock.GURMUKHI, Character.UnicodeBlock.forName("GURMUKHI")); - assertEquals(Character.UnicodeBlock.GUJARATI, Character.UnicodeBlock.forName("GUJARATI")); - assertEquals(Character.UnicodeBlock.ORIYA, Character.UnicodeBlock.forName("ORIYA")); - assertEquals(Character.UnicodeBlock.TAMIL, Character.UnicodeBlock.forName("TAMIL")); - assertEquals(Character.UnicodeBlock.TELUGU, Character.UnicodeBlock.forName("TELUGU")); - assertEquals(Character.UnicodeBlock.KANNADA, Character.UnicodeBlock.forName("KANNADA")); - assertEquals(Character.UnicodeBlock.MALAYALAM, Character.UnicodeBlock.forName("MALAYALAM")); - assertEquals(Character.UnicodeBlock.SINHALA, Character.UnicodeBlock.forName("SINHALA")); - assertEquals(Character.UnicodeBlock.THAI, Character.UnicodeBlock.forName("THAI")); - assertEquals(Character.UnicodeBlock.LAO, Character.UnicodeBlock.forName("LAO")); - assertEquals(Character.UnicodeBlock.TIBETAN, Character.UnicodeBlock.forName("TIBETAN")); - assertEquals(Character.UnicodeBlock.MYANMAR, Character.UnicodeBlock.forName("MYANMAR")); - assertEquals(Character.UnicodeBlock.GEORGIAN, Character.UnicodeBlock.forName("GEORGIAN")); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.forName("HANGUL_JAMO")); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.forName("Hangul Jamo")); - assertEquals(Character.UnicodeBlock.HANGUL_JAMO, Character.UnicodeBlock.forName("HangulJamo")); - assertEquals(Character.UnicodeBlock.ETHIOPIC, Character.UnicodeBlock.forName("ETHIOPIC")); - assertEquals(Character.UnicodeBlock.CHEROKEE, Character.UnicodeBlock.forName("CHEROKEE")); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.forName("UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS")); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.forName("Unified Canadian Aboriginal Syllabics")); - assertEquals(Character.UnicodeBlock.UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS, Character.UnicodeBlock.forName("UnifiedCanadianAboriginalSyllabics")); - assertEquals(Character.UnicodeBlock.OGHAM, Character.UnicodeBlock.forName("OGHAM")); - assertEquals(Character.UnicodeBlock.RUNIC, Character.UnicodeBlock.forName("RUNIC")); - assertEquals(Character.UnicodeBlock.TAGALOG, Character.UnicodeBlock.forName("TAGALOG")); - assertEquals(Character.UnicodeBlock.HANUNOO, Character.UnicodeBlock.forName("HANUNOO")); - assertEquals(Character.UnicodeBlock.BUHID, Character.UnicodeBlock.forName("BUHID")); - assertEquals(Character.UnicodeBlock.TAGBANWA, Character.UnicodeBlock.forName("TAGBANWA")); - assertEquals(Character.UnicodeBlock.KHMER, Character.UnicodeBlock.forName("KHMER")); - assertEquals(Character.UnicodeBlock.MONGOLIAN, Character.UnicodeBlock.forName("MONGOLIAN")); - assertEquals(Character.UnicodeBlock.LIMBU, Character.UnicodeBlock.forName("LIMBU")); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.forName("TAI_LE")); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.forName("Tai Le")); - assertEquals(Character.UnicodeBlock.TAI_LE, Character.UnicodeBlock.forName("TaiLe")); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.forName("KHMER_SYMBOLS")); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.forName("Khmer Symbols")); - assertEquals(Character.UnicodeBlock.KHMER_SYMBOLS, Character.UnicodeBlock.forName("KhmerSymbols")); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.forName("PHONETIC_EXTENSIONS")); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.forName("Phonetic Extensions")); - assertEquals(Character.UnicodeBlock.PHONETIC_EXTENSIONS, Character.UnicodeBlock.forName("PhoneticExtensions")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.forName("LATIN_EXTENDED_ADDITIONAL")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.forName("Latin Extended Additional")); - assertEquals(Character.UnicodeBlock.LATIN_EXTENDED_ADDITIONAL, Character.UnicodeBlock.forName("LatinExtendedAdditional")); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.forName("GREEK_EXTENDED")); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.forName("Greek Extended")); - assertEquals(Character.UnicodeBlock.GREEK_EXTENDED, Character.UnicodeBlock.forName("GreekExtended")); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.forName("GENERAL_PUNCTUATION")); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.forName("General Punctuation")); - assertEquals(Character.UnicodeBlock.GENERAL_PUNCTUATION, Character.UnicodeBlock.forName("GeneralPunctuation")); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.forName("SUPERSCRIPTS_AND_SUBSCRIPTS")); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.forName("Superscripts and Subscripts")); - assertEquals(Character.UnicodeBlock.SUPERSCRIPTS_AND_SUBSCRIPTS, Character.UnicodeBlock.forName("SuperscriptsandSubscripts")); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.forName("CURRENCY_SYMBOLS")); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.forName("Currency Symbols")); - assertEquals(Character.UnicodeBlock.CURRENCY_SYMBOLS, Character.UnicodeBlock.forName("CurrencySymbols")); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.forName("COMBINING_MARKS_FOR_SYMBOLS")); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.forName("Combining Diacritical Marks for Symbols")); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.forName("CombiningDiacriticalMarksforSymbols")); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.forName("Combining Marks for Symbols")); - assertEquals(Character.UnicodeBlock.COMBINING_MARKS_FOR_SYMBOLS, Character.UnicodeBlock.forName("CombiningMarksforSymbols")); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.forName("LETTERLIKE_SYMBOLS")); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.forName("Letterlike Symbols")); - assertEquals(Character.UnicodeBlock.LETTERLIKE_SYMBOLS, Character.UnicodeBlock.forName("LetterlikeSymbols")); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.forName("NUMBER_FORMS")); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.forName("Number Forms")); - assertEquals(Character.UnicodeBlock.NUMBER_FORMS, Character.UnicodeBlock.forName("NumberForms")); - assertEquals(Character.UnicodeBlock.ARROWS, Character.UnicodeBlock.forName("ARROWS")); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.forName("MATHEMATICAL_OPERATORS")); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.forName("Mathematical Operators")); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_OPERATORS, Character.UnicodeBlock.forName("MathematicalOperators")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.forName("MISCELLANEOUS_TECHNICAL")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.forName("Miscellaneous Technical")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_TECHNICAL, Character.UnicodeBlock.forName("MiscellaneousTechnical")); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.forName("CONTROL_PICTURES")); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.forName("Control Pictures")); - assertEquals(Character.UnicodeBlock.CONTROL_PICTURES, Character.UnicodeBlock.forName("ControlPictures")); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.forName("OPTICAL_CHARACTER_RECOGNITION")); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.forName("Optical Character Recognition")); - assertEquals(Character.UnicodeBlock.OPTICAL_CHARACTER_RECOGNITION, Character.UnicodeBlock.forName("OpticalCharacterRecognition")); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.forName("ENCLOSED_ALPHANUMERICS")); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.forName("Enclosed Alphanumerics")); - assertEquals(Character.UnicodeBlock.ENCLOSED_ALPHANUMERICS, Character.UnicodeBlock.forName("EnclosedAlphanumerics")); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.forName("BOX_DRAWING")); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.forName("Box Drawing")); - assertEquals(Character.UnicodeBlock.BOX_DRAWING, Character.UnicodeBlock.forName("BoxDrawing")); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.forName("BLOCK_ELEMENTS")); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.forName("Block Elements")); - assertEquals(Character.UnicodeBlock.BLOCK_ELEMENTS, Character.UnicodeBlock.forName("BlockElements")); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.forName("GEOMETRIC_SHAPES")); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.forName("Geometric Shapes")); - assertEquals(Character.UnicodeBlock.GEOMETRIC_SHAPES, Character.UnicodeBlock.forName("GeometricShapes")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.forName("MISCELLANEOUS_SYMBOLS")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.forName("Miscellaneous Symbols")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS, Character.UnicodeBlock.forName("MiscellaneousSymbols")); - assertEquals(Character.UnicodeBlock.DINGBATS, Character.UnicodeBlock.forName("DINGBATS")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.forName("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.forName("Miscellaneous Mathematical Symbols-A")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A, Character.UnicodeBlock.forName("MiscellaneousMathematicalSymbols-A")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.forName("SUPPLEMENTAL_ARROWS_A")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.forName("Supplemental Arrows-A")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_A, Character.UnicodeBlock.forName("SupplementalArrows-A")); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.forName("BRAILLE_PATTERNS")); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.forName("Braille Patterns")); - assertEquals(Character.UnicodeBlock.BRAILLE_PATTERNS, Character.UnicodeBlock.forName("BraillePatterns")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.forName("SUPPLEMENTAL_ARROWS_B")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.forName("Supplemental Arrows-B")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_ARROWS_B, Character.UnicodeBlock.forName("SupplementalArrows-B")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.forName("MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.forName("Miscellaneous Mathematical Symbols-B")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B, Character.UnicodeBlock.forName("MiscellaneousMathematicalSymbols-B")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.forName("SUPPLEMENTAL_MATHEMATICAL_OPERATORS")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.forName("Supplemental Mathematical Operators")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTAL_MATHEMATICAL_OPERATORS, Character.UnicodeBlock.forName("SupplementalMathematicalOperators")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.forName("MISCELLANEOUS_SYMBOLS_AND_ARROWS")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.forName("Miscellaneous Symbols and Arrows")); - assertEquals(Character.UnicodeBlock.MISCELLANEOUS_SYMBOLS_AND_ARROWS, Character.UnicodeBlock.forName("MiscellaneousSymbolsandArrows")); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.forName("CJK_RADICALS_SUPPLEMENT")); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.forName("CJK Radicals Supplement")); - assertEquals(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT, Character.UnicodeBlock.forName("CJKRadicalsSupplement")); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.forName("KANGXI_RADICALS")); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.forName("Kangxi Radicals")); - assertEquals(Character.UnicodeBlock.KANGXI_RADICALS, Character.UnicodeBlock.forName("KangxiRadicals")); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.forName("IDEOGRAPHIC_DESCRIPTION_CHARACTERS")); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.forName("Ideographic Description Characters")); - assertEquals(Character.UnicodeBlock.IDEOGRAPHIC_DESCRIPTION_CHARACTERS, Character.UnicodeBlock.forName("IdeographicDescriptionCharacters")); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.forName("CJK_SYMBOLS_AND_PUNCTUATION")); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.forName("CJK Symbols and Punctuation")); - assertEquals(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION, Character.UnicodeBlock.forName("CJKSymbolsandPunctuation")); - assertEquals(Character.UnicodeBlock.HIRAGANA, Character.UnicodeBlock.forName("HIRAGANA")); - assertEquals(Character.UnicodeBlock.KATAKANA, Character.UnicodeBlock.forName("KATAKANA")); - assertEquals(Character.UnicodeBlock.BOPOMOFO, Character.UnicodeBlock.forName("BOPOMOFO")); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.forName("HANGUL_COMPATIBILITY_JAMO")); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.forName("Hangul Compatibility Jamo")); - assertEquals(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO, Character.UnicodeBlock.forName("HangulCompatibilityJamo")); - assertEquals(Character.UnicodeBlock.KANBUN, Character.UnicodeBlock.forName("KANBUN")); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.forName("BOPOMOFO_EXTENDED")); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.forName("Bopomofo Extended")); - assertEquals(Character.UnicodeBlock.BOPOMOFO_EXTENDED, Character.UnicodeBlock.forName("BopomofoExtended")); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.forName("KATAKANA_PHONETIC_EXTENSIONS")); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.forName("Katakana Phonetic Extensions")); - assertEquals(Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS, Character.UnicodeBlock.forName("KatakanaPhoneticExtensions")); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.forName("ENCLOSED_CJK_LETTERS_AND_MONTHS")); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.forName("Enclosed CJK Letters and Months")); - assertEquals(Character.UnicodeBlock.ENCLOSED_CJK_LETTERS_AND_MONTHS, Character.UnicodeBlock.forName("EnclosedCJKLettersandMonths")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.forName("CJK_COMPATIBILITY")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.forName("CJK Compatibility")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY, Character.UnicodeBlock.forName("CJKCompatibility")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.forName("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.forName("CJK Unified Ideographs Extension A")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A, Character.UnicodeBlock.forName("CJKUnifiedIdeographsExtensionA")); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.forName("YIJING_HEXAGRAM_SYMBOLS")); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.forName("Yijing Hexagram Symbols")); - assertEquals(Character.UnicodeBlock.YIJING_HEXAGRAM_SYMBOLS, Character.UnicodeBlock.forName("YijingHexagramSymbols")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.forName("CJK_UNIFIED_IDEOGRAPHS")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.forName("CJK Unified Ideographs")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS, Character.UnicodeBlock.forName("CJKUnifiedIdeographs")); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.forName("YI_SYLLABLES")); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.forName("Yi Syllables")); - assertEquals(Character.UnicodeBlock.YI_SYLLABLES, Character.UnicodeBlock.forName("YiSyllables")); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.forName("YI_RADICALS")); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.forName("Yi Radicals")); - assertEquals(Character.UnicodeBlock.YI_RADICALS, Character.UnicodeBlock.forName("YiRadicals")); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.forName("HANGUL_SYLLABLES")); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.forName("Hangul Syllables")); - assertEquals(Character.UnicodeBlock.HANGUL_SYLLABLES, Character.UnicodeBlock.forName("HangulSyllables")); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.forName("HIGH_SURROGATES")); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.forName("High Surrogates")); - assertEquals(Character.UnicodeBlock.HIGH_SURROGATES, Character.UnicodeBlock.forName("HighSurrogates")); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.forName("HIGH_PRIVATE_USE_SURROGATES")); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.forName("High Private Use Surrogates")); - assertEquals(Character.UnicodeBlock.HIGH_PRIVATE_USE_SURROGATES, Character.UnicodeBlock.forName("HighPrivateUseSurrogates")); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.forName("LOW_SURROGATES")); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.forName("Low Surrogates")); - assertEquals(Character.UnicodeBlock.LOW_SURROGATES, Character.UnicodeBlock.forName("LowSurrogates")); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.forName("PRIVATE_USE_AREA")); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.forName("Private Use Area")); - assertEquals(Character.UnicodeBlock.PRIVATE_USE_AREA, Character.UnicodeBlock.forName("PrivateUseArea")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.forName("CJK_COMPATIBILITY_IDEOGRAPHS")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.forName("CJK Compatibility Ideographs")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS, Character.UnicodeBlock.forName("CJKCompatibilityIdeographs")); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.forName("ALPHABETIC_PRESENTATION_FORMS")); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.forName("Alphabetic Presentation Forms")); - assertEquals(Character.UnicodeBlock.ALPHABETIC_PRESENTATION_FORMS, Character.UnicodeBlock.forName("AlphabeticPresentationForms")); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.forName("ARABIC_PRESENTATION_FORMS_A")); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.forName("Arabic Presentation Forms-A")); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_A, Character.UnicodeBlock.forName("ArabicPresentationForms-A")); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.forName("VARIATION_SELECTORS")); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.forName("Variation Selectors")); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS, Character.UnicodeBlock.forName("VariationSelectors")); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.forName("COMBINING_HALF_MARKS")); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.forName("Combining Half Marks")); - assertEquals(Character.UnicodeBlock.COMBINING_HALF_MARKS, Character.UnicodeBlock.forName("CombiningHalfMarks")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.forName("CJK_COMPATIBILITY_FORMS")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.forName("CJK Compatibility Forms")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS, Character.UnicodeBlock.forName("CJKCompatibilityForms")); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.forName("SMALL_FORM_VARIANTS")); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.forName("Small Form Variants")); - assertEquals(Character.UnicodeBlock.SMALL_FORM_VARIANTS, Character.UnicodeBlock.forName("SmallFormVariants")); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.forName("ARABIC_PRESENTATION_FORMS_B")); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.forName("Arabic Presentation Forms-B")); - assertEquals(Character.UnicodeBlock.ARABIC_PRESENTATION_FORMS_B, Character.UnicodeBlock.forName("ArabicPresentationForms-B")); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.forName("HALFWIDTH_AND_FULLWIDTH_FORMS")); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.forName("Halfwidth and Fullwidth Forms")); - assertEquals(Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS, Character.UnicodeBlock.forName("HalfwidthandFullwidthForms")); - assertEquals(Character.UnicodeBlock.SPECIALS, Character.UnicodeBlock.forName("SPECIALS")); - assertEquals(Character.UnicodeBlock.LINEAR_B_SYLLABARY, Character.UnicodeBlock.forName("LINEAR_B_SYLLABARY")); - assertEquals(Character.UnicodeBlock.LINEAR_B_SYLLABARY, Character.UnicodeBlock.forName("Linear B Syllabary")); - assertEquals(Character.UnicodeBlock.LINEAR_B_SYLLABARY, Character.UnicodeBlock.forName("LinearBSyllabary")); - assertEquals(Character.UnicodeBlock.LINEAR_B_IDEOGRAMS, Character.UnicodeBlock.forName("LINEAR_B_IDEOGRAMS")); - assertEquals(Character.UnicodeBlock.LINEAR_B_IDEOGRAMS, Character.UnicodeBlock.forName("Linear B Ideograms")); - assertEquals(Character.UnicodeBlock.LINEAR_B_IDEOGRAMS, Character.UnicodeBlock.forName("LinearBIdeograms")); - assertEquals(Character.UnicodeBlock.AEGEAN_NUMBERS, Character.UnicodeBlock.forName("AEGEAN_NUMBERS")); - assertEquals(Character.UnicodeBlock.AEGEAN_NUMBERS, Character.UnicodeBlock.forName("Aegean Numbers")); - assertEquals(Character.UnicodeBlock.AEGEAN_NUMBERS, Character.UnicodeBlock.forName("AegeanNumbers")); - assertEquals(Character.UnicodeBlock.OLD_ITALIC, Character.UnicodeBlock.forName("OLD_ITALIC")); - assertEquals(Character.UnicodeBlock.OLD_ITALIC, Character.UnicodeBlock.forName("Old Italic")); - assertEquals(Character.UnicodeBlock.OLD_ITALIC, Character.UnicodeBlock.forName("OldItalic")); - assertEquals(Character.UnicodeBlock.GOTHIC, Character.UnicodeBlock.forName("GOTHIC")); - assertEquals(Character.UnicodeBlock.UGARITIC, Character.UnicodeBlock.forName("UGARITIC")); - assertEquals(Character.UnicodeBlock.DESERET, Character.UnicodeBlock.forName("DESERET")); - assertEquals(Character.UnicodeBlock.SHAVIAN, Character.UnicodeBlock.forName("SHAVIAN")); - assertEquals(Character.UnicodeBlock.OSMANYA, Character.UnicodeBlock.forName("OSMANYA")); - assertEquals(Character.UnicodeBlock.CYPRIOT_SYLLABARY, Character.UnicodeBlock.forName("CYPRIOT_SYLLABARY")); - assertEquals(Character.UnicodeBlock.CYPRIOT_SYLLABARY, Character.UnicodeBlock.forName("Cypriot Syllabary")); - assertEquals(Character.UnicodeBlock.CYPRIOT_SYLLABARY, Character.UnicodeBlock.forName("CypriotSyllabary")); - assertEquals(Character.UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS, Character.UnicodeBlock.forName("BYZANTINE_MUSICAL_SYMBOLS")); - assertEquals(Character.UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS, Character.UnicodeBlock.forName("Byzantine Musical Symbols")); - assertEquals(Character.UnicodeBlock.BYZANTINE_MUSICAL_SYMBOLS, Character.UnicodeBlock.forName("ByzantineMusicalSymbols")); - assertEquals(Character.UnicodeBlock.MUSICAL_SYMBOLS, Character.UnicodeBlock.forName("MUSICAL_SYMBOLS")); - assertEquals(Character.UnicodeBlock.MUSICAL_SYMBOLS, Character.UnicodeBlock.forName("Musical Symbols")); - assertEquals(Character.UnicodeBlock.MUSICAL_SYMBOLS, Character.UnicodeBlock.forName("MusicalSymbols")); - assertEquals(Character.UnicodeBlock.TAI_XUAN_JING_SYMBOLS, Character.UnicodeBlock.forName("TAI_XUAN_JING_SYMBOLS")); - assertEquals(Character.UnicodeBlock.TAI_XUAN_JING_SYMBOLS, Character.UnicodeBlock.forName("Tai Xuan Jing Symbols")); - assertEquals(Character.UnicodeBlock.TAI_XUAN_JING_SYMBOLS, Character.UnicodeBlock.forName("TaiXuanJingSymbols")); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_ALPHANUMERIC_SYMBOLS, Character.UnicodeBlock.forName("MATHEMATICAL_ALPHANUMERIC_SYMBOLS")); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_ALPHANUMERIC_SYMBOLS, Character.UnicodeBlock.forName("Mathematical Alphanumeric Symbols")); - assertEquals(Character.UnicodeBlock.MATHEMATICAL_ALPHANUMERIC_SYMBOLS, Character.UnicodeBlock.forName("MathematicalAlphanumericSymbols")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, Character.UnicodeBlock.forName("CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, Character.UnicodeBlock.forName("CJK Unified Ideographs Extension B")); - assertEquals(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B, Character.UnicodeBlock.forName("CJKUnifiedIdeographsExtensionB")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, Character.UnicodeBlock.forName("CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, Character.UnicodeBlock.forName("CJK Compatibility Ideographs Supplement")); - assertEquals(Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT, Character.UnicodeBlock.forName("CJKCompatibilityIdeographsSupplement")); - assertEquals(Character.UnicodeBlock.TAGS, Character.UnicodeBlock.forName("TAGS")); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS_SUPPLEMENT, Character.UnicodeBlock.forName("VARIATION_SELECTORS_SUPPLEMENT")); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS_SUPPLEMENT, Character.UnicodeBlock.forName("Variation Selectors Supplement")); - assertEquals(Character.UnicodeBlock.VARIATION_SELECTORS_SUPPLEMENT, Character.UnicodeBlock.forName("VariationSelectorsSupplement")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_A, Character.UnicodeBlock.forName("SUPPLEMENTARY_PRIVATE_USE_AREA_A")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_A, Character.UnicodeBlock.forName("Supplementary Private Use Area-A")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_A, Character.UnicodeBlock.forName("SupplementaryPrivateUseArea-A")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B, Character.UnicodeBlock.forName("SUPPLEMENTARY_PRIVATE_USE_AREA_B")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B, Character.UnicodeBlock.forName("Supplementary Private Use Area-B")); - assertEquals(Character.UnicodeBlock.SUPPLEMENTARY_PRIVATE_USE_AREA_B, Character.UnicodeBlock.forName("SupplementaryPrivateUseArea-B")); - } - - public void test_forNameLjava_lang_StringExceptions() { - try { - Character.UnicodeBlock.forName(null); - fail("No NPE"); - } catch(NullPointerException e) { - } - - try { - Character.UnicodeBlock.forName("INVALID_NAME"); - fail("No illegal argument exception"); - } catch(IllegalArgumentException e) { - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassCastExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassCastExceptionTest.java deleted file mode 100644 index bc56cef..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassCastExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class ClassCastExceptionTest extends TestCase { - - /** - * @tests java.lang.ClassCastException#ClassCastException() - */ - public void test_Constructor() { - ClassCastException e = new ClassCastException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ClassCastException#ClassCastException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - ClassCastException e = new ClassCastException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassCircularityErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassCircularityErrorTest.java deleted file mode 100644 index 029e16c..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassCircularityErrorTest.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * 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 junit.framework.TestCase; // android-changed - -public class ClassCircularityErrorTest extends TestCase { // android-changed - // Thrown when a circularity has been detected while initializing a class. - /** - * @tests java.lang.ClassCircularityError#ClassCircularityError() - */ - public void test_ClassCircularityError() { - new ClassCircularityError(); - } - - /** - * @tests java.lang.ClassCircularityError#ClassCircularityError(java.lang.String) - */ - public void test_ClassCircularityError_LString() { - ClassCircularityError e = new ClassCircularityError( - "Some Error message"); - assertEquals("Wrong message", "Some Error message", e.getMessage()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassFormatErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassFormatErrorTest.java deleted file mode 100644 index 2bf8678..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassFormatErrorTest.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * 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 junit.framework.TestCase; // android-changed - -public class ClassFormatErrorTest extends TestCase { // android-changed - /** - * Thrown when the Java Virtual Machine attempts to read a class file and - * determines that the file is malformed or otherwise cannot be interpreted - * as a class file. - */ - - /** - * @tests java.lang.ClassFormatError#ClassFormatError() - */ - public void test_ClassFormatError() { - new ClassFormatError(); - } - - /** - * @tests java.lang.ClassFormatError#ClassFormatError(java.lang.String) - */ - public void test_ClassFormatError_LString() { - ClassFormatError e = new ClassFormatError("Some Error Message"); - assertEquals("Wrong message", "Some Error Message", e.getMessage()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassLoaderTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassLoaderTest.java deleted file mode 100644 index ca4ae28..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassLoaderTest.java +++ /dev/null @@ -1,269 +0,0 @@ -/* - * 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 java.io.InputStream; -import java.security.CodeSource; -import java.security.Permission; -import java.security.PermissionCollection; -import java.security.Policy; -import java.security.ProtectionDomain; -import java.security.SecurityPermission; - -import junit.framework.TestCase; - -public class ClassLoaderTest extends TestCase { - - public static volatile int flag; - - /** - * Tests that Classloader.defineClass() assigns appropriate - * default domains to the defined classes. - */ - public void test_defineClass_defaultDomain() throws Exception { - // Regression for HARMONY-765 - DynamicPolicy plc = new DynamicPolicy(); - Policy back = Policy.getPolicy(); - try { - Policy.setPolicy(plc); - - Class<?> a = new Ldr().define(); - - Permission p = new SecurityPermission("abc"); - assertFalse("impossible! misconfiguration?", a.getProtectionDomain().implies(p)); - - plc.pc = p.newPermissionCollection(); - plc.pc.add(p); - assertTrue("default domain is not dynamic", a.getProtectionDomain().implies(p)); - } finally { - Policy.setPolicy(back); - } - } - - static class SyncTestClassLoader extends ClassLoader { - Object lock; - volatile int numFindClassCalled; - - SyncTestClassLoader(Object o) { - this.lock = o; - numFindClassCalled = 0; - } - - /* - * Byte array of bytecode equivalent to the following source code: - * public class TestClass { - * } - */ - private byte[] classData = new byte[] { - -54, -2, -70, -66, 0, 0, 0, 49, 0, 13, - 10, 0, 3, 0, 10, 7, 0, 11, 7, 0, - 12, 1, 0, 6, 60, 105, 110, 105, 116, 62, - 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, - 111, 100, 101, 1, 0, 15, 76, 105, 110, 101, - 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, - 101, 1, 0, 10, 83, 111, 117, 114, 99, 101, - 70, 105, 108, 101, 1, 0, 14, 84, 101, 115, - 116, 67, 108, 97, 115, 115, 46, 106, 97, 118, - 97, 12, 0, 4, 0, 5, 1, 0, 9, 84, - 101, 115, 116, 67, 108, 97, 115, 115, 1, 0, - 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, - 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, - 2, 0, 3, 0, 0, 0, 0, 0, 1, 0, - 1, 0, 4, 0, 5, 0, 1, 0, 6, 0, - 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, - 5, 42, -73, 0, 1, -79, 0, 0, 0, 1, - 0, 7, 0, 0, 0, 6, 0, 1, 0, 0, - 0, 1, 0, 1, 0, 8, 0, 0, 0, 2, - 0, 9 }; - - @Override - protected Class<?> findClass(String name) throws ClassNotFoundException { - try { - while (flag != 2) { - synchronized (lock) { - lock.wait(); - } - } - } catch (InterruptedException ie) {} - - if (name.equals("TestClass")) { - numFindClassCalled++; - return defineClass(null, classData, 0, classData.length); - } - throw new ClassNotFoundException("Class " + name + " not found."); - } - } - - static class SyncLoadTestThread extends Thread { - volatile boolean started; - ClassLoader cl; - Class<?> cls; - - SyncLoadTestThread(ClassLoader cl) { - this.cl = cl; - } - - @Override - public void run() { - try { - started = true; - cls = Class.forName("TestClass", false, cl); - } catch (Exception ex) { - ex.printStackTrace(); - } - } - } - - /** - * Regression test for HARMONY-1939: - * 2 threads simultaneously run Class.forName() method for the same classname - * and the same classloader. It is expected that both threads succeed but - * class must be defined just once. - */ - public void test_loadClass_concurrentLoad() throws Exception - { - Object lock = new Object(); - SyncTestClassLoader cl = new SyncTestClassLoader(lock); - SyncLoadTestThread tt1 = new SyncLoadTestThread(cl); - SyncLoadTestThread tt2 = new SyncLoadTestThread(cl); - flag = 1; - tt1.start(); - tt2.start(); - - while (!tt1.started && !tt2.started) { - Thread.sleep(100); - } - - flag = 2; - synchronized (lock) { - lock.notifyAll(); - } - tt1.join(); - tt2.join(); - - assertSame("Bad or redefined class", tt1.cls, tt2.cls); - assertEquals("Both threads tried to define class", 1, cl.numFindClassCalled); - } - - /** - * @tests java.lang.ClassLoader#getResource(java.lang.String) - */ - public void test_getResourceLjava_lang_String() { - // Test for method java.net.URL - // java.lang.ClassLoader.getResource(java.lang.String) - java.net.URL u = ClassLoader.getSystemClassLoader().getResource("hyts_Foo.c"); - assertNotNull("Unable to find resource", u); - java.io.InputStream is = null; - try { - is = u.openStream(); - assertNotNull("Resource returned is invalid", is); - is.close(); - } catch (java.io.IOException e) { - fail("IOException getting stream for resource : " + e.getMessage()); - } - } - - /** - * @tests java.lang.ClassLoader#getResourceAsStream(java.lang.String) - */ - public void test_getResourceAsStreamLjava_lang_String() { - // Test for method java.io.InputStream - // java.lang.ClassLoader.getResourceAsStream(java.lang.String) - // Need better test... - - java.io.InputStream is = null; - assertNotNull("Failed to find resource: hyts_Foo.c", (is = ClassLoader - .getSystemClassLoader().getResourceAsStream("hyts_Foo.c"))); - try { - is.close(); - } catch (java.io.IOException e) { - fail("Exception during getResourceAsStream: " + e.toString()); - } - } - - /** - * @tests java.lang.ClassLoader#getSystemClassLoader() - */ - public void test_getSystemClassLoader() { - // Test for method java.lang.ClassLoader - // java.lang.ClassLoader.getSystemClassLoader() - ClassLoader cl = ClassLoader.getSystemClassLoader(); - java.io.InputStream is = cl.getResourceAsStream("hyts_Foo.c"); - assertNotNull("Failed to find resource from system classpath", is); - try { - is.close(); - } catch (java.io.IOException e) { - } - - } - - /** - * @tests java.lang.ClassLoader#getSystemResource(java.lang.String) - */ - public void test_getSystemResourceLjava_lang_String() { - // Test for method java.net.URL - // java.lang.ClassLoader.getSystemResource(java.lang.String) - // Need better test... - assertNotNull("Failed to find resource: hyts_Foo.c", ClassLoader - .getSystemResource("hyts_Foo.c")); - } - - - //Regression Test for JIRA-2047 - public void test_getResourceAsStream_withSharpChar() throws Exception { - InputStream in = this.getClass().getClassLoader().getResourceAsStream( - ClassTest.FILENAME); - assertNotNull(in); - in.close(); - } -} - -class DynamicPolicy extends Policy { - - public PermissionCollection pc; - - @Override - public PermissionCollection getPermissions(ProtectionDomain pd) { - return pc; - } - - @Override - public PermissionCollection getPermissions(CodeSource codesource) { - return pc; - } - - @Override - public void refresh() { - } -} - -class A { -} - -class Ldr extends ClassLoader { - @SuppressWarnings("deprecation") - public Class<?> define() throws Exception { - Package p = getClass().getPackage(); - // Class loader paths use '/' character as separator - String path = p == null ? "" : p.getName().replace('.', '/') + '/'; - InputStream is = getResourceAsStream(path + "A.class"); - byte[] buf = new byte[512]; - int len = is.read(buf); - return defineClass(buf, 0, len); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassNotFoundExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassNotFoundExceptionTest.java deleted file mode 100644 index 3a26a79..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassNotFoundExceptionTest.java +++ /dev/null @@ -1,60 +0,0 @@ -/* - * 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 java.io.IOException; - -import junit.framework.TestCase; - -public class ClassNotFoundExceptionTest extends TestCase { - /** - * Thrown when an application tries to load in a class through its string - * name using the forName method in class Class. - */ - - /** - * @tests java.lang.ClassNotFoundException#ClassNotFoundException() - */ - public void test_Constructor() { - ClassNotFoundException e = new ClassNotFoundException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ClassNotFoundException#ClassNotFoundException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - ClassNotFoundException e = new ClassNotFoundException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ClassNotFoundException#ClassNotFoundException(java.lang.String, java.lang.Throwable) - */ - public void test_ClassNotFoundException_LString_LThrowable() { - IOException in = new IOException(); - ClassNotFoundException e = new ClassNotFoundException("SomeMessage", in); - assertEquals("Wrong Exception", in, e.getException()); - assertEquals("Wrong message", "SomeMessage", e.getMessage()); - assertEquals("Wrong cause", in, e.getCause()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassTest.java deleted file mode 100644 index 4f373de..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassTest.java +++ /dev/null @@ -1,1806 +0,0 @@ -/* - * 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 java.io.File; -import java.io.FileInputStream; -import java.io.InputStream; -import java.io.Serializable; -import java.lang.annotation.Annotation; -import java.lang.reflect.Constructor; -import java.lang.reflect.Field; -import java.lang.reflect.Member; -import java.lang.reflect.Method; -import java.lang.reflect.Modifier; -import java.lang.reflect.ParameterizedType; -import java.lang.reflect.Type; -import java.lang.reflect.TypeVariable; -import java.net.URL; -import java.net.URLClassLoader; -import java.security.AccessControlContext; -import java.security.AccessController; -import java.security.BasicPermission; -import java.security.DomainCombiner; -import java.security.Permission; -import java.security.PrivilegedAction; -import java.security.ProtectionDomain; -import java.security.Security; -import java.util.AbstractList; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Vector; - -import tests.support.Support_ClassLoader; -import tests.support.resource.Support_Resources; -import dalvik.annotation.AndroidOnly; -import dalvik.annotation.BrokenTest; -import dalvik.annotation.KnownFailure; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.TestTargetNew; - -@SuppressWarnings("deprecation") -@TestTargetClass(Class.class) -public class ClassTest extends junit.framework.TestCase { - - public static final String FILENAME = - ClassTest.class.getPackage().getName().replace('.', '/') + - "/test#.properties"; - - final String packageName = getClass().getPackage().getName(); - final String classNameInitError1 = packageName + ".TestClass1"; - final String classNameInitError2 = packageName + ".TestClass1B"; - final String classNameLinkageError = packageName + ".TestClass"; - final String sourceJARfile = "illegalClasses.jar"; - final String illegalClassName = "illegalClass"; - - static class StaticMember$Class { - class Member2$A { - } - } - - class Member$Class { - class Member3$B { - } - } - - public static class TestClass { - @SuppressWarnings("unused") - private int privField = 1; - - public int pubField = 2; - - private Object cValue = null; - - public Object ack = new Object(); - - @SuppressWarnings("unused") - private int privMethod() { - return 1; - } - - public int pubMethod() { - return 2; - } - - public Object cValue() { - return cValue; - } - - public TestClass() { - } - - @SuppressWarnings("unused") - private TestClass(Object o) { - } - } - - public static class SubTestClass extends TestClass { - } - - interface Intf1 { - public int field1 = 1; - public int field2 = 1; - void test(); - } - - interface Intf2 { - public int field1 = 1; - void test(); - } - - interface Intf3 extends Intf1 { - public int field1 = 1; - } - - interface Intf4 extends Intf1, Intf2 { - public int field1 = 1; - void test2(int a, Object b); - } - - interface Intf5 extends Intf1 { - } - - class Cls1 implements Intf2 { - public int field1 = 2; - public int field2 = 2; - public void test() { - } - } - - class Cls2 extends Cls1 implements Intf1 { - public int field1 = 2; - @Override - public void test() { - } - } - - class Cls3 implements Intf3, Intf4 { - public void test() { - } - public void test2(int a, Object b) { - } - } - - static class Cls4 { - - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getAnnotations", - args = {} - ) - public void test_getAnnotations() { - Annotation [] annotations = PublicTestClass.class.getAnnotations(); - assertEquals(1, annotations.length); - assertEquals(TestAnnotation.class, annotations[0].annotationType()); - - annotations = ExtendTestClass.class.getAnnotations(); - assertEquals(2, annotations.length); - - for(int i = 0; i < annotations.length; i++) { - Class<? extends Annotation> type = annotations[i].annotationType(); - assertTrue("Annotation's type " + i + ": " + type, - type.equals(Deprecated.class) || - type.equals(TestAnnotation.class)); - } - } - - /** - * @tests java.lang.Class#forName(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "java.lang.LinkageError can't be checked.", - method = "forName", - args = {java.lang.String.class} - ) - @AndroidOnly("harmony specific: test with " + - "'org.apache.harmony.luni.tests.java.lang.TestClass1'") - public void test_forNameLjava_lang_String() throws Exception { - - assertSame("Class for name failed for java.lang.Object", - Object.class, Class.forName("java.lang.Object")); - assertSame("Class for name failed for [[Ljava.lang.Object;", - Object[][].class, Class.forName("[[Ljava.lang.Object;")); - - assertSame("Class for name failed for [I", - int[].class, Class.forName("[I")); - - try { - Class.forName("int"); - fail(); - } catch (ClassNotFoundException e) { - } - - try { - Class.forName("byte"); - fail(); - } catch (ClassNotFoundException e) { - } - try { - Class.forName("char"); - fail(); - } catch (ClassNotFoundException e) { - } - - try { - Class.forName("void"); - fail(); - } catch (ClassNotFoundException e) { - } - - try { - Class.forName("short"); - fail(); - } catch (ClassNotFoundException e) { - } - try { - Class.forName("long"); - fail(); - } catch (ClassNotFoundException e) { - } - - try { - Class.forName("boolean"); - fail(); - } catch (ClassNotFoundException e) { - } - try { - Class.forName("float"); - fail(); - } catch (ClassNotFoundException e) { - } - try { - Class.forName("double"); - fail(); - } catch (ClassNotFoundException e) { - } - - //regression test for JIRA 2162 - try { - Class.forName("%"); - fail("should throw ClassNotFoundException."); - } catch (ClassNotFoundException e) { - } - - //Regression Test for HARMONY-3332 - String securityProviderClassName; - int count = 1; - while ((securityProviderClassName = Security - .getProperty("security.provider." + count++)) != null) { - Class.forName(securityProviderClassName); - } - - try { - Class.forName(classNameInitError1); - fail("ExceptionInInitializerError or ClassNotFoundException " + - "expected."); - } catch (java.lang.ExceptionInInitializerError ie) { - // Expected for the RI. - } catch (java.lang.ClassNotFoundException ce) { - // Expected for Android. - } - } - - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "", - method = "forName", - args = {java.lang.String.class, boolean.class, java.lang.ClassLoader.class} - ) - public void test_forNameLjava_lang_StringLbooleanLClassLoader() throws Exception { - - ClassLoader pcl = getClass().getClassLoader(); - - Class<?> [] classes = {PublicTestClass.class, ExtendTestClass.class, - ExtendTestClass1.class, TestInterface.class, String.class}; - - for(int i = 0; i < classes.length; i++) { - Class<?> clazz = Class.forName(classes[i].getName(), true, pcl); - assertEquals(classes[i], clazz); - - clazz = Class.forName(classes[i].getName(), false, pcl); - assertEquals(classes[i], clazz); - } - - Class<?> [] systemClasses = {String.class, Integer.class, Object.class, - Object[].class}; - - for(int i = 0; i < systemClasses.length; i++) { - Class<?> clazz = Class.forName(systemClasses[i].getName(), true, - ClassLoader.getSystemClassLoader()); - assertEquals(systemClasses[i], clazz); - - clazz = Class.forName(systemClasses[i].getName(), false, - ClassLoader.getSystemClassLoader()); - assertEquals(systemClasses[i], clazz); - } - - try { - Class.forName(null, true, pcl); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - Class.forName("NotExistClass", true, pcl); - fail("ClassNotFoundException is not thrown for non existent class."); - } catch(ClassNotFoundException cnfe) { - //expected - } - - try { - Class.forName("String", false, pcl); - fail("ClassNotFoundException is not thrown for non existent class."); - } catch(ClassNotFoundException cnfe) { - //expected - } - - try { - Class.forName("org.apache.harmony.luni.tests.java.PublicTestClass", - false, pcl); - fail("ClassNotFoundException is not thrown for non existent class."); - } catch(ClassNotFoundException cnfe) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "", - method = "forName", - args = {java.lang.String.class, boolean.class, java.lang.ClassLoader.class} - ) - @AndroidOnly("Class.forName method throws ClassNotFoundException on " + - "Android.") - public void test_forNameLjava_lang_StringLbooleanLClassLoader_AndroidOnly() throws Exception { - - // Android doesn't support loading class files from a jar. - try { - - URL url = getClass().getClassLoader().getResource( - packageName.replace(".", "/") + "/" + sourceJARfile); - - ClassLoader loader = new URLClassLoader(new URL[] { url }, - getClass().getClassLoader()); - try { - Class.forName(classNameLinkageError, true, loader); - fail("LinkageError or ClassNotFoundException expected."); - } catch (java.lang.LinkageError le) { - // Expected for the RI. - } catch (java.lang.ClassNotFoundException ce) { - // Expected for Android. - } - } catch(Exception e) { - fail("Unexpected exception was thrown: " + e.toString()); - } - - try { - Class.forName(classNameInitError2, - true, getClass().getClassLoader()); - fail("ExceptionInInitializerError or ClassNotFoundException " + - "should be thrown."); - } catch (java.lang.ExceptionInInitializerError ie) { - // Expected for the RI. - // Remove this comment to let the test pass on Android. - } catch (java.lang.ClassNotFoundException ce) { - // Expected for Android. - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getAnnotation", - args = {java.lang.Class.class} - ) - public void test_getAnnotation() { - TestAnnotation target = PublicTestClass.class.getAnnotation(TestAnnotation.class); - assertEquals(target.value(), PublicTestClass.class.getName()); - - assertNull(PublicTestClass.class.getAnnotation(Deprecated.class)); - - Deprecated target2 = ExtendTestClass.class.getAnnotation(Deprecated.class); - assertNotNull(target2); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredAnnotations", - args = {} - ) - public void test_getDeclaredAnnotations() { - Annotation [] annotations = PublicTestClass.class.getDeclaredAnnotations(); - assertEquals(1, annotations.length); - - annotations = ExtendTestClass.class.getDeclaredAnnotations(); - assertEquals(2, annotations.length); - - annotations = TestInterface.class.getDeclaredAnnotations(); - assertEquals(0, annotations.length); - - annotations = String.class.getDeclaredAnnotations(); - assertEquals(0, annotations.length); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getEnclosingClass", - args = {} - ) - public void test_getEnclosingClass() { - Class clazz = ExtendTestClass.class.getEnclosingClass(); - assertNull(clazz); - - assertEquals(getClass(), Cls1.class.getEnclosingClass()); - assertEquals(getClass(), Intf1.class.getEnclosingClass()); - assertEquals(getClass(), Cls4.class.getEnclosingClass()); - } - - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getEnclosingMethod", - args = {} - ) - public void test_getEnclosingMethod() { - Method clazz = ExtendTestClass.class.getEnclosingMethod(); - assertNull(clazz); - - PublicTestClass ptc = new PublicTestClass(); - try { - assertEquals("getEnclosingMethod returns incorrect method.", - PublicTestClass.class.getMethod("getLocalClass", - (Class []) null), - ptc.getLocalClass().getClass().getEnclosingMethod()); - } catch(NoSuchMethodException nsme) { - fail("NoSuchMethodException was thrown."); - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getEnclosingConstructor", - args = {} - ) - public void test_getEnclosingConstructor() { - - PublicTestClass ptc = new PublicTestClass(); - - assertEquals("getEnclosingConstructor method returns incorrect class.", - PublicTestClass.class.getConstructors()[0], - ptc.clazz.getClass().getEnclosingConstructor()); - - assertNull("getEnclosingConstructor should return null for local " + - "class declared in method.", - ptc.getLocalClass().getClass().getEnclosingConstructor()); - - assertNull("getEnclosingConstructor should return null for local " + - "class declared in method.", - ExtendTestClass.class.getEnclosingConstructor()); - } - - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getEnumConstants", - args = {} - ) - public void test_getEnumConstants() { - Object [] clazz = ExtendTestClass.class.getEnumConstants(); - assertNull(clazz); - Object [] constants = TestEnum.class.getEnumConstants(); - assertEquals(TestEnum.values().length, constants.length); - for(int i = 0; i < constants.length; i++) { - assertEquals(TestEnum.values()[i], constants[i]); - } - assertEquals(0, TestEmptyEnum.class.getEnumConstants().length); - } - public enum TestEnum { - ONE, TWO, THREE - } - public enum TestEmptyEnum { - } - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "GenericSignatureFormatError, TypeNotPresentException, " + - "MalformedParameterizedTypeException are not verified.", - method = "getGenericInterfaces", - args = {} - ) - public void test_getGenericInterfaces() { - Type [] types = ExtendTestClass1.class.getGenericInterfaces(); - assertEquals(0, types.length); - - Class [] interfaces = {TestInterface.class, Serializable.class, - Cloneable.class}; - types = PublicTestClass.class.getGenericInterfaces(); - assertEquals(interfaces.length, types.length); - for(int i = 0; i < types.length; i++) { - assertEquals(interfaces[i], types[i]); - } - - types = TestInterface.class.getGenericInterfaces(); - assertEquals(0, types.length); - - types = List.class.getGenericInterfaces(); - assertEquals(1, types.length); - assertEquals(Collection.class, ((ParameterizedType)types[0]).getRawType()); - - assertEquals(0, int.class.getGenericInterfaces().length); - assertEquals(0, void.class.getGenericInterfaces().length); - } - - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "GenericSignatureFormatError, TypeNotPresentException, MalformedParameterizedTypeException are not verified.", - method = "getGenericSuperclass", - args = {} - ) - public void test_getGenericSuperclass () { - assertEquals(PublicTestClass.class, - ExtendTestClass.class.getGenericSuperclass()); - assertEquals(ExtendTestClass.class, - ExtendTestClass1.class.getGenericSuperclass()); - assertEquals(Object.class, PublicTestClass.class.getGenericSuperclass()); - assertEquals(Object.class, String.class.getGenericSuperclass()); - assertEquals(null, TestInterface.class.getGenericSuperclass()); - - ParameterizedType type = (ParameterizedType) Vector.class.getGenericSuperclass(); - assertEquals(AbstractList.class, type.getRawType()); - } - - @TestTargetNew( - level = TestLevel.SUFFICIENT, - method = "getPackage", - args = {} - ) - @AndroidOnly("Uses dalvik.system.PathClassLoader.") - @BrokenTest("Different behavior between cts host and run-core-test") - public void test_getPackage() { - - Package thisPackage = getClass().getPackage(); - assertEquals("org.apache.harmony.luni.tests.java.lang", - thisPackage.getName()); - - Package stringPackage = String.class.getPackage(); - assertNotNull("java.lang", stringPackage.getName()); - - String hyts_package_name = "hyts_package_dex.jar"; - File resources = Support_Resources.createTempFolder(); - Support_Resources.copyFile(resources, "Package", hyts_package_name); - - String resPath = resources.toString(); - if (resPath.charAt(0) == '/' || resPath.charAt(0) == '\\') - resPath = resPath.substring(1); - - try { - - URL resourceURL = new URL("file:/" + resPath + "/Package/" - + hyts_package_name); - - ClassLoader cl = Support_ClassLoader.getInstance(resourceURL, - getClass().getClassLoader()); - - Class clazz = cl.loadClass("C"); - assertNull("getPackage for C.class should return null", - clazz.getPackage()); - - clazz = cl.loadClass("a.b.C"); - Package cPackage = clazz.getPackage(); - assertNotNull("getPackage for a.b.C.class should not return null", - cPackage); - - /* - * URLClassLoader doesn't work on Android for jar files - * - * URL url = getClass().getClassLoader().getResource( - * packageName.replace(".", "/") + "/" + sourceJARfile); - * - * ClassLoader loader = new URLClassLoader(new URL[] { url }, null); - * - * try { - * Class<?> clazz = loader.loadClass(illegalClassName); - * Package pack = clazz.getPackage(); - * assertNull(pack); - * } catch(ClassNotFoundException cne) { - * fail("ClassNotFoundException was thrown for " + illegalClassName); - * } - */ - } catch(Exception e) { - fail("Unexpected exception was thrown: " + e.toString()); - } - } - - @TestTargetNew( - level = TestLevel.SUFFICIENT, - notes = "", - method = "getSigners", - args = {} - ) - public void test_getSigners() { - assertNull(void.class.getSigners()); - assertNull(PublicTestClass.class.getSigners()); - - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getSimpleName", - args = {} - ) - public void test_getSimpleName() { - assertEquals("PublicTestClass", PublicTestClass.class.getSimpleName()); - assertEquals("void", void.class.getSimpleName()); - assertEquals("int[]", int[].class.getSimpleName()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getTypeParameters", - args = {} - ) - public void test_getTypeParameters() { - assertEquals(0, PublicTestClass.class.getTypeParameters().length); - TypeVariable [] tv = TempTestClass1.class.getTypeParameters(); - assertEquals(1, tv.length); - assertEquals(Object.class, tv[0].getBounds()[0]); - - TempTestClass2<String> tc = new TempTestClass2<String>(); - tv = tc.getClass().getTypeParameters(); - assertEquals(1, tv.length); - assertEquals(String.class, tv[0].getBounds()[0]); - } - - class TempTestClass1<T> { - } - - class TempTestClass2<S extends String> extends TempTestClass1<S> { - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isAnnotation", - args = {} - ) - public void test_isAnnotation() { - assertTrue(Deprecated.class.isAnnotation()); - assertTrue(TestAnnotation.class.isAnnotation()); - assertFalse(PublicTestClass.class.isAnnotation()); - assertFalse(String.class.isAnnotation()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isAnnotationPresent", - args = {java.lang.Class.class} - ) - public void test_isAnnotationPresent() { - assertTrue(PublicTestClass.class.isAnnotationPresent(TestAnnotation.class)); - assertFalse(ExtendTestClass1.class.isAnnotationPresent(TestAnnotation.class)); - assertFalse(String.class.isAnnotationPresent(Deprecated.class)); - assertTrue(ExtendTestClass.class.isAnnotationPresent(TestAnnotation.class)); - assertTrue(ExtendTestClass.class.isAnnotationPresent(Deprecated.class)); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isAnonymousClass", - args = {} - ) - public void test_isAnonymousClass() { - assertFalse(PublicTestClass.class.isAnonymousClass()); - assertTrue((new Thread() {}).getClass().isAnonymousClass()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isEnum", - args = {} - ) - public void test_isEnum() { - assertFalse(PublicTestClass.class.isEnum()); - assertFalse(ExtendTestClass.class.isEnum()); - assertTrue(TestEnum.ONE.getClass().isEnum()); - assertTrue(TestEnum.class.isEnum()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isLocalClass", - args = {} - ) - public void test_isLocalClass() { - assertFalse(ExtendTestClass.class.isLocalClass()); - assertFalse(TestInterface.class.isLocalClass()); - assertFalse(TestEnum.class.isLocalClass()); - class InternalClass {} - assertTrue(InternalClass.class.isLocalClass()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isMemberClass", - args = {} - ) - public void test_isMemberClass() { - assertFalse(ExtendTestClass.class.isMemberClass()); - assertFalse(TestInterface.class.isMemberClass()); - assertFalse(String.class.isMemberClass()); - assertTrue(TestEnum.class.isMemberClass()); - assertTrue(StaticMember$Class.class.isMemberClass()); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isSynthetic", - args = {} - ) - public void test_isSynthetic() { - assertFalse("Returned true for non synthetic class.", - ExtendTestClass.class.isSynthetic()); - assertFalse("Returned true for non synthetic class.", - TestInterface.class.isSynthetic()); - assertFalse("Returned true for non synthetic class.", - String.class.isSynthetic()); - - String className = "org.apache.harmony.luni.tests.java.lang.ClassLoaderTest$1"; - - /* - *try { - * assertTrue("Returned false for synthetic class.", - * getClass().getClassLoader().loadClass(className). - * isSynthetic()); - *} catch(ClassNotFoundException cnfe) { - * fail("Class " + className + " can't be found."); - *} - */ - - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isInstance", - args = {java.lang.Object.class} - ) - public void test_isInstance() { - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getCanonicalName", - args = {} - ) - public void test_getCanonicalName() { - String name = int[].class.getCanonicalName(); - Class [] classArray = { int.class, int[].class, String.class, - PublicTestClass.class, TestInterface.class, - ExtendTestClass.class }; - String [] classNames = {"int", "int[]", "java.lang.String", - "org.apache.harmony.luni.tests.java.lang.PublicTestClass", - "org.apache.harmony.luni.tests.java.lang.TestInterface", - "org.apache.harmony.luni.tests.java.lang.ExtendTestClass"}; - - for(int i = 0; i < classArray.length; i++) { - assertEquals(classNames[i], classArray[i].getCanonicalName()); - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getClassLoader", - args = {} - ) - public void test_getClassLoader() { - assertEquals(ExtendTestClass.class.getClassLoader(), - PublicTestClass.class.getClassLoader()); - - assertNull(int.class.getClassLoader()); - assertNull(void.class.getClassLoader()); - } - - /** - * @tests java.lang.Class#getClasses() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getClasses", - args = {} - ) - public void test_getClasses() { - assertEquals("Incorrect class array returned", - 4, ClassTest.class.getClasses().length); - } - - /** - * @tests java.lang.Class#getComponentType() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getComponentType", - args = {} - ) - public void test_getComponentType() { - assertSame("int array does not have int component type", int.class, int[].class - .getComponentType()); - assertSame("Object array does not have Object component type", Object.class, - Object[].class.getComponentType()); - assertNull("Object has non-null component type", Object.class.getComponentType()); - } - - /** - * @tests java.lang.Class#getConstructor(java.lang.Class[]) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getConstructor", - args = {java.lang.Class[].class} - ) - public void test_getConstructor$Ljava_lang_Class() - throws NoSuchMethodException { - Constructor constr = TestClass.class.getConstructor(new Class[0]); - assertNotNull(constr); - assertEquals("org.apache.harmony.luni.tests.java.lang.ClassTest$TestClass", - constr.getName()); - try { - TestClass.class.getConstructor(Object.class); - fail("Found private constructor"); - } catch (NoSuchMethodException e) { - // Correct - constructor with obj is private - } - } - - /** - * @tests java.lang.Class#getConstructors() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getConstructors", - args = {} - ) - public void test_getConstructors() throws Exception { - Constructor[] c = TestClass.class.getConstructors(); - assertEquals("Incorrect number of constructors returned", 1, c.length); - } - - /** - * @tests java.lang.Class#getDeclaredClasses() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredClasses", - args = {} - ) - public void test_getDeclaredClasses() { - - Class [] declClasses = Object.class.getDeclaredClasses(); - assertEquals("Incorrect length of declared classes array is returned " + - "for Object.", 0, declClasses.length); - - declClasses = PublicTestClass.class.getDeclaredClasses(); - assertEquals(2, declClasses.length); - - assertEquals(0, int.class.getDeclaredClasses().length); - assertEquals(0, void.class.getDeclaredClasses().length); - - for(int i = 0; i < declClasses.length; i++) { - Constructor<?> constr = declClasses[i].getDeclaredConstructors()[0]; - constr.setAccessible(true); - PublicTestClass publicClazz = new PublicTestClass(); - try { - Object o = constr.newInstance(publicClazz); - assertTrue("Returned incorrect class: " + o.toString(), - o.toString().startsWith("PrivateClass")); - } catch(Exception e) { - fail("Unexpected exception was thrown: " + e.toString()); - } - } - - - declClasses = TestInterface.class.getDeclaredClasses(); - assertEquals(0, declClasses.length); - } - - - /** - * @tests java.lang.Class#getDeclaredConstructor(java.lang.Class[]) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredConstructor", - args = {java.lang.Class[].class} - ) - public void test_getDeclaredConstructor$Ljava_lang_Class() throws Exception { - Constructor<TestClass> c = TestClass.class.getDeclaredConstructor(new Class[0]); - assertNull("Incorrect constructor returned", c.newInstance().cValue()); - c = TestClass.class.getDeclaredConstructor(Object.class); - - try { - TestClass.class.getDeclaredConstructor(String.class); - fail("NoSuchMethodException should be thrown."); - } catch(NoSuchMethodException nsme) { - //expected - } - } - - /** - * @tests java.lang.Class#getDeclaredConstructors() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredConstructors", - args = {} - ) - public void test_getDeclaredConstructors() throws Exception { - Constructor[] c = TestClass.class.getDeclaredConstructors(); - assertEquals("Incorrect number of constructors returned", 2, c.length); - } - - /** - * @tests java.lang.Class#getDeclaredField(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredField", - args = {java.lang.String.class} - ) - public void test_getDeclaredFieldLjava_lang_String() throws Exception { - Field f = TestClass.class.getDeclaredField("pubField"); - assertEquals("Returned incorrect field", 2, f.getInt(new TestClass())); - - try { - TestClass.class.getDeclaredField(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - TestClass.class.getDeclaredField("NonExistentField"); - fail("NoSuchFieldException is not thrown."); - } catch(NoSuchFieldException nsfe) { - //expected - } - } - - /** - * @tests java.lang.Class#getDeclaredFields() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredFields", - args = {} - ) - public void test_getDeclaredFields() throws Exception { - Field[] f = TestClass.class.getDeclaredFields(); - assertEquals("Returned incorrect number of fields", 4, f.length); - f = SubTestClass.class.getDeclaredFields(); - // Declared fields do not include inherited - assertEquals("Returned incorrect number of fields", 0, f.length); - } - - /** - * @tests java.lang.Class#getDeclaredMethod(java.lang.String, - * java.lang.Class[]) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredMethod", - args = {java.lang.String.class, java.lang.Class[].class} - ) - public void test_getDeclaredMethodLjava_lang_String$Ljava_lang_Class() throws Exception { - Method m = TestClass.class.getDeclaredMethod("pubMethod", new Class[0]); - assertEquals("Returned incorrect method", 2, ((Integer) (m.invoke(new TestClass()))) - .intValue()); - m = TestClass.class.getDeclaredMethod("privMethod", new Class[0]); - - try { - TestClass.class.getDeclaredMethod(null, new Class[0]); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - TestClass.class.getDeclaredMethod("NonExistentMethod", new Class[0]); - fail("NoSuchMethodException is not thrown."); - } catch(NoSuchMethodException nsme) { - //expected - } - } - - /** - * @tests java.lang.Class#getDeclaredMethods() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaredMethods", - args = {} - ) - public void test_getDeclaredMethods() throws Exception { - Method[] m = TestClass.class.getDeclaredMethods(); - assertEquals("Returned incorrect number of methods", 3, m.length); - m = SubTestClass.class.getDeclaredMethods(); - assertEquals("Returned incorrect number of methods", 0, m.length); - } - - /** - * @tests java.lang.Class#getDeclaringClass() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getDeclaringClass", - args = {} - ) - public void test_getDeclaringClass() { - assertEquals(ClassTest.class, TestClass.class.getDeclaringClass()); - assertNull(PublicTestClass.class.getDeclaringClass()); - } - - /** - * @tests java.lang.Class#getField(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getField", - args = {java.lang.String.class} - ) - public void test_getFieldLjava_lang_String() throws Exception { - Field f = TestClass.class.getField("pubField"); - assertEquals("Returned incorrect field", 2, f.getInt(new TestClass())); - - f = PublicTestClass.class.getField("TEST_FIELD"); - assertEquals("Returned incorrect field", "test field", - f.get(new PublicTestClass())); - - f = PublicTestClass.class.getField("TEST_INTERFACE_FIELD"); - assertEquals("Returned incorrect field", 0, - f.getInt(new PublicTestClass())); - - try { - f = TestClass.class.getField("privField"); - fail("Private field access failed to throw exception"); - } catch (NoSuchFieldException e) { - // Correct - } - - try { - TestClass.class.getField(null); - fail("NullPointerException is thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - /** - * @tests java.lang.Class#getFields() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "getFields", - args = {} - ) - public void test_getFields2() throws Exception { - Field[] f; - Field expected = null; - - f = PublicTestClass.class.getFields(); - assertEquals("Test 1: Incorrect number of fields;", 2, f.length); - - f = Cls2.class.getFields(); - assertEquals("Test 2: Incorrect number of fields;", 6, f.length); - - f = Cls3.class.getFields(); - assertEquals("Test 2: Incorrect number of fields;", 5, f.length); - - for (Field field : f) { - if (field.toString().equals("public static final int org.apache" + - ".harmony.luni.tests.java.lang.ClassTest$Intf3.field1")) { - expected = field; - break; - } - } - if (expected == null) { - fail("Test 3: getFields() did not return all fields."); - } - assertEquals("Test 4: Incorrect field;", expected, - Cls3.class.getField("field1")); - - expected = null; - for (Field field : f) { - if(field.toString().equals("public static final int org.apache" + - ".harmony.luni.tests.java.lang.ClassTest$Intf1.field2")) { - expected = field; - break; - } - } - if (expected == null) { - fail("Test 5: getFields() did not return all fields."); - } - assertEquals("Test 6: Incorrect field;", expected, - Cls3.class.getField("field2")); - } - - /** - * @tests java.lang.Class#getFields() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "getFields", - args = {} - ) - public void test_getFields() throws Exception { - Field[] f = TestClass.class.getFields(); - assertEquals("Test 1: Incorrect number of fields;", 2, f.length); - f = SubTestClass.class.getFields(); - // Check inheritance of pub fields - assertEquals("Test 2: Incorrect number of fields;", 2, f.length); - - Field expected = null; - Field[] fields = Cls2.class.getFields(); - for (Field field : fields) { - if(field.toString().equals("public int org.apache.harmony.luni" + - ".tests.java.lang.ClassTest$Cls2.field1")) { - expected = field; - break; - } - } - if (expected == null) { - fail("getFields() did not return all fields"); - } - assertEquals(expected, Cls2.class.getField("field1")); - } - - /** - * @tests java.lang.Class#getInterfaces() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getInterfaces", - args = {} - ) - public void test_getInterfaces() { - Class[] interfaces; - List<?> interfaceList; - interfaces = Object.class.getInterfaces(); - assertEquals("Incorrect interface list for Object", 0, interfaces.length); - interfaceList = Arrays.asList(Vector.class.getInterfaces()); - assertTrue("Incorrect interface list for Vector", interfaceList - .contains(Cloneable.class) - && interfaceList.contains(Serializable.class) - && interfaceList.contains(List.class)); - - Class [] interfaces1 = Cls1.class.getInterfaces(); - assertEquals(1, interfaces1.length); - assertEquals(Intf2.class, interfaces1[0]); - - Class [] interfaces2 = Cls2.class.getInterfaces(); - assertEquals(1, interfaces2.length); - assertEquals(Intf1.class, interfaces2[0]); - - Class [] interfaces3 = Cls3.class.getInterfaces(); - assertEquals(2, interfaces3.length); - assertEquals(Intf3.class, interfaces3[0]); - assertEquals(Intf4.class, interfaces3[1]); - - Class [] interfaces4 = Cls4.class.getInterfaces(); - assertEquals(0, interfaces4.length); - } - - /** - * @tests java.lang.Class#getMethod(java.lang.String, java.lang.Class[]) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMethod", - args = {java.lang.String.class, java.lang.Class[].class} - ) - public void test_getMethodLjava_lang_String$Ljava_lang_Class() throws Exception { - Method m = TestClass.class.getMethod("pubMethod", new Class[0]); - assertEquals("Returned incorrect method", 2, ((Integer) (m.invoke(new TestClass()))) - .intValue()); - - m = ExtendTestClass1.class.getMethod("getCount", new Class[0]); - assertEquals("Returned incorrect method", 0, ((Integer) (m.invoke(new ExtendTestClass1()))) - .intValue()); - - try { - m = TestClass.class.getMethod("privMethod", new Class[0]); - fail("Failed to throw exception accessing private method"); - } catch (NoSuchMethodException e) { - // Correct - return; - } - - try { - m = TestClass.class.getMethod("init", new Class[0]); - fail("Failed to throw exception accessing to init method"); - } catch (NoSuchMethodException e) { - // Correct - return; - } - - try { - TestClass.class.getMethod("pubMethod", new Class[0]); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - /** - * @tests java.lang.Class#getMethods() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMethods", - args = {} - ) - public void test_getMethods() throws Exception { - Method[] m = TestClass.class.getMethods(); - assertEquals("Returned incorrect number of methods", - 2 + Object.class.getMethods().length, m.length); - m = SubTestClass.class.getMethods(); - assertEquals("Returned incorrect number of sub-class methods", - 2 + Object.class.getMethods().length, m.length); - // Number of inherited methods - - assertEquals("Incorrect number of methods", 10, - Cls2.class.getMethods().length); - assertEquals("Incorrect number of methods", 11, - Cls3.class.getMethods().length); - - Method expected = null; - Method[] methods = Cls2.class.getMethods(); - for (Method method : methods) { - if(method.toString().equals("public void org.apache.harmony.luni" + - ".tests.java.lang.ClassTest$Cls2.test()")) { - expected = method; - break; - } - } - if (expected == null) { - fail("getMethods() did not return all methods"); - } - assertEquals(expected, Cls2.class.getMethod("test")); - - expected = null; - methods = Cls3.class.getMethods(); - for (Method method : methods) { - if(method.toString().equals("public void org.apache.harmony.luni" + - ".tests.java.lang.ClassTest$Cls3.test()")) { - expected = method; - break; - } - } - if (expected == null) { - fail("getMethods() did not return all methods"); - } - assertEquals(expected, Cls3.class.getMethod("test")); - - expected = null; - methods = Cls3.class.getMethods(); - for (Method method : methods) { - if(method.toString().equals("public void org.apache.harmony.luni" + - ".tests.java.lang.ClassTest$Cls3.test2(int," + - "java.lang.Object)")) { - expected = method; - break; - } - } - if (expected == null) { - fail("getMethods() did not return all methods"); - } - - assertEquals(expected, Cls3.class.getMethod("test2", int.class, - Object.class)); - - assertEquals("Incorrect number of methods", 1, - Intf5.class.getMethods().length); - } - - private static final class PrivateClass { - } - /** - * @tests java.lang.Class#getModifiers() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getModifiers", - args = {} - ) - public void test_getModifiers() { - int dcm = PrivateClass.class.getModifiers(); - assertFalse("default class is public", Modifier.isPublic(dcm)); - assertFalse("default class is protected", Modifier.isProtected(dcm)); - assertTrue("default class is not private", Modifier.isPrivate(dcm)); - - int ocm = Object.class.getModifiers(); - assertTrue("public class is not public", Modifier.isPublic(ocm)); - assertFalse("public class is protected", Modifier.isProtected(ocm)); - assertFalse("public class is private", Modifier.isPrivate(ocm)); - } - - /** - * @tests java.lang.Class#getName() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getName", - args = {} - ) - public void test_getName() throws Exception { - String className = Class.forName("java.lang.Object").getName(); - assertNotNull(className); - - assertEquals("Class getName printed wrong value", "java.lang.Object", className); - assertEquals("Class getName printed wrong value", "int", int.class.getName()); - className = Class.forName("[I").getName(); - assertNotNull(className); - assertEquals("Class getName printed wrong value", "[I", className); - - className = Class.forName("[Ljava.lang.Object;").getName(); - assertNotNull(className); - - assertEquals("Class getName printed wrong value", "[Ljava.lang.Object;", className); - } - - /** - * @tests java.lang.Class#getResource(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getResource", - args = {java.lang.String.class} - ) - public void test_getResourceLjava_lang_String() { - final String name = "/"; - URL res = getClass().getResource(name + "HelloWorld.txt"); - assertNotNull(res); - assertNull(getClass().getResource( - "org/apache/harmony/luni/tests/java/lang/NonExistentResource")); - assertNull(getClass().getResource(name + "NonExistentResource")); - } - - /** - * @tests java.lang.Class#getResourceAsStream(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "getResourceAsStream", - args = {java.lang.String.class} - ) - public void test_getResourceAsStreamLjava_lang_String() throws Exception { - String name = "/HelloWorld.txt"; - assertNotNull("the file " + name + " can not be found in this " + - "directory", getClass().getResourceAsStream(name)); - - final String nameBadURI = "org/apache/harmony/luni/tests/" + - "test_resource.txt"; - assertNull("the file " + nameBadURI + " should not be found in this " + - "directory", - getClass().getResourceAsStream(nameBadURI)); - - ClassLoader pcl = getClass().getClassLoader(); - Class<?> clazz = pcl.loadClass("org.apache.harmony.luni.tests.java.lang.ClassTest"); - assertNotNull(clazz.getResourceAsStream("HelloWorld1.txt")); - - try { - getClass().getResourceAsStream(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - /** - * @tests java.lang.Class#getSuperclass() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getSuperclass", - args = {} - ) - public void test_getSuperclass() { - assertNull("Object has a superclass???", Object.class.getSuperclass()); - assertSame("Normal class has bogus superclass", InputStream.class, - FileInputStream.class.getSuperclass()); - assertSame("Array class has bogus superclass", Object.class, FileInputStream[].class - .getSuperclass()); - assertNull("Base class has a superclass", int.class.getSuperclass()); - assertNull("Interface class has a superclass", Cloneable.class.getSuperclass()); - } - - /** - * @tests java.lang.Class#isArray() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isArray", - args = {} - ) - public void test_isArray() throws ClassNotFoundException { - assertTrue("Non-array type claims to be.", !int.class.isArray()); - Class<?> clazz = null; - clazz = Class.forName("[I"); - assertTrue("int Array type claims not to be.", clazz.isArray()); - - clazz = Class.forName("[Ljava.lang.Object;"); - assertTrue("Object Array type claims not to be.", clazz.isArray()); - - clazz = Class.forName("java.lang.Object"); - assertTrue("Non-array Object type claims to be.", !clazz.isArray()); - } - - /** - * @tests java.lang.Class#isAssignableFrom(java.lang.Class) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isAssignableFrom", - args = {java.lang.Class.class} - ) - public void test_isAssignableFromLjava_lang_Class() { - Class<?> clazz1 = null; - Class<?> clazz2 = null; - - clazz1 = Object.class; - clazz2 = Class.class; - assertTrue("returned false for superclass", - clazz1.isAssignableFrom(clazz2)); - - clazz1 = TestClass.class; - assertTrue("returned false for same class", - clazz1.isAssignableFrom(clazz1)); - - clazz1 = Runnable.class; - clazz2 = Thread.class; - assertTrue("returned false for implemented interface", - clazz1.isAssignableFrom(clazz2)); - - assertFalse("returned true not assignable classes", - Integer.class.isAssignableFrom(String.class)); - - try { - clazz1.isAssignableFrom(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - /** - * @tests java.lang.Class#isInterface() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isInterface", - args = {} - ) - public void test_isInterface() throws ClassNotFoundException { - assertTrue("Prim type claims to be interface.", !int.class.isInterface()); - Class<?> clazz = null; - clazz = Class.forName("[I"); - assertTrue("Prim Array type claims to be interface.", !clazz.isInterface()); - - clazz = Class.forName("java.lang.Runnable"); - assertTrue("Interface type claims not to be interface.", clazz.isInterface()); - clazz = Class.forName("java.lang.Object"); - assertTrue("Object type claims to be interface.", !clazz.isInterface()); - - clazz = Class.forName("[Ljava.lang.Object;"); - assertTrue("Array type claims to be interface.", !clazz.isInterface()); - } - - /** - * @tests java.lang.Class#isPrimitive() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isPrimitive", - args = {} - ) - public void test_isPrimitive() { - assertFalse("Interface type claims to be primitive.", - Runnable.class.isPrimitive()); - assertFalse("Object type claims to be primitive.", - Object.class.isPrimitive()); - assertFalse("Prim Array type claims to be primitive.", - int[].class.isPrimitive()); - assertFalse("Array type claims to be primitive.", - Object[].class.isPrimitive()); - assertTrue("Prim type claims not to be primitive.", - int.class.isPrimitive()); - assertFalse("Object type claims to be primitive.", - Object.class.isPrimitive()); - } - - /** - * @tests java.lang.Class#newInstance() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "newInstance", - args = {} - ) - public void test_newInstance() throws Exception { - Class<?> clazz = null; - clazz = Class.forName("java.lang.Object"); - assertNotNull("new object instance was null", clazz.newInstance()); - - clazz = Class.forName("java.lang.Throwable"); - assertSame("new Throwable instance was not a throwable", - clazz, clazz.newInstance().getClass()); - - clazz = Class.forName("java.lang.Integer"); - try { - clazz.newInstance(); - fail("Exception for instantiating a newInstance with no default " + - " constructor is not thrown"); - } catch (InstantiationException e) { - // expected - } - - try { - TestClass3.class.newInstance(); - fail("IllegalAccessException is not thrown."); - } catch(IllegalAccessException iae) { - //expected - } - - try { - TestClass1C.class.newInstance(); - fail("ExceptionInInitializerError should be thrown."); - } catch (java.lang.ExceptionInInitializerError ie) { - //expected - } - } - - /** - * @tests java.lang.Class#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() throws ClassNotFoundException { - assertEquals("Class toString printed wrong value", - "int", int.class.toString()); - Class<?> clazz = null; - clazz = Class.forName("[I"); - assertEquals("Class toString printed wrong value", - "class [I", clazz.toString()); - - clazz = Class.forName("java.lang.Object"); - assertEquals("Class toString printed wrong value", - "class java.lang.Object", clazz.toString()); - - clazz = Class.forName("[Ljava.lang.Object;"); - assertEquals("Class toString printed wrong value", - "class [Ljava.lang.Object;", clazz.toString()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "getResourceAsStream", - args = {java.lang.String.class} - ) - // Regression Test for JIRA-2047 - public void test_getResourceAsStream_withSharpChar() throws Exception{ - InputStream in = getClass().getResourceAsStream("/" + FILENAME); - assertNotNull(in); - in.close(); - - in = getClass().getResourceAsStream(FILENAME); - assertNull(in); - - in = this.getClass().getClassLoader().getResourceAsStream( - FILENAME); - assertNotNull(in); - in.close(); - } - - /* - * Regression test for HARMONY-2644: - * Load system and non-system array classes via Class.forName() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies ClassNotFoundException.", - method = "forName", - args = {java.lang.String.class} - ) - public void test_forName_arrays() throws Exception { - Class<?> c1 = getClass(); - String s = c1.getName(); - Class<?> a1 = Class.forName("[L" + s + ";"); - Class<?> a2 = Class.forName("[[L" + s + ";"); - assertSame(c1, a1.getComponentType()); - assertSame(a1, a2.getComponentType()); - Class<?> l4 = Class.forName("[[[[[J"); - assertSame(long[][][][][].class, l4); - - try{ - Class<?> clazz = Class.forName("[;"); - fail("1: " + clazz); - } catch (ClassNotFoundException ok) {} - try{ - Class<?> clazz = Class.forName("[["); - fail("2:" + clazz); - } catch (ClassNotFoundException ok) {} - try{ - Class<?> clazz = Class.forName("[L"); - fail("3:" + clazz); - } catch (ClassNotFoundException ok) {} - try{ - Class<?> clazz = Class.forName("[L;"); - fail("4:" + clazz); - } catch (ClassNotFoundException ok) {} - try{ - Class<?> clazz = Class.forName(";"); - fail("5:" + clazz); - } catch (ClassNotFoundException ok) {} - try{ - Class<?> clazz = Class.forName(""); - fail("6:" + clazz); - } catch (ClassNotFoundException ok) {} - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "asSubclass", - args = {java.lang.Class.class} - ) - public void test_asSubclass1() { - assertEquals(ExtendTestClass.class, - ExtendTestClass.class.asSubclass(PublicTestClass.class)); - - assertEquals(PublicTestClass.class, - PublicTestClass.class.asSubclass(TestInterface.class)); - - assertEquals(ExtendTestClass1.class, - ExtendTestClass1.class.asSubclass(PublicTestClass.class)); - - assertEquals(PublicTestClass.class, - PublicTestClass.class.asSubclass(PublicTestClass.class)); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "asSubclass", - args = {java.lang.Class.class} - ) - public void test_asSubclass2() { - try { - PublicTestClass.class.asSubclass(ExtendTestClass.class); - fail("Test 1: ClassCastException expected."); - } catch(ClassCastException cce) { - // Expected. - } - - try { - PublicTestClass.class.asSubclass(String.class); - fail("Test 2: ClassCastException expected."); - } catch(ClassCastException cce) { - // Expected. - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "cast", - args = {java.lang.Object.class} - ) - public void test_cast() { - Object o = PublicTestClass.class.cast(new ExtendTestClass()); - assertTrue(o instanceof ExtendTestClass); - - try { - ExtendTestClass.class.cast(new PublicTestClass()); - fail("Test 1: ClassCastException expected."); - } catch(ClassCastException cce) { - //expected - } - - try { - ExtendTestClass.class.cast(new String()); - fail("ClassCastException is not thrown."); - } catch(ClassCastException cce) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "desiredAssertionStatus", - args = {} - ) - public void test_desiredAssertionStatus() { - Class [] classArray = { Object.class, Integer.class, - String.class, PublicTestClass.class, - ExtendTestClass.class, ExtendTestClass1.class}; - - for(int i = 0; i < classArray.length; i++) { - assertFalse("assertion status for " + classArray[i], - classArray[i].desiredAssertionStatus()); - } - } - - - - SecurityManager sm = new SecurityManager() { - - final String forbidenPermissionName = "user.dir"; - - public void checkPermission(Permission perm) { - if (perm.getName().equals(forbidenPermissionName)) { - throw new SecurityException(); - } - } - - public void checkMemberAccess(Class<?> clazz, - int which) { - if(clazz.equals(TestClass.class)) { - throw new SecurityException(); - } - } - - public void checkPackageAccess(String pkg) { - if(pkg.equals(TestClass.class.getPackage())) { - throw new SecurityException(); - } - } - - }; -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassTest2.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassTest2.java deleted file mode 100644 index ea69bb2..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ClassTest2.java +++ /dev/null @@ -1,99 +0,0 @@ -/* - * 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 java.io.IOException; -import java.io.InputStream; - -@TestTargetClass(Class.class) -public class ClassTest2 extends junit.framework.TestCase { - - /** - * Sets up the fixture, for example, open a network connection. This method - * is called before a test is executed. - */ - protected void setUp() { - } - - /** - * Tears down the fixture, for example, close a network connection. This - * method is called after a test is executed. - */ - protected void tearDown() { - } - - /** - * Tests loading a resource with a relative name. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "getResourceAsStream", - args = {java.lang.String.class} - ) - public void testGetResourceAsStream1() throws IOException { - Class clazz = getClass(); - - InputStream stream = clazz.getResourceAsStream("HelloWorld.txt"); - assert(stream != null); - - byte[] buffer = new byte[20]; - int length = stream.read(buffer); - String s = new String(buffer, 0, length); - assert("Hello, World.".equals(s)); - - stream.close(); - } - - /** - * Tests loading a resource with a global name. - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "getResourceAsStream", - args = {java.lang.String.class} - ) - public void testGetResourceAsStream2() throws IOException { - Class clazz = getClass(); - - InputStream stream = clazz.getResourceAsStream("/org/apache/harmony/luni/tests/java/lang/HelloWorld.txt"); - assert(stream != null); - - byte[] buffer = new byte[20]; - int length = stream.read(buffer); - String s = new String(buffer, 0, length); - assert("Hello, World.".equals(s)); - - stream.close(); - - try { - clazz.getResourceAsStream(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - assertNull(clazz.getResourceAsStream("/NonExistentResource")); - assertNull(clazz.getResourceAsStream("org/apache/harmony/luni/tests/java/lang/HelloWorld.txt")); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CloneNotSupportedExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CloneNotSupportedExceptionTest.java deleted file mode 100644 index da66da9..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CloneNotSupportedExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class CloneNotSupportedExceptionTest extends TestCase { - - /** - * @tests java.lang.CloneNotSupportedException#CloneNotSupportedException() - */ - public void test_Constructor() { - CloneNotSupportedException e = new CloneNotSupportedException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.CloneNotSupportedException#CloneNotSupportedException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - CloneNotSupportedException e = new CloneNotSupportedException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CompilerTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CompilerTest.java deleted file mode 100644 index 4793a42..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CompilerTest.java +++ /dev/null @@ -1,65 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class CompilerTest extends TestCase { - - /** - * @tests java.lang.Compiler#command(java.lang.Object) - */ - public void test_commandLjava_lang_Object() { - assertNull("Incorrect behavior.", Compiler.command(new Object())); - } - - /** - * @tests java.lang.Compiler#compileClass(java.lang.Class) - */ - public void test_compileClassLjava_lang_Class() { - // Do not test return value, may return true or false depending on - // if the jit is enabled. Make the call to ensure it doesn't crash. - Compiler.compileClass(Compiler.class); - } - - /** - * @tests java.lang.Compiler#compileClasses(java.lang.String) - */ - public void test_compileClassesLjava_lang_String() { - // Do not test return value, may return true or false depending on - // if the jit is enabled. Make the call to ensure it doesn't crash. - Compiler.compileClasses("Compiler"); - } - - /** - * @tests java.lang.Compiler#disable() - */ - public void test_disable() { - Compiler.disable(); - Compiler.compileClass(Compiler.class); - } - - /** - * @tests java.lang.Compiler#enable() - */ - public void test_enable() { - Compiler.disable(); - Compiler.enable(); - Compiler.compileClass(Compiler.class); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java deleted file mode 100644 index 501e981..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java +++ /dev/null @@ -1,1661 +0,0 @@ -/* 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.KnownFailure; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargetClass; - -import junit.framework.TestCase; - -import java.util.Locale; - -@TestTargetClass(Double.class) -public class DoubleTest extends TestCase { - private static final long rawBitsFor3_4en324ToN1[] = { 0x1L, 0x7L, 0x45L, 0x2b0L, 0x1ae2L, - 0x10cd1L, 0xa8028L, 0x69018dL, 0x41a0f7eL, 0x29049aedL, 0x19a2e0d44L, - 0x1005cc84acL, 0xa039fd2ebdL, 0x64243e3d361L, 0x3e96a6e641c6L, 0x271e284fe91b8L, - 0x1872d931f1b131L, 0x4e8f8f7e6e1d7dL, 0x8319b9af04d26eL, 0xb7e0281ac6070aL, - 0xedd832217788ccL, 0x122a71f54eab580L, 0x15750e72a2562e0L, 0x18d2520f4aebb98L, - 0x1c2373498ed353fL, 0x1f6c501bf28828eL, 0x22c76422ef2a332L, 0x261c9e95d57a5ffL, - 0x2963c63b4ad8f7fL, 0x2cbcb7ca1d8f35fL, 0x3015f2de527981bL, 0x335b6f95e717e22L, - 0x36b24b7b60dddabL, 0x3a0f6f2d1c8aa8bL, 0x3d534af863ad52dL, 0x40a81db67c98a79L, - 0x440912920ddf68bL, 0x474b5736915742eL, 0x4a9e2d0435ad13aL, 0x4e02dc22a18c2c4L, - 0x5143932b49ef375L, 0x549477f61c6b052L, 0x57f995f3a385c67L, 0x5b3bfdb846339c0L, - 0x5e8afd2657c0830L, 0x61edbc6fedb0a3dL, 0x653495c5f48e666L, 0x6881bb3771b1fffL, - 0x6be22a054e1e7ffL, 0x6f2d5a4350d30ffL, 0x7278b0d42507d3fL, 0x75d6dd092e49c8fL, - 0x79264a25bcee1daL, 0x7c6fdcaf2c29a50L, 0x7fcbd3daf7340e4L, 0x831f6468da8088eL, - 0x86673d831120ab2L, 0x89c10ce3d568d5fL, 0x8d18a80e656185bL, 0x905ed211feb9e72L, - 0x93b686967e6860eL, 0x9712141e0f013c9L, 0x9a56992592c18bbL, 0x9dac3f6ef771eeaL, - 0xa10ba7a55aa7352L, 0xa44e918eb151027L, 0xa7a235f25da5430L, 0xab0561b77a8749eL, - 0xae46ba2559291c6L, 0xb19868aeaf73637L, 0xb4fe82da5b503c5L, 0xb83f11c8791225bL, - 0xbb8ed63a9756af2L, 0xbef28bc93d2c5afL, 0xc237975dc63bb8dL, 0xc5857d3537caa70L, - 0xc8e6dc8285bd50cL, 0xcc3049d19396528L, 0xcf7c5c45f87be72L, 0xd2db7357769ae0eL, - 0xd6292816aa20cc9L, 0xd973721c54a8ffbL, 0xdcd04ea369d33faL, 0xe0223126222407cL, - 0xe36abd6faaad09bL, 0xe6c56ccb95584c2L, 0xea1b63ff3d572f9L, 0xed623cff0cacfb8L, - 0xf0bacc3ecfd83a5L, 0xf414bfa741e7247L, 0xf759ef911260ed9L, 0xfab06b7556f9290L, - 0xfe0e4329565bb9aL, 0x10151d3f3abf2a80L, 0x104a648f096ef520L, 0x10807ed965e55934L, - 0x10b49e8fbf5eaf81L, 0x10e9c633af365b61L, 0x11201be04d81f91dL, 0x115422d860e27764L, - 0x11892b8e791b153dL, 0x11bf76721761da8cL, 0x11f3aa074e9d2898L, 0x12289489224472beL, - 0x125eb9ab6ad58f6dL, 0x1293340b22c579a4L, 0x12c8010deb76d80dL, 0x12fe015166548e11L, - 0x1332c0d2dff4d8caL, 0x1367710797f20efdL, 0x139d4d497dee92bcL, 0x13d2504deeb51bb6L, - 0x1406e4616a6262a3L, 0x143c9d79c4fafb4cL, 0x1471e26c1b1cdd0fL, 0x14a65b0721e41453L, - 0x14dbf1c8ea5d1968L, 0x1511771d927a2fe1L, 0x1545d4e4f718bbd9L, 0x157b4a1e34deead0L, - 0x15b10e52e10b52c2L, 0x15e551e7994e2772L, 0x161aa6617fa1b14fL, 0x1650a7fcefc50ed1L, - 0x1684d1fc2bb65286L, 0x16ba067b36a3e727L, 0x16f0440d02267078L, 0x1724551042b00c96L, - 0x17596a54535c0fbcL, 0x178fc4e9683313abL, 0x17c3db11e11fec4bL, 0x17f8d1d65967e75eL, - 0x182f064befc1e135L, 0x186363ef75d92cc1L, 0x18983ceb534f77f1L, 0x18ce4c26282355eeL, - 0x1902ef97d91615b5L, 0x1937ab7dcf5b9b22L, 0x196d965d433281eaL, 0x19a27dfa49ff9132L, - 0x19d71d78dc7f757fL, 0x1a0ce4d7139f52dfL, 0x1a420f066c4393cbL, 0x1a7692c8075478beL, - 0x1aac377a092996edL, 0x1ae1a2ac45b9fe54L, 0x1b160b5757287de9L, 0x1b4b8e2d2cf29d64L, - 0x1b8138dc3c17a25eL, 0x1bb587134b1d8af6L, 0x1beae8d81de4edb4L, 0x1c20d18712af1490L, - 0x1c5505e8d75ad9b4L, 0x1c8a47630d319021L, 0x1cc06c9de83efa15L, 0x1cf487c5624eb89aL, - 0x1d29a9b6bae266c1L, 0x1d600a1234cd8038L, 0x1d940c96c200e046L, 0x1dc90fbc72811858L, - 0x1dff53ab8f215e6eL, 0x1e33944b3974db05L, 0x1e68795e07d211c6L, 0x1e9e97b589c69637L, - 0x1ed31ed1761c1de3L, 0x1f07e685d3a3255bL, 0x1f3de027488beeb2L, 0x1f72ac188d57752fL, - 0x1fa7571eb0ad527bL, 0x1fdd2ce65cd8a71aL, 0x20123c0ffa076870L, 0x2046cb13f889428cL, - 0x207c7dd8f6ab932fL, 0x20b1cea79a2b3bfeL, 0x20e6425180b60afdL, 0x211bd2e5e0e38dbcL, - 0x215163cfac8e3896L, 0x2185bcc397b1c6bbL, 0x21bb2bf47d9e386aL, 0x21f0fb78ce82e342L, - 0x22253a5702239c13L, 0x225a88ecc2ac8317L, 0x22909593f9abd1efL, 0x22c4baf8f816c66aL, - 0x22f9e9b7361c7805L, 0x2330321281d1cb03L, 0x23643e9722463dc4L, 0x23994e3cead7cd35L, - 0x23cfa1cc258dc082L, 0x2403c51f97789851L, 0x2438b6677d56be65L, 0x246ee4015cac6dffL, - 0x24a34e80d9ebc4bfL, 0x24d822211066b5efL, 0x250e2aa95480636bL, 0x2542daa9d4d03e23L, - 0x257791544a044dabL, 0x25ad75a95c856116L, 0x25e26989d9d35caeL, 0x261703ec504833d9L, - 0x264cc4e7645a40d0L, 0x2681fb109eb86882L, 0x26b679d4c66682a2L, 0x26ec1849f800234bL, - 0x27218f2e3b00160fL, 0x2755f2f9c9c01b93L, 0x278b6fb83c302277L, 0x27c125d3259e158bL, - 0x27f56f47ef059aedL, 0x282acb19eac701a8L, 0x2860bef032bc6109L, 0x2894eeac3f6b794cL, - 0x28ca2a574f46579eL, 0x29005a76918bf6c3L, 0x2934711435eef474L, 0x29698d59436ab191L, - 0x299ff0af94455df5L, 0x29d3f66dbcab5ab9L, 0x2a08f4092bd63167L, 0x2a3f310b76cbbdc1L, - 0x2a737ea72a3f5699L, 0x2aa85e50f4cf2c3fL, 0x2ade75e53202f74fL, 0x2b1309af3f41da91L, - 0x2b47cc1b0f125135L, 0x2b7dbf21d2d6e583L, 0x2bb2977523c64f72L, 0x2be73d526cb7e34eL, - 0x2c1d0ca707e5dc22L, 0x2c5227e864efa995L, 0x2c86b1e27e2b93faL, 0x2cbc5e5b1db678f9L, - 0x2cf1baf8f2920b9cL, 0x2d2629b72f368e83L, 0x2d5bb424fb043223L, 0x2d9150971ce29f56L, - 0x2dc5a4bce41b472bL, 0x2dfb0dec1d2218f6L, 0x2e30e8b392354f9aL, 0x2e6522e076c2a380L, - 0x2e9a6b9894734c61L, 0x2ed0833f5cc80fbcL, 0x2f04a40f33fa13abL, 0x2f39cd1300f89896L, - 0x2f70202be09b5f5eL, 0x2fa42836d8c23735L, 0x2fd932448ef2c503L, 0x300f7ed5b2af7643L, - 0x3043af458fada9eaL, 0x30789b16f3991465L, 0x30aec1dcb07f597eL, 0x30e33929ee4f97efL, - 0x3118077469e37deaL, 0x314e0951845c5d65L, 0x3182c5d2f2b9ba5fL, 0x31b77747af6828f7L, - 0x31ed55199b423335L, 0x3222553001096001L, 0x3256ea7c014bb801L, 0x328ca51b019ea601L, - 0x32c1e730e10327c1L, 0x32f660fd1943f1b1L, 0x332bf93c5f94ee1dL, 0x33617bc5bbbd14d2L, - 0x3395dab72aac5a07L, 0x33cb5164f5577089L, 0x340112df1956a655L, 0x34355796dfac4febL, - 0x346aad7c979763e5L, 0x34a0ac6ddebe9e6fL, 0x34d4d789566e460bL, 0x350a0d6bac09d78eL, - 0x354048634b8626b9L, 0x35745a7c1e67b067L, 0x35a9711b26019c81L, 0x35dfcd61ef8203a1L, - 0x3613e05d35b14245L, 0x3648d874831d92d6L, 0x367f0e91a3e4f78bL, 0x36b3691b066f1ab7L, - 0x36e84361c80ae165L, 0x371e543a3a0d99beL, 0x3752f4a464488017L, 0x3787b1cd7d5aa01cL, - 0x37bd9e40dcb14823L, 0x37f282e889eecd16L, 0x382723a2ac6a805cL, 0x385cec8b57852073L, - 0x389213d716b33448L, 0x38c698ccdc60015aL, 0x38fc3f00137801b0L, 0x3931a7600c2b010eL, - 0x396611380f35c151L, 0x399b9586130331a6L, 0x39d13d73cbe1ff08L, 0x3a058cd0beda7ec9L, - 0x3a3af004ee911e7cL, 0x3a70d603151ab30dL, 0x3aa50b83da615fd1L, 0x3ada4e64d0f9b7c5L, - 0x3b1070ff029c12dbL, 0x3b448d3ec3431792L, 0x3b79b08e7413dd76L, 0x3bb00e59088c6a6aL, - 0x3be411ef4aaf8504L, 0x3c19166b1d5b6646L, 0x3c4f5c05e4b23fd7L, 0x3c839983aeef67e6L, - 0x3cb87fe49aab41e0L, 0x3cee9fddc1561258L, 0x3d2323ea98d5cb77L, 0x3d57ece53f0b3e55L, - 0x3d8de81e8ece0deaL, 0x3dc2b1131940c8b2L, 0x3df75d57df90fadfL, 0x3e2d34add7753996L, - 0x3e6240eca6a943feL, 0x3e96d127d05394fdL, 0x3ecc8571c4687a3dL, 0x3f01d3671ac14c66L, - 0x3f364840e1719f80L, 0x3f6bda5119ce075fL, 0x3fa16872b020c49cL, 0x3fd5c28f5c28f5c3L, - 0x400B333333333333L }; - - private static final long rawBitsFor1_2e0To309[] = { 0x3ff3333333333333L, 0x4028000000000000L, - 0x405e000000000000L, 0x4092c00000000000L, 0x40c7700000000000L, 0x40fd4c0000000000L, - 0x41324f8000000000L, 0x4166e36000000000L, 0x419c9c3800000000L, 0x41d1e1a300000000L, - 0x42065a0bc0000000L, 0x423bf08eb0000000L, 0x427176592e000000L, 0x42a5d3ef79800000L, - 0x42db48eb57e00000L, 0x43110d9316ec0000L, 0x434550f7dca70000L, 0x437aa535d3d0c000L, - 0x43b0a741a4627800L, 0x43e4d1120d7b1600L, 0x441a055690d9db80L, 0x445043561a882930L, - 0x4484542ba12a337cL, 0x44b969368974c05bL, 0x44efc3842bd1f072L, 0x4523da329b633647L, - 0x4558d0bf423c03d9L, 0x458f04ef12cb04cfL, 0x45c363156bbee301L, 0x45f83bdac6ae9bc2L, - 0x462e4ad1785a42b2L, 0x4662eec2eb3869afL, 0x4697aa73a606841bL, 0x46cd95108f882522L, - 0x47027d2a59b51735L, 0x47371c74f0225d03L, 0x476ce3922c2af443L, 0x47a20e3b5b9ad8aaL, - 0x47d691ca32818ed5L, 0x480c363cbf21f28aL, 0x4841a1e5f7753796L, 0x48760a5f7552857cL, - 0x48ab8cf752a726daL, 0x48e1381a93a87849L, 0x491586213892965bL, 0x494ae7a986b73bf1L, - 0x4980d0c9f4328577L, 0x49b504fc713f26d5L, 0x49ea463b8d8ef08aL, 0x4a206be538795656L, - 0x4a5486de8697abecL, 0x4a89a896283d96e6L, 0x4ac0095dd9267e50L, 0x4af40bb54f701de4L, - 0x4b290ea2a34c255dL, 0x4b5f524b4c1f2eb4L, 0x4b93936f0f937d31L, 0x4bc8784ad3785c7dL, - 0x4bfe965d8856739cL, 0x4c331dfa75360842L, 0x4c67e57912838a52L, 0x4c9dded757246ce6L, - 0x4cd2ab469676c410L, 0x4d0756183c147514L, 0x4d3d2b9e4b199259L, 0x4d723b42eeeffb78L, - 0x4da6ca13aaabfa56L, 0x4ddc7c989556f8ebL, 0x4e11cddf5d565b93L, 0x4e46415734abf278L, - 0x4e7bd1ad01d6ef15L, 0x4eb1630c2126556dL, 0x4ee5bbcf296feac9L, 0x4f1b2ac2f3cbe57bL, - 0x4f50fab9d85f6f6dL, 0x4f8539684e774b48L, 0x4fba87c262151e1aL, 0x4ff094d97d4d32d0L, - 0x5024ba0fdca07f84L, 0x5059e893d3c89f65L, 0x5090315c645d639fL, 0x50c43db37d74bc87L, - 0x50f94d205cd1eba9L, 0x512fa06874066693L, 0x5163c4414884001cL, 0x5198b5519aa50023L, - 0x51cee2a6014e402cL, 0x52034da7c0d0e81bL, 0x52382111b1052222L, 0x526e29561d466aabL, - 0x52a2d9d5d24c02abL, 0x52d7904b46df0355L, 0x530d745e1896c42bL, 0x534268bacf5e3a9bL, - 0x537702e98335c941L, 0x53acc3a3e4033b92L, 0x53e1fa466e82053bL, 0x541678d80a22868aL, - 0x544c170e0cab282cL, 0x54818e68c7eaf91cL, 0x54b5f202f9e5b763L, 0x54eb6e83b85f253bL, - 0x55212512533b7745L, 0x55556e56e80a5516L, 0x558ac9eca20cea5cL, 0x55c0be33e5481279L, - 0x55f4edc0de9a1718L, 0x562a293116409cdeL, 0x566059beade8620bL, 0x5694702e59627a8dL, - 0x56c98c39efbb1931L, 0x56ffef486ba9df7dL, 0x5733f58d434a2baeL, 0x5768f2f0941cb699L, - 0x579f2facb923e440L, 0x57d37dcbf3b66ea8L, 0x58085d3ef0a40a52L, 0x583e748eaccd0ce6L, - 0x587308d92c002810L, 0x58a7cb0f77003214L, 0x58ddbdd354c03e99L, 0x591296a414f82720L, - 0x59473c4d1a3630e8L, 0x597d0b6060c3bd21L, 0x59b2271c3c7a5635L, 0x59e6b0e34b98ebc2L, - 0x5a1c5d1c1e7f26b3L, 0x5a51ba31930f7830L, 0x5a8628bdf7d3563cL, 0x5abbb2ed75c82bcaL, - 0x5af14fd4699d1b5fL, 0x5b25a3c984046236L, 0x5b5b0cbbe5057ac4L, 0x5b90e7f56f236cbaL, - 0x5bc521f2caec47e9L, 0x5bfa6a6f7da759e3L, 0x5c308285ae88982eL, 0x5c64a3271a2abe39L, - 0x5c99cbf0e0b56dc8L, 0x5cd01f768c71649dL, 0x5d0427542f8dbdc4L, 0x5d3931293b712d35L, - 0x5d6f7d738a4d7882L, 0x5da3ae6836706b51L, 0x5dd89a02440c8626L, 0x5e0ec082d50fa7afL, - 0x5e433851c529c8ceL, 0x5e78066636743b01L, 0x5eae07ffc41149c1L, 0x5ee2c4ffda8ace19L, - 0x5f17763fd12d819fL, 0x5f4d53cfc578e207L, 0x5f825461db6b8d44L, 0x5fb6e97a52467095L, - 0x5feca3d8e6d80cbbL, 0x6021e667904707f5L, 0x605660017458c9f2L, 0x608bf801d16efc6eL, - 0x60c17b0122e55dc5L, 0x60f5d9c16b9eb536L, 0x612b5031c6866284L, 0x6161121f1c13fd92L, - 0x619556a6e318fcf7L, 0x61caac509bdf3c34L, 0x6200abb2616b85a1L, 0x6234d69ef9c66709L, - 0x626a0c46b83800cbL, 0x62a047ac3323007fL, 0x62d459973febc09fL, 0x63096ffd0fe6b0c6L, - 0x633fcbfc53e05cf8L, 0x6373df7db46c3a1bL, 0x63a8d75d218748a2L, 0x63df0d3469e91acaL, - 0x64136840c231b0beL, 0x64484250f2be1ceeL, 0x647e52e52f6da42aL, 0x64b2f3cf3da4869aL, - 0x64e7b0c30d0da840L, 0x651d9cf3d0511251L, 0x655282186232ab72L, 0x6587229e7abf564fL, - 0x65bceb46196f2be3L, 0x65f2130bcfe57b6eL, 0x662697cec3deda49L, 0x665c3dc274d690dbL, - 0x6691a69989061a89L, 0x66c6103feb47a12bL, 0x66fb944fe6198976L, 0x67313cb1efcff5eaL, - 0x67658bde6bc3f364L, 0x679aeed606b4f03dL, 0x67d0d545c4311626L, 0x68050a97353d5bb0L, - 0x683a4d3d028cb29cL, 0x687070462197efa2L, 0x68a48c57a9fdeb8aL, 0x68d9af6d947d666cL, - 0x69100da47cce6004L, 0x6944110d9c01f805L, 0x6979155103027606L, 0x69af5aa543c31387L, - 0x69e398a74a59ec35L, 0x6a187ed11cf06742L, 0x6a4e9e85642c8112L, 0x6a8323135e9bd0abL, - 0x6ab7ebd83642c4d6L, 0x6aede6ce43d3760cL, 0x6b22b040ea6429c7L, 0x6b575c5124fd3439L, - 0x6b8d33656e3c8147L, 0x6bc2401f64e5d0cdL, 0x6bf6d0273e1f4500L, 0x6c2c84310da71640L, - 0x6c61d29ea8886de8L, 0x6c96474652aa8962L, 0x6ccbd917e7552bbaL, 0x6d0167aef0953b54L, - 0x6d35c19aacba8a29L, 0x6d6b320157e92cb4L, 0x6da0ff40d6f1bbf0L, 0x6dd53f110cae2aedL, - 0x6e0a8ed54fd9b5a8L, 0x6e40994551e81189L, 0x6e74bf96a66215ebL, 0x6ea9ef7c4ffa9b66L, - 0x6ee035adb1fca120L, 0x6f1443191e7bc967L, 0x6f4953df661abbc1L, 0x6f7fa8d73fa16ab2L, - 0x6fb3c98687c4e2afL, 0x6fe8bbe829b61b5bL, 0x701eeae23423a232L, 0x705352cd6096455fL, - 0x70882780b8bbd6b7L, 0x70be3160e6eacc64L, 0x70f2dedc9052bfbfL, 0x71279693b4676faeL, - 0x715d7c38a1814b9aL, 0x71926da364f0cf40L, 0x71c7090c3e2d0310L, 0x71fccb4f4db843d4L, - 0x7231ff1190932a65L, 0x72667ed5f4b7f4feL, 0x729c1e8b71e5f23dL, 0x72d19317272fb766L, - 0x7305f7dcf0fba540L, 0x733b75d42d3a8e90L, 0x737129a49c44991aL, 0x73a5740dc355bf60L, - 0x73dad111342b2f39L, 0x7410c2aac09afd83L, 0x7444f35570c1bce4L, 0x747a302accf22c1dL, - 0x74b05e1ac0175b92L, 0x74e475a1701d3277L, 0x75199309cc247f15L, 0x754ff7cc3f2d9edaL, - 0x7583fadfa77c8348L, 0x75b8f997915ba41aL, 0x75ef37fd75b28d21L, 0x762382fe698f9834L, - 0x765863be03f37e41L, 0x768e7cad84f05dd2L, 0x76c30dec73163aa3L, 0x76f7d1678fdbc94cL, - 0x772dc5c173d2bb9fL, 0x77629b98e863b543L, 0x7797427f227ca294L, 0x77cd131eeb1bcb39L, - 0x78022bf352f15f04L, 0x7836b6f027adb6c5L, 0x786c64ac31992476L, 0x78a1beeb9effb6caL, - 0x78d62ea686bfa47cL, 0x790bba50286f8d9bL, 0x794154721945b881L, 0x7975a98e9f9726a1L, - 0x79ab13f2477cf049L, 0x79e0ec776cae162eL, 0x7a15279547d99bb9L, 0x7a4a717a99d002a8L, - 0x7a8086eca02201a9L, 0x7ab4a8a7c82a8213L, 0x7ae9d2d1ba352298L, 0x7b2023c31461359fL, - 0x7b542cb3d9798307L, 0x7b8937e0cfd7e3c8L, 0x7bbf85d903cddcbaL, 0x7bf3b3a7a260a9f4L, - 0x7c28a0918af8d472L, 0x7c5ec8b5edb7098eL, 0x7c933d71b49265f9L, 0x7cc80cce21b6ff77L, - 0x7cfe1001aa24bf55L, 0x7d32ca010a56f795L, 0x7d677c814cecb57aL, 0x7d9d5ba1a027e2d9L, - 0x7dd259450418edc7L, 0x7e06ef96451f2939L, 0x7e3cab7bd666f388L, 0x7e71eb2d66005835L, - 0x7ea665f8bf806e42L, 0x7edbff76ef6089d2L, 0x7f117faa559c5623L, 0x7f45df94eb036bacL, - 0x7f7b577a25c44697L, 0x7fb116ac579aac1fL, 0x7fe55c576d815726L, 0x7ff0000000000000L }; - - private void doTestCompareRawBits(String originalDoubleString, long expectedRawBits, - String expectedString) { - double result; - long rawBits; - String convertedString; - result = Double.parseDouble(originalDoubleString); - rawBits = Double.doubleToLongBits(result); - convertedString = new Double(result).toString(); - assertEquals(expectedRawBits, rawBits); - assertEquals(expectedString.toLowerCase(Locale.US), convertedString - .toLowerCase(Locale.US)); - } - - private void test_toString(double dd, String answer) { - assertEquals(answer, Double.toString(dd)); - Double d = new Double(dd); - assertEquals(answer, Double.toString(d.doubleValue())); - assertEquals(answer, d.toString()); - } - - /** - * @tests java.lang.Double#Double(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Double", - args = {double.class} - ) - public void test_ConstructorD() { - Double d = new Double(39089.88888888888888888888888888888888); - assertEquals("Created incorrect double", 39089.88888888888888888888888888888888, d - .doubleValue(), 0D); - } - - /** - * @tests java.lang.Double#Double(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Double", - args = {java.lang.String.class} - ) - public void test_ConstructorLjava_lang_String() { - Double d = new Double("39089.88888888888888888888888888888888"); - assertEquals("Created incorrect double", 39089.88888888888888888888888888888888, d - .doubleValue(), 0D); - - // REGRESSION for HARMONY-489 - try { - d = new Double("1E+-20"); - fail("new Double(\"1E+-20\") should throw exception"); - } catch (NumberFormatException e) { - // expected - } - } - - /** - * @tests java.lang.Double#byteValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "byteValue", - args = {} - ) - public void test_byteValue() { - Double d = new Double(1923311.47712); - assertEquals("Returned incorrect byte value", (byte) -17, d.byteValue()); - d= new Double(Byte.MAX_VALUE); - assertEquals("Returned incorrect byte value", Byte.MAX_VALUE, d.byteValue()); - d= new Double(Byte.MIN_VALUE); - assertEquals("Returned incorrect byte value", Byte.MIN_VALUE, d.byteValue()); - d= new Double(Double.MAX_VALUE); - assertEquals("Returned incorrect byte value", -1, d.byteValue()); - } - - /** - * @tests java.lang.Double#compareTo(java.lang.Double) - * @tests java.lang.Double#compare(double, double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "compare", - args = {double.class, double.class} - ) - public void test_compare() { - double[] values = new double[] { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, -2d, - -Double.MIN_VALUE, -0d, 0d, Double.MIN_VALUE, 2d, Double.MAX_VALUE, - Double.POSITIVE_INFINITY, Double.NaN }; - for (int i = 0; i < values.length; i++) { - double d1 = values[i]; - assertTrue("compare() should be equal: " + d1, Double.compare(d1, d1) == 0); - Double D1 = new Double(d1); - assertTrue("compareTo() should be equal: " + d1, D1.compareTo(D1) == 0); - for (int j = i + 1; j < values.length; j++) { - double d2 = values[j]; - assertTrue("compare() " + d1 + " should be less " + d2, - Double.compare(d1, d2) == -1); - assertTrue("compare() " + d2 + " should be greater " + d1, Double.compare(d2, - d1) == 1); - Double D2 = new Double(d2); - assertTrue("compareTo() " + d1 + " should be less " + d2, - D1.compareTo(D2) == -1); - assertTrue("compareTo() " + d2 + " should be greater " + d1, - D2.compareTo(D1) == 1); - } - } - - try { - new Double(0.0D).compareTo(null); - fail("No NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Double#doubleToLongBits(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "doubleToLongBits", - args = {double.class} - ) - public void test_doubleToLongBitsD() { - // Test for method long java.lang.Double.doubleToLongBits(double) - Double d = new Double(Double.MAX_VALUE); - long lbits = Double.doubleToLongBits(d.doubleValue()); - double r = Double.longBitsToDouble(lbits); - - assertTrue("Bit conversion failed", d.doubleValue() == r); - - assertEquals(0x7ff8000000000000L, Double.doubleToLongBits(Double.NaN)); - assertEquals(0x7ff0000000000000L, Double.doubleToLongBits(Double.POSITIVE_INFINITY)); - assertEquals(0xfff0000000000000L, Double.doubleToLongBits(Double.NEGATIVE_INFINITY)); - } - - /** - * @tests java.lang.Double#doubleToRawLongBits(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "doubleToRawLongBits", - args = {double.class} - ) - public void test_doubleToRawLongBitsD() { - long l = 0x7ff80000000004d2L; - double d = Double.longBitsToDouble(l); - assertTrue("Wrong raw bits", Double.doubleToRawLongBits(d) == l); - - assertEquals(0x7ff8000000000000L, Double.doubleToLongBits(Double.NaN)); - assertEquals(0x7ff0000000000000L, Double.doubleToLongBits(Double.POSITIVE_INFINITY)); - assertEquals(0xfff0000000000000L, Double.doubleToLongBits(Double.NEGATIVE_INFINITY)); - } - - /** - * @tests java.lang.Double#doubleValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "doubleValue", - args = {} - ) - public void test_doubleValue() { - assertEquals("Incorrect double value returned", 999999999999999.9999999999999, - new Double(999999999999999.9999999999999).doubleValue(), 0D); - assertEquals(Double.POSITIVE_INFINITY, new Double("1.7976931348623159E308").doubleValue()); - assertEquals(Double.NEGATIVE_INFINITY, new Double("-1.7976931348623159E308").doubleValue()); - assertEquals(Double.MAX_VALUE, new Double("1.7976931348623157E308").doubleValue()); - assertEquals(Double.MIN_VALUE, new Double("4.9E-324").doubleValue()); - } - - /** - * @tests java.lang.Double#floatValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "floatValue", - args = {} - ) - public void test_floatValue() { - // Test for method float java.lang.Double.floatValue() - assertTrue( - "Incorrect float value returned ", - Math.abs(new Double(999999999999999.9999999999999d). - floatValue() - 999999999999999.9999999999999f) < 1); - assertEquals(Float.POSITIVE_INFINITY, new Double("3.4028236E38").floatValue()); - assertEquals(Float.NEGATIVE_INFINITY, new Double("-3.4028236E38").floatValue()); - assertEquals(Float.MAX_VALUE, new Double("3.4028235E38").floatValue()); - assertEquals(Float.MIN_VALUE, new Double("1.4E-45").floatValue()); - } - - /** - * @tests java.lang.Double#hashCode() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) - public void test_hashCode() { - // Test for method int java.lang.Double.hashCode() - for (int i = -1000; i < 1000; i++) { - Double d = new Double(i); - Double dd = new Double(i); - assertTrue("Should not be identical ", d != dd); - assertTrue("Should be equals 1 ", d.equals(dd)); - assertTrue("Should be equals 2 ", dd.equals(d)); - assertTrue("Should have identical values ", dd.doubleValue() == d.doubleValue()); - assertTrue("Invalid hash for equal but not identical doubles ", d.hashCode() == dd - .hashCode()); - } - assertEquals("Magic assumption hasCode (0.0) = 0 failed", 0, new Double(0.0).hashCode()); - } - - /** - * @tests java.lang.Double#intValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "intValue", - args = {} - ) - public void test_intValue() { - // Test for method int java.lang.Double.intValue() - Double d = new Double(1923311.47712); - assertEquals("Returned incorrect int value", 1923311, d.intValue()); - assertEquals("Returned incorrect int value", Integer.MAX_VALUE, - new Double(2147483648d).intValue()); - assertEquals("Returned incorrect int value", Integer.MIN_VALUE, - new Double(-2147483649d).intValue()); - } - - /** - * @tests java.lang.Double#isInfinite() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isInfinite", - args = {} - ) - public void test_isInfinite() { - // Test for method boolean java.lang.Double.isInfinite() - assertTrue("NEGATIVE_INFINITY returned false", new Double(Double.NEGATIVE_INFINITY) - .isInfinite()); - assertTrue("POSITIVE_INFINITY returned false", new Double(Double.POSITIVE_INFINITY) - .isInfinite()); - assertTrue("Non infinite number returned true", !(new Double(1000).isInfinite())); - } - - /** - * @tests java.lang.Double#isInfinite(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isInfinite", - args = {double.class} - ) - public void test_isInfiniteD() { - // Test for method boolean java.lang.Double.isInfinite(double) - assertTrue("Infinity check failed", Double.isInfinite(Double.NEGATIVE_INFINITY) - && (Double.isInfinite(Double.POSITIVE_INFINITY)) - && !(Double.isInfinite(Double.MAX_VALUE))); - } - - /** - * @tests java.lang.Double#isNaN() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isNaN", - args = {} - ) - public void test_isNaN() { - // Test for method boolean java.lang.Double.isNaN() - Double d = new Double(0.0 / 0.0); - assertTrue("NAN returned false", d.isNaN()); - d = new Double(0); - assertTrue("Non NAN returned true", !d.isNaN()); - } - - /** - * @tests java.lang.Double#isNaN(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isNaN", - args = {double.class} - ) - public void test_isNaND() { - // Test for method boolean java.lang.Double.isNaN(double) - - Double d = new Double(0.0 / 0.0); - assertTrue("NAN check failed", Double.isNaN(d.doubleValue())); - - assertFalse("Doesn't return false value", Double.isNaN(new Double(Double.MAX_VALUE))); - } - - /** - * @tests java.lang.Double#longBitsToDouble(long) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "longBitsToDouble", - args = {long.class} - ) - public void test_longBitsToDoubleJ() { - // Test for method double java.lang.Double.longBitsToDouble(long) - - Double d = new Double(Double.MAX_VALUE); - long lbits = Double.doubleToLongBits(d.doubleValue()); - double r = Double.longBitsToDouble(lbits); - - assertTrue("Bit conversion failed", d.doubleValue() == r); - } - - /** - * @tests java.lang.Double#longValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "longValue", - args = {} - ) - public void test_longValue() { - // Test for method long java.lang.Double.longValue() - Double d = new Double(1923311.47712); - assertEquals("Returned incorrect long value", 1923311, d.longValue()); - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies boundary values and the loop due to the difference in the expected output string.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDoubleLjava_lang_String() { - assertEquals("Incorrect double returned, expected zero.", 0.0, Double - .parseDouble("2.4703282292062327208828439643411e-324"), 0.0); - assertTrue("Incorrect double returned, expected minimum double.", Double - .parseDouble("2.4703282292062327208828439643412e-324") == Double.MIN_VALUE); - - for (int i = 324; i > 0; i--) { - Double.parseDouble("3.4e-" + i); - } - for (int i = 0; i <= 309; i++) { - Double.parseDouble("1.2e" + i); - } - - /* - * The first two cases and the last four cases have to placed outside - * the loop due to the difference in the expected output string. - */ - doTestCompareRawBits("3.4e-324", rawBitsFor3_4en324ToN1[0], "4.9e-324"); - doTestCompareRawBits("3.4e-323", rawBitsFor3_4en324ToN1[1], "3.5e-323"); - for (int i = 322; i > 3; i--) { - String testString, expectedString; - testString = expectedString = "3.4e-" + i; - doTestCompareRawBits(testString, rawBitsFor3_4en324ToN1[324 - i], expectedString); - } - doTestCompareRawBits("3.4e-3", rawBitsFor3_4en324ToN1[321], "0.0034"); - doTestCompareRawBits("3.4e-2", rawBitsFor3_4en324ToN1[322], "0.034"); - doTestCompareRawBits("3.4e-1", rawBitsFor3_4en324ToN1[323], "0.34"); - doTestCompareRawBits("3.4e-0", rawBitsFor3_4en324ToN1[324], "3.4"); - - doTestCompareRawBits("1.2e0", rawBitsFor1_2e0To309[0], "1.2"); - doTestCompareRawBits("1.2e1", rawBitsFor1_2e0To309[1], "12.0"); - doTestCompareRawBits("1.2e2", rawBitsFor1_2e0To309[2], "120.0"); - doTestCompareRawBits("1.2e3", rawBitsFor1_2e0To309[3], "1200.0"); - doTestCompareRawBits("1.2e4", rawBitsFor1_2e0To309[4], "12000.0"); - doTestCompareRawBits("1.2e5", rawBitsFor1_2e0To309[5], "120000.0"); - doTestCompareRawBits("1.2e6", rawBitsFor1_2e0To309[6], "1200000.0"); - for (int i = 7; i <= 308; i++) { - String testString, expectedString; - testString = expectedString = "1.2e" + i; - doTestCompareRawBits(testString, rawBitsFor1_2e0To309[i], expectedString); - } - doTestCompareRawBits("1.2e309", rawBitsFor1_2e0To309[309], "Infinity"); - - doTestCompareRawBits( - "111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000.92233720368547758079223372036854775807", - 0x7e054218c295e43fL, "1.1122233344455567E299"); - doTestCompareRawBits( - "-111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000111222333444555666777888999000.92233720368547758079223372036854775807", - 0xfe054218c295e43fL, "-1.1122233344455567E299"); - - doTestCompareRawBits("1.234123412431233E107", 0x562ae7a25fe706ebL, - "1.234123412431233E107"); - doTestCompareRawBits("1.2341234124312331E107", 0x562ae7a25fe706ecL, - "1.2341234124312331E107"); - doTestCompareRawBits("1.2341234124312332E107", 0x562ae7a25fe706ecL, - "1.2341234124312331E107"); - doTestCompareRawBits("-1.234123412431233E107", 0xd62ae7a25fe706ebL, - "-1.234123412431233E107"); - doTestCompareRawBits("-1.2341234124312331E107", 0xd62ae7a25fe706ecL, - "-1.2341234124312331E107"); - doTestCompareRawBits("-1.2341234124312332E107", 0xd62ae7a25fe706ecL, - "-1.2341234124312331E107"); - - doTestCompareRawBits("9.999999999999999e22", 0x44b52d02c7e14af6L, - "9.999999999999999e22"); - - /* - * These particular tests verify that the extreme boundary conditions - * are converted correctly. - */ - doTestCompareRawBits("0.0e-309", 0L, "0.0"); - doTestCompareRawBits("-0.0e-309", 0x8000000000000000L, "-0.0"); - doTestCompareRawBits("0.0e309", 0L, "0.0"); - doTestCompareRawBits("-0.0e309", 0x8000000000000000L, "-0.0"); - doTestCompareRawBits("0.1e309", 0x7fe1ccf385ebc8a0L, "1.0e308"); - doTestCompareRawBits("0.2e309", 0x7ff0000000000000L, "Infinity"); - doTestCompareRawBits("65e-325", 1L, "4.9e-324"); - doTestCompareRawBits("1000e-326", 2L, "1.0e-323"); - - doTestCompareRawBits("4.0e-306", 0x86789e3750f791L, "4.0e-306"); - doTestCompareRawBits("2.22507e-308", 0xffffe2e8159d0L, "2.22507e-308"); - doTestCompareRawBits( - "111222333444555666777888999000111228999000.92233720368547758079223372036854775807", - 0x48746da623f1dd8bL, "1.1122233344455567E41"); - doTestCompareRawBits( - "-111222333444555666777888999000111228999000.92233720368547758079223372036854775807", - 0xc8746da623f1dd8bL, "-1.1122233344455567E41"); - doTestCompareRawBits( - "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210", - 0x54820fe0ba17f469L, "1.2345678901234567E99"); - doTestCompareRawBits( - "-1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890.987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210987654321098765432109876543210", - 0xd4820fe0ba17f469L, "-1.2345678901234567E99"); - - doTestCompareRawBits( - "179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", - 0x7fefffffffffffffL, "1.7976931348623157E308"); - doTestCompareRawBits( - "-179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", - 0xffefffffffffffffL, "-1.7976931348623157E308"); - doTestCompareRawBits( - "1112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001234567890", - 0x7ff0000000000000L, "Infinity"); - doTestCompareRawBits( - "-1112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001112223334445556667778889990001234567890", - 0xfff0000000000000L, "-Infinity"); - doTestCompareRawBits( - "179769313486231590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", - 0x7ff0000000000000L, "Infinity"); - doTestCompareRawBits( - "-179769313486231590000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.01", - 0xfff0000000000000L, "-Infinity"); - doTestCompareRawBits( - "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0x2b392a32afcc661eL, "1.7976931348623157E-100"); - doTestCompareRawBits( - "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0xab392a32afcc661eL, "-1.7976931348623157E-100"); - doTestCompareRawBits( - "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0x1b3432f0cb68e61L, "1.7976931348623157E-300"); - doTestCompareRawBits( - "-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0x81b3432f0cb68e61L, "-1.7976931348623157E-300"); - doTestCompareRawBits( - "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0x2117b590b942L, "1.79769313486234E-310"); - doTestCompareRawBits( - "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0x80002117b590b942L, "-1.79769313486234E-310"); - doTestCompareRawBits( - "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0xe37L, "1.798E-320"); - doTestCompareRawBits( - "-0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000017976931348623157", - 0x8000000000000e37L, "-1.798E-320"); - doTestCompareRawBits( - "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", - 0x2L, "1.0E-323"); - doTestCompareRawBits( - "-0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001", - 0x8000000000000002L, "-1.0E-323"); - doTestCompareRawBits( - "0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055595409854908458349204328908234982349050934129878452378432452458968024357823490509341298784523784324524589680243578234905093412987845237843245245896802435782349050934129878452378432452458968024357868024357823490509341298784523784324524589680243578234905093412987845237843245245896802435786802435782349050934129878452378432452458968024357823490509341298784523784324524589680243578", - 0x1L, "4.9E-324"); - doTestCompareRawBits( - "-0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000055595409854908458349204328908234982349050934129878452378432452458968024357823490509341298784523784324524589680243578234905093412987845237843245245896802435782349050934129878452378432452458968024357868024357823490509341298784523784324524589680243578234905093412987845237843245245896802435786802435782349050934129878452378432452458968024357823490509341298784523784324524589680243578", - 0x8000000000000001L, "-4.9E-324"); - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies NumberFormatException.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_Illegal() { - try { - Double.parseDouble("0.0p0D"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble("+0x.p1d"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble("0Xg.gp1D"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble("-0x1.1p"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble("+0x 1.1 p2d"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble("x1.1p2d"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble(" 0x-2.1p2"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble(" 0x2.1pad"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - - try { - Double.parseDouble(" 0x111.222p 22d"); - fail("Should throw NumberFormatException."); - } catch (NumberFormatException e) { - // expected - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Doesn't check exception.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_FromHexString() { - double actual; - double expected; - - actual = Double.parseDouble("0x0.0p0D"); - assertEquals("Returned incorrect value", 0.0d, actual, 0.0D); - - actual = Double.parseDouble("0xa.ap+9d"); - assertEquals("Returned incorrect value", 5440.0d, actual, 0.0D); - - actual = Double.parseDouble("+0Xb.10ap8"); - assertEquals("Returned incorrect value", 2832.625d, actual, 0.0D); - - actual = Double.parseDouble("-0X.a0P2D"); - assertEquals("Returned incorrect value", -2.5d, actual, 0.0D); - - actual = Double.parseDouble("\r 0x22.1p2d \t"); - assertEquals("Returned incorrect value", 136.25d, actual, 0.0D); - - actual = Double.parseDouble("0x1.0p-1"); - assertEquals("Returned incorrect value", 0.5, actual, 0.0D); - - actual = Double - .parseDouble("0x00000000000000000000000000000000001.0p-1"); - assertEquals("Returned incorrect value", 0.5, actual, 0.0D); - - actual = Double.parseDouble("0x1.0p-00000000000000000000000000001"); - assertEquals("Returned incorrect value", 0.5, actual, 0.0D); - - actual = Double.parseDouble("0x.100000000000000000000000000000000p1"); - assertEquals("Returned incorrect value", 0.125, actual, 0.0D); - - actual = Double.parseDouble("0x0.0p999999999999999999999999999999999999999999999999999999999999999"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - - actual = Double.parseDouble("0xf1.0p9999999999999999999999999999999999999999999999999999999999999999"); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); - - actual = Double.parseDouble("0xffffffffffffffffffffffffffffffffffff.ffffffffffffffffffffffffffffffffffffffffffffffp1"); - expected = Double.longBitsToDouble(0x4900000000000000L); - assertEquals("Returned incorrect value", expected, actual, 0.0D); - - actual = Double.parseDouble("0x0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001p1600"); - expected = Double.longBitsToDouble(0x7f30000000000000L); - assertEquals("Returned incorrect value", expected, actual, 0.0D); - - actual = Double.parseDouble("0x0.0p-999999999999999999999999999999999999999999999999999999"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - - actual = Double.parseDouble("0xf1.0p-9999999999999999999999999999999999999999999999999999999999999999"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - - actual = Double.parseDouble("0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000p-1600"); - expected = Double.longBitsToDouble(0xf0000000000000L); - assertEquals("Returned incorrect value", expected, actual, 0.0D); - - actual = Double.parseDouble("0x1.p9223372036854775807"); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); - - actual = Double.parseDouble("0x1.p9223372036854775808"); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); - - actual = Double.parseDouble("0x10.p9223372036854775808"); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); - - actual = Double.parseDouble("0xabcd.ffffffffp+2000"); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D); - - actual = Double.parseDouble("0x1.p-9223372036854775808"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - - actual = Double.parseDouble("0x1.p-9223372036854775809"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - - actual = Double.parseDouble("0x.1p-9223372036854775809"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - - actual = Double.parseDouble("0xabcd.ffffffffffffffp-2000"); - assertEquals("Returned incorrect value", 0.0, actual, 0.0D); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Regression test for hotfix in native code of double parser.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_AndroidRegression() { - // Android regression test - long startTime = System.currentTimeMillis(); - double actual = Double.parseDouble("9e551027"); - assertTrue("parsing double 9e551027 took too long.", - (System.currentTimeMillis() - startTime) < 1000); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, - actual, 0.0D); - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies positive functionality.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_NormalPositiveExponent() { - long[] expecteds = { - 0x3f323456789abcdfL, 0x40e111012345678aL, 0x41a1110091a2b3c5L, - 0x4259998091a2b3c5L, 0x4311110048d159e2L, 0x43c5554048d159e2L, - 0x4479998048d159e2L, 0x452dddc048d159e2L, 0x45e111002468acf1L, - 0x469333202468acf1L, 0x4751011001234568L, 0x4802112101234568L, - 0x48b3213201234568L, 0x4964314301234568L, 0x4a15415401234568L, - 0x4ac6516501234568L, 0x4b77617601234568L, 0x4c28718701234568L, - 0x4cd9819801234568L, 0x4d9049048091a2b4L, 0x4e4101100091a2b4L, - 0x4ef189188091a2b4L, 0x4fa211210091a2b4L, 0x505299298091a2b4L, - 0x510321320091a2b4L, 0x51b3a93a8091a2b4L, 0x526431430091a2b4L, - 0x5314b94b8091a2b4L, 0x53c841840091a2b4L, 0x5478c98c8091a2b4L, - 0x552981980091a2b4L, 0x55da09a08091a2b4L, 0x568a91a90091a2b4L, - 0x573b19b18091a2b4L, 0x57eba1ba0091a2b4L, 0x589c29c28091a2b4L, - 0x594cb1cb0091a2b4L, 0x5a001d01c048d15aL, 0x5ab061060048d15aL, - 0x5b60a50a4048d15aL, 0x5c1101100048d15aL, 0x5cc145144048d15aL, - 0x5d7189188048d15aL, 0x5e21cd1cc048d15aL, 0x5ed211210048d15aL, - 0x5f8255254048d15aL, 0x603419418048d15aL, 0x60e45d45c048d15aL, - 0x6194a14a0048d15aL, 0x6244e54e4048d15aL, 0x62f541540048d15aL, - 0x63a585584048d15aL, 0x6455c95c8048d15aL, 0x65060d60c048d15aL, - 0x65b651650048d15aL, 0x666815814048d15aL, 0x671859858048d15aL, - 0x67c89d89c048d15aL, 0x6878e18e0048d15aL, 0x692925924048d15aL, - 0x69d981980048d15aL, 0x6a89c59c4048d15aL, 0x6b3a09a08048d15aL, - 0x6bea4da4c048d15aL, 0x6c9c11c10048d15aL, 0x6d4c55c54048d15aL, - 0x6dfc99c98048d15aL, 0x6eacddcdc048d15aL, 0x6f5d21d20048d15aL, - 0x700d65d64048d15aL, 0x70bdc1dc0048d15aL, 0x716e05e04048d15aL, - 0x721e49e48048d15aL, 0x72d00700602468adL, 0x73802902802468adL, - 0x74304b04a02468adL, 0x74e06d06c02468adL, 0x75908f08e02468adL, - 0x7640b10b002468adL, 0x76f0d30d202468adL, 0x77a10110002468adL, - 0x78512312202468adL, 0x79020520402468adL, 0x79b22722602468adL, - 0x7a624924802468adL, 0x7b126b26a02468adL, 0x7bc28d28c02468adL, - 0x7c72af2ae02468adL, 0x7d22d12d002468adL, 0x7dd2f32f202468adL, - 0x7e832132002468adL, 0x7f40011001012345L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L }; - - for (int i = 0; i < expecteds.length; i++) { - int part = i*11; - String inputString = "0x" + part + "." + part + "0123456789abcdefp" + part; - - double actual = Double.parseDouble(inputString); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputString - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies positive functionality.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_NormalNegativeExponent() { - long[] expecteds = { - 0x3f323456789abcdfL, 0x3f8111012345678aL, 0x3ee1110091a2b3c5L, - 0x3e39998091a2b3c5L, 0x3d91110048d159e2L, 0x3ce5554048d159e2L, - 0x3c39998048d159e2L, 0x3b8dddc048d159e2L, 0x3ae111002468acf1L, - 0x3a3333202468acf1L, 0x3991011001234568L, 0x38e2112101234568L, - 0x3833213201234568L, 0x3784314301234568L, 0x36d5415401234568L, - 0x3626516501234568L, 0x3577617601234568L, 0x34c8718701234568L, - 0x3419819801234568L, 0x337049048091a2b4L, 0x32c101100091a2b4L, - 0x321189188091a2b4L, 0x316211210091a2b4L, 0x30b299298091a2b4L, - 0x300321320091a2b4L, 0x2f53a93a8091a2b4L, 0x2ea431430091a2b4L, - 0x2df4b94b8091a2b4L, 0x2d4841840091a2b4L, 0x2c98c98c8091a2b4L, - 0x2be981980091a2b4L, 0x2b3a09a08091a2b4L, 0x2a8a91a90091a2b4L, - 0x29db19b18091a2b4L, 0x292ba1ba0091a2b4L, 0x287c29c28091a2b4L, - 0x27ccb1cb0091a2b4L, 0x27201d01c048d15aL, 0x267061060048d15aL, - 0x25c0a50a4048d15aL, 0x251101100048d15aL, 0x246145144048d15aL, - 0x23b189188048d15aL, 0x2301cd1cc048d15aL, 0x225211210048d15aL, - 0x21a255254048d15aL, 0x20f419418048d15aL, 0x20445d45c048d15aL, - 0x1f94a14a0048d15aL, 0x1ee4e54e4048d15aL, 0x1e3541540048d15aL, - 0x1d8585584048d15aL, 0x1cd5c95c8048d15aL, 0x1c260d60c048d15aL, - 0x1b7651650048d15aL, 0x1ac815814048d15aL, 0x1a1859858048d15aL, - 0x19689d89c048d15aL, 0x18b8e18e0048d15aL, 0x180925924048d15aL, - 0x175981980048d15aL, 0x16a9c59c4048d15aL, 0x15fa09a08048d15aL, - 0x154a4da4c048d15aL, 0x149c11c10048d15aL, 0x13ec55c54048d15aL, - 0x133c99c98048d15aL, 0x128cddcdc048d15aL, 0x11dd21d20048d15aL, - 0x112d65d64048d15aL, 0x107dc1dc0048d15aL, 0xfce05e04048d15aL, - 0xf1e49e48048d15aL, 0xe700700602468adL, 0xdc02902802468adL, - 0xd104b04a02468adL, 0xc606d06c02468adL, 0xbb08f08e02468adL, - 0xb00b10b002468adL, 0xa50d30d202468adL, 0x9a10110002468adL, - 0x8f12312202468adL, 0x8420520402468adL, 0x7922722602468adL, - 0x6e24924802468adL, 0x6326b26a02468adL, 0x5828d28c02468adL, - 0x4d2af2ae02468adL, 0x422d12d002468adL, 0x372f32f202468adL, - 0x2c32132002468adL, 0x220011001012345L, 0x170121012012345L, - 0xc0231023012345L, 0x10341034012345L, 0x208a208a024L, - 0x41584158L, 0x83388L, 0x108L, - 0x0L, 0x0L, 0x0L, - 0x0L, 0x0L, 0x0L, - 0x0L, 0x0L, 0x0L, - 0x0L, 0x0L, 0x0L, - 0x0L, 0x0L }; - - for (int i = 0; i < expecteds.length; i++) { - int part = i*11; - String inputString = "0x" + part + "." + part + "0123456789abcdefp-" + part; - - double actual = Double.parseDouble(inputString); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputString - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies max boundary.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_MaxNormalBoundary() { - long[] expecteds = { - 0x7fefffffffffffffL, 0x7fefffffffffffffL, 0x7fefffffffffffffL, - 0x7fefffffffffffffL, 0x7fefffffffffffffL, 0x7fefffffffffffffL, - 0x7fefffffffffffffL, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - 0x7ff0000000000000L, 0x7ff0000000000000L, 0x7ff0000000000000L, - - 0xffefffffffffffffL, 0xffefffffffffffffL, 0xffefffffffffffffL, - 0xffefffffffffffffL, 0xffefffffffffffffL, 0xffefffffffffffffL, - 0xffefffffffffffffL, 0xfff0000000000000L, 0xfff0000000000000L, - 0xfff0000000000000L, 0xfff0000000000000L, 0xfff0000000000000L, - 0xfff0000000000000L, 0xfff0000000000000L, 0xfff0000000000000L }; - - String[] inputs = { - "0x1.fffffffffffffp1023", - "0x1.fffffffffffff000000000000000000000000001p1023", - "0x1.fffffffffffff1p1023", - "0x1.fffffffffffff100000000000000000000000001p1023", - "0x1.fffffffffffff1fffffffffffffffffffffffffffffffffffffffffffffp1023", - "0x1.fffffffffffff7p1023", - "0x1.fffffffffffff700000000000000000000000001p1023", - "0x1.fffffffffffff8p1023", - "0x1.fffffffffffff800000000000000000000000001p1023", - "0x1.fffffffffffff8fffffffffffffffffffffffffffffffffffffffffffffp1023", - "0x1.fffffffffffff9p1023", - "0x1.fffffffffffff900000000000000000000000001p1023", - "0x1.ffffffffffffffp1023", - "0x1.ffffffffffffff00000000000000000000000001p1023", - "0x1.fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp1023", - - "-0x1.fffffffffffffp1023", - "-0x1.fffffffffffff000000000000000000000000001p1023", - "-0x1.fffffffffffff1p1023", - "-0x1.fffffffffffff100000000000000000000000001p1023", - "-0x1.fffffffffffff1fffffffffffffffffffffffffffffffffffffffffffffp1023", - "-0x1.fffffffffffff7p1023", - "-0x1.fffffffffffff700000000000000000000000001p1023", - "-0x1.fffffffffffff8p1023", - "-0x1.fffffffffffff800000000000000000000000001p1023", - "-0x1.fffffffffffff8fffffffffffffffffffffffffffffffffffffffffffffp1023", - "-0x1.fffffffffffff9p1023", - "-0x1.fffffffffffff900000000000000000000000001p1023", - "-0x1.ffffffffffffffp1023", - "-0x1.ffffffffffffff00000000000000000000000001p1023", - "-0x1.fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp1023" }; - - for (int i = 0; i < inputs.length; i++) { - double actual = Double.parseDouble(inputs[i]); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies Min boundary.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_MinNormalBoundary() { - long[] expecteds = { - 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, - 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, - 0x10000000000000L, 0x10000000000000L, 0x10000000000001L, - 0x10000000000001L, 0x10000000000001L, 0x10000000000001L, - 0x10000000000001L, 0x10000000000001L, 0x10000000000001L, - - 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L, - 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L, - 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000001L, - 0x8010000000000001L, 0x8010000000000001L, 0x8010000000000001L, - 0x8010000000000001L, 0x8010000000000001L, 0x8010000000000001L }; - - String[] inputs = { - "0x1.0p-1022", - "0x1.00000000000001p-1022", - "0x1.000000000000010000000000000000001p-1022", - "0x1.00000000000001fffffffffffffffffffffffffffffffffp-1022", - "0x1.00000000000007p-1022", - "0x1.000000000000070000000000000000001p-1022", - "0x1.00000000000007fffffffffffffffffffffffffffffffffp-1022", - "0x1.00000000000008p-1022", - "0x1.000000000000080000000000000000001p-1022", - "0x1.00000000000008fffffffffffffffffffffffffffffffffp-1022", - "0x1.00000000000009p-1022", - "0x1.000000000000090000000000000000001p-1022", - "0x1.00000000000009fffffffffffffffffffffffffffffffffp-1022", - "0x1.0000000000000fp-1022", - "0x1.0000000000000ffffffffffffffffffffffffffffffffffp-1022", - - "-0x1.0p-1022", - "-0x1.00000000000001p-1022", - "-0x1.000000000000010000000000000000001p-1022", - "-0x1.00000000000001fffffffffffffffffffffffffffffffffp-1022", - "-0x1.00000000000007p-1022", - "-0x1.000000000000070000000000000000001p-1022", - "-0x1.00000000000007fffffffffffffffffffffffffffffffffp-1022", - "-0x1.00000000000008p-1022", - "-0x1.000000000000080000000000000000001p-1022", - "-0x1.00000000000008fffffffffffffffffffffffffffffffffp-1022", - "-0x1.00000000000009p-1022", - "-0x1.000000000000090000000000000000001p-1022", - "-0x1.00000000000009fffffffffffffffffffffffffffffffffp-1022", - "-0x1.0000000000000fp-1022", - "-0x1.0000000000000ffffffffffffffffffffffffffffffffffp-1022" }; - - for (int i = 0; i < inputs.length; i++) { - double actual = Double.parseDouble(inputs[i]); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies Max boundary.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_MaxSubNormalBoundary() { - long[] expecteds = { - 0xfffffffffffffL, 0xfffffffffffffL, 0xfffffffffffffL, - 0xfffffffffffffL, 0xfffffffffffffL, 0xfffffffffffffL, - 0xfffffffffffffL, 0x10000000000000L, 0x10000000000000L, - 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, - 0x10000000000000L, 0x10000000000000L, 0x10000000000000L, - - 0x800fffffffffffffL, 0x800fffffffffffffL, 0x800fffffffffffffL, - 0x800fffffffffffffL, 0x800fffffffffffffL, 0x800fffffffffffffL, - 0x800fffffffffffffL, 0x8010000000000000L, 0x8010000000000000L, - 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L, - 0x8010000000000000L, 0x8010000000000000L, 0x8010000000000000L }; - - String[] inputs = { - "0x0.fffffffffffffp-1022", - "0x0.fffffffffffff00000000000000000000000000000000001p-1022", - "0x0.fffffffffffff1p-1022", - "0x0.fffffffffffff10000000000000000000000000000000001p-1022", - "0x0.fffffffffffff1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "0x0.fffffffffffff7p-1022", - "0x0.fffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "0x0.fffffffffffff8p-1022", - "0x0.fffffffffffff80000000000000000000000000000000001p-1022", - "0x0.fffffffffffff8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "0x0.fffffffffffff9p-1022", - "0x0.fffffffffffff9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "0x0.ffffffffffffffp-1022", - "0x0.ffffffffffffff0000000000000000000000000000000001p-1022", - "0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - - "-0x0.fffffffffffffp-1022", - "-0x0.fffffffffffff00000000000000000000000000000000001p-1022", - "-0x0.fffffffffffff1p-1022", - "-0x0.fffffffffffff10000000000000000000000000000000001p-1022", - "-0x0.fffffffffffff1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "-0x0.fffffffffffff7p-1022", - "-0x0.fffffffffffff7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "-0x0.fffffffffffff8p-1022", - "-0x0.fffffffffffff80000000000000000000000000000000001p-1022", - "-0x0.fffffffffffff8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "-0x0.fffffffffffff9p-1022", - "-0x0.fffffffffffff9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022", - "-0x0.ffffffffffffffp-1022", - "-0x0.ffffffffffffff0000000000000000000000000000000001p-1022", - "-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-1022" }; - - for (int i = 0; i < inputs.length; i++) { - double actual = Double.parseDouble(inputs[i]); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies Min boundary.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_MinSubNormalBoundary() { - long[] expecteds = { - 0x1L, 0x1L, 0x2L, - 0x1L, 0x1L, 0x1L, - 0x2L, 0x2L, 0x2L, - 0x2L, 0x2L, 0x2L, - 0x2L, 0x2L, 0x2L, - - 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000002L, - 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L, - 0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L, - 0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L, - 0x8000000000000002L, 0x8000000000000002L, 0x8000000000000002L }; - - String[] inputs = { - "0x0.0000000000001p-1022", - "0x0.00000000000010000000000000000001p-1022", - "0x0.0000000000001fffffffffffffffffffffffffffffffffp-1022", - "0x0.00000000000017p-1022", - "0x0.000000000000170000000000000000001p-1022", - "0x0.00000000000017fffffffffffffffffffffffffffffffffp-1022", - "0x0.00000000000018p-1022", - "0x0.000000000000180000000000000000001p-1022", - "0x0.00000000000018fffffffffffffffffffffffffffffffffp-1022", - "0x0.00000000000019p-1022", - "0x0.000000000000190000000000000000001p-1022", - "0x0.00000000000019fffffffffffffffffffffffffffffffffp-1022", - "0x0.0000000000001fp-1022", - "0x0.0000000000001f0000000000000000001p-1022", - "0x0.0000000000001ffffffffffffffffffffffffffffffffffp-1022", - - "-0x0.0000000000001p-1022", - "-0x0.00000000000010000000000000000001p-1022", - "-0x0.0000000000001fffffffffffffffffffffffffffffffffp-1022", - "-0x0.00000000000017p-1022", - "-0x0.000000000000170000000000000000001p-1022", - "-0x0.00000000000017fffffffffffffffffffffffffffffffffp-1022", - "-0x0.00000000000018p-1022", - "-0x0.000000000000180000000000000000001p-1022", - "-0x0.00000000000018fffffffffffffffffffffffffffffffffp-1022", - "-0x0.00000000000019p-1022", - "-0x0.000000000000190000000000000000001p-1022", - "-0x0.00000000000019fffffffffffffffffffffffffffffffffp-1022", - "-0x0.0000000000001fp-1022", - "-0x0.0000000000001f0000000000000000001p-1022", - "-0x0.0000000000001ffffffffffffffffffffffffffffffffffp-1022" }; - - for (int i = 0; i < inputs.length; i++) { - double actual = Double.parseDouble(inputs[i]); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#parseDouble(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies zero boundary.", - method = "parseDouble", - args = {java.lang.String.class} - ) - public void test_parseDouble_LString_ZeroBoundary() { - long[] expecteds = { - 0x0L, 0x0L, 0x0L, - 0x1L, 0x1L, 0x1L, - 0x1L, 0x1L, 0x1L, - 0x8000000000000000L, 0x8000000000000000L, 0x8000000000000000L, - 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L, - 0x8000000000000001L, 0x8000000000000001L, 0x8000000000000001L }; - - String[] inputs = { - "0x0.00000000000004p-1022", - "0x0.00000000000007ffffffffffffffffffffffp-1022", - "0x0.00000000000008p-1022", - "0x0.000000000000080000000000000000001p-1022", - "0x0.00000000000008fffffffffffffffffffffffffffffffp-1022", - "0x0.00000000000009p-1022", - "0x0.000000000000090000000000000000001p-1022", - "0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022", - "0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022", - - "-0x0.00000000000004p-1022", - "-0x0.00000000000007ffffffffffffffffffffffp-1022", - "-0x0.00000000000008p-1022", - "-0x0.000000000000080000000000000000001p-1022", - "-0x0.00000000000008fffffffffffffffffffffffffffffffp-1022", - "-0x0.00000000000009p-1022", - "-0x0.000000000000090000000000000000001p-1022", - "-0x0.00000000000009fffffffffffffffffffffffffffffffffp-1022", - "-0x0.0000000000000fffffffffffffffffffffffffffffffffffp-1022" }; - - for (int i = 0; i < inputs.length; i++) { - double actual = Double.parseDouble(inputs[i]); - double expected = Double.longBitsToDouble(expecteds[i]); - - String expectedString = "0x" + Long.toHexString(Double.doubleToLongBits(expected)); - String actualString = "0x" + Long.toHexString(Double.doubleToLongBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0D); - } - } - - /** - * @tests java.lang.Double#shortValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "shortValue", - args = {} - ) - public void test_shortValue() { - // Test for method short java.lang.Double.shortValue() - Double d = new Double(1923311.47712); - assertEquals("Returned incorrect short value", 22767, d.shortValue()); - } - - /** - * @tests java.lang.Double#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - // Test for method java.lang.String java.lang.Double.toString() - test_toString(1.7976931348623157E308, "1.7976931348623157E308"); - test_toString(5.0E-4, "5.0E-4"); - } - - /** - * @tests java.lang.Double#toString(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {double.class} - ) - public void test_toStringD() { - // Test for method java.lang.String java.lang.Double.toString(double) - test_toString(1.7976931348623157E308, "1.7976931348623157E308"); - test_toString(1.0 / 0.0, "Infinity"); - test_toString(0.0 / 0.0, "NaN"); - test_toString(-1.0 / 0.0, "-Infinity"); - - double d; - d = Double.longBitsToDouble(0x470fffffffffffffL); - test_toString(d, "2.0769187434139308E34"); - d = Double.longBitsToDouble(0x4710000000000000L); - test_toString(d, "2.076918743413931E34"); - - d = Double.longBitsToDouble(0x470000000000000aL); - test_toString(d, "1.0384593717069678E34"); - d = Double.longBitsToDouble(0x470000000000000bL); - test_toString(d, "1.038459371706968E34"); - - d = Double.longBitsToDouble(0x4700000000000017L); - test_toString(d, "1.0384593717069708E34"); - d = Double.longBitsToDouble(0x4700000000000018L); - test_toString(d, "1.038459371706971E34"); - - d = Double.longBitsToDouble(0x4700000000000024L); - test_toString(d, "1.0384593717069738E34"); - d = Double.longBitsToDouble(0x4700000000000025L); - test_toString(d, "1.038459371706974E34"); - - d = Double.longBitsToDouble(0x4700000000000031L); - test_toString(d, "1.0384593717069768E34"); - d = Double.longBitsToDouble(0x4700000000000032L); - test_toString(d, "1.038459371706977E34"); - - d = Double.longBitsToDouble(0x470000000000003eL); - test_toString(d, "1.0384593717069798E34"); - d = Double.longBitsToDouble(0x470000000000003fL); - test_toString(d, "1.03845937170698E34"); - - d = Double.longBitsToDouble(0x7e00000000000003L); - test_toString(d, "8.371160993642719E298"); - d = Double.longBitsToDouble(0x7e00000000000004L); - test_toString(d, "8.37116099364272E298"); - - d = Double.longBitsToDouble(0x7e00000000000008L); - test_toString(d, "8.371160993642728E298"); - d = Double.longBitsToDouble(0x7e00000000000009L); - test_toString(d, "8.37116099364273E298"); - - d = Double.longBitsToDouble(0x7e00000000000013L); - test_toString(d, "8.371160993642749E298"); - d = Double.longBitsToDouble(0x7e00000000000014L); - test_toString(d, "8.37116099364275E298"); - - d = Double.longBitsToDouble(0x7e00000000000023L); - test_toString(d, "8.371160993642779E298"); - d = Double.longBitsToDouble(0x7e00000000000024L); - test_toString(d, "8.37116099364278E298"); - - d = Double.longBitsToDouble(0x7e0000000000002eL); - test_toString(d, "8.371160993642799E298"); - d = Double.longBitsToDouble(0x7e0000000000002fL); - test_toString(d, "8.3711609936428E298"); - - d = Double.longBitsToDouble(0xda00000000000001L); - test_toString(d, "-3.3846065602060736E125"); - d = Double.longBitsToDouble(0xda00000000000002L); - test_toString(d, "-3.384606560206074E125"); - - d = Double.longBitsToDouble(0xda00000000000005L); - test_toString(d, "-3.3846065602060766E125"); - d = Double.longBitsToDouble(0xda00000000000006L); - test_toString(d, "-3.384606560206077E125"); - - d = Double.longBitsToDouble(0xda00000000000009L); - test_toString(d, "-3.3846065602060796E125"); - d = Double.longBitsToDouble(0xda0000000000000aL); - test_toString(d, "-3.38460656020608E125"); - - d = Double.longBitsToDouble(0xda0000000000000dL); - test_toString(d, "-3.3846065602060826E125"); - d = Double.longBitsToDouble(0xda0000000000000eL); - test_toString(d, "-3.384606560206083E125"); - } - - /** - * @tests java.lang.Double#valueOf(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "valueOf", - args = {java.lang.String.class} - ) - public void test_valueOfLjava_lang_String() { - // Test for method java.lang.Double - // java.lang.Double.valueOf(java.lang.String) - assertTrue("Incorrect double returned", Math.abs(Double.valueOf("999999999999.999") - .doubleValue() - 999999999999.999d) < 1); - - try { - Double.valueOf(null); - fail("Expected Double.valueOf(null) to throw NPE."); - } catch (NullPointerException ex) { - // expected - } catch (Throwable ex) { - fail("Expected Double.valueOf(null) to throw NPE not " + ex.getClass().getName()); - } - - try { - Double.valueOf(""); - fail("Expected Double.valueOf(\"\") to throw NFE"); - } catch (NumberFormatException e) { - // expected - } - - Double pi = Double.valueOf("3.141592654"); - assertEquals(3.141592654, pi.doubleValue(), 0D); - - Double posZero = Double.valueOf("+0.0"); - Double negZero = Double.valueOf("-0.0"); - assertFalse("Doubletest0", posZero.equals(negZero)); - - // Tests for double values by name. - Double expectedNaN = new Double(Double.NaN); - - Double posNaN = Double.valueOf("NaN"); - assertTrue("Doubletest1", posNaN.equals(expectedNaN)); - - Double posNaNSigned = Double.valueOf("+NaN"); - assertTrue("Doubletest2", posNaNSigned.equals(expectedNaN)); - - Double negNaNSigned = Double.valueOf("-NaN"); - assertTrue("Doubletest3", negNaNSigned.equals(expectedNaN)); - - Double posInfinite = Double.valueOf("Infinity"); - assertTrue("Doubletest4", posInfinite.equals(new Double(Double.POSITIVE_INFINITY))); - - Double posInfiniteSigned = Double.valueOf("+Infinity"); - assertTrue("Doubletest5", posInfiniteSigned - .equals(new Double(Double.POSITIVE_INFINITY))); - - Double negInfiniteSigned = Double.valueOf("-Infinity"); - assertTrue("Doubletest6", negInfiniteSigned - .equals(new Double(Double.NEGATIVE_INFINITY))); - } - - /** - * @tests java.lang.Double#compareTo(java.lang.Double) - * @tests java.lang.Double#compare(double, double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "compareTo", - args = {java.lang.Double.class} - ) - public void test_compareToLjava_lang_Double() { - // A selection of double values in ascending order. - double[] values = new double[] { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, -2d, - -Double.MIN_VALUE, -0d, 0d, Double.MIN_VALUE, 2d, Double.MAX_VALUE, - Double.POSITIVE_INFINITY, Double.NaN }; - for (int i = 0; i < values.length; i++) { - double d1 = values[i]; - - // Test that each value compares equal to itself; and each object is - // equal to another object like itself. - assertTrue("Assert 0: compare() should be equal: " + d1, - Double.compare(d1, d1) == 0); - Double objDouble = new Double(d1); - assertTrue("Assert 1: compareTo() should be equal: " + d1, objDouble - .compareTo(objDouble) == 0); - - // Test that the Double-defined order is respected - for (int j = i + 1; j < values.length; j++) { - double d2 = values[j]; - assertTrue("Assert 2: compare() " + d1 + " should be less " + d2, Double - .compare(d1, d2) == -1); - assertTrue("Assert 3: compare() " + d2 + " should be greater " + d1, Double - .compare(d2, d1) == 1); - Double D2 = new Double(d2); - assertTrue("Assert 4: compareTo() " + d1 + " should be less " + d2, objDouble - .compareTo(D2) == -1); - assertTrue("Assert 5: compareTo() " + d2 + " should be greater " + d1, D2 - .compareTo(objDouble) == 1); - } - } - - try { - new Double(0.0D).compareTo(null); - fail("No NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Double#equals(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) - public void test_equalsLjava_lang_Object() { - Double d1 = new Double(87654321.12345d); - Double d2 = new Double(87654321.12345d); - Double d3 = new Double(0.0002f); - assertTrue("Assert 0: Equality test failed", d1.equals(d2) && !(d1.equals(d3))); - - assertTrue("Assert 2: NaN should not be == Nan", Double.NaN != Double.NaN); - assertTrue("Assert 3: NaN should not be == Nan", new Double(Double.NaN) - .equals(new Double(Double.NaN))); - assertTrue("Assert 4: -0d should be == 0d", 0d == -0d); - assertTrue("Assert 5: -0d should not be equals() 0d", !new Double(0d) - .equals(new Double(-0d))); - - Double dmax = new Double(Double.MAX_VALUE); - Double dmax1 = new Double(Double.MAX_VALUE); - - assertTrue("Equality test failed", dmax.equals(dmax1) && !(dmax.equals(new Object()))); - } - - /** - * @tests java.lang.Double#toHexString(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toHexString", - args = {double.class} - ) - public void test_toHexStringF() { - // the follow values come from the Double Javadoc/Spec - assertEquals("0x0.0p0", Double.toHexString(0.0D)); - assertEquals("-0x0.0p0", Double.toHexString(-0.0D)); - assertEquals("0x1.0p0", Double.toHexString(1.0D)); - assertEquals("-0x1.0p0", Double.toHexString(-1.0D)); - assertEquals("0x1.0p1", Double.toHexString(2.0D)); - assertEquals("0x1.8p1", Double.toHexString(3.0D)); - assertEquals("0x1.0p-1", Double.toHexString(0.5D)); - assertEquals("0x1.0p-2", Double.toHexString(0.25D)); - assertEquals("0x1.fffffffffffffp1023", Double.toHexString(Double.MAX_VALUE)); - assertEquals("0x0.0000000000001p-1022", Double.toHexString(Double.MIN_VALUE)); - - // test edge cases - assertEquals("NaN", Double.toHexString(Double.NaN)); - assertEquals("-Infinity", Double.toHexString(Double.NEGATIVE_INFINITY)); - assertEquals("Infinity", Double.toHexString(Double.POSITIVE_INFINITY)); - - // test various numbers - assertEquals("-0x1.da8p6", Double.toHexString(-118.625D)); - assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65D)); - assertEquals("0x1.2957874cccccdp23", Double.toHexString(9743299.65000D)); - assertEquals("0x1.2957874cccf63p23", Double.toHexString(9743299.650001234D)); - assertEquals("0x1.700d1061d3333p33", Double.toHexString(12349743299.65000D)); - - // test HARMONY-2132 - assertEquals("0x1.01p10", Double.toHexString(0x1.01p10)); - } - - /** - * @tests java.lang.Double#valueOf(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "valueOf", - args = {double.class} - ) - public void test_valueOfD() { - assertEquals(new Double(Double.MIN_VALUE), Double.valueOf(Double.MIN_VALUE)); - assertEquals(new Double(Double.MAX_VALUE), Double.valueOf(Double.MAX_VALUE)); - assertEquals(new Double(0), Double.valueOf(0)); - - int s = -128; - while (s < 128) { - assertEquals(new Double(s), Double.valueOf(s)); - assertEquals(new Double(s + 0.1D), Double.valueOf(s + 0.1D)); - s++; - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/EnumConstantNotPresentExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/EnumConstantNotPresentExceptionTest.java deleted file mode 100644 index 053c694..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/EnumConstantNotPresentExceptionTest.java +++ /dev/null @@ -1,55 +0,0 @@ -/* 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 junit.framework.TestCase; - -public class EnumConstantNotPresentExceptionTest extends TestCase { - - public enum Fixture { - ONE,TWO,THREE - } - - /** - * @test java.lang.EnumConstantNotPresentException#EnumConstantNotPresentException(Class<? - * extends Enum>, String) - */ - public void test_ConstructorLjava_lang_ClassLjava_lang_String() { - try { - new EnumConstantNotPresentException(null, ""); - fail("No NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @test java.lang.EnumConstantNotPresentException#enumType() - */ - public void test_enumType() { - EnumConstantNotPresentException e = new EnumConstantNotPresentException(Fixture.class, "FOUR"); - assertEquals(Fixture.class, e.enumType()); - } - - /** - * @test java.lang.EnumConstantNotPresentException#constantName() - */ - public void test_constantName() { - EnumConstantNotPresentException e = new EnumConstantNotPresentException(Fixture.class, "FOUR"); - assertEquals("FOUR", e.constantName()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ErrorTest.java deleted file mode 100644 index 32db9b3..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class ErrorTest extends TestCase { - - /** - * @tests java.lang.Error#Error() - */ - public void test_Constructor() { - Error e = new Error(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.Error#Error(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - Error e = new Error("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExceptionInInitializerErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExceptionInInitializerErrorTest.java deleted file mode 100644 index 83c6cd8..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExceptionInInitializerErrorTest.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * 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; - -public class ExceptionInInitializerErrorTest extends junit.framework.TestCase { - - /** - * @tests java.lang.ExceptionInInitializerError#ExceptionInInitializerError() - */ - public void test_Constructor() { - ExceptionInInitializerError e = new ExceptionInInitializerError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ExceptionInInitializerError#ExceptionInInitializerError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - ExceptionInInitializerError e = new ExceptionInInitializerError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.ExceptionInInitializerExceptionInInitializerError#ExceptionInInitializerError(java.lang.Throwable) - */ - public void test_ConstructorLjava_lang_Throwable() { - NullPointerException npe = new NullPointerException("fixture"); - ExceptionInInitializerError e = new ExceptionInInitializerError(npe); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertSame(npe, e.getException()); - assertSame(npe, e.getCause()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExceptionTest.java deleted file mode 100644 index 88cc2e4..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class ExceptionTest extends TestCase { - - /** - * @tests java.lang.Exception#Exception() - */ - public void test_Constructor() { - Exception e = new Exception(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.Exception#Exception(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - Exception e = new Exception("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExtendTestClass.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExtendTestClass.java deleted file mode 100644 index f4944b2..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExtendTestClass.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.harmony.luni.tests.java.lang; - -@Deprecated -@TestAnnotation("org.apache.harmony.luni.tests.java.lang.ExtendTestClass") -public class ExtendTestClass extends PublicTestClass { - - private static final long serialVersionUID = 1L; - - public enum enumExm {ONE, TWO, THREE}; - @Override - public void setCount(int value) { - - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExtendTestClass1.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExtendTestClass1.java deleted file mode 100644 index 8af91f1..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ExtendTestClass1.java +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class ExtendTestClass1 extends ExtendTestClass { - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java deleted file mode 100644 index a81b96e..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java +++ /dev/null @@ -1,1293 +0,0 @@ -/* 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(Float.class) -public class FloatTest extends TestCase { - - private static final int rawBitsFor3_4eN38To38[] = { 0x1394470, 0x2e7958c, 0x490bd77, 0x634ecd5, - 0x7e2280b, 0x98d5907, 0xb30af48, 0xcdcdb1a, 0xe8a08f0, 0x102c8b2d, 0x11d7adf8, - 0x1386ccbb, 0x15287fe9, 0x16d29fe4, 0x1883a3ee, 0x1a248cea, 0x1bcdb025, 0x1d808e17, - 0x1f20b19d, 0x20c8de04, 0x227b1585, 0x241ced73, 0x25c428d0, 0x27753303, 0x29193fe2, - 0x2abf8fdb, 0x2c6f73d1, 0x2e15a863, 0x2fbb127c, 0x3169d71a, 0x33122671, 0x34b6b00d, - 0x36645c10, 0x380eb98a, 0x39b267ec, 0x3b5f01e8, 0x3d0b6131, 0x3eae397d, 0x4059c7dc, - 0x42081cea, 0x43aa2424, 0x4554ad2d, 0x4704ec3c, 0x48a6274b, 0x4a4fb11e, 0x4c01ceb3, - 0x4da2425f, 0x4f4ad2f7, 0x50fd87b5, 0x529e74d1, 0x54461205, 0x55f79687, 0x579abe14, - 0x59416d99, 0x5af1c900, 0x5c971da0, 0x5e3ce508, 0x5fec1e4a, 0x619392ee, 0x633877a9, - 0x64e69594, 0x66901d7c, 0x683424dc, 0x69e12e12, 0x6b8cbccb, 0x6d2febfe, 0x6edbe6fe, - 0x7089705f, 0x722bcc76, 0x73d6bf94, 0x758637bc, 0x7727c5ac, 0x78d1b717, 0x7a83126e, - 0x7c23d70a, 0x7dcccccc, 0x7f7fffff }; - - private static final String expectedStringFor3_4eN38To38[] = { "3.4028235E-38", "3.4028235E-37", - "3.4028233E-36", "3.4028234E-35", "3.4028236E-34", "3.4028236E-33", - "3.4028234E-32", "3.4028234E-31", "3.4028233E-30", "3.4028236E-29", - "3.4028235E-28", "3.4028235E-27", "3.4028233E-26", "3.4028235E-25", - "3.4028233E-24", "3.4028235E-23", "3.4028236E-22", "3.4028235E-21", - "3.4028236E-20", "3.4028236E-19", "3.4028236E-18", "3.4028235E-17", - "3.4028236E-16", "3.4028234E-15", "3.4028234E-14", "3.4028235E-13", - "3.4028234E-12", "3.4028235E-11", "3.4028236E-10", "3.4028234E-9", "3.4028236E-8", - "3.4028236E-7", "3.4028235E-6", "3.4028235E-5", "3.4028233E-4", "0.0034028236", - "0.034028236", "0.34028235", "3.4028234", "34.028236", "340.28235", "3402.8235", - "34028.234", "340282.34", "3402823.5", "3.4028236E7", "3.40282336E8", - "3.40282342E9", "3.40282348E10", "3.40282343E11", "3.40282337E12", "3.40282353E13", - "3.4028234E14", "3.4028234E15", "3.40282356E16", "3.40282356E17", "3.40282356E18", - "3.4028236E19", "3.4028235E20", "3.4028233E21", "3.4028235E22", "3.4028233E23", - "3.4028236E24", "3.4028234E25", "3.4028233E26", "3.4028234E27", "3.4028235E28", - "3.4028236E29", "3.4028233E30", "3.4028235E31", "3.4028233E32", "3.4028236E33", - "3.4028236E34", "3.4028234E35", "3.4028236E36", "3.4028235E37", "3.4028235E38" }; - - private static final int rawBitsFor1_17eN38To38[] = { 0x80800000, 0x82200000, 0x83c80000, - 0x857a0000, 0x871c4000, 0x88c35000, 0x8a742400, 0x8c189680, 0x8dbebc20, 0x8f6e6b28, - 0x911502f9, 0x92ba43b7, 0x9468d4a5, 0x961184e7, 0x97b5e621, 0x99635fa9, 0x9b0e1bca, - 0x9cb1a2bc, 0x9e5e0b6b, 0xa00ac723, 0xa1ad78ec, 0xa358d727, 0xa5078678, 0xa6a96816, - 0xa853c21c, 0xaa045951, 0xaba56fa6, 0xad4ecb8f, 0xaf013f39, 0xb0a18f08, 0xb249f2ca, - 0xb3fc6f7c, 0xb59dc5ae, 0xb7453719, 0xb8f684df, 0xba9a130c, 0xbc4097ce, 0xbdf0bdc2, - 0xbf967699, 0xc13c1440, 0xc2eb1950, 0xc492efd2, 0xc637abc6, 0xc7e596b8, 0xc98f7e33, - 0xcb335dc0, 0xcce0352f, 0xce8c213e, 0xd02f298d, 0xd1daf3f0, 0xd388d876, 0xd52b0e94, - 0xd6d5d239, 0xd885a363, 0xda270c3c, 0xdbd0cf4b, 0xdd82818f, 0xdf2321f3, 0xe0cbea70, - 0xe27ee50b, 0xe41f4f27, 0xe5c722f1, 0xe778ebad, 0xe91b934c, 0xeac2781f, 0xec731627, - 0xee17edd8, 0xefbde94f, 0xf16d63a2, 0xf3145e45, 0xf4b975d7, 0xf667d34c, 0xf810e410, - 0xf9b51d14, 0xfb626459, 0xfd0d7eb7, 0xfeb0de65 }; - - private static final String expectedStringFor1_17eN38To38[] = { "-1.17549435E-38", - "-1.1754944E-37", "-1.17549435E-36", "-1.17549435E-35", "-1.1754944E-34", - "-1.17549435E-33", "-1.17549435E-32", "-1.1754944E-31", "-1.17549435E-30", - "-1.17549435E-29", "-1.1754944E-28", "-1.1754943E-27", "-1.17549435E-26", - "-1.1754943E-25", "-1.1754944E-24", "-1.1754943E-23", "-1.1754944E-22", - "-1.1754943E-21", "-1.1754943E-20", "-1.1754943E-19", "-1.1754944E-18", - "-1.1754944E-17", "-1.1754943E-16", "-1.1754943E-15", "-1.1754944E-14", - "-1.1754943E-13", "-1.1754944E-12", "-1.1754943E-11", "-1.1754943E-10", - "-1.1754944E-9", "-1.1754944E-8", "-1.1754943E-7", "-1.1754944E-6", - "-1.1754943E-5", "-1.1754943E-4", "-0.0011754944", "-0.011754943", "-0.117549434", - "-1.1754943", "-11.754944", "-117.54944", "-1175.4944", "-11754.943", "-117549.44", - "-1175494.4", "-1.1754944E7", "-1.17549432E8", "-1.1754944E9", "-1.17549435E10", - "-1.17549433E11", "-1.17549433E12", "-1.17549438E13", "-1.17549438E14", - "-1.1754943E15", "-1.17549432E16", "-1.17549432E17", "-1.17549434E18", - "-1.1754944E19", "-1.1754944E20", "-1.1754943E21", "-1.1754943E22", - "-1.1754944E23", "-1.17549434E24", "-1.1754943E25", "-1.1754943E26", - "-1.17549434E27", "-1.1754943E28", "-1.1754944E29", "-1.1754943E30", - "-1.1754943E31", "-1.1754944E32", "-1.1754943E33", "-1.1754944E34", - "-1.1754944E35", "-1.1754944E36", "-1.1754943E37", "-1.1754943E38" }; - - private void doTestCompareRawBits(String originalFloatString, int expectedRawBits, - String expectedString) { - int rawBits; - float result = Float.parseFloat(originalFloatString); - rawBits = Float.floatToIntBits(result); - assertEquals("Original float(" + originalFloatString + ") Converted float(" + result - + ") Expecting:" + Integer.toHexString(expectedRawBits) + " Got: " - + Integer.toHexString(rawBits), expectedRawBits, rawBits); - } - - /** - * @tests java.lang.Float#Float(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Float", - args = {float.class} - ) - public void test_ConstructorF() { - // Test for method java.lang.Float(float) - - Float f = new Float(900.89f); - assertTrue("Created incorrect float", f.floatValue() == 900.89f); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Float", - args = {double.class} - ) - public void test_ConstructorD() { - - Float f = new Float(Double.MAX_VALUE); - assertTrue("Created incorrect float", f.floatValue() == Float.POSITIVE_INFINITY); - } - - /** - * @tests java.lang.Float#Float(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Float", - args = {java.lang.String.class} - ) - public void test_ConstructorLjava_lang_String() { - // Test for method java.lang.Float(java.lang.String) - - Float f = new Float("900.89"); - assertTrue("Created incorrect Float", f.floatValue() == 900.89f); - try { - new Float("900.89ff"); - fail("NumberFormatException is not thrown."); - } catch(NumberFormatException nfe) { - //expected - } - } - - /** - * @tests java.lang.Float#byteValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "byteValue", - args = {} - ) - public void test_byteValue() { - // Test for method byte java.lang.Float.byteValue() - Float f = new Float(0.46874f); - Float f2 = new Float(90.8f); - assertTrue("Returned incorrect byte value", f.byteValue() == 0 && f2.byteValue() == 90); - } - - /** - * @tests java.lang.Float#compareTo(java.lang.Float) - * @tests java.lang.Float#compare(float, float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "compare", - args = {float.class, float.class} - ) - public void test_compare() { - float[] values = new float[] { Float.NEGATIVE_INFINITY, -Float.MAX_VALUE, -2f, - -Float.MIN_VALUE, -0f, 0f, Float.MIN_VALUE, 2f, Float.MAX_VALUE, - Float.POSITIVE_INFINITY, Float.NaN }; - for (int i = 0; i < values.length; i++) { - float f1 = values[i]; - assertTrue("compare() should be equal: " + f1, Float.compare(f1, f1) == 0); - Float F1 = new Float(f1); - assertTrue("compareTo() should be equal: " + f1, F1.compareTo(F1) == 0); - for (int j = i + 1; j < values.length; j++) { - float f2 = values[j]; - assertTrue("compare() " + f1 + " should be less " + f2, - Float.compare(f1, f2) == -1); - assertTrue("compare() " + f2 + " should be greater " + f1, Float - .compare(f2, f1) == 1); - Float F2 = new Float(f2); - assertTrue("compareTo() " + f1 + " should be less " + f2, - F1.compareTo(F2) == -1); - assertTrue("compareTo() " + f2 + " should be greater " + f1, - F2.compareTo(F1) == 1); - } - } - - try { - new Float(0.0F).compareTo(null); - fail("No NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Float#doubleValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "doubleValue", - args = {} - ) - public void test_doubleValue() { - // Test for method double java.lang.Float.doubleValue() - assertTrue("Incorrect double value returned", Math.abs(new Float(999999.999f) - .doubleValue() - 999999.999d) < 1); - } - - /** - * @tests java.lang.Float#floatToIntBits(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "floatToIntBits", - args = {float.class} - ) - public void test_floatToIntBitsF() { - float f = 9876.2345f; - int bits = Float.floatToIntBits(f); - float r = Float.intBitsToFloat(bits); - assertTrue("Incorrect intBits returned", f == r); - - assertEquals(0x7f800000, Float.floatToIntBits(Float.POSITIVE_INFINITY)); - assertEquals(0xff800000, Float.floatToIntBits(Float.NEGATIVE_INFINITY)); - assertEquals(0x7fc00000, Float.floatToIntBits(Float.NaN)); - } - - /** - * @tests java.lang.Float#floatToRawIntBits(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "floatToRawIntBits", - args = {float.class} - ) - public void test_floatToRawIntBitsF() { - int i = 0x7fc004d2; - float f = Float.intBitsToFloat(i); - assertTrue("Wrong raw bits", Float.floatToRawIntBits(f) == i); - - assertEquals(0x7f800000, Float.floatToRawIntBits(Float.POSITIVE_INFINITY)); - assertEquals(0xff800000, Float.floatToRawIntBits(Float.NEGATIVE_INFINITY)); - assertEquals(0x7fc00000, Float.floatToRawIntBits(Float.NaN)); - } - - /** - * @tests java.lang.Float#floatValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "floatValue", - args = {} - ) - public void test_floatValue() { - // Test for method float java.lang.Float.floatValue() - Float f = new Float(87.657f); - Float f2 = new Float(-0.876f); - assertTrue("Returned incorrect floatValue", f.floatValue() == 87.657f - && (f2.floatValue() == -0.876f)); - - } - - /** - * @tests java.lang.Float#hashCode() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) - public void test_hashCode() { - // Test for method int java.lang.Float.hashCode() - Float f = new Float(1908.8786f); - assertTrue("Returned invalid hash code for 1908.8786f", f.hashCode() == Float - .floatToIntBits(1908.8786f)); - - f = new Float(-1.112f); - assertTrue("Returned invalid hash code for -1.112", f.hashCode() == Float - .floatToIntBits(-1.112f)); - - f = new Float(0f); - assertTrue("Returned invalid hash code for 0", f.hashCode() == Float.floatToIntBits(0f)); - - assertTrue(new Float(Float.MAX_VALUE).hashCode() != new Float(Float.MIN_VALUE).hashCode()); - } - - /** - * @tests java.lang.Float#intBitsToFloat(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "intBitsToFloat", - args = {int.class} - ) - public void test_intBitsToFloatI() { - float f = 9876.2345f; - int bits = Float.floatToIntBits(f); - float r = Float.intBitsToFloat(bits); - assertEquals("Incorrect intBits returned", f, r, 0F); - - assertEquals(Float.POSITIVE_INFINITY, Float.intBitsToFloat(0x7f800000)); - assertEquals(Float.NEGATIVE_INFINITY, Float.intBitsToFloat(0xff800000)); - - assertEquals(Float.NaN, Float.intBitsToFloat(0x7f800001)); - assertEquals(Float.NaN, Float.intBitsToFloat(0x7fffffff)); - assertEquals(Float.NaN, Float.intBitsToFloat(0xff800001)); - assertEquals(Float.NaN, Float.intBitsToFloat(0xffffffff)); - } - - /** - * @tests java.lang.Float#intValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "intValue", - args = {} - ) - public void test_intValue() { - // Test for method int java.lang.Float.intValue() - Float f = new Float(0.46874f); - Float f2 = new Float(90.8f); - assertTrue("Returned incorrect int value", f.intValue() == 0 && f2.intValue() == 90); - assertEquals(Integer.MAX_VALUE, new Float(Float.MAX_VALUE).intValue()); - assertEquals(0, new Float(Float.MIN_VALUE).intValue()); - } - - /** - * @tests java.lang.Float#isInfinite() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isInfinite", - args = {} - ) - public void test_isInfinite() { - // Test for method boolean java.lang.Float.isInfinite() - assertTrue("Infinity check failed", - (new Float(Float.POSITIVE_INFINITY).isInfinite() && new Float( - Float.NEGATIVE_INFINITY).isInfinite()) - && !(new Float(0.13131414f).isInfinite())); - } - - /** - * @tests java.lang.Float#isInfinite(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isInfinite", - args = {float.class} - ) - public void test_isInfiniteF() { - // Test for method boolean java.lang.Float.isInfinite(float) - - assertTrue("Infinity check failed", Float.isInfinite(Float.POSITIVE_INFINITY) - && (Float.isInfinite(Float.NEGATIVE_INFINITY)) && !(Float.isInfinite(1.0f))); - } - - /** - * @tests java.lang.Float#isNaN() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isNaN", - args = {} - ) - public void test_isNaN() { - // Test for method boolean java.lang.Float.isNaN() - assertTrue("NAN check failed", new Float(Float.NaN).isNaN() - && !(new Float(1.0f).isNaN())); - } - - /** - * @tests java.lang.Float#isNaN(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "isNaN", - args = {float.class} - ) - public void test_isNaNF() { - // Test for method boolean java.lang.Float.isNaN(float) - assertTrue("NaN check failed", Float.isNaN(Float.NaN) && !(Float.isNaN(12.09f)) - && !Float.isNaN(Float.MAX_VALUE) && !Float.isNaN(Float.MIN_VALUE)); - } - - /** - * @tests java.lang.Float#longValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "longValue", - args = {} - ) - public void test_longValue() { - // Test for method long java.lang.Float.longValue() - Float f = new Float(0.46874f); - Float f2 = new Float(90.8f); - assertTrue("Returned incorrect long value", f.longValue() == 0 && f2.longValue() == 90); - assertEquals(Long.MAX_VALUE, new Float(Float.MAX_VALUE).longValue()); - assertEquals(0, new Float(Float.MIN_VALUE).longValue()); - } - - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies NumberFormatException.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloatLExceptions() { - String [] incorrectStrings = {"", ";", "99999999EE999999", "99999l", - "0x1.f.ffffep127"}; - for(int i = 0; i < incorrectStrings.length; i++) { - try { - Float.parseFloat(incorrectStrings[i]); - fail("NumberFormatException is not thrown for string: " - + incorrectStrings[i]); - } catch(NumberFormatException nfe) { - //expected - } - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies boundary cases.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloatLjava_lang_String() { - assertEquals("Incorrect float returned, expected zero.", 0.0, Float - .parseFloat("7.0064923216240853546186479164495e-46"), 0.0); - assertEquals("Incorrect float returned, expected minimum float.", Float.MIN_VALUE, - Float.parseFloat("7.0064923216240853546186479164496e-46"), 0.0); - - doTestCompareRawBits( - "0.000000000000000000000000000000000000011754942807573642917278829910357665133228589927589904276829631184250030649651730385585324256680905818939208984375", - 0x800000, "1.17549435E-38"); - doTestCompareRawBits( - "0.00000000000000000000000000000000000001175494280757364291727882991035766513322858992758990427682963118425003064965173038558532425668090581893920898437499999f", - 0x7fffff, "1.1754942E-38"); - - /* Test a set of regular floats with exponents from -38 to +38 */ - for (int i = 38; i > 3; i--) { - String testString; - testString = "3.4028234663852886e-" + i; - doTestCompareRawBits(testString, rawBitsFor3_4eN38To38[38 - i], - expectedStringFor3_4eN38To38[38 - i]); - } - doTestCompareRawBits("3.4028234663852886e-3", rawBitsFor3_4eN38To38[38 - 3], - expectedStringFor3_4eN38To38[38 - 3]); - doTestCompareRawBits("3.4028234663852886e-2", rawBitsFor3_4eN38To38[38 - 2], - expectedStringFor3_4eN38To38[38 - 2]); - doTestCompareRawBits("3.4028234663852886e-1", rawBitsFor3_4eN38To38[38 - 1], - expectedStringFor3_4eN38To38[38 - 1]); - doTestCompareRawBits("3.4028234663852886e-0", rawBitsFor3_4eN38To38[38 - 0], - expectedStringFor3_4eN38To38[38 - 0]); - doTestCompareRawBits("3.4028234663852886e+1", rawBitsFor3_4eN38To38[38 + 1], - expectedStringFor3_4eN38To38[38 + 1]); - doTestCompareRawBits("3.4028234663852886e+2", rawBitsFor3_4eN38To38[38 + 2], - expectedStringFor3_4eN38To38[38 + 2]); - doTestCompareRawBits("3.4028234663852886e+3", rawBitsFor3_4eN38To38[38 + 3], - expectedStringFor3_4eN38To38[38 + 3]); - doTestCompareRawBits("3.4028234663852886e+4", rawBitsFor3_4eN38To38[38 + 4], - expectedStringFor3_4eN38To38[38 + 4]); - doTestCompareRawBits("3.4028234663852886e+5", rawBitsFor3_4eN38To38[38 + 5], - expectedStringFor3_4eN38To38[38 + 5]); - doTestCompareRawBits("3.4028234663852886e+6", rawBitsFor3_4eN38To38[38 + 6], - expectedStringFor3_4eN38To38[38 + 6]); - - for (int i = 7; i < 39; i++) { - String testString; - testString = "3.4028234663852886e+" + i; - doTestCompareRawBits(testString, rawBitsFor3_4eN38To38[38 + i], - expectedStringFor3_4eN38To38[38 + i]); - } - - /* Test another set of regular floats with exponents from -38 to +38 */ - for (int i = 38; i > 3; i--) { - String testString; - testString = "-1.1754943508222875e-" + i; - doTestCompareRawBits(testString, rawBitsFor1_17eN38To38[38 - i], - expectedStringFor1_17eN38To38[38 - i]); - } - doTestCompareRawBits("-1.1754943508222875e-3", rawBitsFor1_17eN38To38[38 - 3], - expectedStringFor1_17eN38To38[38 - 3]); - doTestCompareRawBits("-1.1754943508222875e-2", rawBitsFor1_17eN38To38[38 - 2], - expectedStringFor1_17eN38To38[38 - 2]); - doTestCompareRawBits("-1.1754943508222875e-1", rawBitsFor1_17eN38To38[38 - 1], - expectedStringFor1_17eN38To38[38 - 1]); - doTestCompareRawBits("-1.1754943508222875e-0", rawBitsFor1_17eN38To38[38 - 0], - expectedStringFor1_17eN38To38[38 - 0]); - doTestCompareRawBits("-1.1754943508222875e+1", rawBitsFor1_17eN38To38[38 + 1], - expectedStringFor1_17eN38To38[38 + 1]); - doTestCompareRawBits("-1.1754943508222875e+2", rawBitsFor1_17eN38To38[38 + 2], - expectedStringFor1_17eN38To38[38 + 2]); - doTestCompareRawBits("-1.1754943508222875e+3", rawBitsFor1_17eN38To38[38 + 3], - expectedStringFor1_17eN38To38[38 + 3]); - doTestCompareRawBits("-1.1754943508222875e+4", rawBitsFor1_17eN38To38[38 + 4], - expectedStringFor1_17eN38To38[38 + 4]); - doTestCompareRawBits("-1.1754943508222875e+5", rawBitsFor1_17eN38To38[38 + 5], - expectedStringFor1_17eN38To38[38 + 5]); - doTestCompareRawBits("-1.1754943508222875e+6", rawBitsFor1_17eN38To38[38 + 6], - expectedStringFor1_17eN38To38[38 + 6]); - - for (int i = 7; i < 39; i++) { - String testString; - testString = "-1.1754943508222875e+" + i; - doTestCompareRawBits(testString, rawBitsFor1_17eN38To38[38 + i], - expectedStringFor1_17eN38To38[38 + i]); - } - - /* Test denormalized floats (floats with exponents <= -38 */ - doTestCompareRawBits("1.1012984643248170E-45", 1, "1.4E-45"); - doTestCompareRawBits("-1.1012984643248170E-45", 0x80000001, "-1.4E-45"); - doTestCompareRawBits("1.0E-45", 1, "1.4E-45"); - doTestCompareRawBits("-1.0E-45", 0x80000001, "-1.4E-45"); - doTestCompareRawBits("0.9E-45", 1, "1.4E-45"); - doTestCompareRawBits("-0.9E-45", 0x80000001, "-1.4E-45"); - doTestCompareRawBits("4.203895392974451e-45", 3, "4.2E-45"); - doTestCompareRawBits("-4.203895392974451e-45", 0x80000003, "-4.2E-45"); - doTestCompareRawBits("0.004E-45", 0, "0.0"); - doTestCompareRawBits("-0.004E-45", 0x80000000, "-0.0"); - - /* - * Test for large floats close to and greater than 3.4028235E38 and - * -3.4028235E38 - */ - doTestCompareRawBits("1.2E+38", 0x7eb48e52, "1.2E38"); - doTestCompareRawBits("-1.2E+38", 0xfeb48e52, "-1.2E38"); - doTestCompareRawBits("3.2E+38", 0x7f70bdc2, "3.2E38"); - doTestCompareRawBits("-3.2E+38", 0xff70bdc2, "-3.2E38"); - doTestCompareRawBits("3.4E+38", 0x7f7fc99e, "3.4E38"); - doTestCompareRawBits("-3.4E+38", 0xff7fc99e, "-3.4E38"); - doTestCompareRawBits("3.4028234663852886E+38", 0x7f7fffff, "3.4028235E38"); - doTestCompareRawBits("-3.4028234663852886E+38", 0xff7fffff, "-3.4028235E38"); - doTestCompareRawBits("3.405E+38", 0x7f800000, "Infinity"); - doTestCompareRawBits("-3.405E+38", 0xff800000, "-Infinity"); - doTestCompareRawBits("3.41E+38", 0x7f800000, "Infinity"); - doTestCompareRawBits("-3.41E+38", 0xff800000, "-Infinity"); - doTestCompareRawBits("3.42E+38", 0x7f800000, "Infinity"); - doTestCompareRawBits("-3.42E+38", 0xff800000, "-Infinity"); - doTestCompareRawBits("1.0E+39", 0x7f800000, "Infinity"); - doTestCompareRawBits("-1.0E+39", 0xff800000, "-Infinity"); - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies boundary values.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_Unusual() { - float actual; - - actual = Float.parseFloat("0x00000000000000000000000000000000000000000.0000000000000000000000000000000000000p0000000000000000000000000000000000"); - assertEquals("Returned incorrect value", 0.0f, actual, 0.0F); - - actual = Float.parseFloat("+0Xfffff.fffffffffffffffffffffffffffffffp+99F"); - assertEquals("Returned incorrect value", 6.64614E35f, actual, 0.0F); - - actual = Float.parseFloat("-0X.123456789abcdefp+99f"); - assertEquals("Returned incorrect value", -4.5072022E28f, actual, 0.0F); - - actual = Float.parseFloat("-0X123456789abcdef.p+1f"); - assertEquals("Returned incorrect value", -1.63971062E17f, actual, 0.0F); - - actual = Float.parseFloat("-0X000000000000000000000000000001abcdef.0000000000000000000000000001abefp00000000000000000000000000000000000000000004f"); - assertEquals("Returned incorrect value", -4.48585472E8f, actual, 0.0F); - - actual = Float.parseFloat("0X0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234p600f"); - assertEquals("Returned incorrect value", 5.907252E33f, actual, 0.0F); - - actual = Float.parseFloat("0x1.p9223372036854775807"); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F); - - actual = Float.parseFloat("0x1.p9223372036854775808"); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F); - - actual = Float.parseFloat("0x10.p9223372036854775808"); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F); - - actual = Float.parseFloat("0xabcd.ffffffffp+2000"); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F); - - actual = Float.parseFloat("0x1.p-9223372036854775808"); - assertEquals("Returned incorrect value", 0.0f, actual, 0.0F); - - actual = Float.parseFloat("0x1.p-9223372036854775809"); - assertEquals("Returned incorrect value", 0.0f, actual, 0.0F); - - actual = Float.parseFloat("0x.1p-9223372036854775809"); - assertEquals("Returned incorrect value", 0.0f, actual, 0.0F); - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies positive exponent.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_NormalPositiveExponent() { - int[] expecteds = { - 0x3991a2b4, 0x43cc0247, 0x47909009, - 0x4ac0c009, 0x4e109005, 0x5140c005, - 0x5458d805, 0x57848402, 0x5a909002, - 0x5da8a802, 0x60c0c002, 0x63cccc02, - 0x66e4e402, 0x69f0f002, 0x6d048401, - 0x70109001, 0x73169601, 0x76810810, - 0x79840840, 0x7c8a08a0, 0x7f800000, - 0x7f800000, 0x7f800000, 0x7f800000, - 0x7f800000, - }; - - for (int i = 0; i < expecteds.length; i++) { - int part = i * 6; - String inputString = "0x" + part + "." + part + "0123456789abcdefp" + part; - - float actual = Float.parseFloat(inputString); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputString - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies negative exponent.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_NormalNegativeExponent() { - int[] expecteds = { - 0x3991a2b4, - 0x3d6e0247, - 0x3aa0a009, - 0x37848405, - 0x3420a005, - 0x30d4d405, - 0x2d848402, - 0x2a129202, - 0x26acac02, - 0x2346c602, - 0x1fe0e002, - 0x1c6eee02, - 0x19048401, - 0x15919101, - 0x12189801, - 0xf028828, - 0xb890890, - 0x80c88c8, - 0x4930930, - 0x1198998, - 0x28028, - 0x51c, - 0xb, - 0x0, - 0x0, - }; - - for (int i = 0; i < expecteds.length; i++) { - int part = i * 7; - String inputString = "0x" + part + "." + part + "0123456789abcdefp-" + part; - - float actual = Float.parseFloat(inputString); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputString - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies max boundary value. Doesn't verify NumberFormatException.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_MaxNormalBoundary() { - int[] expecteds ={ - 0x7f7fffff, - 0x7f7fffff, - 0x7f7fffff, - 0x7f800000, - 0x7f800000, - 0x7f800000, - - 0xff7fffff, - 0xff7fffff, - 0xff7fffff, - 0xff800000, - 0xff800000, - 0xff800000, - }; - - String[] inputs = { - "0x1.fffffep127", - "0x1.fffffe000000000000000000000000000000000000000000000001p127", - "0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127", - "0x1.ffffffp127", - "0x1.ffffff000000000000000000000000000000000000000000000001p127", - "0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127", - - "-0x1.fffffep127", - "-0x1.fffffe000000000000000000000000000000000000000000000001p127", - "-0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127", - "-0x1.ffffffp127", - "-0x1.ffffff000000000000000000000000000000000000000000000001p127", - "-0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127", - }; - - for (int i = 0; i < inputs.length; i++) { - float actual = Float.parseFloat(inputs[i]); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies min boundary value.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_MinNormalBoundary() { - int expecteds[] = { - 0x800000, - 0x800000, - 0x800000, - 0x800000, - 0x800001, - 0x800001, - - 0x80800000, - 0x80800000, - 0x80800000, - 0x80800000, - 0x80800001, - 0x80800001, - }; - - String inputs[] = { - "0x1.0p-126", - "0x1.00000000000000000000000000000000000000000000001p-126", - "0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "0x1.000001p-126", - "0x1.000001000000000000000000000000000000000000000001p-126", - "0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - - "-0x1.0p-126", - "-0x1.00000000000000000000000000000000000000000000001p-126", - "-0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "-0x1.000001p-126", - "-0x1.000001000000000000000000000000000000000000000001p-126", - "-0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - }; - - for (int i = 0; i < inputs.length; i++) { - float actual = Float.parseFloat(inputs[i]); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies max boundary value.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_MaxSubNormalBoundary() { - int expecteds[] = { - 0x7fffff, - 0x7fffff, - 0x7fffff, - 0x800000, - 0x800000, - 0x800000, - - 0x807fffff, - 0x807fffff, - 0x807fffff, - 0x80800000, - 0x80800000, - 0x80800000, - }; - - String inputs[] = { - "0x0.fffffep-126", - "0x0.fffffe000000000000000000000000000000000000000000000000000001p-126", - "0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "0x0.ffffffp-126", - "0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126", - "0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - - "-0x0.fffffep-126", - "-0x0.fffffe000000000000000000000000000000000000000000000000000001p-126", - "-0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "-0x0.ffffffp-126", - "-0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126", - "-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - }; - - for (int i = 0; i < inputs.length; i++) { - float actual = Float.parseFloat(inputs[i]); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies min boundary value.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_MinSubNormalBoundary() { - int expecteds[] = { - 0x1, - 0x1, - 0x1, - 0x2, - 0x2, - 0x2, - - 0x80000001, - 0x80000001, - 0x80000001, - 0x80000002, - 0x80000002, - 0x80000002, - }; - - String inputs[] = { - "0x0.000002p-126", - "0x0.00000200000000000000000000000000000000000001p-126", - "0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "0x0.000003p-126", - "0x0.000003000000000000000000000000000000000000001p-126", - "0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - - "-0x0.000002p-126", - "-0x0.00000200000000000000000000000000000000000001p-126", - "-0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "-0x0.000003p-126", - "-0x0.000003000000000000000000000000000000000000001p-126", - "-0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - }; - - for (int i = 0; i < inputs.length; i++) { - float actual = Float.parseFloat(inputs[i]); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies zero boundary value.", - method = "parseFloat", - args = {java.lang.String.class} - ) - public void test_parseFloat_LString_ZeroBoundary() { - int expecteds[] = { - 0x0, - 0x0, - 0x0, - 0x0, - 0x1, - 0x1, - - 0x80000000, - 0x80000000, - 0x80000000, - 0x80000000, - 0x80000001, - 0x80000001, - }; - - String inputs[] = { - "0x0.000000000000000p-126", - "0x0.000000000000000000000000000000000000000000000001p-126", - "0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "0x0.000001p-126", - "0x0.000001000000000000000000000000000000000000000001p-126", - "0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - - "-0x0.000000000000000p-126", - "-0x0.000000000000000000000000000000000000000000000001p-126", - "-0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - "-0x0.000001p-126", - "-0x0.000001000000000000000000000000000000000000000001p-126", - "-0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126", - }; - - for (int i = 0; i < inputs.length; i++) { - float actual = Float.parseFloat(inputs[i]); - float expected = Float.intBitsToFloat(expecteds[i]); - - String expectedString = Integer.toHexString(Float.floatToIntBits(expected)); - String actualString = Integer.toHexString(Float.floatToIntBits(actual)); - String errorMsg = i + "th input string is:<" + inputs[i] - + ">.The expected result should be:<" + expectedString - + ">, but was: <" + actualString + ">. "; - - assertEquals(errorMsg, expected, actual, 0.0F); - } - } - - /** - * @tests java.lang.Float#parseFloat(java.lang.String) - */ - public void test_parseFloat_LString_Harmony6261() { - // Regression test for HARMONY-6261 - float f = new Float("2147483648"); - assertEquals("2.1474836E9", Float.toString(f)); - - doTestCompareRawBits("123456790528.000000000000000f", 0x51e5f4c9, "1.2345679E11"); - doTestCompareRawBits("8589934592", 0x50000000, "8.5899346E9"); - doTestCompareRawBits("8606711808", 0x50004000, "8.606712E9"); - } - - /** - * @tests java.lang.Float#shortValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "shortValue", - args = {} - ) - public void test_shortValue() { - // Test for method short java.lang.Float.shortValue() - Float f = new Float(0.46874f); - Float f2 = new Float(90.8f); - assertTrue("Returned incorrect short value", f.shortValue() == 0 - && f2.shortValue() == 90); - } - - /** - * @tests java.lang.Float#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - // Test for method java.lang.String java.lang.Float.toString() - - test_toString(12.90898f, "12.90898"); - - test_toString(1.7014118346046924e+38F, "1.7014118E38"); - } - - /** - * @tests java.lang.Float#toString(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {float.class} - ) - public void test_toStringF() { - // Test for method java.lang.String java.lang.Float.toString(float) - - float ff; - String answer; - - ff = 12.90898f; - answer = "12.90898"; - assertTrue("Incorrect String representation want " + answer + ", got " - + Float.toString(ff), Float.toString(ff).equals(answer)); - - ff = Float.MAX_VALUE; - answer = "3.4028235E38"; - assertTrue("Incorrect String representation want " + answer + ", got " - + Float.toString(ff), Float.toString(ff).equals(answer)); - } - - /** - * @tests java.lang.Float#valueOf(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "valueOf", - args = {java.lang.String.class} - ) - public void test_valueOfLjava_lang_String() { - // Test for method java.lang.Float - // java.lang.Float.valueOf(java.lang.String) - - Float wanted = new Float(432.1235f); - Float got = Float.valueOf("432.1235"); - assertTrue("Incorrect float returned--wanted: " + wanted + " but got: " + got, got - .equals(wanted)); - - wanted = new Float(0f); - got = Float.valueOf("0"); - assertTrue("Incorrect float returned--wanted: " + wanted + " but got: " + got, got - .equals(wanted)); - - wanted = new Float(-1212.3232f); - got = Float.valueOf("-1212.3232"); - assertTrue("Incorrect float returned--wanted: " + wanted + " but got: " + got, got - .equals(wanted)); - - try { - Float.valueOf(null); - fail("Expected Float.valueOf(null) to throw NPE."); - } catch (NullPointerException ex) { - // expected - } - - try { - Float.valueOf(""); - fail("Expected Float.valueOf(\"\") to throw NFE"); - } catch (NumberFormatException e) { - // expected - } - - Float posZero = Float.valueOf("+0.0"); - Float negZero = Float.valueOf("-0.0"); - assertFalse("Floattest0", posZero.equals(negZero)); - assertTrue("Floattest1", 0.0f == -0.0f); - - // Tests for float values by name. - Float expectedNaN = new Float(Float.NaN); - - Float posNaN = Float.valueOf("NaN"); - assertTrue("Floattest2", posNaN.equals(expectedNaN)); - - Float posNaNSigned = Float.valueOf("+NaN"); - assertTrue("Floattest3", posNaNSigned.equals(expectedNaN)); - - Float negNaNSigned = Float.valueOf("-NaN"); - assertTrue("Floattest4", negNaNSigned.equals(expectedNaN)); - - Float posInfinite = Float.valueOf("Infinity"); - assertTrue("Floattest5", posInfinite.equals(new Float(Float.POSITIVE_INFINITY))); - - Float posInfiniteSigned = Float.valueOf("+Infinity"); - assertTrue("Floattest6", posInfiniteSigned.equals(new Float(Float.POSITIVE_INFINITY))); - - Float negInfiniteSigned = Float.valueOf("-Infinity"); - assertTrue("Floattest7", negInfiniteSigned.equals(new Float(Float.NEGATIVE_INFINITY))); - } - - private void test_toString(float ff, String answer) { - // Test for method java.lang.String java.lang.Double.toString(double) - assertTrue("Incorrect String representation want " + answer + ", got (" - + Float.toString(ff) + ")", Float.toString(ff).equals(answer)); - Float f = new Float(ff); - assertTrue("Incorrect String representation want " + answer + ", got (" - + Float.toString(f.floatValue()) + ")", Float.toString(f.floatValue()).equals( - answer)); - assertTrue("Incorrect String representation want " + answer + ", got (" + f.toString() - + ")", f.toString().equals(answer)); - } - - /** - * @tests java.lang.Float#compareTo(java.lang.Float) - * @tests java.lang.Float#compare(float, float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "compareTo", - args = {java.lang.Float.class} - ) - public void test_compareToLjava_lang_Float() { - // A selection of float values in ascending order. - float[] values = new float[] { Float.NEGATIVE_INFINITY, -Float.MAX_VALUE, -2f, - -Float.MIN_VALUE, -0f, 0f, Float.MIN_VALUE, 2f, Float.MAX_VALUE, - Float.POSITIVE_INFINITY, Float.NaN }; - - for (int i = 0; i < values.length; i++) { - float f1 = values[i]; - - // Test that each value compares equal to itself; and each object is - // equal to another object - // like itself - assertTrue("Assert 0: compare() should be equal: " + f1, Float.compare(f1, f1) == 0); - Float objFloat = new Float(f1); - assertTrue("Assert 1: compareTo() should be equal: " + objFloat, objFloat - .compareTo(objFloat) == 0); - - // Test that the Float-defined order is respected - for (int j = i + 1; j < values.length; j++) { - float f2 = values[j]; - assertTrue("Assert 2: compare() " + f1 + " should be less " + f2, Float - .compare(f1, f2) == -1); - assertTrue("Assert 3: compare() " + f2 + " should be greater " + f1, Float - .compare(f2, f1) == 1); - - Float F2 = new Float(f2); - assertTrue("Assert 4: compareTo() " + f1 + " should be less " + f2, objFloat - .compareTo(F2) == -1); - assertTrue("Assert 5: compareTo() " + f2 + " should be greater " + f1, F2 - .compareTo(objFloat) == 1); - } - } - } - - /** - * @tests java.lang.Float#equals(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) - public void test_equalsLjava_lang_Object() { - Float f1 = new Float(8765.4321f); - Float f2 = new Float(8765.4321f); - Float f3 = new Float(-1.0f); - assertTrue("Assert 0: Equality test failed", f1.equals(f2) && !(f1.equals(f3))); - - assertTrue("Assert 1: NaN should not be == Nan", Float.NaN != Float.NaN); - assertTrue("Assert 2: NaN should not be == Nan", new Float(Float.NaN).equals(new Float( - Float.NaN))); - assertTrue("Assert 3: -0f should be == 0f", 0f == -0f); - assertTrue("Assert 4: -0f should not be equals() 0f", !new Float(0f).equals(new Float( - -0f))); - - f1 = new Float(1098.576f); - f2 = new Float(1098.576f); - f3 = new Float(1.0f); - assertTrue("Equality test failed", f1.equals(f2) && !(f1.equals(f3))); - - assertTrue("NaN should not be == Nan", Float.NaN != Float.NaN); - assertTrue("NaN should not be == Nan", new Float(Float.NaN) - .equals(new Float(Float.NaN))); - assertTrue("-0f should be == 0f", 0f == -0f); - assertTrue("-0f should not be equals() 0f", !new Float(0f).equals(new Float(-0f))); - } - - /** - * @tests java.lang.Float#toHexString(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toHexString", - args = {float.class} - ) - public void test_toHexStringF() { - // the follow values comes from the Float Javadoc/Spec - assertEquals("0x0.0p0", Float.toHexString(0.0F)); - assertEquals("-0x0.0p0", Float.toHexString(-0.0F)); - assertEquals("0x1.0p0", Float.toHexString(1.0F)); - assertEquals("-0x1.0p0", Float.toHexString(-1.0F)); - assertEquals("0x1.0p1", Float.toHexString(2.0F)); - assertEquals("0x1.8p1", Float.toHexString(3.0F)); - assertEquals("0x1.0p-1", Float.toHexString(0.5F)); - assertEquals("0x1.0p-2", Float.toHexString(0.25F)); - assertEquals("0x1.fffffep127", Float.toHexString(Float.MAX_VALUE)); - assertEquals("0x0.000002p-126", Float.toHexString(Float.MIN_VALUE)); - - // test edge cases - assertEquals("NaN", Float.toHexString(Float.NaN)); - assertEquals("-Infinity", Float.toHexString(Float.NEGATIVE_INFINITY)); - assertEquals("Infinity", Float.toHexString(Float.POSITIVE_INFINITY)); - - // test various numbers - assertEquals("-0x1.da8p6", Float.toHexString(-118.625F)); - assertEquals("0x1.295788p23", Float.toHexString(9743299.65F)); - assertEquals("0x1.295788p23", Float.toHexString(9743299.65000F)); - assertEquals("0x1.295788p23", Float.toHexString(9743299.650001234F)); - assertEquals("0x1.700d1p33", Float.toHexString(12349743299.65000F)); - - // test HARMONY-2132 - assertEquals("0x1.01p10", Float.toHexString(0x1.01p10f)); - } - - /** - * @tests java.lang.Float#valueOf(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "valueOf", - args = {float.class} - ) - public void test_valueOfF() { - assertEquals(new Float(Float.MIN_VALUE), Float.valueOf(Float.MIN_VALUE)); - assertEquals(new Float(Float.MAX_VALUE), Float.valueOf(Float.MAX_VALUE)); - assertEquals(new Float(0), Float.valueOf(0)); - - int s = -128; - while (s < 128) { - assertEquals(new Float(s), Float.valueOf(s)); - assertEquals(new Float(s + 0.1F), Float.valueOf(s + 0.1F)); - assertEquals(Float.valueOf(s + 0.1F), Float.valueOf(s + 0.1F)); - s++; - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalAccessExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalAccessExceptionTest.java deleted file mode 100644 index 2a984cb..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalAccessExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class IllegalAccessExceptionTest extends TestCase { - - /** - * @tests java.lang.IllegalAccessException#IllegalAccessException() - */ - public void test_Constructor() { - IllegalAccessException e = new IllegalAccessException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IllegalAccessException#IllegalAccessException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IllegalAccessException e = new IllegalAccessException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalArgumentExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalArgumentExceptionTest.java deleted file mode 100644 index c9faa09..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalArgumentExceptionTest.java +++ /dev/null @@ -1,87 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; - -public class IllegalArgumentExceptionTest extends TestCase { - - /** - * @tests java.lang.IllegalArgumentException#IllegalArgumentException() - */ - public void test_Constructor() { - IllegalArgumentException e = new IllegalArgumentException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IllegalArgumentException#IllegalArgumentException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IllegalArgumentException e = new IllegalArgumentException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests {@link java.lang.IllegalArgumentException#IllegalArgumentException(Throwable)} - */ - public void test_ConstructorLjava_lang_Throwable() { - Throwable emptyThrowable = new Exception(); - IllegalArgumentException emptyException = new IllegalArgumentException(emptyThrowable); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getLocalizedMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getCause().toString()); - - Throwable exception = new Exception("msg"); - IllegalArgumentException e = new IllegalArgumentException(exception); - assertEquals(exception.getClass().getName() + ": " + "msg", e.getMessage()); - assertEquals(exception.getClass().getName(), emptyException.getLocalizedMessage()); - assertEquals(exception.getClass().getName(), emptyException.getCause().toString()); - } - - /** - * @tests java.lang.IllegalArgumentException#IllegalArgumentException(String,Throwable) - */ - @SuppressWarnings("nls") - public void test_ConstructorLjava_lang_StringLjava_lang_Throwable() { - NullPointerException npe = new NullPointerException(); - IllegalArgumentException e = new IllegalArgumentException("fixture", - npe); - assertSame("fixture", e.getMessage()); - assertSame(npe, e.getCause()); - } - - /** - * @tests serialization/deserialization. - */ - public void testSerializationSelf() throws Exception { - SerializationTest.verifySelf(new IllegalArgumentException()); - } - - /** - * @tests serialization/deserialization compatibility with RI. - */ - public void testSerializationCompatibility() throws Exception { - SerializationTest.verifyGolden(this, new IllegalArgumentException()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalMonitorStateExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalMonitorStateExceptionTest.java deleted file mode 100644 index 37ce9c3..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalMonitorStateExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class IllegalMonitorStateExceptionTest extends TestCase { - - /** - * @tests java.lang.IllegalMonitorStateException#IllegalMonitorStateException() - */ - public void test_Constructor() { - IllegalMonitorStateException e = new IllegalMonitorStateException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IllegalMonitorStateException#IllegalMonitorStateException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IllegalMonitorStateException e = new IllegalMonitorStateException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalStateExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalStateExceptionTest.java deleted file mode 100644 index a926535..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalStateExceptionTest.java +++ /dev/null @@ -1,95 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; - -public class IllegalStateExceptionTest extends TestCase { - - /** - * @tests java.lang.IllegalStateException#IllegalStateException() - */ - public void test_Constructor() { - IllegalStateException e = new IllegalStateException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IllegalStateException#IllegalStateException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IllegalStateException e = new IllegalStateException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests {@link java.land.IllegalStateException#IllIllegalStateException(java.lang.Throwable)} - */ - public void test_ConstructorLjava_lang_Throwable() { - Throwable emptyThrowable = new Exception(); - IllegalStateException emptyException = new IllegalStateException(emptyThrowable); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getLocalizedMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getCause().toString()); - - Throwable throwable = new Exception("msg"); - IllegalStateException exception = new IllegalStateException(throwable); - assertEquals(throwable.getClass().getName() + ": " + "msg", exception.getMessage()); - assertEquals(throwable.getClass().getName(), emptyException.getLocalizedMessage()); - assertEquals(throwable.getClass().getName(), emptyException.getCause().toString()); - } - - /** - * @tests {@link java.land.IllegalStateException#IllIllegalStateException(java.lang.String, java.lang.Throwable)} - */ - public void test_ConstructorLjava_lang_StringLjava_lang_Throwable() { - Throwable emptyThrowable = new Exception(); - IllegalStateException emptyException = new IllegalStateException("msg", emptyThrowable); - assertEquals("msg", emptyException.getMessage()); - assertEquals("msg", emptyException.getLocalizedMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getCause().toString()); - - Throwable throwable = new Exception("msg_exception"); - IllegalStateException exception = new IllegalStateException("msg", throwable); - assertEquals("msg", exception.getMessage()); - assertEquals("msg", exception.getLocalizedMessage()); - assertEquals(throwable.getClass().getName() + ": " + throwable.getMessage(), exception - .getCause().toString()); - } - - /** - * @tests serialization/deserialization. - */ - public void testSerializationSelf() throws Exception { - - SerializationTest.verifySelf(new IllegalStateException()); - } - - /** - * @tests serialization/deserialization compatibility with RI. - */ - public void testSerializationCompatibility() throws Exception { - - SerializationTest.verifyGolden(this, new IllegalStateException()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalThreadStateExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalThreadStateExceptionTest.java deleted file mode 100644 index 475f6bb..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IllegalThreadStateExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class IllegalThreadStateExceptionTest extends TestCase { - - /** - * @tests java.lang.IllegalThreadStateException#IllegalThreadStateException() - */ - public void test_Constructor() { - IllegalThreadStateException e = new IllegalThreadStateException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IllegalThreadStateException#IllegalThreadStateException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IllegalThreadStateException e = new IllegalThreadStateException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IncompatibleClassChangeErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IncompatibleClassChangeErrorTest.java deleted file mode 100644 index b6a8d6a..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IncompatibleClassChangeErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class IncompatibleClassChangeErrorTest extends TestCase { - - /** - * @tests java.lang.IncompatibleClassChangeError#IncompatibleClassChangeError() - */ - public void test_Constructor() { - IncompatibleClassChangeError e = new IncompatibleClassChangeError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IncompatibleClassChangeError#IncompatibleClassChangeError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IncompatibleClassChangeError e = new IncompatibleClassChangeError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IndexOutOfBoundsExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IndexOutOfBoundsExceptionTest.java deleted file mode 100644 index 617c71c..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IndexOutOfBoundsExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class IndexOutOfBoundsExceptionTest extends TestCase { - - /** - * @tests java.lang.IndexOutOfBoundsException#IndexOutOfBoundsException() - */ - public void test_Constructor() { - IndexOutOfBoundsException e = new IndexOutOfBoundsException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.IndexOutOfBoundsException#IndexOutOfBoundsException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - IndexOutOfBoundsException e = new IndexOutOfBoundsException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InstantiationErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InstantiationErrorTest.java deleted file mode 100644 index 1d9722c..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InstantiationErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class InstantiationErrorTest extends TestCase { - - /** - * @tests java.lang.InstantiationError#InstantiationError() - */ - public void test_Constructor() { - InstantiationError e = new InstantiationError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.InstantiationError#InstantiationError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - InstantiationError e = new InstantiationError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InstantiationExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InstantiationExceptionTest.java deleted file mode 100644 index 5f636d5..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InstantiationExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class InstantiationExceptionTest extends TestCase { - - /** - * @tests java.lang.InstantiationException#InstantiationException() - */ - public void test_Constructor() { - InstantiationException e = new InstantiationException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.InstantiationException#InstantiationException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - InstantiationException e = new InstantiationException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IntegerTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IntegerTest.java deleted file mode 100644 index 12fb758..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/IntegerTest.java +++ /dev/null @@ -1,1531 +0,0 @@ -/* 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(Integer.class) -public class IntegerTest extends TestCase { - private Properties orgProps; - - @Override - protected void setUp() { - orgProps = System.getProperties(); - } - - @Override - protected void tearDown() { - System.setProperties(orgProps); - } - - /** - * @tests java.lang.Integer#byteValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "byteValue", - args = {} - ) - public void test_byteValue() { - // Test for method byte java.lang.Integer.byteValue() - assertEquals("Returned incorrect byte value", -1, new Integer(65535) - .byteValue()); - assertEquals("Returned incorrect byte value", 127, new Integer(127) - .byteValue()); - } - - /** - * @tests java.lang.Integer#compareTo(java.lang.Integer) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "compareTo", - args = {java.lang.Integer.class} - ) - public void test_compareToLjava_lang_Integer() { - // Test for method int java.lang.Integer.compareTo(java.lang.Integer) - assertTrue("-2 compared to 1 gave non-negative answer", new Integer(-2) - .compareTo(new Integer(1)) < 0); - assertEquals("-2 compared to -2 gave non-zero answer", 0, new Integer(-2) - .compareTo(new Integer(-2))); - assertTrue("3 compared to 2 gave non-positive answer", new Integer(3) - .compareTo(new Integer(2)) > 0); - - try { - new Integer(0).compareTo(null); - fail("No NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.Integer#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.Integer - // java.lang.Integer.decode(java.lang.String) - assertEquals("Failed for 132233", - 132233, Integer.decode("132233").intValue()); - assertEquals("Failed for 07654321", - 07654321, Integer.decode("07654321").intValue()); - assertTrue("Failed for #1234567", - Integer.decode("#1234567").intValue() == 0x1234567); - assertTrue("Failed for 0xdAd", - Integer.decode("0xdAd").intValue() == 0xdad); - assertEquals("Failed for -23", -23, Integer.decode("-23").intValue()); - assertEquals("Returned incorrect value for 0 decimal", 0, Integer - .decode("0").intValue()); - assertEquals("Returned incorrect value for 0 hex", 0, Integer.decode("0x0") - .intValue()); - assertTrue("Returned incorrect value for most negative value decimal", - Integer.decode("-2147483648").intValue() == 0x80000000); - assertTrue("Returned incorrect value for most negative value hex", - Integer.decode("-0x80000000").intValue() == 0x80000000); - assertTrue("Returned incorrect value for most positive value decimal", - Integer.decode("2147483647").intValue() == 0x7fffffff); - assertTrue("Returned incorrect value for most positive value hex", - Integer.decode("0x7fffffff").intValue() == 0x7fffffff); - - boolean exception = false; - try { - Integer.decode("0a"); - } catch (NumberFormatException e) { - // correct - exception = true; - } - assertTrue("Failed to throw NumberFormatException for \"Oa\"", - exception); - - exception = false; - try { - Integer.decode("2147483648"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.decode("-2147483649"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); - - exception = false; - try { - Integer.decode("0x80000000"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.decode("-0x80000001"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for hex MIN_VALUE - 1", exception); - - exception = false; - try { - Integer.decode("9999999999"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for 9999999999", exception); - - try { - Integer.decode("-"); - fail("Expected exception for -"); - } catch (NumberFormatException e) { - // Expected - } - - try { - Integer.decode("0x"); - fail("Expected exception for 0x"); - } catch (NumberFormatException e) { - // Expected - } - - try { - Integer.decode("#"); - fail("Expected exception for #"); - } catch (NumberFormatException e) { - // Expected - } - - try { - Integer.decode("x123"); - fail("Expected exception for x123"); - } catch (NumberFormatException e) { - // Expected - } - - try { - Integer.decode(null); - fail("Expected exception for null"); - } catch (NullPointerException e) { - // Expected - } - - try { - Integer.decode(""); - fail("Expected exception for empty string"); - } catch (NumberFormatException ex) { - // Expected - } - - try { - Integer.decode(" "); - fail("Expected exception for single space"); - } catch (NumberFormatException ex) { - // Expected - } - - } - - /** - * @tests java.lang.Integer#doubleValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Checks integer's boundary values.", - method = "doubleValue", - args = {} - ) - public void test_doubleValue2() { - // Test for method double java.lang.Integer.doubleValue() - assertEquals("Returned incorrect double value", 2147483647.0, new Integer(2147483647) - .doubleValue(), 0.0D); - assertEquals("Returned incorrect double value", -2147483647.0, new Integer(-2147483647) - .doubleValue(), 0.0D); - } - - /** - * @tests java.lang.Integer#equals(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) - public void test_equalsLjava_lang_Object2() { - // Test for method boolean java.lang.Integer.equals(java.lang.Object) - Integer i1 = new Integer(1000); - Integer i2 = new Integer(1000); - Integer i3 = new Integer(-1000); - assertTrue("Equality test failed", i1.equals(i2) && !(i1.equals(i3))); - } - - /** - * @tests java.lang.Integer#floatValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "floatValue", - args = {} - ) - public void test_floatValue2() { - // Test for method float java.lang.Integer.floatValue() - assertTrue("Returned incorrect float value", new Integer(65535) - .floatValue() == 65535.0f); - assertTrue("Returned incorrect float value", new Integer(-65535) - .floatValue() == -65535.0f); - } - - /** - * @tests java.lang.Integer#getInteger(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getInteger", - args = {java.lang.String.class} - ) - public void test_getIntegerLjava_lang_String() { - // Test for method java.lang.Integer - // java.lang.Integer.getInteger(java.lang.String) - Properties tProps = new Properties(); - tProps.put("testInt", "99"); - System.setProperties(tProps); - assertTrue("returned incorrect Integer", Integer.getInteger("testInt") - .equals(new Integer(99))); - assertNull("returned incorrect default Integer", Integer - .getInteger("ff")); - } - - /** - * @tests java.lang.Integer#getInteger(java.lang.String, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getInteger", - args = {java.lang.String.class, int.class} - ) - public void test_getIntegerLjava_lang_StringI() { - // Test for method java.lang.Integer - // java.lang.Integer.getInteger(java.lang.String, int) - Properties tProps = new Properties(); - tProps.put("testInt", "99"); - tProps.put("testIncInt", "notInt"); - System.setProperties(tProps); - assertTrue("returned incorrect Integer", Integer.getInteger("testInt", - 4).equals(new Integer(99))); - assertTrue("returned incorrect default Integer", Integer.getInteger( - "ff", 4).equals(new Integer(4))); - assertTrue("returned incorrect default Integer", Integer.getInteger( - "testIncInt", 4).equals(new Integer(4))); - } - - /** - * @tests java.lang.Integer#getInteger(java.lang.String, java.lang.Integer) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getInteger", - args = {java.lang.String.class, java.lang.Integer.class} - ) - public void test_getIntegerLjava_lang_StringLjava_lang_Integer() { - // Test for method java.lang.Integer - // java.lang.Integer.getInteger(java.lang.String, java.lang.Integer) - Properties tProps = new Properties(); - tProps.put("testInt", "99"); - tProps.put("testIncInt", "notInt"); - System.setProperties(tProps); - assertTrue("returned incorrect Integer", Integer.getInteger("testInt", - new Integer(4)).equals(new Integer(99))); - assertTrue("returned incorrect default Integer", Integer.getInteger( - "ff", new Integer(4)).equals(new Integer(4))); - assertTrue("returned incorrect default Integer", Integer.getInteger( - "testIncInt", new Integer(4)).equals(new Integer(4))); - } - - /** - * @tests java.lang.Integer#hashCode() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) - public void test_hashCode2() { - // Test for method int java.lang.Integer.hashCode() - - Integer i1 = new Integer(1000); - Integer i2 = new Integer(-1000); - assertTrue("Returned incorrect hashcode", i1.hashCode() == 1000 - && (i2.hashCode() == -1000)); - } - - /** - * @tests java.lang.Integer#intValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL, - notes = "Checks one value.", - method = "intValue", - args = {} - ) - public void test_intValue2() { - // Test for method int java.lang.Integer.intValue() - - Integer i = new Integer(8900); - assertEquals("Returned incorrect int value", 8900, i.intValue()); - } - - /** - * @tests java.lang.Integer#longValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL, - notes = "Checks one value.", - method = "longValue", - args = {} - ) - public void test_longValue2() { - // Test for method long java.lang.Integer.longValue() - Integer i = new Integer(8900); - assertEquals("Returned incorrect long value", 8900L, i.longValue()); - } - - /** - * @tests java.lang.Integer#parseInt(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "parseInt", - args = {java.lang.String.class} - ) - public void test_parseIntLjava_lang_String2() { - // Test for method int java.lang.Integer.parseInt(java.lang.String) - - int i = Integer.parseInt("-8900"); - assertEquals("Returned incorrect int", -8900, i); - assertEquals("Returned incorrect value for 0", 0, Integer.parseInt("0")); - assertTrue("Returned incorrect value for most negative value", Integer - .parseInt("-2147483648") == 0x80000000); - assertTrue("Returned incorrect value for most positive value", Integer - .parseInt("2147483647") == 0x7fffffff); - - boolean exception = false; - try { - Integer.parseInt("999999999999"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for value > int", exception); - - exception = false; - try { - Integer.parseInt("2147483648"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.parseInt("-2147483649"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); - } - - /** - * @tests java.lang.Integer#parseInt(java.lang.String, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "parseInt", - args = {java.lang.String.class, int.class} - ) - public void test_parseIntLjava_lang_StringI2() { - // Test for method int java.lang.Integer.parseInt(java.lang.String, int) - assertEquals("Parsed dec val incorrectly", - -8000, Integer.parseInt("-8000", 10)); - assertEquals("Parsed hex val incorrectly", - 255, Integer.parseInt("FF", 16)); - assertEquals("Parsed oct val incorrectly", - 16, Integer.parseInt("20", 8)); - assertEquals("Returned incorrect value for 0 hex", 0, Integer.parseInt("0", - 16)); - assertTrue("Returned incorrect value for most negative value hex", - Integer.parseInt("-80000000", 16) == 0x80000000); - assertTrue("Returned incorrect value for most positive value hex", - Integer.parseInt("7fffffff", 16) == 0x7fffffff); - assertEquals("Returned incorrect value for 0 decimal", 0, Integer.parseInt( - "0", 10)); - assertTrue("Returned incorrect value for most negative value decimal", - Integer.parseInt("-2147483648", 10) == 0x80000000); - assertTrue("Returned incorrect value for most positive value decimal", - Integer.parseInt("2147483647", 10) == 0x7fffffff); - - boolean exception = false; - try { - Integer.parseInt("FFFF", 10); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue( - "Failed to throw exception when passes hex string and dec parm", - exception); - - exception = false; - try { - Integer.parseInt("2147483648", 10); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.parseInt("-2147483649", 10); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for MIN_VALUE - 1", exception); - - exception = false; - try { - Integer.parseInt("80000000", 16); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for hex MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.parseInt("-80000001", 16); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for hex MIN_VALUE + 1", exception); - - exception = false; - try { - Integer.parseInt("9999999999", 10); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception for 9999999999", exception); - } - - /** - * @tests java.lang.Integer#shortValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL, - notes = "Checks one value.", - method = "shortValue", - args = {} - ) - public void test_shortValue2() { - // Test for method short java.lang.Integer.shortValue() - Integer i = new Integer(2147450880); - assertEquals("Returned incorrect long value", -32768, i.shortValue()); - } - - /** - * @tests java.lang.Integer#toBinaryString(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toBinaryString", - args = {int.class} - ) - public void test_toBinaryStringI() { - // Test for method java.lang.String - // java.lang.Integer.toBinaryString(int) - assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toBinaryString( - Integer.MAX_VALUE)); - assertEquals("Incorrect string returned", "10000000000000000000000000000000", Integer.toBinaryString( - Integer.MIN_VALUE)); - } - - /** - * @tests java.lang.Integer#toHexString(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toHexString", - args = {int.class} - ) - public void test_toHexStringI() { - // Test for method java.lang.String java.lang.Integer.toHexString(int) - - String[] hexvals = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", - "a", "b", "c", "d", "e", "f" }; - - for (int i = 0; i < 16; i++) { - assertTrue("Incorrect string returned " + hexvals[i], Integer - .toHexString(i).equals(hexvals[i])); - } - - assertTrue("Returned incorrect hex string: " - + Integer.toHexString(Integer.MAX_VALUE), Integer.toHexString( - Integer.MAX_VALUE).equals("7fffffff")); - assertTrue("Returned incorrect hex string: " - + Integer.toHexString(Integer.MIN_VALUE), Integer.toHexString( - Integer.MIN_VALUE).equals("80000000")); - } - - /** - * @tests java.lang.Integer#toOctalString(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toOctalString", - args = {int.class} - ) - public void test_toOctalStringI() { - // Test for method java.lang.String java.lang.Integer.toOctalString(int) - // Spec states that the int arg is treated as unsigned - assertEquals("Returned incorrect octal string", "17777777777", Integer.toOctalString( - Integer.MAX_VALUE)); - assertEquals("Returned incorrect octal string", "20000000000", Integer.toOctalString( - Integer.MIN_VALUE)); - } - - /** - * @tests java.lang.Integer#toString() - */ - @TestTargetNew( - level = TestLevel.PARTIAL, - notes = "Checks one value.", - method = "toString", - args = {} - ) - public void test_toString2() { - // Test for method java.lang.String java.lang.Integer.toString() - - Integer i = new Integer(-80001); - - assertEquals("Returned incorrect String", "-80001", i.toString()); - } - - /** - * @tests java.lang.Integer#toString(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {int.class} - ) - public void test_toStringI2() { - // Test for method java.lang.String java.lang.Integer.toString(int) - - assertEquals("Returned incorrect String", "-80765", Integer.toString(-80765) - ); - assertEquals("Returned incorrect octal string", "2147483647", Integer.toString( - Integer.MAX_VALUE)); - assertEquals("Returned incorrect octal string", "-2147483647", Integer.toString( - -Integer.MAX_VALUE)); - assertEquals("Returned incorrect octal string", "-2147483648", Integer.toString( - Integer.MIN_VALUE)); - - // Test for HARMONY-6068 - assertEquals("Returned incorrect octal String", "-1000", Integer.toString(-1000)); - assertEquals("Returned incorrect octal String", "1000", Integer.toString(1000)); - assertEquals("Returned incorrect octal String", "0", Integer.toString(0)); - assertEquals("Returned incorrect octal String", "708", Integer.toString(708)); - assertEquals("Returned incorrect octal String", "-100", Integer.toString(-100)); - assertEquals("Returned incorrect octal String", "-1000000008", Integer.toString(-1000000008)); - assertEquals("Returned incorrect octal String", "2000000008", Integer.toString(2000000008)); - } - - /** - * @tests java.lang.Integer#toString(int, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {int.class, int.class} - ) - public void test_toStringII() { - // Test for method java.lang.String java.lang.Integer.toString(int, int) - assertEquals("Returned incorrect octal string", "17777777777", Integer.toString( - 2147483647, 8)); - assertTrue("Returned incorrect hex string--wanted 7fffffff but got: " - + Integer.toString(2147483647, 16), Integer.toString( - 2147483647, 16).equals("7fffffff")); - assertEquals("Incorrect string returned", "1111111111111111111111111111111", Integer.toString(2147483647, 2) - ); - assertEquals("Incorrect string returned", "2147483647", Integer - .toString(2147483647, 10)); - - assertEquals("Returned incorrect octal string", "-17777777777", Integer.toString( - -2147483647, 8)); - assertTrue("Returned incorrect hex string--wanted -7fffffff but got: " - + Integer.toString(-2147483647, 16), Integer.toString( - -2147483647, 16).equals("-7fffffff")); - assertEquals("Incorrect string returned", - "-1111111111111111111111111111111", Integer - .toString(-2147483647, 2)); - assertEquals("Incorrect string returned", "-2147483647", Integer.toString(-2147483647, - 10)); - - assertEquals("Returned incorrect octal string", "-20000000000", Integer.toString( - -2147483648, 8)); - assertTrue("Returned incorrect hex string--wanted -80000000 but got: " - + Integer.toString(-2147483648, 16), Integer.toString( - -2147483648, 16).equals("-80000000")); - assertEquals("Incorrect string returned", - "-10000000000000000000000000000000", Integer - .toString(-2147483648, 2)); - assertEquals("Incorrect string returned", "-2147483648", Integer.toString(-2147483648, - 10)); - } - - /** - * @tests java.lang.Integer#valueOf(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Verifies boundary values.", - method = "valueOf", - args = {java.lang.String.class} - ) - public void test_valueOfLjava_lang_String2() { - // Test for method java.lang.Integer - // java.lang.Integer.valueOf(java.lang.String) - assertEquals("Returned incorrect int", 8888888, Integer.valueOf("8888888") - .intValue()); - assertTrue("Returned incorrect int", Integer.valueOf("2147483647") - .intValue() == Integer.MAX_VALUE); - assertTrue("Returned incorrect int", Integer.valueOf("-2147483648") - .intValue() == Integer.MIN_VALUE); - - boolean exception = false; - try { - Integer.valueOf("2147483648"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception with MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.valueOf("-2147483649"); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception with MIN_VALUE - 1", exception); - } - - /** - * @tests java.lang.Integer#valueOf(java.lang.String, int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Checks boundary values.", - method = "valueOf", - args = {java.lang.String.class, int.class} - ) - public void test_valueOfLjava_lang_StringI2() { - // Test for method java.lang.Integer - // java.lang.Integer.valueOf(java.lang.String, int) - assertEquals("Returned incorrect int for hex string", 255, Integer.valueOf( - "FF", 16).intValue()); - assertEquals("Returned incorrect int for oct string", 16, Integer.valueOf( - "20", 8).intValue()); - assertEquals("Returned incorrect int for bin string", 4, Integer.valueOf( - "100", 2).intValue()); - - assertEquals("Returned incorrect int for - hex string", -255, Integer.valueOf( - "-FF", 16).intValue()); - assertEquals("Returned incorrect int for - oct string", -16, Integer.valueOf( - "-20", 8).intValue()); - assertEquals("Returned incorrect int for - bin string", -4, Integer.valueOf( - "-100", 2).intValue()); - assertTrue("Returned incorrect int", Integer.valueOf("2147483647", 10) - .intValue() == Integer.MAX_VALUE); - assertTrue("Returned incorrect int", Integer.valueOf("-2147483648", 10) - .intValue() == Integer.MIN_VALUE); - assertTrue("Returned incorrect int", Integer.valueOf("7fffffff", 16) - .intValue() == Integer.MAX_VALUE); - assertTrue("Returned incorrect int", Integer.valueOf("-80000000", 16) - .intValue() == Integer.MIN_VALUE); - - boolean exception = false; - try { - Integer.valueOf("FF", 2); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue( - "Failed to throw exception with hex string and base 2 radix", - exception); - - exception = false; - try { - Integer.valueOf("2147483648", 10); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception with MAX_VALUE + 1", exception); - - exception = false; - try { - Integer.valueOf("-2147483649", 10); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception with MIN_VALUE - 1", exception); - - exception = false; - try { - Integer.valueOf("80000000", 16); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception with hex MAX_VALUE + 1", - exception); - - exception = false; - try { - Integer.valueOf("-80000001", 16); - } catch (NumberFormatException e) { - // Correct - exception = true; - } - assertTrue("Failed to throw exception with hex MIN_VALUE - 1", - exception); - } - - /** - * @tests java.lang.Integer#valueOf(byte) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "valueOf", - args = {int.class} - ) - public void test_valueOfI() { - assertEquals(new Integer(Integer.MIN_VALUE), Integer.valueOf(Integer.MIN_VALUE)); - assertEquals(new Integer(Integer.MAX_VALUE), Integer.valueOf(Integer.MAX_VALUE)); - assertEquals(new Integer(0), Integer.valueOf(0)); - - short s = -128; - while (s < 128) { - assertEquals(new Integer(s), Integer.valueOf(s)); - assertSame(Integer.valueOf(s), Integer.valueOf(s)); - s++; - } - } - - /** - * @tests java.lang.Integer#hashCode() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) - public void test_hashCode() { - assertEquals(1, new Integer(1).hashCode()); - assertEquals(2, new Integer(2).hashCode()); - assertEquals(0, new Integer(0).hashCode()); - assertEquals(-1, new Integer(-1).hashCode()); - } - - /** - * @tests java.lang.Integer#Integer(String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Integer", - args = {java.lang.String.class} - ) - public void test_ConstructorLjava_lang_String() { - assertEquals(new Integer(0), new Integer("0")); - assertEquals(new Integer(1), new Integer("1")); - assertEquals(new Integer(-1), new Integer("-1")); - - try { - new Integer("0x1"); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) {} - - try { - new Integer("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) {} - - try { - new Integer(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) {} - - try { - new Integer(null); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) {} - } - - /** - * @tests java.lang.Integer#Integer - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Integer", - args = {int.class} - ) - public void test_ConstructorI() { - assertEquals(1, new Integer(1).intValue()); - assertEquals(2, new Integer(2).intValue()); - assertEquals(0, new Integer(0).intValue()); - assertEquals(-1, new Integer(-1).intValue()); - - Integer i = new Integer(-89000); - assertEquals("Incorrect Integer created", -89000, i.intValue()); - } - - /** - * @tests java.lang.Integer#byteValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "byteValue", - args = {} - ) - public void test_booleanValue() { - assertEquals(1, new Integer(1).byteValue()); - assertEquals(2, new Integer(2).byteValue()); - assertEquals(0, new Integer(0).byteValue()); - assertEquals(-1, new Integer(-1).byteValue()); - } - - /** - * @tests java.lang.Integer#equals(Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) - public void test_equalsLjava_lang_Object() { - assertEquals(new Integer(0), Integer.valueOf(0)); - assertEquals(new Integer(1), Integer.valueOf(1)); - assertEquals(new Integer(-1), Integer.valueOf(-1)); - - Integer fixture = new Integer(25); - assertEquals(fixture, fixture); - assertFalse(fixture.equals(null)); - assertFalse(fixture.equals("Not a Integer")); - } - - /** - * @tests java.lang.Integer#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - assertEquals("-1", new Integer(-1).toString()); - assertEquals("0", new Integer(0).toString()); - assertEquals("1", new Integer(1).toString()); - assertEquals("-1", new Integer(0xFFFFFFFF).toString()); - } - - /** - * @tests java.lang.Integer#toString - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {int.class} - ) - public void test_toStringI() { - assertEquals("-1", Integer.toString(-1)); - assertEquals("0", Integer.toString(0)); - assertEquals("1", Integer.toString(1)); - assertEquals("-1", Integer.toString(0xFFFFFFFF)); - } - - /** - * @tests java.lang.Integer#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 Integer(0), Integer.valueOf("0")); - assertEquals(new Integer(1), Integer.valueOf("1")); - assertEquals(new Integer(-1), Integer.valueOf("-1")); - - try { - Integer.valueOf("0x1"); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) {} - - try { - Integer.valueOf("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) {} - - try { - Integer.valueOf(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) {} - - try { - Integer.valueOf(null); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) {} - } - - /** - * @tests java.lang.Integer#valueOf(String,int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Doesn't check boundary values.", - method = "valueOf", - args = {java.lang.String.class, int.class} - ) - public void test_valueOfLjava_lang_StringI() { - assertEquals(new Integer(0), Integer.valueOf("0", 10)); - assertEquals(new Integer(1), Integer.valueOf("1", 10)); - assertEquals(new Integer(-1), Integer.valueOf("-1", 10)); - - //must be consistent with Character.digit() - assertEquals(Character.digit('1', 2), Integer.valueOf("1", 2).byteValue()); - assertEquals(Character.digit('F', 16), Integer.valueOf("F", 16).byteValue()); - - try { - Integer.valueOf("0x1", 10); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) {} - - try { - Integer.valueOf("9.2", 10); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) {} - - try { - Integer.valueOf("", 10); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) {} - - try { - Integer.valueOf(null, 10); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) {} - } - - /** - * @tests java.lang.Integer#parseInt(String) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Doesn't check boundary values.", - method = "parseInt", - args = {java.lang.String.class} - ) - public void test_parseIntLjava_lang_String() { - assertEquals(0, Integer.parseInt("0")); - assertEquals(1, Integer.parseInt("1")); - assertEquals(-1, Integer.parseInt("-1")); - - try { - Integer.parseInt("0x1"); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) {} - - try { - Integer.parseInt("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) {} - - try { - Integer.parseInt(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) {} - - try { - Integer.parseInt(null); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) {} - } - - /** - * @tests java.lang.Integer#parseInt(String,int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "parseInt", - args = {java.lang.String.class, int.class} - ) - public void test_parseIntLjava_lang_StringI() { - assertEquals(0, Integer.parseInt("0", 10)); - assertEquals(1, Integer.parseInt("1", 10)); - assertEquals(-1, Integer.parseInt("-1", 10)); - - //must be consistent with Character.digit() - assertEquals(Character.digit('1', 2), Integer.parseInt("1", 2)); - assertEquals(Character.digit('F', 16), Integer.parseInt("F", 16)); - - try { - Integer.parseInt("0x1", 10); - fail("Expected NumberFormatException with hex string."); - } catch (NumberFormatException e) {} - - try { - Integer.parseInt("9.2", 10); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) {} - - try { - Integer.parseInt("", 10); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) {} - - try { - Integer.parseInt(null, 10); - fail("Expected NumberFormatException with null string."); - } catch (NumberFormatException e) {} - } - - /** - * @tests java.lang.Integer#decode(String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "decode", - args = {java.lang.String.class} - ) - public void test_decodeLjava_lang_String() { - assertEquals(new Integer(0), Integer.decode("0")); - assertEquals(new Integer(1), Integer.decode("1")); - assertEquals(new Integer(-1), Integer.decode("-1")); - assertEquals(new Integer(0xF), Integer.decode("0xF")); - assertEquals(new Integer(0xF), Integer.decode("#F")); - assertEquals(new Integer(0xF), Integer.decode("0XF")); - assertEquals(new Integer(07), Integer.decode("07")); - - try { - Integer.decode("9.2"); - fail("Expected NumberFormatException with floating point string."); - } catch (NumberFormatException e) {} - - try { - Integer.decode(""); - fail("Expected NumberFormatException with empty string."); - } catch (NumberFormatException e) {} - - try { - Integer.decode(null); - //undocumented NPE, but seems consistent across JREs - fail("Expected NullPointerException with null string."); - } catch (NullPointerException e) {} - } - - /** - * @tests java.lang.Integer#doubleValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Doesn't check boundaries.", - method = "doubleValue", - args = {} - ) - public void test_doubleValue() { - assertEquals(-1D, new Integer(-1).doubleValue(), 0D); - assertEquals(0D, new Integer(0).doubleValue(), 0D); - assertEquals(1D, new Integer(1).doubleValue(), 0D); - } - - /** - * @tests java.lang.Integer#floatValue() - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "floatValue", - args = {} - ) - public void test_floatValue() { - assertEquals(-1F, new Integer(-1).floatValue(), 0F); - assertEquals(0F, new Integer(0).floatValue(), 0F); - assertEquals(1F, new Integer(1).floatValue(), 0F); - } - - /** - * @tests java.lang.Integer#intValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "intValue", - args = {} - ) - public void test_intValue() { - assertEquals(-1, new Integer(-1).intValue()); - assertEquals(0, new Integer(0).intValue()); - assertEquals(1, new Integer(1).intValue()); - assertEquals(Integer.MAX_VALUE, new Integer(Integer.MAX_VALUE).intValue()); - assertEquals(Integer.MIN_VALUE, new Integer(Integer.MIN_VALUE).intValue()); - } - - /** - * @tests java.lang.Integer#longValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "longValue", - args = {} - ) - public void test_longValue() { - assertEquals(-1L, new Integer(-1).longValue()); - assertEquals(0L, new Integer(0).longValue()); - assertEquals(1L, new Integer(1).longValue()); - assertEquals(Integer.MAX_VALUE, new Integer(Integer.MAX_VALUE).longValue()); - assertEquals(Integer.MIN_VALUE, new Integer(Integer.MIN_VALUE).longValue()); - } - - /** - * @tests java.lang.Integer#shortValue() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "shortValue", - args = {} - ) - public void test_shortValue() { - assertEquals(-1, new Integer(-1).shortValue()); - assertEquals(0, new Integer(0).shortValue()); - assertEquals(1, new Integer(1).shortValue()); - assertEquals(-1, new Integer(Integer.MAX_VALUE).shortValue()); - assertEquals(0, new Integer(Integer.MIN_VALUE).shortValue()); - } - /** - * @tests java.lang.Integer#highestOneBit(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "highestOneBit", - args = {int.class} - ) - public void test_highestOneBitI() { - assertEquals(0x08, Integer.highestOneBit(0x0A)); - assertEquals(0x08, Integer.highestOneBit(0x0B)); - assertEquals(0x08, Integer.highestOneBit(0x0C)); - assertEquals(0x08, Integer.highestOneBit(0x0F)); - assertEquals(0x80, Integer.highestOneBit(0xFF)); - - assertEquals(0x080000, Integer.highestOneBit(0x0F1234)); - assertEquals(0x800000, Integer.highestOneBit(0xFF9977)); - - assertEquals(0x80000000, Integer.highestOneBit(0xFFFFFFFF)); - - assertEquals(0, Integer.highestOneBit(0)); - assertEquals(1, Integer.highestOneBit(1)); - assertEquals(0x80000000, Integer.highestOneBit(-1)); - } - - /** - * @tests java.lang.Integer#lowestOneBit(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "lowestOneBit", - args = {int.class} - ) - public void test_lowestOneBitI() { - assertEquals(0x10, Integer.lowestOneBit(0xF0)); - - assertEquals(0x10, Integer.lowestOneBit(0x90)); - assertEquals(0x10, Integer.lowestOneBit(0xD0)); - - assertEquals(0x10, Integer.lowestOneBit(0x123490)); - assertEquals(0x10, Integer.lowestOneBit(0x1234D0)); - - assertEquals(0x100000, Integer.lowestOneBit(0x900000)); - assertEquals(0x100000, Integer.lowestOneBit(0xD00000)); - - assertEquals(0x40, Integer.lowestOneBit(0x40)); - assertEquals(0x40, Integer.lowestOneBit(0xC0)); - - assertEquals(0x4000, Integer.lowestOneBit(0x4000)); - assertEquals(0x4000, Integer.lowestOneBit(0xC000)); - - assertEquals(0x4000, Integer.lowestOneBit(0x99994000)); - assertEquals(0x4000, Integer.lowestOneBit(0x9999C000)); - - assertEquals(0, Integer.lowestOneBit(0)); - assertEquals(1, Integer.lowestOneBit(1)); - assertEquals(1, Integer.lowestOneBit(-1)); - } - /** - * @tests java.lang.Integer#numberOfLeadingZeros(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "numberOfLeadingZeros", - args = {int.class} - ) - public void test_numberOfLeadingZerosI() { - assertEquals(32, Integer.numberOfLeadingZeros(0x0)); - assertEquals(31, Integer.numberOfLeadingZeros(0x1)); - assertEquals(30, Integer.numberOfLeadingZeros(0x2)); - assertEquals(30, Integer.numberOfLeadingZeros(0x3)); - assertEquals(29, Integer.numberOfLeadingZeros(0x4)); - assertEquals(29, Integer.numberOfLeadingZeros(0x5)); - assertEquals(29, Integer.numberOfLeadingZeros(0x6)); - assertEquals(29, Integer.numberOfLeadingZeros(0x7)); - assertEquals(28, Integer.numberOfLeadingZeros(0x8)); - assertEquals(28, Integer.numberOfLeadingZeros(0x9)); - assertEquals(28, Integer.numberOfLeadingZeros(0xA)); - assertEquals(28, Integer.numberOfLeadingZeros(0xB)); - assertEquals(28, Integer.numberOfLeadingZeros(0xC)); - assertEquals(28, Integer.numberOfLeadingZeros(0xD)); - assertEquals(28, Integer.numberOfLeadingZeros(0xE)); - assertEquals(28, Integer.numberOfLeadingZeros(0xF)); - assertEquals(27, Integer.numberOfLeadingZeros(0x10)); - assertEquals(24, Integer.numberOfLeadingZeros(0x80)); - assertEquals(24, Integer.numberOfLeadingZeros(0xF0)); - assertEquals(23, Integer.numberOfLeadingZeros(0x100)); - assertEquals(20, Integer.numberOfLeadingZeros(0x800)); - assertEquals(20, Integer.numberOfLeadingZeros(0xF00)); - assertEquals(19, Integer.numberOfLeadingZeros(0x1000)); - assertEquals(16, Integer.numberOfLeadingZeros(0x8000)); - assertEquals(16, Integer.numberOfLeadingZeros(0xF000)); - assertEquals(15, Integer.numberOfLeadingZeros(0x10000)); - assertEquals(12, Integer.numberOfLeadingZeros(0x80000)); - assertEquals(12, Integer.numberOfLeadingZeros(0xF0000)); - assertEquals(11, Integer.numberOfLeadingZeros(0x100000)); - assertEquals(8, Integer.numberOfLeadingZeros(0x800000)); - assertEquals(8, Integer.numberOfLeadingZeros(0xF00000)); - assertEquals(7, Integer.numberOfLeadingZeros(0x1000000)); - assertEquals(4, Integer.numberOfLeadingZeros(0x8000000)); - assertEquals(4, Integer.numberOfLeadingZeros(0xF000000)); - assertEquals(3, Integer.numberOfLeadingZeros(0x10000000)); - assertEquals(0, Integer.numberOfLeadingZeros(0x80000000)); - assertEquals(0, Integer.numberOfLeadingZeros(0xF0000000)); - - assertEquals(1, Integer.numberOfLeadingZeros(Integer.MAX_VALUE)); - assertEquals(0, Integer.numberOfLeadingZeros(Integer.MIN_VALUE)); - } - - /** - * @tests - * java.lang.Integer#numberOfTrailingZeros(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "numberOfTrailingZeros", - args = {int.class} - ) - public void test_numberOfTrailingZerosI() { - assertEquals(32, Integer.numberOfTrailingZeros(0x0)); - assertEquals(31, Integer.numberOfTrailingZeros(Integer.MIN_VALUE)); - assertEquals(0, Integer.numberOfTrailingZeros(Integer.MAX_VALUE)); - - assertEquals(0, Integer.numberOfTrailingZeros(0x1)); - assertEquals(3, Integer.numberOfTrailingZeros(0x8)); - assertEquals(0, Integer.numberOfTrailingZeros(0xF)); - - assertEquals(4, Integer.numberOfTrailingZeros(0x10)); - assertEquals(7, Integer.numberOfTrailingZeros(0x80)); - assertEquals(4, Integer.numberOfTrailingZeros(0xF0)); - - assertEquals(8, Integer.numberOfTrailingZeros(0x100)); - assertEquals(11, Integer.numberOfTrailingZeros(0x800)); - assertEquals(8, Integer.numberOfTrailingZeros(0xF00)); - - assertEquals(12, Integer.numberOfTrailingZeros(0x1000)); - assertEquals(15, Integer.numberOfTrailingZeros(0x8000)); - assertEquals(12, Integer.numberOfTrailingZeros(0xF000)); - - assertEquals(16, Integer.numberOfTrailingZeros(0x10000)); - assertEquals(19, Integer.numberOfTrailingZeros(0x80000)); - assertEquals(16, Integer.numberOfTrailingZeros(0xF0000)); - - assertEquals(20, Integer.numberOfTrailingZeros(0x100000)); - assertEquals(23, Integer.numberOfTrailingZeros(0x800000)); - assertEquals(20, Integer.numberOfTrailingZeros(0xF00000)); - - assertEquals(24, Integer.numberOfTrailingZeros(0x1000000)); - assertEquals(27, Integer.numberOfTrailingZeros(0x8000000)); - assertEquals(24, Integer.numberOfTrailingZeros(0xF000000)); - - assertEquals(28, Integer.numberOfTrailingZeros(0x10000000)); - assertEquals(31, Integer.numberOfTrailingZeros(0x80000000)); - assertEquals(28, Integer.numberOfTrailingZeros(0xF0000000)); - } - - /** - * @tests java.lang.Integer#bitCount(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "bitCount", - args = {int.class} - ) - public void test_bitCountI() { - assertEquals(0, Integer.bitCount(0x0)); - assertEquals(1, Integer.bitCount(0x1)); - assertEquals(1, Integer.bitCount(0x2)); - assertEquals(2, Integer.bitCount(0x3)); - assertEquals(1, Integer.bitCount(0x4)); - assertEquals(2, Integer.bitCount(0x5)); - assertEquals(2, Integer.bitCount(0x6)); - assertEquals(3, Integer.bitCount(0x7)); - assertEquals(1, Integer.bitCount(0x8)); - assertEquals(2, Integer.bitCount(0x9)); - assertEquals(2, Integer.bitCount(0xA)); - assertEquals(3, Integer.bitCount(0xB)); - assertEquals(2, Integer.bitCount(0xC)); - assertEquals(3, Integer.bitCount(0xD)); - assertEquals(3, Integer.bitCount(0xE)); - assertEquals(4, Integer.bitCount(0xF)); - - assertEquals(8, Integer.bitCount(0xFF)); - assertEquals(12, Integer.bitCount(0xFFF)); - assertEquals(16, Integer.bitCount(0xFFFF)); - assertEquals(20, Integer.bitCount(0xFFFFF)); - assertEquals(24, Integer.bitCount(0xFFFFFF)); - assertEquals(28, Integer.bitCount(0xFFFFFFF)); - assertEquals(32, Integer.bitCount(0xFFFFFFFF)); - } - - /** - * @tests java.lang.Integer#rotateLeft(int,int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "rotateLeft", - args = {int.class, int.class} - ) - public void test_rotateLeftII() { - assertEquals(0xF, Integer.rotateLeft(0xF, 0)); - assertEquals(0xF0, Integer.rotateLeft(0xF, 4)); - assertEquals(0xF00, Integer.rotateLeft(0xF, 8)); - assertEquals(0xF000, Integer.rotateLeft(0xF, 12)); - assertEquals(0xF0000, Integer.rotateLeft(0xF, 16)); - assertEquals(0xF00000, Integer.rotateLeft(0xF, 20)); - assertEquals(0xF000000, Integer.rotateLeft(0xF, 24)); - assertEquals(0xF0000000, Integer.rotateLeft(0xF, 28)); - assertEquals(0xF0000000, Integer.rotateLeft(0xF0000000, 32)); - } - - /** - * @tests java.lang.Integer#rotateRight(int,int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "rotateRight", - args = {int.class, int.class} - ) - public void test_rotateRightII() { - assertEquals(0xF, Integer.rotateRight(0xF0, 4)); - assertEquals(0xF, Integer.rotateRight(0xF00, 8)); - assertEquals(0xF, Integer.rotateRight(0xF000, 12)); - assertEquals(0xF, Integer.rotateRight(0xF0000, 16)); - assertEquals(0xF, Integer.rotateRight(0xF00000, 20)); - assertEquals(0xF, Integer.rotateRight(0xF000000, 24)); - assertEquals(0xF, Integer.rotateRight(0xF0000000, 28)); - assertEquals(0xF0000000, Integer.rotateRight(0xF0000000, 32)); - assertEquals(0xF0000000, Integer.rotateRight(0xF0000000, 0)); - - } - - /** - * @tests java.lang.Integer#reverseBytes(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "reverseBytes", - args = {int.class} - ) - public void test_reverseBytesI() { - assertEquals(0xAABBCCDD, Integer.reverseBytes(0xDDCCBBAA)); - assertEquals(0x11223344, Integer.reverseBytes(0x44332211)); - assertEquals(0x00112233, Integer.reverseBytes(0x33221100)); - assertEquals(0x20000002, Integer.reverseBytes(0x02000020)); - } - - /** - * @tests java.lang.Integer#reverse(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "reverse", - args = {int.class} - ) - public void test_reverseI() { - assertEquals(-1, Integer.reverse(-1)); - assertEquals(0x80000000,Integer.reverse(1)); - } - - /** - * @tests java.lang.Integer#signum(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "signum", - args = {int.class} - ) - public void test_signumI() { - for (int i = -128; i<0; i++) { - assertEquals(-1, Integer.signum(i)); - } - assertEquals(0, Integer.signum(0)); - for (int i = 1; i<=127; i++) { - assertEquals(1, Integer.signum(i)); - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InternalErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InternalErrorTest.java deleted file mode 100644 index 3ff4711..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InternalErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class InternalErrorTest extends TestCase { - - /** - * @tests java.lang.InternalError#InternalError() - */ - public void test_Constructor() { - InternalError e = new InternalError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.InternalError#InternalError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - InternalError e = new InternalError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InterruptedExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InterruptedExceptionTest.java deleted file mode 100644 index 96c85e6..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/InterruptedExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class InterruptedExceptionTest extends TestCase { - - /** - * @tests java.lang.InterruptedException#InterruptedException() - */ - public void test_Constructor() { - InterruptedException e = new InterruptedException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.InterruptedException#InterruptedException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - InterruptedException e = new InterruptedException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LinkageErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LinkageErrorTest.java deleted file mode 100644 index 9c1adcb..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LinkageErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class LinkageErrorTest extends TestCase { - - /** - * @tests java.lang.LinkageError#LinkageError() - */ - public void test_Constructor() { - LinkageError e = new LinkageError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.LinkageError#LinkageError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - LinkageError e = new LinkageError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java deleted file mode 100644 index 432f802..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/LongTest.java +++ /dev/null @@ -1,1332 +0,0 @@ -/* 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)); - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MathTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MathTest.java deleted file mode 100644 index ceabd2c..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MathTest.java +++ /dev/null @@ -1,1987 +0,0 @@ -/* - * 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; - -public class MathTest extends junit.framework.TestCase { - - double HYP = Math.sqrt(2.0); - - double OPP = 1.0; - - double ADJ = 1.0; - - /* Required to make previous preprocessor flags work - do not remove */ - int unused = 0; - - /** - * @tests java.lang.Math#abs(double) - */ - public void test_absD() { - // Test for method double java.lang.Math.abs(double) - - assertTrue("Incorrect double abs value", - (Math.abs(-1908.8976) == 1908.8976)); - assertTrue("Incorrect double abs value", - (Math.abs(1908.8976) == 1908.8976)); - } - - /** - * @tests java.lang.Math#abs(float) - */ - public void test_absF() { - // Test for method float java.lang.Math.abs(float) - assertTrue("Incorrect float abs value", - (Math.abs(-1908.8976f) == 1908.8976f)); - assertTrue("Incorrect float abs value", - (Math.abs(1908.8976f) == 1908.8976f)); - } - - /** - * @tests java.lang.Math#abs(int) - */ - public void test_absI() { - // Test for method int java.lang.Math.abs(int) - assertTrue("Incorrect int abs value", (Math.abs(-1908897) == 1908897)); - assertTrue("Incorrect int abs value", (Math.abs(1908897) == 1908897)); - } - - /** - * @tests java.lang.Math#abs(long) - */ - public void test_absJ() { - // Test for method long java.lang.Math.abs(long) - assertTrue("Incorrect long abs value", - (Math.abs(-19088976000089L) == 19088976000089L)); - assertTrue("Incorrect long abs value", - (Math.abs(19088976000089L) == 19088976000089L)); - } - - /** - * @tests java.lang.Math#acos(double) - */ - public void test_acosD() { - // Test for method double java.lang.Math.acos(double) - double r = Math.cos(Math.acos(ADJ / HYP)); - long lr = Double.doubleToLongBits(r); - long t = Double.doubleToLongBits(ADJ / HYP); - assertTrue("Returned incorrect arc cosine", lr == t || (lr + 1) == t - || (lr - 1) == t); - } - - /** - * @tests java.lang.Math#asin(double) - */ - public void test_asinD() { - // Test for method double java.lang.Math.asin(double) - double r = Math.sin(Math.asin(OPP / HYP)); - long lr = Double.doubleToLongBits(r); - long t = Double.doubleToLongBits(OPP / HYP); - assertTrue("Returned incorrect arc sine", lr == t || (lr + 1) == t - || (lr - 1) == t); - } - - /** - * @tests java.lang.Math#atan(double) - */ - public void test_atanD() { - // Test for method double java.lang.Math.atan(double) - double answer = Math.tan(Math.atan(1.0)); - assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 - && answer >= 9.9999999999999983E-1); - } - - /** - * @tests java.lang.Math#atan2(double, double) - */ - public void test_atan2DD() { - // Test for method double java.lang.Math.atan2(double, double) - double answer = Math.atan(Math.tan(1.0)); - assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 - && answer >= 9.9999999999999983E-1); - } - - /** - * @tests java.lang.Math#cbrt(double) - */ - public void test_cbrt_D() { - //Test for special situations - assertTrue("Should return Double.NaN", Double.isNaN(Math - .cbrt(Double.NaN))); - assertEquals("Should return Double.POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math - .cbrt(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return Double.NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, Math - .cbrt(Double.NEGATIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math - .cbrt(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double.doubleToLongBits(Math - .cbrt(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double.doubleToLongBits(Math - .cbrt(-0.0))); - - assertEquals("Should return 3.0", 3.0, Math.cbrt(27.0), 0D); - assertEquals("Should return 23.111993172558684", 23.111993172558684, - Math.cbrt(12345.6), 0D); - assertEquals("Should return 5.643803094122362E102", - 5.643803094122362E102, Math.cbrt(Double.MAX_VALUE), 0D); - assertEquals("Should return 0.01", 0.01, Math.cbrt(0.000001), 0D); - - assertEquals("Should return -3.0", -3.0, Math.cbrt(-27.0), 0D); - assertEquals("Should return -23.111993172558684", -23.111993172558684, - Math.cbrt(-12345.6), 0D); - assertEquals("Should return 1.7031839360032603E-108", - 1.7031839360032603E-108, Math.cbrt(Double.MIN_VALUE), 0D); - assertEquals("Should return -0.01", -0.01, Math.cbrt(-0.000001), 0D); - } - - /** - * @tests java.lang.Math#ceil(double) - */ - public void test_ceilD() { - // Test for method double java.lang.Math.ceil(double) - assertEquals("Incorrect ceiling for double", - 79, Math.ceil(78.89), 0); - assertEquals("Incorrect ceiling for double", - -78, Math.ceil(-78.89), 0); - } - - /** - * cases for test_copySign_DD in MathTest/StrictMathTest - */ - static final double[] COPYSIGN_DD_CASES = new double[] { - Double.POSITIVE_INFINITY, Double.MAX_VALUE, 3.4E302, 2.3, - Double.MIN_NORMAL, Double.MIN_NORMAL / 2, Double.MIN_VALUE, +0.0, - 0.0, -0.0, -Double.MIN_VALUE, -Double.MIN_NORMAL / 2, - -Double.MIN_NORMAL, -4.5, -3.4E102, -Double.MAX_VALUE, - Double.NEGATIVE_INFINITY }; - - /** - * @tests {@link java.lang.Math#copySign(double, double)} - * @since 1.6 - * - */ - @SuppressWarnings("boxing") - public void test_copySign_DD() { - for (int i = 0; i < COPYSIGN_DD_CASES.length; i++) { - final double magnitude = COPYSIGN_DD_CASES[i]; - final long absMagnitudeBits = Double.doubleToLongBits(Math - .abs(magnitude)); - final long negMagnitudeBits = Double.doubleToLongBits(-Math - .abs(magnitude)); - - // cases for NaN - assertEquals("If the sign is NaN, the result should be positive.", - absMagnitudeBits, Double.doubleToLongBits(Math.copySign( - magnitude, Double.NaN))); - assertTrue("The result should be NaN.", Double.isNaN(Math.copySign( - Double.NaN, magnitude))); - - for (int j = 0; j < COPYSIGN_DD_CASES.length; j++) { - final double sign = COPYSIGN_DD_CASES[j]; - final long resultBits = Double.doubleToLongBits(Math.copySign( - magnitude, sign)); - - if (sign > 0 || Double.valueOf(+0.0).equals(sign) - || Double.valueOf(0.0).equals(sign)) { - assertEquals( - "If the sign is positive, the result should be positive.", - absMagnitudeBits, resultBits); - } - if (sign < 0 || Double.valueOf(-0.0).equals(sign)) { - assertEquals( - "If the sign is negative, the result should be negative.", - negMagnitudeBits, resultBits); - } - } - } - - assertTrue("The result should be NaN.", Double.isNaN(Math.copySign( - Double.NaN, Double.NaN))); - - try { - Math.copySign((Double) null, 2.3); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.copySign(2.3, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.copySign((Double) null, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * cases for test_copySign_FF in MathTest/StrictMathTest - */ - static final float[] COPYSIGN_FF_CASES = new float[] { - Float.POSITIVE_INFINITY, Float.MAX_VALUE, 3.4E12f, 2.3f, - Float.MIN_NORMAL, Float.MIN_NORMAL / 2, Float.MIN_VALUE, +0.0f, - 0.0f, -0.0f, -Float.MIN_VALUE, -Float.MIN_NORMAL / 2, - -Float.MIN_NORMAL, -4.5f, -5.6442E21f, -Float.MAX_VALUE, - Float.NEGATIVE_INFINITY }; - - /** - * @tests {@link java.lang.Math#copySign(float, float)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_copySign_FF() { - for (int i = 0; i < COPYSIGN_FF_CASES.length; i++) { - final float magnitude = COPYSIGN_FF_CASES[i]; - final int absMagnitudeBits = Float.floatToIntBits(Math - .abs(magnitude)); - final int negMagnitudeBits = Float.floatToIntBits(-Math - .abs(magnitude)); - - // cases for NaN - assertEquals("If the sign is NaN, the result should be positive.", - absMagnitudeBits, Float.floatToIntBits(Math.copySign( - magnitude, Float.NaN))); - assertTrue("The result should be NaN.", Float.isNaN(Math.copySign( - Float.NaN, magnitude))); - - for (int j = 0; j < COPYSIGN_FF_CASES.length; j++) { - final float sign = COPYSIGN_FF_CASES[j]; - final int resultBits = Float.floatToIntBits(Math.copySign( - magnitude, sign)); - if (sign > 0 || Float.valueOf(+0.0f).equals(sign) - || Float.valueOf(0.0f).equals(sign)) { - assertEquals( - "If the sign is positive, the result should be positive.", - absMagnitudeBits, resultBits); - } - if (sign < 0 || Float.valueOf(-0.0f).equals(sign)) { - assertEquals( - "If the sign is negative, the result should be negative.", - negMagnitudeBits, resultBits); - } - } - } - - assertTrue("The result should be NaN.", Float.isNaN(Math.copySign( - Float.NaN, Float.NaN))); - - try { - Math.copySign((Float) null, 2.3f); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.copySign(2.3f, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.copySign((Float) null, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.Math#cos(double) - */ - public void test_cosD() { - // Test for method double java.lang.Math.cos(double) - assertEquals("Incorrect answer", 1.0, Math.cos(0), 0D); - assertEquals("Incorrect answer", 0.5403023058681398, Math.cos(1), 0D); - } - - /** - * @tests java.lang.Math#cosh(double) - */ - public void test_cosh_D() { - // Test for special situations - assertTrue(Double.isNaN(Math.cosh(Double.NaN))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.cosh(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.cosh(Double.NEGATIVE_INFINITY), 0D); - assertEquals("Should return 1.0", 1.0, Math.cosh(+0.0), 0D); - assertEquals("Should return 1.0", 1.0, Math.cosh(-0.0), 0D); - - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.cosh(1234.56), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.cosh(-1234.56), 0D); - assertEquals("Should return 1.0000000000005", 1.0000000000005, Math - .cosh(0.000001), 0D); - assertEquals("Should return 1.0000000000005", 1.0000000000005, Math - .cosh(-0.000001), 0D); - assertEquals("Should return 5.212214351945598", 5.212214351945598, Math - .cosh(2.33482), 0D); - - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.cosh(Double.MAX_VALUE), 0D); - assertEquals("Should return 1.0", 1.0, Math.cosh(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.Math#exp(double) - */ - public void test_expD() { - // Test for method double java.lang.Math.exp(double) - assertTrue("Incorrect answer returned for simple power", Math.abs(Math - .exp(4D) - - Math.E * Math.E * Math.E * Math.E) < 0.1D); - assertTrue("Incorrect answer returned for larger power", Math.log(Math - .abs(Math.exp(5.5D)) - 5.5D) < 10.0D); - } - - /** - * @tests java.lang.Math#expm1(double) - */ - public void test_expm1_D() { - // Test for special cases - assertTrue("Should return NaN", Double.isNaN(Math.expm1(Double.NaN))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.expm1(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return -1.0", -1.0, Math - .expm1(Double.NEGATIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math - .expm1(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(Math.expm1(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(Math.expm1(-0.0))); - - assertEquals("Should return -9.999950000166666E-6", - -9.999950000166666E-6, Math.expm1(-0.00001), 0D); - assertEquals("Should return 1.0145103074469635E60", - 1.0145103074469635E60, Math.expm1(138.16951162), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math - .expm1(123456789123456789123456789.4521584223), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.expm1(Double.MAX_VALUE), 0D); - assertEquals("Should return MIN_VALUE", Double.MIN_VALUE, Math - .expm1(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.Math#floor(double) - */ - public void test_floorD() { - assertEquals("Incorrect floor for int", 42, Math.floor(42), 0); - assertEquals("Incorrect floor for -int", -2, Math.floor(-2), 0); - assertEquals("Incorrect floor for zero", 0d, Math.floor(0d), 0); - - assertEquals("Incorrect floor for +double", 78, Math.floor(78.89), 0); - assertEquals("Incorrect floor for -double", -79, Math.floor(-78.89), 0); - assertEquals("floor large +double", 3.7314645675925406E19, Math.floor(3.7314645675925406E19), 0); - assertEquals("floor large -double", -8.173521839218E12, Math.floor(-8.173521839218E12), 0); - assertEquals("floor small double", 0.0d, Math.floor(1.11895241315E-102), 0); - - // Compare toString representations here since -0.0 = +0.0, and - // NaN != NaN and we need to distinguish - assertEquals("Floor failed for NaN", - Double.toString(Double.NaN), Double.toString(Math.floor(Double.NaN))); - assertEquals("Floor failed for +0.0", - Double.toString(+0.0d), Double.toString(Math.floor(+0.0d))); - assertEquals("Floor failed for -0.0", - Double.toString(-0.0d), Double.toString(Math.floor(-0.0d))); - assertEquals("Floor failed for +infinity", - Double.toString(Double.POSITIVE_INFINITY), Double.toString(Math.floor(Double.POSITIVE_INFINITY))); - assertEquals("Floor failed for -infinity", - Double.toString(Double.NEGATIVE_INFINITY), Double.toString(Math.floor(Double.NEGATIVE_INFINITY))); - } - - /** - * cases for test_getExponent_D in MathTest/StrictMathTest - */ - static final double GETEXPONENT_D_CASES[] = new double[] { - Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, - Double.MAX_VALUE, -Double.MAX_VALUE, 2.342E231, -2.342E231, 2800.0, - -2800.0, 5.323, -5.323, 1.323, -1.323, 0.623, -0.623, 0.323, - -0.323, Double.MIN_NORMAL * 24, -Double.MIN_NORMAL * 24, - Double.MIN_NORMAL, -Double.MIN_NORMAL, Double.MIN_NORMAL / 2, - -Double.MIN_NORMAL / 2, Double.MIN_VALUE, -Double.MIN_VALUE, +0.0, - 0.0, -0.0, Double.NaN }; - - /** - * result for test_getExponent_D in MathTest/StrictMathTest - */ - static final int GETEXPONENT_D_RESULTS[] = new int[] { - Double.MAX_EXPONENT + 1, Double.MAX_EXPONENT + 1, - Double.MAX_EXPONENT, Double.MAX_EXPONENT, 768, 768, 11, 11, 2, 2, - 0, 0, -1, -1, -2, -2, -1018, -1018, Double.MIN_EXPONENT, - Double.MIN_EXPONENT, Double.MIN_EXPONENT - 1, - Double.MIN_EXPONENT - 1, Double.MIN_EXPONENT - 1, - Double.MIN_EXPONENT - 1, Double.MIN_EXPONENT - 1, - Double.MIN_EXPONENT - 1, Double.MIN_EXPONENT - 1, - Double.MAX_EXPONENT + 1 }; - - /** - * @tests {@link java.lang.Math#getExponent(double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_getExponent_D() { - for (int i = 0; i < GETEXPONENT_D_CASES.length; i++) { - final double number = GETEXPONENT_D_CASES[i]; - final int result = GETEXPONENT_D_RESULTS[i]; - assertEquals("Wrong result of getExponent(double).", result, Math - .getExponent(number)); - } - - try { - Math.getExponent((Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * cases for test_getExponent_F in MathTest/StrictMathTest - */ - static final float GETEXPONENT_F_CASES[] = new float[] { - Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, Float.MAX_VALUE, - -Float.MAX_VALUE, 3.4256E23f, -3.4256E23f, 2800.0f, -2800.0f, - 5.323f, -5.323f, 1.323f, -1.323f, 0.623f, -0.623f, 0.323f, -0.323f, - Float.MIN_NORMAL * 24, -Float.MIN_NORMAL * 24, Float.MIN_NORMAL, - -Float.MIN_NORMAL, Float.MIN_NORMAL / 2, -Float.MIN_NORMAL / 2, - Float.MIN_VALUE, -Float.MIN_VALUE, +0.0f, 0.0f, -0.0f, Float.NaN,1,Float.MIN_NORMAL * 1.5f }; - - /** - * result for test_getExponent_F in MathTest/StrictMathTest - */ - static final int GETEXPONENT_F_RESULTS[] = new int[] { - Float.MAX_EXPONENT + 1, Float.MAX_EXPONENT + 1, Float.MAX_EXPONENT, - Float.MAX_EXPONENT, 78, 78, 11, 11, 2, 2, 0, 0, -1, -1, -2, -2, - -122, -122, Float.MIN_EXPONENT, Float.MIN_EXPONENT, - Float.MIN_EXPONENT - 1, Float.MIN_EXPONENT - 1, - Float.MIN_EXPONENT - 1, Float.MIN_EXPONENT - 1, - Float.MIN_EXPONENT - 1, Float.MIN_EXPONENT - 1, - Float.MIN_EXPONENT - 1, Float.MAX_EXPONENT + 1,0,Float.MIN_EXPONENT }; - - /** - * @tests {@link java.lang.Math#getExponent(float)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_getExponent_F() { - for (int i = 0; i < GETEXPONENT_F_CASES.length; i++) { - final float number = GETEXPONENT_F_CASES[i]; - final int result = GETEXPONENT_F_RESULTS[i]; - assertEquals("Wrong result of getExponent(float).", result, Math - .getExponent(number)); - } - try { - Math.getExponent((Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.Math#hypot(double, double) - */ - public void test_hypot_DD() { - // Test for special cases - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.hypot(Double.POSITIVE_INFINITY, - 1.0), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.hypot(Double.NEGATIVE_INFINITY, - 123.324), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.hypot(-758.2587, - Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.hypot(5687.21, - Double.NEGATIVE_INFINITY), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.hypot(Double.POSITIVE_INFINITY, - Double.NEGATIVE_INFINITY), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.hypot(Double.NEGATIVE_INFINITY, - Double.POSITIVE_INFINITY), 0D); - assertTrue("Should be NaN", Double.isNaN(Math.hypot(Double.NaN, - 2342301.89843))); - assertTrue("Should be NaN", Double.isNaN(Math.hypot(-345.2680, - Double.NaN))); - - assertEquals("Should return 2396424.905416697", 2396424.905416697, Math - .hypot(12322.12, -2396393.2258), 0D); - assertEquals("Should return 138.16958070558556", 138.16958070558556, - Math.hypot(-138.16951162, 0.13817035864), 0D); - assertEquals("Should return 1.7976931348623157E308", - 1.7976931348623157E308, Math.hypot(Double.MAX_VALUE, 211370.35), 0D); - assertEquals("Should return 5413.7185", 5413.7185, Math.hypot( - -5413.7185, Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.Math#IEEEremainder(double, double) - */ - public void test_IEEEremainderDD() { - // Test for method double java.lang.Math.IEEEremainder(double, double) - assertEquals("Incorrect remainder returned", - 0.0, Math.IEEEremainder(1.0, 1.0), 0D); - assertTrue("Incorrect remainder returned", Math.IEEEremainder(1.32, - 89.765) >= 1.4705063220631647E-2 - || Math.IEEEremainder(1.32, 89.765) >= 1.4705063220631649E-2); - } - - /** - * @tests java.lang.Math#log(double) - */ - public void test_logD() { - // Test for method double java.lang.Math.log(double) - for (double d = 10; d >= -10; d -= 0.5) { - double answer = Math.log(Math.exp(d)); - assertTrue("Answer does not equal expected answer for d = " + d - + " answer = " + answer, Math.abs(answer - d) <= Math - .abs(d * 0.00000001)); - } - } - - /** - * @tests java.lang.Math#log10(double) - */ - @SuppressWarnings("boxing") - public void test_log10_D() { - // Test for special cases - assertTrue(Double.isNaN(Math.log10(Double.NaN))); - assertTrue(Double.isNaN(Math.log10(-2541.05745687234187532))); - assertTrue(Double.isNaN(Math.log10(-0.1))); - assertEquals(Double.POSITIVE_INFINITY, Math.log10(Double.POSITIVE_INFINITY)); - assertEquals(Double.NEGATIVE_INFINITY, Math.log10(0.0)); - assertEquals(Double.NEGATIVE_INFINITY, Math.log10(+0.0)); - assertEquals(Double.NEGATIVE_INFINITY, Math.log10(-0.0)); - - assertEquals(3.0, Math.log10(1000.0)); - assertEquals(14.0, Math.log10(Math.pow(10, 14))); - assertEquals(3.7389561269540406, Math.log10(5482.2158)); - assertEquals(14.661551142893833, Math.log10(458723662312872.125782332587)); - assertEquals(-0.9083828622192334, Math.log10(0.12348583358871)); - assertEquals(308.25471555991675, Math.log10(Double.MAX_VALUE)); - assertEquals(-323.3062153431158, Math.log10(Double.MIN_VALUE)); - } - - /** - * @tests java.lang.Math#log1p(double) - */ - public void test_log1p_D() { - // Test for special cases - assertTrue("Should return NaN", Double.isNaN(Math.log1p(Double.NaN))); - assertTrue("Should return NaN", Double.isNaN(Math.log1p(-32.0482175))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.log1p(Double.POSITIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math - .log1p(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(Math.log1p(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(Math.log1p(-0.0))); - - assertEquals("Should return -0.2941782295312541", -0.2941782295312541, - Math.log1p(-0.254856327), 0D); - assertEquals("Should return 7.368050685564151", 7.368050685564151, Math - .log1p(1583.542), 0D); - assertEquals("Should return 0.4633708685409921", 0.4633708685409921, - Math.log1p(0.5894227), 0D); - assertEquals("Should return 709.782712893384", 709.782712893384, Math - .log1p(Double.MAX_VALUE), 0D); - assertEquals("Should return Double.MIN_VALUE", Double.MIN_VALUE, Math - .log1p(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.Math#max(double, double) - */ - public void test_maxDD() { - // Test for method double java.lang.Math.max(double, double) - assertEquals("Incorrect double max value", 1908897.6000089, Math.max(-1908897.6000089, - 1908897.6000089), 0D); - assertEquals("Incorrect double max value", - 1908897.6000089, Math.max(2.0, 1908897.6000089), 0D); - assertEquals("Incorrect double max value", -2.0, Math.max(-2.0, - -1908897.6000089), 0D); - - // Compare toString representations here since -0.0 = +0.0, and - // NaN != NaN and we need to distinguish - assertEquals("Max failed for NaN", - Double.toString(Double.NaN), Double.toString(Math.max(Double.NaN, 42.0d))); - assertEquals("Max failed for NaN", - Double.toString(Double.NaN), Double.toString(Math.max(42.0d, Double.NaN))); - assertEquals("Max failed for 0.0", - Double.toString(+0.0d), Double.toString(Math.max(+0.0d, -0.0d))); - assertEquals("Max failed for 0.0", - Double.toString(+0.0d), Double.toString(Math.max(-0.0d, +0.0d))); - assertEquals("Max failed for -0.0d", - Double.toString(-0.0d), Double.toString(Math.max(-0.0d, -0.0d))); - assertEquals("Max failed for 0.0", - Double.toString(+0.0d), Double.toString(Math.max(+0.0d, +0.0d))); - } - - /** - * @tests java.lang.Math#max(float, float) - */ - public void test_maxFF() { - // Test for method float java.lang.Math.max(float, float) - assertTrue("Incorrect float max value", Math.max(-1908897.600f, - 1908897.600f) == 1908897.600f); - assertTrue("Incorrect float max value", - Math.max(2.0f, 1908897.600f) == 1908897.600f); - assertTrue("Incorrect float max value", - Math.max(-2.0f, -1908897.600f) == -2.0f); - - // Compare toString representations here since -0.0 = +0.0, and - // NaN != NaN and we need to distinguish - assertEquals("Max failed for NaN", - Float.toString(Float.NaN), Float.toString(Math.max(Float.NaN, 42.0f))); - assertEquals("Max failed for NaN", - Float.toString(Float.NaN), Float.toString(Math.max(42.0f, Float.NaN))); - assertEquals("Max failed for 0.0", - Float.toString(+0.0f), Float.toString(Math.max(+0.0f, -0.0f))); - assertEquals("Max failed for 0.0", - Float.toString(+0.0f), Float.toString(Math.max(-0.0f, +0.0f))); - assertEquals("Max failed for -0.0f", - Float.toString(-0.0f), Float.toString(Math.max(-0.0f, -0.0f))); - assertEquals("Max failed for 0.0", - Float.toString(+0.0f), Float.toString(Math.max(+0.0f, +0.0f))); - } - - /** - * @tests java.lang.Math#max(int, int) - */ - public void test_maxII() { - // Test for method int java.lang.Math.max(int, int) - assertEquals("Incorrect int max value", - 19088976, Math.max(-19088976, 19088976)); - assertEquals("Incorrect int max value", - 19088976, Math.max(20, 19088976)); - assertEquals("Incorrect int max value", -20, Math.max(-20, -19088976)); - } - - /** - * @tests java.lang.Math#max(long, long) - */ - public void test_maxJJ() { - // Test for method long java.lang.Math.max(long, long) - assertEquals("Incorrect long max value", 19088976000089L, Math.max(-19088976000089L, - 19088976000089L)); - assertEquals("Incorrect long max value", - 19088976000089L, Math.max(20, 19088976000089L)); - assertEquals("Incorrect long max value", - -20, Math.max(-20, -19088976000089L)); - } - - /** - * @tests java.lang.Math#min(double, double) - */ - public void test_minDD() { - // Test for method double java.lang.Math.min(double, double) - assertEquals("Incorrect double min value", -1908897.6000089, Math.min(-1908897.6000089, - 1908897.6000089), 0D); - assertEquals("Incorrect double min value", - 2.0, Math.min(2.0, 1908897.6000089), 0D); - assertEquals("Incorrect double min value", -1908897.6000089, Math.min(-2.0, - -1908897.6000089), 0D); - assertEquals("Incorrect double min value", 1.0d, Math.min(1.0d, 1.0d)); - - // Compare toString representations here since -0.0 = +0.0, and - // NaN != NaN and we need to distinguish - assertEquals("Min failed for NaN", - Double.toString(Double.NaN), Double.toString(Math.min(Double.NaN, 42.0d))); - assertEquals("Min failed for NaN", - Double.toString(Double.NaN), Double.toString(Math.min(42.0d, Double.NaN))); - assertEquals("Min failed for -0.0", - Double.toString(-0.0d), Double.toString(Math.min(+0.0d, -0.0d))); - assertEquals("Min failed for -0.0", - Double.toString(-0.0d), Double.toString(Math.min(-0.0d, +0.0d))); - assertEquals("Min failed for -0.0d", - Double.toString(-0.0d), Double.toString(Math.min(-0.0d, -0.0d))); - assertEquals("Min failed for 0.0", - Double.toString(+0.0d), Double.toString(Math.min(+0.0d, +0.0d))); - } - - /** - * @tests java.lang.Math#min(float, float) - */ - public void test_minFF() { - // Test for method float java.lang.Math.min(float, float) - assertTrue("Incorrect float min value", Math.min(-1908897.600f, - 1908897.600f) == -1908897.600f); - assertTrue("Incorrect float min value", - Math.min(2.0f, 1908897.600f) == 2.0f); - assertTrue("Incorrect float min value", - Math.min(-2.0f, -1908897.600f) == -1908897.600f); - assertEquals("Incorrect float min value", 1.0f, Math.min(1.0f, 1.0f)); - - // Compare toString representations here since -0.0 = +0.0, and - // NaN != NaN and we need to distinguish - assertEquals("Min failed for NaN", - Float.toString(Float.NaN), Float.toString(Math.min(Float.NaN, 42.0f))); - assertEquals("Min failed for NaN", - Float.toString(Float.NaN), Float.toString(Math.min(42.0f, Float.NaN))); - assertEquals("Min failed for -0.0", - Float.toString(-0.0f), Float.toString(Math.min(+0.0f, -0.0f))); - assertEquals("Min failed for -0.0", - Float.toString(-0.0f), Float.toString(Math.min(-0.0f, +0.0f))); - assertEquals("Min failed for -0.0f", - Float.toString(-0.0f), Float.toString(Math.min(-0.0f, -0.0f))); - assertEquals("Min failed for 0.0", - Float.toString(+0.0f), Float.toString(Math.min(+0.0f, +0.0f))); - } - - /** - * @tests java.lang.Math#min(int, int) - */ - public void test_minII() { - // Test for method int java.lang.Math.min(int, int) - assertEquals("Incorrect int min value", - -19088976, Math.min(-19088976, 19088976)); - assertEquals("Incorrect int min value", 20, Math.min(20, 19088976)); - assertEquals("Incorrect int min value", - -19088976, Math.min(-20, -19088976)); - - } - - /** - * @tests java.lang.Math#min(long, long) - */ - public void test_minJJ() { - // Test for method long java.lang.Math.min(long, long) - assertEquals("Incorrect long min value", -19088976000089L, Math.min(-19088976000089L, - 19088976000089L)); - assertEquals("Incorrect long min value", - 20, Math.min(20, 19088976000089L)); - assertEquals("Incorrect long min value", - -19088976000089L, Math.min(-20, -19088976000089L)); - } - - /** - * start number cases for test_nextAfter_DD in MathTest/StrictMathTest - * NEXTAFTER_DD_START_CASES[i][0] is the start number - * NEXTAFTER_DD_START_CASES[i][1] is the nextUp of start number - * NEXTAFTER_DD_START_CASES[i][2] is the nextDown of start number - */ - static final double NEXTAFTER_DD_START_CASES[][] = new double[][] { - { 3.4, 3.4000000000000004, 3.3999999999999995 }, - { -3.4, -3.3999999999999995, -3.4000000000000004 }, - { 3.4233E109, 3.4233000000000005E109, 3.4232999999999996E109 }, - { -3.4233E109, -3.4232999999999996E109, -3.4233000000000005E109 }, - { +0.0, Double.MIN_VALUE, -Double.MIN_VALUE }, - { 0.0, Double.MIN_VALUE, -Double.MIN_VALUE }, - { -0.0, Double.MIN_VALUE, -Double.MIN_VALUE }, - { Double.MIN_VALUE, 1.0E-323, +0.0 }, - { -Double.MIN_VALUE, -0.0, -1.0E-323 }, - { Double.MIN_NORMAL, 2.225073858507202E-308, 2.225073858507201E-308 }, - { -Double.MIN_NORMAL, -2.225073858507201E-308, - -2.225073858507202E-308 }, - { Double.MAX_VALUE, Double.POSITIVE_INFINITY, - 1.7976931348623155E308 }, - { -Double.MAX_VALUE, -1.7976931348623155E308, - Double.NEGATIVE_INFINITY }, - { Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, - Double.MAX_VALUE }, - { Double.NEGATIVE_INFINITY, -Double.MAX_VALUE, - Double.NEGATIVE_INFINITY } }; - - /** - * direction number cases for test_nextAfter_DD/test_nextAfter_FD in - * MathTest/StrictMathTest - */ - static final double NEXTAFTER_DD_FD_DIRECTION_CASES[] = new double[] { - Double.POSITIVE_INFINITY, Double.MAX_VALUE, 8.8, 3.4, 1.4, - Double.MIN_NORMAL, Double.MIN_NORMAL / 2, Double.MIN_VALUE, +0.0, - 0.0, -0.0, -Double.MIN_VALUE, -Double.MIN_NORMAL / 2, - -Double.MIN_NORMAL, -1.4, -3.4, -8.8, -Double.MAX_VALUE, - Double.NEGATIVE_INFINITY }; - - /** - * @tests {@link java.lang.Math#nextAfter(double, double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextAfter_DD() { - // test for most cases without exception - for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { - final double start = NEXTAFTER_DD_START_CASES[i][0]; - final long nextUpBits = Double - .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][1]); - final long nextDownBits = Double - .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][2]); - - for (int j = 0; j < NEXTAFTER_DD_FD_DIRECTION_CASES.length; j++) { - final double direction = NEXTAFTER_DD_FD_DIRECTION_CASES[j]; - final long resultBits = Double.doubleToLongBits(Math.nextAfter( - start, direction)); - final long directionBits = Double.doubleToLongBits(direction); - if (direction > start) { - assertEquals("Result should be next up-number.", - nextUpBits, resultBits); - } else if (direction < start) { - assertEquals("Result should be next down-number.", - nextDownBits, resultBits); - } else { - assertEquals("Result should be direction.", directionBits, - resultBits); - } - } - } - - // test for cases with NaN - for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { - assertTrue("The result should be NaN.", Double.isNaN(Math - .nextAfter(NEXTAFTER_DD_START_CASES[i][0], Double.NaN))); - } - for (int i = 0; i < NEXTAFTER_DD_FD_DIRECTION_CASES.length; i++) { - assertTrue("The result should be NaN.", Double.isNaN(Math - .nextAfter(Double.NaN, NEXTAFTER_DD_FD_DIRECTION_CASES[i]))); - } - assertTrue("The result should be NaN.", Double.isNaN(Math.nextAfter( - Double.NaN, Double.NaN))); - - // test for exception - try { - Math.nextAfter((Double) null, 2.3); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.nextAfter(2.3, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.nextAfter((Double) null, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * start number cases for test_nextAfter_FD in MathTest/StrictMathTest - * NEXTAFTER_FD_START_CASES[i][0] is the start number - * NEXTAFTER_FD_START_CASES[i][1] is the nextUp of start number - * NEXTAFTER_FD_START_CASES[i][2] is the nextDown of start number - */ - static final float NEXTAFTER_FD_START_CASES[][] = new float[][] { - { 3.4f, 3.4000003f, 3.3999999f }, - { -3.4f, -3.3999999f, -3.4000003f }, - { 3.4233E19f, 3.4233002E19f, 3.4232998E19f }, - { -3.4233E19f, -3.4232998E19f, -3.4233002E19f }, - { +0.0f, Float.MIN_VALUE, -Float.MIN_VALUE }, - { 0.0f, Float.MIN_VALUE, -Float.MIN_VALUE }, - { -0.0f, Float.MIN_VALUE, -Float.MIN_VALUE }, - { Float.MIN_VALUE, 2.8E-45f, +0.0f }, - { -Float.MIN_VALUE, -0.0f, -2.8E-45f }, - { Float.MIN_NORMAL, 1.1754945E-38f, 1.1754942E-38f }, - { -Float.MIN_NORMAL, -1.1754942E-38f, -1.1754945E-38f }, - { Float.MAX_VALUE, Float.POSITIVE_INFINITY, 3.4028233E38f }, - { -Float.MAX_VALUE, -3.4028233E38f, Float.NEGATIVE_INFINITY }, - { Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY, Float.MAX_VALUE }, - { Float.NEGATIVE_INFINITY, -Float.MAX_VALUE, - Float.NEGATIVE_INFINITY } }; - - /** - * @tests {@link java.lang.Math#nextAfter(float, double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextAfter_FD() { - // test for most cases without exception - for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { - final float start = NEXTAFTER_FD_START_CASES[i][0]; - final int nextUpBits = Float - .floatToIntBits(NEXTAFTER_FD_START_CASES[i][1]); - final int nextDownBits = Float - .floatToIntBits(NEXTAFTER_FD_START_CASES[i][2]); - - for (int j = 0; j < NEXTAFTER_DD_FD_DIRECTION_CASES.length; j++) { - final double direction = NEXTAFTER_DD_FD_DIRECTION_CASES[j]; - final int resultBits = Float.floatToIntBits(Math.nextAfter( - start, direction)); - if (direction > start) { - assertEquals("Result should be next up-number.", - nextUpBits, resultBits); - } else if (direction < start) { - assertEquals("Result should be next down-number.", - nextDownBits, resultBits); - } else { - final int equivalentBits = Float.floatToIntBits(new Float( - direction)); - assertEquals( - "Result should be a number equivalent to direction.", - equivalentBits, resultBits); - } - } - } - - // test for cases with NaN - for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { - assertTrue("The result should be NaN.", Float.isNaN(Math.nextAfter( - NEXTAFTER_FD_START_CASES[i][0], Float.NaN))); - } - for (int i = 0; i < NEXTAFTER_DD_FD_DIRECTION_CASES.length; i++) { - assertTrue("The result should be NaN.", Float.isNaN(Math.nextAfter( - Float.NaN, NEXTAFTER_DD_FD_DIRECTION_CASES[i]))); - } - assertTrue("The result should be NaN.", Float.isNaN(Math.nextAfter( - Float.NaN, Float.NaN))); - - // test for exception - try { - Math.nextAfter((Float) null, 2.3); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.nextAfter(2.3, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.nextAfter((Float) null, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.Math#nextUp(double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextUp_D() { - // This method is semantically equivalent to nextAfter(d, - // Double.POSITIVE_INFINITY), - // so we use the data of test_nextAfter_DD - for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { - final double start = NEXTAFTER_DD_START_CASES[i][0]; - final long nextUpBits = Double - .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][1]); - final long resultBits = Double.doubleToLongBits(Math.nextUp(start)); - assertEquals("Result should be next up-number.", nextUpBits, - resultBits); - } - - // test for cases with NaN - assertTrue("The result should be NaN.", Double.isNaN(Math - .nextUp(Double.NaN))); - - // test for exception - try { - Math.nextUp((Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.Math#nextUp(float)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextUp_F() { - // This method is semantically equivalent to nextAfter(f, - // Float.POSITIVE_INFINITY), - // so we use the data of test_nextAfter_FD - for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { - final float start = NEXTAFTER_FD_START_CASES[i][0]; - final int nextUpBits = Float - .floatToIntBits(NEXTAFTER_FD_START_CASES[i][1]); - final int resultBits = Float.floatToIntBits(Math.nextUp(start)); - assertEquals("Result should be next up-number.", nextUpBits, - resultBits); - } - - // test for cases with NaN - assertTrue("The result should be NaN.", Float.isNaN(Math - .nextUp(Float.NaN))); - - // test for exception - try { - Math.nextUp((Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.Math#pow(double, double) - */ - public void test_powDD() { - // Test for method double java.lang.Math.pow(double, double) - double NZERO = longTodouble(doubleTolong(0.0) ^ 0x8000000000000000L); - double p1 = 1.0; - double p2 = 2.0; - double p3 = 3.0; - double p4 = 4.0; - double p5 = 5.0; - double p6 = 6.0; - double p7 = 7.0; - double p8 = 8.0; - double p9 = 9.0; - double p10 = 10.0; - double p11 = 11.0; - double p12 = 12.0; - double p13 = 13.0; - double p14 = 14.0; - double p15 = 15.0; - double p16 = 16.0; - double[] values = { p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, - p13, p14, p15, p16 }; - - for (int x = 0; x < values.length; x++) { - double dval = values[x]; - double nagateDval = negateDouble(dval); - if (nagateDval == Double.NaN) { - continue; - } - - // If the second argument is positive or negative zero, then the - // result is 1.0. - assertEquals("Result should be Math.pow(" + dval - + ",-0.0)=+1.0", 1.0, Math.pow(dval, NZERO)); - assertEquals("Result should be Math.pow(" + nagateDval - + ",-0.0)=+1.0", 1.0, Math.pow(nagateDval, NZERO)); - assertEquals("Result should be Math.pow(" + dval - + ",+0.0)=+1.0", 1.0, Math.pow(dval, +0.0)); - assertEquals("Result should be Math.pow(" + nagateDval - + ",+0.0)=+1.0", 1.0, Math.pow(nagateDval, +0.0)); - - // If the second argument is 1.0, then the result is the same as the - // first argument. - assertEquals("Result should be Math.pow(" + dval + "," + 1.0 + ")=" - + dval, dval, Math.pow(dval, 1.0)); - assertEquals("Result should be Math.pow(" + nagateDval + "," + 1.0 - + ")=" + nagateDval, nagateDval, Math.pow(nagateDval, 1.0)); - - // If the second argument is NaN, then the result is NaN. - assertEquals("Result should be Math.pow(" + dval + "," + Double.NaN - + ")=" + Double.NaN, Double.NaN, Math.pow(dval, Double.NaN)); - assertEquals("Result should be Math.pow(" + nagateDval + "," - + Double.NaN + ")=" + Double.NaN, Double.NaN, Math.pow(nagateDval, - Double.NaN)); - - if (dval > 1) { - // If the first argument is NaN and the second argument is - // nonzero, - // then the result is NaN. - assertEquals("Result should be Math.pow(" + Double.NaN + "," - + dval + ")=" + Double.NaN, Double.NaN, Math.pow(Double.NaN, dval)); - assertEquals("Result should be Math.pow(" + Double.NaN + "," - + nagateDval + ")=" + Double.NaN, Double.NaN, Math.pow(Double.NaN, - nagateDval)); - - /* - * If the first argument is positive zero and the second - * argument is greater than zero, or the first argument is - * positive infinity and the second argument is less than zero, - * then the result is positive zero. - */ - assertEquals("Result should be Math.pow(" + 0.0 + "," + dval - + ")=" + 0.0, +0.0, Math.pow(0.0, dval)); - assertEquals("Result should be Math.pow(" - + Double.POSITIVE_INFINITY + "," + nagateDval + ")=" - + 0.0, +0.0, Math.pow(Double.POSITIVE_INFINITY, nagateDval)); - - /* - * If the first argument is positive zero and the second - * argument is less than zero, or the first argument is positive - * infinity and the second argument is greater than zero, then - * the result is positive infinity. - */ - assertEquals("Result should be Math.pow(" + 0.0 + "," - + nagateDval + ")=" + Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY, - Math.pow(0.0, nagateDval)); - assertEquals("Result should be Math.pow(" - + Double.POSITIVE_INFINITY + "," + dval + ")=" - + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow( - Double.POSITIVE_INFINITY, dval)); - - // Not a finite odd integer - if (dval % 2 == 0) { - /* - * If the first argument is negative zero and the second - * argument is greater than zero but not a finite odd - * integer, or the first argument is negative infinity and - * the second argument is less than zero but not a finite - * odd integer, then the result is positive zero. - */ - assertEquals("Result should be Math.pow(" + NZERO + "," - + dval + ")=" + 0.0, +0.0, Math.pow(NZERO, dval)); - assertEquals("Result should be Math.pow(" - + Double.NEGATIVE_INFINITY + "," + nagateDval - + ")=" + 0.0, +0.0, Math.pow(Double.NEGATIVE_INFINITY, - nagateDval)); - - /* - * If the first argument is negative zero and the second - * argument is less than zero but not a finite odd integer, - * or the first argument is negative infinity and the second - * argument is greater than zero but not a finite odd - * integer, then the result is positive infinity. - */ - assertEquals("Result should be Math.pow(" + NZERO + "," - + nagateDval + ")=" + Double.POSITIVE_INFINITY,Double.POSITIVE_INFINITY, - Math.pow(NZERO, nagateDval)); - assertEquals("Result should be Math.pow(" - + Double.NEGATIVE_INFINITY + "," + dval + ")=" - + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow( - Double.NEGATIVE_INFINITY, dval)); - } - - // finite odd integer - if (dval % 2 != 0) { - /* - * If the first argument is negative zero and the second - * argument is a positive finite odd integer, or the first - * argument is negative infinity and the second argument is - * a negative finite odd integer, then the result is - * negative zero. - */ - assertEquals("Result should be Math.pow(" + NZERO + "," - + dval + ")=" + NZERO, NZERO, Math.pow(NZERO, dval)); - assertEquals("Result should be Math.pow(" - + Double.NEGATIVE_INFINITY + "," + nagateDval - + ")=" + NZERO, NZERO, Math.pow(Double.NEGATIVE_INFINITY, - nagateDval)); - /* - * If the first argument is negative zero and the second - * argument is a negative finite odd integer, or the first - * argument is negative infinity and the second argument is - * a positive finite odd integer then the result is negative - * infinity. - */ - assertEquals("Result should be Math.pow(" + NZERO + "," - + nagateDval + ")=" + Double.NEGATIVE_INFINITY,Double.NEGATIVE_INFINITY, - Math.pow(NZERO, nagateDval)); - assertEquals("Result should be Math.pow(" - + Double.NEGATIVE_INFINITY + "," + dval + ")=" - + Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, Math.pow( - Double.NEGATIVE_INFINITY, dval)); - } - - /** - * 1. If the first argument is finite and less than zero if the - * second argument is a finite even integer, the result is equal - * to the result of raising the absolute value of the first - * argument to the power of the second argument - * - * 2. if the second argument is a finite odd integer, the result is equal to the - * negative of the result of raising the absolute value of the - * first argument to the power of the second argument - * - * 3. if the second argument is finite and not an integer, then the result - * is NaN. - */ - for (int j = 1; j < values.length; j++) { - double jval = values[j]; - if (jval % 2.0 == 0.0) { - assertEquals("" + nagateDval + " " + jval, Math.pow( - dval, jval), Math.pow(nagateDval, jval)); - } else { - assertEquals("" + nagateDval + " " + jval, -1.0 - * Math.pow(dval, jval), Math.pow(nagateDval, - jval)); - } - assertEquals(Double.NaN, Math - .pow(nagateDval, jval / 0.5467)); - assertEquals(Double.NaN, Math.pow(nagateDval, -1.0 * jval - / 0.5467)); - } - } - - // If the absolute value of the first argument equals 1 and the - // second argument is infinite, then the result is NaN. - if (dval == 1) { - assertEquals("Result should be Math.pow(" + dval + "," - + Double.POSITIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math - .pow(dval, Double.POSITIVE_INFINITY)); - assertEquals("Result should be Math.pow(" + dval + "," - + Double.NEGATIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math - .pow(dval, Double.NEGATIVE_INFINITY)); - - assertEquals("Result should be Math.pow(" + nagateDval + "," - + Double.POSITIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math - .pow(nagateDval, Double.POSITIVE_INFINITY)); - assertEquals("Result should be Math.pow(" + nagateDval + "," - + Double.NEGATIVE_INFINITY + ")=" + Double.NaN, Double.NaN, Math - .pow(nagateDval, Double.NEGATIVE_INFINITY)); - } - - if (dval > 1) { - /* - * If the absolute value of the first argument is greater than 1 - * and the second argument is positive infinity, or the absolute - * value of the first argument is less than 1 and the second - * argument is negative infinity, then the result is positive - * infinity. - */ - assertEquals("Result should be Math.pow(" + dval + "," - + Double.POSITIVE_INFINITY + ")=" - + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow(dval, - Double.POSITIVE_INFINITY)); - - assertEquals("Result should be Math.pow(" + nagateDval + "," - + Double.NEGATIVE_INFINITY + ")=" - + Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY, Math.pow(-0.13456, - Double.NEGATIVE_INFINITY)); - - /* - * If the absolute value of the first argument is greater than 1 - * and the second argument is negative infinity, or the absolute - * value of the first argument is less than 1 and the second - * argument is positive infinity, then the result is positive - * zero. - */ - assertEquals("Result should be Math.pow(" + dval + "," - + Double.NEGATIVE_INFINITY + ")= +0.0", +0.0, Math.pow(dval, - Double.NEGATIVE_INFINITY)); - assertEquals("Result should be Math.pow(" + nagateDval + "," - + Double.POSITIVE_INFINITY + ")= +0.0", +0.0, Math.pow( - -0.13456, Double.POSITIVE_INFINITY)); - } - - assertEquals("Result should be Math.pow(" + 0.0 + "," + dval + ")=" - + 0.0, 0.0, Math.pow(0.0, dval)); - assertEquals("Result should be Math.pow(" + Double.NaN + "," + dval - + ")=" + Double.NaN, Double.NaN, Math.pow(Double.NaN, dval)); - } - assertTrue("pow returned incorrect value", - (long) Math.pow(2, 8) == 256l); - assertTrue("pow returned incorrect value", - Math.pow(2, -8) == 0.00390625d); - assertEquals("Incorrect root returned1", - 2, Math.sqrt(Math.pow(Math.sqrt(2), 4)), 0); - - assertEquals(Double.NEGATIVE_INFINITY, Math.pow(-10.0, 3.093403029238847E15)); - assertEquals(Double.POSITIVE_INFINITY, Math.pow(10.0, 3.093403029238847E15)); - } - - private double longTodouble(long longvalue) { - return Double.longBitsToDouble(longvalue); - } - - private long doubleTolong(double doublevalue) { - return Double.doubleToLongBits(doublevalue); - } - - private double negateDouble(double doublevalue) { - return doublevalue * -1.0; - } - - /** - * @tests java.lang.Math#rint(double) - */ - public void test_rintD() { - // Test for method double java.lang.Math.rint(double) - assertEquals("Failed to round properly - up to odd", - 3.0, Math.rint(2.9), 0D); - assertTrue("Failed to round properly - NaN", Double.isNaN(Math - .rint(Double.NaN))); - assertEquals("Failed to round properly down to even", - 2.0, Math.rint(2.1), 0D); - assertTrue("Failed to round properly " + 2.5 + " to even", Math - .rint(2.5) == 2.0); - assertTrue("Failed to round properly " + (+0.0d), - Math.rint(+0.0d) == +0.0d); - assertTrue("Failed to round properly " + (-0.0d), - Math.rint(-0.0d) == -0.0d); - } - - /** - * @tests java.lang.Math#round(double) - */ - public void test_roundD() { - // Test for method long java.lang.Math.round(double) - assertEquals("Incorrect rounding of a float", -91, Math.round(-90.89d)); - } - - /** - * @tests java.lang.Math#round(float) - */ - public void test_roundF() { - // Test for method int java.lang.Math.round(float) - assertEquals("Incorrect rounding of a float", -91, Math.round(-90.89f)); - } - - /** - * @tests {@link java.lang.Math#scalb(double, int)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_scalb_DI() { - // result is normal - assertEquals(4.1422946304E7, Math.scalb(1.2345, 25)); - assertEquals(3.679096698760986E-8, Math.scalb(1.2345, -25)); - assertEquals(1.2345, Math.scalb(1.2345, 0)); - assertEquals(7868514.304, Math.scalb(0.2345, 25)); - - double normal = Math.scalb(0.2345, -25); - assertEquals(6.98864459991455E-9, normal); - // precision kept - assertEquals(0.2345, Math.scalb(normal, 25)); - - assertEquals(0.2345, Math.scalb(0.2345, 0)); - assertEquals(-4.1422946304E7, Math.scalb(-1.2345, 25)); - assertEquals(-6.98864459991455E-9, Math.scalb(-0.2345, -25)); - assertEquals(2.0, Math.scalb(Double.MIN_NORMAL / 2, 1024)); - assertEquals(64.0, Math.scalb(Double.MIN_VALUE, 1080)); - assertEquals(234, Math.getExponent(Math.scalb(1.0, 234))); - assertEquals(3.9999999999999996, Math.scalb(Double.MAX_VALUE, - Double.MIN_EXPONENT)); - - // result is near infinity - double halfMax = Math.scalb(1.0, Double.MAX_EXPONENT); - assertEquals(8.98846567431158E307, halfMax); - assertEquals(Double.MAX_VALUE, halfMax - Math.ulp(halfMax) + halfMax); - assertEquals(Double.POSITIVE_INFINITY, halfMax + halfMax); - assertEquals(1.7976931348623155E308, Math.scalb(1.0 - Math.ulp(1.0), - Double.MAX_EXPONENT + 1)); - assertEquals(Double.POSITIVE_INFINITY, Math.scalb(1.0 - Math.ulp(1.0), - Double.MAX_EXPONENT + 2)); - - halfMax = Math.scalb(-1.0, Double.MAX_EXPONENT); - assertEquals(-8.98846567431158E307, halfMax); - assertEquals(-Double.MAX_VALUE, halfMax + Math.ulp(halfMax) + halfMax); - assertEquals(Double.NEGATIVE_INFINITY, halfMax + halfMax); - - assertEquals(Double.POSITIVE_INFINITY, Math.scalb(0.345, 1234)); - assertEquals(Double.POSITIVE_INFINITY, Math.scalb(44.345E102, 934)); - assertEquals(Double.NEGATIVE_INFINITY, Math.scalb(-44.345E102, 934)); - - assertEquals(Double.POSITIVE_INFINITY, Math.scalb( - Double.MIN_NORMAL / 2, 4000)); - assertEquals(Double.POSITIVE_INFINITY, Math.scalb(Double.MIN_VALUE, - 8000)); - assertEquals(Double.POSITIVE_INFINITY, Math.scalb(Double.MAX_VALUE, 1)); - assertEquals(Double.POSITIVE_INFINITY, Math.scalb( - Double.POSITIVE_INFINITY, 0)); - assertEquals(Double.POSITIVE_INFINITY, Math.scalb( - Double.POSITIVE_INFINITY, -1)); - assertEquals(Double.NEGATIVE_INFINITY, Math.scalb( - Double.NEGATIVE_INFINITY, -1)); - assertEquals(Double.NEGATIVE_INFINITY, Math.scalb( - Double.NEGATIVE_INFINITY, Double.MIN_EXPONENT)); - - // result is subnormal/zero - long posZeroBits = Double.doubleToLongBits(+0.0); - long negZeroBits = Double.doubleToLongBits(-0.0); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb(+0.0, - Integer.MAX_VALUE))); - assertEquals(posZeroBits, Double.doubleToLongBits(Math - .scalb(+0.0, -123))); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb(+0.0, 0))); - assertEquals(negZeroBits, Double - .doubleToLongBits(Math.scalb(-0.0, 123))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb(-0.0, - Integer.MIN_VALUE))); - - assertEquals(Double.MIN_VALUE, Math.scalb(1.0, -1074)); - assertEquals(posZeroBits, Double.doubleToLongBits(Math - .scalb(1.0, -1075))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb(-1.0, - -1075))); - - // precision lost - assertEquals(Math.scalb(21.405, -1078), Math.scalb(21.405, -1079)); - assertEquals(Double.MIN_VALUE, Math.scalb(21.405, -1079)); - assertEquals(-Double.MIN_VALUE, Math.scalb(-21.405, -1079)); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb(21.405, - -1080))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb(-21.405, - -1080))); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( - Double.MIN_VALUE, -1))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( - -Double.MIN_VALUE, -1))); - assertEquals(Double.MIN_VALUE, Math.scalb(Double.MIN_NORMAL, -52)); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( - Double.MIN_NORMAL, -53))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( - -Double.MIN_NORMAL, -53))); - assertEquals(Double.MIN_VALUE, Math.scalb(Double.MAX_VALUE, -2098)); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( - Double.MAX_VALUE, -2099))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( - -Double.MAX_VALUE, -2099))); - assertEquals(Double.MIN_VALUE, Math.scalb(Double.MIN_NORMAL / 3, -51)); - assertEquals(posZeroBits, Double.doubleToLongBits(Math.scalb( - Double.MIN_NORMAL / 3, -52))); - assertEquals(negZeroBits, Double.doubleToLongBits(Math.scalb( - -Double.MIN_NORMAL / 3, -52))); - double subnormal = Math.scalb(Double.MIN_NORMAL / 3, -25); - assertEquals(2.2104123E-316, subnormal); - // precision lost - assertFalse(Double.MIN_NORMAL / 3 == Math.scalb(subnormal, 25)); - - // NaN - assertTrue(Double.isNaN(Math.scalb(Double.NaN, 1))); - assertTrue(Double.isNaN(Math.scalb(Double.NaN, 0))); - assertTrue(Double.isNaN(Math.scalb(Double.NaN, -120))); - - assertEquals(1283457024, Double.doubleToLongBits(Math.scalb( - Double.MIN_VALUE * 153, 23))); - assertEquals(-9223372035571318784L, Double.doubleToLongBits(Math.scalb( - -Double.MIN_VALUE * 153, 23))); - assertEquals(36908406321184768L, Double.doubleToLongBits(Math.scalb( - Double.MIN_VALUE * 153, 52))); - assertEquals(-9186463630533591040L, Double.doubleToLongBits(Math.scalb( - -Double.MIN_VALUE * 153, 52))); - - // test for exception - try { - Math.scalb((Double) null, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.scalb(1.0, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.scalb((Double) null, 1); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - - long b1em1022 = 0x0010000000000000L; // bit representation of - // Double.MIN_NORMAL - long b1em1023 = 0x0008000000000000L; // bit representation of half of - // Double.MIN_NORMAL - // assert exact identity - assertEquals(b1em1023, Double.doubleToLongBits(Math.scalb(Double - .longBitsToDouble(b1em1022), -1))); - } - - /** - * @tests {@link java.lang.Math#scalb(float, int)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_scalb_FI() { - // result is normal - assertEquals(4.1422946304E7f, Math.scalb(1.2345f, 25)); - assertEquals(3.679096698760986E-8f, Math.scalb(1.2345f, -25)); - assertEquals(1.2345f, Math.scalb(1.2345f, 0)); - assertEquals(7868514.304f, Math.scalb(0.2345f, 25)); - - float normal = Math.scalb(0.2345f, -25); - assertEquals(6.98864459991455E-9f, normal); - // precision kept - assertEquals(0.2345f, Math.scalb(normal, 25)); - - assertEquals(0.2345f, Math.scalb(0.2345f, 0)); - assertEquals(-4.1422946304E7f, Math.scalb(-1.2345f, 25)); - assertEquals(-6.98864459991455E-9f, Math.scalb(-0.2345f, -25)); - assertEquals(2.0f, Math.scalb(Float.MIN_NORMAL / 2, 128)); - assertEquals(64.0f, Math.scalb(Float.MIN_VALUE, 155)); - assertEquals(34, Math.getExponent(Math.scalb(1.0f, 34))); - assertEquals(3.9999998f, Math - .scalb(Float.MAX_VALUE, Float.MIN_EXPONENT)); - - // result is near infinity - float halfMax = Math.scalb(1.0f, Float.MAX_EXPONENT); - assertEquals(1.7014118E38f, halfMax); - assertEquals(Float.MAX_VALUE, halfMax - Math.ulp(halfMax) + halfMax); - assertEquals(Float.POSITIVE_INFINITY, halfMax + halfMax); - assertEquals(3.4028233E38f, Math.scalb(1.0f - Math.ulp(1.0f), - Float.MAX_EXPONENT + 1)); - assertEquals(Float.POSITIVE_INFINITY, Math.scalb(1.0f - Math.ulp(1.0f), - Float.MAX_EXPONENT + 2)); - - halfMax = Math.scalb(-1.0f, Float.MAX_EXPONENT); - assertEquals(-1.7014118E38f, halfMax); - assertEquals(-Float.MAX_VALUE, halfMax + Math.ulp(halfMax) + halfMax); - assertEquals(Float.NEGATIVE_INFINITY, halfMax + halfMax); - - assertEquals(Float.POSITIVE_INFINITY, Math.scalb(0.345f, 1234)); - assertEquals(Float.POSITIVE_INFINITY, Math.scalb(44.345E10f, 934)); - assertEquals(Float.NEGATIVE_INFINITY, Math.scalb(-44.345E10f, 934)); - - assertEquals(Float.POSITIVE_INFINITY, Math.scalb(Float.MIN_NORMAL / 2, - 400)); - assertEquals(Float.POSITIVE_INFINITY, Math.scalb(Float.MIN_VALUE, 800)); - assertEquals(Float.POSITIVE_INFINITY, Math.scalb(Float.MAX_VALUE, 1)); - assertEquals(Float.POSITIVE_INFINITY, Math.scalb( - Float.POSITIVE_INFINITY, 0)); - assertEquals(Float.POSITIVE_INFINITY, Math.scalb( - Float.POSITIVE_INFINITY, -1)); - assertEquals(Float.NEGATIVE_INFINITY, Math.scalb( - Float.NEGATIVE_INFINITY, -1)); - assertEquals(Float.NEGATIVE_INFINITY, Math.scalb( - Float.NEGATIVE_INFINITY, Float.MIN_EXPONENT)); - - // result is subnormal/zero - int posZeroBits = Float.floatToIntBits(+0.0f); - int negZeroBits = Float.floatToIntBits(-0.0f); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(+0.0f, - Integer.MAX_VALUE))); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(+0.0f, -123))); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(+0.0f, 0))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-0.0f, 123))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-0.0f, - Integer.MIN_VALUE))); - - assertEquals(Float.MIN_VALUE, Math.scalb(1.0f, -149)); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb(1.0f, -150))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-1.0f, -150))); - - // precision lost - assertEquals(Math.scalb(21.405f, -154), Math.scalb(21.405f, -153)); - assertEquals(Float.MIN_VALUE, Math.scalb(21.405f, -154)); - assertEquals(-Float.MIN_VALUE, Math.scalb(-21.405f, -154)); - assertEquals(posZeroBits, Float.floatToIntBits(Math - .scalb(21.405f, -155))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb(-21.405f, - -155))); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( - Float.MIN_VALUE, -1))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( - -Float.MIN_VALUE, -1))); - assertEquals(Float.MIN_VALUE, Math.scalb(Float.MIN_NORMAL, -23)); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( - Float.MIN_NORMAL, -24))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( - -Float.MIN_NORMAL, -24))); - assertEquals(Float.MIN_VALUE, Math.scalb(Float.MAX_VALUE, -277)); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( - Float.MAX_VALUE, -278))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( - -Float.MAX_VALUE, -278))); - assertEquals(Float.MIN_VALUE, Math.scalb(Float.MIN_NORMAL / 3, -22)); - assertEquals(posZeroBits, Float.floatToIntBits(Math.scalb( - Float.MIN_NORMAL / 3, -23))); - assertEquals(negZeroBits, Float.floatToIntBits(Math.scalb( - -Float.MIN_NORMAL / 3, -23))); - float subnormal = Math.scalb(Float.MIN_NORMAL / 3, -11); - assertEquals(1.913E-42f, subnormal); - // precision lost - assertFalse(Float.MIN_NORMAL / 3 == Math.scalb(subnormal, 11)); - - assertEquals(68747264, Float.floatToIntBits(Math.scalb( - Float.MIN_VALUE * 153, 23))); - assertEquals(-2078736384, Float.floatToIntBits(Math.scalb( - -Float.MIN_VALUE * 153, 23))); - - assertEquals(4896, Float.floatToIntBits(Math.scalb( - Float.MIN_VALUE * 153, 5))); - assertEquals(-2147478752, Float.floatToIntBits(Math.scalb( - -Float.MIN_VALUE * 153, 5))); - - // NaN - assertTrue(Float.isNaN(Math.scalb(Float.NaN, 1))); - assertTrue(Float.isNaN(Math.scalb(Float.NaN, 0))); - assertTrue(Float.isNaN(Math.scalb(Float.NaN, -120))); - - // test for exception - try { - Math.scalb((Float) null, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.scalb(1.0f, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - Math.scalb((Float) null, 1); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - - int b1em126 = 0x00800000; // bit representation of Float.MIN_NORMAL - int b1em127 = 0x00400000; // bit representation of half - // Float.MIN_NORMAL - // assert exact identity - assertEquals(b1em127, Float.floatToIntBits(Math.scalb(Float - .intBitsToFloat(b1em126), -1))); - } - - /** - * @tests java.lang.Math#signum(double) - */ - public void test_signum_D() { - assertTrue(Double.isNaN(Math.signum(Double.NaN))); - assertTrue(Double.isNaN(Math.signum(Double.NaN))); - assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math - .signum(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(Math.signum(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(Math.signum(-0.0))); - - assertEquals(1.0, Math.signum(253681.2187962), 0D); - assertEquals(-1.0, Math.signum(-125874693.56), 0D); - assertEquals(1.0, Math.signum(1.2587E-308), 0D); - assertEquals(-1.0, Math.signum(-1.2587E-308), 0D); - - assertEquals(1.0, Math.signum(Double.MAX_VALUE), 0D); - assertEquals(1.0, Math.signum(Double.MIN_VALUE), 0D); - assertEquals(-1.0, Math.signum(-Double.MAX_VALUE), 0D); - assertEquals(-1.0, Math.signum(-Double.MIN_VALUE), 0D); - assertEquals(1.0, Math.signum(Double.POSITIVE_INFINITY), 0D); - assertEquals(-1.0, Math.signum(Double.NEGATIVE_INFINITY), 0D); - } - - /** - * @tests java.lang.Math#signum(float) - */ - public void test_signum_F() { - assertTrue(Float.isNaN(Math.signum(Float.NaN))); - assertEquals(Float.floatToIntBits(0.0f), Float - .floatToIntBits(Math.signum(0.0f))); - assertEquals(Float.floatToIntBits(+0.0f), Float - .floatToIntBits(Math.signum(+0.0f))); - assertEquals(Float.floatToIntBits(-0.0f), Float - .floatToIntBits(Math.signum(-0.0f))); - - assertEquals(1.0f, Math.signum(253681.2187962f), 0f); - assertEquals(-1.0f, Math.signum(-125874693.56f), 0f); - assertEquals(1.0f, Math.signum(1.2587E-11f), 0f); - assertEquals(-1.0f, Math.signum(-1.2587E-11f), 0f); - - assertEquals(1.0f, Math.signum(Float.MAX_VALUE), 0f); - assertEquals(1.0f, Math.signum(Float.MIN_VALUE), 0f); - assertEquals(-1.0f, Math.signum(-Float.MAX_VALUE), 0f); - assertEquals(-1.0f, Math.signum(-Float.MIN_VALUE), 0f); - assertEquals(1.0f, Math.signum(Float.POSITIVE_INFINITY), 0f); - assertEquals(-1.0f, Math.signum(Float.NEGATIVE_INFINITY), 0f); - } - - /** - * @tests java.lang.Math#sin(double) - */ - public void test_sinD() { - // Test for method double java.lang.Math.sin(double) - assertEquals("Incorrect answer", 0.0, Math.sin(0), 0D); - assertEquals("Incorrect answer", 0.8414709848078965, Math.sin(1), 0D); - } - - /** - * @tests java.lang.Math#sinh(double) - */ - public void test_sinh_D() { - // Test for special situations - assertTrue("Should return NaN", Double.isNaN(Math.sinh(Double.NaN))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.sinh(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, Math.sinh(Double.NEGATIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math - .sinh(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(Math.sinh(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(Math.sinh(-0.0))); - - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.sinh(1234.56), 0D); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, Math.sinh(-1234.56), 0D); - assertEquals("Should return 1.0000000000001666E-6", - 1.0000000000001666E-6, Math.sinh(0.000001), 0D); - assertEquals("Should return -1.0000000000001666E-6", - -1.0000000000001666E-6, Math.sinh(-0.000001), 0D); - assertEquals("Should return 5.115386441963859", 5.115386441963859, Math - .sinh(2.33482), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, Math.sinh(Double.MAX_VALUE), 0D); - assertEquals("Should return 4.9E-324", 4.9E-324, Math - .sinh(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.Math#sqrt(double) - */ - public void test_sqrtD() { - // Test for method double java.lang.Math.sqrt(double) - assertEquals("Incorrect root returned2", 7, Math.sqrt(49), 0); - } - - /** - * @tests java.lang.Math#tan(double) - */ - public void test_tanD() { - // Test for method double java.lang.Math.tan(double) - assertEquals("Incorrect answer", 0.0, Math.tan(0), 0D); - assertEquals("Incorrect answer", 1.5574077246549023, Math.tan(1), 0D); - - } - - /** - * @tests java.lang.Math#tanh(double) - */ - public void test_tanh_D() { - // Test for special situations - assertTrue("Should return NaN", Double.isNaN(Math.tanh(Double.NaN))); - assertEquals("Should return +1.0", +1.0, Math - .tanh(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return -1.0", -1.0, Math - .tanh(Double.NEGATIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double.doubleToLongBits(Math - .tanh(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(Math.tanh(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(Math.tanh(-0.0))); - - assertEquals("Should return 1.0", 1.0, Math.tanh(1234.56), 0D); - assertEquals("Should return -1.0", -1.0, Math.tanh(-1234.56), 0D); - assertEquals("Should return 9.999999999996666E-7", - 9.999999999996666E-7, Math.tanh(0.000001), 0D); - assertEquals("Should return 0.981422884124941", 0.981422884124941, Math - .tanh(2.33482), 0D); - assertEquals("Should return 1.0", 1.0, Math.tanh(Double.MAX_VALUE), 0D); - assertEquals("Should return 4.9E-324", 4.9E-324, Math - .tanh(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.Math#random() - */ - public void test_random() { - // There isn't a place for these tests so just stick them here - assertEquals("Wrong value E", - 4613303445314885481L, Double.doubleToLongBits(Math.E)); - assertEquals("Wrong value PI", - 4614256656552045848L, Double.doubleToLongBits(Math.PI)); - - for (int i = 500; i >= 0; i--) { - double d = Math.random(); - assertTrue("Generated number is out of range: " + d, d >= 0.0 - && d < 1.0); - } - } - - /** - * @tests java.lang.Math#toRadians(double) - */ - public void test_toRadiansD() { - for (double d = 500; d >= 0; d -= 1.0) { - double converted = Math.toDegrees(Math.toRadians(d)); - assertTrue("Converted number not equal to original. d = " + d, - converted >= d * 0.99999999 && converted <= d * 1.00000001); - } - } - - /** - * @tests java.lang.Math#toDegrees(double) - */ - public void test_toDegreesD() { - for (double d = 500; d >= 0; d -= 1.0) { - double converted = Math.toRadians(Math.toDegrees(d)); - assertTrue("Converted number not equal to original. d = " + d, - converted >= d * 0.99999999 && converted <= d * 1.00000001); - } - } - - /** - * @tests java.lang.Math#ulp(double) - */ - @SuppressWarnings("boxing") - public void test_ulp_D() { - // Test for special cases - assertTrue("Should return NaN", Double.isNaN(Math.ulp(Double.NaN))); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, Math - .ulp(Double.POSITIVE_INFINITY), 0D); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, Math - .ulp(Double.NEGATIVE_INFINITY), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, Math - .ulp(0.0), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, Math - .ulp(+0.0), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, Math - .ulp(-0.0), 0D); - assertEquals("Returned incorrect value", Math.pow(2, 971), Math - .ulp(Double.MAX_VALUE), 0D); - assertEquals("Returned incorrect value", Math.pow(2, 971), Math - .ulp(-Double.MAX_VALUE), 0D); - - assertEquals("Returned incorrect value", Double.MIN_VALUE, Math - .ulp(Double.MIN_VALUE), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, Math - .ulp(-Double.MIN_VALUE), 0D); - - assertEquals("Returned incorrect value", 2.220446049250313E-16, Math - .ulp(1.0), 0D); - assertEquals("Returned incorrect value", 2.220446049250313E-16, Math - .ulp(-1.0), 0D); - assertEquals("Returned incorrect value", 2.2737367544323206E-13, Math - .ulp(1153.0), 0D); - } - - /** - * @tests java.lang.Math#ulp(float) - */ - @SuppressWarnings("boxing") - public void test_ulp_f() { - // Test for special cases - assertTrue("Should return NaN", Float.isNaN(Math.ulp(Float.NaN))); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, Math - .ulp(Float.POSITIVE_INFINITY), 0f); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, Math - .ulp(Float.NEGATIVE_INFINITY), 0f); - assertEquals("Returned incorrect value", Float.MIN_VALUE, Math - .ulp(0.0f), 0f); - assertEquals("Returned incorrect value", Float.MIN_VALUE, Math - .ulp(+0.0f), 0f); - assertEquals("Returned incorrect value", Float.MIN_VALUE, Math - .ulp(-0.0f), 0f); - assertEquals("Returned incorrect value", 2.028241E31f, Math - .ulp(Float.MAX_VALUE), 0f); - assertEquals("Returned incorrect value", 2.028241E31f, Math - .ulp(-Float.MAX_VALUE), 0f); - - assertEquals("Returned incorrect value", 1.4E-45f, Math - .ulp(Float.MIN_VALUE), 0f); - assertEquals("Returned incorrect value", 1.4E-45f, Math - .ulp(-Float.MIN_VALUE), 0f); - - assertEquals("Returned incorrect value", 1.1920929E-7f, Math.ulp(1.0f), - 0f); - assertEquals("Returned incorrect value", 1.1920929E-7f, - Math.ulp(-1.0f), 0f); - assertEquals("Returned incorrect value", 1.2207031E-4f, Math - .ulp(1153.0f), 0f); - assertEquals("Returned incorrect value", 5.6E-45f, Math - .ulp(9.403954E-38f), 0f); - } - - /** - * @tests {@link java.lang.Math#shiftIntBits(int, int)} - * - * @since 1.6 - */ - public void test_shiftIntBits_II() { - class Tuple { - public int result; - - public int value; - - public int factor; - - public Tuple(int result, int value, int factor) { - this.result = result; - this.value = value; - this.factor = factor; - } - } - final Tuple[] TUPLES = new Tuple[] { - // sub-normal to sub-normal - new Tuple(0x00000000, 0x00000001, -1), - // round to even - new Tuple(0x00000002, 0x00000003, -1), - // round to even - new Tuple(0x00000001, 0x00000005, -3), - // round to infinity - new Tuple(0x00000002, 0x0000000d, -3), - // round to infinity - - // normal to sub-normal - new Tuple(0x00000002, 0x01a00000, -24), - // round to even - new Tuple(0x00000004, 0x01e00000, -24), - // round to even - new Tuple(0x00000003, 0x01c80000, -24), - // round to infinity - new Tuple(0x00000004, 0x01e80000, -24), - // round to infinity - }; - for (int i = 0; i < TUPLES.length; ++i) { - Tuple tuple = TUPLES[i]; - assertEquals(tuple.result, Float.floatToIntBits(Math.scalb(Float - .intBitsToFloat(tuple.value), tuple.factor))); - assertEquals(tuple.result, Float.floatToIntBits(-Math.scalb(-Float - .intBitsToFloat(tuple.value), tuple.factor))); - } - } - - /** - * @tests {@link java.lang.Math#shiftLongBits(long, long)} - * - * Round result to nearest value on precision lost. - * - * @since 1.6 - */ - public void test_shiftLongBits_LL() { - class Tuple { - public long result; - - public long value; - - public int factor; - - public Tuple(long result, long value, int factor) { - this.result = result; - this.value = value; - this.factor = factor; - } - } - final Tuple[] TUPLES = new Tuple[] { - // sub-normal to sub-normal - new Tuple(0x00000000L, 0x00000001L, -1), - //round to even - new Tuple(0x00000002L, 0x00000003L, -1), - //round to even - new Tuple(0x00000001L, 0x00000005L, -3), - //round to infinity - new Tuple(0x00000002L, 0x0000000dL, -3), - //round to infinity - - // normal to sub-normal - new Tuple(0x0000000000000002L, 0x0034000000000000L, -53), // round to even - new Tuple(0x0000000000000004L, 0x003c000000000000L, -53), // round to even - new Tuple(0x0000000000000003L, 0x0035000000000000L, -53), // round to infinity - new Tuple(0x0000000000000004L, 0x003d000000000000L, -53), // round to infinity - }; - for (int i = 0; i < TUPLES.length; ++i) { - Tuple tuple = TUPLES[i]; - assertEquals(tuple.result, Double.doubleToLongBits(Math.scalb( - Double.longBitsToDouble(tuple.value), tuple.factor))); - assertEquals(tuple.result, Double.doubleToLongBits(-Math.scalb( - -Double.longBitsToDouble(tuple.value), tuple.factor))); - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockEnum.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockEnum.java deleted file mode 100644 index 147e7a8..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockEnum.java +++ /dev/null @@ -1,57 +0,0 @@ -/* 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 java.io.Serializable; - -class MockEnum implements Serializable { - private static final long serialVersionUID = -1678507713086705252L; - - enum Sample { - LARRY, MOE, CURLY - } - - enum Sample2 { - RED, BLUE, YELLO - } - - String str; - - int i; - - Sample2 samEnum; - - Sample larry = Sample.LARRY; - - MockEnum() { - str = "test"; - i = 99; - samEnum = Sample2.BLUE; - } - - public boolean equals(Object arg0) { - if (!(arg0 instanceof MockEnum)) { - return false; - } - MockEnum test = (MockEnum) arg0; - if (str.equals(test.str) && i == test.i && samEnum == test.samEnum) { - return true; - } - return false; - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockEnum2.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockEnum2.java deleted file mode 100644 index cd3a8b7..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockEnum2.java +++ /dev/null @@ -1,61 +0,0 @@ -/* 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 java.io.Serializable; - -class MockEnum2 implements Serializable { - - private static final long serialVersionUID = -4812214670022262730L; - - enum Sample { - LARRY, MOE, CURLY - } - - enum Sample2 { - RED, BLUE, YELLO - } - - String str; - - int i; - - Sample samEnum; - - Sample larry = Sample.LARRY; - - String myStr = "LARRY"; - - MockEnum2() { - str = "test"; - i = 99; - samEnum = larry; - } - - public boolean equals(Object arg0) { - if (!(arg0 instanceof MockEnum2)) { - return false; - } - MockEnum2 test = (MockEnum2) arg0; - if (str.equals(test.str) && i == test.i && samEnum == test.samEnum - && myStr.equals(test.myStr)) { - return true; - } - return false; - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockSecurityManager.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockSecurityManager.java deleted file mode 100644 index adbbedf..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MockSecurityManager.java +++ /dev/null @@ -1,69 +0,0 @@ -package org.apache.harmony.luni.tests.java.lang; - -import java.io.FilePermission; -import java.security.Permission; -import java.security.SecurityPermission; -import java.util.PropertyPermission; - -class MockSecurityManager extends SecurityManager { - - String deletedFile = "/"; - String readedFile = "/"; - String writedFile = "/"; - - public void setInCheck(boolean inCheck) { - super.inCheck = inCheck; - } - - @Override - public int classDepth(String name) { - return super.classDepth(name); - } - - @Override - public int classLoaderDepth() { - return super.classLoaderDepth(); - } - - @Override - public void checkPermission(Permission perm) { - if (perm.equals(new RuntimePermission("createSecurityManager")) || -// perm.equals(new AWTPermission("accessEventQueue")) || - perm.equals(new RuntimePermission("createClassLoader")) || - perm.equals(new FilePermission(deletedFile,"delete")) || - perm.equals(new FilePermission(readedFile,"read")) || - perm.equals(new PropertyPermission("*", "read,write")) || - perm.equals(new PropertyPermission("key", "read")) || - perm.equals(new SecurityPermission("getPolicy")) || -// perm.equals(new AWTPermission("accessClipboard")) || - perm.equals(new FilePermission(writedFile,"write"))) { - throw - new SecurityException("Unable to create Security Manager"); - } - } - - @Override - public ClassLoader currentClassLoader() { - return super.currentClassLoader(); - } - - @Override - public Class<?> currentLoadedClass() { - return super.currentLoadedClass(); - } - - @Override - public Class[] getClassContext() { - return super.getClassContext(); - } - - @Override - public boolean inClass(String name) { - return super.inClass(name); - } - - @Override - public boolean inClassLoader() { - return super.inClassLoader(); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MutableSecurityManager.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MutableSecurityManager.java deleted file mode 100644 index 36b8766..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/MutableSecurityManager.java +++ /dev/null @@ -1,102 +0,0 @@ -/* 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 java.net.SocketPermission; -import java.security.Permission; -import java.security.PermissionCollection; -import java.security.Permissions; - -class MutableSecurityManager extends SecurityManager { - - static final RuntimePermission SET_SECURITY_MANAGER = new RuntimePermission("setSecurityManager"); - - private PermissionCollection enabled; - - private PermissionCollection denied; - - public boolean isCheckAcceptCalled = false; - public boolean isCheckAccessThreadCalled = false; - public boolean isCheckAccessThreadGroupCalled = false; - - public MutableSecurityManager() { - super(); - this.enabled = new Permissions(); - } - - public MutableSecurityManager(Permission... permissions) { - this(); - for (int i = 0; i < permissions.length; i++) { - this.enabled.add(permissions[i]); - } - } - - void addPermission(Permission permission) { - enabled.add(permission); - } - - void clearPermissions() { - enabled = new Permissions(); - } - - void denyPermission(Permission p) { - if (denied == null) { - denied = p.newPermissionCollection(); - } - denied.add(p); - } - - @Override - public void checkPermission(Permission permission) - { - if (permission != null) { - if (denied != null && denied.implies(permission)){ - - throw new SecurityException("Denied " + permission); - } - - if (enabled.implies(permission)) { - return; - } - } - - super.checkPermission(permission); - } - - @Override - public void checkPermission(Permission permission, Object context) - { - if (permission != null) { - if (denied != null && denied.implies(permission)){ - - throw new SecurityException("Denied " + permission); - } - - if (enabled.implies(permission)) { - return; - } - } - - super.checkPermission(permission, context); - } - - // @Override - public void checkAccept(String host, int port) { - isCheckAcceptCalled = true; - super.checkAccept(host, port); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NegativeArraySizeExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NegativeArraySizeExceptionTest.java deleted file mode 100644 index 93b6dbd..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NegativeArraySizeExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NegativeArraySizeExceptionTest extends TestCase { - - /** - * @tests java.lang.NegativeArraySizeException#NegativeArraySizeException() - */ - public void test_Constructor() { - NegativeArraySizeException e = new NegativeArraySizeException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NegativeArraySizeException#NegativeArraySizeException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NegativeArraySizeException e = new NegativeArraySizeException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoClassDefFoundErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoClassDefFoundErrorTest.java deleted file mode 100644 index db7dced..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoClassDefFoundErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NoClassDefFoundErrorTest extends TestCase { - - /** - * @tests java.lang.NoClassDefFoundError#NoClassDefFoundError() - */ - public void test_Constructor() { - NoClassDefFoundError e = new NoClassDefFoundError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NoClassDefFoundError#NoClassDefFoundError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NoClassDefFoundError e = new NoClassDefFoundError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchFieldErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchFieldErrorTest.java deleted file mode 100644 index 88889e5..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchFieldErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NoSuchFieldErrorTest extends TestCase { - - /** - * @tests java.lang.NoSuchFieldError#NoSuchFieldError() - */ - public void test_Constructor() { - NoSuchFieldError e = new NoSuchFieldError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NoSuchFieldError#NoSuchFieldError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NoSuchFieldError e = new NoSuchFieldError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchFieldExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchFieldExceptionTest.java deleted file mode 100644 index 5902d86..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchFieldExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NoSuchFieldExceptionTest extends TestCase { - - /** - * @tests java.lang.NoSuchFieldException#NoSuchFieldException() - */ - public void test_Constructor() { - NoSuchFieldException e = new NoSuchFieldException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NoSuchFieldException#NoSuchFieldException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NoSuchFieldException e = new NoSuchFieldException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchMethodErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchMethodErrorTest.java deleted file mode 100644 index b7e711b..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchMethodErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NoSuchMethodErrorTest extends TestCase { - - /** - * @tests java.lang.NoSuchMethodError#NoSuchMethodError() - */ - public void test_Constructor() { - NoSuchMethodError e = new NoSuchMethodError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NoSuchMethodError#NoSuchMethodError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NoSuchMethodError e = new NoSuchMethodError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchMethodExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchMethodExceptionTest.java deleted file mode 100644 index 68d46a2..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NoSuchMethodExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NoSuchMethodExceptionTest extends TestCase { - - /** - * @tests java.lang.NoSuchMethodException#NoSuchMethodException() - */ - public void test_Constructor() { - NoSuchMethodException e = new NoSuchMethodException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NoSuchMethodException#NoSuchMethodException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NoSuchMethodException e = new NoSuchMethodException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NullPointerExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NullPointerExceptionTest.java deleted file mode 100644 index a3df668..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NullPointerExceptionTest.java +++ /dev/null @@ -1,41 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NullPointerExceptionTest extends TestCase { - - /** - * @tests java.lang.NullPointerException#NullPointerException() - */ - public void test_Constructor() { - NullPointerException e = new NullPointerException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NullPointerException#NullPointerException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NullPointerException e = new NullPointerException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NumberFormatExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NumberFormatExceptionTest.java deleted file mode 100644 index 3cdf445..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NumberFormatExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class NumberFormatExceptionTest extends TestCase { - - /** - * @tests java.lang.NumberFormatException#NumberFormatException() - */ - public void test_Constructor() { - NumberFormatException e = new NumberFormatException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.NumberFormatException#NumberFormatException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - NumberFormatException e = new NumberFormatException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NumberTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NumberTest.java deleted file mode 100644 index 5b7d7f7..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/NumberTest.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * 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; - -public class NumberTest extends junit.framework.TestCase { - - /** - * @tests java.lang.Number#byteValue() - */ - public void test_byteValue() { - int number = 1231243; - assertTrue("Incorrect byte returned for: " + number, - ((byte) new Integer(number).intValue()) == new Integer(number) - .byteValue()); - number = 0; - assertTrue("Incorrect byte returned for: " + number, - ((byte) new Integer(number).intValue()) == new Integer(number) - .byteValue()); - number = -1; - assertTrue("Incorrect byte returned for: " + number, - ((byte) new Integer(number).intValue()) == new Integer(number) - .byteValue()); - number = -84109328; - assertTrue("Incorrect byte returned for: " + number, - ((byte) new Integer(number).intValue()) == new Integer(number) - .byteValue()); - } - - /** - * @tests java.lang.Number#shortValue() - */ - public void test_shortValue() { - int number = 1231243; - assertTrue("Incorrect byte returned for: " + number, - ((short) new Integer(number).intValue()) == new Integer(number) - .shortValue()); - number = 0; - assertTrue("Incorrect byte returned for: " + number, - ((short) new Integer(number).intValue()) == new Integer(number) - .shortValue()); - number = -1; - assertTrue("Incorrect byte returned for: " + number, - ((short) new Integer(number).intValue()) == new Integer(number) - .shortValue()); - number = -84109328; - assertTrue("Incorrect byte returned for: " + number, - ((short) new Integer(number).intValue()) == new Integer(number) - .shortValue()); - - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ObjectTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ObjectTest.java deleted file mode 100644 index 2b3c3f3..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ObjectTest.java +++ /dev/null @@ -1,673 +0,0 @@ -/* - * 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 java.util.Vector; - -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargetClass; -import dalvik.annotation.BrokenTest; -import dalvik.annotation.SideEffect; - -@TestTargetClass(Object.class) -public class ObjectTest extends junit.framework.TestCase { - - public boolean isCalled = false; - /** - * Test objects. - */ - Object obj1 = new Object(); - - Object obj2 = new Object(); - - /** - * Generic state indicator. - */ - int status = 0; - - int ready = 0; - TestThread1 thr1; - TestThread2 thr2; - - /** - * @tests java.lang.Object#Object() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Object", - args = {} - ) - public void test_Constructor() { - // Test for method java.lang.Object() - assertNotNull("Constructor failed !!!", new Object()); - } - - /** - * @tests java.lang.Object#equals(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "equals", - args = {java.lang.Object.class} - ) - public void test_equalsLjava_lang_Object() { - // Test for method boolean java.lang.Object.equals(java.lang.Object) - assertTrue("Same object should be equal", obj1.equals(obj1)); - assertTrue("Different objects should not be equal", !obj1.equals(obj2)); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "finalize", - args = {} - ) - @SideEffect("Causes OutOfMemoryError to test finalization") - public void test_finalize() { - isCalled = false; - class TestObject extends Object { - - Vector<StringBuffer> v = new Vector<StringBuffer>(); - public void add() { - v.add(new StringBuffer(10000)); - } - - protected void finalize() throws Throwable { - isCalled = true; - super.finalize(); - } - } - - TestObject to = new TestObject(); - - try { - while(true) { - to.add(); - } - } catch(OutOfMemoryError oome) { - //expected - to = null; - } - System.gc(); - System.runFinalization(); - assertTrue(isCalled); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "clone", - args = {} - ) - public void test_clone() { - MockCloneableObject mco = new MockCloneableObject(); - try { - assertFalse(mco.equals(mco.clone())); - assertEquals(mco.getClass(), mco.clone().getClass()); - } catch(CloneNotSupportedException cnse) { - fail("CloneNotSupportedException was thrown."); - } - - MockObject mo = new MockObject(); - try { - mo.clone(); - fail("CloneNotSupportedException was not thrown."); - } catch(CloneNotSupportedException cnse) { - //expected - } - } - class MockCloneableObject extends Object implements Cloneable { - public Object clone() throws CloneNotSupportedException { - return super.clone(); - } - } - - class MockObject extends Object { - - boolean isCalled = false; - - public void finalize() throws Throwable { - super.finalize(); - isCalled = true; - } - - public Object clone() throws CloneNotSupportedException { - return super.clone(); - } - } - - /** - * @tests java.lang.Object#getClass() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getClass", - args = {} - ) - public void test_getClass() { - // Test for method java.lang.Class java.lang.Object.getClass() - String classNames[] = { "java.lang.Object", "java.lang.Throwable", - "java.lang.StringBuffer" }; - Class<?> classToTest = null; - Object instanceToTest = null; - - status = 0; - for (int i = 0; i < classNames.length; ++i) { - try { - classToTest = Class.forName(classNames[i]); - instanceToTest = classToTest.newInstance(); - assertTrue("Instance didn't match creator class.", - instanceToTest.getClass() == classToTest); - assertTrue("Instance didn't match class with matching name.", - instanceToTest.getClass() == Class - .forName(classNames[i])); - } catch (Exception ex) { - fail("Unexpected exception : " + ex.getMessage()); - } - } - } - - /** - * @tests java.lang.Object#hashCode() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "hashCode", - args = {} - ) - public void test_hashCode() { - // Test for method int java.lang.Object.hashCode() - assertTrue("Same object should have same hash.", - obj1.hashCode() == obj1.hashCode()); - assertTrue("Same object should have same hash.", - obj2.hashCode() == obj2.hashCode()); - } - - /** - * @tests java.lang.Object#notify() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "notify", - args = {} - ) - public void test_notify() { - // Test for method void java.lang.Object.notify() - - // Inner class to run test thread. - class TestThread implements Runnable { - public void run() { - synchronized (obj1) { - try { - ready += 1; - obj1.wait();// Wait for ever. - status += 1; - } catch (InterruptedException ex) { - status = -1000; - } - } - } - } - ; - - // Start of test code. - - // Warning: - // This code relies on each thread getting serviced within - // 200 mSec of when it is notified. Although this - // seems reasonable, it could lead to false-failures. - - ready = 0; - status = 0; - final int readyWaitSecs = 3; - - final int threadCount = 20; - for (int i = 0; i < threadCount; ++i) { - new Thread(new TestThread()).start(); - } - synchronized (obj1) { - try { - - // Wait up to readyWaitSeconds for all threads to be waiting on - // monitor - for (int i = 0; i < readyWaitSecs; i++) { - obj1.wait(1000, 0); - if (ready == threadCount) { - break; - } - } - - // Check pre-conditions of testing notifyAll - assertTrue("Not all launched threads are waiting. (ready = " - + ready + ")", ready == threadCount); - assertTrue("Thread woke too early. (status = " + status + ")", - status == 0); - - for (int i = 1; i <= threadCount; ++i) { - obj1.notify(); - obj1.wait(200, 0); - assertTrue("Out of sync. (expected " + i + " but got " - + status + ")", status == i); - } - - } catch (InterruptedException ex) { - fail( - "Unexpectedly got an InterruptedException. (status = " - + status + ")"); - } - } - - try { - Object obj = new Object(); - obj.notify(); - fail("IllegalMonitorStateException was not thrown."); - } catch(IllegalMonitorStateException imse) { - //expected - } - } - - /** - * @tests java.lang.Object#notifyAll() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "notifyAll", - args = {} - ) - public void test_notifyAll() { - // Test for method void java.lang.Object.notifyAll() - - // Inner class to run test thread. - class TestThread implements Runnable { - public void run() { - synchronized (obj1) { - try { - ready += 1; - obj1.wait();// Wait for ever. - status += 1; - } catch (InterruptedException ex) { - status = -1000; - } - } - } - } - ; - - // Start of test code. - - // Warning: - // This code relies on all threads getting serviced within - // 5 seconds of when they are notified. Although this - // seems reasonable, it could lead to false-failures. - - status = 0; - ready = 0; - final int readyWaitSecs = 3; - final int threadCount = 20; - for (int i = 0; i < threadCount; ++i) { - new Thread(new TestThread()).start(); - } - - synchronized (obj1) { - - try { - - // Wait up to readyWaitSeconds for all threads to be waiting on - // monitor - for (int i = 0; i < readyWaitSecs; i++) { - obj1.wait(1000, 0); - if (ready == threadCount) { - break; - } - } - - // Check pre-conditions of testing notifyAll - assertTrue("Not all launched threads are waiting. (ready = " - + ready + ")", ready == threadCount); - assertTrue("At least one thread woke too early. (status = " - + status + ")", status == 0); - - obj1.notifyAll(); - - obj1.wait(5000, 0); - - assertTrue( - "At least one thread did not get notified. (status = " - + status + ")", status == threadCount); - - } catch (InterruptedException ex) { - fail( - "Unexpectedly got an InterruptedException. (status = " - + status + ")"); - } - - } - - try { - Object obj = new Object(); - obj.notifyAll(); - fail("IllegalMonitorStateException was not thrown."); - } catch(IllegalMonitorStateException imse) { - //expected - } - } - - /** - * @tests java.lang.Object#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - // Test for method java.lang.String java.lang.Object.toString() - assertNotNull("Object toString returned null.", obj1.toString()); - } - - /** - * @tests java.lang.Object#wait() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "wait", - args = {} - ) - public void test_wait() { - // Test for method void java.lang.Object.wait() - - // Inner class to run test thread. - class TestThread implements Runnable { - public void run() { - synchronized (obj1) { - try { - obj1.wait();// Wait for ever. - status = 1; - } catch (InterruptedException ex) { - status = -1; - } - } - } - } - - - // Start of test code. - - // Warning: - // This code relies on threads getting serviced within - // 1 second of when they are notified. Although this - // seems reasonable, it could lead to false-failures. - - status = 0; - new Thread(new TestThread()).start(); - synchronized (obj1) { - try { - obj1.wait(1000, 0); - assertTrue("Thread woke too early. (status = " + status + ")", - status == 0); - obj1.notifyAll(); - obj1.wait(1000, 0); - assertTrue("Thread did not get notified. (status = " + status - + ")", status == 1); - } catch (InterruptedException ex) { - fail( - "Unexpectedly got an InterruptedException. (status = " - + status + ")"); - } - } - - try { - Object obj = new Object(); - obj.wait(); - fail("IllegalMonitorStateException was not thrown."); - } catch(IllegalMonitorStateException imse) { - //expected - } catch(InterruptedException ex) { - fail("InterruptedException was thrown."); - } - - try { - thr1 = new TestThread1(TestThread1.CASE_WAIT); - thr2 = new TestThread2(); - thr1.start(); - thr2.start(); - thr2.join(); - thr1.join(); - thr1 = null; - thr2 = null; - } catch(InterruptedException e) { - fail("InterruptedException was thrown."); - } - assertEquals(3, status); - } - - class TestThread1 extends Thread { - - static final int CASE_WAIT = 0; - static final int CASE_WAIT_LONG = 1; - static final int CASE_WAIT_LONG_INT = 2; - - int testCase = CASE_WAIT; - - public TestThread1(int option) { - testCase = option; - } - - public void run() { - synchronized (obj1) { - try { - switch(testCase) { - case CASE_WAIT: - obj1.wait();// Wait for ever. - break; - case CASE_WAIT_LONG: - obj1.wait(5000L); - break; - case CASE_WAIT_LONG_INT: - obj1.wait(10000L, 999999); - break; - } - - } catch (InterruptedException ex) { - status = 3; - } - } - } - } - - class TestThread2 extends Thread { - public void run() { - thr1.interrupt(); - } - } - - /** - * @tests java.lang.Object#wait(long) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "wait", - args = {long.class} - ) - public void test_waitJ() { - // Test for method void java.lang.Object.wait(long) - - // Start of test code. - - final int loopCount = 20; - final int allowableError = 100; // millesconds - final int delay = 200; // milliseconds - synchronized (obj1) { - try { - int count = 0; - long[][] toLong = new long[3][3]; - for (int i = 0; i < loopCount; ++i) { - long before = System.currentTimeMillis(); - obj1.wait(delay, 0); - long after = System.currentTimeMillis(); - long error = (after - before - delay); - if (error < 0) - error = -error; - if (i > 0 && error > allowableError) { - // Allow jit to warm up before testing - if (count < toLong.length) { - toLong[count][0] = i; - toLong[count][1] = before; - toLong[count][2] = after; - count++; - } - if (error > (1000 + delay) || count == toLong.length) { - StringBuffer sb = new StringBuffer(); - for (int j = 0; j < count; j++) { - sb - .append("wakeup time too inaccurate, iteration "); - sb.append(toLong[j][0]); - sb.append(", before: "); - sb.append(toLong[j][1]); - sb.append(" after: "); - sb.append(toLong[j][2]); - sb.append(" diff: "); - sb.append(toLong[j][2] - toLong[j][1]); - sb.append("\n"); - } - fail(sb.toString()); - } - } - } - } catch (InterruptedException ex) { - fail( - "Unexpectedly got an InterruptedException. (status = " - + status + ")"); - } - } - - try { - Object obj = new Object(); - obj.wait(5000L); - fail("IllegalMonitorStateException was not thrown."); - } catch(IllegalMonitorStateException imse) { - //expected - } catch(InterruptedException ex) { - fail("InterruptedException was thrown."); - } - - try { - thr1 = new TestThread1(TestThread1.CASE_WAIT_LONG); - thr2 = new TestThread2(); - thr1.start(); - thr2.start(); - thr2.join(); - thr1.join(); - thr1 = null; - thr2 = null; - } catch(InterruptedException e) { - fail("InterruptedException was thrown."); - } - assertEquals(3, status); - } - - /** - * @tests java.lang.Object#wait(long, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "wait", - args = {long.class, int.class} - ) - public void test_waitJI() { - // Test for method void java.lang.Object.wait(long, int) - - // Inner class to run test thread. - class TestThread implements Runnable { - public void run() { - synchronized (obj1) { - try { - obj1.wait(0, 1); // Don't wait very long. - status = 1; - obj1.wait(0, 0); // Wait for ever. - status = 2; - } catch (InterruptedException ex) { - status = -1; - } - } - } - } - - - // Start of test code. - - // Warning: - // This code relies on threads getting serviced within - // 1 second of when they are notified. Although this - // seems reasonable, it could lead to false-failures. - - status = 0; - new Thread(new TestThread()).start(); - synchronized (obj1) { - try { - obj1.wait(1000, 0); - assertTrue("Thread did not wake after 1 ms. (status = " - + status + ")", status == 1); - obj1.notifyAll(); - obj1.wait(1000, 0); - assertTrue("Thread did not get notified. (status = " + status - + ")", status == 2); - } catch (InterruptedException ex) { - fail( - "Unexpectedly got an InterruptedException. (status = " - + status + ")"); - } - } - - try { - Object obj = new Object(); - obj.wait(5000L, 1); - fail("IllegalMonitorStateException was not thrown."); - } catch(IllegalMonitorStateException imse) { - //expected - } catch(InterruptedException ex) { - fail("InterruptedException was thrown."); - } - - try { - thr1 = new TestThread1(TestThread1.CASE_WAIT_LONG_INT); - thr2 = new TestThread2(); - thr1.start(); - thr2.start(); - thr2.join(); - thr1.join(); - thr1 = null; - thr2 = null; - } catch(InterruptedException e) { - fail("InterruptedException was thrown."); - } - assertEquals(3, status); - - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/OutOfMemoryErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/OutOfMemoryErrorTest.java deleted file mode 100644 index 72b6d3d..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/OutOfMemoryErrorTest.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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; - -public class OutOfMemoryErrorTest extends junit.framework.TestCase { - - /** - * @tests java.lang.OutOfMemoryError#OutOfMemoryError() - */ - public void test_Constructor() { - // Test for method java.lang.OutOfMemoryError() - Error e = new OutOfMemoryError(); - assertNull(e.getCause()); - assertNull(e.getMessage()); - } - - /** - * @tests java.lang.OutOfMemoryError#OutOfMemoryError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - // Test for method java.lang.OutOfMemoryError(java.lang.String) - Error e = new OutOfMemoryError(null); - assertNull(e.getMessage()); - assertNull(e.getCause()); - - e= new OutOfMemoryError("msg"); - assertEquals("msg", e.getMessage()); - assertNull(e.getCause()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/PublicClassLoader.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/PublicClassLoader.java deleted file mode 100644 index 6735f1e..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/PublicClassLoader.java +++ /dev/null @@ -1,97 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -import java.io.File; -import java.io.FileInputStream; -import java.io.IOException; -import java.io.InputStream; - - class PublicClassLoader extends ClassLoader { - - public PublicClassLoader() { - super(); - } - - public PublicClassLoader(ClassLoader cl) { - super(cl); - } - - private byte[] getBytes( String filename ) throws IOException { - - File file = new File( filename ); - long len = file.length(); - byte raw[] = new byte[(int)len]; - FileInputStream fin = new FileInputStream( file ); - int r = fin.read( raw ); - if (r != len) - throw new IOException( "Can't read all, "+r+" != "+len ); - fin.close(); - return raw; - } - - public Class<?> loadClass(String name, boolean resolve) - throws ClassNotFoundException { - - Class clazz = findLoadedClass(name); - String classFileName = name.replace( '.', '/' ) + ".class"; - File classFile = new File(classFileName); - if (classFile.exists()) { - try { - byte raw[] = getBytes(classFileName); - clazz = defineClass( name, raw, 0, raw.length ); - } catch(Exception ioe) {} - } - - if (clazz == null) { - Package p = getClass().getPackage(); - InputStream is = getResourceAsStream("/" + classFileName); - byte[] buf = new byte[512]; - int len; - try { - len = is.read(buf); - clazz = defineClass(name, buf, 0, len); - } catch (IOException e) { - } - } - - if (clazz == null) { - clazz = findSystemClass(name); - } - - if(clazz == null) - throw new ClassNotFoundException(name); - return clazz; - } - - public Class<?> defineClassTest(byte[] b, int off, int len) { - return defineClass(b, off, len); - } - - public Package getPackage(String name) { - return super.getPackage(name); - } - - public Package [] getPackages() { - return super.getPackages(); - } - - public InputStream getResourceAsStream(String name) { - return getClass().getResourceAsStream("/" + getClass().getPackage(). - getName().replace(".", "/") + "/" + name); - } - } diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/PublicTestClass.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/PublicTestClass.java deleted file mode 100644 index a377dbc..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/PublicTestClass.java +++ /dev/null @@ -1,73 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -import java.io.Serializable; - -interface TestInterface { - - public static int TEST_INTERFACE_FIELD = 0; - - int getCount(); - void setCount(int value); -} - -@TestAnnotation("org.apache.harmony.luni.tests.java.lang.PublicTestClass") -public class PublicTestClass implements TestInterface, Serializable, Cloneable { - - private static final long serialVersionUID = 1L; - - public static String TEST_FIELD = "test field"; - - Object clazz; - - public PublicTestClass() { - class LocalClass { } - - clazz = new LocalClass(); - } - - public Object getLocalClass() { - class LocalClass {} - Object returnedObject = new LocalClass(); - return returnedObject; - } - - int count = 0; - - public int getCount() { - return count; - } - - public void setCount(int value) { - count = value; - } - - private class PrivateClass1 { - - public String toString() { - return "PrivateClass0"; - } - } - - public class PrivateClass2 { - - public String toString() { - return "PrivateClass1"; - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimePermissionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimePermissionTest.java deleted file mode 100644 index 1d62ad9..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/RuntimePermissionTest.java +++ /dev/null @@ -1,44 +0,0 @@ -/* - * 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; - -public class RuntimePermissionTest extends junit.framework.TestCase { - - /** - * @tests java.lang.RuntimePermission#RuntimePermission(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - // Test for method java.lang.RuntimePermission(java.lang.String) - RuntimePermission r = new RuntimePermission("createClassLoader"); - assertEquals("Returned incorrect name", - "createClassLoader", r.getName()); - - } - - /** - * @tests java.lang.RuntimePermission#RuntimePermission(java.lang.String, - * java.lang.String) - */ - public void test_ConstructorLjava_lang_StringLjava_lang_String() { - // Test for method java.lang.RuntimePermission(java.lang.String, - // java.lang.String) - RuntimePermission r = new RuntimePermission("createClassLoader", null); - assertEquals("Returned incorrect name", - "createClassLoader", r.getName()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SecurityExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SecurityExceptionTest.java deleted file mode 100644 index 471dd1c..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SecurityExceptionTest.java +++ /dev/null @@ -1,81 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; - -public class SecurityExceptionTest extends TestCase { - - /** - * @tests java.lang.SecurityException#SecurityException() - */ - public void test_Constructor() { - SecurityException e = new SecurityException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.SecurityException#SecurityException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - SecurityException e = new SecurityException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.SecurityException#SecurityException(String, Throwable) - */ - @SuppressWarnings("nls") - public void test_ConstructorLjava_lang_StringLjava_lang_Throwable() { - NullPointerException npe = new NullPointerException(); - SecurityException e = new SecurityException("fixture", npe); - assertSame("fixture", e.getMessage()); - assertSame(npe, e.getCause()); - } - - /** - * @tests java.lang.SecurityException#SecurityException(Throwable) - */ - @SuppressWarnings("nls") - public void test_ConstructorLjava_lang_Throwable() { - NullPointerException npe = new NullPointerException(); - SecurityException e = new SecurityException(npe); - assertSame(npe, e.getCause()); - } - - /** - * @tests serialization/deserialization. - */ - public void testSerializationSelf() throws Exception { - - SerializationTest.verifySelf(new SecurityException()); - } - - /** - * @tests serialization/deserialization compatibility with RI. - */ - public void testSerializationCompatibility() throws Exception { - - SerializationTest.verifyGolden(this, new SecurityException()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SecurityManagerTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SecurityManagerTest.java deleted file mode 100644 index 607f388..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SecurityManagerTest.java +++ /dev/null @@ -1,510 +0,0 @@ -/* 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 java.io.File; -import java.io.FileDescriptor; -import java.io.FilePermission; -import java.net.InetAddress; -import java.net.SocketPermission; -import java.net.UnknownHostException; -import java.security.AccessControlContext; -import java.security.AllPermission; -import java.security.Permission; -import java.security.ProtectionDomain; -import java.security.Security; - -import junit.framework.TestCase; -import tests.support.Support_Exec; - -/** - * Test case for java.lang.SecurityManager - */ -public class SecurityManagerTest extends TestCase { - MutableSecurityManager mutableSM = null; - - MockSecurityManager mockSM = null; - - /** - * @tests java.lang.SecurityManager#checkPackageAccess(String) - */ - public void test_checkPackageAccessLjava_lang_String() { - final String old = Security.getProperty("package.access"); - Security.setProperty("package.access", "a.,bbb, c.d."); - - mutableSM - .denyPermission(new RuntimePermission("accessClassInPackage.*")); - - try { - mutableSM.checkPackageAccess("z.z.z"); - mutableSM.checkPackageAccess("aa"); - mutableSM.checkPackageAccess("bb"); - mutableSM.checkPackageAccess("c"); - - try { - mutableSM.checkPackageAccess("a"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - try { - mutableSM.checkPackageAccess("bbb"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - try { - mutableSM.checkPackageAccess("c.d.e"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - Security.setProperty("package.access", "QWERTY"); - mutableSM.checkPackageAccess("a"); - mutableSM.checkPackageAccess("qwerty"); - try { - mutableSM.checkPackageAccess("QWERTY"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - } finally { - Security.setProperty("package.access", old == null ? "" : old); - } - } - - /** - * @tests java.lang.SecurityManager#checkPackageDefinition(String) - */ - public void test_checkPackageDefinitionLjava_lang_String() { - final String old = Security.getProperty("package.definition"); - Security.setProperty("package.definition", "a.,bbb, c.d."); - - mutableSM - .denyPermission(new RuntimePermission("defineClassInPackage.*")); - - try { - mutableSM.checkPackageDefinition("z.z.z"); - mutableSM.checkPackageDefinition("aa"); - mutableSM.checkPackageDefinition("bb"); - mutableSM.checkPackageDefinition("c"); - - try { - mutableSM.checkPackageDefinition("a"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - try { - mutableSM.checkPackageDefinition("bbb"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - try { - mutableSM.checkPackageDefinition("c.d.e"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - Security.setProperty("package.definition", "QWERTY"); - mutableSM.checkPackageDefinition("a"); - mutableSM.checkPackageDefinition("qwerty"); - try { - mutableSM.checkPackageDefinition("QWERTY"); - fail("This should throw a SecurityException."); - } catch (SecurityException ok) { - } - - } finally { - Security.setProperty("package.definition", old == null ? "" : old); - } - } - - /** - * @tests java.lang.SecurityManager#checkAccess(java.lang.Thread) - */ - public void test_checkAccessLjava_lang_Thread() throws InterruptedException { - // Regression for HARMONY-66 - Thread t = new Thread() { - @Override - public void run() { - }; - }; - t.start(); - t.join(); - new SecurityManager().checkAccess(t); - } - - /** - * @tests {@link java.lang.SecurityManager#checkConnect(String, int, Object)} - */ - @SuppressWarnings("nls") - public void test_checkConnectLjava_lang_String_int_Ljava_lang_Object() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new SocketPermission("localhost:1024-", - "accept, connect, listen")); - ProtectionDomain pDomain = this.getClass().getProtectionDomain(); - ProtectionDomain[] pd = { pDomain }; - AccessControlContext acc = new AccessControlContext(pd); - try { - mutableSM.checkConnect("localhost", 1024, acc); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkExec(String)} - */ - @SuppressWarnings("nls") - public void test_checkExecLjava_lang_String() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new FilePermission("<<ALL FILES>>", "execute")); - try { - mutableSM.checkExec("java"); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkExit(int)} - */ - @SuppressWarnings("nls") - public void test_checkExit_int() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new RuntimePermission("exitVM")); - try { - mutableSM.checkExit(0); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkLink(String)} - */ - @SuppressWarnings("nls") - public void test_checkLinkLjava_lang_String() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new RuntimePermission("loadLibrary.harmony")); - try { - mutableSM.checkLink("harmony"); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkListen(int)} - */ - @SuppressWarnings("nls") - public void test_checkListen_int() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM - .denyPermission(new SocketPermission("localhost:80", "listen")); - - try { - mutableSM.checkListen(80); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new SocketPermission("localhost:1024-", - "listen")); - try { - mutableSM.checkListen(0); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @throws UnknownHostException - * @tests {@link java.lang.SecurityManager#checkMulticast(java.net.InetAddress)} - */ - @SuppressWarnings("nls") - public void test_checkMulticastLjava_net_InetAddress() - throws UnknownHostException { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new SocketPermission(InetAddress.getByName( - "localhost").getHostAddress(), "accept,connect")); - try { - mutableSM.checkMulticast(InetAddress.getByName("localhost")); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @throws UnknownHostException - * @tests {@link java.lang.SecurityManager#checkMulticast(java.net.InetAddress,byte)} - */ - @SuppressWarnings( { "nls", "deprecation" }) - public void test_checkMulticastLjava_net_InetAddress_int() - throws UnknownHostException { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new SocketPermission(InetAddress.getByName( - "localhost").getHostAddress(), "accept,connect")); - try { - // the second parameter is the TTL(time to live) - mutableSM.checkMulticast(InetAddress.getByName("localhost"), - (byte) 0); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * - * @tests {@link java.lang.SecurityManager#checkPermission(Permission, Object)} - */ - @SuppressWarnings("nls") - public void test_checkPermissionLjava_security_PermissionLjava_lang_Object() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - Permission denyp = new SocketPermission("localhost:1024-", - "accept, connect, listen"); - mutableSM.denyPermission(denyp); - ProtectionDomain pDomain = this.getClass().getProtectionDomain(); - ProtectionDomain[] pd = { pDomain }; - AccessControlContext acc = new AccessControlContext(pd); - try { - mutableSM.checkPermission(denyp, acc); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkPrintJobAccess()} - */ - @SuppressWarnings("nls") - public void test_checkPrintJobAccess() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new RuntimePermission("queuePrintJob")); - try { - mutableSM.checkPrintJobAccess(); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkRead(FileDescriptor)} - */ - @SuppressWarnings("nls") - public void test_checkReadLjava_io_FileDescriptor() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new RuntimePermission("readFileDescriptor")); - try { - mutableSM.checkRead(new FileDescriptor()); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkRead(String,Object)} - */ - @SuppressWarnings("nls") - public void test_checkReadLjava_lang_StringLjava_lang_Object() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new FilePermission("<<ALL FILES>>", "read")); - ProtectionDomain pDomain = this.getClass().getProtectionDomain(); - ProtectionDomain[] pd = { pDomain }; - AccessControlContext acc = new AccessControlContext(pd); - try { - mutableSM.checkRead("aa", acc); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#checkSetFactory()} - */ - @SuppressWarnings("nls") - public void test_checkSetFactory() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new RuntimePermission("setFactory")); - try { - mutableSM.checkSetFactory(); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#getInCheck()} - */ - public void test_getIncheck() { - mockSM.setInCheck(false); - assertFalse(mockSM.getInCheck()); - mockSM.setInCheck(true); - assertTrue(mockSM.getInCheck()); - } - - /** - * @tests {@link java.lang.SecurityManager#getSecurityContext()} - */ - @SuppressWarnings("nls") - public void test_getSecurityContext() { - // enable all but one check - mutableSM.addPermission(new AllPermission()); - mutableSM.denyPermission(new FilePermission("<<ALL FILES>>", "read")); - try { - mutableSM.checkRead("aa", mutableSM.getSecurityContext()); - fail("This should throw a SecurityException."); - } catch (SecurityException e) { - // expected - } - } - - /** - * @tests {@link java.lang.SecurityManager#classDepth(String)} - */ - @SuppressWarnings("nls") - public void test_classDepthLjava_lang_String() { - assertEquals(-1, mockSM.classDepth("nothing")); - } - - /** - * @tests {@link java.lang.SecurityManager#classLoaderDepth()} - */ - public void test_classLoaderDepth() { - assertEquals(-1, mockSM.classLoaderDepth()); - } - - /** - * @tests {@link java.lang.SecurityManager#currentClassLoader()} - */ - public void test_currentClassLoader() { - assertNull(mockSM.currentClassLoader()); - } - - /** - * @tests {@link java.lang.SecurityManager#currentLoadedClass()} - */ - public void test_currentLoadedClass() { - assertNull(mockSM.currentLoadedClass()); - } - - /** - * @tests {@link java.lang.SecurityManager#inClass(String)} - */ - @SuppressWarnings("nls") - public void test_inClassLjava_lang_String() { - assertFalse(mockSM.inClass("nothing")); - assertTrue(mockSM.inClass(MockSecurityManager.class.getName())); - } - - /** - * @tests {@link java.lang.SecurityManager#inClassLoader()} - */ - public void test_inClassLoader() { - assertFalse(mockSM.inClassLoader()); - } - - /** - * @tests {@link java.lang.SecurityManager#inClassLoader()} - */ - public void test_getClassContext() { - assertEquals("MockSecurityManager should be the first in the classes stack", - mockSM.getClassContext()[0], MockSecurityManager.class); - } - - // set some protected method to public for testing - class MockSecurityManager extends SecurityManager { - - public void setInCheck(boolean inCheck) { - super.inCheck = inCheck; - } - - @Override - public int classDepth(String name) { - return super.classDepth(name); - } - - @Override - public int classLoaderDepth() { - return super.classLoaderDepth(); - } - - @Override - public ClassLoader currentClassLoader() { - return super.currentClassLoader(); - } - - @Override - public Class<?> currentLoadedClass() { - return super.currentLoadedClass(); - } - - @Override - public Class[] getClassContext() { - return super.getClassContext(); - } - - @Override - public boolean inClass(String name) { - return super.inClass(name); - } - - @Override - public boolean inClassLoader() { - return super.inClassLoader(); - } - } - - @Override - protected void setUp() throws Exception { - super.setUp(); - mutableSM = new MutableSecurityManager(); - mockSM = new MockSecurityManager(); - } - - @Override - protected void tearDown() throws Exception { - super.tearDown(); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ShortTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ShortTest.java deleted file mode 100644 index e1dc2d3..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ShortTest.java +++ /dev/null @@ -1,660 +0,0 @@ -/* 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 junit.framework.TestCase; - -public class ShortTest extends TestCase { - private Short sp = new Short((short) 18000); - private Short sn = new Short((short) -19000); - - /** - * @tests java.lang.Short#byteValue() - */ - 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) - */ - 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) - */ - 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) - */ - 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) - */ - 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() - */ - 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) - */ - 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) - */ - 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) - */ - 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(byte) - */ - 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() - */ - 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) - */ - 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) - */ - 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() - */ - public void test_booleanValue() { - 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) - */ - 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() - */ - 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) - */ - 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) - */ - 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) - */ - 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) - */ - 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) - */ - 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) - */ - 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("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() - */ - 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() - */ - 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() - */ - 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() - */ - 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() - */ - 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) - */ - 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)); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackOverflowErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackOverflowErrorTest.java deleted file mode 100644 index b4e928f..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackOverflowErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class StackOverflowErrorTest extends TestCase { - - /** - * @tests java.lang.StackOverflowError#StackOverflowError() - */ - public void test_Constructor() { - StackOverflowError e = new StackOverflowError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.StackOverflowError#StackOverflowError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - StackOverflowError e = new StackOverflowError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackTraceElementOriginal.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackTraceElementOriginal.java deleted file mode 100644 index 27b5e4f..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StackTraceElementOriginal.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Copyright (C) 2007 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -import dalvik.annotation.TestTargetClass; -import junit.framework.TestCase; - -@TestTargetClass(StackTraceElement.class) -public class StackTraceElementOriginal extends TestCase { - - public void pureJavaMethod(Object test) throws Exception { - throw new Exception("pure java method"); - } - - native public void pureNativeMethod(Object test); -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StrictMathTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StrictMathTest.java deleted file mode 100644 index 472e27d..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StrictMathTest.java +++ /dev/null @@ -1,1490 +0,0 @@ -/* - * 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 static org.apache.harmony.luni.tests.java.lang.MathTest.COPYSIGN_DD_CASES; -import static org.apache.harmony.luni.tests.java.lang.MathTest.COPYSIGN_FF_CASES; -import static org.apache.harmony.luni.tests.java.lang.MathTest.GETEXPONENT_D_CASES; -import static org.apache.harmony.luni.tests.java.lang.MathTest.GETEXPONENT_D_RESULTS; -import static org.apache.harmony.luni.tests.java.lang.MathTest.GETEXPONENT_F_CASES; -import static org.apache.harmony.luni.tests.java.lang.MathTest.GETEXPONENT_F_RESULTS; -import static org.apache.harmony.luni.tests.java.lang.MathTest.NEXTAFTER_DD_START_CASES; -import static org.apache.harmony.luni.tests.java.lang.MathTest.NEXTAFTER_DD_FD_DIRECTION_CASES; -import static org.apache.harmony.luni.tests.java.lang.MathTest.NEXTAFTER_FD_START_CASES; - -public class StrictMathTest extends junit.framework.TestCase { - - double HYP = StrictMath.sqrt(2.0); - - double OPP = 1.0; - - double ADJ = 1.0; - - /* Required to make previous preprocessor flags work - do not remove */ - int unused = 0; - - /** - * @tests java.lang.StrictMath#abs(double) - */ - public void test_absD() { - // Test for method double java.lang.StrictMath.abs(double) - - assertTrue("Incorrect double abs value", - (StrictMath.abs(-1908.8976) == 1908.8976)); - assertTrue("Incorrect double abs value", - (StrictMath.abs(1908.8976) == 1908.8976)); - } - - /** - * @tests java.lang.StrictMath#abs(float) - */ - public void test_absF() { - // Test for method float java.lang.StrictMath.abs(float) - assertTrue("Incorrect float abs value", - (StrictMath.abs(-1908.8976f) == 1908.8976f)); - assertTrue("Incorrect float abs value", - (StrictMath.abs(1908.8976f) == 1908.8976f)); - } - - /** - * @tests java.lang.StrictMath#abs(int) - */ - public void test_absI() { - // Test for method int java.lang.StrictMath.abs(int) - assertTrue("Incorrect int abs value", - (StrictMath.abs(-1908897) == 1908897)); - assertTrue("Incorrect int abs value", - (StrictMath.abs(1908897) == 1908897)); - } - - /** - * @tests java.lang.StrictMath#abs(long) - */ - public void test_absJ() { - // Test for method long java.lang.StrictMath.abs(long) - assertTrue("Incorrect long abs value", (StrictMath - .abs(-19088976000089L) == 19088976000089L)); - assertTrue("Incorrect long abs value", - (StrictMath.abs(19088976000089L) == 19088976000089L)); - } - - /** - * @tests java.lang.StrictMath#acos(double) - */ - public void test_acosD() { - // Test for method double java.lang.StrictMath.acos(double) - assertTrue("Returned incorrect arc cosine", StrictMath.cos(StrictMath - .acos(ADJ / HYP)) == ADJ / HYP); - } - - /** - * @tests java.lang.StrictMath#asin(double) - */ - public void test_asinD() { - // Test for method double java.lang.StrictMath.asin(double) - assertTrue("Returned incorrect arc sine", StrictMath.sin(StrictMath - .asin(OPP / HYP)) == OPP / HYP); - } - - /** - * @tests java.lang.StrictMath#atan(double) - */ - public void test_atanD() { - // Test for method double java.lang.StrictMath.atan(double) - double answer = StrictMath.tan(StrictMath.atan(1.0)); - assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 - && answer >= 9.9999999999999983E-1); - } - - /** - * @tests java.lang.StrictMath#atan2(double, double) - */ - public void test_atan2DD() { - // Test for method double java.lang.StrictMath.atan2(double, double) - double answer = StrictMath.atan(StrictMath.tan(1.0)); - assertTrue("Returned incorrect arc tangent: " + answer, answer <= 1.0 - && answer >= 9.9999999999999983E-1); - } - - /** - * @tests java.lang.StrictMath#cbrt(double) - */ - @SuppressWarnings("boxing") - public void test_cbrt_D() { - // Test for special situations - assertTrue("Should return Double.NaN", Double.isNaN(StrictMath - .cbrt(Double.NaN))); - assertEquals("Should return Double.POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .cbrt(Double.POSITIVE_INFINITY)); - assertEquals("Should return Double.NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, StrictMath - .cbrt(Double.NEGATIVE_INFINITY)); - assertEquals(Double.doubleToLongBits(0.0), Double - .doubleToLongBits(StrictMath.cbrt(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(StrictMath.cbrt(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(StrictMath.cbrt(-0.0))); - - assertEquals("Should return 3.0", 3.0, StrictMath.cbrt(27.0)); - assertEquals("Should return 23.111993172558684", 23.111993172558684, - StrictMath.cbrt(12345.6)); - assertEquals("Should return 5.643803094122362E102", - 5.643803094122362E102, StrictMath.cbrt(Double.MAX_VALUE)); - assertEquals("Should return 0.01", 0.01, StrictMath.cbrt(0.000001)); - - assertEquals("Should return -3.0", -3.0, StrictMath.cbrt(-27.0)); - assertEquals("Should return -23.111993172558684", -23.111993172558684, - StrictMath.cbrt(-12345.6)); - assertEquals("Should return 1.7031839360032603E-108", - 1.7031839360032603E-108, StrictMath.cbrt(Double.MIN_VALUE)); - assertEquals("Should return -0.01", -0.01, StrictMath.cbrt(-0.000001)); - - try{ - StrictMath.cbrt((Double)null); - fail("Should throw NullPointerException"); - }catch(NullPointerException e){ - //expected - } - } - - /** - * @tests java.lang.StrictMath#ceil(double) - */ - public void test_ceilD() { - // Test for method double java.lang.StrictMath.ceil(double) - assertEquals("Incorrect ceiling for double", - 79, StrictMath.ceil(78.89), 0.0); - assertEquals("Incorrect ceiling for double", - -78, StrictMath.ceil(-78.89), 0.0); - } - - /** - * @tests {@link java.lang.StrictMath#copySign(double, double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_copySign_DD() { - for (int i = 0; i < COPYSIGN_DD_CASES.length; i++) { - final double magnitude = COPYSIGN_DD_CASES[i]; - final long absMagnitudeBits = Double.doubleToLongBits(StrictMath - .abs(magnitude)); - final long negMagnitudeBits = Double.doubleToLongBits(-StrictMath - .abs(magnitude)); - - // cases for NaN - assertEquals("If the sign is NaN, the result should be positive.", - absMagnitudeBits, Double.doubleToLongBits(StrictMath - .copySign(magnitude, Double.NaN))); - assertTrue("The result should be NaN.", Double.isNaN(StrictMath - .copySign(Double.NaN, magnitude))); - - for (int j = 0; j < COPYSIGN_DD_CASES.length; j++) { - final double sign = COPYSIGN_DD_CASES[j]; - final long resultBits = Double.doubleToLongBits(StrictMath - .copySign(magnitude, sign)); - - if (sign > 0 || Double.valueOf(+0.0).equals(sign) - || Double.valueOf(0.0).equals(sign)) { - assertEquals( - "If the sign is positive, the result should be positive.", - absMagnitudeBits, resultBits); - } - if (sign < 0 || Double.valueOf(-0.0).equals(sign)) { - assertEquals( - "If the sign is negative, the result should be negative.", - negMagnitudeBits, resultBits); - } - } - } - - assertTrue("The result should be NaN.", Double.isNaN(StrictMath - .copySign(Double.NaN, Double.NaN))); - - try { - StrictMath.copySign((Double) null, 2.3); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.copySign(2.3, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.copySign((Double) null, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - - double d = Double.longBitsToDouble(0xfff8000000000000L); - assertEquals(1.0, StrictMath.copySign(1.0, d), 0d); - } - - /** - * @tests {@link java.lang.StrictMath#copySign(float, float)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_copySign_FF() { - for (int i = 0; i < COPYSIGN_FF_CASES.length; i++) { - final float magnitude = COPYSIGN_FF_CASES[i]; - final int absMagnitudeBits = Float.floatToIntBits(StrictMath - .abs(magnitude)); - final int negMagnitudeBits = Float.floatToIntBits(-StrictMath - .abs(magnitude)); - - // cases for NaN - assertEquals("If the sign is NaN, the result should be positive.", - absMagnitudeBits, Float.floatToIntBits(StrictMath.copySign( - magnitude, Float.NaN))); - assertTrue("The result should be NaN.", Float.isNaN(StrictMath - .copySign(Float.NaN, magnitude))); - - for (int j = 0; j < COPYSIGN_FF_CASES.length; j++) { - final float sign = COPYSIGN_FF_CASES[j]; - final int resultBits = Float.floatToIntBits(StrictMath - .copySign(magnitude, sign)); - if (sign > 0 || Float.valueOf(+0.0f).equals(sign) - || Float.valueOf(0.0f).equals(sign)) { - assertEquals( - "If the sign is positive, the result should be positive.", - absMagnitudeBits, resultBits); - } - if (sign < 0 || Float.valueOf(-0.0f).equals(sign)) { - assertEquals( - "If the sign is negative, the result should be negative.", - negMagnitudeBits, resultBits); - } - } - } - - assertTrue("The result should be NaN.", Float.isNaN(StrictMath - .copySign(Float.NaN, Float.NaN))); - - try { - StrictMath.copySign((Float) null, 2.3f); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.copySign(2.3f, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.copySign((Float) null, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - - float f = Float.intBitsToFloat(0xffc00000); - assertEquals(1.0f, StrictMath.copySign(1.0f, f), 0f); - } - - /** - * @tests java.lang.StrictMath#cos(double) - */ - public void test_cosD() { - // Test for method double java.lang.StrictMath.cos(double) - - assertTrue("Returned incorrect cosine", StrictMath.cos(StrictMath - .acos(ADJ / HYP)) == ADJ / HYP); - } - - /** - * @tests java.lang.StrictMath#cosh(double) - */ - @SuppressWarnings("boxing") - public void test_cosh_D() { - // Test for special situations - assertTrue("Should return NaN", Double.isNaN(StrictMath - .cosh(Double.NaN))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .cosh(Double.POSITIVE_INFINITY)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .cosh(Double.NEGATIVE_INFINITY)); - assertEquals("Should return 1.0", 1.0, StrictMath.cosh(+0.0)); - assertEquals("Should return 1.0", 1.0, StrictMath.cosh(-0.0)); - - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.cosh(1234.56)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.cosh(-1234.56)); - assertEquals("Should return 1.0000000000005", 1.0000000000005, - StrictMath.cosh(0.000001)); - assertEquals("Should return 1.0000000000005", 1.0000000000005, - StrictMath.cosh(-0.000001)); - assertEquals("Should return 5.212214351945598", 5.212214351945598, - StrictMath.cosh(2.33482)); - - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.cosh(Double.MAX_VALUE)); - assertEquals("Should return 1.0", 1.0, StrictMath - .cosh(Double.MIN_VALUE)); - } - - /** - * @tests java.lang.StrictMath#exp(double) - */ - public void test_expD() { - // Test for method double java.lang.StrictMath.exp(double) - assertTrue("Incorrect answer returned for simple power", StrictMath - .abs(StrictMath.exp(4D) - StrictMath.E * StrictMath.E - * StrictMath.E * StrictMath.E) < 0.1D); - assertTrue("Incorrect answer returned for larger power", StrictMath - .log(StrictMath.abs(StrictMath.exp(5.5D)) - 5.5D) < 10.0D); - } - - /** - * @tests java.lang.StrictMath#expm1(double) - */ - @SuppressWarnings("boxing") - public void test_expm1_D() { - //Test for special cases - assertTrue("Should return NaN", Double.isNaN(StrictMath.expm1(Double.NaN))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.expm1(Double.POSITIVE_INFINITY)); - assertEquals("Should return -1.0", -1.0, StrictMath - .expm1(Double.NEGATIVE_INFINITY)); - assertEquals(Double.doubleToLongBits(0.0), Double - .doubleToLongBits(StrictMath.expm1(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(StrictMath.expm1(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(StrictMath.expm1(-0.0))); - - assertEquals("Should return -9.999950000166666E-6", - -9.999950000166666E-6, StrictMath.expm1(-0.00001)); - assertEquals("Should return 1.0145103074469635E60", - 1.0145103074469635E60, StrictMath.expm1(138.16951162)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .expm1(123456789123456789123456789.4521584223)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.expm1(Double.MAX_VALUE)); - assertEquals("Should return MIN_VALUE", Double.MIN_VALUE, StrictMath - .expm1(Double.MIN_VALUE)); - - } - - /** - * @tests java.lang.StrictMath#floor(double) - */ - public void test_floorD() { - // Test for method double java.lang.StrictMath.floor(double) - assertEquals("Incorrect floor for double", - 78, StrictMath.floor(78.89), 0.0); - assertEquals("Incorrect floor for double", - -79, StrictMath.floor(-78.89), 0.0); - } - - /** - * @tests {@link java.lang.StrictMath#getExponent(double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_getExponent_D() { - for (int i = 0; i < GETEXPONENT_D_CASES.length; i++) { - final double number = GETEXPONENT_D_CASES[i]; - final int result = GETEXPONENT_D_RESULTS[i]; - assertEquals("Wrong result of getExponent(double).", result, - StrictMath.getExponent(number)); - } - - try { - StrictMath.getExponent((Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.StrictMath#getExponent(float)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_getExponent_F() { - for (int i = 0; i < GETEXPONENT_F_CASES.length; i++) { - final float number = GETEXPONENT_F_CASES[i]; - final int result = GETEXPONENT_F_RESULTS[i]; - assertEquals("Wrong result of getExponent(float).", result, - StrictMath.getExponent(number)); - } - try { - StrictMath.getExponent((Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StrictMath#hypot(double, double) - */ - @SuppressWarnings("boxing") - public void test_hypot_DD() { - // Test for special cases - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.hypot(Double.POSITIVE_INFINITY, - 1.0)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.hypot(Double.NEGATIVE_INFINITY, - 123.324)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.hypot(-758.2587, - Double.POSITIVE_INFINITY)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.hypot(5687.21, - Double.NEGATIVE_INFINITY)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.hypot(Double.POSITIVE_INFINITY, - Double.NEGATIVE_INFINITY)); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.hypot(Double.NEGATIVE_INFINITY, - Double.POSITIVE_INFINITY)); - assertTrue("Should return NaN",Double.isNaN(StrictMath.hypot(Double.NaN, - 2342301.89843))); - assertTrue("Should return NaN",Double.isNaN(StrictMath.hypot(-345.2680, - Double.NaN))); - - assertEquals("Should return 2396424.905416697", 2396424.905416697, StrictMath - .hypot(12322.12, -2396393.2258)); - assertEquals("Should return 138.16958070558556", 138.16958070558556, - StrictMath.hypot(-138.16951162, 0.13817035864)); - assertEquals("Should return 1.7976931348623157E308", - 1.7976931348623157E308, StrictMath.hypot(Double.MAX_VALUE, 211370.35)); - assertEquals("Should return 5413.7185", 5413.7185, StrictMath.hypot( - -5413.7185, Double.MIN_VALUE)); - - } - - /** - * @tests java.lang.StrictMath#IEEEremainder(double, double) - */ - public void test_IEEEremainderDD() { - // Test for method double java.lang.StrictMath.IEEEremainder(double, - // double) - assertEquals("Incorrect remainder returned", 0.0, StrictMath.IEEEremainder( - 1.0, 1.0), 0.0); - assertTrue( - "Incorrect remainder returned", - StrictMath.IEEEremainder(1.32, 89.765) >= 1.4705063220631647E-2 - || StrictMath.IEEEremainder(1.32, 89.765) >= 1.4705063220631649E-2); - } - - /** - * @tests java.lang.StrictMath#log(double) - */ - public void test_logD() { - // Test for method double java.lang.StrictMath.log(double) - for (double d = 10; d >= -10; d -= 0.5) { - double answer = StrictMath.log(StrictMath.exp(d)); - assertTrue("Answer does not equal expected answer for d = " + d - + " answer = " + answer, - StrictMath.abs(answer - d) <= StrictMath - .abs(d * 0.00000001)); - } - } - - /** - * @tests java.lang.StrictMath#log10(double) - */ - @SuppressWarnings("boxing") - public void test_log10_D() { - // Test for special cases - assertTrue("Should return NaN", Double.isNaN(StrictMath - .log10(Double.NaN))); - assertTrue("Should return NaN", Double.isNaN(StrictMath - .log10(-2541.05745687234187532))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .log10(Double.POSITIVE_INFINITY)); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, StrictMath.log10(0.0)); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, StrictMath.log10(+0.0)); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, StrictMath.log10(-0.0)); - assertEquals("Should return 14.0", 14.0, StrictMath.log10(StrictMath - .pow(10, 14))); - - assertEquals("Should return 3.7389561269540406", 3.7389561269540406, - StrictMath.log10(5482.2158)); - assertEquals("Should return 14.661551142893833", 14.661551142893833, - StrictMath.log10(458723662312872.125782332587)); - assertEquals("Should return -0.9083828622192334", -0.9083828622192334, - StrictMath.log10(0.12348583358871)); - assertEquals("Should return 308.25471555991675", 308.25471555991675, - StrictMath.log10(Double.MAX_VALUE)); - assertEquals("Should return -323.3062153431158", -323.3062153431158, - StrictMath.log10(Double.MIN_VALUE)); - } - - /** - * @tests java.lang.StrictMath#log1p(double) - */ - @SuppressWarnings("boxing") - public void test_log1p_D() { - // Test for special cases - assertTrue("Should return NaN", Double.isNaN(StrictMath - .log1p(Double.NaN))); - assertTrue("Should return NaN", Double.isNaN(StrictMath - .log1p(-32.0482175))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .log1p(Double.POSITIVE_INFINITY)); - assertEquals(Double.doubleToLongBits(0.0), Double - .doubleToLongBits(StrictMath.log1p(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(StrictMath.log1p(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(StrictMath.log1p(-0.0))); - - assertEquals("Should return -0.2941782295312541", -0.2941782295312541, - StrictMath.log1p(-0.254856327)); - assertEquals("Should return 7.368050685564151", 7.368050685564151, - StrictMath.log1p(1583.542)); - assertEquals("Should return 0.4633708685409921", 0.4633708685409921, - StrictMath.log1p(0.5894227)); - assertEquals("Should return 709.782712893384", 709.782712893384, - StrictMath.log1p(Double.MAX_VALUE)); - assertEquals("Should return Double.MIN_VALUE", Double.MIN_VALUE, - StrictMath.log1p(Double.MIN_VALUE)); - } - - /** - * @tests java.lang.StrictMath#max(double, double) - */ - public void test_maxDD() { - // Test for method double java.lang.StrictMath.max(double, double) - assertEquals("Incorrect double max value", 1908897.6000089, StrictMath.max( - -1908897.6000089, 1908897.6000089), 0D); - assertEquals("Incorrect double max value", 1908897.6000089, StrictMath.max(2.0, - 1908897.6000089), 0D); - assertEquals("Incorrect double max value", -2.0, StrictMath.max(-2.0, - -1908897.6000089), 0D); - - } - - /** - * @tests java.lang.StrictMath#max(float, float) - */ - public void test_maxFF() { - // Test for method float java.lang.StrictMath.max(float, float) - assertTrue("Incorrect float max value", StrictMath.max(-1908897.600f, - 1908897.600f) == 1908897.600f); - assertTrue("Incorrect float max value", StrictMath.max(2.0f, - 1908897.600f) == 1908897.600f); - assertTrue("Incorrect float max value", StrictMath.max(-2.0f, - -1908897.600f) == -2.0f); - } - - /** - * @tests java.lang.StrictMath#max(int, int) - */ - public void test_maxII() { - // Test for method int java.lang.StrictMath.max(int, int) - assertEquals("Incorrect int max value", 19088976, StrictMath.max(-19088976, - 19088976)); - assertEquals("Incorrect int max value", - 19088976, StrictMath.max(20, 19088976)); - assertEquals("Incorrect int max value", - -20, StrictMath.max(-20, -19088976)); - } - - /** - * @tests java.lang.StrictMath#max(long, long) - */ - public void test_maxJJ() { - // Test for method long java.lang.StrictMath.max(long, long) - assertEquals("Incorrect long max value", 19088976000089L, StrictMath.max(-19088976000089L, - 19088976000089L)); - assertEquals("Incorrect long max value", 19088976000089L, StrictMath.max(20, - 19088976000089L)); - assertEquals("Incorrect long max value", -20, StrictMath.max(-20, - -19088976000089L)); - } - - /** - * @tests java.lang.StrictMath#min(double, double) - */ - public void test_minDD() { - // Test for method double java.lang.StrictMath.min(double, double) - assertEquals("Incorrect double min value", -1908897.6000089, StrictMath.min( - -1908897.6000089, 1908897.6000089), 0D); - assertEquals("Incorrect double min value", 2.0, StrictMath.min(2.0, - 1908897.6000089), 0D); - assertEquals("Incorrect double min value", -1908897.6000089, StrictMath.min(-2.0, - -1908897.6000089), 0D); - } - - /** - * @tests java.lang.StrictMath#min(float, float) - */ - public void test_minFF() { - // Test for method float java.lang.StrictMath.min(float, float) - assertTrue("Incorrect float min value", StrictMath.min(-1908897.600f, - 1908897.600f) == -1908897.600f); - assertTrue("Incorrect float min value", StrictMath.min(2.0f, - 1908897.600f) == 2.0f); - assertTrue("Incorrect float min value", StrictMath.min(-2.0f, - -1908897.600f) == -1908897.600f); - } - - /** - * @tests java.lang.StrictMath#min(int, int) - */ - public void test_minII() { - // Test for method int java.lang.StrictMath.min(int, int) - assertEquals("Incorrect int min value", -19088976, StrictMath.min(-19088976, - 19088976)); - assertEquals("Incorrect int min value", - 20, StrictMath.min(20, 19088976)); - assertEquals("Incorrect int min value", - -19088976, StrictMath.min(-20, -19088976)); - - } - - /** - * @tests java.lang.StrictMath#min(long, long) - */ - public void test_minJJ() { - // Test for method long java.lang.StrictMath.min(long, long) - assertEquals("Incorrect long min value", -19088976000089L, StrictMath.min(-19088976000089L, - 19088976000089L)); - assertEquals("Incorrect long min value", 20, StrictMath.min(20, - 19088976000089L)); - assertEquals("Incorrect long min value", -19088976000089L, StrictMath.min(-20, - -19088976000089L)); - } - - /** - * @tests {@link java.lang.StrictMath#nextAfter(double, double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextAfter_DD() { - // test for most cases without exception - for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { - final double start = NEXTAFTER_DD_START_CASES[i][0]; - final long nextUpBits = Double - .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][1]); - final long nextDownBits = Double - .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][2]); - - for (int j = 0; j < NEXTAFTER_DD_FD_DIRECTION_CASES.length; j++) { - final double direction = NEXTAFTER_DD_FD_DIRECTION_CASES[j]; - final long resultBits = Double.doubleToLongBits(StrictMath - .nextAfter(start, direction)); - final long directionBits = Double.doubleToLongBits(direction); - if (direction > start) { - assertEquals("Result should be next up-number.", - nextUpBits, resultBits); - } else if (direction < start) { - assertEquals("Result should be next down-number.", - nextDownBits, resultBits); - } else { - assertEquals("Result should be direction.", directionBits, - resultBits); - } - } - } - - // test for cases with NaN - for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { - assertTrue("The result should be NaN.", Double.isNaN(StrictMath - .nextAfter(NEXTAFTER_DD_START_CASES[i][0], Double.NaN))); - } - for (int i = 0; i < NEXTAFTER_DD_FD_DIRECTION_CASES.length; i++) { - assertTrue("The result should be NaN.", Double.isNaN(StrictMath - .nextAfter(Double.NaN, NEXTAFTER_DD_FD_DIRECTION_CASES[i]))); - } - assertTrue("The result should be NaN.", Double.isNaN(StrictMath - .nextAfter(Double.NaN, Double.NaN))); - - // test for exception - try { - StrictMath.nextAfter((Double) null, 2.3); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.nextAfter(2.3, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.nextAfter((Double) null, (Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.StrictMath#nextAfter(float, double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextAfter_FD() { - // test for most cases without exception - for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { - final float start = NEXTAFTER_FD_START_CASES[i][0]; - final int nextUpBits = Float - .floatToIntBits(NEXTAFTER_FD_START_CASES[i][1]); - final int nextDownBits = Float - .floatToIntBits(NEXTAFTER_FD_START_CASES[i][2]); - - for (int j = 0; j < NEXTAFTER_DD_FD_DIRECTION_CASES.length; j++) { - final double direction = NEXTAFTER_DD_FD_DIRECTION_CASES[j]; - final int resultBits = Float.floatToIntBits(StrictMath - .nextAfter(start, direction)); - if (direction > start) { - assertEquals("Result should be next up-number.", - nextUpBits, resultBits); - } else if (direction < start) { - assertEquals("Result should be next down-number.", - nextDownBits, resultBits); - } else { - final int equivalentBits = Float.floatToIntBits(new Float( - direction)); - assertEquals( - "Result should be a number equivalent to direction.", - equivalentBits, resultBits); - } - } - } - - // test for cases with NaN - for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { - assertTrue("The result should be NaN.", Float.isNaN(StrictMath - .nextAfter(NEXTAFTER_FD_START_CASES[i][0], Float.NaN))); - } - for (int i = 0; i < NEXTAFTER_DD_FD_DIRECTION_CASES.length; i++) { - assertTrue("The result should be NaN.", Float.isNaN(StrictMath - .nextAfter(Float.NaN, NEXTAFTER_DD_FD_DIRECTION_CASES[i]))); - } - assertTrue("The result should be NaN.", Float.isNaN(StrictMath - .nextAfter(Float.NaN, Float.NaN))); - - // test for exception - try { - StrictMath.nextAfter((Float) null, 2.3); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.nextAfter(2.3, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.nextAfter((Float) null, (Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.StrictMath#nextUp(double)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextUp_D() { - // This method is semantically equivalent to nextAfter(d, - // Double.POSITIVE_INFINITY), - // so we use the data of test_nextAfter_DD - for (int i = 0; i < NEXTAFTER_DD_START_CASES.length; i++) { - final double start = NEXTAFTER_DD_START_CASES[i][0]; - final long nextUpBits = Double - .doubleToLongBits(NEXTAFTER_DD_START_CASES[i][1]); - final long resultBits = Double.doubleToLongBits(StrictMath - .nextUp(start)); - assertEquals("Result should be next up-number.", nextUpBits, - resultBits); - } - - // test for cases with NaN - assertTrue("The result should be NaN.", Double.isNaN(StrictMath - .nextUp(Double.NaN))); - - // test for exception - try { - StrictMath.nextUp((Double) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.StrictMath#nextUp(float)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_nextUp_F() { - // This method is semantically equivalent to nextAfter(f, - // Float.POSITIVE_INFINITY), - // so we use the data of test_nextAfter_FD - for (int i = 0; i < NEXTAFTER_FD_START_CASES.length; i++) { - final float start = NEXTAFTER_FD_START_CASES[i][0]; - final int nextUpBits = Float - .floatToIntBits(NEXTAFTER_FD_START_CASES[i][1]); - final int resultBits = Float.floatToIntBits(StrictMath - .nextUp(start)); - assertEquals("Result should be next up-number.", nextUpBits, - resultBits); - } - - // test for cases with NaN - assertTrue("The result should be NaN.", Float.isNaN(StrictMath - .nextUp(Float.NaN))); - - // test for exception - try { - StrictMath.nextUp((Float) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StrictMath#pow(double, double) - */ - public void test_powDD() { - // Test for method double java.lang.StrictMath.pow(double, double) - assertTrue("pow returned incorrect value", - (long) StrictMath.pow(2, 8) == 256l); - assertTrue("pow returned incorrect value", - StrictMath.pow(2, -8) == 0.00390625d); - } - - /** - * @tests java.lang.StrictMath#rint(double) - */ - public void test_rintD() { - // Test for method double java.lang.StrictMath.rint(double) - assertEquals("Failed to round properly - up to odd", - 3.0, StrictMath.rint(2.9), 0D); - assertTrue("Failed to round properly - NaN", Double.isNaN(StrictMath - .rint(Double.NaN))); - assertEquals("Failed to round properly down to even", 2.0, StrictMath - .rint(2.1), 0D); - assertTrue("Failed to round properly " + 2.5 + " to even", StrictMath - .rint(2.5) == 2.0); - } - - /** - * @tests java.lang.StrictMath#round(double) - */ - public void test_roundD() { - // Test for method long java.lang.StrictMath.round(double) - assertEquals("Incorrect rounding of a float", - -91, StrictMath.round(-90.89d)); - } - - /** - * @tests java.lang.StrictMath#round(float) - */ - public void test_roundF() { - // Test for method int java.lang.StrictMath.round(float) - assertEquals("Incorrect rounding of a float", - -91, StrictMath.round(-90.89f)); - } - - /** - * @tests {@link java.lang.StrictMath#scalb(double, int)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_scalb_DI() { - // result is normal - assertEquals(4.1422946304E7, StrictMath.scalb(1.2345, 25)); - assertEquals(3.679096698760986E-8, StrictMath.scalb(1.2345, -25)); - assertEquals(1.2345, StrictMath.scalb(1.2345, 0)); - assertEquals(7868514.304, StrictMath.scalb(0.2345, 25)); - - double normal = StrictMath.scalb(0.2345, -25); - assertEquals(6.98864459991455E-9, normal); - // precision kept - assertEquals(0.2345, StrictMath.scalb(normal, 25)); - - assertEquals(0.2345, StrictMath.scalb(0.2345, 0)); - assertEquals(-4.1422946304E7, StrictMath.scalb(-1.2345, 25)); - assertEquals(-6.98864459991455E-9, StrictMath.scalb(-0.2345, -25)); - assertEquals(2.0, StrictMath.scalb(Double.MIN_NORMAL / 2, 1024)); - assertEquals(64.0, StrictMath.scalb(Double.MIN_VALUE, 1080)); - assertEquals(234, StrictMath.getExponent(StrictMath.scalb(1.0, 234))); - assertEquals(3.9999999999999996, StrictMath.scalb(Double.MAX_VALUE, - Double.MIN_EXPONENT)); - - // result is near infinity - double halfMax = StrictMath.scalb(1.0, Double.MAX_EXPONENT); - assertEquals(8.98846567431158E307, halfMax); - assertEquals(Double.MAX_VALUE, halfMax - StrictMath.ulp(halfMax) - + halfMax); - assertEquals(Double.POSITIVE_INFINITY, halfMax + halfMax); - assertEquals(1.7976931348623155E308, StrictMath.scalb(1.0 - StrictMath - .ulp(1.0), Double.MAX_EXPONENT + 1)); - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb( - 1.0 - StrictMath.ulp(1.0), Double.MAX_EXPONENT + 2)); - - halfMax = StrictMath.scalb(-1.0, Double.MAX_EXPONENT); - assertEquals(-8.98846567431158E307, halfMax); - assertEquals(-Double.MAX_VALUE, halfMax + StrictMath.ulp(halfMax) - + halfMax); - assertEquals(Double.NEGATIVE_INFINITY, halfMax + halfMax); - - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb(0.345, 1234)); - assertEquals(Double.POSITIVE_INFINITY, StrictMath - .scalb(44.345E102, 934)); - assertEquals(Double.NEGATIVE_INFINITY, StrictMath.scalb(-44.345E102, - 934)); - - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb( - Double.MIN_NORMAL / 2, 4000)); - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb( - Double.MIN_VALUE, 8000)); - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb( - Double.MAX_VALUE, 1)); - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb( - Double.POSITIVE_INFINITY, 0)); - assertEquals(Double.POSITIVE_INFINITY, StrictMath.scalb( - Double.POSITIVE_INFINITY, -1)); - assertEquals(Double.NEGATIVE_INFINITY, StrictMath.scalb( - Double.NEGATIVE_INFINITY, -1)); - assertEquals(Double.NEGATIVE_INFINITY, StrictMath.scalb( - Double.NEGATIVE_INFINITY, Double.MIN_EXPONENT)); - - // result is subnormal/zero - long posZeroBits = Double.doubleToLongBits(+0.0); - long negZeroBits = Double.doubleToLongBits(-0.0); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - +0.0, Integer.MAX_VALUE))); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - +0.0, -123))); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - +0.0, 0))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -0.0, 123))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -0.0, Integer.MIN_VALUE))); - - assertEquals(Double.MIN_VALUE, StrictMath.scalb(1.0, -1074)); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb(1.0, - -1075))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -1.0, -1075))); - - // precision lost - assertEquals(StrictMath.scalb(21.405, -1078), StrictMath.scalb(21.405, - -1079)); - assertEquals(Double.MIN_VALUE, StrictMath.scalb(21.405, -1079)); - assertEquals(-Double.MIN_VALUE, StrictMath.scalb(-21.405, -1079)); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - 21.405, -1080))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -21.405, -1080))); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - Double.MIN_VALUE, -1))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -Double.MIN_VALUE, -1))); - assertEquals(Double.MIN_VALUE, StrictMath.scalb(Double.MIN_NORMAL, -52)); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - Double.MIN_NORMAL, -53))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -Double.MIN_NORMAL, -53))); - assertEquals(Double.MIN_VALUE, StrictMath - .scalb(Double.MAX_VALUE, -2098)); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - Double.MAX_VALUE, -2099))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -Double.MAX_VALUE, -2099))); - assertEquals(Double.MIN_VALUE, StrictMath.scalb(Double.MIN_NORMAL / 3, - -51)); - assertEquals(posZeroBits, Double.doubleToLongBits(StrictMath.scalb( - Double.MIN_NORMAL / 3, -52))); - assertEquals(negZeroBits, Double.doubleToLongBits(StrictMath.scalb( - -Double.MIN_NORMAL / 3, -52))); - double subnormal = StrictMath.scalb(Double.MIN_NORMAL / 3, -25); - assertEquals(2.2104123E-316, subnormal); - // precision lost - assertFalse(Double.MIN_NORMAL / 3 == StrictMath.scalb(subnormal, 25)); - - // NaN - assertTrue(Double.isNaN(StrictMath.scalb(Double.NaN, 1))); - assertTrue(Double.isNaN(StrictMath.scalb(Double.NaN, 0))); - assertTrue(Double.isNaN(StrictMath.scalb(Double.NaN, -120))); - - assertEquals(1283457024, Double.doubleToLongBits(StrictMath.scalb( - Double.MIN_VALUE * 153, 23))); - assertEquals(-9223372035571318784L, Double.doubleToLongBits(StrictMath - .scalb(-Double.MIN_VALUE * 153, 23))); - assertEquals(36908406321184768L, Double.doubleToLongBits(StrictMath - .scalb(Double.MIN_VALUE * 153, 52))); - assertEquals(-9186463630533591040L, Double.doubleToLongBits(StrictMath - .scalb(-Double.MIN_VALUE * 153, 52))); - - // test for exception - try { - StrictMath.scalb((Double) null, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.scalb(1.0, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.scalb((Double) null, 1); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.StrictMath#scalb(float, int)} - * @since 1.6 - */ - @SuppressWarnings("boxing") - public void test_scalb_FI() { - // result is normal - assertEquals(4.1422946304E7f, StrictMath.scalb(1.2345f, 25)); - assertEquals(3.679096698760986E-8f, StrictMath.scalb(1.2345f, -25)); - assertEquals(1.2345f, StrictMath.scalb(1.2345f, 0)); - assertEquals(7868514.304f, StrictMath.scalb(0.2345f, 25)); - - float normal = StrictMath.scalb(0.2345f, -25); - assertEquals(6.98864459991455E-9f, normal); - // precision kept - assertEquals(0.2345f, StrictMath.scalb(normal, 25)); - - assertEquals(0.2345f, StrictMath.scalb(0.2345f, 0)); - assertEquals(-4.1422946304E7f, StrictMath.scalb(-1.2345f, 25)); - assertEquals(-6.98864459991455E-9f, StrictMath.scalb(-0.2345f, -25)); - assertEquals(2.0f, StrictMath.scalb(Float.MIN_NORMAL / 2, 128)); - assertEquals(64.0f, StrictMath.scalb(Float.MIN_VALUE, 155)); - assertEquals(34, StrictMath.getExponent(StrictMath.scalb(1.0f, 34))); - assertEquals(3.9999998f, StrictMath.scalb(Float.MAX_VALUE, - Float.MIN_EXPONENT)); - - // result is near infinity - float halfMax = StrictMath.scalb(1.0f, Float.MAX_EXPONENT); - assertEquals(1.7014118E38f, halfMax); - assertEquals(Float.MAX_VALUE, halfMax - StrictMath.ulp(halfMax) - + halfMax); - assertEquals(Float.POSITIVE_INFINITY, halfMax + halfMax); - assertEquals(3.4028233E38f, StrictMath.scalb(1.0f - StrictMath - .ulp(1.0f), Float.MAX_EXPONENT + 1)); - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb( - 1.0f - StrictMath.ulp(1.0f), Float.MAX_EXPONENT + 2)); - - halfMax = StrictMath.scalb(-1.0f, Float.MAX_EXPONENT); - assertEquals(-1.7014118E38f, halfMax); - assertEquals(-Float.MAX_VALUE, halfMax + StrictMath.ulp(halfMax) - + halfMax); - assertEquals(Float.NEGATIVE_INFINITY, halfMax + halfMax); - - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb(0.345f, 1234)); - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb(44.345E10f, 934)); - assertEquals(Float.NEGATIVE_INFINITY, StrictMath - .scalb(-44.345E10f, 934)); - - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb( - Float.MIN_NORMAL / 2, 400)); - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb(Float.MIN_VALUE, - 800)); - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb(Float.MAX_VALUE, - 1)); - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb( - Float.POSITIVE_INFINITY, 0)); - assertEquals(Float.POSITIVE_INFINITY, StrictMath.scalb( - Float.POSITIVE_INFINITY, -1)); - assertEquals(Float.NEGATIVE_INFINITY, StrictMath.scalb( - Float.NEGATIVE_INFINITY, -1)); - assertEquals(Float.NEGATIVE_INFINITY, StrictMath.scalb( - Float.NEGATIVE_INFINITY, Float.MIN_EXPONENT)); - - // result is subnormal/zero - int posZeroBits = Float.floatToIntBits(+0.0f); - int negZeroBits = Float.floatToIntBits(-0.0f); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb(+0.0f, - Integer.MAX_VALUE))); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb(+0.0f, - -123))); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb(+0.0f, - 0))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb(-0.0f, - 123))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb(-0.0f, - Integer.MIN_VALUE))); - - assertEquals(Float.MIN_VALUE, StrictMath.scalb(1.0f, -149)); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb(1.0f, - -150))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb(-1.0f, - -150))); - - // precision lost - assertEquals(StrictMath.scalb(21.405f, -154), StrictMath.scalb(21.405f, - -153)); - assertEquals(Float.MIN_VALUE, StrictMath.scalb(21.405f, -154)); - assertEquals(-Float.MIN_VALUE, StrictMath.scalb(-21.405f, -154)); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb( - 21.405f, -155))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb( - -21.405f, -155))); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb( - Float.MIN_VALUE, -1))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb( - -Float.MIN_VALUE, -1))); - assertEquals(Float.MIN_VALUE, StrictMath.scalb(Float.MIN_NORMAL, -23)); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb( - Float.MIN_NORMAL, -24))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb( - -Float.MIN_NORMAL, -24))); - assertEquals(Float.MIN_VALUE, StrictMath.scalb(Float.MAX_VALUE, -277)); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb( - Float.MAX_VALUE, -278))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb( - -Float.MAX_VALUE, -278))); - assertEquals(Float.MIN_VALUE, StrictMath.scalb(Float.MIN_NORMAL / 3, - -22)); - assertEquals(posZeroBits, Float.floatToIntBits(StrictMath.scalb( - Float.MIN_NORMAL / 3, -23))); - assertEquals(negZeroBits, Float.floatToIntBits(StrictMath.scalb( - -Float.MIN_NORMAL / 3, -23))); - float subnormal = StrictMath.scalb(Float.MIN_NORMAL / 3, -11); - assertEquals(1.913E-42f, subnormal); - // precision lost - assertFalse(Float.MIN_NORMAL / 3 == StrictMath.scalb(subnormal, 11)); - - assertEquals(68747264, Float.floatToIntBits(StrictMath.scalb( - Float.MIN_VALUE * 153, 23))); - assertEquals(-2078736384, Float.floatToIntBits(StrictMath.scalb( - -Float.MIN_VALUE * 153, 23))); - - assertEquals(4896, Float.floatToIntBits(StrictMath.scalb( - Float.MIN_VALUE * 153, 5))); - assertEquals(-2147478752, Float.floatToIntBits(StrictMath.scalb( - -Float.MIN_VALUE * 153, 5))); - - // NaN - assertTrue(Float.isNaN(StrictMath.scalb(Float.NaN, 1))); - assertTrue(Float.isNaN(StrictMath.scalb(Float.NaN, 0))); - assertTrue(Float.isNaN(StrictMath.scalb(Float.NaN, -120))); - - // test for exception - try { - StrictMath.scalb((Float) null, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.scalb(1.0f, (Integer) null); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - try { - StrictMath.scalb((Float) null, 1); - fail("Should throw NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StrictMath#signum(double) - */ - public void test_signum_D() { - assertTrue(Double.isNaN(StrictMath.signum(Double.NaN))); - assertEquals(Double.doubleToLongBits(0.0), Double - .doubleToLongBits(StrictMath.signum(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(StrictMath.signum(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(StrictMath.signum(-0.0))); - - assertEquals(1.0, StrictMath.signum(253681.2187962), 0D); - assertEquals(-1.0, StrictMath.signum(-125874693.56), 0D); - assertEquals(1.0, StrictMath.signum(1.2587E-308), 0D); - assertEquals(-1.0, StrictMath.signum(-1.2587E-308), 0D); - - assertEquals(1.0, StrictMath.signum(Double.MAX_VALUE), 0D); - assertEquals(1.0, StrictMath.signum(Double.MIN_VALUE), 0D); - assertEquals(-1.0, StrictMath.signum(-Double.MAX_VALUE), 0D); - assertEquals(-1.0, StrictMath.signum(-Double.MIN_VALUE), 0D); - assertEquals(1.0, StrictMath.signum(Double.POSITIVE_INFINITY), 0D); - assertEquals(-1.0, StrictMath.signum(Double.NEGATIVE_INFINITY), 0D); - - } - - /** - * @tests java.lang.StrictMath#signum(float) - */ - public void test_signum_F() { - assertTrue(Float.isNaN(StrictMath.signum(Float.NaN))); - assertEquals(Float.floatToIntBits(0.0f), Float - .floatToIntBits(StrictMath.signum(0.0f))); - assertEquals(Float.floatToIntBits(+0.0f), Float - .floatToIntBits(StrictMath.signum(+0.0f))); - assertEquals(Float.floatToIntBits(-0.0f), Float - .floatToIntBits(StrictMath.signum(-0.0f))); - - assertEquals(1.0f, StrictMath.signum(253681.2187962f), 0f); - assertEquals(-1.0f, StrictMath.signum(-125874693.56f), 0f); - assertEquals(1.0f, StrictMath.signum(1.2587E-11f), 0f); - assertEquals(-1.0f, StrictMath.signum(-1.2587E-11f), 0f); - - assertEquals(1.0f, StrictMath.signum(Float.MAX_VALUE), 0f); - assertEquals(1.0f, StrictMath.signum(Float.MIN_VALUE), 0f); - assertEquals(-1.0f, StrictMath.signum(-Float.MAX_VALUE), 0f); - assertEquals(-1.0f, StrictMath.signum(-Float.MIN_VALUE), 0f); - assertEquals(1.0f, StrictMath.signum(Float.POSITIVE_INFINITY), 0f); - assertEquals(-1.0f, StrictMath.signum(Float.NEGATIVE_INFINITY), 0f); - } - - /** - * @tests java.lang.StrictMath#sin(double) - */ - public void test_sinD() { - // Test for method double java.lang.StrictMath.sin(double) - assertTrue("Returned incorrect sine", StrictMath.sin(StrictMath - .asin(OPP / HYP)) == OPP / HYP); - } - - /** - * @tests java.lang.StrictMath#sinh(double) - */ - public void test_sinh_D() { - // Test for special situations - assertTrue(Double.isNaN(StrictMath.sinh(Double.NaN))); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath - .sinh(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, StrictMath - .sinh(Double.NEGATIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double - .doubleToLongBits(StrictMath.sinh(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(StrictMath.sinh(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(StrictMath.sinh(-0.0))); - - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.sinh(1234.56), 0D); - assertEquals("Should return NEGATIVE_INFINITY", - Double.NEGATIVE_INFINITY, StrictMath.sinh(-1234.56), 0D); - assertEquals("Should return 1.0000000000001666E-6", - 1.0000000000001666E-6, StrictMath.sinh(0.000001), 0D); - assertEquals("Should return -1.0000000000001666E-6", - -1.0000000000001666E-6, StrictMath.sinh(-0.000001), 0D); - assertEquals("Should return 5.115386441963859", 5.115386441963859, - StrictMath.sinh(2.33482), 0D); - assertEquals("Should return POSITIVE_INFINITY", - Double.POSITIVE_INFINITY, StrictMath.sinh(Double.MAX_VALUE), 0D); - assertEquals("Should return 4.9E-324", 4.9E-324, StrictMath - .sinh(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.StrictMath#sqrt(double) - */ - public void test_sqrtD() { - // Test for method double java.lang.StrictMath.sqrt(double) - assertEquals("Incorrect root returned1", - 2, StrictMath.sqrt(StrictMath.pow(StrictMath.sqrt(2), 4)), 0.0); - assertEquals("Incorrect root returned2", 7, StrictMath.sqrt(49), 0.0); - } - - /** - * @tests java.lang.StrictMath#tan(double) - */ - public void test_tanD() { - // Test for method double java.lang.StrictMath.tan(double) - assertTrue( - "Returned incorrect tangent: ", - StrictMath.tan(StrictMath.atan(1.0)) <= 1.0 - || StrictMath.tan(StrictMath.atan(1.0)) >= 9.9999999999999983E-1); - } - - /** - * @tests java.lang.StrictMath#tanh(double) - */ - public void test_tanh_D() { - // Test for special situations - assertTrue(Double.isNaN(StrictMath.tanh(Double.NaN))); - assertEquals("Should return +1.0", +1.0, StrictMath - .tanh(Double.POSITIVE_INFINITY), 0D); - assertEquals("Should return -1.0", -1.0, StrictMath - .tanh(Double.NEGATIVE_INFINITY), 0D); - assertEquals(Double.doubleToLongBits(0.0), Double - .doubleToLongBits(StrictMath.tanh(0.0))); - assertEquals(Double.doubleToLongBits(+0.0), Double - .doubleToLongBits(StrictMath.tanh(+0.0))); - assertEquals(Double.doubleToLongBits(-0.0), Double - .doubleToLongBits(StrictMath.tanh(-0.0))); - - assertEquals("Should return 1.0", 1.0, StrictMath.tanh(1234.56), 0D); - assertEquals("Should return -1.0", -1.0, StrictMath.tanh(-1234.56), 0D); - assertEquals("Should return 9.999999999996666E-7", - 9.999999999996666E-7, StrictMath.tanh(0.000001), 0D); - assertEquals("Should return 0.981422884124941", 0.981422884124941, - StrictMath.tanh(2.33482), 0D); - assertEquals("Should return 1.0", 1.0, StrictMath - .tanh(Double.MAX_VALUE), 0D); - assertEquals("Should return 4.9E-324", 4.9E-324, StrictMath - .tanh(Double.MIN_VALUE), 0D); - } - - /** - * @tests java.lang.StrictMath#random() - */ - public void test_random() { - // There isn't a place for these tests so just stick them here - assertEquals("Wrong value E", - 4613303445314885481L, Double.doubleToLongBits(StrictMath.E)); - assertEquals("Wrong value PI", - 4614256656552045848L, Double.doubleToLongBits(StrictMath.PI)); - - for (int i = 500; i >= 0; i--) { - double d = StrictMath.random(); - assertTrue("Generated number is out of range: " + d, d >= 0.0 - && d < 1.0); - } - } - - /** - * @tests java.lang.StrictMath#toRadians(double) - */ - public void test_toRadiansD() { - for (double d = 500; d >= 0; d -= 1.0) { - double converted = StrictMath.toDegrees(StrictMath.toRadians(d)); - assertTrue("Converted number not equal to original. d = " + d, - converted >= d * 0.99999999 && converted <= d * 1.00000001); - } - } - - /** - * @tests java.lang.StrictMath#toDegrees(double) - */ - public void test_toDegreesD() { - for (double d = 500; d >= 0; d -= 1.0) { - double converted = StrictMath.toRadians(StrictMath.toDegrees(d)); - assertTrue("Converted number not equal to original. d = " + d, - converted >= d * 0.99999999 && converted <= d * 1.00000001); - } - } - - /** - * @tests java.lang.StrictMath#ulp(double) - */ - @SuppressWarnings("boxing") - public void test_ulp_D() { - // Test for special cases - assertTrue("Should return NaN", Double - .isNaN(StrictMath.ulp(Double.NaN))); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, - StrictMath.ulp(Double.POSITIVE_INFINITY), 0D); - assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, - StrictMath.ulp(Double.NEGATIVE_INFINITY), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, StrictMath - .ulp(0.0), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, StrictMath - .ulp(+0.0), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, StrictMath - .ulp(-0.0), 0D); - assertEquals("Returned incorrect value", StrictMath.pow(2, 971), - StrictMath.ulp(Double.MAX_VALUE), 0D); - assertEquals("Returned incorrect value", StrictMath.pow(2, 971), - StrictMath.ulp(-Double.MAX_VALUE), 0D); - - assertEquals("Returned incorrect value", Double.MIN_VALUE, StrictMath - .ulp(Double.MIN_VALUE), 0D); - assertEquals("Returned incorrect value", Double.MIN_VALUE, StrictMath - .ulp(-Double.MIN_VALUE), 0D); - - assertEquals("Returned incorrect value", 2.220446049250313E-16, - StrictMath.ulp(1.0), 0D); - assertEquals("Returned incorrect value", 2.220446049250313E-16, - StrictMath.ulp(-1.0), 0D); - assertEquals("Returned incorrect value", 2.2737367544323206E-13, - StrictMath.ulp(1153.0), 0D); - } - - /** - * @tests java.lang.StrictMath#ulp(float) - */ - @SuppressWarnings("boxing") - public void test_ulp_f() { - // Test for special cases - assertTrue("Should return NaN", Float.isNaN(StrictMath.ulp(Float.NaN))); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, - StrictMath.ulp(Float.POSITIVE_INFINITY), 0f); - assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, - StrictMath.ulp(Float.NEGATIVE_INFINITY), 0f); - assertEquals("Returned incorrect value", Float.MIN_VALUE, StrictMath - .ulp(0.0f), 0f); - assertEquals("Returned incorrect value", Float.MIN_VALUE, StrictMath - .ulp(+0.0f), 0f); - assertEquals("Returned incorrect value", Float.MIN_VALUE, StrictMath - .ulp(-0.0f), 0f); - assertEquals("Returned incorrect value", 2.028241E31f, StrictMath - .ulp(Float.MAX_VALUE), 0f); - assertEquals("Returned incorrect value", 2.028241E31f, StrictMath - .ulp(-Float.MAX_VALUE), 0f); - - assertEquals("Returned incorrect value", 1.4E-45f, StrictMath - .ulp(Float.MIN_VALUE), 0f); - assertEquals("Returned incorrect value", 1.4E-45f, StrictMath - .ulp(-Float.MIN_VALUE), 0f); - - assertEquals("Returned incorrect value", 1.1920929E-7f, StrictMath - .ulp(1.0f), 0f); - assertEquals("Returned incorrect value", 1.1920929E-7f, StrictMath - .ulp(-1.0f), 0f); - assertEquals("Returned incorrect value", 1.2207031E-4f, StrictMath - .ulp(1153.0f), 0f); - assertEquals("Returned incorrect value", 5.6E-45f, Math - .ulp(9.403954E-38f), 0f); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBuffer2Test.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBuffer2Test.java deleted file mode 100644 index 0fa41b9..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBuffer2Test.java +++ /dev/null @@ -1,1106 +0,0 @@ -/* - * 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.KnownFailure; -import dalvik.annotation.TestTargets; -import dalvik.annotation.TestLevel; -import dalvik.annotation.TestTargetNew; -import dalvik.annotation.TestTargetClass; - -@TestTargetClass(StringBuffer.class) -public class StringBuffer2Test extends junit.framework.TestCase { - - StringBuffer testBuffer; - - /** - * @tests java.lang.StringBuffer#StringBuffer() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "StringBuffer", - args = {} - ) - public void test_Constructor() { - // Test for method java.lang.StringBuffer() - new StringBuffer(); - assertTrue("Invalid buffer created", true); - } - - /** - * @tests java.lang.StringBuffer#StringBuffer(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "StringBuffer", - args = {int.class} - ) - public void test_ConstructorI() { - // Test for method java.lang.StringBuffer(int) - StringBuffer sb = new StringBuffer(8); - assertEquals("Newly constructed buffer is of incorrect length", 0, sb - .length()); - } - - /** - * @tests java.lang.StringBuffer#StringBuffer(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "StringBuffer", - args = {java.lang.String.class} - ) - public void test_ConstructorLjava_lang_String() { - // Test for method java.lang.StringBuffer(java.lang.String) - - StringBuffer sb = new StringBuffer("HelloWorld"); - - assertTrue("Invalid buffer created", sb.length() == 10 - && (sb.toString().equals("HelloWorld"))); - - boolean pass = false; - try { - new StringBuffer(null); - } catch (NullPointerException e) { - pass = true; - } - assertTrue("Should throw NullPointerException", pass); - } - - /** - * @tests java.lang.StringBuffer#append(char[]) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {char[].class} - ) - public void test_append$C() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(char []) - char buf[] = new char[4]; - "char".getChars(0, 4, buf, 0); - testBuffer.append(buf); - assertEquals("Append of char[] failed", - "This is a test bufferchar", testBuffer.toString()); - } - - /** - * @tests java.lang.StringBuffer#append(char[], int, int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "", - method = "append", - args = {char[].class, int.class, int.class} - ) - public void test_append$CII() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(char [], int, int) - StringBuffer sb = new StringBuffer(); - char[] buf1 = { 'H', 'e', 'l', 'l', 'o' }; - char[] buf2 = { 'W', 'o', 'r', 'l', 'd' }; - sb.append(buf1, 0, buf1.length); - assertEquals("Buffer is invalid length after append", 5, sb.length()); - sb.append(buf2, 0, buf2.length); - assertEquals("Buffer is invalid length after append", 10, sb.length()); - assertTrue("Buffer contains invalid chars", (sb.toString() - .equals("HelloWorld"))); - } - - /** - * @tests java.lang.StringBuffer#append(char) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {char.class} - ) - public void test_appendC() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(char) - StringBuffer sb = new StringBuffer(); - char buf1 = 'H'; - char buf2 = 'W'; - sb.append(buf1); - assertEquals("Buffer is invalid length after append", 1, sb.length()); - sb.append(buf2); - assertEquals("Buffer is invalid length after append", 2, sb.length()); - assertTrue("Buffer contains invalid chars", - (sb.toString().equals("HW"))); - } - - /** - * @tests java.lang.StringBuffer#append(double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {double.class} - ) - public void test_appendD() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(double) - StringBuffer sb = new StringBuffer(); - sb.append(Double.MAX_VALUE); - assertEquals("Buffer is invalid length after append", 22, sb.length()); - assertEquals("Buffer contains invalid characters", - "1.7976931348623157E308", sb.toString()); - } - - /** - * @tests java.lang.StringBuffer#append(float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {float.class} - ) - public void test_appendF() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(float) - StringBuffer sb = new StringBuffer(); - final float floatNum = 900.87654F; - sb.append(floatNum); - assertTrue("Buffer is invalid length after append: " + sb.length(), sb - .length() == String.valueOf(floatNum).length()); - assertTrue("Buffer contains invalid characters", sb.toString().equals( - String.valueOf(floatNum))); - } - - /** - * @tests java.lang.StringBuffer#append(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {int.class} - ) - public void test_appendI() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(int) - StringBuffer sb = new StringBuffer(); - sb.append(9000); - assertEquals("Buffer is invalid length after append", 4, sb.length()); - sb.append(1000); - assertEquals("Buffer is invalid length after append", 8, sb.length()); - assertEquals("Buffer contains invalid characters", - "90001000", sb.toString()); - } - - /** - * @tests java.lang.StringBuffer#append(long) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {long.class} - ) - public void test_appendJ() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(long) - - StringBuffer sb = new StringBuffer(); - long t = 927654321098L; - sb.append(t); - assertEquals("Buffer is of invlaid length", 12, sb.length()); - assertEquals("Buffer contains invalid characters", - "927654321098", sb.toString()); - } - - /** - * @tests java.lang.StringBuffer#append(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {java.lang.Object.class} - ) - public void test_appendLjava_lang_Object() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(java.lang.Object) - StringBuffer sb = new StringBuffer(); - Object obj1 = new Object(); - Object obj2 = new Object(); - sb.append(obj1); - sb.append(obj2); - assertTrue("Buffer contains invalid characters", sb.toString().equals( - obj1.toString() + obj2.toString())); - } - - /** - * @tests java.lang.StringBuffer#append(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {java.lang.String.class} - ) - public void test_appendLjava_lang_String() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(java.lang.String) - StringBuffer sb = new StringBuffer(); - String buf1 = "Hello"; - String buf2 = "World"; - sb.append(buf1); - assertEquals("Buffer is invalid length after append", 5, sb.length()); - sb.append(buf2); - assertEquals("Buffer is invalid length after append", 10, sb.length()); - assertTrue("Buffer contains invalid chars", (sb.toString() - .equals("HelloWorld"))); - } - - /** - * @tests java.lang.StringBuffer#append(boolean) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "append", - args = {boolean.class} - ) - public void test_appendZ() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.append(boolean) - StringBuffer sb = new StringBuffer(); - sb.append(false); - assertEquals("Buffer is invalid length after append", 5, sb.length()); - sb.append(true); - assertEquals("Buffer is invalid length after append", 9, sb.length()); - assertTrue("Buffer is invalid length after append", (sb.toString() - .equals("falsetrue"))); - } - - /** - * @tests java.lang.StringBuffer#capacity() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "capacity", - args = {} - ) - public void test_capacity() { - // Test for method int java.lang.StringBuffer.capacity() - StringBuffer sb = new StringBuffer(10); - assertEquals("Returned incorrect capacity", 10, sb.capacity()); - sb.ensureCapacity(100); - assertTrue("Returned incorrect capacity", sb.capacity() >= 100); - } - - /** - * @tests java.lang.StringBuffer#charAt(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "charAt", - args = {int.class} - ) - public void test_charAtI() { - // Test for method char java.lang.StringBuffer.charAt(int) - assertEquals("Returned incorrect char", 's', testBuffer.charAt(3)); - - // Test for StringIndexOutOfBoundsException - boolean exception = false; - try { - testBuffer.charAt(-1); - } catch (StringIndexOutOfBoundsException e) { - exception = true; - } catch (ArrayIndexOutOfBoundsException e) { - } - assertTrue("Should throw StringIndexOutOfBoundsException", exception); - } - - /** - * @tests java.lang.StringBuffer#delete(int, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "delete", - args = {int.class, int.class} - ) - public void test_deleteII() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.delete(int, int) - testBuffer.delete(7, 7); - assertEquals("Deleted chars when start == end", "This is a test buffer", testBuffer.toString() - ); - testBuffer.delete(4, 14); - assertEquals("Deleted incorrect chars", - "This buffer", testBuffer.toString()); - - testBuffer = new StringBuffer("This is a test buffer"); - String sharedStr = testBuffer.toString(); - testBuffer.delete(0, testBuffer.length()); - assertEquals("Didn't clone shared buffer", "This is a test buffer", sharedStr - ); - assertTrue("Deleted incorrect chars", testBuffer.toString().equals("")); - testBuffer.append("more stuff"); - assertEquals("Didn't clone shared buffer 2", "This is a test buffer", sharedStr - ); - assertEquals("Wrong contents", "more stuff", testBuffer.toString()); - try { - testBuffer.delete(-5, 2); - } catch (IndexOutOfBoundsException e) { - } - assertEquals("Wrong contents 2", - "more stuff", testBuffer.toString()); - } - - /** - * @tests java.lang.StringBuffer#deleteCharAt(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "deleteCharAt", - args = {int.class} - ) - public void test_deleteCharAtI() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.deleteCharAt(int) - testBuffer.deleteCharAt(3); - assertEquals("Deleted incorrect char", - "Thi is a test buffer", testBuffer.toString()); - try { - testBuffer.deleteCharAt(testBuffer.length() + 1); - fail("StringIndexOutOfBoundsException was not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.deleteCharAt(-1); - fail("StringIndexOutOfBoundsException was not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#ensureCapacity(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "ensureCapacity", - args = {int.class} - ) - public void test_ensureCapacityI() { - // Test for method void java.lang.StringBuffer.ensureCapacity(int) - StringBuffer sb = new StringBuffer(10); - - sb.ensureCapacity(-2); - assertEquals("Failed to increase capacity.", 10, sb.capacity()); - - sb.ensureCapacity(100); - assertTrue("Failed to increase capacity", sb.capacity() >= 100); - - try { - sb.ensureCapacity(Integer.MAX_VALUE); - fail("OutOfMemoryError should be thrown."); - } catch(java.lang.OutOfMemoryError oome) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#getChars(int, int, char[], int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "Doesn't check exceptions.", - method = "getChars", - args = {int.class, int.class, char[].class, int.class} - ) - public void test_getCharsII$CI() { - // Test for method void java.lang.StringBuffer.getChars(int, int, char - // [], int) - - char[] buf = new char[10]; - testBuffer.getChars(4, 8, buf, 2); - assertTrue("Returned incorrect chars", new String(buf, 2, 4) - .equals(testBuffer.toString().substring(4, 8))); - - StringBuffer buf2 = new StringBuffer(""); - try { - buf2.getChars(-1, 0, new char[5], 2); - fail("IndexOutOfBoundsException is not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected - } - - try { - buf2.getChars(0, -1, new char[5], 2); - fail("IndexOutOfBoundsException is not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected - } - - try { - buf2.getChars(0, -1, new char[5], 2); - fail("IndexOutOfBoundsException is not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected - } - - try { - buf2.getChars(2, 1, new char[5], 2); - fail("IndexOutOfBoundsException is not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected - } - - try { - buf2.getChars(0, 6, new char[5], 2); - fail("IndexOutOfBoundsException is not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected - } - - try { - buf2.getChars(0, 6, new char[10], 5); - fail("IndexOutOfBoundsException is not thrown."); - } catch (IndexOutOfBoundsException e) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, char[]) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, char[].class} - ) - public void test_insertI$C() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, char []) - char buf[] = new char[4]; - "char".getChars(0, 4, buf, 0); - testBuffer.insert(15, buf); - assertEquals("Insert test failed", - "This is a test charbuffer", testBuffer.toString()); - - boolean exception = false; - StringBuffer buf1 = new StringBuffer("abcd"); - try { - buf1.insert(-1, (char[]) null); - } catch (StringIndexOutOfBoundsException e) { - exception = true; - } catch (NullPointerException e) { - } - assertTrue("Should throw StringIndexOutOfBoundsException", exception); - } - - /** - * @tests java.lang.StringBuffer#insert(int, char[], int, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, char[].class, int.class, int.class} - ) - public void test_insertI$CII() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, char [], int, int) - char[] c = new char[] { 'n', 'o', 't', ' ' }; - testBuffer.insert(8, c, 0, 4); - assertEquals("This is not a test buffer", testBuffer.toString()); - - StringBuffer buf1 = new StringBuffer("abcd"); - try { - buf1.insert(-1, (char[]) null, 0, 0); - fail("Should throw StringIndexOutOfBoundsException"); - } catch (StringIndexOutOfBoundsException e) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() - 1, c, -1, 1); - } catch (StringIndexOutOfBoundsException e) { - //expected - } - - } - - /** - * @tests java.lang.StringBuffer#insert(int, char) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "IndexOutOfBoundsException is not verified.", - method = "insert", - args = {int.class, char.class} - ) - public void test_insertIC() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, char) - testBuffer.insert(15, 'T'); - assertEquals("Insert test failed", - "This is a test Tbuffer", testBuffer.toString()); - } - - /** - * @tests java.lang.StringBuffer#insert(int, double) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, double.class} - ) - public void test_insertID() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, double) - testBuffer.insert(15, Double.MAX_VALUE); - assertTrue("Insert test failed", testBuffer.toString().equals( - "This is a test " + Double.MAX_VALUE + "buffer")); - try { - testBuffer.insert(-1, Double.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() + 1, Double.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, float) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, float.class} - ) - public void test_insertIF() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, float) - testBuffer.insert(15, Float.MAX_VALUE); - String testBufferString = testBuffer.toString(); - String expectedResult = "This is a test " - + String.valueOf(Float.MAX_VALUE) + "buffer"; - assertTrue("Insert test failed, got: " + "\'" + testBufferString + "\'" - + " but wanted: " + "\'" + expectedResult + "\'", - testBufferString.equals(expectedResult)); - - try { - testBuffer.insert(-1, Float.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() + 1, Float.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, int.class} - ) - public void test_insertII() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, int) - testBuffer.insert(15, 100); - assertEquals("Insert test failed", - "This is a test 100buffer", testBuffer.toString()); - - try { - testBuffer.insert(-1, Integer.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() + 1, Integer.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, long) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, long.class} - ) - public void test_insertIJ() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, long) - testBuffer.insert(15, 88888888888888888L); - assertEquals("Insert test failed", - "This is a test 88888888888888888buffer", testBuffer.toString()); - - try { - testBuffer.insert(-1, Long.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() + 1, Long.MAX_VALUE); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, java.lang.Object.class} - ) - public void test_insertILjava_lang_Object() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, java.lang.Object) - Object obj1 = new Object(); - testBuffer.insert(15, obj1); - assertTrue("Insert test failed", testBuffer.toString().equals( - "This is a test " + obj1.toString() + "buffer")); - - try { - testBuffer.insert(-1, obj1); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() + 1, obj1); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, java.lang.String.class} - ) - public void test_insertILjava_lang_String() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, java.lang.String) - - testBuffer.insert(15, "STRING "); - assertEquals("Insert test failed", - "This is a test STRING buffer", testBuffer.toString()); - - try { - testBuffer.insert(-1, ""); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(testBuffer.length() + 1, ""); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#insert(int, boolean) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "insert", - args = {int.class, boolean.class} - ) - public void test_insertIZ() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.insert(int, boolean) - testBuffer.insert(15, true); - assertEquals("Insert test failed", - "This is a test truebuffer", testBuffer.toString()); - try { - testBuffer.insert(testBuffer.length() + 1, true); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.insert(-1, true); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#length() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "length", - args = {} - ) - public void test_length() { - // Test for method int java.lang.StringBuffer.length() - assertEquals("Incorrect length returned", 21, testBuffer.length()); - } - - /** - * @tests java.lang.StringBuffer#replace(int, int, java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "replace", - args = {int.class, int.class, java.lang.String.class} - ) - public void test_replaceIILjava_lang_String() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.replace(int, int, java.lang.String) - testBuffer.replace(5, 9, "is a replaced"); - assertTrue("Replace failed, wanted: " + "\'" - + "This is a replaced test buffer" + "\'" + " but got: " + "\'" - + testBuffer.toString() + "\'", testBuffer.toString().equals( - "This is a replaced test buffer")); - assertEquals("insert1", "text", new StringBuffer().replace(0, 0, "text") - .toString()); - assertEquals("insert2", "123text", new StringBuffer("123").replace(3, 3, "text") - .toString()); - assertEquals("insert2", "1text23", new StringBuffer("123").replace(1, 1, "text") - .toString()); - - try { - testBuffer.replace(-1, 0, "text"); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.replace(0, -1, "text"); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.replace(2, 1, "text"); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - - try { - testBuffer.replace(testBuffer.length() + 1, testBuffer.length() + 1, - "text"); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException sioobe) { - //expected - } - } - - private String writeString(String in) { - StringBuffer result = new StringBuffer(); - result.append("\""); - for (int i = 0; i < in.length(); i++) { - result.append(" 0x" + Integer.toHexString(in.charAt(i))); - } - result.append("\""); - return result.toString(); - } - - private void reverseTest(String id, String org, String rev, String back) { - // create non-shared StringBuffer - StringBuffer sb = new StringBuffer(org); - sb.reverse(); - String reversed = sb.toString(); - assertTrue("reversed surrogate " + id + ": " + writeString(reversed), - reversed.equals(rev)); - // create non-shared StringBuffer - sb = new StringBuffer(reversed); - sb.reverse(); - reversed = sb.toString(); - assertTrue("reversed surrogate " + id + "a: " + writeString(reversed), - reversed.equals(back)); - - // test algorithm when StringBuffer is shared - sb = new StringBuffer(org); - String copy = sb.toString(); - assertEquals(org, copy); - sb.reverse(); - reversed = sb.toString(); - assertTrue("reversed surrogate " + id + ": " + writeString(reversed), - reversed.equals(rev)); - sb = new StringBuffer(reversed); - copy = sb.toString(); - assertEquals(rev, copy); - sb.reverse(); - reversed = sb.toString(); - assertTrue("reversed surrogate " + id + "a: " + writeString(reversed), - reversed.equals(back)); - - } - - /** - * @tests java.lang.StringBuffer#reverse() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "reverse", - args = {} - ) - public void test_reverse() { - // Test for method java.lang.StringBuffer - // java.lang.StringBuffer.reverse() - String org; - org = "a"; - reverseTest("0", org, org, org); - - org = "ab"; - reverseTest("1", org, "ba", org); - - org = "abcdef"; - reverseTest("2", org, "fedcba", org); - - org = "abcdefg"; - reverseTest("3", org, "gfedcba", org); - - } - - /** - * @tests java.lang.StringBuffer#setCharAt(int, char) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setCharAt", - args = {int.class, char.class} - ) - public void test_setCharAtIC() { - // Test for method void java.lang.StringBuffer.setCharAt(int, char) - StringBuffer s = new StringBuffer("HelloWorld"); - s.setCharAt(4, 'Z'); - assertEquals("Returned incorrect char", 'Z', s.charAt(4)); - - try { - s.setCharAt(-1, 'Z'); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - try { - s.setCharAt(s.length() + 1, 'Z'); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#setLength(int) - */ - @TestTargetNew( - level = TestLevel.PARTIAL_COMPLETE, - notes = "IndexOutOfBoundsException is not verified.", - method = "setLength", - args = {int.class} - ) - public void test_setLengthI() { - // Test for method void java.lang.StringBuffer.setLength(int) - testBuffer.setLength(1000); - assertEquals("Failed to increase length", 1000, testBuffer.length()); - assertTrue("Increase in length trashed buffer", testBuffer.toString() - .startsWith("This is a test buffer")); - testBuffer.setLength(2); - assertEquals("Failed to decrease length", 2, testBuffer.length()); - assertEquals("Decrease in length failed", - "Th", testBuffer.toString()); - } - - /** - * @tests java.lang.StringBuffer#substring(int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "substring", - args = {int.class} - ) - public void test_substringI() { - // Test for method java.lang.String - // java.lang.StringBuffer.substring(int) - assertEquals("Returned incorrect substring", "is a test buffer", - testBuffer.substring(5)); - - try { - testBuffer.substring(testBuffer.length() + 1); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException oobe) { - //expected - } - - try { - testBuffer.substring(-1); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException oobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#substring(int, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "substring", - args = {int.class, int.class} - ) - public void test_substringII() { - // Test for method java.lang.String - // java.lang.StringBuffer.substring(int, int) - assertEquals("Returned incorrect substring", "is", - testBuffer.substring(5, 7)); - - try { - testBuffer.substring(-1, testBuffer.length()); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException oobe) { - //expected - } - - try { - testBuffer.substring(0, -1); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException oobe) { - //expected - } - - try { - testBuffer.substring(2, 1); - fail("StringIndexOutOfBoundsException is not thrown."); - } catch(StringIndexOutOfBoundsException oobe) { - //expected - } - } - - /** - * @tests java.lang.StringBuffer#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - // Test for method java.lang.String java.lang.StringBuffer.toString() - assertEquals("Incorrect string value returned", "This is a test buffer", testBuffer.toString() - ); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "subSequence", - args = {int.class, int.class} - ) - public void test_subSequence() { - - assertEquals("Incorrect substring returned", " is", - testBuffer.subSequence(4, 7)); - assertEquals("Incorrect substring returned", "test buffer", - testBuffer.subSequence(10, 21)); - assertEquals("not identical", "This is a test buffer", - testBuffer.subSequence(0, testBuffer.length())); - - try { - testBuffer.subSequence(0, Integer.MAX_VALUE); - fail("IndexOutOfBoundsException was not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - testBuffer.subSequence(Integer.MAX_VALUE, testBuffer.length()); - fail("IndexOutOfBoundsException was not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - testBuffer.subSequence(-1, testBuffer.length()); - fail("IndexOutOfBoundsException was not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - } - - @Override - protected void setUp() { - testBuffer = new StringBuffer("This is a test buffer"); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBufferTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBufferTest.java deleted file mode 100644 index c5499e7..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBufferTest.java +++ /dev/null @@ -1,622 +0,0 @@ -/* 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 java.io.Serializable; - -import junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; -import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert; - -public class StringBufferTest extends TestCase { - - /** - * @tests java.lang.StringBuffer#setLength(int) - */ - public void test_setLengthI() { - // Regression for HARMONY-90 - StringBuffer buffer = new StringBuffer("abcde"); - try { - buffer.setLength(-1); - fail("Assert 0: IndexOutOfBoundsException must be thrown"); - } catch (IndexOutOfBoundsException e) { - // expected - } - - assertEquals("abcde", buffer.toString()); - buffer.setLength(1); - buffer.append('f'); - assertEquals("af", buffer.toString()); - - buffer = new StringBuffer("abcde"); - assertEquals("cde", buffer.substring(2)); - buffer.setLength(3); - buffer.append('f'); - assertEquals("abcf", buffer.toString()); - - buffer = new StringBuffer("abcde"); - buffer.setLength(2); - try { - buffer.charAt(3); - fail("should throw IndexOutOfBoundsException"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - buffer = new StringBuffer(); - buffer.append("abcdefg"); - buffer.setLength(2); - buffer.setLength(5); - for (int i = 2; i < 5; i++) { - assertEquals(0, buffer.charAt(i)); - } - - buffer = new StringBuffer(); - buffer.append("abcdefg"); - buffer.delete(2, 4); - buffer.setLength(7); - assertEquals('a', buffer.charAt(0)); - assertEquals('b', buffer.charAt(1)); - assertEquals('e', buffer.charAt(2)); - assertEquals('f', buffer.charAt(3)); - assertEquals('g', buffer.charAt(4)); - for (int i = 5; i < 7; i++) { - assertEquals(0, buffer.charAt(i)); - } - - buffer = new StringBuffer(); - buffer.append("abcdefg"); - buffer.replace(2, 5, "z"); - buffer.setLength(7); - for (int i = 5; i < 7; i++) { - assertEquals(0, buffer.charAt(i)); - } - } - - /** - * @tests java.lang.StringBuffer#toString() - */ - public void test_toString() throws Exception { - StringBuffer buffer = new StringBuffer(); - assertEquals("", buffer.toString()); - - buffer.append("abcde"); - assertEquals("abcde", buffer.toString()); - buffer.setLength(1000); - byte[] bytes = buffer.toString().getBytes("GB18030"); - for (int i = 5; i < bytes.length; i++) { - assertEquals(0, bytes[i]); - } - - buffer.setLength(5); - buffer.append("fghij"); - assertEquals("abcdefghij", buffer.toString()); - } - - /** - * @tests StringBuffer.StringBuffer(CharSequence); - */ - public void test_constructorLjava_lang_CharSequence() { - try { - new StringBuffer((CharSequence) null); - fail("Assert 0: NPE must be thrown."); - } catch (NullPointerException e) {} - - assertEquals("Assert 1: must equal 'abc'.", "abc", new StringBuffer((CharSequence)"abc").toString()); - } - - public void test_trimToSize() { - StringBuffer buffer = new StringBuffer(25); - buffer.append("abc"); - int origCapacity = buffer.capacity(); - buffer.trimToSize(); - int trimCapacity = buffer.capacity(); - assertTrue("Assert 0: capacity must be smaller.", trimCapacity < origCapacity); - assertEquals("Assert 1: length must still be 3", 3, buffer.length()); - assertEquals("Assert 2: value must still be 'abc'.", "abc", buffer.toString()); - } - - /** - * @tests java.lang.StringBuffer.append(CharSequence) - */ - public void test_appendLjava_lang_CharSequence() { - StringBuffer sb = new StringBuffer(); - assertSame(sb, sb.append((CharSequence) "ab")); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "cd")); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) null)); - assertEquals("null", sb.toString()); - } - - /** - * @tests java.lang.StringBuffer.append(CharSequence, int, int) - */ - @SuppressWarnings("cast") - public void test_appendLjava_lang_CharSequenceII() { - StringBuffer sb = new StringBuffer(); - assertSame(sb, sb.append((CharSequence) "ab", 0, 2)); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "cd", 0, 2)); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "abcd", 0, 2)); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "abcd", 2, 4)); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) null, 0, 2)); - assertEquals("nu", sb.toString()); - } - - /** - * @tests java.lang.StringBuffer.append(char[], int, int) - */ - public void test_append$CII_2() { - StringBuffer obj = new StringBuffer(); - try { - obj.append(new char[0], -1, -1); - fail("ArrayIndexOutOfBoundsException expected"); - } catch (ArrayIndexOutOfBoundsException e) { - // expected - } - } - - /** - * @tests java.lang.StringBuffer.append(char[], int, int) - */ - public void test_append$CII_3() throws Exception { - StringBuffer obj = new StringBuffer(); - try { - obj.append((char[]) null, -1, -1); - fail("NullPointerException expected"); - } catch (NullPointerException e) { - // expected - } - } - - /** - * @tests java.lang.StringBuffer.insert(int, CharSequence) - */ - public void test_insertILjava_lang_CharSequence() { - final String fixture = "0000"; - StringBuffer sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(0, (CharSequence) "ab")); - assertEquals("ab0000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(2, (CharSequence) "ab")); - assertEquals("00ab00", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(4, (CharSequence) "ab")); - assertEquals("0000ab", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(4, (CharSequence) null)); - assertEquals("0000null", sb.toString()); - assertEquals(8, sb.length()); - - try { - sb = new StringBuffer(fixture); - sb.insert(-1, (CharSequence) "ab"); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuffer(fixture); - sb.insert(5, (CharSequence) "ab"); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuffer.insert(int, CharSequence, int, int) - */ - @SuppressWarnings("cast") - public void test_insertILjava_lang_CharSequenceII() { - final String fixture = "0000"; - StringBuffer sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(0, (CharSequence) "ab", 0, 2)); - assertEquals("ab0000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(0, (CharSequence) "ab", 0, 1)); - assertEquals("a0000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(2, (CharSequence) "ab", 0, 2)); - assertEquals("00ab00", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(2, (CharSequence) "ab", 0, 1)); - assertEquals("00a00", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(4, (CharSequence) "ab", 0, 2)); - assertEquals("0000ab", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(4, (CharSequence) "ab", 0, 1)); - assertEquals("0000a", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuffer(fixture); - assertSame(sb, sb.insert(4, (CharSequence) null, 0, 2)); - assertEquals("0000nu", sb.toString()); - assertEquals(6, sb.length()); - - try { - sb = new StringBuffer(fixture); - sb.insert(-1, (CharSequence) "ab", 0, 2); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuffer(fixture); - sb.insert(5, (CharSequence) "ab", 0, 2); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuffer(fixture); - sb.insert(5, (CharSequence) "ab", -1, 2); - fail("no IOOBE, negative offset"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuffer(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, -1); - fail("no IOOBE, negative length"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuffer(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, 3); - fail("no IOOBE, too long"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuffer.insert(int, char) - */ - public void test_insertIC() { - StringBuffer obj = new StringBuffer(); - try { - obj.insert(-1, ' '); - fail("ArrayIndexOutOfBoundsException expected"); - } catch (ArrayIndexOutOfBoundsException e) { - // expected - } - } - - /** - * @tests java.lang.StringBuffer.appendCodePoint(int)' - */ - public void test_appendCodePointI() { - StringBuffer sb = new StringBuffer(); - sb.appendCodePoint(0x10000); - assertEquals("\uD800\uDC00", sb.toString()); - sb.append("fixture"); - assertEquals("\uD800\uDC00fixture", sb.toString()); - sb.appendCodePoint(0x00010FFFF); - assertEquals("\uD800\uDC00fixture\uDBFF\uDFFF", sb.toString()); - } - - /** - * @tests java.lang.StringBuffer.codePointAt(int) - */ - public void test_codePointAtI() { - StringBuffer sb = new StringBuffer("abc"); - assertEquals('a', sb.codePointAt(0)); - assertEquals('b', sb.codePointAt(1)); - assertEquals('c', sb.codePointAt(2)); - - sb = new StringBuffer("\uD800\uDC00"); - assertEquals(0x10000, sb.codePointAt(0)); - assertEquals('\uDC00', sb.codePointAt(1)); - - try { - sb.codePointAt(-1); - fail("No IOOBE on negative index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointAt(sb.length()); - fail("No IOOBE on index equal to length."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointAt(sb.length() + 1); - fail("No IOOBE on index greater than length."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuffer.codePointBefore(int) - */ - public void test_codePointBeforeI() { - StringBuffer sb = new StringBuffer("abc"); - assertEquals('a', sb.codePointBefore(1)); - assertEquals('b', sb.codePointBefore(2)); - assertEquals('c', sb.codePointBefore(3)); - - sb = new StringBuffer("\uD800\uDC00"); - assertEquals(0x10000, sb.codePointBefore(2)); - assertEquals('\uD800', sb.codePointBefore(1)); - - try { - sb.codePointBefore(0); - fail("No IOOBE on zero index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointBefore(-1); - fail("No IOOBE on negative index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointBefore(sb.length() + 1); - fail("No IOOBE on index greater than length."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuffer.codePointCount(int, int) - */ - public void test_codePointCountII() { - assertEquals(1, new StringBuffer("\uD800\uDC00").codePointCount(0, 2)); - assertEquals(1, new StringBuffer("\uD800\uDC01").codePointCount(0, 2)); - assertEquals(1, new StringBuffer("\uD801\uDC01").codePointCount(0, 2)); - assertEquals(1, new StringBuffer("\uDBFF\uDFFF").codePointCount(0, 2)); - - assertEquals(3, new StringBuffer("a\uD800\uDC00b").codePointCount(0, 4)); - assertEquals(4, new StringBuffer("a\uD800\uDC00b\uD800").codePointCount(0, 5)); - - StringBuffer sb = new StringBuffer("abc"); - try { - sb.codePointCount(-1, 2); - fail("No IOOBE for negative begin index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointCount(0, 4); - fail("No IOOBE for end index that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointCount(3, 2); - fail("No IOOBE for begin index larger than end index."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuffer.getChars(int, int, char[], int) - */ - public void test_getCharsII$CI() { - StringBuffer obj = new StringBuffer(); - try { - obj.getChars(0, 0, new char[0], -1); - fail("ArrayIndexOutOfBoundsException expected"); - } catch (ArrayIndexOutOfBoundsException e) { - // expected - } - } - - /** - * @tests java.lang.StringBuffer.offsetByCodePoints(int, int)' - */ - public void test_offsetByCodePointsII() { - int result = new StringBuffer("a\uD800\uDC00b").offsetByCodePoints(0, 2); - assertEquals(3, result); - - result = new StringBuffer("abcd").offsetByCodePoints(3, -1); - assertEquals(2, result); - - result = new StringBuffer("a\uD800\uDC00b").offsetByCodePoints(0, 3); - assertEquals(4, result); - - result = new StringBuffer("a\uD800\uDC00b").offsetByCodePoints(3, -1); - assertEquals(1, result); - - result = new StringBuffer("a\uD800\uDC00b").offsetByCodePoints(3, 0); - assertEquals(3, result); - - result = new StringBuffer("\uD800\uDC00bc").offsetByCodePoints(3, 0); - assertEquals(3, result); - - result = new StringBuffer("a\uDC00bc").offsetByCodePoints(3, -1); - assertEquals(2, result); - - result = new StringBuffer("a\uD800bc").offsetByCodePoints(3, -1); - assertEquals(2, result); - - StringBuffer sb = new StringBuffer("abc"); - try { - sb.offsetByCodePoints(-1, 1); - fail("No IOOBE for negative index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(0, 4); - fail("No IOOBE for offset that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(3, -4); - fail("No IOOBE for offset that's too small."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(3, 1); - fail("No IOOBE for index that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(4, -1); - fail("No IOOBE for index that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests {@link java.lang.StringBuffer#indexOf(String, int)} - */ - @SuppressWarnings("nls") - public void test_IndexOfStringInt() { - final String fixture = "0123456789"; - StringBuffer sb = new StringBuffer(fixture); - assertEquals(0, sb.indexOf("0")); - assertEquals(0, sb.indexOf("012")); - assertEquals(-1, sb.indexOf("02")); - assertEquals(8, sb.indexOf("89")); - - assertEquals(0, sb.indexOf("0"), 0); - assertEquals(0, sb.indexOf("012"), 0); - assertEquals(-1, sb.indexOf("02"), 0); - assertEquals(8, sb.indexOf("89"), 0); - - assertEquals(-1, sb.indexOf("0"), 5); - assertEquals(-1, sb.indexOf("012"), 5); - assertEquals(-1, sb.indexOf("02"), 0); - assertEquals(8, sb.indexOf("89"), 5); - - try { - sb.indexOf(null, 0); - fail("Should throw a NullPointerExceptionE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests {@link java.lang.StringBuffer#lastIndexOf(String, int)} - */ - @SuppressWarnings("nls") - public void test_lastIndexOfLjava_lang_StringI() { - final String fixture = "0123456789"; - StringBuffer sb = new StringBuffer(fixture); - assertEquals(0, sb.lastIndexOf("0")); - assertEquals(0, sb.lastIndexOf("012")); - assertEquals(-1, sb.lastIndexOf("02")); - assertEquals(8, sb.lastIndexOf("89")); - - assertEquals(0, sb.lastIndexOf("0"), 0); - assertEquals(0, sb.lastIndexOf("012"), 0); - assertEquals(-1, sb.lastIndexOf("02"), 0); - assertEquals(8, sb.lastIndexOf("89"), 0); - - assertEquals(-1, sb.lastIndexOf("0"), 5); - assertEquals(-1, sb.lastIndexOf("012"), 5); - assertEquals(-1, sb.lastIndexOf("02"), 0); - assertEquals(8, sb.lastIndexOf("89"), 5); - - try { - sb.lastIndexOf(null, 0); - fail("Should throw a NullPointerException"); - } catch (NullPointerException e) { - // Expected - } - } - - // comparator for StringBuffer objects - private static final SerializableAssert STRING_BUFFER_COMPARATOR = new SerializableAssert() { - public void assertDeserialized(Serializable initial, - Serializable deserialized) { - - StringBuffer init = (StringBuffer) initial; - StringBuffer desr = (StringBuffer) deserialized; - - // serializable fields are: 'count', 'shared', 'value' - // serialization of 'shared' is not verified - // 'count' + 'value' should result in required string - assertEquals("toString", init.toString(), desr.toString()); - } - }; - - /** - * @tests serialization/deserialization. - */ - public void testSerializationSelf() throws Exception { - - SerializationTest.verifySelf(new StringBuffer("0123456789"), - STRING_BUFFER_COMPARATOR); - } - - /** - * @tests serialization/deserialization compatibility with RI. - */ - public void testSerializationCompatibility() throws Exception { - - SerializationTest.verifyGolden(this, new StringBuffer("0123456789"), - STRING_BUFFER_COMPARATOR); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBuilderTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBuilderTest.java deleted file mode 100644 index d9acab0..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringBuilderTest.java +++ /dev/null @@ -1,1984 +0,0 @@ -/* - * 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 java.io.Serializable; -import java.util.Arrays; - -import junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; -import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert; - -public class StringBuilderTest extends TestCase { - - /** - * @tests java.lang.StringBuilder.StringBuilder() - */ - public void test_Constructor() { - StringBuilder sb = new StringBuilder(); - assertNotNull(sb); - assertEquals(16, sb.capacity()); - } - - /** - * @tests java.lang.StringBuilder.StringBuilder(int) - */ - public void test_ConstructorI() { - StringBuilder sb = new StringBuilder(24); - assertNotNull(sb); - assertEquals(24, sb.capacity()); - - try { - new StringBuilder(-1); - fail("no exception"); - } catch (NegativeArraySizeException e) { - // Expected - } - - assertNotNull(new StringBuilder(0)); - } - - /** - * @tests java.lang.StringBuilder.StringBuilder(CharSequence) - */ - @SuppressWarnings("cast") - public void test_ConstructorLjava_lang_CharSequence() { - StringBuilder sb = new StringBuilder((CharSequence) "fixture"); - assertEquals("fixture", sb.toString()); - assertEquals("fixture".length() + 16, sb.capacity()); - - sb = new StringBuilder((CharSequence) new StringBuffer("fixture")); - assertEquals("fixture", sb.toString()); - assertEquals("fixture".length() + 16, sb.capacity()); - - try { - new StringBuilder((CharSequence) null); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.StringBuilder(String) - */ - public void test_ConstructorLjava_lang_String() { - StringBuilder sb = new StringBuilder("fixture"); - assertEquals("fixture", sb.toString()); - assertEquals("fixture".length() + 16, sb.capacity()); - - try { - new StringBuilder((String) null); - fail("no NPE"); - } catch (NullPointerException e) { - } - } - - /** - * @tests java.lang.StringBuilder.append(boolean) - */ - public void test_appendZ() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(true)); - assertEquals("true", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(false)); - assertEquals("false", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(char) - */ - public void test_appendC() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append('a')); - assertEquals("a", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append('b')); - assertEquals("b", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(char[]) - */ - public void test_append$C() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(new char[] { 'a', 'b' })); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(new char[] { 'c', 'd' })); - assertEquals("cd", sb.toString()); - try { - sb.append((char[]) null); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.append(char[], int, int) - */ - public void test_append$CII() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(new char[] { 'a', 'b' }, 0, 2)); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(new char[] { 'c', 'd' }, 0, 2)); - assertEquals("cd", sb.toString()); - - sb.setLength(0); - assertSame(sb, sb.append(new char[] { 'a', 'b', 'c', 'd' }, 0, 2)); - assertEquals("ab", sb.toString()); - - sb.setLength(0); - assertSame(sb, sb.append(new char[] { 'a', 'b', 'c', 'd' }, 2, 2)); - assertEquals("cd", sb.toString()); - - sb.setLength(0); - assertSame(sb, sb.append(new char[] { 'a', 'b', 'c', 'd' }, 2, 0)); - assertEquals("", sb.toString()); - - try { - sb.append((char[]) null, 0, 2); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - - try { - sb.append(new char[] { 'a', 'b', 'c', 'd' }, -1, 2); - fail("no IOOBE, negative offset"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.append(new char[] { 'a', 'b', 'c', 'd' }, 0, -1); - fail("no IOOBE, negative length"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.append(new char[] { 'a', 'b', 'c', 'd' }, 2, 3); - fail("no IOOBE, offset and length overflow"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.append(CharSequence) - */ - public void test_appendLjava_lang_CharSequence() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append((CharSequence) "ab")); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "cd")); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) null)); - assertEquals("null", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(CharSequence, int, int) - */ - @SuppressWarnings("cast") - public void test_appendLjava_lang_CharSequenceII() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append((CharSequence) "ab", 0, 2)); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "cd", 0, 2)); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "abcd", 0, 2)); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) "abcd", 2, 4)); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((CharSequence) null, 0, 2)); - assertEquals("nu", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(double) - */ - public void test_appendD() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(1D)); - assertEquals(String.valueOf(1D), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(0D)); - assertEquals(String.valueOf(0D), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(-1D)); - assertEquals(String.valueOf(-1D), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Double.NaN)); - assertEquals(String.valueOf(Double.NaN), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Double.NEGATIVE_INFINITY)); - assertEquals(String.valueOf(Double.NEGATIVE_INFINITY), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Double.POSITIVE_INFINITY)); - assertEquals(String.valueOf(Double.POSITIVE_INFINITY), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Double.MIN_VALUE)); - assertEquals(String.valueOf(Double.MIN_VALUE), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Double.MAX_VALUE)); - assertEquals(String.valueOf(Double.MAX_VALUE), sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(float) - */ - public void test_appendF() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(1F)); - assertEquals(String.valueOf(1F), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(0F)); - assertEquals(String.valueOf(0F), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(-1F)); - assertEquals(String.valueOf(-1F), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Float.NaN)); - assertEquals(String.valueOf(Float.NaN), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Float.NEGATIVE_INFINITY)); - assertEquals(String.valueOf(Float.NEGATIVE_INFINITY), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Float.POSITIVE_INFINITY)); - assertEquals(String.valueOf(Float.POSITIVE_INFINITY), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Float.MIN_VALUE)); - assertEquals(String.valueOf(Float.MIN_VALUE), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Float.MAX_VALUE)); - assertEquals(String.valueOf(Float.MAX_VALUE), sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(int) - */ - public void test_appendI() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(1)); - assertEquals(String.valueOf(1), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(0)); - assertEquals(String.valueOf(0), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(-1)); - assertEquals(String.valueOf(-1), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Integer.MIN_VALUE)); - assertEquals(String.valueOf(Integer.MIN_VALUE), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Integer.MAX_VALUE)); - assertEquals(String.valueOf(Integer.MAX_VALUE), sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(long) - */ - public void test_appendL() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(1L)); - assertEquals(String.valueOf(1L), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(0L)); - assertEquals(String.valueOf(0L), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(-1L)); - assertEquals(String.valueOf(-1L), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Integer.MIN_VALUE)); - assertEquals(String.valueOf(Integer.MIN_VALUE), sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(Integer.MAX_VALUE)); - assertEquals(String.valueOf(Integer.MAX_VALUE), sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(Object)' - */ - public void test_appendLjava_lang_Object() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(Fixture.INSTANCE)); - assertEquals(Fixture.INSTANCE.toString(), sb.toString()); - - sb.setLength(0); - assertSame(sb, sb.append((Object) null)); - assertEquals("null", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(String) - */ - public void test_appendLjava_lang_String() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append("ab")); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append("cd")); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((String) null)); - assertEquals("null", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.append(StringBuffer) - */ - public void test_appendLjava_lang_StringBuffer() { - StringBuilder sb = new StringBuilder(); - assertSame(sb, sb.append(new StringBuffer("ab"))); - assertEquals("ab", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append(new StringBuffer("cd"))); - assertEquals("cd", sb.toString()); - sb.setLength(0); - assertSame(sb, sb.append((StringBuffer) null)); - assertEquals("null", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.appendCodePoint(int)' - */ - public void test_appendCodePointI() { - StringBuilder sb = new StringBuilder(); - sb.appendCodePoint(0x10000); - assertEquals("\uD800\uDC00", sb.toString()); - sb.append("fixture"); - assertEquals("\uD800\uDC00fixture", sb.toString()); - sb.appendCodePoint(0x00010FFFF); - assertEquals("\uD800\uDC00fixture\uDBFF\uDFFF", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.capacity()' - */ - public void test_capacity() { - StringBuilder sb = new StringBuilder(); - assertEquals(16, sb.capacity()); - sb.append("0123456789ABCDEF0123456789ABCDEF"); - assertTrue(sb.capacity() > 16); - } - - /** - * @tests java.lang.StringBuilder.charAt(int)' - */ - public void test_charAtI() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - for (int i = 0; i < fixture.length(); i++) { - assertEquals((char) ('0' + i), sb.charAt(i)); - } - - try { - sb.charAt(-1); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.charAt(fixture.length()); - fail("no IOOBE, equal to length"); - } catch (IndexOutOfBoundsException e) { - } - - try { - sb.charAt(fixture.length() + 1); - fail("no IOOBE, greater than length"); - } catch (IndexOutOfBoundsException e) { - } - } - - /** - * @tests java.lang.StringBuilder.codePointAt(int) - */ - public void test_codePointAtI() { - StringBuilder sb = new StringBuilder("abc"); - assertEquals('a', sb.codePointAt(0)); - assertEquals('b', sb.codePointAt(1)); - assertEquals('c', sb.codePointAt(2)); - - sb = new StringBuilder("\uD800\uDC00"); - assertEquals(0x10000, sb.codePointAt(0)); - assertEquals('\uDC00', sb.codePointAt(1)); - - sb = new StringBuilder(); - sb.append("abc"); - try { - sb.codePointAt(-1); - fail("No IOOBE on negative index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointAt(sb.length()); - fail("No IOOBE on index equal to length."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointAt(sb.length() + 1); - fail("No IOOBE on index greater than length."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuilder.codePointBefore(int) - */ - public void test_codePointBeforeI() { - StringBuilder sb = new StringBuilder("abc"); - assertEquals('a', sb.codePointBefore(1)); - assertEquals('b', sb.codePointBefore(2)); - assertEquals('c', sb.codePointBefore(3)); - - sb = new StringBuilder("\uD800\uDC00"); - assertEquals(0x10000, sb.codePointBefore(2)); - assertEquals('\uD800', sb.codePointBefore(1)); - - sb = new StringBuilder(); - sb.append("abc"); - - try { - sb.codePointBefore(0); - fail("No IOOBE on zero index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointBefore(-1); - fail("No IOOBE on negative index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointBefore(sb.length() + 1); - fail("No IOOBE on index greater than length."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuilder.codePointCount(int, int) - */ - public void test_codePointCountII() { - assertEquals(1, new StringBuilder("\uD800\uDC00").codePointCount(0, 2)); - assertEquals(1, new StringBuilder("\uD800\uDC01").codePointCount(0, 2)); - assertEquals(1, new StringBuilder("\uD801\uDC01").codePointCount(0, 2)); - assertEquals(1, new StringBuilder("\uDBFF\uDFFF").codePointCount(0, 2)); - - assertEquals(3, new StringBuilder("a\uD800\uDC00b").codePointCount(0, 4)); - assertEquals(4, new StringBuilder("a\uD800\uDC00b\uD800").codePointCount(0, 5)); - - StringBuilder sb = new StringBuilder(); - sb.append("abc"); - try { - sb.codePointCount(-1, 2); - fail("No IOOBE for negative begin index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointCount(0, 4); - fail("No IOOBE for end index that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.codePointCount(3, 2); - fail("No IOOBE for begin index larger than end index."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuilder.delete(int, int) - */ - public void test_deleteII() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.delete(0, 0)); - assertEquals(fixture, sb.toString()); - assertSame(sb, sb.delete(5, 5)); - assertEquals(fixture, sb.toString()); - assertSame(sb, sb.delete(0, 1)); - assertEquals("123456789", sb.toString()); - assertEquals(9, sb.length()); - assertSame(sb, sb.delete(0, sb.length())); - assertEquals("", sb.toString()); - assertEquals(0, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.delete(0, 11)); - assertEquals("", sb.toString()); - assertEquals(0, sb.length()); - - try { - new StringBuilder(fixture).delete(-1, 2); - fail("no SIOOBE, negative start"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - new StringBuilder(fixture).delete(11, 12); - fail("no SIOOBE, start too far"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - new StringBuilder(fixture).delete(13, 12); - fail("no SIOOBE, start larger than end"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - // HARMONY 6212 - sb = new StringBuilder(); - sb.append("abcde"); - String str = sb.toString(); - sb.delete(0, sb.length()); - sb.append("YY"); - assertEquals("abcde", str); - assertEquals("YY", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.deleteCharAt(int) - */ - public void test_deleteCharAtI() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.deleteCharAt(0)); - assertEquals("123456789", sb.toString()); - assertEquals(9, sb.length()); - sb = new StringBuilder(fixture); - assertSame(sb, sb.deleteCharAt(5)); - assertEquals("012346789", sb.toString()); - assertEquals(9, sb.length()); - sb = new StringBuilder(fixture); - assertSame(sb, sb.deleteCharAt(9)); - assertEquals("012345678", sb.toString()); - assertEquals(9, sb.length()); - - try { - new StringBuilder(fixture).deleteCharAt(-1); - fail("no SIOOBE, negative index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - new StringBuilder(fixture).deleteCharAt(fixture.length()); - fail("no SIOOBE, index equals length"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - new StringBuilder(fixture).deleteCharAt(fixture.length() + 1); - fail("no SIOOBE, index exceeds length"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.ensureCapacity(int)' - */ - public void test_ensureCapacityI() { - StringBuilder sb = new StringBuilder(5); - assertEquals(5, sb.capacity()); - sb.ensureCapacity(10); - assertEquals(12, sb.capacity()); - sb.ensureCapacity(26); - assertEquals(26, sb.capacity()); - sb.ensureCapacity(55); - assertEquals(55, sb.capacity()); - } - - /** - * @tests java.lang.StringBuilder.getChars(int, int, char[], int)' - */ - public void test_getCharsII$CI() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - char[] dst = new char[10]; - sb.getChars(0, 10, dst, 0); - assertTrue(Arrays.equals(fixture.toCharArray(), dst)); - - Arrays.fill(dst, '\0'); - sb.getChars(0, 5, dst, 0); - char[] fixtureChars = new char[10]; - fixture.getChars(0, 5, fixtureChars, 0); - assertTrue(Arrays.equals(fixtureChars, dst)); - - Arrays.fill(dst, '\0'); - Arrays.fill(fixtureChars, '\0'); - sb.getChars(0, 5, dst, 5); - fixture.getChars(0, 5, fixtureChars, 5); - assertTrue(Arrays.equals(fixtureChars, dst)); - - Arrays.fill(dst, '\0'); - Arrays.fill(fixtureChars, '\0'); - sb.getChars(5, 10, dst, 1); - fixture.getChars(5, 10, fixtureChars, 1); - assertTrue(Arrays.equals(fixtureChars, dst)); - - try { - sb.getChars(0, 10, null, 0); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - - try { - sb.getChars(-1, 10, dst, 0); - fail("no IOOBE, srcBegin negative"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.getChars(0, 10, dst, -1); - fail("no IOOBE, dstBegin negative"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.getChars(5, 4, dst, 0); - fail("no IOOBE, srcBegin > srcEnd"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.getChars(0, 11, dst, 0); - fail("no IOOBE, srcEnd > length"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.getChars(0, 10, dst, 5); - fail("no IOOBE, dstBegin and src size too large for what's left in dst"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.indexOf(String) - */ - public void test_indexOfLjava_lang_String() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertEquals(0, sb.indexOf("0")); - assertEquals(0, sb.indexOf("012")); - assertEquals(-1, sb.indexOf("02")); - assertEquals(8, sb.indexOf("89")); - - try { - sb.indexOf(null); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.indexOf(String, int) - */ - public void test_IndexOfStringInt() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertEquals(0, sb.indexOf("0")); - assertEquals(0, sb.indexOf("012")); - assertEquals(-1, sb.indexOf("02")); - assertEquals(8, sb.indexOf("89")); - - assertEquals(0, sb.indexOf("0"), 0); - assertEquals(0, sb.indexOf("012"), 0); - assertEquals(-1, sb.indexOf("02"), 0); - assertEquals(8, sb.indexOf("89"), 0); - - assertEquals(-1, sb.indexOf("0"), 5); - assertEquals(-1, sb.indexOf("012"), 5); - assertEquals(-1, sb.indexOf("02"), 0); - assertEquals(8, sb.indexOf("89"), 5); - - try { - sb.indexOf(null, 0); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, boolean) - */ - public void test_insertIZ() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, true)); - assertEquals("true0000", sb.toString()); - assertEquals(8, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, false)); - assertEquals("false0000", sb.toString()); - assertEquals(9, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, false)); - assertEquals("00false00", sb.toString()); - assertEquals(9, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, false)); - assertEquals("0000false", sb.toString()); - assertEquals(9, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, false); - fail("no SIOOBE, negative index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, false); - fail("no SIOOBE, index too large index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, char) - */ - public void test_insertIC() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, 'a')); - assertEquals("a0000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, 'b')); - assertEquals("b0000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, 'b')); - assertEquals("00b00", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, 'b')); - assertEquals("0000b", sb.toString()); - assertEquals(5, sb.length()); - - // FIXME this fails on Sun JRE 5.0_5 -// try { -// sb = new StringBuilder(fixture); -// sb.insert(-1, 'a'); -// fail("no SIOOBE, negative index"); -// } catch (StringIndexOutOfBoundsException e) { -// // Expected -// } - - /* - * FIXME This fails on Sun JRE 5.0_5, but that seems like a bug, since - * the 'insert(int, char[]) behaves this way. - */ -// try { -// sb = new StringBuilder(fixture); -// sb.insert(5, 'a'); -// fail("no SIOOBE, index too large index"); -// } catch (StringIndexOutOfBoundsException e) { -// // Expected -// } - } - - /** - * @tests java.lang.StringBuilder.insert(int, char) - */ - public void test_insertIC_2() { - StringBuilder obj = new StringBuilder(); - try { - obj.insert(-1, '?'); - fail("ArrayIndexOutOfBoundsException expected"); - } catch (ArrayIndexOutOfBoundsException e) { - // expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, char[])' - */ - public void test_insertI$C() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, new char[] { 'a', 'b' })); - assertEquals("ab0000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, new char[] { 'a', 'b' })); - assertEquals("00ab00", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, new char[] { 'a', 'b' })); - assertEquals("0000ab", sb.toString()); - assertEquals(6, sb.length()); - - /* - * TODO This NPE is the behavior on Sun's JRE 5.0_5, but it's - * undocumented. The assumption is that this method behaves like - * String.valueOf(char[]), which does throw a NPE too, but that is also - * undocumented. - */ - - try { - sb.insert(0, (char[]) null); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, new char[] { 'a', 'b' }); - fail("no SIOOBE, negative index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }); - fail("no SIOOBE, index too large index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, char[], int, int) - */ - public void test_insertI$CII() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, new char[] { 'a', 'b' }, 0, 2)); - assertEquals("ab0000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, new char[] { 'a', 'b' }, 0, 1)); - assertEquals("a0000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, new char[] { 'a', 'b' }, 0, 2)); - assertEquals("00ab00", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, new char[] { 'a', 'b' }, 0, 1)); - assertEquals("00a00", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, new char[] { 'a', 'b' }, 0, 2)); - assertEquals("0000ab", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, new char[] { 'a', 'b' }, 0, 1)); - assertEquals("0000a", sb.toString()); - assertEquals(5, sb.length()); - - /* - * TODO This NPE is the behavior on Sun's JRE 5.0_5, but it's - * undocumented. The assumption is that this method behaves like - * String.valueOf(char[]), which does throw a NPE too, but that is also - * undocumented. - */ - - try { - sb.insert(0, (char[]) null, 0, 2); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, new char[] { 'a', 'b' }, 0, 2); - fail("no SIOOBE, negative index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, 2); - fail("no SIOOBE, index too large index"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }, -1, 2); - fail("no SIOOBE, negative offset"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, -1); - fail("no SIOOBE, negative length"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, 3); - fail("no SIOOBE, too long"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, CharSequence) - */ - public void test_insertILjava_lang_CharSequence() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, (CharSequence) "ab")); - assertEquals("ab0000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, (CharSequence) "ab")); - assertEquals("00ab00", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (CharSequence) "ab")); - assertEquals("0000ab", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (CharSequence) null)); - assertEquals("0000null", sb.toString()); - assertEquals(8, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, (CharSequence) "ab"); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, (CharSequence) "ab"); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, CharSequence, int, int) - */ - @SuppressWarnings("cast") - public void test_insertILjava_lang_CharSequenceII() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, (CharSequence) "ab", 0, 2)); - assertEquals("ab0000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, (CharSequence) "ab", 0, 1)); - assertEquals("a0000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, (CharSequence) "ab", 0, 2)); - assertEquals("00ab00", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, (CharSequence) "ab", 0, 1)); - assertEquals("00a00", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (CharSequence) "ab", 0, 2)); - assertEquals("0000ab", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (CharSequence) "ab", 0, 1)); - assertEquals("0000a", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (CharSequence) null, 0, 2)); - assertEquals("0000nu", sb.toString()); - assertEquals(6, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, (CharSequence) "ab", 0, 2); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, (CharSequence) "ab", 0, 2); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, (CharSequence) "ab", -1, 2); - fail("no IOOBE, negative offset"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, -1); - fail("no IOOBE, negative length"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, new char[] { 'a', 'b' }, 0, 3); - fail("no IOOBE, too long"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, double) - */ - public void test_insertID() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, -1D)); - assertEquals("-1.00000", sb.toString()); - assertEquals(8, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, 0D)); - assertEquals("0.00000", sb.toString()); - assertEquals(7, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, 1D)); - assertEquals("001.000", sb.toString()); - assertEquals(7, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, 2D)); - assertEquals("00002.0", sb.toString()); - assertEquals(7, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, 1D); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, 1D); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, float) - */ - public void test_insertIF() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, -1F)); - assertEquals("-1.00000", sb.toString()); - assertEquals(8, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, 0F)); - assertEquals("0.00000", sb.toString()); - assertEquals(7, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, 1F)); - assertEquals("001.000", sb.toString()); - assertEquals(7, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, 2F)); - assertEquals("00002.0", sb.toString()); - assertEquals(7, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, 1F); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, 1F); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, int) - */ - public void test_insertII() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, -1)); - assertEquals("-10000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, 0)); - assertEquals("00000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, 1)); - assertEquals("00100", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, 2)); - assertEquals("00002", sb.toString()); - assertEquals(5, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, 1); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, 1); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, long) - */ - public void test_insertIJ() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, -1L)); - assertEquals("-10000", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, 0L)); - assertEquals("00000", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, 1L)); - assertEquals("00100", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, 2L)); - assertEquals("00002", sb.toString()); - assertEquals(5, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, 1L); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, 1L); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, Object) - */ - public void test_insertILjava_lang_Object() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, Fixture.INSTANCE)); - assertEquals("fixture0000", sb.toString()); - assertEquals(11, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, Fixture.INSTANCE)); - assertEquals("00fixture00", sb.toString()); - assertEquals(11, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, Fixture.INSTANCE)); - assertEquals("0000fixture", sb.toString()); - assertEquals(11, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (Object) null)); - assertEquals("0000null", sb.toString()); - assertEquals(8, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, Fixture.INSTANCE); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, Fixture.INSTANCE); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.insert(int, String) - */ - public void test_insertILjava_lang_String() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(0, "fixture")); - assertEquals("fixture0000", sb.toString()); - assertEquals(11, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(2, "fixture")); - assertEquals("00fixture00", sb.toString()); - assertEquals(11, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, "fixture")); - assertEquals("0000fixture", sb.toString()); - assertEquals(11, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.insert(4, (Object) null)); - assertEquals("0000null", sb.toString()); - assertEquals(8, sb.length()); - - try { - sb = new StringBuilder(fixture); - sb.insert(-1, "fixture"); - fail("no IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.insert(5, "fixture"); - fail("no IOOBE, index too large index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.lastIndexOf(String) - */ - public void test_lastIndexOfLjava_lang_String() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertEquals(0, sb.lastIndexOf("0")); - assertEquals(0, sb.lastIndexOf("012")); - assertEquals(-1, sb.lastIndexOf("02")); - assertEquals(8, sb.lastIndexOf("89")); - - try { - sb.lastIndexOf(null); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.lastIndexOf(String, int) - */ - public void test_lastIndexOfLjava_lang_StringI() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertEquals(0, sb.lastIndexOf("0")); - assertEquals(0, sb.lastIndexOf("012")); - assertEquals(-1, sb.lastIndexOf("02")); - assertEquals(8, sb.lastIndexOf("89")); - - assertEquals(0, sb.lastIndexOf("0"), 0); - assertEquals(0, sb.lastIndexOf("012"), 0); - assertEquals(-1, sb.lastIndexOf("02"), 0); - assertEquals(8, sb.lastIndexOf("89"), 0); - - assertEquals(-1, sb.lastIndexOf("0"), 5); - assertEquals(-1, sb.lastIndexOf("012"), 5); - assertEquals(-1, sb.lastIndexOf("02"), 0); - assertEquals(8, sb.lastIndexOf("89"), 5); - - try { - sb.lastIndexOf(null, 0); - fail("no NPE"); - } catch (NullPointerException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.length() - */ - public void test_length() { - StringBuilder sb = new StringBuilder(); - assertEquals(0, sb.length()); - sb.append("0000"); - assertEquals(4, sb.length()); - } - - /** - * @tests java.lang.StringBuilder.offsetByCodePoints(int, int)' - */ - public void test_offsetByCodePointsII() { - int result = new StringBuilder("a\uD800\uDC00b").offsetByCodePoints(0, 2); - assertEquals(3, result); - - result = new StringBuilder("abcd").offsetByCodePoints(3, -1); - assertEquals(2, result); - - result = new StringBuilder("a\uD800\uDC00b").offsetByCodePoints(0, 3); - assertEquals(4, result); - - result = new StringBuilder("a\uD800\uDC00b").offsetByCodePoints(3, -1); - assertEquals(1, result); - - result = new StringBuilder("a\uD800\uDC00b").offsetByCodePoints(3, 0); - assertEquals(3, result); - - result = new StringBuilder("\uD800\uDC00bc").offsetByCodePoints(3, 0); - assertEquals(3, result); - - result = new StringBuilder("a\uDC00bc").offsetByCodePoints(3, -1); - assertEquals(2, result); - - result = new StringBuilder("a\uD800bc").offsetByCodePoints(3, -1); - assertEquals(2, result); - - StringBuilder sb = new StringBuilder(); - sb.append("abc"); - try { - sb.offsetByCodePoints(-1, 1); - fail("No IOOBE for negative index."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(0, 4); - fail("No IOOBE for offset that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(3, -4); - fail("No IOOBE for offset that's too small."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(3, 1); - fail("No IOOBE for index that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - - try { - sb.offsetByCodePoints(4, -1); - fail("No IOOBE for index that's too large."); - } catch (IndexOutOfBoundsException e) { - - } - } - - /** - * @tests java.lang.StringBuilder.replace(int, int, String)' - */ - public void test_replaceIILjava_lang_String() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.replace(1, 3, "11")); - assertEquals("0110", sb.toString()); - assertEquals(4, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.replace(1, 2, "11")); - assertEquals("01100", sb.toString()); - assertEquals(5, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.replace(4, 5, "11")); - assertEquals("000011", sb.toString()); - assertEquals(6, sb.length()); - - sb = new StringBuilder(fixture); - assertSame(sb, sb.replace(4, 6, "11")); - assertEquals("000011", sb.toString()); - assertEquals(6, sb.length()); - - // FIXME Undocumented NPE in Sun's JRE 5.0_5 - try { - sb.replace(1, 2, null); - fail("No NPE"); - } catch (NullPointerException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.replace(-1, 2, "11"); - fail("No SIOOBE, negative start"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.replace(5, 2, "11"); - fail("No SIOOBE, start > length"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb = new StringBuilder(fixture); - sb.replace(3, 2, "11"); - fail("No SIOOBE, start > end"); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - // Regression for HARMONY-348 - StringBuilder buffer = new StringBuilder("1234567"); - buffer.replace(2, 6, "XXX"); - assertEquals("12XXX7",buffer.toString()); - } - - private void reverseTest(String org, String rev, String back) { - // create non-shared StringBuilder - StringBuilder sb = new StringBuilder(org); - sb.reverse(); - String reversed = sb.toString(); - assertEquals(rev, reversed); - // create non-shared StringBuilder - sb = new StringBuilder(reversed); - sb.reverse(); - reversed = sb.toString(); - assertEquals(back, reversed); - - // test algorithm when StringBuilder is shared - sb = new StringBuilder(org); - String copy = sb.toString(); - assertEquals(org, copy); - sb.reverse(); - reversed = sb.toString(); - assertEquals(rev, reversed); - sb = new StringBuilder(reversed); - copy = sb.toString(); - assertEquals(rev, copy); - sb.reverse(); - reversed = sb.toString(); - assertEquals(back, reversed); - } - - /** - * @tests java.lang.StringBuilder.reverse() - */ - public void test_reverse() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertSame(sb, sb.reverse()); - assertEquals("9876543210", sb.toString()); - - sb = new StringBuilder("012345678"); - assertSame(sb, sb.reverse()); - assertEquals("876543210", sb.toString()); - - sb.setLength(1); - assertSame(sb, sb.reverse()); - assertEquals("8", sb.toString()); - - sb.setLength(0); - assertSame(sb, sb.reverse()); - assertEquals("", sb.toString()); - - String str; - str = "a"; - reverseTest(str, str, str); - - str = "ab"; - reverseTest(str, "ba", str); - - str = "abcdef"; - reverseTest(str, "fedcba", str); - - str = "abcdefg"; - reverseTest(str, "gfedcba", str); - - str = "\ud800\udc00"; - reverseTest(str, str, str); - - str = "\udc00\ud800"; - reverseTest(str, "\ud800\udc00", "\ud800\udc00"); - - str = "a\ud800\udc00"; - reverseTest(str, "\ud800\udc00a", str); - - str = "ab\ud800\udc00"; - reverseTest(str, "\ud800\udc00ba", str); - - str = "abc\ud800\udc00"; - reverseTest(str, "\ud800\udc00cba", str); - - str = "\ud800\udc00\udc01\ud801\ud802\udc02"; - reverseTest(str, "\ud802\udc02\ud801\udc01\ud800\udc00", - "\ud800\udc00\ud801\udc01\ud802\udc02"); - - str = "\ud800\udc00\ud801\udc01\ud802\udc02"; - reverseTest(str, "\ud802\udc02\ud801\udc01\ud800\udc00", str); - - str = "\ud800\udc00\udc01\ud801a"; - reverseTest(str, "a\ud801\udc01\ud800\udc00", - "\ud800\udc00\ud801\udc01a"); - - str = "a\ud800\udc00\ud801\udc01"; - reverseTest(str, "\ud801\udc01\ud800\udc00a", str); - - str = "\ud800\udc00\udc01\ud801ab"; - reverseTest(str, "ba\ud801\udc01\ud800\udc00", - "\ud800\udc00\ud801\udc01ab"); - - str = "ab\ud800\udc00\ud801\udc01"; - reverseTest(str, "\ud801\udc01\ud800\udc00ba", str); - - str = "\ud800\udc00\ud801\udc01"; - reverseTest(str, "\ud801\udc01\ud800\udc00", str); - - str = "a\ud800\udc00z\ud801\udc01"; - reverseTest(str, "\ud801\udc01z\ud800\udc00a", str); - - str = "a\ud800\udc00bz\ud801\udc01"; - reverseTest(str, "\ud801\udc01zb\ud800\udc00a", str); - - str = "abc\ud802\udc02\ud801\udc01\ud800\udc00"; - reverseTest(str, "\ud800\udc00\ud801\udc01\ud802\udc02cba", str); - - str = "abcd\ud802\udc02\ud801\udc01\ud800\udc00"; - reverseTest(str, "\ud800\udc00\ud801\udc01\ud802\udc02dcba", str); - } - - /** - * @tests java.lang.StringBuilder.setCharAt(int, char) - */ - public void test_setCharAtIC() { - final String fixture = "0000"; - StringBuilder sb = new StringBuilder(fixture); - sb.setCharAt(0, 'A'); - assertEquals("A000", sb.toString()); - sb.setCharAt(1, 'B'); - assertEquals("AB00", sb.toString()); - sb.setCharAt(2, 'C'); - assertEquals("ABC0", sb.toString()); - sb.setCharAt(3, 'D'); - assertEquals("ABCD", sb.toString()); - - try { - sb.setCharAt(-1, 'A'); - fail("No IOOBE, negative index"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.setCharAt(4, 'A'); - fail("No IOOBE, index == length"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.setCharAt(5, 'A'); - fail("No IOOBE, index > length"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.setLength(int)' - */ - public void test_setLengthI() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - sb.setLength(5); - assertEquals(5, sb.length()); - assertEquals("01234", sb.toString()); - sb.setLength(6); - assertEquals(6, sb.length()); - assertEquals("01234\0", sb.toString()); - sb.setLength(0); - assertEquals(0, sb.length()); - assertEquals("", sb.toString()); - - try { - sb.setLength(-1); - fail("No IOOBE, negative length."); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - sb = new StringBuilder("abcde"); - assertEquals("abcde", sb.toString()); - sb.setLength(1); - sb.append('g'); - assertEquals("ag", sb.toString()); - - sb = new StringBuilder("abcde"); - sb.setLength(3); - sb.append('g'); - assertEquals("abcg", sb.toString()); - - sb = new StringBuilder("abcde"); - sb.setLength(2); - try { - sb.charAt(3); - fail("should throw IndexOutOfBoundsException"); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - sb = new StringBuilder(); - sb.append("abcdefg"); - sb.setLength(2); - sb.setLength(5); - for (int i = 2; i < 5; i++) { - assertEquals(0, sb.charAt(i)); - } - - sb = new StringBuilder(); - sb.append("abcdefg"); - sb.delete(2, 4); - sb.setLength(7); - assertEquals('a', sb.charAt(0)); - assertEquals('b', sb.charAt(1)); - assertEquals('e', sb.charAt(2)); - assertEquals('f', sb.charAt(3)); - assertEquals('g', sb.charAt(4)); - for (int i = 5; i < 7; i++) { - assertEquals(0, sb.charAt(i)); - } - - sb = new StringBuilder(); - sb.append("abcdefg"); - sb.replace(2, 5, "z"); - sb.setLength(7); - for (int i = 5; i < 7; i++) { - assertEquals(0, sb.charAt(i)); - } - } - - /** - * @tests java.lang.StringBuilder.subSequence(int, int) - */ - public void test_subSequenceII() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - CharSequence ss = sb.subSequence(0, 5); - assertEquals("01234", ss.toString()); - - ss = sb.subSequence(0, 0); - assertEquals("", ss.toString()); - - try { - sb.subSequence(-1, 1); - fail("No IOOBE, negative start."); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.subSequence(0, -1); - fail("No IOOBE, negative end."); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.subSequence(0, fixture.length() + 1); - fail("No IOOBE, end > length."); - } catch (IndexOutOfBoundsException e) { - // Expected - } - - try { - sb.subSequence(3, 2); - fail("No IOOBE, start > end."); - } catch (IndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.substring(int) - */ - public void test_substringI() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - String ss = sb.substring(0); - assertEquals(fixture, ss); - - ss = sb.substring(10); - assertEquals("", ss); - - try { - sb.substring(-1); - fail("No SIOOBE, negative start."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb.substring(0, -1); - fail("No SIOOBE, negative end."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb.substring(fixture.length() + 1); - fail("No SIOOBE, start > length."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.substring(int, int) - */ - public void test_substringII() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - String ss = sb.substring(0, 5); - assertEquals("01234", ss); - - ss = sb.substring(0, 0); - assertEquals("", ss); - - try { - sb.substring(-1, 1); - fail("No SIOOBE, negative start."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb.substring(0, -1); - fail("No SIOOBE, negative end."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb.substring(0, fixture.length() + 1); - fail("No SIOOBE, end > length."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - - try { - sb.substring(3, 2); - fail("No SIOOBE, start > end."); - } catch (StringIndexOutOfBoundsException e) { - // Expected - } - } - - /** - * @tests java.lang.StringBuilder.toString()' - */ - public void test_toString() throws Exception { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertEquals(fixture, sb.toString()); - - sb.setLength(0); - sb.append("abcde"); - assertEquals("abcde", sb.toString()); - sb.setLength(1000); - byte[] bytes = sb.toString().getBytes("GB18030"); - for (int i = 5; i < bytes.length; i++) { - assertEquals(0, bytes[i]); - } - - sb.setLength(5); - sb.append("fghij"); - assertEquals("abcdefghij", sb.toString()); - } - - /** - * @tests java.lang.StringBuilder.trimToSize()' - */ - public void test_trimToSize() { - final String fixture = "0123456789"; - StringBuilder sb = new StringBuilder(fixture); - assertTrue(sb.capacity() > fixture.length()); - assertEquals(fixture.length(), sb.length()); - assertEquals(fixture, sb.toString()); - int prevCapacity = sb.capacity(); - sb.trimToSize(); - assertTrue(prevCapacity > sb.capacity()); - assertEquals(fixture.length(), sb.length()); - assertEquals(fixture, sb.toString()); - } - - // comparator for StringBuilder objects - private static final SerializableAssert STRING_BILDER_COMPARATOR = new SerializableAssert() { - public void assertDeserialized(Serializable initial, - Serializable deserialized) { - - StringBuilder init = (StringBuilder) initial; - StringBuilder desr = (StringBuilder) deserialized; - - assertEquals("toString", init.toString(), desr.toString()); - } - }; - - /** - * @tests serialization/deserialization. - */ - public void testSerializationSelf() throws Exception { - - SerializationTest.verifySelf(new StringBuilder("0123456789"), - STRING_BILDER_COMPARATOR); - } - - /** - * @tests serialization/deserialization compatibility with RI. - */ - public void testSerializationCompatibility() throws Exception { - - SerializationTest.verifyGolden(this, new StringBuilder("0123456789"), - STRING_BILDER_COMPARATOR); - } - - private static final class Fixture { - static final Fixture INSTANCE = new Fixture(); - - private Fixture() { - super(); - } - - @Override - public String toString() { - return "fixture"; - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringIndexOutOfBoundsExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringIndexOutOfBoundsExceptionTest.java deleted file mode 100644 index 8ffeb3a..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/StringIndexOutOfBoundsExceptionTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class StringIndexOutOfBoundsExceptionTest extends TestCase { - - /** - * @tests java.lang.StringIndexOutOfBoundsException#StringIndexOutOfBoundsException() - */ - public void test_Constructor() { - StringIndexOutOfBoundsException e = new StringIndexOutOfBoundsException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.StringIndexOutOfBoundsException#StringIndexOutOfBoundsException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - StringIndexOutOfBoundsException e = new StringIndexOutOfBoundsException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SystemTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SystemTest.java deleted file mode 100644 index c5e5688..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/SystemTest.java +++ /dev/null @@ -1,895 +0,0 @@ -/* - * 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 java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.PrintStream; -import java.nio.channels.Channel; -import java.nio.channels.spi.SelectorProvider; -import java.security.Permission; -import java.util.Map; -import java.util.Properties; -import java.util.Vector; - -@TestTargetClass(System.class) -public class SystemTest extends junit.framework.TestCase { - - static boolean flag = false; - - static boolean ranFinalize = false; - - /** - * @tests java.lang.System#setIn(java.io.InputStream) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setIn", - args = {java.io.InputStream.class} - ) - public void test_setInLjava_io_InputStream() { - InputStream orgIn = System.in; - InputStream in = new ByteArrayInputStream(new byte[0]); - System.setIn(in); - assertTrue("in not set", System.in == in); - System.setIn(orgIn); - } - - /** - * @tests java.lang.System#setOut(java.io.PrintStream) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setOut", - args = {java.io.PrintStream.class} - ) - public void test_setOutLjava_io_PrintStream() { - PrintStream orgOut = System.out; - PrintStream out = new PrintStream(new ByteArrayOutputStream()); - System.setOut(out); - assertTrue("out not set", System.out == out); - System.setOut(orgOut); - } - - /** - * @tests java.lang.System#setErr(java.io.PrintStream) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setErr", - args = {java.io.PrintStream.class} - ) - public void test_setErrLjava_io_PrintStream() { - PrintStream orgErr = System.err; - PrintStream err = new PrintStream(new ByteArrayOutputStream()); - System.setErr(err); - assertTrue("err not set", System.err == err); - System.setErr(orgErr); - } - - /** - * @tests java.lang.System#arraycopy(java.lang.Object, int, - * java.lang.Object, int, int) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "arraycopy", - args = {java.lang.Object.class, int.class, java.lang.Object.class, - int.class, int.class} - ) - public void test_arraycopyLjava_lang_ObjectILjava_lang_ObjectII() { - // Test for method void java.lang.System.arraycopy(java.lang.Object, - // int, java.lang.Object, int, int) - Integer a[] = new Integer[20]; - Integer b[] = new Integer[20]; - int i = 0; - while (i < a.length) { - a[i] = new Integer(i); - ++i; - } - System.arraycopy(a, 0, b, 0, a.length); - for (i = 0; i < a.length; i++) - assertTrue("Copied elements incorrectly", a[i].equals(b[i])); - - /* Non primitive array types don't need to be identical */ - String[] source1 = new String[] { "element1" }; - Object[] dest1 = new Object[1]; - System.arraycopy(source1, 0, dest1, 0, dest1.length); - assertTrue("Invalid copy 1", dest1[0] == source1[0]); - - char[][] source = new char[][] { { 'H', 'e', 'l', 'l', 'o' }, - { 'W', 'o', 'r', 'l', 'd' } }; - char[][] dest = new char[2][]; - System.arraycopy(source, 0, dest, 0, dest.length); - assertTrue("Invalid copy 2", dest[0] == source[0] - && dest[1] == source[1]); - - try { - // copy from non array object into Object array - System.arraycopy(new Object(), 0, b, 0, 0); - fail("ArrayStoreException is not thrown."); - } catch(ArrayStoreException ase) { - //expected - } - - try { - // copy from Object array into non array object - System.arraycopy(a, 0, new Object(), 0, 0); - fail("ArrayStoreException is not thrown."); - } catch(ArrayStoreException ase) { - //expected - } - - try { - // copy from primitive array into object array - System.arraycopy(new char[] {'a'}, 0, new String[1], 0, 1); - fail("ArrayStoreException is not thrown."); - } catch(ArrayStoreException ase) { - //expected - } - - try { - // copy from object array into primitive array - System.arraycopy(new String[] {"a"}, 0, new char[1], 0, 1); - fail("ArrayStoreException is not thrown."); - } catch(ArrayStoreException ase) { - //expected - } - - try { - // copy from primitive array into an array of another primitive type - System.arraycopy(new char[] {'a'}, 0, new int[1], 0, 1); - fail("ArrayStoreException is not thrown."); - } catch(ArrayStoreException ase) { - //expected - } - - try { - // copy from object array into an array of another Object type - System.arraycopy(new Character[] {'a'}, 0, new Integer[1], 0, 1); - fail("ArrayStoreException is not thrown."); - } catch(ArrayStoreException ase) { - //expected - } - - try { - // copy from null into an array of a primitive type - System.arraycopy(null, 0, new int[1], 0, 1); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - // copy from a primitive array into null - System.arraycopy(new int[]{'1'}, 0, null, 0, 1); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - System.arraycopy(a, a.length + 1, b, 0, 1); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, -1, b, 0, 1); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, 0, b, -1, 1); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, 0, b, 0, -1); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, 11, b, 0, 10); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, Integer.MAX_VALUE, b, 0, 10); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, 0, b, Integer.MAX_VALUE, 10); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - - try { - System.arraycopy(a, 0, b, 10, Integer.MAX_VALUE); - fail("IndexOutOfBoundsException is not thrown."); - } catch(IndexOutOfBoundsException ioobe) { - //expected - } - } - - /** - * @tests java.lang.System#currentTimeMillis() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "currentTimeMillis", - args = {} - ) - public void test_currentTimeMillis() { - // Test for method long java.lang.System.currentTimeMillis() - try { - long firstRead = System.currentTimeMillis(); - try { - Thread.sleep(150); - } catch (InterruptedException e) { - } - long secondRead = System.currentTimeMillis(); - assertTrue("Incorrect times returned: " + firstRead + ", " - + secondRead, firstRead < secondRead); - } catch (Exception e) { - fail("Exception during test: " + e.toString()); - } - } - - /** - * @tests java.lang.System#getProperties() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getProperties", - args = {} - ) - public void test_getProperties() { - - // Test for method java.util.Properties java.lang.System.getProperties() - /* String[] props = { "java.version", "java.vendor", "java.vendor.url", - "java.home", "java.vm.specification.version", - "java.vm.specification.vendor", "java.vm.specification.name", - "java.vm.version", "java.vm.vendor", "java.vm.name", - "java.specification.name", "java.specification.vendor", - "java.specification.name", "java.class.version", - "java.class.path", "java.ext.dirs", "os.name", "os.arch", - "os.version", "file.separator", "path.separator", - "line.separator", "user.name", "user.home", "user.dir", }; - */ - - String [] props = {"java.vendor.url", - "java.class.path", "user.home", - "java.class.version", "os.version", - "java.vendor", "user.dir", - /*"user.timezone",*/ "path.separator", - "os.name", "os.arch", - "line.separator", "file.separator", - "user.name", "java.version", "java.home" }; - - /* Available properties. - String [] props = {"java.boot.class.path", "java.class.path", - "java.class.version", "java.compiler", "java.ext.dirs", - "java.home", "java.io.tmpdir", "java.library.path", - "java.vendor", "java.vendor.url", "java.version", - "java.vm.name", "java.vm.specification.name", - "java.vm.specification.vendor", "java.vm.specification.version", - "java.vm.vendor", "java.vm.version", "java.specification.name", - "java.specification.vendor", "java.specification.version", - "os.arch", "os.name", "os.version", "user.home", "user.name", - "user.dir", "file.separator", "line.separator", - "path.separator", "java.runtime.name", "java.runtime.version", - "java.vm.vendor.url", "file.encoding","user.language", - "user.region"}; - */ - - Properties p = System.getProperties(); - assertTrue(p.size() > 0); - - // Ensure spec'ed properties are non-null. See System.getProperties() - // spec. - - for (int i = 0; i < props.length; i++) { - assertNotNull("There is no property among returned properties: " - + props[i], p.getProperty(props[i])); - assertNotNull("System property is null: " + props[i], - System.getProperty(props[i])); - } - } - - /** - * @tests java.lang.System#getProperty(java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getProperty", - args = {java.lang.String.class} - ) - public void test_getPropertyLjava_lang_String() { - // Test for method java.lang.String - // java.lang.System.getProperty(java.lang.String) - assertTrue("Failed to return correct property value", System - .getProperty("line.separator").indexOf("\n", 0) >= 0); - - boolean is8859_1 = true; - String encoding = System.getProperty("file.encoding"); - byte[] bytes = new byte[128]; - char[] chars = new char[128]; - for (int i = 0; i < bytes.length; i++) { - bytes[i] = (byte) (i + 128); - chars[i] = (char) (i + 128); - } - String charResult = new String(bytes); - byte[] byteResult = new String(chars).getBytes(); - if (charResult.length() == 128 && byteResult.length == 128) { - for (int i = 0; i < bytes.length; i++) { - if (charResult.charAt(i) != (char) (i + 128) - || byteResult[i] != (byte) (i + 128)) - is8859_1 = false; - } - } else - is8859_1 = false; - String[] possibles = new String[] { "ISO8859_1", "8859_1", "ISO8859-1", - "ISO-8859-1", "ISO_8859-1", "ISO_8859-1:1978", "ISO-IR-100", - "LATIN1", "CSISOLATIN1" }; - boolean found8859_1 = false; - for (int i = 0; i < possibles.length; i++) { - if (possibles[i].equals(encoding)) { - found8859_1 = true; - break; - } - } - assertTrue("Wrong encoding: " + encoding, !is8859_1 || found8859_1); - - try { - System.getProperty(null); - fail("NullPointerException should be thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - System.getProperty(""); - fail("IllegalArgumentException should be thrown."); - } catch(IllegalArgumentException iae) { - //expected - } - } - - /** - * @tests java.lang.System#getProperty(java.lang.String, java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getProperty", - args = {java.lang.String.class, java.lang.String.class} - ) - public void test_getPropertyLjava_lang_StringLjava_lang_String() { - // Test for method java.lang.String - // java.lang.System.getProperty(java.lang.String, java.lang.String) - assertTrue("Failed to return correct property value: " - + System.getProperty("line.separator", "99999"), System - .getProperty("line.separator", "99999").indexOf("\n", 0) >= 0); - assertEquals("Failed to return correct property value", "bogus", System - .getProperty("bogus.prop", "bogus")); - - try { - System.getProperty(null, "0.0"); - fail("NullPointerException should be thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - System.getProperty("", "0"); - fail("IllegalArgumentException should be thrown."); - } catch(IllegalArgumentException iae) { - //expected - } - } - - /** - * @tests java.lang.System#setProperty(java.lang.String, java.lang.String) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setProperty", - args = {java.lang.String.class, java.lang.String.class} - ) - public void test_setPropertyLjava_lang_StringLjava_lang_String() { - // Test for method java.lang.String - // java.lang.System.setProperty(java.lang.String, java.lang.String) - - assertNull("Failed to return null", System.setProperty("testing", - "value1")); - assertTrue("Failed to return old value", System.setProperty("testing", - "value2") == "value1"); - assertTrue("Failed to find value", - System.getProperty("testing") == "value2"); - - boolean exception = false; - try { - System.setProperty("", "default"); - } catch (IllegalArgumentException e) { - exception = true; - } - assertTrue("Expected IllegalArgumentException", exception); - } - - /** - * @tests java.lang.System#getSecurityManager() - */ - @TestTargetNew( - level = TestLevel.PARTIAL, - notes = "Doesn't check positive functionality.", - method = "getSecurityManager", - args = {} - ) - public void test_getSecurityManager() { - // Test for method java.lang.SecurityManager - // java.lang.System.getSecurityManager() - assertNull("Returned incorrect SecurityManager", System - .getSecurityManager()); - } - - /** - * @tests java.lang.System#identityHashCode(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "identityHashCode", - args = {java.lang.Object.class} - ) - public void test_identityHashCodeLjava_lang_Object() { - // Test for method int - // java.lang.System.identityHashCode(java.lang.Object) - Object o = new Object(); - String s = "Gabba"; - assertEquals("Nonzero returned for null", - 0, System.identityHashCode(null)); - assertTrue("Nonequal has returned for Object", System - .identityHashCode(o) == o.hashCode()); - assertTrue("Same as usual hash returned for String", System - .identityHashCode(s) != s.hashCode()); - } - - /** - * @throws IOException - * @tests java.lang.System#inheritedChannel() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "inheritedChannel", - args = {} - ) - public void test_inheritedChannel() throws IOException { - Channel iChannel = System.inheritedChannel(); - assertNull("Incorrect value of channel", iChannel); - SelectorProvider sp = SelectorProvider.provider(); - assertEquals("Incorrect value of channel", - sp.inheritedChannel(), iChannel); - } - - /** - * @tests java.lang.System#runFinalization() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "runFinalization", - args = {} - ) - public void test_runFinalization() { - // Test for method void java.lang.System.runFinalization() - - flag = true; - createInstance(); - int count = 10; - // the gc below likely bogosifies the test, but will have to do for - // the moment - while (!ranFinalize && count-- > 0) { - System.gc(); - System.runFinalization(); - } - assertTrue("Failed to run finalization", ranFinalize); - } - - /** - * @tests java.lang.System#runFinalizersOnExit(boolean) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "runFinalizersOnExit", - args = {boolean.class} - ) - @SuppressWarnings("deprecation") - public void test_runFinalizersOnExitZ() { - // Can we call the method at least? - try { - System.runFinalizersOnExit(false); - } catch (Throwable t) { - fail("Failed to set runFinalizersOnExit"); - } - - try { - System.runFinalizersOnExit(true); - } catch (Throwable t) { - fail("Failed to set runFinalizersOnExit"); - } - } - - /** - * @tests java.lang.System#setProperties(java.util.Properties) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setProperties", - args = {java.util.Properties.class} - ) - public void test_setPropertiesLjava_util_Properties() { - // Test for method void - // java.lang.System.setProperties(java.util.Properties) - - Properties orgProps = System.getProperties(); - java.util.Properties tProps = new java.util.Properties(); - tProps.put("test.prop", "this is a test property"); - tProps.put("bogus.prop", "bogus"); - System.setProperties(tProps); - try { - assertEquals("Failed to set properties", "this is a test property", System.getProperties() - .getProperty("test.prop")); - } finally { - // restore the original properties - System.setProperties(orgProps); - } - } - - //Regression Test for Harmony-2356 - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getenv", - args = {} - ) - public void testEnvUnmodifiable() { - Map map = System.getenv(); - try { - map.containsKey(null); - fail("Should throw NullPointerExcepiton."); - } catch (NullPointerException e) { - // expected - } - - try { - map.containsKey(new Integer(10)); - fail("Should throw ClassCastException."); - } catch (ClassCastException e) { - // expected - } - - try { - map.containsValue(null); - fail("Should throw NullPointerExcepiton."); - } catch (NullPointerException e) { - // expected - } - - try { - map.containsValue(new Integer(10)); - fail("Should throw ClassCastException."); - } catch (ClassCastException e) { - // expected - } - - try { - map.get(null); - fail("Should throw NullPointerExcepiton."); - } catch (NullPointerException e) { - // expected - } - - try { - map.get(new Integer(10)); - fail("Should throw ClassCastException."); - } catch (ClassCastException e) { - // expected - } - - try { - map.put(null, "AAA"); - fail("Should throw UnsupportedOperationExcepiton."); - } catch (UnsupportedOperationException e) { - // expected - } - - try { - map.put("AAA", new Integer(10)); - fail("Should throw UnsupportedOperationException."); - } catch (UnsupportedOperationException e) { - // expected - } - - try { - map.put("AAA", "BBB"); - fail("Should throw UnsupportedOperationException."); - } catch (UnsupportedOperationException e) { - // expected - } - - try { - map.clear(); - fail("Should throw UnsupportedOperationException."); - } catch (UnsupportedOperationException e) { - // expected - } - - try { - map.remove(null); - fail("Should throw UnsupportedOperationException."); - } catch (UnsupportedOperationException e) { - // expected - } - - } - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "clearProperty", - args = {java.lang.String.class} - ) - public void test_clearProperty() { - System.setProperty("test", "value"); - System.clearProperty("test"); - assertNull("Property was not deleted.", System.getProperty("test")); - - try { - System.clearProperty(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - - try { - System.clearProperty(""); - fail("IllegalArgumentException is not thrown."); - } catch(IllegalArgumentException iae) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "gc", - args = {} - ) - public void test_gc() { - Runtime rt = Runtime.getRuntime(); - Vector<StringBuffer> vec = new Vector<StringBuffer>(); - long beforeTest = rt.freeMemory(); - while(rt.freeMemory() < beforeTest * 2/3) { - vec.add(new StringBuffer(1000)); - } - vec = null; - long beforeGC = rt.freeMemory(); - System.gc(); - long afterGC = rt.freeMemory(); - assertTrue("memory was not released after calling System.gc()." + - "before gc: " + beforeGC + "; after gc: " + afterGC, - beforeGC < afterGC); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getenv", - args = {} - ) - public void test_getenv() { - - // String[] props = { "PATH", "HOME", "USER"}; - // only PATH of these three exists on android - String[] props = { "PATH" }; - - Map<String,String> envMap = System.getenv(); - assertFalse("environment map is empty.", envMap.isEmpty()); - assertTrue("env map contains less than 3 keys.", - props.length < envMap.keySet().size()); - for(int i = 0; i < props.length; i++) { - assertNotNull("There is no property: " + props[i], - envMap.get(props[i])); - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getenv", - args = {java.lang.String.class} - ) - public void test_getenvLString() { - - assertNotNull("PATH environment variable is not found", - System.getenv("PATH")); - - assertNull("Doesn't return NULL for non existent property", - System.getenv("nonexistent.property")); - - try { - System.getenv(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "load", - args = {java.lang.String.class} - ) - public void test_load() { - try { - Runtime.getRuntime().load("nonExistentLibrary"); - fail("UnsatisfiedLinkError was not thrown."); - } catch(UnsatisfiedLinkError e) { - //expected - } - - try { - System.load("nonExistentLibrary"); - fail("UnsatisfiedLinkError was not thrown."); - } catch(UnsatisfiedLinkError ule) { - //expected - } - - try { - System.load(null); - fail("NullPointerException was not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "loadLibrary", - args = {java.lang.String.class} - ) - public void test_loadLibrary() { - - try { - System.loadLibrary("nonExistentLibrary"); - fail("UnsatisfiedLinkError was not thrown."); - } catch(UnsatisfiedLinkError ule) { - //expected - } - - try { - System.loadLibrary(null); - fail("NullPointerException was not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "mapLibraryName", - args = {java.lang.String.class} - ) - public void test_mapLibraryName() { - assertEquals("libname.so", System.mapLibraryName("name")); - - try { - System.mapLibraryName(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException npe) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "nanoTime", - args = {} - ) - public void test_nanoTime() { - long sleepTime = 5000; - long beginTime = System.nanoTime(); - try { - Thread.sleep(sleepTime); - } catch(Exception e) { - fail("Unknown exception was thrown."); - } - long endTime = System.nanoTime(); - assertTrue((endTime - beginTime) > sleepTime * 1000000); - } - - @Override - protected void setUp() { - flag = false; - ranFinalize = false; - } - - @Override protected void tearDown() throws Exception { - super.tearDown(); - } - - protected SystemTest createInstance() { - return new SystemTest("FT"); - } - - @Override - protected void finalize() { - if (flag) - ranFinalize = true; - } - - public SystemTest() { - } - - public SystemTest(String name) { - super(name); - } - - private class MockSecurityManager extends SecurityManager { - @Override - public void checkPermission(Permission perm) { - if (perm.equals(new RuntimePermission("inheritedChannel"))) - throw new SecurityException("Incorrect permission"); - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAnnotation.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAnnotation.java deleted file mode 100644 index 45d16ad..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAnnotation.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; - -@Retention(RetentionPolicy.RUNTIME) -public @interface TestAnnotation { - String value(); -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAssertions.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAssertions.java deleted file mode 100644 index 3006553..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAssertions.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestAssertions { - boolean isTrue = false; - - TestAssertions() { - - } - - public void test() throws AssertionError { - assert (isTrue == true); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAssertions1.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAssertions1.java deleted file mode 100644 index 16958cb..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestAssertions1.java +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestAssertions1 { - boolean isTrue = true; - - TestAssertions1() { - - } - - public void test() throws AssertionError { - assert (isTrue == false); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1.java deleted file mode 100644 index 2d21de6..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestClass1 { - static TestClass2 tc = new TestClass2(0); - - TestClass1() { - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1B.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1B.java deleted file mode 100644 index 7891613..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1B.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestClass1B { - static TestClass2 tc = new TestClass2(0); - - TestClass1B() { - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1C.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1C.java deleted file mode 100644 index 37c890f..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass1C.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestClass1C { - static TestClass2 tc = new TestClass2(0); - - TestClass1C() { - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass2.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass2.java deleted file mode 100644 index 26be6fa..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass2.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestClass2 { - - public TestClass2(int i) throws IllegalArgumentException { - throw new IllegalArgumentException(); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass3.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass3.java deleted file mode 100644 index 21ebb38..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass3.java +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (C) 2008 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.harmony.luni.tests.java.lang; - -public class TestClass3 { - private TestClass3() {} -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass4.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass4.java deleted file mode 100644 index e69de29..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TestClass4.java +++ /dev/null diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadDeathTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadDeathTest.java deleted file mode 100644 index c40e0b0..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadDeathTest.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * 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; - -public class ThreadDeathTest extends junit.framework.TestCase { - - /** - * @tests java.lang.ThreadDeath#ThreadDeath() - */ - public void test_Constructor() { - ThreadDeath td = new ThreadDeath(); - assertNull(td.getCause()); - assertNull(td.getMessage()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadLocalTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadLocalTest.java deleted file mode 100644 index 659a839..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThreadLocalTest.java +++ /dev/null @@ -1,217 +0,0 @@ -/* - * 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(ThreadLocal.class) -public class ThreadLocalTest extends TestCase { - - /** - * @tests java.lang.ThreadLocal#ThreadLocal() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "ThreadLocal", - args = {} - ) - public void test_Constructor() { - new ThreadLocal<Object>(); - } - - /** - * @tests java.lang.ThreadLocal#remove() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "remove", - args = {} - ) - public void test_remove() { - ThreadLocal<String> tl = new ThreadLocal<String>() { - @Override - protected String initialValue() { - return "initial"; - } - }; - - assertEquals("initial", tl.get()); - tl.set("fixture"); - assertEquals("fixture", tl.get()); - tl.remove(); - assertEquals("initial", tl.get()); - } - - /** - * @tests java.lang.ThreadLocal#get() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "get", - args = {} - ) - public void test_get() { - // Test for method java.lang.Object java.lang.ThreadLocal.get() - ThreadLocal<Object> l = new ThreadLocal<Object>(); - assertNull("ThreadLocal's initial value is null", l.get()); - - // The ThreadLocal has to run once for each thread that touches the - // ThreadLocal - final Object INITIAL_VALUE = "'foo'"; - final ThreadLocal<Object> l1 = new ThreadLocal<Object>() { - @Override - protected Object initialValue() { - return INITIAL_VALUE; - } - }; - - assertTrue("ThreadLocal's initial value should be " + INITIAL_VALUE - + " but is " + l1.get(), l1.get() == INITIAL_VALUE); - - // We need this because inner types cannot assign to variables in - // container method. But assigning to object slots in the container - // method is ok. - class ResultSlot { - public Object result = null; - } - - final ResultSlot THREADVALUE = new ResultSlot(); - Thread t = new Thread() { - @Override - public void run() { - THREADVALUE.result = l1.get(); - } - }; - - // Wait for the other Thread assign what it observes as the value of the - // variable - t.start(); - try { - t.join(); - } catch (InterruptedException ie) { - fail("Interrupted!!"); - } - - assertTrue("ThreadLocal's initial value in other Thread should be " - + INITIAL_VALUE, THREADVALUE.result == INITIAL_VALUE); - - /* Regression test for implementation vulnerability reported - * on Harmony dev list. - */ - ThreadLocal<Object> thrVar = new ThreadLocal<Object>() { - public int hashCode() { - fail("ThreadLocal should not be asked for it's hashCode"); - return 0; // never reached - } - }; - thrVar.get(); - } - - /** - * @tests java.lang.ThreadLocal#set(java.lang.Object) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "set", - args = {java.lang.Object.class} - ) - public void test_setLjava_lang_Object() { - // Test for method void java.lang.ThreadLocal.set(java.lang.Object) - - final Object OBJ = new Object(); - final ThreadLocal<Object> l = new ThreadLocal<Object>(); - l.set(OBJ); - assertTrue("ThreadLocal's initial value is " + OBJ, l.get() == OBJ); - - // We need this because inner types cannot assign to variables in - // container method. - // But assigning to object slots in the container method is ok. - class ResultSlot { - public Object result = null; - } - - final ResultSlot THREADVALUE = new ResultSlot(); - Thread t = new Thread() { - @Override - public void run() { - THREADVALUE.result = l.get(); - } - }; - - // Wait for the other Thread assign what it observes as the value of the - // variable - t.start(); - try { - t.join(); - } catch (InterruptedException ie) { - fail("Interrupted!!"); - } - - // ThreadLocal is not inherited, so the other Thread should see it as - // null - assertNull("ThreadLocal's value in other Thread should be null", - THREADVALUE.result); - - } - - /** - * @tests java.lang.InheritableThreadLocal - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "get", - args = {} - ) - public void test_Ljava_lang_InheritableThreadLocal() - throws InterruptedException { - final Object value = new Object(); - final Object inheritedValue = new Object(); - final ThreadLocal<Object> threadLocal - = new InheritableThreadLocal<Object>() { - @Override - protected Object childValue(Object parentValue) { - assertSame(value, parentValue); - return inheritedValue; - } - }; - threadLocal.set(value); - final Object[] holder = new Object[1]; - Thread thread = new Thread() { - public void run() { - holder[0] = threadLocal.get(); - } - }; - thread.start(); - thread.join(); - assertSame(value, threadLocal.get()); - assertSame(inheritedValue, holder[0]); - - // Cleanup properly, so other tests are not affected. - threadLocal.remove(); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThrowableTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThrowableTest.java deleted file mode 100644 index a8e5c7f..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/ThrowableTest.java +++ /dev/null @@ -1,413 +0,0 @@ -/* - * 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.io.ByteArrayOutputStream; -import java.io.IOException; -import java.io.PrintStream; -import java.io.PrintWriter; - -@TestTargetClass(Throwable.class) -public class ThrowableTest extends TestCase { - - /** - * @tests java.lang.Throwable#Throwable() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Throwable", - args = {} - ) - public void test_Constructor() { - Throwable e = new Throwable(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.Throwable#Throwable(java.lang.String) - */ - @TestTargets({ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Throwable", - args = {java.lang.String.class} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMessage", - args = {} - ) - }) - public void test_ConstructorLjava_lang_String() { - Throwable e = new Throwable("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Throwable", - args = {java.lang.String.class, java.lang.Throwable.class} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getCause", - args = {} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMessage", - args = {} - ) - }) - public void test_ConstructorLStringLThrowable() { - String message = "Test message"; - NullPointerException npe = new NullPointerException(); - Throwable thr = new Throwable(message, npe); - assertEquals("message is incorrect.", message, thr.getMessage()); - assertEquals("cause is incorrect.", npe, thr.getCause()); - - thr = new Throwable(null, npe); - assertNull("message is not null.", thr.getMessage()); - assertEquals("cause is incorrect.", npe, thr.getCause()); - - thr = new Throwable(message, null); - assertEquals("message is incorrect.", message, thr.getMessage()); - assertNull("cause is not null.", thr.getCause()); - } - - @TestTargets({ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "Throwable", - args = {java.lang.Throwable.class} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getCause", - args = {} - ), - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getMessage", - args = {} - ) - }) - public void test_ConstructorLThrowable() { - - NullPointerException npe = new NullPointerException(); - Throwable thr = new Throwable(npe); - - assertEquals("Returned cause is incorrect.", npe, thr.getCause()); - - thr = new Throwable((Throwable) null); - assertNull("The cause is not null.", thr.getCause()); - } - - /** - * @tests java.lang.Throwable#fillInStackTrace() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "fillInStackTrace", - args = {} - ) - public void test_fillInStackTrace() { - // Test for method java.lang.Throwable - // java.lang.Throwable.fillInStackTrace() - class Test implements Runnable { - public int x; - - public Test(int x) { - this.x = x; - } - - public void anotherMethod() { - if (true) - throw new IndexOutOfBoundsException(); - } - - public void run() { - if (x == 0) - throw new IndexOutOfBoundsException(); - try { - anotherMethod(); - } catch (IndexOutOfBoundsException e) { - e.fillInStackTrace(); - throw e; - } - } - } - ByteArrayOutputStream bao = new ByteArrayOutputStream(); - PrintStream ps = new PrintStream(bao); - try { - new Test(0).run(); - } catch (Throwable e) { - e.printStackTrace(ps); - } - ps.flush(); - String s = fixStacktrace(new String(bao.toByteArray(), 0, bao.size())); - - bao.reset(); - try { - new Test(1).run(); - } catch (Throwable e) { - e.printStackTrace(ps); - } - ps.close(); - String s2 = fixStacktrace(new String(bao.toByteArray(), 0, bao.size())); - assertTrue("Invalid stackTrace? length: " + s2.length() + "\n" + s2, s2 - .length() > 300); - assertTrue("Incorrect stackTrace printed: \n" + s2 - + "\n\nCompared with:\n" + s, s2.equals(s)); - } - - private String fixStacktrace(String trace) { - // remove linenumbers - StringBuffer sb = new StringBuffer(); - int lastIndex = 0; - while (lastIndex < trace.length()) { - int index = trace.indexOf('\n', lastIndex); - if (index == -1) - index = trace.length(); - String line = trace.substring(lastIndex, index); - lastIndex = index + 1; - - index = line.indexOf("("); - if (index > -1) { - line = line.substring(0, index); - } - // Usually the construction of the exception is removed - // however if running with the JIT, it may not be removed - if (line.indexOf("java.lang.Throwable") > -1) - continue; - sb.append(line); - sb.append('\n'); - } - return sb.toString(); - } - - /** - * @tests java.lang.Throwable#printStackTrace() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "printStackTrace", - args = {} - ) - public void test_printStackTrace() { - // Test for method void java.lang.Throwable.printStackTrace() - Throwable x = new ClassNotFoundException("A Test Message"); - ByteArrayOutputStream bao = new ByteArrayOutputStream(); - PrintStream ps = new PrintStream(bao); - PrintStream err = System.err; - System.setErr(ps); - x.printStackTrace(); - System.setErr(err); - ps.close(); - String s = new String(bao.toByteArray(), 0, bao.size()); - assertTrue("Incorrect stackTrace printed:\n" + s, s != null - && s.length() > 400); - } - - /** - * @tests java.lang.Throwable#printStackTrace(java.io.PrintStream) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "printStackTrace", - args = {java.io.PrintStream.class} - ) - public void test_printStackTraceLjava_io_PrintStream() { - // Test for method void - // java.lang.Throwable.printStackTrace(java.io.PrintStream) - ByteArrayOutputStream bao = new ByteArrayOutputStream(); - PrintStream ps = new PrintStream(bao); - Throwable x = new java.net.UnknownHostException("A Message"); - x.printStackTrace(ps); - ps.close(); - String s = new String(bao.toByteArray(), 0, bao.size()); - assertTrue("Incorrect stackTrace printed:\n" + s, s != null - && s.length() > 400); - } - - /** - * @tests java.lang.Throwable#printStackTrace(java.io.PrintWriter) - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "printStackTrace", - args = {java.io.PrintWriter.class} - ) - public void test_printStackTraceLjava_io_PrintWriter() { - // Test for method void - // java.lang.Throwable.printStackTrace(java.io.PrintWriter) - // SM - ByteArrayOutputStream bao = new ByteArrayOutputStream(); - PrintWriter pw = new PrintWriter(bao); - Throwable x = new java.net.UnknownHostException("A Message"); - x.printStackTrace(pw); - pw.close(); - String s = new String(bao.toByteArray(), 0, bao.size()); - assertTrue("Incorrect stackTrace printed:\n" + s, s != null - && s.length() > 400); - } - - /** - * @tests java.lang.Throwable#toString() - */ - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "toString", - args = {} - ) - public void test_toString() { - Throwable e = new Throwable("Throw"); - assertEquals("java.lang.Throwable: Throw", e.toString()); - - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getLocalizedMessage", - args = {} - ) - public void test_getLocalizedMessage() { - String testMessage = "Test message"; - Throwable e = new Throwable(testMessage); - assertEquals("Returned incorrect localized message.", - testMessage, e.getLocalizedMessage()); - - TestThrowable tt = new TestThrowable(testMessage); - assertEquals("localized message", tt.getLocalizedMessage()); - } - - class TestThrowable extends Throwable { - - public TestThrowable(String message) { - super(message); - } - - public String getLocalizedMessage() { - return "localized message"; - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "getStackTrace", - args = {} - ) - public void test_getStackTrace() { - String message = "Test message"; - NullPointerException npe = new NullPointerException(); - Throwable thr = new Throwable(message, npe); - StackTraceElement[] ste = thr.getStackTrace(); - assertNotNull("Returned stack trace is empty", ste.length != 0); - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "initCause", - args = {java.lang.Throwable.class} - ) - public void test_initCause() { - String message = "Test message"; - NullPointerException npe = new NullPointerException(); - IllegalArgumentException iae = new IllegalArgumentException(); - Throwable thr = new Throwable(); - thr.initCause(iae); - assertEquals("getCause returns incorrect cause.", iae, thr.getCause()); - - thr = new Throwable("message"); - thr.initCause(npe); - assertEquals("getCause returns incorrect cause.", npe, thr.getCause()); - - thr = new Throwable(message, npe); - try { - thr.initCause(iae); - fail("IllegalStateException was not thrown."); - } catch(IllegalStateException ise) { - //expected - } - - thr = new Throwable(npe); - try { - thr.initCause(iae); - fail("IllegalStateException was not thrown."); - } catch(IllegalStateException ise) { - //expected - } - - thr = new Throwable(); - try { - thr.initCause(thr); - fail("IllegalArgumentException was not thrown."); - } catch(IllegalArgumentException ise) { - //expected - } - } - - @TestTargetNew( - level = TestLevel.COMPLETE, - notes = "", - method = "setStackTrace", - args = {java.lang.StackTraceElement[].class} - ) - public void test_setStackTrace() { - NullPointerException npe = new NullPointerException(); - Throwable thr = new Throwable(npe); - StackTraceElement[] ste = thr.getStackTrace(); - Throwable thr1 = new Throwable(npe); - thr1.setStackTrace(ste); - assertEquals(ste.length, thr1.getStackTrace().length); - - try { - thr.setStackTrace(null); - fail("NullPointerException is not thrown."); - } catch(NullPointerException np) { - //expected - } - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TypeNotPresentExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TypeNotPresentExceptionTest.java deleted file mode 100644 index 76df014..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/TypeNotPresentExceptionTest.java +++ /dev/null @@ -1,54 +0,0 @@ -/* 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 junit.framework.TestCase; - -public class TypeNotPresentExceptionTest extends TestCase { - - /** - * @tests java.lang.TypeNotPresentException.TypeNotPresentException(String, Throwable) - */ - public void test_constructorLjava_lang_StringLjava_lang_Throwable() { - TypeNotPresentException e = new TypeNotPresentException(null, null); - assertNotNull(e); - String m = e.getMessage(); - assertNotNull(m); - - e = new TypeNotPresentException(getClass().getName(), null); - assertNotNull(e); - m = e.getMessage(); - assertNotNull(m); - - NullPointerException npe = new NullPointerException(); - e = new TypeNotPresentException(getClass().getName(), npe); - assertNotNull(e.getMessage()); - assertSame(npe, e.getCause()); - } - - /** - * @tests java.lang.TypeNotPresentException.typeName() - */ - public void test_typeName() { - TypeNotPresentException e = new TypeNotPresentException(null, null); - assertNull(e.typeName()); - - e = new TypeNotPresentException(getClass().getName(), null); - assertEquals(getClass().getName(), e.typeName()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnknownErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnknownErrorTest.java deleted file mode 100644 index 15f264b..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnknownErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class UnknownErrorTest extends TestCase { - - /** - * @tests java.lang.UnknownError#UnknownError() - */ - public void test_Constructor() { - UnknownError e = new UnknownError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.UnknownError#UnknownError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - UnknownError e = new UnknownError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsatisfiedLinkErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsatisfiedLinkErrorTest.java deleted file mode 100644 index 84229d8..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsatisfiedLinkErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class UnsatisfiedLinkErrorTest extends TestCase { - - /** - * @tests java.lang.UnsatisfiedLinkError#UnsatisfiedLinkError() - */ - public void test_Constructor() { - UnsatisfiedLinkError e = new UnsatisfiedLinkError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.UnsatisfiedLinkError#UnsatisfiedLinkError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - UnsatisfiedLinkError e = new UnsatisfiedLinkError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsupportedClassVersionErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsupportedClassVersionErrorTest.java deleted file mode 100644 index 791ec16..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsupportedClassVersionErrorTest.java +++ /dev/null @@ -1,46 +0,0 @@ -/* - * 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 junit.framework.TestCase; // android-changed - -public class UnsupportedClassVersionErrorTest extends TestCase { // android-changed - /** - * Thrown when the Java Virtual Machine attempts to read a class file and - * determines that the major and minor version numbers in the file are not - * supported. - */ - - /** - * @tests java.lang.UnsupportedClassVersionError#UnsupportedClassVersionError() - */ - public void test_UnsupportedClassVersionError() { - UnsupportedClassVersionError error = new UnsupportedClassVersionError(); - assertNotNull(error); - assertNull(error.getMessage()); - } - - /** - *@tests java.lang.UnsupportedClassVersionError#UnsupportedClassVersionError(java.lang.String) - */ - public void test_UnsupportedClassVersionError_LString() { - UnsupportedClassVersionError e = new UnsupportedClassVersionError( - "Some Error Message"); - assertEquals("Wrong message", "Some Error Message", e.getMessage()); - } - -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsupportedOperationExceptionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsupportedOperationExceptionTest.java deleted file mode 100644 index 4b1dbd8..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/UnsupportedOperationExceptionTest.java +++ /dev/null @@ -1,100 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -import org.apache.harmony.testframework.serialization.SerializationTest; - -public class UnsupportedOperationExceptionTest extends TestCase { - - /** - * @tests java.lang.UnsupportedOperationException#UnsupportedOperationException() - */ - public void test_Constructor() { - UnsupportedOperationException e = new UnsupportedOperationException(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.UnsupportedOperationException#UnsupportedOperationException(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - UnsupportedOperationException e = new UnsupportedOperationException("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } - - /** - * @tests {@link java.land.UnsupportedOperationException#UnsupportedOperationException(java.lang.Throwable)} - */ - public void test_ConstructorLjava_lang_Throwable() { - Throwable emptyThrowable = new Exception(); - UnsupportedOperationException emptyException = new UnsupportedOperationException( - emptyThrowable); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getLocalizedMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getCause().toString()); - - Throwable throwable = new Exception("msg"); - UnsupportedOperationException exception = new UnsupportedOperationException(throwable); - assertEquals(throwable.getClass().getName() + ": " + "msg", exception.getMessage()); - assertEquals(throwable.getClass().getName(), emptyException.getLocalizedMessage()); - assertEquals(throwable.getClass().getName(), emptyException.getCause().toString()); - } - - /** - * @tests {@link java.land.UnsupportedOperationException#UnsupportedOperationException(java.lang.String, java.lang.Throwable)} - */ - public void test_ConstructorLjava_lang_StringLjava_lang_Throwable() { - Throwable emptyThrowable = new Exception(); - UnsupportedOperationException emptyException = new UnsupportedOperationException( - "msg", emptyThrowable); - assertEquals("msg", emptyException.getMessage()); - assertEquals("msg", emptyException.getLocalizedMessage()); - assertEquals(emptyThrowable.getClass().getName(), emptyException.getCause().toString()); - - Throwable throwable = new Exception("msg_exception"); - UnsupportedOperationException exception = new UnsupportedOperationException( - "msg", throwable); - assertEquals("msg", exception.getMessage()); - assertEquals("msg", exception.getLocalizedMessage()); - assertEquals(throwable.getClass().getName() + ": " + throwable.getMessage(), exception - .getCause().toString()); - } - - - /** - * @tests serialization/deserialization. - */ - public void testSerializationSelf() throws Exception { - - SerializationTest.verifySelf(new UnsupportedOperationException()); - } - - /** - * @tests serialization/deserialization compatibility with RI. - */ - public void testSerializationCompatibility() throws Exception { - - SerializationTest.verifyGolden(this, - new UnsupportedOperationException()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/VerifyErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/VerifyErrorTest.java deleted file mode 100644 index 7bd2581..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/VerifyErrorTest.java +++ /dev/null @@ -1,42 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -public class VerifyErrorTest extends TestCase { - - /** - * @tests java.lang.VerifyError#VerifyError() - */ - public void test_Constructor() { - VerifyError e = new VerifyError(); - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.VerifyError#VerifyError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - VerifyError e = new VerifyError("fixture"); - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/VirtualMachineErrorTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/VirtualMachineErrorTest.java deleted file mode 100644 index c8ce58c..0000000 --- a/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/VirtualMachineErrorTest.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * 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 junit.framework.TestCase; - -@SuppressWarnings("serial") -public class VirtualMachineErrorTest extends TestCase { - - /** - * @tests java.lang.VirtualMachineError#VirtualMachineError() - */ - public void test_Constructor() { - VirtualMachineError e = new VirtualMachineError() {}; - assertNull(e.getMessage()); - assertNull(e.getLocalizedMessage()); - assertNull(e.getCause()); - } - - /** - * @tests java.lang.VirtualMachineError#VirtualMachineError(java.lang.String) - */ - public void test_ConstructorLjava_lang_String() { - VirtualMachineError e = new VirtualMachineError("fixture") {}; - assertEquals("fixture", e.getMessage()); - assertNull(e.getCause()); - } -} diff --git a/luni/src/test/java/tests/luni/AllTestsLang.java b/luni/src/test/java/tests/luni/AllTestsLang.java index 3da5bb4..a7a18a8 100644 --- a/luni/src/test/java/tests/luni/AllTestsLang.java +++ b/luni/src/test/java/tests/luni/AllTestsLang.java @@ -33,8 +33,6 @@ public class AllTestsLang public static final Test suite() { TestSuite suite = new TestSuite("Tests for java.lang"); - suite.addTest(org.apache.harmony.luni.tests.java.lang.AllTests.suite()); - suite.addTest(tests.api.java.lang.AllTests.suite()); suite.addTest(tests.api.java.lang.ref.AllTests.suite()); diff --git a/luni/src/test/resources/org/apache/harmony/luni/tests/java/lang/HelloWorld.txt b/luni/src/test/resources/libcore/java/lang/HelloWorld.txt index 349db2b..349db2b 100644 --- a/luni/src/test/resources/org/apache/harmony/luni/tests/java/lang/HelloWorld.txt +++ b/luni/src/test/resources/libcore/java/lang/HelloWorld.txt diff --git a/luni/src/test/resources/org/apache/harmony/luni/tests/java/lang/HelloWorld1.txt b/luni/src/test/resources/libcore/java/lang/HelloWorld1.txt index 349db2b..349db2b 100644 --- a/luni/src/test/resources/org/apache/harmony/luni/tests/java/lang/HelloWorld1.txt +++ b/luni/src/test/resources/libcore/java/lang/HelloWorld1.txt |