/* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
 * Any copyright is dedicated to the Public Domain.
   http://creativecommons.org/publicdomain/zero/1.0/ */

package org.mozilla.geckoview.test

import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
import androidx.test.filters.MediumTest
import junit.framework.TestCase.assertTrue
import org.hamcrest.Matchers.closeTo
import org.hamcrest.Matchers.endsWith
import org.hamcrest.Matchers.equalTo
import org.hamcrest.Matchers.greaterThan
import org.hamcrest.Matchers.greaterThanOrEqualTo
import org.hamcrest.Matchers.lessThan
import org.hamcrest.Matchers.lessThanOrEqualTo
import org.hamcrest.Matchers.notNullValue
import org.json.JSONObject
import org.junit.Assume.assumeThat
import org.junit.Ignore
import org.junit.Test
import org.junit.runner.RunWith
import org.mozilla.geckoview.GeckoSession
import org.mozilla.geckoview.GeckoSession.NavigationDelegate
import org.mozilla.geckoview.GeckoSession.PermissionDelegate.ContentPermission
import org.mozilla.geckoview.GeckoSession.ProgressDelegate
import org.mozilla.geckoview.test.rule.GeckoSessionTestRule.AssertCalled
import org.mozilla.geckoview.test.rule.GeckoSessionTestRule.NullDelegate
import org.mozilla.geckoview.test.rule.GeckoSessionTestRule.WithDisplay

@RunWith(AndroidJUnit4::class)
@MediumTest
class ProgressDelegateTest : BaseSessionTest() {

    fun testProgress(path: String) {
        mainSession.loadTestPath(path)
        sessionRule.waitForPageStop()

        var counter = 0
        var lastProgress = -1

        sessionRule.forCallbacksDuringWait(object :
            ProgressDelegate,
            NavigationDelegate {
            @AssertCalled
            override fun onLocationChange(session: GeckoSession, url: String?, perms: MutableList<ContentPermission>, hasUserGesture: Boolean) {
                assertThat("LocationChange is called", url, endsWith(path))
            }

            @AssertCalled
            override fun onProgressChange(session: GeckoSession, progress: Int) {
                assertThat(
                    "Progress must be strictly increasing",
                    progress,
                    greaterThan(lastProgress),
                )
                lastProgress = progress
                counter++
            }

            @AssertCalled
            override fun onPageStart(session: GeckoSession, url: String) {
                assertThat("PageStart is called", url, endsWith(path))
            }

            @AssertCalled
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                assertThat("PageStop is called", success, equalTo(true))
            }
        })

