diff options
Diffstat (limited to 'tests')
13 files changed, 953 insertions, 189 deletions
diff --git a/tests/FlickerTests/ActivityEmbedding/src/com/android/server/wm/flicker/activityembedding/splitscreen/EnterSystemSplitTest.kt b/tests/FlickerTests/ActivityEmbedding/src/com/android/server/wm/flicker/activityembedding/splitscreen/EnterSystemSplitTest.kt index 379b45cdf08e..c3e1a1fa2e18 100644 --- a/tests/FlickerTests/ActivityEmbedding/src/com/android/server/wm/flicker/activityembedding/splitscreen/EnterSystemSplitTest.kt +++ b/tests/FlickerTests/ActivityEmbedding/src/com/android/server/wm/flicker/activityembedding/splitscreen/EnterSystemSplitTest.kt @@ -24,6 +24,7 @@ import android.tools.flicker.legacy.FlickerBuilder import android.tools.flicker.legacy.LegacyFlickerTest import android.tools.flicker.legacy.LegacyFlickerTestFactory import android.tools.traces.parsers.toFlickerComponent +import androidx.test.filters.FlakyTest import com.android.server.wm.flicker.activityembedding.ActivityEmbeddingTestBase import com.android.server.wm.flicker.helpers.ActivityEmbeddingAppHelper import com.android.server.wm.flicker.testapp.ActivityOptions @@ -177,6 +178,13 @@ class EnterSystemSplitTest(flicker: LegacyFlickerTest) : ActivityEmbeddingTestBa @Ignore("Not applicable to this CUJ.") override fun visibleLayersShownMoreThanOneConsecutiveEntry() {} + @FlakyTest(bugId = 342596801) + override fun entireScreenCovered() = super.entireScreenCovered() + + @FlakyTest(bugId = 342596801) + override fun visibleWindowsShownMoreThanOneConsecutiveEntry() = + super.visibleWindowsShownMoreThanOneConsecutiveEntry() + companion object { /** {@inheritDoc} */ private var startDisplayBounds = Rect() diff --git a/tests/FlickerTests/AppLaunch/src/com/android/server/wm/flicker/launch/OpenAppFromLockscreenViaIntentTest.kt b/tests/FlickerTests/AppLaunch/src/com/android/server/wm/flicker/launch/OpenAppFromLockscreenViaIntentTest.kt index adeba72c9c96..6e6a3275191f 100644 --- a/tests/FlickerTests/AppLaunch/src/com/android/server/wm/flicker/launch/OpenAppFromLockscreenViaIntentTest.kt +++ b/tests/FlickerTests/AppLaunch/src/com/android/server/wm/flicker/launch/OpenAppFromLockscreenViaIntentTest.kt @@ -196,7 +196,7 @@ open class OpenAppFromLockscreenViaIntentTest(flicker: LegacyFlickerTest) : super.appLayerBecomesVisible() } - @Presubmit + @FlakyTest(bugId = 338296297) @Test override fun visibleWindowsShownMoreThanOneConsecutiveEntry() = super.visibleWindowsShownMoreThanOneConsecutiveEntry() diff --git a/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/DesktopModeAppHelper.kt b/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/DesktopModeAppHelper.kt index 753cb1ff5dd3..3f6a0bf49eb4 100644 --- a/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/DesktopModeAppHelper.kt +++ b/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/DesktopModeAppHelper.kt @@ -48,6 +48,13 @@ open class DesktopModeAppHelper(private val innerHelper: IStandardAppHelper) : RIGHT_BOTTOM } + enum class Edges { + LEFT, + RIGHT, + TOP, + BOTTOM + } + /** Wait for an app moved to desktop to finish its transition. */ private fun waitForAppToMoveToDesktop(wmHelper: WindowManagerStateHelper) { wmHelper @@ -124,7 +131,8 @@ open class DesktopModeAppHelper(private val innerHelper: IStandardAppHelper) : val displayRect = getDisplayRect(wmHelper) val insets = getWindowInsets( - context, WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars()) + context, WindowInsets.Type.statusBars() or WindowInsets.Type.navigationBars() + ) displayRect.inset(insets) val expectedWidth = displayRect.width() / 2 @@ -187,6 +195,40 @@ open class DesktopModeAppHelper(private val innerHelper: IStandardAppHelper) : dragWindow(startX, startY, endX, endY, wmHelper, device) } + /** Resize a desktop app from its edges. */ + fun edgeResize( + wmHelper: WindowManagerStateHelper, + motionEvent: MotionEventHelper, + edge: Edges + ) { + val windowRect = wmHelper.getWindowRegion(innerHelper).bounds + val (startX, startY) = getStartCoordinatesForEdgeResize(windowRect, edge) + val verticalChange = when (edge) { + Edges.LEFT -> 0 + Edges.RIGHT -> 0 + Edges.TOP -> -100 + Edges.BOTTOM -> 100 + } + val horizontalChange = when (edge) { + Edges.LEFT -> -100 + Edges.RIGHT -> 100 + Edges.TOP -> 0 + Edges.BOTTOM -> 0 + } + + // The position we want to drag to + val endY = startY + verticalChange + val endX = startX + horizontalChange + + motionEvent.actionDown(startX, startY) + motionEvent.actionMove(startX, startY, endX, endY, /* steps= */100) + motionEvent.actionUp(endX, endY) + wmHelper + .StateSyncBuilder() + .withAppTransitionIdle() + .waitForAndVerify() + } + /** Drag a window from a source coordinate to a destination coordinate. */ fun dragWindow( startX: Int, startY: Int, @@ -237,6 +279,18 @@ open class DesktopModeAppHelper(private val innerHelper: IStandardAppHelper) : } } + private fun getStartCoordinatesForEdgeResize( + windowRect: Rect, + edge: Edges + ): Pair<Int, Int> { + return when (edge) { + Edges.LEFT -> Pair(windowRect.left, windowRect.bottom / 2) + Edges.RIGHT -> Pair(windowRect.right, windowRect.bottom / 2) + Edges.TOP -> Pair(windowRect.right / 2, windowRect.top) + Edges.BOTTOM -> Pair(windowRect.right / 2, windowRect.bottom) + } + } + /** Exit desktop mode by dragging the app handle to the top drag zone. */ fun exitDesktopWithDragToTopDragZone( wmHelper: WindowManagerStateHelper, diff --git a/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/MotionEventHelper.kt b/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/MotionEventHelper.kt new file mode 100644 index 000000000000..083539890906 --- /dev/null +++ b/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/MotionEventHelper.kt @@ -0,0 +1,116 @@ +/* + * 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.server.wm.flicker.helpers + +import android.app.Instrumentation +import android.os.SystemClock +import android.view.ContentInfo.Source +import android.view.InputDevice.SOURCE_MOUSE +import android.view.InputDevice.SOURCE_STYLUS +import android.view.MotionEvent +import android.view.MotionEvent.ACTION_DOWN +import android.view.MotionEvent.ACTION_MOVE +import android.view.MotionEvent.ACTION_UP +import android.view.MotionEvent.TOOL_TYPE_FINGER +import android.view.MotionEvent.TOOL_TYPE_MOUSE +import android.view.MotionEvent.TOOL_TYPE_STYLUS +import android.view.MotionEvent.ToolType + +/** + * Helper class for injecting a custom motion event and performing some actions. This is used for + * instrumenting input injections like stylus, mouse and touchpad. + */ +class MotionEventHelper( + private val instr: Instrumentation, + private val inputMethod: InputMethod +) { + enum class InputMethod(@ToolType val toolType: Int, @Source val source: Int) { + STYLUS(TOOL_TYPE_STYLUS, SOURCE_STYLUS), + MOUSE(TOOL_TYPE_MOUSE, SOURCE_MOUSE), + TOUCHPAD(TOOL_TYPE_FINGER, SOURCE_MOUSE) + } + + fun actionDown(x: Int, y: Int) { + injectMotionEvent(ACTION_DOWN, x, y) + } + + fun actionUp(x: Int, y: Int) { + injectMotionEvent(ACTION_UP, x, y) + } + + fun actionMove(startX: Int, startY: Int, endX: Int, endY: Int, steps: Int) { + val incrementX = (endX - startX).toFloat() / (steps - 1) + val incrementY = (endY - startY).toFloat() / (steps - 1) + + for (i in 0..steps) { + val time = SystemClock.uptimeMillis() + val x = startX + incrementX * i + val y = startY + incrementY * i + + val moveEvent = getMotionEvent(time, time, ACTION_MOVE, x, y) + injectMotionEvent(moveEvent) + } + } + + private fun injectMotionEvent(action: Int, x: Int, y: Int): MotionEvent { + val eventTime = SystemClock.uptimeMillis() + val event = getMotionEvent(eventTime, eventTime, action, x.toFloat(), y.toFloat()) + injectMotionEvent(event) + return event + } + + private fun injectMotionEvent(event: MotionEvent) { + instr.uiAutomation.injectInputEvent(event, true, false) + } + + private fun getMotionEvent( + downTime: Long, + eventTime: Long, + action: Int, + x: Float, + y: Float, + ): MotionEvent { + val properties = MotionEvent.PointerProperties.createArray(1) + properties[0].toolType = inputMethod.toolType + properties[0].id = 1 + + val coords = MotionEvent.PointerCoords.createArray(1) + coords[0].x = x + coords[0].y = y + coords[0].pressure = 1f + + val event = + MotionEvent.obtain( + downTime, + eventTime, + action, + /* pointerCount= */ 1, + properties, + coords, + /* metaState= */ 0, + /* buttonState= */ 0, + /* xPrecision = */ 1f, + /* yPrecision = */ 1f, + /* deviceId = */ 0, + /* edgeFlags = */ 0, + inputMethod.source, + /* flags = */ 0 + ) + event.displayId = 0 + return event + } +}
\ No newline at end of file diff --git a/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt b/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt index 43fd57bf39aa..931e4f88aa8d 100644 --- a/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt +++ b/tests/FlickerTests/test-apps/app-helpers/src/com/android/server/wm/flicker/helpers/PipAppHelper.kt @@ -269,9 +269,23 @@ open class PipAppHelper(instrumentation: Instrumentation) : /** Expand the PIP window back to full screen via intent and wait until the app is visible */ fun exitPipToFullScreenViaIntent(wmHelper: WindowManagerStateHelper) = launchViaIntent(wmHelper) - fun changeAspectRatio() { + fun changeAspectRatio(wmHelper: WindowManagerStateHelper) { val intent = Intent("com.android.wm.shell.flicker.testapp.ASPECT_RATIO") context.sendBroadcast(intent) + // Wait on WMHelper on size change upon aspect ratio change + val windowRect = getWindowRect(wmHelper) + wmHelper + .StateSyncBuilder() + .add("pipAspectRatioChanged") { + val pipAppWindow = + it.wmState.visibleWindows.firstOrNull { window -> + this.windowMatchesAnyOf(window) + } + ?: return@add false + val pipRegion = pipAppWindow.frameRegion + return@add pipRegion != Region(windowRect) + } + .waitForAndVerify() } fun clickEnterPipButton(wmHelper: WindowManagerStateHelper) { diff --git a/tests/FlickerTests/test-apps/flickerapp/src/com/android/server/wm/flicker/testapp/GameActivity.java b/tests/FlickerTests/test-apps/flickerapp/src/com/android/server/wm/flicker/testapp/GameActivity.java index ef75d4ddcdcd..93254f7247b6 100644 --- a/tests/FlickerTests/test-apps/flickerapp/src/com/android/server/wm/flicker/testapp/GameActivity.java +++ b/tests/FlickerTests/test-apps/flickerapp/src/com/android/server/wm/flicker/testapp/GameActivity.java @@ -71,7 +71,7 @@ public class GameActivity extends Activity implements SurfaceHolder.Callback { windowInsetsController.setSystemBarsBehavior( WindowInsetsControllerCompat.BEHAVIOR_SHOW_TRANSIENT_BARS_BY_SWIPE ); - // Hide both the status bar and the navigation bar. - windowInsetsController.hide(WindowInsetsCompat.Type.systemBars()); + // Hide status bar only to avoid flakiness on gesture quick switch cases. + windowInsetsController.hide(WindowInsetsCompat.Type.statusBars()); } } diff --git a/tests/Input/Android.bp b/tests/Input/Android.bp index 06c2651b604d..65398a22d968 100644 --- a/tests/Input/Android.bp +++ b/tests/Input/Android.bp @@ -40,7 +40,7 @@ android_test { "frameworks-base-testutils", "hamcrest-library", "kotlin-test", - "mockito-target-minus-junit4", + "mockito-target-extended-minus-junit4", "platform-test-annotations", "platform-screenshot-diff-core", "services.core.unboosted", diff --git a/tests/Input/src/com/android/server/input/debug/TouchpadDebugViewControllerTests.java b/tests/Input/src/com/android/server/input/debug/TouchpadDebugViewControllerTests.java new file mode 100644 index 000000000000..c7ebd3a27a2e --- /dev/null +++ b/tests/Input/src/com/android/server/input/debug/TouchpadDebugViewControllerTests.java @@ -0,0 +1,215 @@ +/* + * Copyright 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.server.input.debug; + +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.graphics.Rect; +import android.hardware.input.InputManager; +import android.testing.AndroidTestingRunner; +import android.testing.TestableContext; +import android.testing.TestableLooper; +import android.testing.TestableLooper.RunWithLooper; +import android.view.InputDevice; +import android.view.WindowInsets; +import android.view.WindowManager; +import android.view.WindowMetrics; + +import androidx.test.platform.app.InstrumentationRegistry; + +import com.android.server.input.InputManagerService; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.junit.MockitoJUnit; +import org.mockito.junit.MockitoRule; + +/** + * Build/Install/Run: + * atest TouchpadDebugViewControllerTests + */ + +@RunWith(AndroidTestingRunner.class) +@RunWithLooper +public class TouchpadDebugViewControllerTests { + private static final int DEVICE_ID = 1000; + private static final String TAG = "TouchpadDebugViewController"; + + @Rule + public final MockitoRule mockito = MockitoJUnit.rule(); + + private Context mContext; + private TouchpadDebugViewController mTouchpadDebugViewController; + @Mock + private InputManager mInputManagerMock; + @Mock + private InputManagerService mInputManagerServiceMock; + @Mock + private WindowManager mWindowManagerMock; + private TestableLooper mTestableLooper; + + @Before + public void setup() throws Exception { + mContext = InstrumentationRegistry.getInstrumentation().getContext(); + TestableContext mTestableContext = new TestableContext(mContext); + mTestableContext.addMockSystemService(WindowManager.class, mWindowManagerMock); + + Rect bounds = new Rect(0, 0, 2560, 1600); + WindowMetrics metrics = new WindowMetrics(bounds, new WindowInsets(bounds), 1.0f); + + when(mWindowManagerMock.getCurrentWindowMetrics()).thenReturn(metrics); + + unMockTouchpad(); + + mTestableLooper = TestableLooper.get(this); + + mTestableContext.addMockSystemService(InputManager.class, mInputManagerMock); + + mTouchpadDebugViewController = new TouchpadDebugViewController(mTestableContext, + mTestableLooper.getLooper(), mInputManagerServiceMock); + } + + private InputDevice createTouchpadInputDevice(int id) { + return new InputDevice.Builder() + .setId(id) + .setSources(InputDevice.SOURCE_TOUCHPAD | InputDevice.SOURCE_MOUSE) + .setName("Test Device " + id) + .build(); + } + + private void mockTouchpad() { + when(mInputManagerMock.getInputDeviceIds()).thenReturn(new int[]{DEVICE_ID}); + when(mInputManagerMock.getInputDevice(eq(DEVICE_ID))).thenReturn( + createTouchpadInputDevice(DEVICE_ID)); + } + + private void unMockTouchpad() { + when(mInputManagerMock.getInputDeviceIds()).thenReturn(new int[]{}); + when(mInputManagerMock.getInputDevice(eq(DEVICE_ID))).thenReturn(null); + } + + @Test + public void touchpadConnectedWhileSettingDisabled() throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(false); + + mockTouchpad(); + mTouchpadDebugViewController.onInputDeviceAdded(DEVICE_ID); + + verify(mWindowManagerMock, never()).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + } + + @Test + public void settingEnabledWhileNoTouchpadConnected() throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(true); + + verify(mWindowManagerMock, never()).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + } + + @Test + public void touchpadConnectedWhileSettingEnabled() throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(true); + + mockTouchpad(); + mTouchpadDebugViewController.onInputDeviceAdded(DEVICE_ID); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + } + + @Test + public void touchpadConnectedWhileSettingEnabledThenDisabled() throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(true); + + mockTouchpad(); + mTouchpadDebugViewController.onInputDeviceAdded(DEVICE_ID); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(false); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, times(1)).removeView(any()); + } + + @Test + public void touchpadConnectedWhileSettingDisabledThenEnabled() throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(false); + + mockTouchpad(); + mTouchpadDebugViewController.onInputDeviceAdded(DEVICE_ID); + + verify(mWindowManagerMock, never()).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(true); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + } + + @Test + public void touchpadConnectedWhileSettingDisabledThenTouchpadDisconnected() throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(false); + + mockTouchpad(); + mTouchpadDebugViewController.onInputDeviceAdded(DEVICE_ID); + + verify(mWindowManagerMock, never()).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + + unMockTouchpad(); + mTouchpadDebugViewController.onInputDeviceRemoved(DEVICE_ID); + + verify(mWindowManagerMock, never()).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + } + + @Test + public void touchpadConnectedWhileSettingEnabledThenTouchpadDisconnectedThenSettingDisabled() + throws Exception { + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(true); + + mockTouchpad(); + mTouchpadDebugViewController.onInputDeviceAdded(DEVICE_ID); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, never()).removeView(any()); + + unMockTouchpad(); + mTouchpadDebugViewController.onInputDeviceRemoved(DEVICE_ID); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, times(1)).removeView(any()); + + mTouchpadDebugViewController.updateTouchpadVisualizerEnabled(false); + + verify(mWindowManagerMock, times(1)).addView(any(), any()); + verify(mWindowManagerMock, times(1)).removeView(any()); + } +} diff --git a/tests/Input/src/com/android/server/input/debug/TouchpadDebugViewTest.java b/tests/Input/src/com/android/server/input/debug/TouchpadDebugViewTest.java new file mode 100644 index 000000000000..2a49eb12c3ff --- /dev/null +++ b/tests/Input/src/com/android/server/input/debug/TouchpadDebugViewTest.java @@ -0,0 +1,326 @@ +/* + * Copyright 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.server.input.debug; + +import static android.view.InputDevice.SOURCE_TOUCHSCREEN; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.doAnswer; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.graphics.Color; +import android.graphics.Rect; +import android.graphics.drawable.ColorDrawable; +import android.testing.TestableContext; +import android.view.MotionEvent; +import android.view.View; +import android.view.ViewConfiguration; +import android.view.WindowInsets; +import android.view.WindowManager; +import android.view.WindowMetrics; + +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.runner.AndroidJUnit4; + +import com.android.cts.input.MotionEventBuilder; +import com.android.cts.input.PointerBuilder; +import com.android.server.input.TouchpadFingerState; +import com.android.server.input.TouchpadHardwareState; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +/** + * Build/Install/Run: + * atest TouchpadDebugViewTest + */ +@RunWith(AndroidJUnit4.class) +public class TouchpadDebugViewTest { + private static final int TOUCHPAD_DEVICE_ID = 6; + + private TouchpadDebugView mTouchpadDebugView; + private WindowManager.LayoutParams mWindowLayoutParams; + + @Mock + WindowManager mWindowManager; + + Rect mWindowBounds; + WindowMetrics mWindowMetrics; + TestableContext mTestableContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + Context context = InstrumentationRegistry.getInstrumentation().getContext(); + mTestableContext = new TestableContext(context); + + mTestableContext.addMockSystemService(WindowManager.class, mWindowManager); + + mWindowBounds = new Rect(0, 0, 2560, 1600); + mWindowMetrics = new WindowMetrics(mWindowBounds, new WindowInsets(mWindowBounds), 1.0f); + + when(mWindowManager.getCurrentWindowMetrics()).thenReturn(mWindowMetrics); + + mTouchpadDebugView = new TouchpadDebugView(mTestableContext, TOUCHPAD_DEVICE_ID); + + mTouchpadDebugView.measure( + View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED), + View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED) + ); + + doAnswer(invocation -> { + mTouchpadDebugView.layout(0, 0, mTouchpadDebugView.getMeasuredWidth(), + mTouchpadDebugView.getMeasuredHeight()); + return null; + }).when(mWindowManager).addView(any(), any()); + + doAnswer(invocation -> { + mTouchpadDebugView.layout(0, 0, mTouchpadDebugView.getMeasuredWidth(), + mTouchpadDebugView.getMeasuredHeight()); + return null; + }).when(mWindowManager).updateViewLayout(any(), any()); + + mWindowLayoutParams = mTouchpadDebugView.getWindowLayoutParams(); + mWindowLayoutParams.x = 20; + mWindowLayoutParams.y = 20; + + mTouchpadDebugView.layout(0, 0, mTouchpadDebugView.getMeasuredWidth(), + mTouchpadDebugView.getMeasuredHeight()); + } + + @Test + public void testDragView() { + // Initial view position relative to screen. + int initialX = mWindowLayoutParams.x; + int initialY = mWindowLayoutParams.y; + + float offsetX = ViewConfiguration.get(mTestableContext).getScaledTouchSlop() + 10; + float offsetY = ViewConfiguration.get(mTestableContext).getScaledTouchSlop() + 10; + + // Simulate ACTION_DOWN event (initial touch). + MotionEvent actionDown = new MotionEventBuilder(MotionEvent.ACTION_DOWN, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(40f) + .y(40f) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionDown); + + verify(mWindowManager, times(0)).updateViewLayout(any(), any()); + + // Simulate ACTION_MOVE event (dragging to the right). + MotionEvent actionMove = new MotionEventBuilder(MotionEvent.ACTION_MOVE, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(40f + offsetX) + .y(40f + offsetY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionMove); + + ArgumentCaptor<WindowManager.LayoutParams> mWindowLayoutParamsCaptor = + ArgumentCaptor.forClass(WindowManager.LayoutParams.class); + verify(mWindowManager).updateViewLayout(any(), mWindowLayoutParamsCaptor.capture()); + + // Verify position after ACTION_MOVE + assertEquals(initialX + (long) offsetX, mWindowLayoutParamsCaptor.getValue().x); + assertEquals(initialY + (long) offsetY, mWindowLayoutParamsCaptor.getValue().y); + + // Simulate ACTION_UP event (release touch). + MotionEvent actionUp = new MotionEventBuilder(MotionEvent.ACTION_UP, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(40f + offsetX) + .y(40f + offsetY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionUp); + + assertEquals(initialX + (long) offsetX, mWindowLayoutParamsCaptor.getValue().x); + assertEquals(initialY + (long) offsetY, mWindowLayoutParamsCaptor.getValue().y); + } + + @Test + public void testDragViewOutOfBounds() { + int initialX = mWindowLayoutParams.x; + int initialY = mWindowLayoutParams.y; + + MotionEvent actionDown = new MotionEventBuilder(MotionEvent.ACTION_DOWN, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX + 10f) + .y(initialY + 10f) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionDown); + + verify(mWindowManager, times(0)).updateViewLayout(any(), any()); + + // Simulate ACTION_MOVE event (dragging far to the right and bottom, beyond screen bounds) + MotionEvent actionMove = new MotionEventBuilder(MotionEvent.ACTION_MOVE, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(mWindowBounds.width() + mTouchpadDebugView.getWidth()) + .y(mWindowBounds.height() + mTouchpadDebugView.getHeight()) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionMove); + + ArgumentCaptor<WindowManager.LayoutParams> mWindowLayoutParamsCaptor = + ArgumentCaptor.forClass(WindowManager.LayoutParams.class); + verify(mWindowManager).updateViewLayout(any(), mWindowLayoutParamsCaptor.capture()); + + // Verify the view has been clamped to the right and bottom edges of the screen + assertEquals(mWindowBounds.width() - mTouchpadDebugView.getWidth(), + mWindowLayoutParamsCaptor.getValue().x); + assertEquals(mWindowBounds.height() - mTouchpadDebugView.getHeight(), + mWindowLayoutParamsCaptor.getValue().y); + + MotionEvent actionUp = new MotionEventBuilder(MotionEvent.ACTION_UP, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(mWindowBounds.width() + mTouchpadDebugView.getWidth()) + .y(mWindowBounds.height() + mTouchpadDebugView.getHeight()) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionUp); + + // Verify the view has been clamped to the right and bottom edges of the screen + assertEquals(mWindowBounds.width() - mTouchpadDebugView.getWidth(), + mWindowLayoutParamsCaptor.getValue().x); + assertEquals(mWindowBounds.height() - mTouchpadDebugView.getHeight(), + mWindowLayoutParamsCaptor.getValue().y); + } + + @Test + public void testSlopOffset() { + int initialX = mWindowLayoutParams.x; + int initialY = mWindowLayoutParams.y; + + float offsetX = ViewConfiguration.get(mTestableContext).getScaledTouchSlop() / 2.0f; + float offsetY = -(ViewConfiguration.get(mTestableContext).getScaledTouchSlop() / 2.0f); + + MotionEvent actionDown = new MotionEventBuilder(MotionEvent.ACTION_DOWN, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX) + .y(initialY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionDown); + + MotionEvent actionMove = new MotionEventBuilder(MotionEvent.ACTION_MOVE, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX + offsetX) + .y(initialY + offsetY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionMove); + + MotionEvent actionUp = new MotionEventBuilder(MotionEvent.ACTION_UP, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX) + .y(initialY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionUp); + + // In this case the updateViewLayout() method wouldn't be called because the drag + // distance hasn't exceeded the slop + verify(mWindowManager, times(0)).updateViewLayout(any(), any()); + } + + @Test + public void testViewReturnsToInitialPositionOnCancel() { + int initialX = mWindowLayoutParams.x; + int initialY = mWindowLayoutParams.y; + + float offsetX = 50; + float offsetY = 50; + + MotionEvent actionDown = new MotionEventBuilder(MotionEvent.ACTION_DOWN, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX) + .y(initialY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionDown); + + MotionEvent actionMove = new MotionEventBuilder(MotionEvent.ACTION_MOVE, SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX + offsetX) + .y(initialY + offsetY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionMove); + + ArgumentCaptor<WindowManager.LayoutParams> mWindowLayoutParamsCaptor = + ArgumentCaptor.forClass(WindowManager.LayoutParams.class); + verify(mWindowManager).updateViewLayout(any(), mWindowLayoutParamsCaptor.capture()); + + assertEquals(initialX + (long) offsetX, mWindowLayoutParamsCaptor.getValue().x); + assertEquals(initialY + (long) offsetY, mWindowLayoutParamsCaptor.getValue().y); + + // Simulate ACTION_CANCEL event (canceling the touch event stream) + MotionEvent actionCancel = new MotionEventBuilder(MotionEvent.ACTION_CANCEL, + SOURCE_TOUCHSCREEN) + .pointer(new PointerBuilder(0, MotionEvent.TOOL_TYPE_FINGER) + .x(initialX + offsetX) + .y(initialY + offsetY) + ) + .build(); + mTouchpadDebugView.dispatchTouchEvent(actionCancel); + + // Verify the view returns to its initial position + verify(mWindowManager, times(2)).updateViewLayout(any(), + mWindowLayoutParamsCaptor.capture()); + assertEquals(initialX, mWindowLayoutParamsCaptor.getValue().x); + assertEquals(initialY, mWindowLayoutParamsCaptor.getValue().y); + } + + @Test + public void testTouchpadClick() { + View child = mTouchpadDebugView.getChildAt(0); + + mTouchpadDebugView.updateHardwareState( + new TouchpadHardwareState(0, 1 /* buttonsDown */, 0, 0, + new TouchpadFingerState[0]), TOUCHPAD_DEVICE_ID); + + assertEquals(((ColorDrawable) child.getBackground()).getColor(), Color.BLUE); + + mTouchpadDebugView.updateHardwareState( + new TouchpadHardwareState(0, 0 /* buttonsDown */, 0, 0, + new TouchpadFingerState[0]), TOUCHPAD_DEVICE_ID); + + assertEquals(((ColorDrawable) child.getBackground()).getColor(), Color.RED); + + mTouchpadDebugView.updateHardwareState( + new TouchpadHardwareState(0, 1 /* buttonsDown */, 0, 0, + new TouchpadFingerState[0]), TOUCHPAD_DEVICE_ID); + + assertEquals(((ColorDrawable) child.getBackground()).getColor(), Color.BLUE); + + // Color should not change because hardware state of a different touchpad + mTouchpadDebugView.updateHardwareState( + new TouchpadHardwareState(0, 0 /* buttonsDown */, 0, 0, + new TouchpadFingerState[0]), TOUCHPAD_DEVICE_ID + 1); + + assertEquals(((ColorDrawable) child.getBackground()).getColor(), Color.BLUE); + } +} diff --git a/tests/Internal/src/com/android/internal/protolog/PerfettoProtoLogImplTest.java b/tests/Internal/src/com/android/internal/protolog/PerfettoProtoLogImplTest.java index 6db5f8277e52..e841d9ea0880 100644 --- a/tests/Internal/src/com/android/internal/protolog/PerfettoProtoLogImplTest.java +++ b/tests/Internal/src/com/android/internal/protolog/PerfettoProtoLogImplTest.java @@ -16,8 +16,6 @@ package com.android.internal.protolog; -import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation; - import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; @@ -30,7 +28,6 @@ import static org.mockito.Mockito.when; import static java.io.File.createTempFile; -import android.content.Context; import android.os.SystemClock; import android.platform.test.annotations.Presubmit; import android.tools.ScenarioBuilder; @@ -45,6 +42,7 @@ import android.util.proto.ProtoInputStream; import androidx.test.platform.app.InstrumentationRegistry; +import com.android.internal.protolog.ProtoLogConfigurationService.ViewerConfigFileTracer; import com.android.internal.protolog.common.IProtoLogGroup; import com.android.internal.protolog.common.LogDataType; import com.android.internal.protolog.common.LogLevel; @@ -53,11 +51,11 @@ import com.google.common.truth.Truth; import org.junit.After; import org.junit.Before; +import org.junit.BeforeClass; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; import perfetto.protos.Protolog; import perfetto.protos.ProtologCommon; @@ -75,6 +73,8 @@ import java.util.concurrent.atomic.AtomicInteger; @Presubmit @RunWith(JUnit4.class) public class PerfettoProtoLogImplTest { + private static final String TEST_PROTOLOG_DATASOURCE_NAME = "test.android.protolog"; + private static final String MOCK_VIEWER_CONFIG_FILE = "my/mock/viewer/config/file.pb"; private final File mTracingDirectory = InstrumentationRegistry.getInstrumentation() .getTargetContext().getFilesDir(); @@ -91,28 +91,19 @@ public class PerfettoProtoLogImplTest { new TraceConfig(false, true, false) ); - private PerfettoProtoLogImpl mProtoLog; - private Protolog.ProtoLogViewerConfig.Builder mViewerConfigBuilder; - private File mFile; - private Runnable mCacheUpdater; + private static ProtoLogConfigurationService sProtoLogConfigurationService; + private static PerfettoProtoLogImpl sProtoLog; + private static Protolog.ProtoLogViewerConfig.Builder sViewerConfigBuilder; + private static Runnable sCacheUpdater; - private ProtoLogViewerConfigReader mReader; + private static ProtoLogViewerConfigReader sReader; public PerfettoProtoLogImplTest() throws IOException { } - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); - final Context testContext = getInstrumentation().getContext(); - mFile = testContext.getFileStreamPath("tracing_test.dat"); - //noinspection ResultOfMethodCallIgnored - mFile.delete(); - - TestProtoLogGroup.TEST_GROUP.setLogToLogcat(false); - TestProtoLogGroup.TEST_GROUP.setLogToProto(false); - - mViewerConfigBuilder = Protolog.ProtoLogViewerConfig.newBuilder() + @BeforeClass + public static void setUp() throws Exception { + sViewerConfigBuilder = Protolog.ProtoLogViewerConfig.newBuilder() .addGroups( Protolog.ProtoLogViewerConfig.Group.newBuilder() .setId(1) @@ -158,36 +149,62 @@ public class PerfettoProtoLogImplTest { ViewerConfigInputStreamProvider viewerConfigInputStreamProvider = Mockito.mock( ViewerConfigInputStreamProvider.class); Mockito.when(viewerConfigInputStreamProvider.getInputStream()) - .thenAnswer(it -> new ProtoInputStream(mViewerConfigBuilder.build().toByteArray())); + .thenAnswer(it -> new ProtoInputStream(sViewerConfigBuilder.build().toByteArray())); + + sCacheUpdater = () -> {}; + sReader = Mockito.spy(new ProtoLogViewerConfigReader(viewerConfigInputStreamProvider)); + + final ProtoLogDataSourceBuilder dataSourceBuilder = + (onStart, onFlush, onStop) -> new ProtoLogDataSource( + onStart, onFlush, onStop, TEST_PROTOLOG_DATASOURCE_NAME); + final ViewerConfigFileTracer tracer = (dataSource, viewerConfigFilePath) -> { + Utils.dumpViewerConfig(dataSource, () -> { + if (!viewerConfigFilePath.equals(MOCK_VIEWER_CONFIG_FILE)) { + throw new RuntimeException( + "Unexpected viewer config file path provided"); + } + return new ProtoInputStream(sViewerConfigBuilder.build().toByteArray()); + }); + }; + sProtoLogConfigurationService = new ProtoLogConfigurationService(dataSourceBuilder, tracer); + + if (android.tracing.Flags.clientSideProtoLogging()) { + sProtoLog = new PerfettoProtoLogImpl( + MOCK_VIEWER_CONFIG_FILE, sReader, () -> sCacheUpdater.run(), + TestProtoLogGroup.values(), dataSourceBuilder, sProtoLogConfigurationService); + } else { + sProtoLog = new PerfettoProtoLogImpl( + viewerConfigInputStreamProvider, sReader, () -> sCacheUpdater.run(), + TestProtoLogGroup.values(), dataSourceBuilder, sProtoLogConfigurationService); + } + } + + @Before + public void before() { + Mockito.reset(sReader); - mCacheUpdater = () -> {}; - mReader = Mockito.spy(new ProtoLogViewerConfigReader(viewerConfigInputStreamProvider)); - mProtoLog = new PerfettoProtoLogImpl( - viewerConfigInputStreamProvider, mReader, - () -> mCacheUpdater.run(), TestProtoLogGroup.values()); + TestProtoLogGroup.TEST_GROUP.setLogToLogcat(false); + TestProtoLogGroup.TEST_GROUP.setLogToProto(false); } @After public void tearDown() { - if (mFile != null) { - //noinspection ResultOfMethodCallIgnored - mFile.delete(); - } ProtoLogImpl.setSingleInstance(null); } @Test public void isEnabled_returnsFalseByDefault() { - assertFalse(mProtoLog.isProtoEnabled()); + assertFalse(sProtoLog.isProtoEnabled()); } @Test public void isEnabled_returnsTrueAfterStart() { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog().build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - assertTrue(mProtoLog.isProtoEnabled()); + assertTrue(sProtoLog.isProtoEnabled()); } finally { traceMonitor.stop(mWriter); } @@ -195,35 +212,37 @@ public class PerfettoProtoLogImplTest { @Test public void isEnabled_returnsFalseAfterStop() { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog().build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - assertTrue(mProtoLog.isProtoEnabled()); + assertTrue(sProtoLog.isProtoEnabled()); } finally { traceMonitor.stop(mWriter); } - assertFalse(mProtoLog.isProtoEnabled()); + assertFalse(sProtoLog.isProtoEnabled()); } @Test public void defaultMode() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(false).build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(false, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); // Shouldn't be logging anything except WTF unless explicitly requested in the group // override. - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, + sProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, + sProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, + sProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, + sProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, LogDataType.BOOLEAN, new Object[]{true}); } finally { traceMonitor.stop(mWriter); @@ -238,22 +257,24 @@ public class PerfettoProtoLogImplTest { @Test public void respectsOverrideConfigs_defaultMode() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true, + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog( + true, List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( - TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.DEBUG, true))) - .build(); + TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.DEBUG, true)), + TEST_PROTOLOG_DATASOURCE_NAME + ).build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, + sProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, + sProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, + sProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, + sProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, LogDataType.BOOLEAN, new Object[]{true}); } finally { traceMonitor.stop(mWriter); @@ -273,21 +294,23 @@ public class PerfettoProtoLogImplTest { @Test public void respectsOverrideConfigs_allEnabledMode() throws IOException { PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true, + PerfettoTraceMonitor.newBuilder().enableProtoLog( + true, List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( - TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.WARN, false))) - .build(); + TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.WARN, false)), + TEST_PROTOLOG_DATASOURCE_NAME + ).build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, + sProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, + sProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, + sProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, + sProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, LogDataType.BOOLEAN, new Object[]{true}); } finally { traceMonitor.stop(mWriter); @@ -304,20 +327,20 @@ public class PerfettoProtoLogImplTest { @Test public void respectsAllEnabledMode() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true, List.of()) - .build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, + sProtoLog.log(LogLevel.VERBOSE, TestProtoLogGroup.TEST_GROUP, 2, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, + sProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, 3, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, + sProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, 4, LogDataType.BOOLEAN, new Object[]{true}); - mProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, + sProtoLog.log(LogLevel.WTF, TestProtoLogGroup.TEST_GROUP, 5, LogDataType.BOOLEAN, new Object[]{true}); } finally { traceMonitor.stop(mWriter); @@ -336,8 +359,8 @@ public class PerfettoProtoLogImplTest { @Test public void log_logcatEnabled() { - when(mReader.getViewerString(anyLong())).thenReturn("test %b %d %% 0x%x %s %f"); - PerfettoProtoLogImpl implSpy = Mockito.spy(mProtoLog); + when(sReader.getViewerString(anyLong())).thenReturn("test %b %d %% 0x%x %s %f"); + PerfettoProtoLogImpl implSpy = Mockito.spy(sProtoLog); TestProtoLogGroup.TEST_GROUP.setLogToLogcat(true); TestProtoLogGroup.TEST_GROUP.setLogToProto(false); @@ -348,13 +371,13 @@ public class PerfettoProtoLogImplTest { verify(implSpy).passToLogcat(eq(TestProtoLogGroup.TEST_GROUP.getTag()), eq( LogLevel.INFO), eq("test true 10000 % 0x7530 test 3.0E-6")); - verify(mReader).getViewerString(eq(1234L)); + verify(sReader).getViewerString(eq(1234L)); } @Test public void log_logcatEnabledInvalidMessage() { - when(mReader.getViewerString(anyLong())).thenReturn("test %b %d %% %x %s %f"); - PerfettoProtoLogImpl implSpy = Mockito.spy(mProtoLog); + when(sReader.getViewerString(anyLong())).thenReturn("test %b %d %% %x %s %f"); + PerfettoProtoLogImpl implSpy = Mockito.spy(sProtoLog); TestProtoLogGroup.TEST_GROUP.setLogToLogcat(true); TestProtoLogGroup.TEST_GROUP.setLogToProto(false); @@ -366,29 +389,28 @@ public class PerfettoProtoLogImplTest { LogLevel.INFO), eq("FORMAT_ERROR \"test %b %d %% %x %s %f\", " + "args=(true, 10000, 1.0E-4, 2.0E-5, test)")); - verify(mReader).getViewerString(eq(1234L)); + verify(sReader).getViewerString(eq(1234L)); } @Test public void log_logcatEnabledNoMessage() { - when(mReader.getViewerString(anyLong())).thenReturn(null); - PerfettoProtoLogImpl implSpy = Mockito.spy(mProtoLog); + when(sReader.getViewerString(anyLong())).thenReturn(null); + PerfettoProtoLogImpl implSpy = Mockito.spy(sProtoLog); TestProtoLogGroup.TEST_GROUP.setLogToLogcat(true); TestProtoLogGroup.TEST_GROUP.setLogToProto(false); - implSpy.log( - LogLevel.INFO, TestProtoLogGroup.TEST_GROUP, 1234, 4321, + implSpy.log(LogLevel.INFO, TestProtoLogGroup.TEST_GROUP, 1234, 4321, new Object[]{5}); verify(implSpy).passToLogcat(eq(TestProtoLogGroup.TEST_GROUP.getTag()), eq( LogLevel.INFO), eq("UNKNOWN MESSAGE args = (5)")); - verify(mReader).getViewerString(eq(1234L)); + verify(sReader).getViewerString(eq(1234L)); } @Test public void log_logcatDisabled() { - when(mReader.getViewerString(anyLong())).thenReturn("test %d"); - PerfettoProtoLogImpl implSpy = Mockito.spy(mProtoLog); + when(sReader.getViewerString(anyLong())).thenReturn("test %d"); + PerfettoProtoLogImpl implSpy = Mockito.spy(sProtoLog); TestProtoLogGroup.TEST_GROUP.setLogToLogcat(false); implSpy.log( @@ -396,7 +418,7 @@ public class PerfettoProtoLogImplTest { new Object[]{5}); verify(implSpy, never()).passToLogcat(any(), any(), any()); - verify(mReader, never()).getViewerString(anyLong()); + verify(sReader, never()).getViewerString(anyLong()); } @Test @@ -405,16 +427,18 @@ public class PerfettoProtoLogImplTest { ProtologCommon.ProtoLogLevel.PROTOLOG_LEVEL_INFO, "My test message :: %s, %d, %o, %x, %f, %e, %g, %b"); - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog().build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(TEST_PROTOLOG_DATASOURCE_NAME) + .build(); long before; long after; try { + assertFalse(sProtoLog.isProtoEnabled()); traceMonitor.start(); - assertTrue(mProtoLog.isProtoEnabled()); + assertTrue(sProtoLog.isProtoEnabled()); before = SystemClock.elapsedRealtimeNanos(); - mProtoLog.log( + sProtoLog.log( LogLevel.INFO, TestProtoLogGroup.TEST_GROUP, messageHash, 0b1110101001010100, new Object[]{"test", 1, 2, 3, 0.4, 0.5, 0.6, true}); @@ -432,21 +456,23 @@ public class PerfettoProtoLogImplTest { Truth.assertThat(protolog.messages.getFirst().getTimestamp().getElapsedNanos()) .isAtMost(after); Truth.assertThat(protolog.messages.getFirst().getMessage()) - .isEqualTo("My test message :: test, 2, 4, 6, 0.400000, 5.000000e-01, 0.6, true"); + .isEqualTo( + "My test message :: test, 1, 2, 3, 0.400000, 5.000000e-01, 0.6, true"); } @Test public void log_noProcessing() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog().build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(TEST_PROTOLOG_DATASOURCE_NAME) + .build(); long before; long after; try { traceMonitor.start(); - assertTrue(mProtoLog.isProtoEnabled()); + assertTrue(sProtoLog.isProtoEnabled()); before = SystemClock.elapsedRealtimeNanos(); - mProtoLog.log( + sProtoLog.log( LogLevel.INFO, TestProtoLogGroup.TEST_GROUP, "My test message :: %s, %d, %x, %f, %b", "test", 1, 3, 0.4, true); @@ -464,16 +490,17 @@ public class PerfettoProtoLogImplTest { Truth.assertThat(protolog.messages.getFirst().getTimestamp().getElapsedNanos()) .isAtMost(after); Truth.assertThat(protolog.messages.getFirst().getMessage()) - .isEqualTo("My test message :: test, 2, 6, 0.400000, true"); + .isEqualTo("My test message :: test, 1, 3, 0.400000, true"); } @Test public void supportsLocationInformation() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true).build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, LogDataType.BOOLEAN, new Object[]{true}); } finally { traceMonitor.stop(mWriter); @@ -489,7 +516,7 @@ public class PerfettoProtoLogImplTest { private long addMessageToConfig(ProtologCommon.ProtoLogLevel logLevel, String message) { final long messageId = new Random().nextLong(); - mViewerConfigBuilder.addMessages(Protolog.ProtoLogViewerConfig.MessageData.newBuilder() + sViewerConfigBuilder.addMessages(Protolog.ProtoLogViewerConfig.MessageData.newBuilder() .setMessageId(messageId) .setMessage(message) .setLevel(logLevel) @@ -504,14 +531,15 @@ public class PerfettoProtoLogImplTest { final long messageHash = addMessageToConfig( ProtologCommon.ProtoLogLevel.PROTOLOG_LEVEL_INFO, "My test message :: %s, %d, %f, %b"); - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog().build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(TEST_PROTOLOG_DATASOURCE_NAME) + .build(); long before; long after; try { traceMonitor.start(); before = SystemClock.elapsedRealtimeNanos(); - mProtoLog.log( + sProtoLog.log( LogLevel.INFO, TestProtoLogGroup.TEST_GROUP, messageHash, 0b01100100, new Object[]{"test", 1, 0.1, true}); @@ -526,11 +554,12 @@ public class PerfettoProtoLogImplTest { @Test public void log_protoDisabled() throws Exception { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(false).build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(false, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, 0b11, new Object[]{true}); } finally { traceMonitor.stop(mWriter); @@ -544,16 +573,18 @@ public class PerfettoProtoLogImplTest { @Test public void stackTraceTrimmed() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true, + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog( + true, List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.DEBUG, - true))) - .build(); + true)), + TEST_PROTOLOG_DATASOURCE_NAME + ).build(); try { traceMonitor.start(); - ProtoLogImpl.setSingleInstance(mProtoLog); + ProtoLogImpl.setSingleInstance(sProtoLog); ProtoLogImpl.d(TestProtoLogGroup.TEST_GROUP, 1, 0b11, true); } finally { @@ -577,20 +608,20 @@ public class PerfettoProtoLogImplTest { @Test public void cacheIsUpdatedWhenTracesStartAndStop() { final AtomicInteger cacheUpdateCallCount = new AtomicInteger(0); - mCacheUpdater = cacheUpdateCallCount::incrementAndGet; + sCacheUpdater = cacheUpdateCallCount::incrementAndGet; - PerfettoTraceMonitor traceMonitor1 = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true, - List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( - TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.WARN, - false))) - .build(); + PerfettoTraceMonitor traceMonitor1 = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, + List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( + TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.WARN, + false)), TEST_PROTOLOG_DATASOURCE_NAME + ).build(); PerfettoTraceMonitor traceMonitor2 = PerfettoTraceMonitor.newBuilder().enableProtoLog(true, List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.DEBUG, - false))) + false)), TEST_PROTOLOG_DATASOURCE_NAME) .build(); Truth.assertThat(cacheUpdateCallCount.get()).isEqualTo(0); @@ -619,107 +650,107 @@ public class PerfettoProtoLogImplTest { @Test public void isEnabledUpdatesBasedOnRunningTraces() { - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)).isFalse(); + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)).isFalse(); PerfettoTraceMonitor traceMonitor1 = PerfettoTraceMonitor.newBuilder().enableProtoLog(true, List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.WARN, - false))) + false)), TEST_PROTOLOG_DATASOURCE_NAME) .build(); PerfettoTraceMonitor traceMonitor2 = PerfettoTraceMonitor.newBuilder().enableProtoLog(true, List.of(new PerfettoTraceMonitor.Builder.ProtoLogGroupOverride( TestProtoLogGroup.TEST_GROUP.toString(), LogLevel.DEBUG, - false))) + false)), TEST_PROTOLOG_DATASOURCE_NAME) .build(); try { traceMonitor1.start(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) .isTrue(); try { traceMonitor2.start(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)).isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) .isTrue(); } finally { traceMonitor2.stop(mWriter); } - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) .isTrue(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) .isTrue(); } finally { traceMonitor1.stop(mWriter); } - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.DEBUG)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.VERBOSE)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.INFO)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WARN)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.ERROR)) .isFalse(); - Truth.assertThat(mProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) + Truth.assertThat(sProtoLog.isEnabled(TestProtoLogGroup.TEST_GROUP, LogLevel.WTF)) .isFalse(); } @Test public void supportsNullString() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true) - .build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, "My test null string: %s", (Object) null); } finally { traceMonitor.stop(mWriter); @@ -735,14 +766,14 @@ public class PerfettoProtoLogImplTest { @Test public void supportNullParams() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true) - .build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, "My null args: %d, %f, %b", null, null, null); } finally { traceMonitor.stop(mWriter); @@ -753,18 +784,18 @@ public class PerfettoProtoLogImplTest { Truth.assertThat(protolog.messages).hasSize(1); Truth.assertThat(protolog.messages.get(0).getMessage()) - .isEqualTo("My null args: 0, 0, false"); + .isEqualTo("My null args: 0, 0.000000, false"); } @Test public void handlesConcurrentTracingSessions() throws IOException { - PerfettoTraceMonitor traceMonitor1 = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true) - .build(); + PerfettoTraceMonitor traceMonitor1 = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); - PerfettoTraceMonitor traceMonitor2 = - PerfettoTraceMonitor.newBuilder().enableProtoLog(true) - .build(); + PerfettoTraceMonitor traceMonitor2 = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(true, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); final ResultWriter writer2 = new ResultWriter() .forScenario(new ScenarioBuilder() @@ -776,7 +807,7 @@ public class PerfettoProtoLogImplTest { traceMonitor1.start(); traceMonitor2.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, 1, LogDataType.BOOLEAN, new Object[]{true}); } finally { traceMonitor1.stop(mWriter); @@ -800,16 +831,17 @@ public class PerfettoProtoLogImplTest { @Test public void usesDefaultLogFromLevel() throws IOException { - PerfettoTraceMonitor traceMonitor = - PerfettoTraceMonitor.newBuilder().enableProtoLog(LogLevel.WARN).build(); + PerfettoTraceMonitor traceMonitor = PerfettoTraceMonitor.newBuilder() + .enableProtoLog(LogLevel.WARN, List.of(), TEST_PROTOLOG_DATASOURCE_NAME) + .build(); try { traceMonitor.start(); - mProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, - "This message should not be logged"); - mProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, - "This message should logged %d", 123); - mProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, - "This message should also be logged %d", 567); + sProtoLog.log(LogLevel.DEBUG, TestProtoLogGroup.TEST_GROUP, + "This message should not be logged"); + sProtoLog.log(LogLevel.WARN, TestProtoLogGroup.TEST_GROUP, + "This message should be logged %d", 123); + sProtoLog.log(LogLevel.ERROR, TestProtoLogGroup.TEST_GROUP, + "This message should also be logged %d", 567); } finally { traceMonitor.stop(mWriter); } @@ -822,7 +854,7 @@ public class PerfettoProtoLogImplTest { Truth.assertThat(protolog.messages.get(0).getLevel()) .isEqualTo(LogLevel.WARN); Truth.assertThat(protolog.messages.get(0).getMessage()) - .isEqualTo("This message should logged 123"); + .isEqualTo("This message should be logged 123"); Truth.assertThat(protolog.messages.get(1).getLevel()) .isEqualTo(LogLevel.ERROR); diff --git a/tests/TrustTests/Android.bp b/tests/TrustTests/Android.bp index 4e75a1d02a41..8888b32d2c69 100644 --- a/tests/TrustTests/Android.bp +++ b/tests/TrustTests/Android.bp @@ -40,3 +40,10 @@ android_test { platform_apis: true, certificate: "platform", } + +test_module_config { + name: "TrustTests_trust_test", + base: "TrustTests", + test_suites: ["device-tests"], + include_filters: ["android.trust.test"], +} diff --git a/tests/vcn/java/com/android/server/vcn/TelephonySubscriptionTrackerTest.java b/tests/vcn/java/com/android/server/vcn/TelephonySubscriptionTrackerTest.java index 887630b03a8c..b5cc5536532c 100644 --- a/tests/vcn/java/com/android/server/vcn/TelephonySubscriptionTrackerTest.java +++ b/tests/vcn/java/com/android/server/vcn/TelephonySubscriptionTrackerTest.java @@ -59,7 +59,6 @@ import android.os.HandlerExecutor; import android.os.ParcelUuid; import android.os.PersistableBundle; import android.os.test.TestLooper; -import android.platform.test.flag.junit.SetFlagsRule; import android.telephony.CarrierConfigManager; import android.telephony.SubscriptionInfo; import android.telephony.SubscriptionManager; @@ -73,10 +72,7 @@ import android.util.ArraySet; import androidx.test.filters.SmallTest; import androidx.test.runner.AndroidJUnit4; -import com.android.internal.telephony.flags.Flags; - import org.junit.Before; -import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; @@ -133,8 +129,6 @@ public class TelephonySubscriptionTrackerTest { TEST_SUBID_TO_CARRIER_CONFIG_MAP = Collections.unmodifiableMap(subIdToCarrierConfigMap); } - @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule(); - @NonNull private final Context mContext; @NonNull private final TestLooper mTestLooper; @@ -193,7 +187,6 @@ public class TelephonySubscriptionTrackerTest { @Before public void setUp() throws Exception { - mSetFlagsRule.enableFlags(Flags.FLAG_FIX_CRASH_ON_GETTING_CONFIG_WHEN_PHONE_IS_GONE); doReturn(2).when(mTelephonyManager).getActiveModemCount(); mCallback = mock(TelephonySubscriptionTrackerCallback.class); diff --git a/tests/vcn/java/com/android/server/vcn/routeselection/NetworkEvaluationTestBase.java b/tests/vcn/java/com/android/server/vcn/routeselection/NetworkEvaluationTestBase.java index 0439d5f54e23..edad67896e8e 100644 --- a/tests/vcn/java/com/android/server/vcn/routeselection/NetworkEvaluationTestBase.java +++ b/tests/vcn/java/com/android/server/vcn/routeselection/NetworkEvaluationTestBase.java @@ -123,7 +123,6 @@ public abstract class NetworkEvaluationTestBase { mSetFlagsRule.enableFlags(Flags.FLAG_VALIDATE_NETWORK_ON_IPSEC_LOSS); mSetFlagsRule.enableFlags(Flags.FLAG_EVALUATE_IPSEC_LOSS_ON_LP_NC_CHANGE); mSetFlagsRule.enableFlags(Flags.FLAG_HANDLE_SEQ_NUM_LEAP); - mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_DISABLE_IPSEC_LOSS_DETECTOR); when(mNetwork.getNetId()).thenReturn(-1); |