Consolidate lazy and computed property tests into main PropertyHolder test block

- Moved lazy property, computed property, and property observer tests from separate ph3 instance to main ph test block
- Eliminated need for ph3 instance by reusing existing ph instance
- Updated test expectations to match the actual test flow
- All property tests now use consistent PropertyHolder instance for better code organization

Author: kateinoigakukun

Tests/BridgeJSRuntimeTests/ExportAPITests.swift

@@ -181,13 +181,25 @@ struct TestError: Error {
     // Property with property observers
     @JS var observedProperty: Int {
         willSet {
-            // Note: print won't show in WebAssembly tests, but the observers will still execute
+            Self.willSetCallCount += 1
+            Self.lastWillSetOldValue = self.observedProperty
+            Self.lastWillSetNewValue = newValue
         }
         didSet {
-            // Note: print won't show in WebAssembly tests, but the observers will still execute
+            Self.didSetCallCount += 1
+            Self.lastDidSetOldValue = oldValue
+            Self.lastDidSetNewValue = self.observedProperty
         }
     }
 
+    // Static properties to track observer calls
+    nonisolated(unsafe) static var willSetCallCount: Int = 0
+    nonisolated(unsafe) static var didSetCallCount: Int = 0
+    nonisolated(unsafe) static var lastWillSetOldValue: Int = 0
+    nonisolated(unsafe) static var lastWillSetNewValue: Int = 0
+    nonisolated(unsafe) static var lastDidSetOldValue: Int = 0
+    nonisolated(unsafe) static var lastDidSetNewValue: Int = 0
+
     @JS init(
         intValue: Int,
         floatValue: Float,
@@ -236,6 +248,20 @@ struct TestError: Error {
     return holder.getAllValues()
 }
 
+@JS func resetObserverCounts() {
+    PropertyHolder.willSetCallCount = 0
+    PropertyHolder.didSetCallCount = 0
+    PropertyHolder.lastWillSetOldValue = 0
+    PropertyHolder.lastWillSetNewValue = 0
+    PropertyHolder.lastDidSetOldValue = 0
+    PropertyHolder.lastDidSetNewValue = 0
+}
+
+@JS func getObserverStats() -> String {
+    return
+        "willSet:\(PropertyHolder.willSetCallCount),didSet:\(PropertyHolder.didSetCallCount),willSetOld:\(PropertyHolder.lastWillSetOldValue),willSetNew:\(PropertyHolder.lastWillSetNewValue),didSetOld:\(PropertyHolder.lastDidSetOldValue),didSetNew:\(PropertyHolder.lastDidSetNewValue)"
+}
+
 class ExportAPITests: XCTestCase {
     func testAll() {
         var hasDeinitGreeter = false

Tests/BridgeJSRuntimeTests/Generated/BridgeJS.ExportSwift.swift

@@ -505,6 +505,29 @@ public func _bjs_testPropertyHolder(holder: UnsafeMutableRawPointer) -> Void {
     #endif
 }
 
+@_expose(wasm, "bjs_resetObserverCounts")
+@_cdecl("bjs_resetObserverCounts")
+public func _bjs_resetObserverCounts() -> Void {
+    #if arch(wasm32)
+    resetObserverCounts()
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
+@_expose(wasm, "bjs_getObserverStats")
+@_cdecl("bjs_getObserverStats")
+public func _bjs_getObserverStats() -> Void {
+    #if arch(wasm32)
+    var ret = getObserverStats()
+    return ret.withUTF8 { ptr in
+        _swift_js_return_string(ptr.baseAddress, Int32(ptr.count))
+    }
+    #else
+    fatalError("Only available on WebAssembly")
+    #endif
+}
+
 @_expose(wasm, "bjs_Greeter_init")
 @_cdecl("bjs_Greeter_init")
 public func _bjs_Greeter_init(nameBytes: Int32, nameLen: Int32) -> UnsafeMutableRawPointer {

Tests/BridgeJSRuntimeTests/Generated/JavaScript/BridgeJS.ExportSwift.json

@@ -1167,6 +1167,38 @@
 
         }
       }
+    },
+    {
+      "abiName" : "bjs_resetObserverCounts",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "resetObserverCounts",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "void" : {
+
+        }
+      }
+    },
+    {
+      "abiName" : "bjs_getObserverStats",
+      "effects" : {
+        "isAsync" : false,
+        "isThrows" : false
+      },
+      "name" : "getObserverStats",
+      "parameters" : [
+
+      ],
+      "returnType" : {
+        "string" : {
+
+        }
+      }
     }
   ],
   "moduleName" : "BridgeJSRuntimeTests"

Tests/prelude.mjs

@@ -221,6 +221,53 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
     ph.sibling = newSibling;
     assert.equal(ph.sibling.value, 123);
 
+    // Test lazy property
+    assert.equal(ph.lazyValue, "computed lazily");
+    ph.lazyValue = "modified lazy";
+    assert.equal(ph.lazyValue, "modified lazy");
+    
+    // Test computed read-write property
+    assert.equal(ph.computedReadWrite, "Value: 456");
+    ph.computedReadWrite = "Value: 777";
+    assert.equal(ph.intValue, 777); // Should have parsed and set intValue
+    assert.equal(ph.computedReadWrite, "Value: 777");
+    
+    // Test computed readonly property  
+    assert.equal(ph.computedReadonly, 1554); // intValue * 2 = 777 * 2
+    
+    // Test property with observers
+    // First, reset observer counts to start fresh
+    exports.resetObserverCounts();
+    let initialStats = exports.getObserverStats();
+    assert.equal(initialStats, "willSet:0,didSet:0,willSetOld:0,willSetNew:0,didSetOld:0,didSetNew:0");
+    
+    // Set property from JavaScript and verify observers are called
+    ph.observedProperty = 100;
+    assert.equal(ph.observedProperty, 100);
+    let afterSetStats = exports.getObserverStats();
+    
+    // Verify willSet and didSet were called
+    // The stats should show: willSet:1,didSet:1,willSetOld:777,willSetNew:100,didSetOld:777,didSetNew:100
+    assert(afterSetStats.includes("willSet:1"), `willSet should be called once, got: ${afterSetStats}`);
+    assert(afterSetStats.includes("didSet:1"), `didSet should be called once, got: ${afterSetStats}`);
+    assert(afterSetStats.includes("willSetOld:777"), `willSet should see old value 777, got: ${afterSetStats}`);
+    assert(afterSetStats.includes("willSetNew:100"), `willSet should see new value 100, got: ${afterSetStats}`);
+    assert(afterSetStats.includes("didSetOld:777"), `didSet should see old value 777, got: ${afterSetStats}`);
+    assert(afterSetStats.includes("didSetNew:100"), `didSet should see new value 100, got: ${afterSetStats}`);
+    
+    // Set property to a different value and verify observers are called again
+    ph.observedProperty = 200;
+    assert.equal(ph.observedProperty, 200);
+    let afterSecondSetStats = exports.getObserverStats();
+    
+    // Now should be: willSet:2,didSet:2,willSetOld:100,willSetNew:200,didSetOld:100,didSetNew:200
+    assert(afterSecondSetStats.includes("willSet:2"), `willSet should be called twice, got: ${afterSecondSetStats}`);
+    assert(afterSecondSetStats.includes("didSet:2"), `didSet should be called twice, got: ${afterSecondSetStats}`);
+    assert(afterSecondSetStats.includes("willSetOld:100"), `willSet should see old value 100 on second call, got: ${afterSecondSetStats}`);
+    assert(afterSecondSetStats.includes("willSetNew:200"), `willSet should see new value 200 on second call, got: ${afterSecondSetStats}`);
+    assert(afterSecondSetStats.includes("didSetOld:100"), `didSet should see old value 100 on second call, got: ${afterSecondSetStats}`);
+    assert(afterSecondSetStats.includes("didSetNew:200"), `didSet should see new value 200 on second call, got: ${afterSecondSetStats}`);
+
     ph.release();
     ph2.release();
 
@@ -235,40 +282,6 @@ function BridgeJSRuntimeTests_runJsWorks(instance, exports) {
     const anyObject = {};
     assert.equal(exports.roundTripJSObject(anyObject), anyObject);
 
-    // Test PropertyHolder's newly added lazy and computed properties
-    // Create a new PropertyHolder for testing lazy/computed properties
-    const testObj2 = { testProp2: "test2" };
-    const sibling2 = new exports.SimplePropertyHolder(777);
-    const ph3 = new exports.PropertyHolder(
-        456,        // intValue
-        6.28,       // floatValue
-        1.414,      // doubleValue
-        false,      // boolValue
-        "test2",    // stringValue
-        testObj2,   // jsObject
-        sibling2    // sibling
-    );
-
-    // Test lazy property
-    assert.equal(ph3.lazyValue, "computed lazily");
-    ph3.lazyValue = "modified lazy";
-    assert.equal(ph3.lazyValue, "modified lazy");
-    
-    // Test computed readonly property  
-    assert.equal(ph3.computedReadonly, 912); // intValue * 2 = 456 * 2
-    
-    // Test computed read-write property
-    assert.equal(ph3.computedReadWrite, "Value: 456");
-    ph3.computedReadWrite = "Value: 555";
-    assert.equal(ph3.intValue, 555); // Should have parsed and set intValue
-    assert.equal(ph3.computedReadWrite, "Value: 555");
-    
-    // Test property with observers
-    ph3.observedProperty = 100;
-    assert.equal(ph3.observedProperty, 100);
-
-    ph3.release();
-
     try {
         exports.throwsSwiftError(true);
         assert.fail("Expected error");