Add RavenwoodAwareTestRunner + use it (8317f695) · Commits · e / os / android_frameworks_base

ravenwood/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -211,6 +211,7 @@ java_library {
	libs: [		libs: [
	"junit",		"junit",
	"flag-junit",		"flag-junit",
			"framework-annotations-lib",
	],		],
	visibility: ["//visibility:public"],		visibility: ["//visibility:public"],
	}		}

ravenwood/bivalenttest/Android.bp

+6 −0

Original line number	Original line	Diff line number	Diff line
	@@ -39,6 +39,9 @@ android_ravenwood_test {
	"androidx.test.ext.junit",		"androidx.test.ext.junit",
	"androidx.test.rules",		"androidx.test.rules",

			"junit-params",
			"platform-parametric-runner-lib",

	// To make sure it won't cause VerifyError (b/324063814)		// To make sure it won't cause VerifyError (b/324063814)
	"platformprotosnano",		"platformprotosnano",
	],		],
	@@ -65,6 +68,9 @@ android_test {
	"androidx.test.ext.junit",		"androidx.test.ext.junit",
	"androidx.test.rules",		"androidx.test.rules",

			"junit-params",
			"platform-parametric-runner-lib",

	"ravenwood-junit",		"ravenwood-junit",
	],		],
	jni_libs: [		jni_libs: [

ravenwood/bivalenttest/test/com/android/ravenwoodtest/bivalenttest/ravenizer/CallTracker.java

0 → 100644

+110 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2024 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 com.android.ravenwoodtest.bivalenttest.ravenizer;

			import static org.junit.Assert.fail;

			import static java.lang.StackWalker.Option.RETAIN_CLASS_REFERENCE;

			import android.util.Log;

			import java.lang.StackWalker.StackFrame;
			import java.util.HashMap;

			/**
			* Used to keep track of and count the number of calls.
			*/
			public class CallTracker {
			public static final String TAG = "CallTracker";

			private final HashMap<String, Integer> mNumCalled = new HashMap<>();

			/**
			* Call it when a method is called. It increments the count for the calling method.
			*/
			public void incrementMethodCallCount() {
			var methodName = getCallingMethodName(1);

			Log.i(TAG, "Method called: " + methodName);

			mNumCalled.put(methodName, getNumCalled(methodName) + 1);
			}

			/**
			* Return the number of calls of a method.
			*/
			public int getNumCalled(String methodName) {
			return mNumCalled.getOrDefault(methodName, 0);
			}

			/**
			* Return the current method name. (with the class name.)
			*/
			private static String getCallingMethodName(int frameOffset) {
			var walker = StackWalker.getInstance(RETAIN_CLASS_REFERENCE);
			var caller = walker.walk(frames ->
			frames.skip(1 + frameOffset).findFirst().map(StackFrame::getMethodName)
			);
			return caller.get();
			}

			/**
			* Check the number of calls stored in {@link #mNumCalled}.
			*/
			protected void assertCalls(Object... methodNameAndCountPairs) {
			// Create a local copy
			HashMap<String, Integer> counts = new HashMap<>(mNumCalled);
			for (int i = 0; i < methodNameAndCountPairs.length - 1; i += 2) {
			String methodName = (String) methodNameAndCountPairs[i];
			int expectedCount = (Integer) methodNameAndCountPairs[i + 1];

			if (getNumCalled(methodName) != expectedCount) {
			fail(String.format("Method %s: expected call count=%d, actual=%d",
			methodName, expectedCount, getNumCalled(methodName)));
			}
			counts.remove(methodName);
			}
			// All other entries are expected to be 0.
			var sb = new StringBuilder();
			for (var e : counts.entrySet()) {
			if (e.getValue() == 0) {
			continue;
			}
			sb.append(String.format("Method %s: expected call count=0, actual=%d",
			e.getKey(), e.getValue()));
			}
			if (sb.length() > 0) {
			fail(sb.toString());
			}
			}

			/**
			* Same as {@link #assertCalls(Object...)} but it kills the process if it fails.
			* Only use in @AfterClass.
			*/
			protected void assertCallsOrDie(Object... methodNameAndCountPairs) {
			try {
			assertCalls(methodNameAndCountPairs);
			} catch (Throwable th) {
			// TODO: I don't think it's by spec, but the exception here would be ignored both on
			// ravenwood and on the device side. Look into it.
			Log.e(TAG, "* Failure detected in @AfterClass! *", th);
			Log.e(TAG, "JUnit seems to ignore exceptions from @AfterClass, so killing self.");
			System.exit(7);
			}
			}

			}

ravenwood/bivalenttest/test/com/android/ravenwoodtest/bivalenttest/ravenizer/RavenwoodAwareTestRunnerTest.java

0 → 100644

+93 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2024 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 com.android.ravenwoodtest.bivalenttest.ravenizer;

			import static org.junit.Assert.assertFalse;

			import android.platform.test.annotations.DisabledOnRavenwood;
			import android.platform.test.ravenwood.RavenwoodAwareTestRunner.RavenwoodTestRunnerInitializing;
			import android.platform.test.ravenwood.RavenwoodRule;
			import android.util.Log;

			import junitparams.JUnitParamsRunner;
			import junitparams.Parameters;

			import org.junit.AfterClass;
			import org.junit.BeforeClass;
			import org.junit.Test;
			import org.junit.runner.RunWith;

			/**
			* Make sure RavenwoodAwareTestRunnerTest properly delegates to the original runner,
			* and also run the special annotated methods.
			*/
			@RunWith(JUnitParamsRunner.class)
			public class RavenwoodAwareTestRunnerTest {
			public static final String TAG = "RavenwoodAwareTestRunnerTest";

			private static final CallTracker sCallTracker = new CallTracker();

			private static int getExpectedRavenwoodRunnerInitializingNumCalls() {
			return RavenwoodRule.isOnRavenwood() ? 1 : 0;
			}

			@RavenwoodTestRunnerInitializing
			public static void ravenwoodRunnerInitializing() {
			// No other calls should have been made.
			sCallTracker.assertCalls();

			sCallTracker.incrementMethodCallCount();
			}

			@BeforeClass
			public static void beforeClass() {
			sCallTracker.assertCalls(
			"ravenwoodRunnerInitializing",
			getExpectedRavenwoodRunnerInitializingNumCalls()
			);
			sCallTracker.incrementMethodCallCount();
			}

			@Test
			public void test1() {
			sCallTracker.incrementMethodCallCount();
			}

			@Test
			@Parameters({"foo", "bar"})
			public void testWithParams(String arg) {
			sCallTracker.incrementMethodCallCount();
			}

			@Test
			@DisabledOnRavenwood
			public void testDeviceOnly() {
			assertFalse(RavenwoodRule.isOnRavenwood());
			}

			@AfterClass
			public static void afterClass() {
			Log.i(TAG, "afterClass called");

			sCallTracker.assertCallsOrDie(
			"ravenwoodRunnerInitializing",
			getExpectedRavenwoodRunnerInitializingNumCalls(),
			"beforeClass", 1,
			"test1", 1,
			"testWithParams", 2
			);
			}
			}

ravenwood/bivalenttest/test/com/android/ravenwoodtest/bivalenttest/ravenizer/RavenwoodImplicitClassRuleDeviceOnlyTest.java

0 → 100644

+52 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2024 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 com.android.ravenwoodtest.bivalenttest.ravenizer;

			import android.platform.test.annotations.DisabledOnRavenwood;
			import android.platform.test.ravenwood.RavenwoodRule;
			import android.util.Log;

			import androidx.test.ext.junit.runners.AndroidJUnit4;

			import org.junit.AfterClass;
			import org.junit.Assert;
			import org.junit.BeforeClass;
			import org.junit.Test;
			import org.junit.runner.RunWith;

			@RunWith(AndroidJUnit4.class)
			@DisabledOnRavenwood
			public class RavenwoodImplicitClassRuleDeviceOnlyTest {
			public static final String TAG = "RavenwoodImplicitClassRuleDeviceOnlyTest";

			@BeforeClass
			public static void beforeClass() {
			Assert.assertFalse(RavenwoodRule.isOnRavenwood());
			}

			@Test
			public void testDeviceOnly() {
			Assert.assertFalse(RavenwoodRule.isOnRavenwood());
			}

			@AfterClass
			public static void afterClass() {
			if (RavenwoodRule.isOnRavenwood()) {
			Log.e(TAG, "Even @AfterClass shouldn't be executed!");
			System.exit(1);
			}
			}
			}