Backed out 2 changesets (bug 1457863) for merge conflict on a CLOSED TREE
authorshindli <shindli@mozilla.com>
Wed, 02 May 2018 01:54:08 +0300
changeset 416455 6340700abe0f9639891ed8498287b9c5b8bcf545
parent 416454 c91dda92242abf7f072485bb97bc7a0f05df500a
child 416456 c4e3dcdb87c6fa0340d9809ad20804e021a94c37
push id33928
push usercsabou@mozilla.com
push dateWed, 02 May 2018 09:26:14 +0000
treeherdermozilla-central@d28c45ebedcc [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs1457863
milestone61.0a1
backs outa9e4a1af13b92a150a30dd9d89f12c9c4e2e97e4
d4e8c9ea8f0e7041cde174758867bd85d6f1c5b7
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 2 changesets (bug 1457863) for merge conflict on a CLOSED TREE Backed out changeset a9e4a1af13b9 (bug 1457863) Backed out changeset d4e8c9ea8f0e (bug 1457863)
build.gradle
mobile/android/geckoview/build.gradle
mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/GeckoSessionTestRuleTest.kt
mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/NavigationDelegateTest.kt
mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/ProgressDelegateTest.kt
--- a/build.gradle
+++ b/build.gradle
@@ -45,17 +45,17 @@ buildscript {
             }
         }
         // For in tree plugins.
         maven {
             url "file://${gradle.mozconfig.topsrcdir}/mobile/android/gradle/m2repo"
         }
     }
 
-    ext.kotlin_version = '1.2.20'
+    ext.kotlin_version = '1.1.51'
     ext.support_library_version = '23.4.0'
 
     if (gradle.mozconfig.substs.MOZ_ANDROID_GOOGLE_PLAY_SERVICES) {
         ext.google_play_services_version = '8.4.0'
     }
 
     dependencies {
         classpath 'com.android.tools.build:gradle:3.0.1'
--- a/mobile/android/geckoview/build.gradle
+++ b/mobile/android/geckoview/build.gradle
@@ -165,20 +165,16 @@ tasks.withType(org.jetbrains.kotlin.grad
             }
             def (_, type, file, line, column, message) = matches[0]
             type = (type == 'w') ? 'warning' : 'error'
             // Use logger.lifecycle, which does not go through stderr again.
             logger.lifecycle "$file:$line:$column: $type: $message"
         }
     } as StandardOutputListener
 
-    kotlinOptions {
-        allWarningsAsErrors = true
-    }
-
     doFirst {
         logging.addStandardErrorListener(listener)
     }
     doLast {
         logging.removeStandardErrorListener(listener)
     }
 }
 
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/GeckoSessionTestRuleTest.kt
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/GeckoSessionTestRuleTest.kt
@@ -312,17 +312,17 @@ class GeckoSessionTestRuleTest : BaseSes
 
     @Test fun waitUntilCalled_currentCall() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.session.reload()
 
         var counter = 0
 
         sessionRule.waitUntilCalled(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 2, order = [1, 2])
+            @AssertCalled(count = 2, order = intArrayOf(1, 2))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 val info = sessionRule.currentCall
                 assertThat("Method info should be valid", info, notNullValue())
                 assertThat("Counter should be correct",
                            info.counter, equalTo(forEachCall(1, 2)))
                 assertThat("Order should equal counter",
                            info.order, equalTo(info.counter))
                 counter++
@@ -457,70 +457,70 @@ class GeckoSessionTestRuleTest : BaseSes
         })
     }
 
     @Test fun forCallbacksDuringWait_specificOrder() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(order = [1])
+            @AssertCalled(order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
             }
 
-            @AssertCalled(order = [2])
+            @AssertCalled(order = intArrayOf(2))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
             }
         })
     }
 
     @Test(expected = AssertionError::class)
     fun forCallbacksDuringWait_throwOnWrongOrder() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(order = [2])
+            @AssertCalled(order = intArrayOf(2))
             override fun onPageStart(session: GeckoSession, url: String) {
             }
 
