// SPDX-License-Identifier: GPL-3.0-or-later import XCTest final class CMOCVariableTreeTests: XCTestCase { private struct Fixture { let metadata: CMOCVariableDebug var memory: Data var available: Data func evaluator(u: UInt16 = 0x4000, locals: Bool = true) -> CMOCWatchEvaluator { CMOCWatchEvaluator(metadata: metadata, context: .init(pc: 0x2800, u: u, memory: memory, available: available), frameLocalsAvailable: locals) } mutating func word(_ address: Int, _ value: UInt16) { memory[address] = UInt8(value >> 8); memory[address + 1] = UInt8(value & 255) } } private func fixture() -> Fixture { let word = CMOCVariableDebug.CType.integer let array = CMOCVariableDebug.CType(name: "int[40]", kind: "array", size: 80, count: 40, element: word) let small = CMOCVariableDebug.CType(name: "int[3]", kind: "array", size: 6, count: 3, element: word) let float = CMOCVariableDebug.CType(name: "float", kind: "floating", size: 5) let bag = CMOCVariableDebug.CType(name: "struct Bag", kind: "aggregate", size: 13, members: [ .init(name: "number", offset: 0, type: word), .init(name: "unsupported", offset: 2, type: float), .init(name: "items", offset: 7, type: small) ]) let union = CMOCVariableDebug.CType(name: "union Word", kind: "aggregate", size: 2, members: [ .init(name: "first", offset: 0, type: word), .init(name: "second", offset: 0, type: word) ]) let pointer = CMOCVariableDebug.CType(name: "int *", kind: "pointer", size: 2, element: word) let terminal = CMOCVariableDebug.CType(name: "struct Node", kind: "aggregate", size: 4, members: []) let next = CMOCVariableDebug.CType(name: "struct Node *", kind: "pointer", size: 2, element: terminal) let node = CMOCVariableDebug.CType(name: "struct Node", kind: "aggregate", size: 4, members: [ .init(name: "value", offset: 0, type: word), .init(name: "next", offset: 2, type: next) ]) var deep = word for _ in 0..<14 { deep = .init(name: "int[]", kind: "array", size: 2, count: 1, element: deep) } let wide = CMOCVariableDebug.CType(name: "struct Wide", kind: "aggregate", size: 80, members: (0..<40).map { .init(name: "field\($0)", offset: $0 * 2, type: word) }) let entries: [(String, CMOCVariableDebug.CType, Int)] = [ ("array", array, 0x3000), ("bag", bag, 0x3100), ("union", union, 0x3120), ("pointer", pointer, 0x3200), ("null", pointer, 0x3202), ("io", pointer, 0x3204), ("node", node, 0x3300), ("deep", deep, 0x3400), ("wide", wide, 0x3500) ] let map = CMOCProjectSourceMap(entryPoint: 0x2800, binarySHA256: "", sourceHashes: [:], instructions: [.init(sourcePath: "main.c", sourceLine: 5, address: 0x2800, bytes: [0x12], assembly: "NOP")], objectHashes: [:], listingHashes: [:], linkMapSHA256: "") let variables = entries.map { CMOCVariableDebug.Variable(name: $0.0, sourcePath: "main.c", line: 1, type: $0.1, address: $0.2, offset: nil, scope: nil, isStatic: false) } + [ .init(name: "local", sourcePath: "main.c", line: 2, type: small, address: nil, offset: -6, scope: 0x2800..<0x2820, isStatic: false) ] let metadata = CMOCVariableDebug(functions: [.init(name: "main", sourcePath: "main.c", entry: 0x2800, body: 0x2800, end: 0x2820, frame: true)], variables: variables, sourceMap: map) var result = Fixture(metadata: metadata, memory: Data(repeating: 0, count: 65536), available: Data(repeating: 1, count: 65536)) result.memory[0x2800] = 0x12 for i in 0..<40 { result.word(0x3000 + 2*i, UInt16(i)); result.word(0x3500 + 2*i, UInt16(100 + i)) } result.word(0x3100, 7); result.word(0x3107, 11); result.word(0x3109, 22); result.word(0x310b, 33) result.word(0x3120, 456); result.word(0x3200, 0x3109); result.word(0x3204, 0xff00) result.word(0x3300, 8); result.word(0x3302, 0x3300) result.word(0x3ffa, 9); result.word(0x40fa, 19) for i in 0xff00..<65536 { result.available[i] = 0 } return result } private func path(_ name: String, _ components: [CMOCWatchEvaluator.Component] = []) -> CMOCWatchEvaluator.TreePath { .init(root: .variable(name), components: components) } func testArrayAndMemberPagesRespectDeclaredBoundsAndStableTypedIdentity() { let evaluator = fixture().evaluator() let root = evaluator.treeNode(at: path("array")) XCTAssertEqual(root.childCount, 40) XCTAssertEqual(root.value, "[40 elements]") let first = evaluator.children(of: root.path) XCTAssertEqual(first.nodes.count, 32); XCTAssertEqual(first.nextOffset, 32) XCTAssertEqual(first.nodes.first?.name, "[0]"); XCTAssertEqual(first.nodes.last?.value, "31") let last = evaluator.children(of: root.path, offset: 32) XCTAssertEqual(last.nodes.count, 8); XCTAssertNil(last.nextOffset); XCTAssertEqual(last.nodes.last?.value, "39") XCTAssertNotNil(evaluator.children(of: root.path, offset: -1).error) XCTAssertNotNil(evaluator.children(of: root.path, offset: 41).error) XCTAssertNotNil(evaluator.treeNode(at: path("array", [.index(40)])).error) XCTAssertNotNil(evaluator.treeNode(at: path("pointer", [.index(0)])).error, "Pointers must not imply array bounds") XCTAssertNotEqual(root.id, evaluator.watchTreeRoot("array").id) let members = evaluator.children(of: path("wide"), offset: 32) XCTAssertEqual(members.nodes.map(\.name), (32..<40).map { "field\($0)" }) XCTAssertEqual(members.nodes.last?.value, "139") } func testUnsupportedAggregateChildrenDoNotHideSiblingsOrNestedArraysAndUnions() { let evaluator = fixture().evaluator() XCTAssertNil(evaluator.treeNode(at: path("bag")).error) let members = evaluator.children(of: path("bag")).nodes XCTAssertEqual(members.count, 3); XCTAssertEqual(members[0].value, "7") XCTAssertNotNil(members[1].error); XCTAssertEqual(members[1].typeName, "float"); XCTAssertEqual(members[2].childCount, 3) XCTAssertEqual(evaluator.children(of: members[2].path).nodes.map(\.value), ["11", "22", "33"]) XCTAssertEqual(evaluator.children(of: path("union")).nodes.map(\.value), ["456", "456"]) let watch = evaluator.watchTreeRoot("(bag)") XCTAssertEqual(evaluator.children(of: watch.path).nodes[0].value, "7") } func testPointerExpansionIsExplicitAndNullIOAndCyclesFailAtTheirOwnChild() { let evaluator = fixture().evaluator() XCTAssertEqual(evaluator.treeNode(at: path("pointer")).value, "$3109") XCTAssertEqual(evaluator.children(of: path("pointer")).nodes.first?.value, "22") for name in ["null", "io"] { XCTAssertNil(evaluator.treeNode(at: path(name)).error) let child = evaluator.children(of: path(name)).nodes.first XCTAssertEqual(child?.name, "Pointee"); XCTAssertNotNil(child?.error); XCTAssertEqual(child?.childCount, 0) } let child = evaluator.children(of: path("node", [.member("next")])).nodes.first XCTAssertTrue(child?.error?.contains("cycle") == true) XCTAssertEqual(evaluator.treeNode(at: path("node", [.member("value")])).value, "8") } func testDepthLimitAndUnavailableSiblingAreBounded() { var fixture = fixture(); fixture.available[0x3100] = 0 let evaluator = fixture.evaluator() let members = evaluator.children(of: path("bag")).nodes XCTAssertNotNil(members[0].error) XCTAssertNil(members[2].error) XCTAssertEqual(evaluator.children(of: members[2].path).nodes[1].value, "22") let deep = path("deep", Array(repeating: .index(0), count: 12)) XCTAssertEqual(evaluator.treeNode(at: deep).childCount, 0) XCTAssertNotNil(evaluator.treeNode(at: deep).error) XCTAssertNotNil(evaluator.children(of: deep).error) XCTAssertNotNil(evaluator.treeNode(at: deep.appending(.index(0))).error) } func testPathsResolveAgainForSelectedFramesStaleCodeAndLocalAvailability() { var fixture = fixture() let local = path("local", [.index(0)]) XCTAssertEqual(fixture.evaluator().treeNode(at: local).value, "9") XCTAssertEqual(fixture.evaluator(u: 0x4100).treeNode(at: local).value, "19") var gated = fixture.evaluator() XCTAssertEqual(gated.treeNode(at: local).value, "9") gated.frameLocalsAvailable = false XCTAssertNotNil(gated.treeNode(at: local).error, "Cached code verification must not cache local availability") XCTAssertNotNil(gated.children(of: path("local")).error) XCTAssertNil(gated.treeNode(at: path("array", [.index(0)])).error) fixture.memory[0x2800] = 0x39 let stale = fixture.evaluator() XCTAssertNotNil(stale.children(of: path("array")).error) XCTAssertNotNil(stale.treeNode(at: local).error) XCTAssertNotNil(stale.watchTreeRoot("1 + 2").error) } func testCachedVerificationOwnsFoundationSnapshotBuffers() { let fixture = fixture() let memory = NSMutableData(data: fixture.memory), availability = NSMutableData(data: fixture.available) let evaluator = CMOCWatchEvaluator(metadata: fixture.metadata, context: .init(pc: 0x2800, u: 0x4000, memory: Data(referencing: memory), available: Data(referencing: availability))) XCTAssertEqual(evaluator.treeNode(at: path("array", [.index(1)])).value, "1") memory.mutableBytes.assumingMemoryBound(to: UInt8.self)[0x2800] = 0x39 memory.mutableBytes.assumingMemoryBound(to: UInt8.self)[0x3003] = 99 availability.mutableBytes.assumingMemoryBound(to: UInt8.self)[0x3002] = 0 XCTAssertEqual(evaluator.context.memory[0x2800], 0x12) XCTAssertEqual(evaluator.context.available[0x3002], 1) XCTAssertEqual(evaluator.treeNode(at: path("array", [.index(1)])).value, "1") } }