mirror of
https://github.com/hanzoai/dev.git
synced 2026-11-21 14:22:49 +00:00
263 lines
10 KiB
Swift
263 lines
10 KiB
Swift
// The harness instruments only decoder entry; scheduling and publication use the real view.
|
|
private final class RowDecodeProbe {
|
|
private let lock = NSLock()
|
|
private var entries = 0
|
|
private var onEntry: ((Int) -> Void)?
|
|
|
|
func reset(onEntry: ((Int) -> Void)? = nil) {
|
|
lock.lock()
|
|
entries = 0
|
|
self.onEntry = onEntry
|
|
lock.unlock()
|
|
}
|
|
|
|
func enter() {
|
|
lock.lock()
|
|
entries += 1
|
|
let entry = entries
|
|
let callback = onEntry
|
|
lock.unlock()
|
|
callback?(entry)
|
|
}
|
|
|
|
var count: Int {
|
|
lock.lock()
|
|
defer { lock.unlock() }
|
|
return entries
|
|
}
|
|
}
|
|
|
|
private let rowDecodeProbe = RowDecodeProbe()
|
|
|
|
private func decodeRowsForTest(_ data: Data) throws -> [ReviewDiffNativeRow] {
|
|
rowDecodeProbe.enter()
|
|
return try JSONDecoder().decode([ReviewDiffNativeRow].self, from: data)
|
|
}
|
|
|
|
private extension ReviewDiffContentView {
|
|
func checkSameGeometry(as reference: ReviewDiffContentView) {
|
|
check(rowOffsets == reference.rowOffsets && contentHeight == reference.contentHeight,
|
|
"Queued decoding must preserve reference row offsets and height")
|
|
check(contentWidthsByFileId == reference.contentWidthsByFileId,
|
|
"Queued decoding must preserve reference widths")
|
|
}
|
|
}
|
|
|
|
private extension HanzoReviewDiffView {
|
|
// One worker/main round decodes, the next prepares and publishes geometry.
|
|
func afterRowPipeline(_ completion: @escaping () -> Void) {
|
|
Self.afterRowPipeline(on: payloadDecodeQueue, completion)
|
|
}
|
|
|
|
static func afterRowPipeline(on queue: DispatchQueue, _ completion: @escaping () -> Void) {
|
|
queue.async {
|
|
DispatchQueue.main.async {
|
|
queue.async {
|
|
DispatchQueue.main.async(execute: completion)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func checkRowsMatch(_ json: String) {
|
|
let expected = try! JSONDecoder().decode([ReviewDiffNativeRow].self, from: Data(json.utf8))
|
|
check(rows.map { String(reflecting: $0) } == expected.map { String(reflecting: $0) },
|
|
"Every decoded row field must match the unchanged decoder")
|
|
check(contentView.rows.map { String(reflecting: $0) } == rows.map { String(reflecting: $0) })
|
|
contentView.checkReferenceGeometry()
|
|
let reference = ReviewDiffContentView(frame: contentView.frame)
|
|
reference.style = contentView.style
|
|
reference.viewportWidth = contentView.viewportWidth
|
|
reference.collapsedFileIds = contentView.collapsedFileIds
|
|
reference.collapsedCommentIds = contentView.collapsedCommentIds
|
|
reference.rows = expected
|
|
contentView.checkSameGeometry(as: reference)
|
|
}
|
|
|
|
func checkEmptyRows() {
|
|
check(rows.isEmpty && contentView.rows.isEmpty && contentView.contentHeight == 0,
|
|
"Reset/error must remain empty after the queue drains")
|
|
}
|
|
}
|
|
|
|
private func rowDecodePayload(_ file: String) -> String {
|
|
let objects: [[String: Any]] = [
|
|
["kind": "file", "id": "\(file):header", "fileId": file, "filePath": "\(file).swift"],
|
|
["kind": "hunk", "id": "\(file):hunk", "fileId": file, "text": "@@ context\t@@"],
|
|
["kind": "line", "id": "\(file):ascii", "fileId": file, "content": String(repeating: "let value = 123; ", count: 60),
|
|
"change": "add", "newLineNumber": 1, "wordDiffRanges": [["start": 0, "end": 3]]],
|
|
["kind": "line", "id": "\(file):unicode", "fileId": file, "content": "漢字\t👨👩👧👦 e\u{301} مرحبا", "oldLineNumber": 2],
|
|
["kind": "comment", "id": "\(file):comment", "fileId": file, "commentText": "Keep every field"],
|
|
]
|
|
return String(data: try! JSONSerialization.data(withJSONObject: objects), encoding: .utf8)!
|
|
}
|
|
|
|
private extension HanzoReviewDiffView {
|
|
static func runQueuedRowDecodeCase(_ index: Int) {
|
|
let names = ["A to B", "reset", "reset then B", "unchanged reset key", "current success", "current error", "obsolete error"]
|
|
guard index < names.count else {
|
|
runReleasedRowDecodeCase()
|
|
return
|
|
}
|
|
rowDecodeProbe.reset()
|
|
let view = HanzoReviewDiffView()
|
|
view.bounds = CGRect(x: 0, y: 0, width: 390, height: 844)
|
|
view.layoutSubviews()
|
|
view.setContentResetKey("section-a")
|
|
view.setStyleJson("{\"wordWrap\":true}")
|
|
view.pendingScrollFileId = "pending"
|
|
var events: [[String: Any]] = []
|
|
view.onDebug.onEvent = { payload in
|
|
if (payload["message"] as? String)?.hasPrefix("rows-decode") == true { events.append(payload) }
|
|
}
|
|
let a = rowDecodePayload("a")
|
|
let b = rowDecodePayload("b")
|
|
view.payloadDecodeQueue.suspend()
|
|
switch index {
|
|
case 0:
|
|
view.setRowsJson(a)
|
|
view.setRowsJson(b)
|
|
case 1, 2:
|
|
view.setRowsJson(a)
|
|
view.setContentResetKey("section-b")
|
|
if index == 2 { view.setRowsJson(b) }
|
|
case 3:
|
|
view.setRowsJson(b)
|
|
view.setContentResetKey("section-a")
|
|
case 4:
|
|
view.setRowsJson(b)
|
|
case 5:
|
|
view.rows = try! JSONDecoder().decode([ReviewDiffNativeRow].self, from: Data(a.utf8))
|
|
view.contentView.rows = view.rows
|
|
view.setRowsJson("invalid JSON")
|
|
default:
|
|
view.setRowsJson("invalid JSON")
|
|
view.setRowsJson(b)
|
|
}
|
|
view.payloadDecodeQueue.resume()
|
|
view.afterRowPipeline {
|
|
let expected = index == 1 ? 0 : 1
|
|
check(rowDecodeProbe.count == expected,
|
|
"\(names[index]): expected \(expected) decoder entries, got \(rowDecodeProbe.count)")
|
|
if index == 1 {
|
|
view.checkEmptyRows()
|
|
check(events.isEmpty, "Reset work must not publish success or error")
|
|
} else if index == 5 {
|
|
view.checkEmptyRows()
|
|
check(view.pendingScrollFileId == nil, "Current error must clear pending scroll")
|
|
check(events.count == 1 && events[0]["message"] as? String == "rows-decode-failed")
|
|
do {
|
|
_ = try JSONDecoder().decode([ReviewDiffNativeRow].self, from: Data("invalid JSON".utf8))
|
|
check(false)
|
|
} catch {
|
|
check(events[0]["error"] as? String == error.localizedDescription, "Preserve the current error")
|
|
}
|
|
} else {
|
|
view.checkRowsMatch(b)
|
|
check(events.count == 1 && events[0]["message"] as? String == "rows-decoded",
|
|
"Only the current payload may publish success")
|
|
}
|
|
print("Passed queued row decode: \(names[index]), decoder entries=\(rowDecodeProbe.count)")
|
|
runQueuedRowDecodeCase(index + 1)
|
|
}
|
|
}
|
|
|
|
static func runReleasedRowDecodeCase() {
|
|
rowDecodeProbe.reset()
|
|
var view: HanzoReviewDiffView? = HanzoReviewDiffView()
|
|
let isReleased = { [weak view] in view == nil }
|
|
let queue = view!.payloadDecodeQueue
|
|
queue.suspend()
|
|
view!.setRowsJson(rowDecodePayload("released"))
|
|
view = nil
|
|
check(isReleased(), "Queued row work must not retain the view")
|
|
queue.resume()
|
|
HanzoReviewDiffView.afterRowPipeline(on: queue) {
|
|
check(rowDecodeProbe.count == 0, "Release before worker resume must skip decoding")
|
|
print("Passed release before worker resume, decoder entries=0")
|
|
runRunningRowDecodeCase(invalid: false)
|
|
}
|
|
}
|
|
|
|
static func runRunningRowDecodeCase(invalid: Bool) {
|
|
let view = HanzoReviewDiffView()
|
|
let release = DispatchSemaphore(value: 0)
|
|
let b = rowDecodePayload("current")
|
|
var publications = 0
|
|
view.onDebug.onEvent = { payload in
|
|
if (payload["message"] as? String)?.hasPrefix("rows-decode") == true {
|
|
check(payload["message"] as? String == "rows-decoded", "Running stale errors must not publish")
|
|
publications += 1
|
|
}
|
|
}
|
|
rowDecodeProbe.reset { entry in
|
|
guard entry == 1 else { return }
|
|
DispatchQueue.main.async {
|
|
view.setContentResetKey("new-section")
|
|
view.setRowsJson(b)
|
|
release.signal()
|
|
view.afterRowPipeline {
|
|
check(rowDecodeProbe.count == 2, "An entered decoder must finish; the current payload must also decode")
|
|
check(publications == 1, "Running obsolete success/error must not publish")
|
|
view.checkRowsMatch(b)
|
|
rowDecodeProbe.reset()
|
|
print("Passed running \(invalid ? "error" : "success") replaced by current rows, decoder entries=2")
|
|
if invalid { runReleasedRunningRowDecodeCase() } else { runRunningRowDecodeCase(invalid: true) }
|
|
}
|
|
}
|
|
release.wait()
|
|
}
|
|
view.setRowsJson(invalid ? "invalid JSON" : rowDecodePayload("running"))
|
|
}
|
|
|
|
static func runReleasedRunningRowDecodeCase() {
|
|
var view: HanzoReviewDiffView? = HanzoReviewDiffView()
|
|
let isReleased = { [weak view] in view == nil }
|
|
let queue = view!.payloadDecodeQueue
|
|
let release = DispatchSemaphore(value: 0)
|
|
var publications = 0
|
|
view!.onDebug.onEvent = { payload in
|
|
if (payload["message"] as? String)?.hasPrefix("rows-decode") == true { publications += 1 }
|
|
}
|
|
rowDecodeProbe.reset { _ in
|
|
DispatchQueue.main.async {
|
|
view = nil
|
|
check(isReleased(), "An entered decoder must not retain the view")
|
|
release.signal()
|
|
afterRowPipeline(on: queue) {
|
|
check(rowDecodeProbe.count == 1 && publications == 0,
|
|
"An entered decode may finish after release but must not publish")
|
|
rowDecodeProbe.reset()
|
|
print("Passed release after decoder entry without retaining the view, decoder entries=1")
|
|
runAdditiveTokenPatchCase()
|
|
}
|
|
}
|
|
release.wait()
|
|
}
|
|
view!.setRowsJson(rowDecodePayload("released-running"))
|
|
}
|
|
|
|
static func runAdditiveTokenPatchCase() {
|
|
let view = HanzoReviewDiffView()
|
|
view.setTokensResetKey("tokens")
|
|
view.payloadDecodeQueue.suspend()
|
|
var acknowledgements: [Bool] = []
|
|
for id in ["one", "two"] {
|
|
view.setTokensPatchJson("{\"resetKey\":\"tokens\",\"tokensByRowId\":{\"\(id)\":[{\"content\":\"\(id)\"}]}}") {
|
|
acknowledgements.append($0)
|
|
}
|
|
}
|
|
view.payloadDecodeQueue.resume()
|
|
view.afterRowPipeline {
|
|
check(acknowledgements == [true, true], "Every additive token patch must be acknowledged")
|
|
check(Set(view.contentView.tokensByRowId.keys) == Set(["one", "two"]), "Token patches must never coalesce")
|
|
print("Passed additive token patches and acknowledgements; all 12 row/payload lifecycle cases passed")
|
|
HanzoReviewDiffView.runQueuedTokenDecodeCase(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
private func runRowDecodeTests() {
|
|
HanzoReviewDiffView.runQueuedRowDecodeCase(0)
|
|
}
|