-            @AssertCalled(order = [1])
+            @AssertCalled(order = intArrayOf(1))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
             }
         })
     }
 
     @Test fun forCallbacksDuringWait_multipleOrder() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.session.reload()
         sessionRule.waitForPageStops(2)
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(order = [1, 3, 1])
+            @AssertCalled(order = intArrayOf(1, 3, 1))
             override fun onPageStart(session: GeckoSession, url: String) {
             }
 
-            @AssertCalled(order = [2, 4, 1])
+            @AssertCalled(order = intArrayOf(2, 4, 1))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
             }
         })
     }
 
     @Test(expected = AssertionError::class)
     fun forCallbacksDuringWait_throwOnWrongMultipleOrder() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.session.reload()
         sessionRule.waitForPageStops(2)
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(order = [1, 2, 1])
+            @AssertCalled(order = intArrayOf(1, 2, 1))
             override fun onPageStart(session: GeckoSession, url: String) {
             }
 
-            @AssertCalled(order = [3, 4, 1])
+            @AssertCalled(order = intArrayOf(3, 4, 1))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
             }
         })
     }
 
     @Test fun forCallbacksDuringWait_notCalled() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
@@ -659,22 +659,22 @@ class GeckoSessionTestRuleTest : BaseSes
     fun getCurrentCall_throwOnNoCurrentCall() {
         sessionRule.currentCall
     }
 
     @Test fun delegateUntilTestEnd() {
         var counter = 0
 
         sessionRule.delegateUntilTestEnd(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 counter++
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 counter++
             }
         })
 
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
@@ -703,21 +703,21 @@ class GeckoSessionTestRuleTest : BaseSes
 
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
     }
 
     @Test(expected = AssertionError::class)
     fun delegateUntilTestEnd_throwOnWrongOrder() {
         sessionRule.delegateUntilTestEnd(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onPageStart(session: GeckoSession, url: String) {
             }
 
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
             }
         })
 
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
     }
 
