Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 007d6861 authored by Ale Nijamkin's avatar Ale Nijamkin Committed by Automerger Merge Worker
Browse files

Merge "Modernizes RepeatWhenAttachedTest." into udc-dev am: 03a1a8ed 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/22256693



Change-Id: I5b8d5ea5c6e7566b13a75e2e3102ffef618e0271
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 29086383 03a1a8ed

packages/SystemUI/tests/src/com/android/systemui/lifecycle/RepeatWhenAttachedTest.kt

+181 −138
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 


package com.android.systemui.lifecycle



import android.testing.TestableLooper.RunWithLooper

import android.view.View

import android.view.ViewTreeObserver

import androidx.lifecycle.Lifecycle
@@ -28,8 +27,16 @@ import com.android.systemui.util.Assert 
import com.android.systemui.util.mockito.argumentCaptor

import com.google.common.truth.Truth.assertThat

import kotlinx.coroutines.CoroutineScope

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.DisposableHandle

import kotlinx.coroutines.test.runBlockingTest

import kotlinx.coroutines.ExperimentalCoroutinesApi

import kotlinx.coroutines.test.StandardTestDispatcher

import kotlinx.coroutines.test.TestScope

import kotlinx.coroutines.test.resetMain

import kotlinx.coroutines.test.runCurrent

import kotlinx.coroutines.test.runTest

import kotlinx.coroutines.test.setMain

import org.junit.After

import org.junit.Before

import org.junit.Rule

import org.junit.Test
@@ -41,9 +48,9 @@ import org.mockito.Mockito.verify 
import org.mockito.Mockito.`when` as whenever

import org.mockito.junit.MockitoJUnit



@OptIn(ExperimentalCoroutinesApi::class)

@SmallTest

@RunWith(JUnit4::class)

@RunWithLooper

class RepeatWhenAttachedTest : SysuiTestCase() {



    @JvmField @Rule val mockito = MockitoJUnit.rule()
@@ -54,9 +61,13 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 


    private lateinit var block: Block

    private lateinit var attachListeners: MutableList<View.OnAttachStateChangeListener>

    private lateinit var testScope: TestScope



    @Before

    fun setUp() {

        val testDispatcher = StandardTestDispatcher()

        testScope = TestScope(testDispatcher)

        Dispatchers.setMain(testDispatcher)

        Assert.setTestThread(Thread.currentThread())

        whenever(view.viewTreeObserver).thenReturn(viewTreeObserver)

        whenever(view.windowVisibility).thenReturn(View.GONE)
@@ -71,15 +82,22 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
        block = Block()

    }



    @After

    fun tearDown() {

        Dispatchers.resetMain()

    }



    @Test(expected = IllegalStateException::class)

