feat: Add maxBuffer configuration for command output in iOS and macOS test scripts

DjDeveloperr · DjDeveloperr · commit 3368c984aa52 · 2026-02-26T00:04:26.000-05:00
diff --git a/NativeScript/ffi/Tasks.cpp b/NativeScript/ffi/Tasks.cpp
@@ -1,9 +1,10 @@
 #include "Tasks.h"
+#include <utility>
 
 namespace nativescript {
 
 void Tasks::Register(std::function<void()> task) {
-    tasks_.push_back(task);
+    tasks_.emplace_back(std::move(task));
 }
 
 void Tasks::Drain() {
diff --git a/TestRunner/app/tests/ApiTests.js b/TestRunner/app/tests/ApiTests.js
@@ -135,29 +135,49 @@ describe(module.id, function () {
     });
 
     it("instanceOfUITabBarController", function () {
-        if (pendingIfMissingSymbol("UITabBarController") ||
-            pendingIfMissingSymbol("UIViewController") ||
-            pendingIfMissingSymbol("UIResponder")) {
+        if (hasGlobalSymbol("UITabBarController") &&
+            hasGlobalSymbol("UIViewController") &&
+            hasGlobalSymbol("UIResponder")) {
+            var uiObject = UITabBarController.alloc().init();
+            expect(uiObject instanceof UITabBarController).toBe(true);
+            expect(uiObject instanceof UIViewController).toBe(true);
+            expect(uiObject instanceof UIResponder).toBe(true);
+            expect(uiObject instanceof NSObject).toBe(true);
             return;
         }
 
-        var object = UITabBarController.alloc().init();
-        expect(object instanceof UITabBarController).toBe(true);
-        expect(object instanceof UIViewController).toBe(true);
-        expect(object instanceof UIResponder).toBe(true);
-        expect(object instanceof NSObject).toBe(true);
+        if (hasGlobalSymbol("NSTabViewController") &&
+            hasGlobalSymbol("NSViewController") &&
+            hasGlobalSymbol("NSResponder")) {
+            var nsObject = NSTabViewController.alloc().init();
+            expect(nsObject instanceof NSTabViewController).toBe(true);
+            expect(nsObject instanceof NSViewController).toBe(true);
+            expect(nsObject instanceof NSResponder).toBe(true);
+            expect(nsObject instanceof NSObject).toBe(true);
+            return;
+        }
+
+        pending("Neither UIKit nor AppKit tab/view controller hierarchy is available.");
     });
 
     it("Appearance", function () {
-        if (pendingIfMissingSymbol("UILabel") || pendingIfMissingSymbol("UIColor")) {
+        if (hasGlobalSymbol("UILabel") && hasGlobalSymbol("UIColor")) {
+            expect(UILabel.appearance().description.indexOf('<Customizable class: UILabel>')).not.toBe(-1);
+
+            UILabel.appearance().textColor = UIColor.redColor;
+            expect(UILabel.appearance().textColor).toBe(UIColor.redColor);
             return;
         }
 
-        expect(UILabel.appearance().description.indexOf('<Customizable class: UILabel>')).not.toBe(-1);
+        if (hasGlobalSymbol("NSAppearance") && hasGlobalSymbol("NSAppearanceNameAqua")) {
+            var appearance = NSAppearance.appearanceNamed(NSAppearanceNameAqua);
+            expect(appearance).toBeDefined();
+            expect(appearance).not.toBeNull();
+            expect(appearance.name).toContain("Aqua");
+            return;
+        }
 
-        UILabel.appearance().textColor = UIColor.redColor;
-        expect(UILabel.appearance().textColor).toBe(UIColor.redColor);
-        // expect(UILabel.appearance().constructor).toBe(UILabel);
+        pending("Neither UIKit nor AppKit appearance APIs are available.");
     });
 
     it("ReadonlyPropertyInProtocolAndOverrideWithSetterInInterface", function () {
@@ -248,42 +268,88 @@ describe(module.id, function () {
     });
 
     it("SpecialCaseProperty_When_InstancesRespondToSelector:_IsFalse", function () {
-        if (pendingIfMissingSymbol("UITextField")) {
+        var uiTextField = hasGlobalSymbol("UITextField") ? global.UITextField : null;
+        var nsView = hasGlobalSymbol("NSView") ? global.NSView : null;
+        if (uiTextField) {
+            var uiField = new uiTextField();
+            expect(uiField.secureTextEntry).toBe(false);
+            uiField.secureTextEntry = true;
+            expect(uiField.secureTextEntry).toBe(true);
+            return;
+        }
+
+        if (!nsView) {
+            pending("No suitable platform class is available for special-case property checks.");
             return;
         }
 
-        var field = new UITextField();
-        expect(field.secureTextEntry).toBe(false);
-        field.secureTextEntry = true;
-        expect(field.secureTextEntry).toBe(true);
+        var field = nsView.alloc().init();
+        expect(field.hidden).toBe(false);
+        field.hidden = true;
+        expect(field.hidden).toBe(true);
     });
 
      it("SpecialCaseProperty_When_CustomSelector_ImplementedInJS", function () {
-        if (pendingIfMissingSymbol("UITextField")) {
+        var uiTextField = hasGlobalSymbol("UITextField") ? global.UITextField : null;
+        var nsView = hasGlobalSymbol("NSView") ? global.NSView : null;
+        if (uiTextField) {
+            var uiField = new (uiTextField.extend({
+                get secureTextEntry() {
+                    TNSLog("getter");
+                    return this._secureTextEntry;
+                },
+                set secureTextEntry(val) {
+                    this._secureTextEntry = val;
+                    TNSLog("setter:" + val);
+                }
+            }))();
+            var uiExpectedOutput = "";
+
+            expect(uiField.secureTextEntry).toBeUndefined(); uiExpectedOutput+="getter";
+
+            uiField.secureTextEntry = true; uiExpectedOutput+="setter:true";
+
+            expect(uiField.secureTextEntry).toBe(true); uiExpectedOutput+="getter";
+
+            uiField.secureTextEntry = false; uiExpectedOutput+="setter:false";
+
+            expect(uiField.secureTextEntry).toBe(false); uiExpectedOutput+="getter";
+
+            expect(TNSGetOutput()).toBe(uiExpectedOutput);
+            return;
+        }
+
+        if (!nsView) {
+            pending("No suitable platform class is available for special-case property checks.");
             return;
         }
 
-        var field = new (UITextField.extend({
-            get secureTextEntry() {
+        var overrides = {};
+        Object.defineProperty(overrides, "hidden", {
+            get: function () {
                 TNSLog("getter");
-                return this._secureTextEntry;
+                return this._value;
             },
-            set secureTextEntry(val) {
-                this._secureTextEntry = val;
+            set: function (val) {
+                this._value = val;
                 TNSLog("setter:" + val);
-            }
-        }))();
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        var field = new (nsView.extend(overrides))();
         var expectedOutput = "";
 
-        expect(field.secureTextEntry).toBeUndefined(); expectedOutput+="getter";
+        expect(field.hidden).toBeUndefined(); expectedOutput+="getter";
 
-        field.secureTextEntry = true; expectedOutput+="setter:true";
+        field.hidden = true; expectedOutput+="setter:true";
 
-        expect(field.secureTextEntry).toBe(true); expectedOutput+="getter";
+        expect(field.hidden).toBe(true); expectedOutput+="getter";
 
-        field.secureTextEntry = false; expectedOutput+="setter:false";
+        field.hidden = false; expectedOutput+="setter:false";
 
-        expect(field.secureTextEntry).toBe(false); expectedOutput+="getter";
+        expect(field.hidden).toBe(false); expectedOutput+="getter";
 
         expect(TNSGetOutput()).toBe(expectedOutput);
      });
@@ -802,25 +868,32 @@ describe(module.id, function () {
     // });
 
     it("Unimplemented properties from UIBarItem class should be provided by the inheritors", function () {
-        var classConstructors = ["UIBarButtonItem", "UITabBarItem"];
-        for (var className of classConstructors) {
-            if (!hasGlobalSymbol(className)) {
-                pending(className + " is not available in this runtime/platform configuration.");
-                return;
+        if (hasGlobalSymbol("UIBarButtonItem") && hasGlobalSymbol("UITabBarItem")) {
+            var iosClassConstructors = ["UIBarButtonItem", "UITabBarItem"];
+            var iosProps = ["enabled", "image", "imageInsets", "title"];
+            if (NSProcessInfo.processInfo.isOperatingSystemAtLeastVersion({majorVersion: 11, minorVersion: 0, patchVersion: 0})) {
+                iosProps = iosProps.concat("landscapeImagePhone", "landscapeImagePhoneInsets");
             }
-        }
 
-        var props = ["enabled", "image", "imageInsets", "title"];
-        if (NSProcessInfo.processInfo.isOperatingSystemAtLeastVersion({majorVersion: 11, minorVersion: 0, patchVersion: 0})) {
-            props = props.concat("landscapeImagePhone", "landscapeImagePhoneInsets");
+            for (var iosKlass of iosClassConstructors) {
+                var iosInstance = new global[iosKlass]();
+                for (var iosProp of iosProps) {
+                    expect(iosInstance[iosProp]).toBeDefined(`"${iosProp}" must be defined in instances of "${iosKlass}"`);
+                }
+            }
+            return;
         }
 
-        for (var klass of classConstructors) {
-            var instance = new global[klass]();
-            for (var prop of props) {
-                expect(instance[prop]).toBeDefined(`"${prop}" must be defined in instances of "${klass}"`);
+        if (hasGlobalSymbol("NSToolbarItem")) {
+            var toolbarItem = NSToolbarItem.alloc().initWithItemIdentifier("nativescript.test.item");
+            var macProps = ["enabled", "image", "label", "paletteLabel", "toolTip"];
+            for (var macProp of macProps) {
+                expect(toolbarItem[macProp]).toBeDefined(`"${macProp}" must be defined in instances of "NSToolbarItem"`);
             }
+            return;
         }
+
+        pending("Neither UIKit UIBarItem inheritors nor AppKit NSToolbarItem are available.");
     });
 
     it("Unimplemented properties from MTLRenderPassAttachmentDescriptor class should be provided by the inheritors", function () {
@@ -846,16 +919,25 @@ describe(module.id, function () {
     });
 
     it("Dynamically load modules", () => {
-        if (pendingIfMissingSymbol("CMMotionActivityManager")) {
+        var className = null;
+        for (var candidate of ["CMMotionActivityManager", "CMMotionManager", "CLLocationManager", "AVAudioEngine"]) {
+            if (hasGlobalSymbol(candidate)) {
+                className = candidate;
+                break;
+            }
+        }
+
+        if (!className) {
+            pending("No candidate class from dynamically loaded frameworks is available in this runtime.");
             return;
         }
 
-        // The CMMotionActivityManager interface is defined inside the CoreMotion system framework which is not
-        // statically loaded and the runtime must dynamically resolve it at runtime.
-        let activityManager = CMMotionActivityManager.new();
-        expect(activityManager).not.toBeUndefined();
-        expect(activityManager).not.toBeNull();
-        expect(activityManager instanceof CMMotionActivityManager).toBe(true);
+        // The selected class is expected to come from a framework resolved at runtime.
+        let dynamicType = global[className];
+        let instance = dynamicType.new ? dynamicType.new() : dynamicType.alloc().init();
+        expect(instance).not.toBeUndefined();
+        expect(instance).not.toBeNull();
+        expect(instance instanceof dynamicType).toBe(true);
     });
 
     it("Optional method returning a structure should use objc_msgSend_stret on x86_64", () => {
diff --git a/scripts/run-tests-ios.js b/scripts/run-tests-ios.js
@@ -12,11 +12,13 @@
 //  - IOS_SWIFT_VERSION overrides default Swift version (default: 5.0).
 //  - IOS_COMMAND_TIMEOUT_MS overrides timeout for build/install/simctl commands (default: 3 minutes).
 //  - IOS_BUILD_TIMEOUT_MS overrides timeout for xcodebuild app build (default: IOS_COMMAND_TIMEOUT_MS).
+//  - IOS_COMMAND_MAX_BUFFER_BYTES overrides spawnSync maxBuffer for captured command output (default: 64 MiB).
 //  - IOS_TEST_TIMEOUT_MS overrides max test runtime (default: 2 minutes).
 //  - IOS_LOG_JUNIT=0 disables streaming TKUnit/JUnit lines to console.
 //  - IOS_TESTS filters test modules (comma-separated substrings passed to app as -tests).
 //  - IOS_TEST_INACTIVITY_TIMEOUT_MS overrides max no-log interval (default: 45 seconds).
 //  - IOS_TEST_LOG_STREAM=0 disables parallel simulator log stream (enabled by default).
+//  - IOS_SIM_LOG_LOOKBACK sets log-show window used for post-failure diagnostics (default: 45s).
 
 const fs = require("fs");
 const path = require("path");
@@ -75,13 +77,24 @@ function parseTimeoutMs(name, fallback) {
     return value;
 }
 
+function parsePositiveInt(name, fallback) {
+    const value = Number(process.env[name] || fallback);
+    if (!Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+
+    return Math.floor(value);
+}
+
 const commandTimeoutMs = parseTimeoutMs("IOS_COMMAND_TIMEOUT_MS", 3 * 60 * 1000);
 const buildTimeoutMs = parseTimeoutMs("IOS_BUILD_TIMEOUT_MS", commandTimeoutMs);
+const commandMaxBufferBytes = parsePositiveInt("IOS_COMMAND_MAX_BUFFER_BYTES", 64 * 1024 * 1024);
 const testTimeoutMs = Number(process.env.IOS_TEST_TIMEOUT_MS || 2 * 60 * 1000);
 const inactivityTimeoutMs = Number(process.env.IOS_TEST_INACTIVITY_TIMEOUT_MS || 45 * 1000);
 const emitJunitLogs = process.env.IOS_LOG_JUNIT !== "0";
 const requestedTests = (process.env.IOS_TESTS || "").trim();
 const enableLiveLogStream = process.env.IOS_TEST_LOG_STREAM !== "0";
+const simulatorLogLookback = process.env.IOS_SIM_LOG_LOOKBACK || "45s";
 const consoleLogMarker = "CONSOLE LOG:";
 
 function looksLikeDestination(value) {
@@ -111,6 +124,7 @@ function run(command, args, options = {}) {
     const result = cp.spawnSync(command, args, {
         encoding: "utf8",
         timeout: effectiveTimeout,
+        maxBuffer: commandMaxBufferBytes,
         ...options
     });
 
@@ -529,7 +543,8 @@ function buildTestRunnerApp(destination, swiftVersion) {
         ];
         const result = cp.spawnSync("xcodebuild", args, {
             encoding: "utf8",
-            timeout: buildTimeoutMs
+            timeout: buildTimeoutMs,
+            maxBuffer: commandMaxBufferBytes
         });
         if (result.error && result.error.code === "ETIMEDOUT") {
             if (result.stdout && result.stdout.trim().length > 0) {
@@ -801,7 +816,10 @@ async function waitForCompletedJunitOrLaunchExit(udid, launchProcess, timeoutMs,
         }
 
         if (Date.now() - state.lastActivityAt >= inactivityTimeoutMs) {
-            return { junitResult: null, launchResult, timedOut: true, inactive: true };
+            const launchStillRunning = launchProcess.exitCode === null || launchProcess.exitCode === undefined;
+            if (!enableLiveLogStream || !launchStillRunning) {
+                return { junitResult: null, launchResult, timedOut: true, inactive: true };
+            }
         }
 
         await sleep(250);
@@ -829,7 +847,7 @@ function collectRecentSimulatorLogs(udid, pid) {
         "--style",
         "compact",
         "--last",
-        "3m",
+        simulatorLogLookback,
         "--predicate",
         predicate
     ]);
diff --git a/scripts/run-tests-macos.js b/scripts/run-tests-macos.js
@@ -6,6 +6,7 @@
 //  - MACOS_TEST_SKIP_BUILD=1 skips xcodebuild app build.
 //  - MACOS_TEST_CLEAN_BUILD=1 deletes derived data before build.
 //  - MACOS_COMMAND_TIMEOUT_MS overrides timeout for build commands (default: 10 minutes).
+//  - MACOS_COMMAND_MAX_BUFFER_BYTES overrides spawnSync maxBuffer for captured command output (default: 64 MiB).
 //  - MACOS_TEST_TIMEOUT_MS overrides max test runtime after launch (default: 2 minutes).
 //  - MACOS_TEST_INACTIVITY_TIMEOUT_MS overrides max no-log interval after launch (default: 45 seconds).
 //  - MACOS_LOG_JUNIT=0 disables streaming TKUnit/JUnit lines to console.
@@ -68,7 +69,17 @@ function parseTimeoutMs(name, fallback) {
     return value;
 }
 
+function parsePositiveInt(name, fallback) {
+    const value = Number(process.env[name] || fallback);
+    if (!Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+
+    return Math.floor(value);
+}
+
 const commandTimeoutMs = parseTimeoutMs("MACOS_COMMAND_TIMEOUT_MS", 10 * 60 * 1000);
+const commandMaxBufferBytes = parsePositiveInt("MACOS_COMMAND_MAX_BUFFER_BYTES", 64 * 1024 * 1024);
 const testTimeoutMs = parseTimeoutMs("MACOS_TEST_TIMEOUT_MS", 2 * 60 * 1000);
 const inactivityTimeoutMs = parseTimeoutMs("MACOS_TEST_INACTIVITY_TIMEOUT_MS", 45 * 1000);
 const emitJunitLogs = process.env.MACOS_LOG_JUNIT !== "0";
@@ -94,6 +105,7 @@ function run(command, args, options = {}) {
     const result = cp.spawnSync(command, args, {
         encoding: "utf8",
         timeout: effectiveTimeout,
+        maxBuffer: commandMaxBufferBytes,
         ...options
     });
 
@@ -350,7 +362,8 @@ function emitLLDBBacktrace(appBinaryPath, runArgs) {
 
     const result = cp.spawnSync("xcrun", args, {
         encoding: "utf8",
-        timeout: commandTimeoutMs
+        timeout: commandTimeoutMs,
+        maxBuffer: commandMaxBufferBytes
     });
 
     if (result.error) {
@@ -396,7 +409,8 @@ async function emitCrashBacktrace(appBinaryPath, runArgs, launchedAtMs, pid) {
 function runBuildAndRequireSuccess(command, args, timeoutMs = commandTimeoutMs) {
     const result = cp.spawnSync(command, args, {
         encoding: "utf8",
-        timeout: timeoutMs
+        timeout: timeoutMs,
+        maxBuffer: commandMaxBufferBytes
     });
 
     if (result.error && result.error.code === "ETIMEDOUT") {

Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,10 @@`
`1`	`1`	`#include "Tasks.h"`
	`2`	`+#include <utility>`
`2`	`3`
`3`	`4`	`namespace nativescript {`
`4`	`5`
`5`	`6`	`void Tasks::Register(std::function<void()> task) {`
`6`		`- tasks_.push_back(task);`
	`7`	`+ tasks_.emplace_back(std::move(task));`
`7`	`8`	`}`
`8`	`9`
`9`	`10`	`void Tasks::Drain() {`