@@ -737,22 +737,22 @@ class GeckoSessionTestRuleTest : BaseSes
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
     }
 
     @Test fun delegateDuringNextWait() {
         var counter = 0
 
         sessionRule.delegateDuringNextWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 counter++
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 counter++
             }
         })
 
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
@@ -780,44 +780,44 @@ class GeckoSessionTestRuleTest : BaseSes
     }
 
     @Test fun delegateDuringNextWait_hasPrecedence() {
         var testCounter = 0
         var waitCounter = 0
 
         sessionRule.delegateUntilTestEnd(object : Callbacks.ProgressDelegate,
                                                   Callbacks.NavigationDelegate {
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onPageStart(session: GeckoSession, url: String) {
                 testCounter++
             }
 
-            @AssertCalled(count = 1, order = [4])
+            @AssertCalled(count = 1, order = intArrayOf(4))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 testCounter++
             }
 
-            @AssertCalled(count = 2, order = [1, 3])
+            @AssertCalled(count = 2, order = intArrayOf(1, 3))
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
                 testCounter++
             }
 
-            @AssertCalled(count = 2, order = [1, 3])
+            @AssertCalled(count = 2, order = intArrayOf(1, 3))
             override fun onCanGoForward(session: GeckoSession, canGoForward: Boolean) {
                 testCounter++
             }
         })
 
         sessionRule.delegateDuringNextWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 waitCounter++
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 waitCounter++
             }
         })
 
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/NavigationDelegateTest.kt
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/NavigationDelegateTest.kt
@@ -21,44 +21,44 @@ import org.junit.runner.RunWith
 @MediumTest
 class NavigationDelegateTest : BaseSessionTest() {
 
     @Test fun load() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.NavigationDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onLoadRequest(session: GeckoSession, uri: String,
                                        where: Int,
                                        flags: Int,
                                        response: GeckoResponse<Boolean>) {
                 assertThat("Session should not be null", session, notNullValue())
                 assertThat("URI should not be null", uri, notNullValue())
                 assertThat("URI should match", uri, endsWith(HELLO_HTML_PATH))
                 assertThat("Where should not be null", where, notNullValue())
                 assertThat("Where should match", where,
                            equalTo(GeckoSession.NavigationDelegate.TARGET_WINDOW_CURRENT))
                 response.respond(false)
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onLocationChange(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])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
                 assertThat("Session should not be null", session, notNullValue())
                 assertThat("Cannot go back", canGoBack, equalTo(false))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoForward(session: GeckoSession, canGoForward: Boolean) {
                 assertThat("Session should not be null", session, notNullValue())
                 assertThat("Cannot go forward", canGoForward, equalTo(false))
             }
 
             @AssertCalled(false)
             override fun onNewSession(session: GeckoSession, uri: String,
                                       response: GeckoResponse<GeckoSession>) {
@@ -193,38 +193,38 @@ class NavigationDelegateTest : BaseSessi
     @Test fun reload() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.session.reload()
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.NavigationDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onLoadRequest(session: GeckoSession, uri: String,
                                        where: Int,
                                        flags: Int,
                                        response: GeckoResponse<Boolean>) {
                 assertThat("URI should match", uri, endsWith(HELLO_HTML_PATH))
                 assertThat("Where should match", where,
                            equalTo(GeckoSession.NavigationDelegate.TARGET_WINDOW_CURRENT))
                 response.respond(false)
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onLocationChange(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
                 assertThat("Cannot go back", canGoBack, equalTo(false))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoForward(session: GeckoSession, canGoForward: Boolean) {
                 assertThat("Cannot go forward", canGoForward, equalTo(false))
             }
 
             @AssertCalled(false)
             override fun onNewSession(session: GeckoSession, uri: String,
                                       response: GeckoResponse<GeckoSession>) {
             }
@@ -244,74 +244,74 @@ class NavigationDelegateTest : BaseSessi
                 assertThat("URL should match", url, endsWith(HELLO2_HTML_PATH))
             }
         })
 
         sessionRule.session.goBack()
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.NavigationDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onLoadRequest(session: GeckoSession, uri: String,
                                        where: Int,
                                        flags: Int,
                                        response: GeckoResponse<Boolean>) {
                 assertThat("URI should match", uri, endsWith(HELLO_HTML_PATH))
                 assertThat("Where should match", where,
                            equalTo(GeckoSession.NavigationDelegate.TARGET_WINDOW_CURRENT))
                 response.respond(false)
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onLocationChange(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
                 assertThat("Cannot go back", canGoBack, equalTo(false))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoForward(session: GeckoSession, canGoForward: Boolean) {
                 assertThat("Can go forward", canGoForward, equalTo(true))
             }
 
             @AssertCalled(false)
             override fun onNewSession(session: GeckoSession, uri: String,
                                       response: GeckoResponse<GeckoSession>) {
             }
         })
 
         sessionRule.session.goForward()
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.NavigationDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onLoadRequest(session: GeckoSession, uri: String,
                                        where: Int,
                                        flags: Int,
                                        response: GeckoResponse<Boolean>) {
                 assertThat("URI should match", uri, endsWith(HELLO2_HTML_PATH))
                 assertThat("Where should match", where,
                            equalTo(GeckoSession.NavigationDelegate.TARGET_WINDOW_CURRENT))
                 response.respond(false)
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onLocationChange(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO2_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoBack(session: GeckoSession, canGoBack: Boolean) {
                 assertThat("Can go back", canGoBack, equalTo(true))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onCanGoForward(session: GeckoSession, canGoForward: Boolean) {
                 assertThat("Cannot go forward", canGoForward, equalTo(false))
             }
 
             @AssertCalled(false)
             override fun onNewSession(session: GeckoSession, uri: String,
                                       response: GeckoResponse<GeckoSession>) {
             }
@@ -329,22 +329,22 @@ class NavigationDelegateTest : BaseSessi
             }
         })
 
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.session.loadTestPath(HELLO2_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO2_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 assertThat("Load should succeed", success, equalTo(true))
             }
         })
     }
 
     @WithDisplay(width = 128, height = 128)
     @Test fun onNewSession_calledForNewWindow() {
--- a/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/ProgressDelegateTest.kt
+++ b/mobile/android/geckoview/src/androidTest/java/org/mozilla/geckoview/test/ProgressDelegateTest.kt
@@ -22,36 +22,36 @@ import org.junit.runner.RunWith
 @MediumTest
 class ProgressDelegateTest : BaseSessionTest() {
 
     @Test fun load() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(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])
+            @AssertCalled(count = 1, order = intArrayOf(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))
                 assertThat("Tracking mode should match",
                            securityInfo.trackingMode,
                            equalTo(GeckoSession.ProgressDelegate.SecurityInformation.CONTENT_UNKNOWN))
             }
 
