152 lines
9.9 KiB
Swift
152 lines
9.9 KiB
Swift
// 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")
|
|
}
|
|
|
|
}
|