try {
t.start();
- Thread.sleep(SHORT_DELAY_MS);
+ // BEGIN android-changed
+ Thread.sleep(SMALL_DELAY_MS); // SHORT_DELAY_MS was flaky on Android
t.interrupt();
- t.join(SHORT_DELAY_MS);
+ t.join(SMALL_DELAY_MS); // SHORT_DELAY_MS was flaky on Android
+ // END android-changed
assertFalse(t.isAlive());
}
catch (Exception ex) {
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;
+import dalvik.annotation.TestLevel;
@SuppressWarnings("deprecation")
@TestTargetClass(Class.class)
URL resourceURL = new URL("file:/" + resPath + "/Package/"
+ hyts_package_name);
- ClassLoader cl = new dalvik.system.PathClassLoader(
- resourceURL.getPath(), getClass().getClassLoader());
-
+ ClassLoader cl = Support_ClassLoader.getInstance(resourceURL,
+ getClass().getClassLoader());
+
Class clazz = cl.loadClass("C");
assertNull("getPackage for C.class should return null",
clazz.getPackage());
import java.lang.annotation.Annotation;
+import tests.support.Support_ClassLoader;
import tests.support.resource.Support_Resources;
@TestTargetClass(Package.class)
Class clazz;
- // URLClassLoader doesn't load classes from jar.
- // use PathClassLoader
- boolean USE_PATH_CLASS_LOADER = true;
-
Package getTestPackage(String resourceJar, String className)
throws Exception {
- if (USE_PATH_CLASS_LOADER) {
+ if ("Dalvik".equals(System.getProperty("java.vm.name"))) {
resourceJar = resourceJar.substring(0, resourceJar.indexOf(".")) +
"_dex.jar";
}
URL resourceURL = new URL("file:/" + resPath + "/Package/"
+ resourceJar);
- ClassLoader cl = null;
- if(USE_PATH_CLASS_LOADER) {
- cl = new dalvik.system.PathClassLoader(
- resourceURL.getPath(), getClass().getClassLoader());
- } else {
- cl = new URLClassLoader(new URL[] { resourceURL },
- getClass().getClassLoader());
- }
+ ClassLoader cl = Support_ClassLoader.getInstance(resourceURL,
+ getClass().getClassLoader());
+
clazz = cl.loadClass(className);
return clazz.getPackage();
}
package org.apache.harmony.luni.tests.java.lang;
+import dalvik.annotation.AndroidOnly;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetNew;
method = "load",
args = {java.lang.String.class}
)
+ @AndroidOnly("No x86 version of this library")
public void test_load() {
try {
new TestLibrary().checkString();
import java.lang.reflect.GenericSignatureFormatError;
import java.lang.reflect.TypeVariable;
+import tests.support.Support_ClassLoader;
+
@TestTargetClass(GenericSignatureFormatError.class)
public class GenericSignatureFormatErrorTest extends TestCase{
// class signature string "<U:" was changed to "<<:"
//System.out.println("file length:"+tf.length());
try {
- DexFile df = new DexFile(tf);
- Class clazz = df.loadClass("demo/HelloWorld", this.getClass().getClassLoader());
+ // Was:
+ // DexFile df = new DexFile(tf);
+ // Class clazz = df.loadClass("demo/HelloWorld", this.getClass().getClassLoader());
+
+ ClassLoader cl = Support_ClassLoader.getInstance(tf.toURL(),
+ getClass().getClassLoader());
+
+ Class clazz = cl.loadClass("demo/HelloWorld");
TypeVariable[] tvs = clazz.getTypeParameters();
fail("expecting a GenericSignatureFormatError");
// for (TypeVariable tv : tvs) {
args = {}
)
public void test_getInputStream() throws IOException {
+ System.setSecurityManager(null);
+
// Test for method java.io.InputStream java.net.Socket.getInputStream()
int sport = startServer("SServer getInputStream");
int portNumber = Support_PortManager.getNextPort();
try {
Class.forName("bpack.Bart", true, ucl);
fail("InvalidJarIndexException should be thrown");
- } catch (InvalidJarIndexException e) {
+ } catch (RuntimeException e) {
+ e.printStackTrace();
// expected
}
exec dalvikvm -Duser.language=en -Duser.region=US -Djava.io.tmpdir=$tmp \
-Xbootclasspath:$BOOTCLASSPATH:/system/framework/core-tests.jar \
- com.google.coretests.Main "$@"
+ -Xmx64M com.google.coretests.Main "$@"
package tests.security.permissions;
-import dalvik.annotation.AndroidOnly;
-import dalvik.annotation.TestTargets;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTargetNew;
-import dalvik.annotation.TestTargetClass;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.security.Permission;
import junit.framework.TestCase;
-
-import java.security.Permission;
+import tests.support.Support_ClassLoader;
+import dalvik.annotation.AndroidOnly;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestLevel;
/*
* This class tests the security permissions which are documented in
assertNotNull("test assumption: caller's class loader must not be null",
this.getClass().getClassLoader());
+
+ URL url;
+
+ try {
+ url = new URL("file:");
+ } catch (MalformedURLException ex) {
+ throw new RuntimeException(ex);
+ }
t1.setContextClassLoader(null);
t2.setContextClassLoader(this.getClass().getClassLoader());
t3.setContextClassLoader(this.getClass().getClassLoader().getParent());
t4.setContextClassLoader(
- new dalvik.system.PathClassLoader("",
- this.getClass().getClassLoader()));
+ Support_ClassLoader.getInstance(url,
+ getClass().getClassLoader()));
t5.setContextClassLoader(
new ClassLoader(this.getClass().getClassLoader()) {});
sqlPassword =
sqlUser =
sqlMaxConnections = 30
-sqlMaxTasks = 10000
+sqlMaxTasks = 1000
--- /dev/null
+/*
+ * Copyright (C) 2009 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 tests.support;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import dalvik.system.PathClassLoader;
+
+/**
+ * Support class for creating a file-based ClassLoader. Delegates to either
+ * Dalvik's PathClassLoader or the RI's URLClassLoader, but does so by-name.
+ * This allows us to run corresponding tests in both environments.
+ */
+public abstract class Support_ClassLoader {
+
+ public abstract ClassLoader getClassLoader(URL url, ClassLoader parent);
+
+ public static ClassLoader getInstance(URL url, ClassLoader parent) {
+ try {
+ Support_ClassLoader factory;
+
+ if ("Dalvik".equals(System.getProperty("java.vm.name"))) {
+ factory = (Support_ClassLoader)Class.forName(
+ "tests.support.Support_ClassLoader$Dalvik").newInstance();
+ } else {
+ factory = (Support_ClassLoader)Class.forName(
+ "tests.support.Support_ClassLoader$RefImpl").newInstance();
+ }
+
+ return factory.getClassLoader(url, parent);
+ } catch (Exception ex) {
+ throw new RuntimeException("Unable to create ClassLoader", ex);
+ }
+ }
+
+ class Dalvik extends Support_ClassLoader {
+ public ClassLoader getClassLoader(URL url, ClassLoader parent) {
+ return new PathClassLoader(url.getPath(), parent);
+ }
+ }
+
+ class RefImpl extends Support_ClassLoader {
+ public ClassLoader getClassLoader(URL url, ClassLoader parent) {
+ return new URLClassLoader(new URL[] { url }, parent);
+ }
+ }
+}
*/
public class FileClientSessionCache {
- static final int MAX_SIZE = 20;
+ static final int MAX_SIZE = 12; // ~72k
static final java.util.logging.Logger logger
= java.util.logging.Logger.getLogger(
/*
* Compute some stats on loaded classes.
*/
- int numLoadedClasses;
- int numDeclaredMethods;
- int numDeclaredInstFields;
- int numDeclaredStaticFields;
+ int numLoadedClasses;
+ int numDeclaredMethods;
+ int numDeclaredInstFields;
+ int numDeclaredStaticFields;
+
+ /* when using a native debugger, set this to suppress watchdog timers */
+ bool nativeDebuggerActive;
/*
* JDWP debugger support.
}
/* Make sure that the HeapWorker thread hasn't spent an inordinate
- * amount of time inside interpreted a finalizer.
+ * amount of time inside a finalizer.
*
* Aborts the VM if the thread appears to be wedged.
*
u8 nowCpu = dvmGetOtherThreadCpuTimeUsec(gDvm.heapWorkerHandle);
u8 deltaCpu = nowCpu - heapWorkerInterpCpuStartTime;
- if (delta > HEAP_WORKER_WATCHDOG_TIMEOUT && gDvm.debuggerActive) {
+ if (delta > HEAP_WORKER_WATCHDOG_TIMEOUT &&
+ (gDvm.debuggerActive || gDvm.nativeDebuggerActive))
+ {
/*
* Debugger suspension can block the thread indefinitely. For
* best results we should reset this explicitly whenever the
- * HeapWorker thread is resumed. Ignoring the yelp isn't
- * quite right but will do for a quick fix.
+ * HeapWorker thread is resumed. Unfortunately this is also
+ * affected by native debuggers, and we have no visibility
+ * into how they're manipulating us. So, we ignore the
+ * watchdog and just reset the timer.
*/
LOGI("Debugger is attached -- suppressing HeapWorker watchdog\n");
heapWorkerInterpStartTime = now; /* reset timer */
OSDN Git Service