        assertThat(
            "Callback should be called at least twice",
            counter,
            greaterThanOrEqualTo(2),
        )
        assertThat(
            "Last progress value should be 100",
            lastProgress,
            equalTo(100),
        )
    }

    @Test fun loadProgress() {
        testProgress(HELLO_HTML_PATH)
        // Test that loading the same path again still
        // results in the right progress events
        testProgress(HELLO_HTML_PATH)
        // Test that calling a different path works too
        testProgress(HELLO2_HTML_PATH)
    }

    @Test fun load() {
        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1, order = [1])
            override fun onPageStart(session: GeckoSession, url: String) {
                assertThat("Session should not be null", session, notNullValue())
                assertThat("URL should not be null", url, notNullValue())
                assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
            }

            @AssertCalled(count = 1, order = [2])
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
                assertThat("Session should not be null", session, notNullValue())
                assertThat("Security info should not be null", securityInfo, notNullValue())

                assertThat("Should not be secure", securityInfo.isSecure, equalTo(false))
            }

            @AssertCalled(count = 1, order = [3])
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                assertThat("Session should not be null", session, notNullValue())
                assertThat("Load should succeed", success, equalTo(true))
            }
        })
    }

    @Ignore("https://bugzilla.mozilla.org/show_bug.cgi?id=1988041")
    @Test
    fun multipleLoads() {
        mainSession.loadUri(UNKNOWN_HOST_URI)
        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStops(2)

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 2, order = [1, 3])
            override fun onPageStart(session: GeckoSession, url: String) {
                assertThat(
                    "URL should match",
                    url,
                    endsWith(forEachCall(UNKNOWN_HOST_URI, HELLO_HTML_PATH)),
                )
            }

            @AssertCalled(count = 2, order = [2, 4])
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                // The first load is certain to fail because of interruption by the second load
                // or by invalid domain name, whereas the second load is certain to succeed.
                assertThat(
                    "Success flag should match",
                    success,
                    equalTo(forEachCall(false, true)),
                )
            }
        })
    }

    @Test fun reload() {
        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()

        mainSession.reload()
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1, order = [1])
            override fun onPageStart(session: GeckoSession, url: String) {
                assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
            }

            @AssertCalled(count = 1, order = [2])
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
            }

            @AssertCalled(count = 1, order = [3])
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                assertThat("Load should succeed", success, equalTo(true))
            }
        })
    }

    @Ignore("https://bugzilla.mozilla.org/show_bug.cgi?id=1988041")
    @Test fun goBackAndForward() {
        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()
        mainSession.loadTestPath(HELLO2_HTML_PATH)
        sessionRule.waitForPageStop()

        mainSession.goBack()
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1, order = [1])
            override fun onPageStart(session: GeckoSession, url: String) {
                assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
            }

            @AssertCalled(count = 1, order = [2])
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
            }

            @AssertCalled(count = 1, order = [3])
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                assertThat("Load should succeed", success, equalTo(true))
            }
        })

        mainSession.goForward()
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1, order = [1])
            override fun onPageStart(session: GeckoSession, url: String) {
                assertThat("URL should match", url, endsWith(HELLO2_HTML_PATH))
            }

            @AssertCalled(count = 1, order = [2])
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
            }

            @AssertCalled(count = 1, order = [3])
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                assertThat("Load should succeed", success, equalTo(true))
            }
        })
    }

    @Test fun correctSecurityInfoForValidTLS_automation() {
        assumeThat(sessionRule.env.isAutomation, equalTo(true))

        mainSession.loadUri("https://example.com")
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
                assertThat(
                    "Should be secure",
                    securityInfo.isSecure,
                    equalTo(true),
                )
                assertThat(
                    "Should not be exception",
                    securityInfo.isException,
                    equalTo(false),
                )
                assertThat(
                    "Origin should match",
                    securityInfo.origin,
                    equalTo("https://example.com"),
                )
                assertThat(
                    "Host should match",
                    securityInfo.host,
                    equalTo("example.com"),
                )
                assertThat(
                    "Subject should match",
                    securityInfo.certificate?.subjectX500Principal?.name,
                    equalTo("CN=example.com"),
                )
                assertThat(
                    "Issuer should match",
                    securityInfo.certificate?.issuerX500Principal?.name,
                    equalTo("OU=Profile Guided Optimization,O=Mozilla Testing,CN=Temporary Certificate Authority"),
                )
                assertThat(
                    "Security mode should match",
                    securityInfo.securityMode,
                    equalTo(GeckoSession.ProgressDelegate.SecurityInformation.SECURITY_MODE_IDENTIFIED),
                )
                assertThat(
                    "Active mixed mode should match",
                    securityInfo.mixedModeActive,
                    equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
                )
                assertThat(
                    "Passive mixed mode should match",
                    securityInfo.mixedModePassive,
                    equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
                )
            }
        })
    }

    @LargeTest
    @Test
    fun correctSecurityInfoForValidTLS_local() {
        assumeThat(sessionRule.env.isAutomation, equalTo(false))

        mainSession.loadUri("https://mozilla-modern.badssl.com")
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
                assertThat(
                    "Should be secure",
                    securityInfo.isSecure,
                    equalTo(true),
                )
                assertThat(
                    "Should not be exception",
                    securityInfo.isException,
                    equalTo(false),
                )
                assertThat(
                    "Origin should match",
                    securityInfo.origin,
                    equalTo("https://mozilla-modern.badssl.com"),
                )
                assertThat(
                    "Host should match",
                    securityInfo.host,
                    equalTo("mozilla-modern.badssl.com"),
                )
                assertThat(
                    "Subject should match",
                    securityInfo.certificate?.subjectX500Principal?.name,
                    equalTo("CN=*.badssl.com,O=Lucas Garron,L=Walnut Creek,ST=California,C=US"),
                )
                assertThat(
                    "Issuer should match",
                    securityInfo.certificate?.issuerX500Principal?.name,
                    equalTo("CN=DigiCert SHA2 Secure Server CA,O=DigiCert Inc,C=US"),
                )
                assertThat(
                    "Security mode should match",
                    securityInfo.securityMode,
                    equalTo(GeckoSession.ProgressDelegate.SecurityInformation.SECURITY_MODE_IDENTIFIED),
                )
                assertThat(
                    "Active mixed mode should match",
                    securityInfo.mixedModeActive,
                    equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
                )
                assertThat(
                    "Passive mixed mode should match",
                    securityInfo.mixedModePassive,
                    equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN),
                )
            }
        })
    }

    @LargeTest
    @Test
    fun noSecurityInfoForExpiredTLS() {
        mainSession.loadUri(
            if (sessionRule.env.isAutomation) {
                "https://expired.example.com"
            } else {
                "https://expired.badssl.com"
            },
        )
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onPageStop(session: GeckoSession, success: Boolean) {
                assertThat("Load should fail", success, equalTo(false))
            }

            @AssertCalled(false)
            override fun onSecurityChange(
                session: GeckoSession,
                securityInfo: GeckoSession.ProgressDelegate.SecurityInformation,
            ) {
            }
        })
    }

    val errorEpsilon = 0.1

    private fun waitForScroll(offset: Double, timeout: Double, param: String) {
        mainSession.evaluateJS(
            """
           new Promise((resolve, reject) => {
             const start = Date.now();
             function step() {
               if (window.visualViewport.$param >= ($offset - $errorEpsilon)) {
                 resolve();
               } else if ($timeout < (Date.now() - start)) {
                 reject();
               } else {
                 window.requestAnimationFrame(step);
               }
             }
             window.requestAnimationFrame(step);
           });
            """.trimIndent(),
        )
    }

    private fun waitForVerticalScroll(offset: Double, timeout: Double) {
        waitForScroll(offset, timeout, "pageTop")
    }

    fun collectState(vararg uris: String): GeckoSession.SessionState {
        for (uri in uris) {
            mainSession.loadUri(uri)
            sessionRule.waitForPageStop()
        }

        mainSession.evaluateJS("document.querySelector('#name').value = 'the name';")
        mainSession.evaluateJS("document.querySelector('#name').dispatchEvent(new Event('input'));")

        mainSession.evaluateJS("window.scrollBy(0, 100);")
        waitForVerticalScroll(100.0, sessionRule.env.defaultTimeoutMillis.toDouble())

        var savedState: GeckoSession.SessionState? = null
        sessionRule.waitUntilCalled(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSessionStateChange(session: GeckoSession, state: GeckoSession.SessionState) {
                savedState = state

                val serialized = state.toString()
                val deserialized = GeckoSession.SessionState.fromString(serialized)
                assertThat("Deserialized session state should match", deserialized, equalTo(state))
            }
        })

        assertThat("State should not be null", savedState, notNullValue())
        return savedState!!
    }

    @WithDisplay(width = 400, height = 400)
    @Test
    fun containsFormData() {
        val startUri = createTestUrl(SAVE_STATE_PATH)
        mainSession.loadUri(startUri)
        sessionRule.waitForPageStop()

        val formData = mainSession.containsFormData()
        sessionRule.waitForResult(formData).let {
            assertThat("There should be no form data", it, equalTo(false))
        }

        mainSession.evaluateJS("document.querySelector('#name').value = 'the name';")
        mainSession.evaluateJS("document.querySelector('#name').dispatchEvent(new Event('input'));")

        val formData2 = mainSession.containsFormData()
        sessionRule.waitForResult(formData2).let {
            assertThat("There should be form data", it, equalTo(true))
        }
    }

    @Ignore("https://bugzilla.mozilla.org/show_bug.cgi?id=1988041")
    @WithDisplay(width = 400, height = 400)
    @Test
    fun saveAndRestoreStateNewSession() {
        val helloUri = createTestUrl(HELLO_HTML_PATH)
        val startUri = createTestUrl(SAVE_STATE_PATH)

        val savedState = collectState(helloUri, startUri)

        val session = sessionRule.createOpenSession()
        session.addDisplay(400, 400)

        session.restoreState(savedState)
        session.waitForPageStop()

        session.forCallbacksDuringWait(object : NavigationDelegate {
            @AssertCalled
            override fun onLocationChange(
                session: GeckoSession,
                url: String?,
                perms: MutableList<ContentPermission>,
                hasUserGesture: Boolean,
            ) {
                assertThat("URI should match", url, equalTo(startUri))
            }
        })

        /* TODO: Reenable when we have a workaround for ContentSessionStore not
                 saving in response to JS-driven formdata changes.
        assertThat("'name' field should match",
                mainSession.evaluateJS("$('#name').value").toString(),
                equalTo("the name"))*/

        assertThat(
            "Scroll position should match",
            session.evaluateJS("window.visualViewport.pageTop") as Double,
            closeTo(100.0, .5),
        )

        session.goBack()

        session.waitUntilCalled(object : NavigationDelegate {
            override fun onLocationChange(session: GeckoSession, url: String?, perms: MutableList<ContentPermission>, hasUserGesture: Boolean) {
                assertThat("History should be preserved", url, equalTo(helloUri))
            }
        })
    }

    @WithDisplay(width = 400, height = 400)
    @Test
    fun saveAndRestoreState() {
        // Bug 1662035 - disable to reduce intermittent failures
        assumeThat(sessionRule.env.isX86, equalTo(false))
        val startUri = createTestUrl(SAVE_STATE_PATH)
        val savedState = collectState(startUri)

        mainSession.loadUri("about:blank")
        sessionRule.waitForPageStop()

        mainSession.restoreState(savedState)
        sessionRule.waitForPageStop()

        sessionRule.forCallbacksDuringWait(object : NavigationDelegate {
            @AssertCalled
            override fun onLocationChange(session: GeckoSession, url: String?, perms: MutableList<ContentPermission>, hasUserGesture: Boolean) {
                assertThat("URI should match", url, equalTo(startUri))
            }
        })

        /* TODO: Reenable when we have a workaround for ContentSessionStore not
                 saving in response to JS-driven formdata changes.
        assertThat("'name' field should match",
                mainSession.evaluateJS("$('#name').value").toString(),
                equalTo("the name"))*/

        assertThat(
            "Scroll position should match",
            mainSession.evaluateJS("window.visualViewport.pageTop") as Double,
            closeTo(100.0, .5),
        )
    }

    @WithDisplay(width = 400, height = 400)
    @Test
    fun flushSessionState() {
        val startUri = createTestUrl(SAVE_STATE_PATH)
        mainSession.loadUri(startUri)
        sessionRule.waitForPageStop()

        var oldState: GeckoSession.SessionState? = null

        sessionRule.waitUntilCalled(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
                oldState = sessionState
            }
        })

        assertThat("State should not be null", oldState, notNullValue())

        mainSession.setActive(false)

        sessionRule.waitUntilCalled(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
                assertThat("Old session state and new should match", sessionState, equalTo(oldState))
            }
        })
    }

    @Test fun nullState() {
        val stateFromNull: GeckoSession.SessionState? = GeckoSession.SessionState.fromString(null)
        val nullState: GeckoSession.SessionState? = null
        assertThat("Null string should result in null state", stateFromNull, equalTo(nullState))
    }

    @NullDelegate(GeckoSession.HistoryDelegate::class)
    @Test
    fun noHistoryDelegateOnSessionStateChange() {
        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()

        sessionRule.waitUntilCalled(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
            }
        })
    }

    @Test
    fun getWebCompatInfo() {
        sessionRule.setPrefsUntilTestEnd(mapOf("browser.webcompat.geckoview.enableAllTestMocks" to true))

        val expectedResult = """{"devicePixelRatio":2.5,"antitracking":{"hasTrackingContentBlocked":false}}"""

        val info = mainSession.webCompatInfo
        assertThat("Result should match mocked web compat info", sessionRule.waitForResult(info).toString(), equalTo(expectedResult))
    }

    @Test
    fun getWebCompatInfoExampleSite() {
        val url = "https://www.mozilla.org/en-US/"
        mainSession.loadUri(url)
        sessionRule.waitForPageStop()
        val info = sessionRule.waitForResult(mainSession.webCompatInfo)
        val infoUrl = info.getString("url")

        assertThat("Result should match actual url", infoUrl, equalTo(url))
    }

    @Test
    fun getWebCompatInfoError() {
        // Catch an exception when no web page is loaded
        try {
            sessionRule.waitForResult(mainSession.webCompatInfo)
            assertThat("This test is expected to fail.", true, equalTo(false))
        } catch (error: Exception) {
            assertTrue("Expect an exception while getting web compat info.", true)
        }
    }

    @Test
    fun sendMoreWebCompatInfoSuccess() {
        sessionRule.setPrefsUntilTestEnd(mapOf("browser.webcompat.geckoview.enableAllTestMocks" to true))

        val testInfo = JSONObject().apply {
            put("reason", "test-reason")
            put("description", "test-description")
            put("endpointUrl", "https://webcompat.com/issues/new")
            put("reportUrl", "https://example.com")
        }

        try {
            sessionRule.waitForResult(mainSession.sendMoreWebCompatInfo(testInfo))
            assertTrue("sendMoreWebCompatInfo() should succeed.", true)
        } catch (error: Exception) {
            assertTrue("sendMoreWebCompatInfo() should not fail.", false)
        }
    }

    @Test
    fun pageLoadProgressCompletedAtPageStop() {
        sessionRule.setPrefsUntilTestEnd(mapOf("page_load.progressbar_completion" to 0))
        val progressChanges = mutableListOf<Int>()

        sessionRule.delegateUntilTestEnd(object : ProgressDelegate {
            @AssertCalled
            override fun onProgressChange(session: GeckoSession, progress: Int) {
                progressChanges.add(progress)
            }
        })

        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()

        val completionIndex = progressChanges.indexOf(100)
        assertThat("Must have more than 1 progress value", completionIndex, greaterThan(0))

        val lastProgressBeforeCompletion = progressChanges[completionIndex - 1]

        assertThat(
            "Last progress before completion should be less than or equal to 80",
            lastProgressBeforeCompletion,
            lessThanOrEqualTo(80),
        )
    }

    @Test
    fun pageLoadProgressCompletedAtDOMContentLoaded() {
        sessionRule.setPrefsUntilTestEnd(mapOf("page_load.progressbar_completion" to 1))
        val progressChanges = mutableListOf<Int>()

        sessionRule.delegateUntilTestEnd(object : ProgressDelegate {
            @AssertCalled
            override fun onProgressChange(session: GeckoSession, progress: Int) {
                progressChanges.add(progress)
            }
        })

        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()

        val completionIndex = progressChanges.indexOf(100)
        assertThat("Must have more than 1 progress value", completionIndex, greaterThan(0))

        val lastProgressBeforeCompletion = progressChanges[completionIndex - 1]

        assertThat(
            "Last progress before completion should be less than 55",
            lastProgressBeforeCompletion,
            lessThan(55),
        )
    }

    @Test
    fun pageLoadProgressCompletedAtMozAfterPaintAfterDOMContentLoaded() {
        sessionRule.setPrefsUntilTestEnd(mapOf("page_load.progressbar_completion" to 2))
        val progressChanges = mutableListOf<Int>()

        sessionRule.delegateUntilTestEnd(object : ProgressDelegate {
            @AssertCalled
            override fun onProgressChange(session: GeckoSession, progress: Int) {
                progressChanges.add(progress)
            }
        })

        mainSession.loadTestPath(HELLO_HTML_PATH)
        sessionRule.waitForPageStop()

        val completionIndex = progressChanges.indexOf(100)
        assertThat("Must have more than 1 progress value", completionIndex, greaterThan(0))

        val lastProgressBeforeCompletion = progressChanges[completionIndex - 1]

        assertThat(
            "Last progress before completion should be less than 80",
            lastProgressBeforeCompletion,
            lessThan(80),
        )
    }

    @Test fun flushSessionStateTriggersSessionStateChange() {
        mainSession.loadTestPath(HELLO_HTML_PATH)
        mainSession.waitForPageStop()

        var oldState: GeckoSession.SessionState? = null

        sessionRule.waitUntilCalled(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
                oldState = sessionState
            }
        })

        assertThat("State should not be null", oldState, notNullValue())

        mainSession.flushSessionState()

        sessionRule.waitUntilCalled(object : ProgressDelegate {
            @AssertCalled(count = 1)
            override fun onSessionStateChange(session: GeckoSession, sessionState: GeckoSession.SessionState) {
            }
        })
    }
}
