--- 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))