/*
* 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.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 {
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");
}
/**
* @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
// we are just doing some basic sanity
// checks here.
assertTrue("must have some free memory",
r.freeMemory() > 0);
assertTrue("must not exceed total memory",
r.freeMemory() < r.totalMemory());
long before = r.totalMemory() - r.freeMemory();
Vector<byte[]> v = new Vector<byte[]>();
for (int i = 1; i < 10; i++) {
v.addElement(new byte[10000]);
}
long after = r.totalMemory() - r.freeMemory();
assertTrue("free memory must change with allocations",
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() {
try {
Runtime.getRuntime().addShutdownHook(this);
fail("IllegalStateException was not thrown.");
} catch(IllegalStateException ise) {
//expected
}
}
};
try {
Runtime.getRuntime().addShutdownHook(thrException);
} catch (Throwable t) {
fail(t.getMessage());
}
try {
Runtime.getRuntime().addShutdownHook(thrException);
fail("IllegalArgumentException was not thrown.");
} catch(IllegalArgumentException iae) {
// expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
if (perm.getName().equals("shutdownHooks")) {
throw new SecurityException();
}
}
};
// remove previously added hook so we're not depending on the priority
// of the Exceptions to be thrown.
Runtime.getRuntime().removeShutdownHook(thrException);
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().addShutdownHook(thrException);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
System.setSecurityManager(oldSm);
}
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException ie) {
}
}
@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() {
String [] envp = getEnv();
checkExec(0, envp, null);
checkExec(0, null, null);
try {
Runtime.getRuntime().exec((String)null, null);
fail("NullPointerException should be thrown.");
} catch(IOException ioe) {
fail("IOException was thrown.");
} catch(NullPointerException npe) {
//expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
if (perm.getName().equals("checkExec")) {
throw new SecurityException();
}
}
public void checkExec(String cmd) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().exec("ls", envp);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException e) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
try {
Runtime.getRuntime().exec("", envp);
fail("IllegalArgumentException should be thrown.");
} catch(IllegalArgumentException iae) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
}
@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();
checkExec(4, envp, null);
checkExec(4, null, null);
try {
Runtime.getRuntime().exec((String[])null, null);
fail("NullPointerException should be thrown.");
} catch(IOException ioe) {
fail("IOException was thrown.");
} catch(NullPointerException npe) {
//expected
}
try {
Runtime.getRuntime().exec(new String[]{"ls", null}, null);
fail("NullPointerException should be thrown.");
} catch(IOException ioe) {
fail("IOException was thrown.");
} catch(NullPointerException npe) {
//expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
if (perm.getName().equals("checkExec")) {
throw new SecurityException();
}
}
public void checkExec(String cmd) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().exec(new String[]{"ls"}, envp);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException e) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
try {
Runtime.getRuntime().exec(new String[]{}, envp);
fail("IndexOutOfBoundsException should be thrown.");
} catch(IndexOutOfBoundsException ioob) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
try {
Runtime.getRuntime().exec(new String[]{""}, envp);
fail("IOException should be thrown.");
} 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();
File workFolder = Support_Resources.createTempFolder();
checkExec(2, envp, workFolder);
checkExec(2, null, null);
try {
Runtime.getRuntime().exec((String)null, null, workFolder);
fail("NullPointerException should be thrown.");
} catch(IOException ioe) {
fail("IOException was thrown.");
} catch(NullPointerException npe) {
//expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
if (perm.getName().equals("checkExec")) {
throw new SecurityException();
}
}
public void checkExec(String cmd) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().exec("ls", envp, workFolder);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException e) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
try {
Runtime.getRuntime().exec("", envp, workFolder);
fail("SecurityException should be thrown.");
} catch(IllegalArgumentException iae) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
}
@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();
File workFolder = Support_Resources.createTempFolder();
checkExec(5, envp, workFolder);
checkExec(5, null, null);
try {
Runtime.getRuntime().exec((String[])null, null, workFolder);
fail("NullPointerException should be thrown.");
} catch(IOException ioe) {
fail("IOException was thrown.");
} catch(NullPointerException npe) {
//expected
}
try {
Runtime.getRuntime().exec(new String[]{"ls", null}, null, workFolder);
fail("NullPointerException should be thrown.");
} catch(IOException ioe) {
fail("IOException was thrown.");
} catch(NullPointerException npe) {
//expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
if (perm.getName().equals("checkExec")) {
throw new SecurityException();
}
}
public void checkExec(String cmd) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().exec(new String[] {"ls"}, envp, workFolder);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException e) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
try {
Runtime.getRuntime().exec(new String[]{""}, envp, workFolder);
fail("IOException should be thrown.");
} catch (IOException e) {
//expected
}
}
String [] getEnv() {
Object [] valueSet = System.getenv().values().toArray();
Object [] keySet = System.getenv().keySet().toArray();
String [] envp = new String[valueSet.length];
for(int i = 0; i < envp.length; i++) {
envp[i] = keySet[i] + "=" + valueSet[i];
}
return envp;
}
void checkExec(int testCase, String [] envp, File file) {
String dirName = "Test_Directory";
String dirParentName = "Parent_Directory";
File resources = Support_Resources.createTempFolder();
String folder = resources.getAbsolutePath() + "/" + dirName;
String folderWithParent = resources.getAbsolutePath() + "/" +
dirParentName + "/" + dirName;
String command = "mkdir " + folder;
String [] commandArguments = {"mkdir", folder};
try {
Process proc = null;
switch(testCase) {
case 0:
proc = Runtime.getRuntime().exec(command, envp);
break;
case 1:
proc = Runtime.getRuntime().exec(command);
break;
case 2:
proc = Runtime.getRuntime().exec(command, envp, file);
break;
case 3:
proc = Runtime.getRuntime().exec(commandArguments);
break;
case 4:
proc = Runtime.getRuntime().exec(commandArguments, envp);
break;
case 5:
proc = Runtime.getRuntime().exec(commandArguments, envp, file);
break;
}
assertNotNull(proc);
try {
Thread.sleep(3000);
} catch(InterruptedException ie) {
fail("InterruptedException was thrown.");
}
File f = new File(folder);
assertTrue(f.exists());
if(f.exists()) {
f.delete();
}
} catch(IOException io) {
fail("IOException was thrown.");
}
}
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "exec",
args = {java.lang.String.class}
)
public void test_execLjava_lang_String() {
checkExec(1, null, null);
try {
Runtime.getRuntime().exec((String) null);
fail("NullPointerException was not thrown.");
} catch(NullPointerException npe) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
try {
Runtime.getRuntime().exec("");
fail("IllegalArgumentException was not thrown.");
} catch(IllegalArgumentException iae) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkExec(String cmd) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().exec("ls");
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException ioe) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
}
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "exec",
args = {java.lang.String[].class}
)
public void test_execLjava_lang_StringArray() {
checkExec(3, null, null);
try {
Runtime.getRuntime().exec((String[]) null);
fail("NullPointerException was not thrown.");
} catch(NullPointerException npe) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
try {
Runtime.getRuntime().exec(new String[]{"ls", null});
fail("NullPointerException was not thrown.");
} catch(NullPointerException npe) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
try {
Runtime.getRuntime().exec(new String[]{});
fail("IndexOutOfBoundsException was not thrown.");
} catch(IndexOutOfBoundsException iobe) {
//expected
} catch (IOException e) {
fail("IOException was thrown.");
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkExec(String cmd) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().exec(new String[]{"ls"});
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} catch (IOException ioe) {
fail("IOException was thrown.");
} finally {
System.setSecurityManager(oldSm);
}
try {
Runtime.getRuntime().exec(new String[]{""});
fail("IOException should be thrown.");
} catch (IOException e) {
//expected
}
}
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "runFinalizersOnExit",
args = {boolean.class}
)
public void test_runFinalizersOnExit() {
Runtime.getRuntime().runFinalizersOnExit(true);
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkExit(int status) {
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().runFinalizersOnExit(true);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
System.setSecurityManager(oldSm);
}
}
@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() {
try {
Runtime.getRuntime().addShutdownHook(this);
} catch(IllegalStateException ise) {
fail("IllegalStateException shouldn't be thrown.");
}
}
};
try {
Runtime.getRuntime().addShutdownHook(thr1);
Runtime.getRuntime().removeShutdownHook(thr1);
} catch (Throwable t) {
fail(t.getMessage());
}
Thread thr2 = new Thread () {
public void run() {
try {
Runtime.getRuntime().removeShutdownHook(this);
fail("IllegalStateException wasn't thrown.");
} catch(IllegalStateException ise) {
//expected
}
}
};
try {
Runtime.getRuntime().addShutdownHook(thr2);
} catch (Throwable t) {
fail(t.getMessage());
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
if (perm.getName().equals("shutdownHooks")) {
throw new SecurityException();
}
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().addShutdownHook(thr1);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
System.setSecurityManager(oldSm);
}
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException ie) {
}
}
@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}
)
public void test_traceMethodCalls() {
try {
Runtime.getRuntime().traceMethodCalls(false);
Runtime.getRuntime().traceMethodCalls(true);
Runtime.getRuntime().traceMethodCalls(false);
} catch (RuntimeException ex) {
// Slightly ugly: we default to the SD card, which may or may not
// be there. So we also accept the error case as a success, since
// it means we actually did enable tracing (or tried to).
if (!"file open failed".equals(ex.getMessage())) {
throw ex;
}
}
}
@SuppressWarnings("deprecation")
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "getLocalizedInputStream",
args = {java.io.InputStream.class}
)
public void test_getLocalizedInputStream() {
String simpleString = "Heart \u2f3c";
byte[] expected = {72, 0, 101, 0, 97, 0, 114, 0, 116, 0, 32, 0, 60, 47};
byte[] returned = new byte[expected.length];
String oldEncoding = System.getProperty("file.encoding");
System.setProperty("file.encoding", "UTF-16LE");
try {
ByteArrayInputStream bais = new ByteArrayInputStream(
simpleString.getBytes("UTF-8"));
InputStream lcIn =
Runtime.getRuntime().getLocalizedInputStream(bais);
try {
lcIn.read(returned);
} catch(IOException ioe) {
fail("IOException was thrown.");
}
assertTrue("wrong result for String: " + simpleString,
Arrays.equals(expected, returned));
} catch (UnsupportedEncodingException e) {
fail("UnsupportedEncodingException was thrown.");
} finally {
System.setProperty("file.encoding", oldEncoding);
}
}
@SuppressWarnings("deprecation")
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "",
method = "getLocalizedOutputStream",
args = {java.io.OutputStream.class}
)
public void test_getLocalizedOutputStream() {
String simpleString = "Heart \u2f3c";
byte[] expected = {72, 0, 101, 0, 97, 0, 114, 0, 116, 0, 32, 0, 60, 47};
byte[] returned;
String oldEncoding = System.getProperty("file.encoding");
System.setProperty("file.encoding", "UTF-16LE");
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
OutputStream lcOut =
Runtime.getRuntime().getLocalizedOutputStream(out);
try {
lcOut.write(simpleString.getBytes("UTF-8"));
lcOut.flush();
lcOut.close();
} catch(IOException ioe) {
fail("IOException was thrown.");
}
returned = out.toByteArray();
assertTrue("wrong result for String: " + returned.toString() +
" expected string: " + expected.toString(),
Arrays.equals(expected, returned));
} finally {
System.setProperty("file.encoding", oldEncoding);
}
}
@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 ule) {
//expected
}
try {
Runtime.getRuntime().load(null);
fail("NullPointerException was not thrown.");
} catch(NullPointerException npe) {
//expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkLink(String lib) {
if (lib.endsWith("libjvm.so")) {
throw new SecurityException();
}
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().load("libjvm.so");
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
System.setSecurityManager(oldSm);
}
}
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "loadLibrary",
args = {java.lang.String.class}
)
public void test_loadLibrary() {
try {
Runtime.getRuntime().loadLibrary("nonExistentLibrary");
fail("UnsatisfiedLinkError was not thrown.");
} catch(UnsatisfiedLinkError ule) {
//expected
}
try {
Runtime.getRuntime().loadLibrary(null);
fail("NullPointerException was not thrown.");
} catch(NullPointerException npe) {
//expected
}
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkLink(String lib) {
if (lib.endsWith("libjvm.so")) {
throw new SecurityException();
}
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
Runtime.getRuntime().loadLibrary("libjvm.so");
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
System.setSecurityManager(oldSm);
}
}
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "This method never returns normally, " +
"and can't be tested. Only SecurityException can be checked.",
method = "exit",
args = {int.class}
)
public void test_exit() {
statusCode = -1;
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkExit(int status) {
statusCode = status;
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
r.exit(0);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
assertTrue("Incorrect status code was received: " + statusCode,
statusCode == 0);
System.setSecurityManager(oldSm);
}
}
@TestTargetNew(
level = TestLevel.SUFFICIENT,
notes = "Can't be tested. This method terminates the currently " +
"running VM. Only SecurityException can be checked.",
method = "halt",
args = {int.class}
)
public void test_halt() {
statusCode = -1;
SecurityManager sm = new SecurityManager() {
public void checkPermission(Permission perm) {
}
public void checkExit(int status) {
statusCode = status;
throw new SecurityException();
}
};
SecurityManager oldSm = System.getSecurityManager();
System.setSecurityManager(sm);
try {
r.halt(0);
fail("SecurityException should be thrown.");
} catch (SecurityException e) {
// expected
} finally {
assertTrue("Incorrect status code was received: " + statusCode,
statusCode == 0);
System.setSecurityManager(oldSm);
}
}
public RuntimeTest() {
}
public RuntimeTest(String name) {
super(name);
}
}
|