    fun `repeatWhenAttached - enforces main thread`() = runBlockingTest {

    fun `repeatWhenAttached - enforces main thread`() =

        testScope.runTest {

            Assert.setTestThread(null)



            repeatWhenAttached()

        }



    @Test(expected = IllegalStateException::class)

    fun `repeatWhenAttached - dispose enforces main thread`() = runBlockingTest {

    fun `repeatWhenAttached - dispose enforces main thread`() =

        testScope.runTest {

            val disposableHandle = repeatWhenAttached()

            Assert.setTestThread(null)
@@ -87,7 +105,8 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
        }



    @Test

    fun `repeatWhenAttached - view starts detached - runs block when attached`() = runBlockingTest {

    fun `repeatWhenAttached - view starts detached - runs block when attached`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(false)

            repeatWhenAttached()

            assertThat(block.invocationCount).isEqualTo(0)
@@ -95,56 +114,66 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
            whenever(view.isAttachedToWindow).thenReturn(true)

            attachListeners.last().onViewAttachedToWindow(view)



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.CREATED)

        }



    @Test

    fun `repeatWhenAttached - view already attached - immediately runs block`() = runBlockingTest {

    fun `repeatWhenAttached - view already attached - immediately runs block`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)



            repeatWhenAttached()



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.CREATED)

        }



    @Test

    fun `repeatWhenAttached - starts visible without focus - STARTED`() = runBlockingTest {

    fun `repeatWhenAttached - starts visible without focus - STARTED`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            whenever(view.windowVisibility).thenReturn(View.VISIBLE)



            repeatWhenAttached()



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.STARTED)

        }



    @Test

    fun `repeatWhenAttached - starts with focus but invisible - CREATED`() = runBlockingTest {

    fun `repeatWhenAttached - starts with focus but invisible - CREATED`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            whenever(view.hasWindowFocus()).thenReturn(true)



            repeatWhenAttached()



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.CREATED)

        }



    @Test

    fun `repeatWhenAttached - starts visible and with focus - RESUMED`() = runBlockingTest {

    fun `repeatWhenAttached - starts visible and with focus - RESUMED`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            whenever(view.windowVisibility).thenReturn(View.VISIBLE)

            whenever(view.hasWindowFocus()).thenReturn(true)



            repeatWhenAttached()



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.RESUMED)

        }



    @Test

    fun `repeatWhenAttached - becomes visible without focus - STARTED`() = runBlockingTest {

    fun `repeatWhenAttached - becomes visible without focus - STARTED`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            repeatWhenAttached()

            val listenerCaptor = argumentCaptor<ViewTreeObserver.OnWindowVisibilityChangeListener>()
@@ -153,12 +182,14 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
            whenever(view.windowVisibility).thenReturn(View.VISIBLE)

            listenerCaptor.value.onWindowVisibilityChanged(View.VISIBLE)



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.STARTED)

        }



    @Test

    fun `repeatWhenAttached - gains focus but invisible - CREATED`() = runBlockingTest {

    fun `repeatWhenAttached - gains focus but invisible - CREATED`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            repeatWhenAttached()

            val listenerCaptor = argumentCaptor<ViewTreeObserver.OnWindowFocusChangeListener>()
@@ -167,12 +198,14 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
            whenever(view.hasWindowFocus()).thenReturn(true)

            listenerCaptor.value.onWindowFocusChanged(true)



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.CREATED)

        }



    @Test

    fun `repeatWhenAttached - becomes visible and gains focus - RESUMED`() = runBlockingTest {

    fun `repeatWhenAttached - becomes visible and gains focus - RESUMED`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            repeatWhenAttached()

            val visibleCaptor = argumentCaptor<ViewTreeObserver.OnWindowVisibilityChangeListener>()
@@ -185,24 +218,28 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
            whenever(view.hasWindowFocus()).thenReturn(true)

            focusCaptor.value.onWindowFocusChanged(true)



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.RESUMED)

        }



    @Test

    fun `repeatWhenAttached - view gets detached - destroys the lifecycle`() = runBlockingTest {

    fun `repeatWhenAttached - view gets detached - destroys the lifecycle`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            repeatWhenAttached()



            whenever(view.isAttachedToWindow).thenReturn(false)

            attachListeners.last().onViewDetachedFromWindow(view)



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.DESTROYED)

        }



    @Test

    fun `repeatWhenAttached - view gets reattached - recreates a lifecycle`() = runBlockingTest {

    fun `repeatWhenAttached - view gets reattached - recreates a lifecycle`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            repeatWhenAttached()

            whenever(view.isAttachedToWindow).thenReturn(false)
@@ -211,25 +248,29 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
            whenever(view.isAttachedToWindow).thenReturn(true)

            attachListeners.last().onViewAttachedToWindow(view)



            runCurrent()

            assertThat(block.invocationCount).isEqualTo(2)

            assertThat(block.invocations[0].lifecycleState).isEqualTo(Lifecycle.State.DESTROYED)

            assertThat(block.invocations[1].lifecycleState).isEqualTo(Lifecycle.State.CREATED)

        }



    @Test

    fun `repeatWhenAttached - dispose attached`() = runBlockingTest {

    fun `repeatWhenAttached - dispose attached`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            val handle = repeatWhenAttached()



            handle.dispose()



            runCurrent()

            assertThat(attachListeners).isEmpty()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.DESTROYED)

        }



    @Test

    fun `repeatWhenAttached - dispose never attached`() = runBlockingTest {

    fun `repeatWhenAttached - dispose never attached`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(false)

            val handle = repeatWhenAttached()
@@ -240,13 +281,15 @@ class RepeatWhenAttachedTest : SysuiTestCase() { 
        }



    @Test

    fun `repeatWhenAttached - dispose previously attached now detached`() = runBlockingTest {

    fun `repeatWhenAttached - dispose previously attached now detached`() =

        testScope.runTest {

            whenever(view.isAttachedToWindow).thenReturn(true)

            val handle = repeatWhenAttached()

            attachListeners.last().onViewDetachedFromWindow(view)



            handle.dispose()



            runCurrent()

            assertThat(attachListeners).isEmpty()

            assertThat(block.invocationCount).isEqualTo(1)

            assertThat(block.latestLifecycleState).isEqualTo(Lifecycle.State.DESTROYED)