Merge pull request #1743 from NativeScript/feature/v8-10.3.22-perf

feature/v8 10.3.22 perf

Author: edusperoni

Diff for: build.dev.sh

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+# smaller version of build.sh that sets the commit hash to the current git commit hash and uses the package.json version
+
+echo "Ensure adb is in PATH"
+export PATH="$ANDROID_HOME/platform-tools:$PATH"
+adb version
+
+echo "Update submodule"
+git submodule update --init
+
+echo "Cleanup old build and test artefacts"
+rm -rf consoleLog.txt
+rm -rf test-app/dist/*.xml
+
+./gradlew cleanRuntime
+
+./gradlew -PgitCommitVersion=$(git rev-parse HEAD)
+cp dist/nativescript-android-*.tgz dist/nativescript-android.tgz
+

Diff for: package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nativescript/android",
   "description": "NativeScript for Android using v8",
-  "version": "8.4.0",
+  "version": "8.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/NativeScript/android.git"

Diff for: test-app/app/src/main/assets/app/mainpage.js

@@ -66,4 +66,6 @@ require("./tests/kotlin/extensions/testExtensionFunctionsSupport");
 require("./tests/kotlin/enums/testEnumsSupport");
 require("./tests/kotlin/access/testInternalLanguageFeaturesSupport");
 require("./tests/testPackagePrivate");
-require("./tests/kotlin/properties/testPropertiesSupport.js")
+require("./tests/kotlin/properties/testPropertiesSupport.js");
+require('./tests/testNativeTimers');
+require("./tests/console/logTests.js");

Diff for: test-app/app/src/main/assets/app/tests/console/logTests.js

@@ -0,0 +1,31 @@
+describe("Test JSONObject conversions", () => {
+    it("console.log with number param should not crash", () => {
+        console.log(123);
+    });
+
+    it("console.log with string param should not crash", () => {
+        console.log("123");
+    });
+
+    it("console.log with object param should not crash", () => {
+        console.log({ num: 123 });
+    });
+
+    it("console.log with function param should not crash", () => {
+        console.log(function() {});
+    });
+
+    it("console.log with arrow function param should not crash", () => {
+        console.log(() => {});
+    });
+
+    it("console.log with primitive array param should not crash", () => {
+        console.log([1, 2, 3]);
+    });
+
+    it("console.log with object array param should not crash", () => {
+        console.log([{
+            num: 123
+        }]);
+    });
+});

Diff for: test-app/app/src/main/assets/app/tests/exceptionHandlingTests.js

@@ -322,7 +322,7 @@ describe("Tests exception handling ", function () {
 
    // run this test only for API level bigger than 25 as we have handling there
    if(android.os.Build.VERSION.SDK_INT > 25 && android.os.Build.CPU_ABI != "x86" && android.os.Build.CPU_ABI != "x86_64") {
-       it("Should handle SIGABRT and throw a NativeScript exception when incorrectly calling JNI methods", function () {
+       xit("Should handle SIGABRT and throw a NativeScript exception when incorrectly calling JNI methods", function () {
            let myClassInstance = new com.tns.tests.MyTestBaseClass3();
            // public void callMeWithAString(java.lang.String[] stringArr, Runnable arbitraryInterface)
            try {

Diff for: test-app/app/src/main/assets/app/tests/testNativeTimers.js

@@ -0,0 +1,126 @@
+describe('native timer', () => {
+    
+    /** @type {global.setTimeout} */
+    let setTimeout = global.__ns__setTimeout; 
+    /** @type {global.setInterval} */
+    let setInterval = global.__ns__setInterval; /** @type global.setTimeout */
+    /** @type {global.clearTimeout} */
+    let clearTimeout = global.__ns__clearTimeout;
+    /** @type {global.clearInterval} */
+    let clearInterval = global.__ns__clearInterval;
+
+    it('exists', () => {
+        expect(setTimeout).toBeDefined();
+        expect(setInterval).toBeDefined();
+        expect(clearTimeout).toBeDefined();
+        expect(clearInterval).toBeDefined();
+    });
+
+    it('triggers timeout', (done) => {
+        const now = Date.now();
+        setTimeout(() => {
+            expect(Date.now() - now).not.toBeLessThan(100);
+            done();
+        }, 100);
+    });
+
+    it('triggers timeout', (done) => {
+        const now = Date.now();
+        setTimeout(() => {
+            expect(Date.now() - now).not.toBeLessThan(100);
+            done();
+        }, 100);
+    });
+
+    it('triggers interval', (done) => {
+        let calls = 0;
+        const itv = setInterval(() => {
+            calls++;
+        }, 100);
+        setTimeout(() => {
+            clearInterval(itv);
+            expect(calls).toBe(10);
+            done();
+        }, 1000);
+    });
+
+    it('cancels timeout', (done) => {
+        let triggered = false;
+        const now = Date.now();
+        const timeout = setTimeout(() => {
+            triggered = true;
+        }, 100);
+        clearTimeout(timeout);
+        setTimeout(() => {
+            expect(triggered).toBe(false);
+            done();
+        }, 200);
+    });
+
+    it('cancels interval', (done) => {
+        let triggered = false;
+        const now = Date.now();
+        const timeout = setInterval(() => {
+            triggered = true;
+        }, 100);
+        clearInterval(timeout);
+        setTimeout(() => {
+            expect(triggered).toBe(false);
+            done();
+        }, 200);
+    });
+
+    it('cancels interval inside function', (done) => {
+        let calls = 0;
+        const itv = setInterval(() => {
+            calls++;
+            clearInterval(itv);
+        }, 10);
+        setTimeout(() => {
+            expect(calls).toBe(1);
+            done();
+        }, 100);
+    });
+
+    it('preserves order', (done) => {
+        let calls = 0;
+        setTimeout(() => {
+            expect(calls).toBe(0);
+            calls++;
+        });
+        setTimeout(() => {
+            expect(calls).toBe(1);
+            calls++;
+            done();
+        });
+    });
+    it('frees up resources after complete', (done) => {
+        let timeout = 0;
+        let interval = 0;
+        let weakRef;
+        {
+            let obj = {
+                value: 0
+            };
+            weakRef = new WeakRef(obj);
+            timeout = setTimeout(() => {
+                obj.value++;
+            }, 100);
+            interval = setInterval(() => {
+                obj.value++;
+            }, 50);
+        }
+        setTimeout(() => {
+            // use !! here because if you pass weakRef.get() it creates a strong reference (side effect of expect)
+            expect(!!weakRef.get()).toBe(true);
+            clearInterval(interval);
+            clearTimeout(timeout);
+            // use another timeout as native weakrefs can't be gced until we leave the isolate after being used once
+            setTimeout(() => {
+                gc();
+                expect(!!weakRef.get()).toBe(false);
+                done();
+            })
+        }, 200);
+    })
+});