-            @AssertCalled(count = 1, order = [3])
+            @AssertCalled(count = 1, order = intArrayOf(3))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 assertThat("Session should not be null", session, notNullValue())
                 assertThat("Load should succeed", success, equalTo(true))
             }
         })
     }
 
     fun loadExpectNetError(testUri: String) {
@@ -88,23 +88,23 @@ class ProgressDelegateTest : BaseSession
     }
 
     @Test fun multipleLoads() {
         sessionRule.session.loadUri(INVALID_URI)
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStops(2)
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 2, order = [1, 3])
+            @AssertCalled(count = 2, order = intArrayOf(1, 3))
             override fun onPageStart(session: GeckoSession, url: String) {
                 assertThat("URL should match", url,
                            endsWith(forEachCall(INVALID_URI, HELLO_HTML_PATH)))
             }
 
-            @AssertCalled(count = 2, order = [2, 4])
+            @AssertCalled(count = 2, order = intArrayOf(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)))
             };
         })
     }
@@ -112,74 +112,74 @@ class ProgressDelegateTest : BaseSession
     @Test fun reload() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.session.reload()
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onSecurityChange(session: GeckoSession,
                                           securityInfo: GeckoSession.ProgressDelegate.SecurityInformation) {
             }
 
-            @AssertCalled(count = 1, order = [3])
+            @AssertCalled(count = 1, order = intArrayOf(3))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 assertThat("Load should succeed", success, equalTo(true))
             }
         })
     }
 
     @Test fun goBackAndForward() {
         sessionRule.session.loadTestPath(HELLO_HTML_PATH)
         sessionRule.waitForPageStop()
         sessionRule.session.loadTestPath(HELLO2_HTML_PATH)
         sessionRule.waitForPageStop()
 
         sessionRule.session.goBack()
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onSecurityChange(session: GeckoSession,
                                           securityInfo: GeckoSession.ProgressDelegate.SecurityInformation) {
             }
 
-            @AssertCalled(count = 1, order = [3])
+            @AssertCalled(count = 1, order = intArrayOf(3))
             override fun onPageStop(session: GeckoSession, success: Boolean) {
                 assertThat("Load should succeed", success, equalTo(true))
             }
         })
 
         sessionRule.session.goForward()
         sessionRule.waitForPageStop()
 
         sessionRule.forCallbacksDuringWait(object : Callbacks.ProgressDelegate {
-            @AssertCalled(count = 1, order = [1])
+            @AssertCalled(count = 1, order = intArrayOf(1))
             override fun onPageStart(session: GeckoSession, url: String) {
                 assertThat("URL should match", url, endsWith(HELLO2_HTML_PATH))
             }
 
-            @AssertCalled(count = 1, order = [2])
+            @AssertCalled(count = 1, order = intArrayOf(2))
             override fun onSecurityChange(session: GeckoSession,
                                           securityInfo: GeckoSession.ProgressDelegate.SecurityInformation) {
             }
 
-            @AssertCalled(count = 1, order = [3])
+            @AssertCalled(count = 1, order = intArrayOf(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))