Merge "Remove CoreTests: HeapTest" am: c3fd3b8c7d am: 19d39ee384 (2d828366) · Commits · e / os / android_frameworks_base

tests/CoreTests/android/core/HeapTest.java

deleted100644 → 0

+0 −476

Original line number	Diff line number	Diff line
		/*
		* 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 android.core;

		import android.test.suitebuilder.annotation.LargeTest;
		import android.test.suitebuilder.annotation.MediumTest;
		import android.test.suitebuilder.annotation.SmallTest;
		import android.util.Log;
		import android.test.suitebuilder.annotation.Suppress;
		import dalvik.system.VMRuntime;
		import junit.framework.TestCase;

		import java.lang.ref.PhantomReference;
		import java.lang.ref.ReferenceQueue;
		import java.lang.ref.SoftReference;
		import java.lang.ref.WeakReference;
		import java.util.LinkedList;
		import java.util.Random;


		public class HeapTest extends TestCase {

		private static final String TAG = "HeapTest";

		/**
		* Returns a WeakReference to an object that has no
		* other references. This is done in a separate method
		* to ensure that the Object's address isn't sitting in
		* a stale local register.
		*/
		private WeakReference<Object> newRef() {
		return new WeakReference<Object>(new Object());
		}

		private static void makeRefs(Object objects[], SoftReference<Object> refs[]) {
		for (int i = 0; i < objects.length; i++) {
		objects[i] = (Object) new byte[8 * 1024];
		refs[i] = new SoftReference<Object>(objects[i]);
		}
		}

		private static <T> int checkRefs(SoftReference<T> refs[], int last) {
		int i;
		int numCleared = 0;
		for (i = 0; i < refs.length; i++) {
		Object o = refs[i].get();
		if (o == null) {
		numCleared++;
		}
		}
		if (numCleared != last) {
		Log.i(TAG, "**** " + numCleared + "/" + i + " cleared ****");
		}
		return numCleared;
		}

		private static void clearRefs(Object objects[], int skip) {
		for (int i = 0; i < objects.length; i += skip) {
		objects[i] = null;
		}
		}

		private static void clearRefs(Object objects[]) {
		clearRefs(objects, 1);
		}

		private static <T> void checkRefs(T objects[], SoftReference<T> refs[]) {
		boolean ok = true;

		for (int i = 0; i < objects.length; i++) {
		if (refs[i].get() != objects[i]) {
		ok = false;
		}
		}
		if (!ok) {
		throw new RuntimeException("Test failed: soft refs not cleared");
		}
		}

		@MediumTest
		public void testGcSoftRefs() throws Exception {
		final int NUM_REFS = 128;

		Object objects[] = new Object[NUM_REFS];
		SoftReference<Object> refs[] = new SoftReference[objects.length];

		/* Create a bunch of objects and a parallel array
		* of SoftReferences.
		*/
		makeRefs(objects, refs);
		Runtime.getRuntime().gc();

		/* Let go of some of the hard references to the objects so that
		* the references can be cleared.
		*/
		clearRefs(objects, 3);

		/* Collect all softly-reachable objects.
		*/
		VMRuntime.getRuntime().gcSoftReferences();
		Runtime.getRuntime().runFinalization();

		/* Make sure that the objects were collected.
		*/
		checkRefs(objects, refs);

		/* Remove more hard references and re-check.
		*/
		clearRefs(objects, 2);
		VMRuntime.getRuntime().gcSoftReferences();
		Runtime.getRuntime().runFinalization();
		checkRefs(objects, refs);

		/* Remove the rest of the references and re-check.
		*/
		/* Remove more hard references and re-check.
		*/
		clearRefs(objects);
		VMRuntime.getRuntime().gcSoftReferences();
		Runtime.getRuntime().runFinalization();
		checkRefs(objects, refs);
		}

		public void xxtestSoftRefPartialClean() throws Exception {
		final int NUM_REFS = 128;

		Object objects[] = new Object[NUM_REFS];
		SoftReference<Object> refs[] = new SoftReference[objects.length];

		/* Create a bunch of objects and a parallel array
		* of SoftReferences.
		*/
		makeRefs(objects, refs);
		Runtime.getRuntime().gc();

		/* Let go of the hard references to the objects so that
		* the references can be cleared.
		*/
		clearRefs(objects);

		/* Start creating a bunch of temporary and permanent objects
		* to drive GC.
		*/
		final int NUM_OBJECTS = 64 * 1024;
		Object junk[] = new Object[NUM_OBJECTS];
		Random random = new Random();

		int i = 0;
		int mod = 0;
		int totalSize = 0;
		int cleared = -1;
		while (i < junk.length && totalSize < 8 * 1024 * 1024) {
		int r = random.nextInt(64 * 1024) + 128;
		Object o = (Object) new byte[r];
		if (++mod % 16 == 0) {
		junk[i++] = o;
		totalSize += r * 4;
		}
		cleared = checkRefs(refs, cleared);
		}
		}

		private static void makeRefs(Object objects[], WeakReference<Object> refs[]) {
		for (int i = 0; i < objects.length; i++) {
		objects[i] = new Object();
		refs[i] = new WeakReference<Object>(objects[i]);
		}
		}

		private static <T> void checkRefs(T objects[], WeakReference<T> refs[]) {
		boolean ok = true;

		for (int i = 0; i < objects.length; i++) {
		if (refs[i].get() != objects[i]) {
		ok = false;
		}
		}
		if (!ok) {
		throw new RuntimeException("Test failed: " +
		"weak refs not cleared");
		}
		}

		@MediumTest
		public void testWeakRefs() throws Exception {
		final int NUM_REFS = 16;

		Object objects[] = new Object[NUM_REFS];
		WeakReference<Object> refs[] = new WeakReference[objects.length];

		/* Create a bunch of objects and a parallel array
		* of WeakReferences.
		*/
		makeRefs(objects, refs);
		Runtime.getRuntime().gc();
		checkRefs(objects, refs);

		/* Clear out every other strong reference.
		*/
		for (int i = 0; i < objects.length; i += 2) {
		objects[i] = null;
		}
		Runtime.getRuntime().gc();
		checkRefs(objects, refs);

		/* Clear out the rest of them.
		*/
		for (int i = 0; i < objects.length; i++) {
		objects[i] = null;
		}
		Runtime.getRuntime().gc();
		checkRefs(objects, refs);
		}

		private static void makeRefs(Object objects[], PhantomReference<Object> refs[],
		ReferenceQueue<Object> queue) {
		for (int i = 0; i < objects.length; i++) {
		objects[i] = new Object();
		refs[i] = new PhantomReference<Object>(objects[i], queue);
		}
		}

		static <T> void checkRefs(T objects[], PhantomReference<T> refs[],
		ReferenceQueue<T> queue) {
		boolean ok = true;

		/* Make sure that the reference that should be on
		* the queue are marked as enqueued. Once we
		* pull them off the queue, they will no longer
		* be marked as enqueued.
		*/
		for (int i = 0; i < objects.length; i++) {
		if (objects[i] == null && refs[i] != null) {
		if (!refs[i].isEnqueued()) {
		ok = false;
		}
		}
		}
		if (!ok) {
		throw new RuntimeException("Test failed: " +
		"phantom refs not marked as enqueued");
		}

		/* Make sure that all of the references on the queue
		* are supposed to be there.
		*/
		PhantomReference<T> ref;
		while ((ref = (PhantomReference<T>) queue.poll()) != null) {
		/* Find the list index that corresponds to this reference.
		*/
		int i;
		for (i = 0; i < objects.length; i++) {
		if (refs[i] == ref) {
		break;
		}
		}
		if (i == objects.length) {
		throw new RuntimeException("Test failed: " +
		"unexpected ref on queue");
		}
		if (objects[i] != null) {
		throw new RuntimeException("Test failed: " +
		"reference enqueued for strongly-reachable " +
		"object");
		}
		refs[i] = null;

		/* TODO: clear doesn't do much, since we're losing the
		* strong ref to the ref object anyway. move the ref
		* into another list.
		*/
		ref.clear();
		}

		/* We've visited all of the enqueued references.
		* Make sure that there aren't any other references
		* that should have been enqueued.
		*
		* NOTE: there is a race condition here; this assumes
		* that the VM has serviced all outstanding reference
		* enqueue() calls.
		*/
		for (int i = 0; i < objects.length; i++) {
		if (objects[i] == null && refs[i] != null) {
		// System.out.println("HeapTest/PhantomRefs: refs[" + i +
		// "] should be enqueued");
		ok = false;
		}
		}
		if (!ok) {
		throw new RuntimeException("Test failed: " +
		"phantom refs not enqueued");
		}
		}

		@MediumTest
		public void testPhantomRefs() throws Exception {
		final int NUM_REFS = 16;

		Object objects[] = new Object[NUM_REFS];
		PhantomReference<Object> refs[] = new PhantomReference[objects.length];
		ReferenceQueue<Object> queue = new ReferenceQueue<Object>();

		/* Create a bunch of objects and a parallel array
		* of PhantomReferences.
		*/
		makeRefs(objects, refs, queue);
		Runtime.getRuntime().gc();
		checkRefs(objects, refs, queue);

		/* Clear out every other strong reference.
		*/
		for (int i = 0; i < objects.length; i += 2) {
		objects[i] = null;
		}
		// System.out.println("HeapTest/PhantomRefs: cleared evens");
		Runtime.getRuntime().gc();
		Runtime.getRuntime().runFinalization();
		checkRefs(objects, refs, queue);

		/* Clear out the rest of them.
		*/
		for (int i = 0; i < objects.length; i++) {
		objects[i] = null;
		}
		// System.out.println("HeapTest/PhantomRefs: cleared all");
		Runtime.getRuntime().gc();
		Runtime.getRuntime().runFinalization();
		checkRefs(objects, refs, queue);
		}

		private static int sNumFinalized = 0;
		private static final Object sLock = new Object();

		private static class FinalizableObject {
		protected void finalize() {
		// System.out.println("gc from finalize()");
		Runtime.getRuntime().gc();
		synchronized (sLock) {
		sNumFinalized++;
		}
		}
		}

		private static void makeRefs(FinalizableObject objects[],
		WeakReference<FinalizableObject> refs[]) {
		for (int i = 0; i < objects.length; i++) {
		objects[i] = new FinalizableObject();
		refs[i] = new WeakReference<FinalizableObject>(objects[i]);
		}
		}

		@LargeTest
		public void testWeakRefsAndFinalizers() throws Exception {
		final int NUM_REFS = 16;

		FinalizableObject objects[] = new FinalizableObject[NUM_REFS];
		WeakReference<FinalizableObject> refs[] = new WeakReference[objects.length];
		int numCleared;

		/* Create a bunch of objects and a parallel array
		* of WeakReferences.
		*/
		makeRefs(objects, refs);
		Runtime.getRuntime().gc();
		checkRefs(objects, refs);

		/* Clear out every other strong reference.
		*/
		sNumFinalized = 0;
		numCleared = 0;
		for (int i = 0; i < objects.length; i += 2) {
		objects[i] = null;
		numCleared++;
		}
		// System.out.println("HeapTest/WeakRefsAndFinalizers: cleared evens");
		Runtime.getRuntime().gc();
		Runtime.getRuntime().runFinalization();
		checkRefs(objects, refs);
		if (sNumFinalized != numCleared) {
		throw new RuntimeException("Test failed: " +
		"expected " + numCleared + " finalizations, saw " +
		sNumFinalized);
		}

		/* Clear out the rest of them.
		*/
		sNumFinalized = 0;
		numCleared = 0;
		for (int i = 0; i < objects.length; i++) {
		if (objects[i] != null) {
		objects[i] = null;
		numCleared++;
		}
		}
		// System.out.println("HeapTest/WeakRefsAndFinalizers: cleared all");
		Runtime.getRuntime().gc();
		Runtime.getRuntime().runFinalization();
		checkRefs(objects, refs);
		if (sNumFinalized != numCleared) {
		throw new RuntimeException("Test failed: " +
		"expected " + numCleared + " finalizations, saw " +
		sNumFinalized);
		}
		}

		// TODO: flaky test
		//@MediumTest
		public void testOomeLarge() throws Exception {
		/* Just shy of the typical max heap size so that it will actually
		* try to allocate it instead of short-circuiting.
		*/
		final int SIXTEEN_MB = (16 * 1024 * 1024 - 32);

		Boolean sawEx = false;
		byte a[];

		try {
		a = new byte[SIXTEEN_MB];
		} catch (OutOfMemoryError oom) {
		//Log.i(TAG, "HeapTest/OomeLarge caught " + oom);
		sawEx = true;
		}

		if (!sawEx) {
		throw new RuntimeException("Test failed: " +
		"OutOfMemoryError not thrown");
		}
		}

		//See bug 1308253 for reasons.
		@Suppress
		public void disableTestOomeSmall() throws Exception {
		final int SIXTEEN_MB = (16 * 1024 * 1024);
		final int LINK_SIZE = 6 * 4; // estimated size of a LinkedList's node

		Boolean sawEx = false;

		LinkedList<Object> list = new LinkedList<Object>();

		/* Allocate progressively smaller objects to fill up the entire heap.
		*/
		int objSize = 1 * 1024 * 1024;
		while (objSize >= LINK_SIZE) {
		try {
		for (int i = 0; i < SIXTEEN_MB / objSize; i++) {
		list.add((Object)new byte[objSize]);
		}
		} catch (OutOfMemoryError oom) {
		sawEx = true;
		}

		if (!sawEx) {
		throw new RuntimeException("Test failed: " +
		"OutOfMemoryError not thrown while filling heap");
		}
		sawEx = false;

		objSize = (objSize * 4) / 5;
		}
		}
		}