android-16.0.0_r2/s

/*
 * Copyright (C) 2018 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.contentcaptureservice.cts;

import static android.contentcaptureservice.cts.Helper.MY_EPOCH;
import static android.contentcaptureservice.cts.Helper.TAG;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_CONTEXT_UPDATED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_SESSION_PAUSED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_SESSION_RESUMED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_VIEW_APPEARED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_VIEW_DISAPPEARED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_VIEW_INSETS_CHANGED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_VIEW_TEXT_CHANGED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_VIEW_TREE_APPEARED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_VIEW_TREE_APPEARING;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_WINDOW_BOUNDS_CHANGED;
import static android.view.contentcapture.ContentCaptureEvent.TYPE_SESSION_FLUSH;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth.assertWithMessage;

import android.app.assist.ActivityId;
import android.content.ComponentName;
import android.content.LocusId;
import android.contentcaptureservice.cts.CtsContentCaptureService.Session;
import android.util.Log;
import android.view.Display;
import android.view.View;
import android.view.autofill.AutofillId;
import android.view.contentcapture.ContentCaptureEvent;
import android.view.contentcapture.ContentCaptureSession;
import android.view.contentcapture.ContentCaptureSessionId;
import android.view.contentcapture.ViewNode;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import com.android.compatibility.common.util.RetryableException;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Helper for common assertions.
 */
final class Assertions {

    /**
     * Asserts a session belongs to the right activity.
     */
    public static void assertRightActivity(@NonNull Session session,
            @NonNull ContentCaptureSessionId expectedSessionId,
            @NonNull AbstractContentCaptureActivity activity) {
        assertRightActivity(session, expectedSessionId, activity.getComponentName());
    }

    /**
     * Asserts a session belongs to the right activity.
     */
    public static void assertRightActivity(@NonNull Session session,
            @NonNull ContentCaptureSessionId expectedSessionId,
            @NonNull ComponentName componentName) {
        assertWithMessage("wrong activity for %s", session)
                .that(session.context.getActivityComponent()).isEqualTo(componentName);
        // TODO(b/123540602): merge both or replace check above by:
        //  assertMainSessionContext(session, activity);
        assertThat(session.id).isEqualTo(expectedSessionId);
    }

    /**
     * Asserts the context of a main session.
     */
    public static void assertMainSessionContext(@NonNull Session session,
            @NonNull AbstractContentCaptureActivity activity) {
        assertMainSessionContext(session, activity, /* expectedFlags= */ 0);
    }

    /**
     * Asserts the context of a main session.
     */
    public static void assertMainSessionContext(@NonNull Session session,
            @NonNull AbstractContentCaptureActivity activity, int expectedFlags) {
        assertWithMessage("no context on %s", session).that(session.context).isNotNull();
        assertWithMessage("wrong activity for %s", session)
                .that(session.context.getActivityComponent())
                .isEqualTo(activity.getComponentName());
        assertWithMessage("context for session %s should have displayId", session)
                .that(session.context.getDisplayId()).isNotEqualTo(Display.INVALID_DISPLAY);
        assertWithMessage("wrong task id for session %s", session)
                .that(session.context.getTaskId()).isEqualTo(activity.getRealTaskId());
        assertWithMessage("wrong flags on context for session %s", session)
                .that(session.context.getFlags()).isEqualTo(expectedFlags);
        assertWithMessage("context for session %s should not have ID", session)
                .that(session.context.getLocusId()).isNull();
        assertWithMessage("context for session %s should not have extras", session)
                .that(session.context.getExtras()).isNull();
        final ActivityId activityId = session.context.getActivityId();
        assertWithMessage("context for session %s should have ActivityIds", session)
                .that(activityId).isNotNull();
        assertWithMessage("wrong task id for session %s", session)
                .that(activityId.getTaskId()).isEqualTo(activity.getRealTaskId());
        assertWithMessage("context for session %s should have ActivityId", session)
                .that(activityId.getToken()).isNotNull();
        assertWithMessage("context for session %s should have windowToken", session)
                .that(session.context.getWindowToken()).isNotNull();
    }

    /**
     * Asserts the invariants of a child session.
     */
    public static void assertChildSessionContext(@NonNull Session session) {
        assertWithMessage("no context on %s", session).that(session.context).isNotNull();
        assertWithMessage("context for session %s should not have component", session)
                .that(session.context.getActivityComponent()).isNull();
        assertWithMessage("context for session %s should not have displayId", session)
                .that(session.context.getDisplayId()).isEqualTo(Display.INVALID_DISPLAY);
        assertWithMessage("context for session %s should not have taskId", session)
                .that(session.context.getTaskId()).isEqualTo(0);
        assertWithMessage("context for session %s should not have flags", session)
                .that(session.context.getFlags()).isEqualTo(0);
        final ActivityId activityId = session.context.getActivityId();
        assertWithMessage("context for session %s should not have ActivityIds", session)
                .that(activityId).isNull();
        assertWithMessage("context for session %s should not have windowToken", session)
                .that(session.context.getWindowToken()).isNull();
    }

    /**
     * Asserts the invariants of a child session.
     */
    public static void assertChildSessionContext(@NonNull Session session,
            @NonNull String expectedId) {
        assertChildSessionContext(session);
        assertThat(session.context.getLocusId()).isEqualTo(new LocusId(expectedId));
    }

    /**
     * Asserts a session belongs to the right parent
     */
    public static void assertRightRelationship(@NonNull Session parent, @NonNull Session child) {
        final ContentCaptureSessionId expectedParentId = parent.id;
        assertWithMessage("No id on parent session %s", parent).that(expectedParentId).isNotNull();
        assertWithMessage("No context on child session %s", child).that(child.context).isNotNull();
        final ContentCaptureSessionId actualParentId = child.context.getParentSessionId();
        assertWithMessage("No parent id on context %s of child session %s", child.context, child)
                .that(actualParentId).isNotNull();
        assertWithMessage("id of parent session doesn't match child").that(actualParentId)
                .isEqualTo(expectedParentId);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event, without checking for parent id.
     */
    public static ViewNode assertViewWithUnknownParentAppeared(
            @NonNull List<ContentCaptureEvent> events, int index, @NonNull View expectedView) {
        return assertViewWithUnknownParentAppeared(events, index, expectedView,
                /* expectedText= */ null);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event for a decor view.
     *
     * <P>The decor view is typically internal, so there isn't much we can assert, other than its
     * autofill id.
     */
    public static void assertDecorViewAppeared(@NonNull List<ContentCaptureEvent> events,
            int index, @NonNull View expectedDecorView) {
        final ContentCaptureEvent event = assertViewAppeared(events, index);
        assertWithMessage("wrong autofill id on %s (%s)", event, index)
                .that(event.getViewNode().getAutofillId())
                .isEqualTo(expectedDecorView.getAutofillId());
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event, without checking for parent id.
     */
    public static ViewNode assertViewWithUnknownParentAppeared(
            @NonNull List<ContentCaptureEvent> events, int index, @NonNull View expectedView,
            @Nullable String expectedText) {
        final ContentCaptureEvent event = assertViewAppeared(events, index);
        final ViewNode node = event.getViewNode();

        assertWithMessage("wrong class on %s (%s)", event, index).that(node.getClassName())
                .isEqualTo(expectedView.getClass().getName());
        assertWithMessage("wrong autofill id on %s (%s)", event, index).that(node.getAutofillId())
                .isEqualTo(expectedView.getAutofillId());

        if (expectedText != null) {
            assertWithMessage("wrong text on %s (%s)", event, index).that(node.getText().toString())
                    .isEqualTo(expectedText);
        }
        // TODO(b/123540602): test more fields, like resource id
        return node;
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event, without checking for parent id.
     */
    public static ContentCaptureEvent assertViewAppeared(@NonNull List<ContentCaptureEvent> events,
            int index) {
        final ContentCaptureEvent event = getEvent(events, index, TYPE_VIEW_APPEARED);
        final ViewNode node = event.getViewNode();
        assertThat(node).isNotNull();
        return event;
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event.
     */
    public static void assertViewAppeared(@NonNull List<ContentCaptureEvent> events, int index,
            @NonNull View expectedView, @Nullable AutofillId expectedParentId,
            @Nullable String expectedText) {
        final ViewNode node = assertViewWithUnknownParentAppeared(events, index, expectedView,
                expectedText);
        assertWithMessage("wrong parent autofill id on %s (%s)", events.get(index), index)
            .that(node.getParentAutofillId()).isEqualTo(expectedParentId);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event.
     */
    public static void assertViewAppeared(@NonNull List<ContentCaptureEvent> events, int index,
            @NonNull View expectedView, @Nullable AutofillId expectedParentId) {
        assertViewAppeared(events, index, expectedView, expectedParentId, /* expectedText= */ null);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event.
     */
    public static void assertViewAppeared(@NonNull List<ContentCaptureEvent> events, int index,
            @NonNull ContentCaptureSessionId expectedSessionId,
            @NonNull View expectedView, @Nullable AutofillId expectedParentId) {
        assertViewAppeared(events, index, expectedView, expectedParentId);
        assertSessionId(expectedSessionId, expectedView);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_TREE_APPEARING} event.
     */
    public static void assertViewTreeStarted(@NonNull List<ContentCaptureEvent> events,
            int index) {
        assertSessionLevelEvent(events, index, TYPE_VIEW_TREE_APPEARING);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_TREE_APPEARED} event.
     */
    public static void assertViewTreeFinished(@NonNull List<ContentCaptureEvent> events,
            int index) {
        assertSessionLevelEvent(events, index, TYPE_VIEW_TREE_APPEARED);
    }

    private static void assertSessionLevelEvent(@NonNull List<ContentCaptureEvent> events,
            int index, int expectedType) {
        final ContentCaptureEvent event = getEvent(events, index, expectedType);
        assertWithMessage("event %s (index %s) should not have a ViewNode", event, index)
                .that(event.getViewNode()).isNull();
        assertWithMessage("event %s (index %s) should not have text", event, index)
                .that(event.getText()).isNull();
        assertWithMessage("event %s (index %s) should not have an autofillId", event, index)
                .that(event.getId()).isNull();
        assertWithMessage("event %s (index %s) should not have autofillIds", event, index)
                .that(event.getIds()).isNull();
    }

    /**
     * Asserts the contents of a {@link #TYPE_SESSION_RESUMED} event.
     */
    public static void assertSessionResumed(@NonNull List<ContentCaptureEvent> events,
            int index) {
        assertSessionLevelEvent(events, index, TYPE_SESSION_RESUMED);
    }

    /**
     * Asserts the contents of a {@link #TYPE_SESSION_PAUSED} event.
     */
    public static void assertSessionPaused(@NonNull List<ContentCaptureEvent> events,
            int index) {
        assertSessionLevelEvent(events, index, TYPE_SESSION_PAUSED);
    }

    /**
     * Asserts the contents of a {@link #TYPE_SESSION_FLUSH} event.
     */
    public static void assertSessionFlush(@NonNull List<ContentCaptureEvent> events,
            int index) {
        assertSessionLevelEvent(events, index, TYPE_SESSION_FLUSH);
    }

    /**
     * Asserts that a session for the given activity has no view-level events, just
     * {@link #TYPE_SESSION_RESUMED} and {@link #TYPE_SESSION_PAUSED}.
     */
    public static void assertNoViewLevelEvents(@NonNull Session session,
            @NonNull AbstractContentCaptureActivity activity) {
        assertRightActivity(session, session.id, activity);
        final List<ContentCaptureEvent> events = removeUnexpectedEvents(session.getEvents());
        Log.v(TAG, "events on " + activity + ": " + events);
        assertThat(events).hasSize(2);
        assertSessionResumed(events, 0);
        assertSessionPaused(events, 1);
    }

    /**
     * This method is used to remove unexpected events if the test should only
     * contain session level events.
     * In special case, there are some events, such as {@link #TYPE_WINDOW_BOUNDS_CHANGED}
     * and {@link #TYPE_VIEW_INSETS_CHANGED}, will be accidentally generated by
     * the system. Because these events were not expected in the test, remove
     * them if needed.
     */
    public static List<ContentCaptureEvent> removeUnexpectedEvents(
            @NonNull List<ContentCaptureEvent> events) {
        return Collections.unmodifiableList(events).stream().filter(
                e -> e.getType() != TYPE_WINDOW_BOUNDS_CHANGED
                        && e.getType() != TYPE_VIEW_INSETS_CHANGED
                        && e.getType() != TYPE_VIEW_TREE_APPEARING
                        && e.getType() != TYPE_VIEW_TREE_APPEARED
        ).collect(Collectors.toList());
    }

    /** Gets a list of events that are related to view changes only. */
    public static List<ContentCaptureEvent> getViewLevelEvents(
            @NonNull List<ContentCaptureEvent> events) {
        return Collections.unmodifiableList(events).stream().filter(
                e -> e.getType() == TYPE_WINDOW_BOUNDS_CHANGED
                        || e.getType() == TYPE_VIEW_INSETS_CHANGED
                        || e.getType() == TYPE_VIEW_TREE_APPEARING
                        || e.getType() == TYPE_VIEW_TREE_APPEARED
        ).collect(Collectors.toList());
    }

    /**
     * Asserts that a session for the given activity has events at all.
     */
    public static void assertNoEvents(@NonNull Session session,
            @NonNull ComponentName componentName) {
        assertRightActivity(session, session.id, componentName);
        assertThat(session.getEvents()).isEmpty();
    }

    /**
     * Asserts that the events received by the service optionally contains the
     * {@code TYPE_VIEW_DISAPPEARED} events, as they might have not been generated if the views
     * disappeared after the activity stopped.
     *
     * @param events events received by the service.
     * @param minimumSize size of events received if activity stopped before views disappeared
     * @param expectedIds ids of views that might have disappeared.
     *
     * @return whether the view disappeared events were generated
     */
    // TODO(b/123540067, 122315042): remove this method if we could make it deterministic, and
    // inline the assertions (or rename / change its logic)
    public static boolean assertViewsOptionallyDisappeared(
            @NonNull List<ContentCaptureEvent> events, int minimumSize,
            @NonNull AutofillId... expectedIds) {
        final int actualSize = events.size();
        final int disappearedEventIndex;
        if (actualSize == minimumSize) {
            // Activity stopped before TYPE_VIEW_DISAPPEARED were sent.
            return false;
        } else if (actualSize == minimumSize + 1) {
            // Activity did not receive TYPE_VIEW_TREE_APPEARING and TYPE_VIEW_TREE_APPEARED.
            disappearedEventIndex = minimumSize;
        } else {
            disappearedEventIndex = minimumSize + 1;
        }
        final ContentCaptureEvent batchDisappearEvent = events.get(disappearedEventIndex);

        if (expectedIds.length == 1) {
            assertWithMessage("Should have just one deleted id on %s", batchDisappearEvent)
                    .that(batchDisappearEvent.getIds()).isNull();
            assertWithMessage("wrong deleted id on %s", batchDisappearEvent)
                    .that(batchDisappearEvent.getId()).isEqualTo(expectedIds[0]);
        } else {
            assertWithMessage("Should not have individual deleted id on %s", batchDisappearEvent)
                    .that(batchDisappearEvent.getId()).isNull();
            final List<AutofillId> actualIds = batchDisappearEvent.getIds();
            assertWithMessage("wrong deleteds id on %s", batchDisappearEvent)
                    .that(actualIds).containsExactly((Object[]) expectedIds);
        }
        return true;
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event, without checking for parent
     */
    public static void assertViewWithUnknownParentAppeared(
            @NonNull List<ContentCaptureEvent> events, int index,
            @NonNull ContentCaptureSessionId expectedSessionId, @NonNull View expectedView) {
        assertViewWithUnknownParentAppeared(events, index, expectedView);
        assertSessionId(expectedSessionId, expectedView);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_DISAPPEARED} event for a single view.
     */
    public static void assertViewDisappeared(@NonNull List<ContentCaptureEvent> events, int index,
            @NonNull AutofillId expectedId) {
        final ContentCaptureEvent event = assertCommonViewDisappearedProperties(events, index);
        assertWithMessage("wrong autofillId on event %s (index %s)", event, index)
            .that(event.getId()).isEqualTo(expectedId);
        assertWithMessage("event %s (index %s) should not have autofillIds", event, index)
            .that(event.getIds()).isNull();
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_DISAPPEARED} event for multiple views.
     */
    public static void assertViewsDisappeared(@NonNull List<ContentCaptureEvent> events, int index,
            @NonNull AutofillId... expectedIds) {
        final ContentCaptureEvent event = assertCommonViewDisappearedProperties(events, index);
        final List<AutofillId> ids = event.getIds();
        assertWithMessage("no autofillIds on event %s (index %s)", event, index).that(ids)
                .isNotNull();
        assertWithMessage("wrong autofillId on event %s (index %s)", event, index)
            .that(ids).containsExactly((Object[]) expectedIds).inOrder();
        assertWithMessage("event %s (index %s) should not have autofillId", event, index)
            .that(event.getId()).isNull();
    }

    private static ContentCaptureEvent assertCommonViewDisappearedProperties(
            @NonNull List<ContentCaptureEvent> events, int index) {
        final ContentCaptureEvent event = getEvent(events, index, TYPE_VIEW_DISAPPEARED);
        assertWithMessage("event %s (index %s) should not have a ViewNode", event, index)
                .that(event.getViewNode()).isNull();
        assertWithMessage("event %s (index %s) should not have text", event, index)
                .that(event.getText()).isNull();
        return event;
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_APPEARED} event for a virtual node.
     */
    public static void assertVirtualViewAppeared(@NonNull List<ContentCaptureEvent> events,
            int index, @NonNull ContentCaptureSession session, @NonNull AutofillId parentId,
            int childId, @Nullable String expectedText) {
        final ContentCaptureEvent event = getEvent(events, index, TYPE_VIEW_APPEARED);
        final ViewNode node = event.getViewNode();
        assertThat(node).isNotNull();
        final AutofillId expectedId = session.newAutofillId(parentId, childId);
        assertWithMessage("wrong autofill id on %s (index %s)", event, index)
            .that(node.getAutofillId()).isEqualTo(expectedId);
        if (expectedText != null) {
            assertWithMessage("wrong text on %s(index %s) ", event, index)
                .that(node.getText().toString()).isEqualTo(expectedText);
        } else {
            assertWithMessage("%s (index %s) should not have text", node, index)
                .that(node.getText()).isNull();
        }
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_DISAPPEARED} event for a virtual node.
     */
    public static void assertVirtualViewDisappeared(@NonNull List<ContentCaptureEvent> events,
            int index, @NonNull AutofillId parentId, @NonNull ContentCaptureSession session,
            long childId) {
        assertViewDisappeared(events, index, session.newAutofillId(parentId, childId));
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_DISAPPEARED} event for many virtual nodes.
     */
    public static void assertVirtualViewsDisappeared(@NonNull List<ContentCaptureEvent> events,
            int index, @NonNull AutofillId parentId, @NonNull ContentCaptureSession session,
            long... childrenIds) {
        final int size = childrenIds.length;
        final AutofillId[] expectedIds = new AutofillId[size];
        for (int i = 0; i < childrenIds.length; i++) {
            expectedIds[i] = session.newAutofillId(parentId, childrenIds[i]);
        }
        assertViewsDisappeared(events, index, expectedIds);
    }

    /**
     * Asserts a view has the given session id.
     */
    public static void assertSessionId(@NonNull ContentCaptureSessionId expectedSessionId,
            @NonNull View view) {
        assertThat(expectedSessionId).isNotNull();
        final ContentCaptureSession session = view.getContentCaptureSession();
        assertWithMessage("no session for view %s", view).that(session).isNotNull();
        assertWithMessage("wrong session id for for view %s", view)
                .that(session.getContentCaptureSessionId()).isEqualTo(expectedSessionId);
    }

    /**
     * Asserts the contents of a {@link #TYPE_VIEW_TEXT_CHANGED} event.
     */
    public static void assertViewTextChanged(@NonNull List<ContentCaptureEvent> events, int index,
            @NonNull AutofillId expectedId, @NonNull String expectedText) {
        final ContentCaptureEvent event = getEvent(events, index, TYPE_VIEW_TEXT_CHANGED);
        assertWithMessage("Wrong id on %s (%s)", event, index).that(event.getId())
                .isEqualTo(expectedId);
        assertWithMessage("Wrong text on %s (%s)", event, index).that(event.getText().toString())
                .isEqualTo(expectedText);
    }

    /**
     * Asserts the existence and contents of a {@link #TYPE_VIEW_INSETS_CHANGED} event.
     */
    public static void assertViewInsetsChanged(@NonNull List<ContentCaptureEvent> events) {
        boolean insetsEventFound = false;
        for (ContentCaptureEvent event : events) {
            if (event.getType() == TYPE_VIEW_INSETS_CHANGED) {
                assertWithMessage("Expected view insets to be non-null on %s", event)
                    .that(event.getInsets()).isNotNull();
                insetsEventFound = true;
            }
        }

        if (!insetsEventFound) {
            throw new RetryableException(
                String.format(
                    "Expected at least one VIEW_INSETS_CHANGED event in the set of events %s",
                    events));
        }
    }

    /**
     * Asserts the existence and contents of a {@link #TYPE_WINDOW_BOUNDS_CHANGED} event.
     */
    public static void assertWindowBoundsChanged(@NonNull List<ContentCaptureEvent> events) {
        boolean boundsEventFound = false;
        for (ContentCaptureEvent event : events) {
            if (event.getType() == TYPE_WINDOW_BOUNDS_CHANGED) {
                assertWithMessage("Expected window bounds to be non-null on %s", event)
                        .that(event.getBounds()).isNotNull();
                boundsEventFound = true;
            }
        }

        if (!boundsEventFound) {
            throw new RetryableException(
                String.format(
                        "Expected at least one WINDOW_BOUNDS_CHANGED event in the set of events %s",
                        events));
        }
    }

    /**
     * Asserts the basic contents of a {@link #TYPE_CONTEXT_UPDATED} event.
     */
    public static ContentCaptureEvent assertContextUpdated(
            @NonNull List<ContentCaptureEvent> events, int index) {
        final ContentCaptureEvent event = getEvent(events, index, TYPE_CONTEXT_UPDATED);
        assertWithMessage("event %s (index %s) should not have a ViewNode", event, index)
                .that(event.getViewNode()).isNull();
        assertWithMessage("event %s (index %s) should not have text", event, index)
                .that(event.getViewNode()).isNull();
        assertWithMessage("event %s (index %s) should not have an autofillId", event, index)
                .that(event.getId()).isNull();
        assertWithMessage("event %s (index %s) should not have autofillIds", event, index)
                .that(event.getIds()).isNull();
        return event;
    }

    /**
     * Asserts the order a session was created or destroyed.
     */
    public static void assertLifecycleOrder(int expectedOrder, @NonNull Session session,
            @NonNull LifecycleOrder type) {
        switch(type) {
            case CREATION:
                assertWithMessage("Wrong order of creation for session %s", session)
                    .that(session.creationOrder).isEqualTo(expectedOrder);
                break;
            case DESTRUCTION:
                assertWithMessage("Wrong order of destruction for session %s", session)
                    .that(session.destructionOrder).isEqualTo(expectedOrder);
                break;
            default:
                throw new IllegalArgumentException("Invalid type: " + type);
        }
    }

    /**
     * Gets the event at the given index, failing with the user-friendly message if necessary...
     */
    @NonNull
    private static ContentCaptureEvent getEvent(@NonNull List<ContentCaptureEvent> events,
            int index, int expectedType) {
        assertWithMessage("events is null").that(events).isNotNull();
        final ContentCaptureEvent event = events.get(index);
        assertWithMessage("no event at index %s (size %s): %s", index, events.size(), events)
                .that(event).isNotNull();
        final int actualType = event.getType();
        if (actualType != expectedType) {
            throw new AssertionError(String.format(
                    "wrong event type (expected %s, actual is %s) at index %s: %s",
                    eventTypeAsString(expectedType), eventTypeAsString(actualType), index, event));
        }
        assertWithMessage("invalid time on %s (index %s)", event, index).that(event.getEventTime())
                 .isAtLeast(MY_EPOCH);
        return event;
    }

    /**
     * Gets an user-friendly description of the given event type.
     */
    @NonNull
    public static String eventTypeAsString(int type) {
        final String string;
        switch (type) {
            case TYPE_VIEW_APPEARED:
                string = "APPEAR";
                break;
            case TYPE_VIEW_DISAPPEARED:
                string = "DISAPPEAR";
                break;
            case TYPE_VIEW_TEXT_CHANGED:
                string = "TEXT_CHANGE";
                break;
            case TYPE_VIEW_TREE_APPEARING:
                string = "TREE_START";
                break;
            case TYPE_VIEW_TREE_APPEARED:
                string = "TREE_END";
                break;
            case TYPE_SESSION_PAUSED:
                string = "PAUSED";
                break;
            case TYPE_SESSION_RESUMED:
                string = "RESUMED";
                break;
            case TYPE_WINDOW_BOUNDS_CHANGED:
                string = "WINDOW_BOUNDS";
                break;
            case TYPE_SESSION_FLUSH:
                string = "SESSION_FLUSH";
                break;
            default:
                return "UNKNOWN-" + type;
        }
        return String.format("%s-%d", string, type);
    }

    private Assertions() {
        throw new UnsupportedOperationException("contain static methods only");
    }

    public enum LifecycleOrder {
        CREATION, DESTRUCTION
    }
}