Repository Public
1// ORIX Docs2// File: Packages/ORIXDocsKit/Tests/DocReviewTests/DocumentComparerTests.swift3// Description: Tests of the comparison engine: content, formatting, moves, tables, inline objects, stories, Unicode, merged-document invariants.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai7import Foundation8import Testing9import DocModel10@testable import DocReview1112private typealias Comparison = DocReview.ComparisonResult13private let fixedDate = Date(timeIntervalSince1970: 1_800_000_000)14private let options = ComparisonOptions(author: "Reviewer", date: fixedDate)1516/// Asserts the two invariants of the merged document.17private func expectInvariants(_ original: DocumentModel, _ revised: DocumentModel, _ result: Comparison, sourceLocation: SourceLocation = #_sourceLocation) {18 #expect(textLines(resolve(result.merged, .accept)) == textLines(revised), "accept-all must give the revised text", sourceLocation: sourceLocation)19 #expect(textLines(resolve(result.merged, .reject)) == textLines(original), "reject-all must give the original text", sourceLocation: sourceLocation)20}2122private func kinds(_ r: Comparison) -> [DocumentChange.Kind] { r.changes.map(\.kind) }2324@Suite struct ContentTests {25 @Test func identicalDocumentsHaveNoChanges() {26 let a = document(["Alpha beta gamma.", "", "Second paragraph with words.", "Third."])27 let r = DocumentComparer.compare(original: a, revised: a, options: options)28 #expect(r.changes.isEmpty)29 #expect(r.rows.allSatisfy { $0.kind == .equal })30 #expect(r.rows.count == 4)31 #expect(r.summary.similarity == 1)32 #expect(r.summary.isIdentical)33 #expect(r.merged.body == a.body)34 expectInvariants(a, a, r)35 }3637 @Test func identicalContentWithDifferentIdentifiersIsEqual() {38 let a = document(["One paragraph here.", "Another paragraph there."])39 let b = document(["One paragraph here.", "Another paragraph there."])40 let r = DocumentComparer.compare(original: a, revised: b, options: options)41 #expect(r.changes.isEmpty)42 }4344 @Test func pureInsertion() {45 let a = document(["First paragraph of the text.", "Third paragraph of the text."])46 let b = document(["First paragraph of the text.", "A brand new sentence.", "Third paragraph of the text."])47 let r = DocumentComparer.compare(original: a, revised: b, options: options)48 #expect(kinds(r) == [.inserted])49 #expect(r.changes[0].revisedBlock == 1 && r.changes[0].originalBlock == nil)50 #expect(r.changes[0].after == "A brand new sentence.")51 #expect(r.rows.map(\.kind) == [.equal, .inserted, .equal])52 #expect(r.summary.wordsInserted == 4 && r.summary.wordsDeleted == 0)53 let p = paragraphs(of: r.merged)[1]54 #expect(p.markRevision?.kind == .insertion && p.runs.allSatisfy { $0.isInserted && $0.revision?.author == "Reviewer" })55 expectInvariants(a, b, r)56 }5758 @Test func pureDeletion() {59 let a = document(["First paragraph of the text.", "Doomed sentence goes away.", "Third paragraph of the text."])60 let b = document(["First paragraph of the text.", "Third paragraph of the text."])61 let r = DocumentComparer.compare(original: a, revised: b, options: options)62 #expect(kinds(r) == [.deleted])63 #expect(r.changes[0].originalBlock == 1 && r.changes[0].revisedBlock == nil)64 #expect(r.rows.map(\.kind) == [.equal, .deleted, .equal])65 #expect(r.merged.body.count == 3)66 let p = paragraphs(of: r.merged)[1]67 #expect(p.plainText == "Doomed sentence goes away." && p.runs.allSatisfy(\.isDeleted) && p.markRevision?.kind == .deletion)68 #expect(Set(r.merged.body.map(\.id)).count == 3)69 expectInvariants(a, b, r)70 }7172 @Test func editedParagraphIsModifiedNotDeletedAndInserted() {73 let a = document(["Intro.", "The quick brown fox jumps over the lazy dog.", "Outro."])74 let b = document(["Intro.", "The quick red fox leaps over the lazy dog today.", "Outro."])75 let r = DocumentComparer.compare(original: a, revised: b, options: options)76 #expect(kinds(r) == [.modified])77 #expect(r.rows.map(\.kind) == [.equal, .modified, .equal])78 #expect(r.changes[0].originalBlock == 1 && r.changes[0].revisedBlock == 1)79 #expect(r.changes[0].before.contains("brown") && r.changes[0].after.contains("red"))80 let p = paragraphs(of: r.merged)[1]81 #expect(p.markRevision == nil)82 #expect(p.runs.filter(\.isDeleted).map(\.text) == ["brown", "jumps"])83 #expect(p.runs.filter(\.isInserted).map(\.text) == ["red", "leaps", " today"])84 #expect(r.summary.wordsInserted == 3 && r.summary.wordsDeleted == 2)85 #expect(r.summary.similarity > 0.7 && r.summary.similarity < 1)86 expectInvariants(a, b, r)87 }8889 @Test func unrelatedParagraphIsDeletedAndInserted() {90 let a = document(["Keep this one.", "Completely different content about zebras and giraffes.", "Keep that one."])91 let b = document(["Keep this one.", "Quarterly revenue numbers exceeded every forecast.", "Keep that one."])92 let r = DocumentComparer.compare(original: a, revised: b, options: options)93 #expect(Set(kinds(r)) == [.deleted, .inserted])94 #expect(r.rows.map(\.kind) == [.equal, .deleted, .inserted, .equal])95 expectInvariants(a, b, r)96 }9798 @Test func inlineDiffProducesRevisionRuns() {99 let runs = DocumentComparer.inlineDiff(Paragraph("Rates rose sharply in March."), Paragraph("Rates fell sharply in April."), options: options)100 #expect(runs.reduce("") { $0 + ($1.isDeleted ? "" : $1.text) } == "Rates fell sharply in April.")101 #expect(runs.reduce("") { $0 + ($1.isInserted ? "" : $1.text) } == "Rates rose sharply in March.")102 #expect(runs.filter(\.isDeleted).map(\.text) == ["rose", "March"])103 #expect(runs.filter(\.isInserted).map(\.text) == ["fell", "April"])104 }105106 @Test func ignoreCaseAndWhitespace() {107 let a = document(["The Yield curve is steep.", "Second."])108 let b = document(["the yield curve is steep. ", "Second."])109 let strict = DocumentComparer.compare(original: a, revised: b, options: options)110 #expect(kinds(strict) == [.modified])111 var loose = options112 loose.ignoreCase = true; loose.ignoreWhitespace = true113 let r = DocumentComparer.compare(original: a, revised: b, options: loose)114 #expect(r.changes.isEmpty)115 #expect(textLines(resolve(r.merged, .accept)) == textLines(b))116 var caseOnly = options117 caseOnly.ignoreCase = true118 #expect(kinds(DocumentComparer.compare(original: a, revised: b, options: caseOnly)) == [.modified])119 }120121 @Test func pendingTrackedChangesOfTheInputsAreComparedAsAccepted() {122 var p = Paragraph("Kept text")123 p.runs.append(Run(" removed text", revision: Revision(kind: .deletion, author: "X")))124 let a = DocumentModel(body: [.paragraph(p)])125 let b = document(["Kept text"])126 let r = DocumentComparer.compare(original: a, revised: b, options: options)127 #expect(r.changes.isEmpty)128 }129}130131@Suite struct FormattingTests {132 @Test func formattingOnlyChangeIsNeverContentChange() {133 let a = document(["Opening.", "The central result is robust.", "Closing."])134 var b = a135 var p = paragraphs(of: a)[1]136 p.transform(4..<11) { $0.props.bold = true } // "central"137 b.body[1] = .paragraph(p)138 let r = DocumentComparer.compare(original: a, revised: b, options: options)139 #expect(kinds(r) == [.formatting])140 #expect(r.changes[0].detail == "Bold added")141 #expect(r.summary.wordsInserted == 0 && r.summary.wordsDeleted == 0 && r.summary.similarity == 1)142 #expect(r.rows.map(\.kind) == [.equal, .modified, .equal])143 let m = paragraphs(of: r.merged)[1]144 #expect(m.runs.allSatisfy { $0.revision == nil })145 let marked = m.runs.filter { $0.formatRevision != nil }146 #expect(marked.map(\.text) == ["central"])147 #expect(marked[0].formatRevision?.previous == CharProps.none && marked[0].props.bold == true)148 #expect(marked[0].formatRevision?.author == "Reviewer")149 // Rejecting restores the original runs exactly.150 #expect(resolve(r.merged, .reject).body.compactMap(\.paragraph)[1].runs == paragraphs(of: a)[1].runs)151 #expect(resolve(r.merged, .accept).body.compactMap(\.paragraph)[1].runs == p.runs)152 expectInvariants(a, b, r)153 }154155 @Test func formattingIgnoredWhenNotCompared() {156 let a = document(["The central result is robust."])157 var b = a158 var p = paragraphs(of: a)[0]159 p.transform(0..<3) { $0.props.italic = true }160 p.style = StyleID.quote161 b.body[0] = .paragraph(p)162 var o = options163 o.compareFormatting = false164 let r = DocumentComparer.compare(original: a, revised: b, options: o)165 #expect(r.changes.isEmpty)166 }167168 @Test func equivalentDirectFormattingIsNotAChange() {169 // bold: false on a style that is not bold resolves to the same appearance as no direct formatting.170 let a = document(["Plain sentence here."])171 var b = a172 var p = paragraphs(of: a)[0]173 p.runs[0].props.bold = false174 b.body[0] = .paragraph(p)175 let r = DocumentComparer.compare(original: a, revised: b, options: options)176 #expect(r.changes.isEmpty)177 }178179 @Test func styleChangeIsReportedAsStyle() {180 let a = DocumentModel(body: [.paragraph(Paragraph("Methods", style: StyleID.heading(2))), .paragraph(Paragraph("Body text follows."))])181 var b = a182 var p = paragraphs(of: a)[0]183 p.style = StyleID.heading(3)184 b.body[0] = .paragraph(p)185 let r = DocumentComparer.compare(original: a, revised: b, options: options)186 #expect(kinds(r) == [.style])187 #expect(r.changes[0].detail == "Style Heading2 → Heading3")188 #expect(paragraphs(of: r.merged)[0].runs.allSatisfy { $0.revision == nil })189 expectInvariants(a, b, r)190 }191192 @Test func paragraphPropertyChangeIsFormatting() {193 let a = document(["Centered soon.", "Unchanged."])194 var b = a195 var p = paragraphs(of: a)[0]196 p.props.alignment = .center197 b.body[0] = .paragraph(p)198 let r = DocumentComparer.compare(original: a, revised: b, options: options)199 #expect(kinds(r) == [.formatting])200 #expect(r.changes[0].detail == "Alignment left → center")201 }202203 @Test func textAndFormattingChangesAreReportedSeparately() {204 let a = document(["The estimate is significant at five percent."])205 var p = Paragraph("The estimate is significant at one percent.")206 p.transform(16..<27) { $0.props.italic = true }207 let b = DocumentModel(body: [.paragraph(p)])208 let r = DocumentComparer.compare(original: a, revised: b, options: options)209 #expect(kinds(r) == [.modified, .formatting])210 #expect(r.changes[1].detail == "Italic added")211 expectInvariants(a, b, r)212 }213214 @Test func styleDefinitionChange() {215 let a = document(["Text."])216 var b = a217 var s = b.styles.style(StyleID.heading(1))!218 s.char.fontSize = 30219 b.styles.upsert(s)220 let r = DocumentComparer.compare(original: a, revised: b, options: options)221 #expect(kinds(r) == [.style])222 #expect(r.changes[0].detail.hasPrefix("Style definition Heading1: Font size"))223 }224}225226@Suite struct MoveTests {227 private let texts = ["Introduction to the study of intraday yield curves.",228 "The data come from one-minute Treasury futures quotes between 2010 and 2024.",229 "We estimate the Nelson–Siegel factors at every minute of the trading day.",230 "Results show a pronounced intraday pattern in the slope factor.",231 "The conclusion discusses implications for monetary policy announcements."]232233 @Test func movedParagraphIsDetected() {234 let a = document(texts)235 let b = document([texts[0], texts[2], texts[3], texts[1], texts[4]])236 let r = DocumentComparer.compare(original: a, revised: b, options: options)237 #expect(kinds(r) == [.moved])238 #expect(r.changes[0].originalBlock == 1 && r.changes[0].revisedBlock == 3)239 #expect(r.rows.map(\.kind) == [.equal, .movedFrom, .equal, .equal, .movedTo, .equal])240 #expect(r.rows[1].original == 1 && r.rows[1].revised == 3 && r.rows[4].original == 1 && r.rows[4].revised == 3)241 #expect(r.summary.wordsInserted == 0 && r.summary.wordsDeleted == 0 && r.summary.wordsMoved > 0)242 #expect(r.summary.similarity == 1)243 #expect(Set(r.merged.body.map(\.id)).count == r.merged.body.count)244 expectInvariants(a, b, r)245 }246247 @Test func movedParagraphWithEditsIsDetected() {248 let a = document(texts)249 let edited = "The data come from one-minute Treasury futures quotes between 2011 and 2024."250 let b = document([texts[0], texts[2], texts[3], edited, texts[4]])251 let r = DocumentComparer.compare(original: a, revised: b, options: options)252 #expect(kinds(r) == [.moved])253 #expect(r.changes[0].detail.hasSuffix("with edits"))254 expectInvariants(a, b, r)255 }256257 @Test func shortParagraphIsNotReportedAsMoved() {258 let a = document([texts[0], "Yes.", texts[2], texts[3]])259 let b = document([texts[0], texts[2], texts[3], "Yes."])260 let r = DocumentComparer.compare(original: a, revised: b, options: options)261 #expect(Set(kinds(r)) == [.deleted, .inserted])262 #expect(!r.rows.contains { $0.kind == .movedFrom || $0.kind == .movedTo })263 expectInvariants(a, b, r)264 }265266 @Test func moveDetectionCanBeTurnedOff() {267 var o = options268 o.detectMoves = false269 let a = document(texts)270 let b = document([texts[0], texts[2], texts[3], texts[1], texts[4]])271 let r = DocumentComparer.compare(original: a, revised: b, options: o)272 #expect(Set(kinds(r)) == [.deleted, .inserted])273 expectInvariants(a, b, r)274 }275276 @Test func dissimilarRelocatedTextIsNotAMove() {277 let a = document([texts[0], texts[1], texts[2], texts[3]])278 let b = document([texts[0], texts[2], texts[3], "The data set is described in the appendix together with every cleaning step applied."])279 let r = DocumentComparer.compare(original: a, revised: b, options: options)280 #expect(!kinds(r).contains(.moved))281 expectInvariants(a, b, r)282 }283}284285@Suite struct TableTests {286 private func doc(_ rows: [[String]]) -> DocumentModel {287 DocumentModel(body: [.paragraph(Paragraph("Before the table.")), .table(Table(strings: rows, width: 400)), .paragraph(Paragraph("After the table."))])288 }289 private let base = [["Country", "GDP", "Growth"], ["Canada", "2140", "1.5"], ["France", "2780", "0.9"], ["Japan", "4230", "1.1"]]290291 @Test func identicalTablesWithDifferentIdentifiers() {292 let r = DocumentComparer.compare(original: doc(base), revised: doc(base), options: options)293 #expect(r.changes.isEmpty)294 }295296 @Test func cellChange() {297 var rows = base298 rows[2][1] = "2790"299 let a = doc(base), b = doc(rows)300 let r = DocumentComparer.compare(original: a, revised: b, options: options)301 #expect(kinds(r) == [.modified])302 #expect(r.changes[0].detail.hasPrefix("Table cell R3C2"))303 #expect(r.changes[0].originalBlock == 1 && r.changes[0].revisedBlock == 1)304 #expect(r.rows.map(\.kind) == [.equal, .modified, .equal])305 let cell = r.merged.body[1].table!.rows[2].cells[1].paragraphs[0]306 #expect(cell.runs.filter(\.isDeleted).map(\.text) == ["2780"] && cell.runs.filter(\.isInserted).map(\.text) == ["2790"])307 expectInvariants(a, b, r)308 }309310 @Test func rowInserted() {311 var rows = base312 rows.insert(["Germany", "4080", "0.2"], at: 2)313 let a = doc(base), b = doc(rows)314 let r = DocumentComparer.compare(original: a, revised: b, options: options)315 #expect(kinds(r) == [.structure])316 #expect(r.changes[0].detail == "Row inserted (row 3)")317 #expect(r.changes[0].after.contains("Germany"))318 #expect(r.merged.body[1].table!.rows.count == 5)319 expectInvariants(a, b, r)320 }321322 @Test func rowDeleted() {323 var rows = base324 rows.remove(at: 1)325 let a = doc(base), b = doc(rows)326 let r = DocumentComparer.compare(original: a, revised: b, options: options)327 #expect(kinds(r) == [.structure])328 #expect(r.changes[0].detail == "Row deleted (row 2)")329 #expect(r.merged.body[1].table!.rows.count == 4)330 expectInvariants(a, b, r)331 }332333 @Test func columnInserted() {334 let rows = base.enumerated().map { i, r in [r[0], r[1], ["Population", "40", "68", "124"][i], r[2]] }335 let a = doc(base), b = doc(rows)336 let r = DocumentComparer.compare(original: a, revised: b, options: options)337 #expect(kinds(r) == [.structure])338 #expect(r.changes[0].detail == "Column inserted (column 3)")339 #expect(r.changes[0].after == "Population")340 let t = r.merged.body[1].table!341 #expect(t.columnCount == 4 && t.rows.allSatisfy { $0.cells.count == 4 })342 expectInvariants(a, b, r)343 }344345 @Test func columnDeletedAndCellChanged() {346 var rows = base.map { [$0[0], $0[2]] }347 rows[3][1] = "1.3"348 let a = doc(base), b = doc(rows)349 let r = DocumentComparer.compare(original: a, revised: b, options: options)350 #expect(kinds(r) == [.structure, .modified])351 #expect(r.changes[0].detail == "Column deleted (column 2)")352 #expect(r.changes[1].detail.hasPrefix("Table cell R4C2"))353 expectInvariants(a, b, r)354 }355356 @Test func incompatibleTableIsReplaced() {357 let other = [["Quarter", "Revenue"], ["Q1", "12"], ["Q2", "15"]]358 let a = doc(base), b = doc(other)359 let r = DocumentComparer.compare(original: a, revised: b, options: options)360 #expect(Set(kinds(r)).isSubset(of: [.structure, .deleted, .inserted]))361 #expect(!kinds(r).contains(.modified))362 #expect(r.merged.body.compactMap(\.table).count == 2)363 expectInvariants(a, b, r)364 }365366 @Test func tableFormattingOnly() {367 let a = doc(base)368 var b = a369 var t = a.body[1].table!370 t.style = .banded371 t.rows[1].cells[0].shading = RGBA(hex: 0xFFEEAA)372 b.body[1] = .table(t)373 let r = DocumentComparer.compare(original: a, revised: b, options: options)374 #expect(kinds(r) == [.formatting])375 #expect(r.changes[0].detail.contains("Table style Grid → Banded") && r.changes[0].detail.contains("shading"))376 }377}378379@Suite struct InlineObjectAndStoryTests {380 @Test func equationSourceChange() {381 func make(_ latex: String) -> DocumentModel {382 var p = Paragraph("Energy is ")383 p.runs.append(Run(inline: .equation(Equation(latex: latex))))384 p.runs.append(Run(" as shown."))385 return DocumentModel(body: [.paragraph(p)])386 }387 let a = make("E = mc^2"), b = make("E = mc^3")388 let r = DocumentComparer.compare(original: a, revised: b, options: options)389 #expect(kinds(r) == [.modified])390 #expect(r.changes[0].before.contains("mc^2") && r.changes[0].after.contains("mc^3"))391 let p = paragraphs(of: r.merged)[0]392 #expect(p.runs.filter(\.isDeleted).count == 1 && p.runs.filter(\.isInserted).count == 1)393 #expect(p.runs.filter { $0.revision == nil }.map(\.text) == ["Energy is ", " as shown."])394 expectInvariants(a, b, r)395 }396397 @Test func imageComparedByAssetAndSize() {398 func make(_ asset: String, width: Double, alt: String = "") -> DocumentModel {399 var p = Paragraph()400 p.runs = [Run(inline: .image(ImageObject(asset: asset, width: width, height: 100, altText: alt)))]401 var d = DocumentModel(body: [.paragraph(Paragraph("Lead paragraph.")), .paragraph(p)])402 d.assets["img1"] = Asset(id: "img1", mimeType: "image/png", data: Data([1, 2, 3]))403 d.assets["img2"] = Asset(id: "img2", mimeType: "image/png", data: Data([9, 9, 9]))404 d.assets["copy"] = Asset(id: "copy", mimeType: "image/png", data: Data([1, 2, 3]))405 return d406 }407 #expect(DocumentComparer.compare(original: make("img1", width: 200), revised: make("img1", width: 200), options: options).changes.isEmpty)408 // Same bytes under another asset id: equal.409 #expect(DocumentComparer.compare(original: make("img1", width: 200), revised: make("copy", width: 200), options: options).changes.isEmpty)410 let resized = DocumentComparer.compare(original: make("img1", width: 200), revised: make("img1", width: 300), options: options)411 #expect(!resized.changes.isEmpty && resized.changes.allSatisfy { $0.kind != .formatting })412 let other = DocumentComparer.compare(original: make("img1", width: 200), revised: make("img2", width: 200), options: options)413 #expect(!other.changes.isEmpty)414 let alt = DocumentComparer.compare(original: make("img1", width: 200), revised: make("img1", width: 200, alt: "A chart"), options: options)415 #expect(kinds(alt) == [.formatting])416 #expect(alt.changes[0].detail == "Image alternative text changed")417 }418419 @Test func citationKeysChange() {420 func make(_ keys: [String]) -> DocumentModel {421 var p = Paragraph("As shown before ")422 p.runs.append(Run(inline: .citation(Citation(items: keys.map { CitationItem(key: $0) }))))423 p.runs.append(Run("."))424 return DocumentModel(body: [.paragraph(p)])425 }426 let a = make(["smith2020"]), b = make(["smith2020", "doe2021"])427 let r = DocumentComparer.compare(original: a, revised: b, options: options)428 #expect(kinds(r) == [.modified])429 #expect(r.changes[0].after.contains("doe2021"))430 expectInvariants(a, b, r)431 }432433 @Test func footnoteContentChange() {434 func make(_ note: String, id: String) -> DocumentModel {435 var p = Paragraph("A claim")436 p.runs.append(Run(inline: .note(NoteRef(kind: .footnote, id: id))))437 p.runs.append(Run(" in the text."))438 var d = DocumentModel(body: [.paragraph(p)])439 d.notes[id] = Note(id: id, kind: .footnote, paragraphs: [Paragraph(note, style: StyleID.footnoteText)])440 return d441 }442 let a = make("See the appendix for details.", id: "n1"), b = make("See the online appendix for details.", id: "n9")443 let r = DocumentComparer.compare(original: a, revised: b, options: options)444 #expect(kinds(r) == [.modified])445 #expect(r.changes[0].detail.hasPrefix("Footnote"))446 #expect(r.changes[0].story == .note("n9"))447 #expect(r.changes[0].originalBlock == 0 && r.changes[0].revisedBlock == 0)448 let note = r.merged.notes["n9"]!.paragraphs[0]449 #expect(note.runs.filter(\.isInserted).map(\.text) == ["online "])450 expectInvariants(a, b, r)451 // Same note content under different ids: no change.452 #expect(DocumentComparer.compare(original: a, revised: make("See the appendix for details.", id: "zz"), options: options).changes.isEmpty)453 }454455 @Test func deletedParagraphKeepsItsFootnote() {456 var p = Paragraph("A paragraph that will be removed entirely")457 p.runs.append(Run(inline: .note(NoteRef(kind: .footnote, id: "n1"))))458 var a = DocumentModel(body: [.paragraph(Paragraph("Stays.")), .paragraph(p)])459 a.notes["n1"] = Note(id: "n1", kind: .footnote, paragraphs: [Paragraph("Original note.")])460 let b = document(["Stays."])461 let r = DocumentComparer.compare(original: a, revised: b, options: options)462 #expect(kinds(r) == [.deleted])463 #expect(r.merged.notes["n1"]?.paragraphs.first?.plainText == "Original note.")464 expectInvariants(a, b, r)465 }466467 @Test func headerFooterAndPageSetup() {468 var a = document(["Body."])469 a.pageSetup = PageSetup(paper: .letter)470 a.pageSetup.header.default = [Paragraph("Draft report", style: StyleID.header)]471 var b = a472 b.pageSetup.header.default = [Paragraph("Final report", style: StyleID.header)]473 b.pageSetup.landscape = true474 b.pageSetup.margins = Insets(all: 54)475 let r = DocumentComparer.compare(original: a, revised: b, options: options)476 #expect(kinds(r) == [.structure, .modified])477 #expect(r.changes[0].detail.contains("Orientation portrait → landscape") && r.changes[0].detail.contains("Margins"))478 #expect(r.changes[1].story == .header(section: 0, variant: .default))479 #expect(r.changes[1].detail.hasPrefix("Header, section 1"))480 let h = r.merged.pageSetup.header.default[0]481 #expect(h.runs.filter(\.isDeleted).map(\.text) == ["Draft"] && h.runs.filter(\.isInserted).map(\.text) == ["Final"])482 expectInvariants(a, b, r)483 }484485 @Test func breaksAndSectionsAreStructure() {486 let a = document(["One long enough paragraph.", "Two long enough paragraph."])487 var b = a488 b.body.insert(.pageBreak(BreakBlock()), at: 1)489 b.body.append(.sectionBreak(SectionBreak(setup: PageSetup(paper: .letter, landscape: true))))490 b.body.append(.paragraph(Paragraph("Appendix text.")))491 let r = DocumentComparer.compare(original: a, revised: b, options: options)492 #expect(kinds(r) == [.structure, .structure, .inserted])493 #expect(r.changes[0].detail == "Page break inserted" && r.changes[1].detail == "Section break inserted")494 let back = DocumentComparer.compare(original: b, revised: a, options: options)495 #expect(kinds(back) == [.structure, .structure, .deleted])496 #expect(back.rows.filter { $0.merged == nil }.count == 2)497 #expect(back.rows.compactMap(\.merged) == Array(0..<back.merged.body.count))498 }499}500501@Suite struct UnicodeTests {502 /// No run of the merged document may start inside a composed character sequence.503 private func expectComposedBoundaries(_ doc: DocumentModel, sourceLocation: SourceLocation = #_sourceLocation) {504 doc.forEachParagraphEverywhere { p, _, _ in505 for r in p.runs {506 guard let first = r.text.unicodeScalars.first, let lastUnit = r.text.utf16.last, let firstUnit = r.text.utf16.first else { continue }507 #expect(!UTF16.isTrailSurrogate(firstUnit) && !UTF16.isLeadSurrogate(lastUnit), sourceLocation: sourceLocation)508 #expect(first.properties.generalCategory != .nonspacingMark && first.value != 0x200D && !(0xFE00...0xFE0F).contains(first.value),509 "run “\(r.text)” starts inside a composed character", sourceLocation: sourceLocation)510 #expect(r.text.unicodeScalars.last?.value != 0x200D, sourceLocation: sourceLocation)511 }512 }513 }514515 @Test func emojiZeroWidthJoinerSequences() {516 let a = document(["The family 👨👩👧👦 went to the park with 🧑🏽🚀 yesterday."])517 let b = document(["The family 👨👩👧 went to the park with 🧑🏽🚀 and 🏳️🌈 today."])518 let r = DocumentComparer.compare(original: a, revised: b, options: options)519 #expect(kinds(r) == [.modified])520 let p = paragraphs(of: r.merged)[0]521 #expect(p.runs.filter(\.isDeleted).map(\.text).contains("👨👩👧👦"))522 #expect(p.runs.filter(\.isInserted).map(\.text).contains("👨👩👧"))523 expectComposedBoundaries(r.merged)524 expectInvariants(a, b, r)525 }526527 @Test func combiningMarks() {528 // Decomposed "é" (e + U+0301) against a plain "e", and a precomposed against a decomposed form.529 let a = document(["Le re\u{301}sultat de\u{301}pend du mode\u{300}le estime\u{301}."])530 let b = document(["Le resultat de\u{301}pend du mod\u{E8}le estime\u{301} ici."])531 let r = DocumentComparer.compare(original: a, revised: b, options: options)532 #expect(kinds(r) == [.modified])533 expectComposedBoundaries(r.merged)534 #expect(Array(resolve(r.merged, .accept).body[0].paragraph!.plainText.utf16) == Array(b.body[0].paragraph!.plainText.utf16))535 // Canonically equivalent text (precomposed "è" against "e" + U+0300) is equal text, not a change: the revised encoding is kept,536 // so reject-all gives the original up to Unicode canonical equivalence.537 let rejected = resolve(r.merged, .reject).body[0].paragraph!.plainText538 #expect(rejected == a.body[0].paragraph!.plainText)539 #expect(rejected.precomposedStringWithCanonicalMapping == a.body[0].paragraph!.plainText.precomposedStringWithCanonicalMapping)540 let p = paragraphs(of: r.merged)[0]541 #expect(p.runs.filter(\.isDeleted).map(\.text) == ["re\u{301}sultat"])542 #expect(p.runs.filter(\.isInserted).map(\.text) == ["resultat", " ici"])543 }544545 @Test func rightToLeftText() {546 let a = document(["هذا النص مكتوب باللغة العربية للاختبار.", "שלום עולם וברוכים הבאים."])547 let b = document(["هذا النص مكتوب باللغة العربية للتجربة.", "שלום עולם וברוכים הבאים לכאן."])548 let r = DocumentComparer.compare(original: a, revised: b, options: options)549 #expect(kinds(r) == [.modified, .modified])550 let p = paragraphs(of: r.merged)[0]551 #expect(p.runs.filter(\.isDeleted).map(\.text) == ["للاختبار"] && p.runs.filter(\.isInserted).map(\.text) == ["للتجربة"])552 expectComposedBoundaries(r.merged)553 expectInvariants(a, b, r)554 }555556 @Test func chineseAndJapaneseAreComparedBelowTheParagraph() {557 let a = document(["今天的天气非常好,我们一起去公园散步。", "東京は日本の首都です。"])558 let b = document(["今天的天气非常好,我们一起去图书馆看书。", "京都は日本の古都です。"])559 let r = DocumentComparer.compare(original: a, revised: b, options: options)560 #expect(kinds(r) == [.modified, .modified])561 let p = paragraphs(of: r.merged)[0]562 // The common beginning stays unchanged text: the paragraph is not one token.563 #expect(p.runs.first?.revision == nil && p.runs.first!.text.hasPrefix("今天的天气非常好"))564 #expect(p.runs.contains(where: \.isDeleted) && p.runs.contains(where: \.isInserted))565 expectInvariants(a, b, r)566 }567568 @Test func surrogatePairsAndVariationSelectors() {569 let a = document(["Math 𝒳 and 𝒴 with ❤️ and ☺︎ signs."])570 let b = document(["Math 𝒵 and 𝒴 with ❤ and ☺︎ signs!"])571 let r = DocumentComparer.compare(original: a, revised: b, options: options)572 expectComposedBoundaries(r.merged)573 expectInvariants(a, b, r)574 }575}576577@Suite struct InvariantTests {578 /// Random documents and random edits: the merged document must always resolve to both texts.579 @Test(arguments: 1...40) func randomEditsKeepBothTexts(seed: Int) {580 var g = SeededGenerator(seed: UInt64(seed) &* 7919)581 var original: [Block] = []582 for i in 0..<Int.random(in: 5...40, using: &g) {583 if i % 11 == 7 {584 let rows = (0..<Int.random(in: 2...5, using: &g)).map { _ in (0..<3).map { _ in sentence(&g, words: Int.random(in: 1...3, using: &g)) } }585 original.append(.table(Table(strings: rows, width: 400)))586 } else {587 original.append(.paragraph(Paragraph(Int.random(in: 0...9, using: &g) == 0 ? "" : sentence(&g, words: Int.random(in: 1...30, using: &g)))))588 }589 }590 var revised = original591 for _ in 0..<Int.random(in: 1...12, using: &g) {592 let at = Int.random(in: 0..<revised.count, using: &g)593 switch Int.random(in: 0...6, using: &g) {594 case 0: revised.insert(.paragraph(Paragraph(sentence(&g, words: Int.random(in: 1...20, using: &g)))), at: at)595 case 1: if revised.count > 2 { revised.remove(at: at) }596 case 2:597 if case .paragraph(var p) = revised[at], p.length > 4 {598 let cut = p.plainText.composedBoundary(atOrBefore: Int.random(in: 1..<p.length, using: &g))599 p.insert(Run(" " + sentence(&g, words: 3)), at: cut)600 revised[at] = .paragraph(p)601 }602 case 3:603 if case .paragraph(var p) = revised[at], p.length > 8 {604 let lo = p.plainText.composedBoundary(atOrBefore: Int.random(in: 0..<(p.length / 2), using: &g))605 let hi = p.plainText.composedBoundary(atOrBefore: Int.random(in: (p.length / 2)..<p.length, using: &g))606 p.delete(lo..<hi)607 revised[at] = .paragraph(p)608 }609 case 4:610 let to = Int.random(in: 0..<revised.count, using: &g)611 let b = revised.remove(at: at)612 revised.insert(b, at: min(to, revised.count))613 case 5:614 if case .paragraph(var p) = revised[at], p.length > 6 {615 p.transform(1..<min(p.length, 6)) { $0.props.bold = true }616 revised[at] = .paragraph(p)617 }618 default:619 if case .table(var t) = revised[at] {620 if Bool.random(using: &g) { t.rows.append(TableRow(cells: (0..<3).map { _ in TableCell(sentence(&g, words: 2)) })) }621 else { t.rows[t.rows.count - 1].cells[1] = TableCell(sentence(&g, words: 2)) }622 revised[at] = .table(t)623 }624 }625 }626 let a = DocumentModel(body: original), b = DocumentModel(body: revised)627 let r = DocumentComparer.compare(original: a, revised: b, options: options)628 expectInvariants(a, b, r)629 #expect(r.rows.compactMap(\.merged) == Array(0..<r.merged.body.count))630 #expect(Set(r.merged.body.map(\.id)).count == r.merged.body.count, "block ids must stay unique")631 #expect(r.summary.similarity >= 0 && r.summary.similarity <= 1)632 // Determinism: same input, same output.633 let again = DocumentComparer.compare(original: a, revised: b, options: options)634 #expect(again.changes == r.changes && again.merged == r.merged && again.rows == r.rows)635 }636637 @Test func emptyAndSingleParagraphDocuments() {638 let empty = DocumentModel()639 let one = document(["Only paragraph."])640 for (a, b) in [(empty, one), (one, empty), (empty, empty)] {641 let r = DocumentComparer.compare(original: a, revised: b, options: options)642 expectInvariants(a, b, r)643 }644 }645646 @Test(arguments: 1...60) func longestCommonSubsequenceIsOptimal(seed: Int) {647 var g = SeededGenerator(seed: UInt64(seed))648 let n = Int.random(in: 0...60, using: &g), m = Int.random(in: 0...60, using: &g)649 let alphabet = Int.random(in: 2...12, using: &g)650 let a = (0..<n).map { _ in Int.random(in: 0..<alphabet, using: &g) }, b = (0..<m).map { _ in Int.random(in: 0..<alphabet, using: &g) }651 var dp = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)652 for i in 0..<n { for j in 0..<m { dp[i + 1][j + 1] = a[i] == b[j] ? dp[i][j] + 1 : max(dp[i][j + 1], dp[i + 1][j]) } }653 let myers = SequenceDiff.lcs(a, b, anchors: false)654 #expect(myers.count == dp[n][m])655 for pairs in [myers, SequenceDiff.lcs(a, b, anchors: true)] {656 #expect(pairs.allSatisfy { a[$0.0] == b[$0.1] })657 #expect(zip(pairs, pairs.dropFirst()).allSatisfy { $0.0 < $1.0 && $0.1 < $1.1 })658 }659 }660}661662@Suite struct ReportTests {663 private func sample() -> Comparison {664 let a = document(["Title line of the document.", "The quick brown fox jumps over the lazy dog.", "A paragraph to delete entirely."])665 let b = document(["Title line of the document.", "The quick red fox jumps over the lazy dog.", "A new closing paragraph | with a pipe."])666 return DocumentComparer.compare(original: a, revised: b, options: options)667 }668669 @Test func markdownReport() {670 let r = sample()671 let md = r.reportMarkdown(originalName: "v1.orixdoc", revisedName: "v2.orixdoc")672 #expect(md.hasPrefix("# Comparison report"))673 #expect(md.contains("v1.orixdoc") && md.contains("v2.orixdoc"))674 #expect(md.contains("| Changes | \(r.changes.count) |"))675 #expect(md.contains("**Modified**") && md.contains("Before: ") && md.contains("After: "))676 #expect(md.contains("Similarity"))677 let same = DocumentComparer.compare(original: document(["x"]), revised: document(["x"]), options: options)678 #expect(same.reportMarkdown(originalName: "a", revisedName: "b").contains("The documents are identical."))679 }680681 @Test func documentReport() {682 let r = sample()683 let doc = r.reportDocument(originalName: "v1.orixdoc", revisedName: "v2.orixdoc")684 let ps = doc.body.compactMap(\.paragraph)685 #expect(ps.first?.style == StyleID.title && ps.first?.plainText == "Comparison report")686 #expect(ps.filter { $0.style == StyleID.heading(1) }.map(\.plainText) == ["Summary", "Changes"])687 let table = doc.body.compactMap(\.table).first688 #expect(table != nil && table!.rows.first!.isHeader && table!.rows.count >= 6)689 #expect(ps.filter { $0.plainText.hasPrefix("Before ") }.count >= 2)690 #expect(ps.contains { $0.plainText.contains("Modified") })691 #expect(doc.meta.title == "Comparison report")692 #expect(Numbering(doc).outline.count == 2)693 // The report is an ordinary document: it survives a JSON round trip.694 let data = try! JSONEncoder().encode(doc)695 #expect((try? JSONDecoder().decode(DocumentModel.self, from: data))?.body == doc.body)696 }697}698699@Suite struct PerformanceTests {700 @Test func twoFiveThousandParagraphDocuments() {701 var g = SeededGenerator(seed: 42)702 var original: [Block] = []703 for i in 0..<5000 {704 original.append(.paragraph(Paragraph(i % 50 == 0 ? "" : "§\(i) " + sentence(&g, words: Int.random(in: 20...80, using: &g)))))705 }706 var revised = original707 // 250 edited paragraphs, 100 deletions, 100 insertions, 20 moves.708 for k in 0..<250 {709 let at = (k * 19 + 3) % revised.count710 if case .paragraph(var p) = revised[at], p.length > 20 {711 p.insert(Run(" inserted words here"), at: p.plainText.composedBoundary(atOrBefore: p.length / 2))712 p.delete(0..<4)713 revised[at] = .paragraph(p)714 }715 }716 for k in 0..<100 { revised.remove(at: (k * 47 + 11) % revised.count) }717 for k in 0..<100 { revised.insert(.paragraph(Paragraph("New " + sentence(&g, words: 30))), at: (k * 53 + 5) % revised.count) }718 for k in 0..<20 {719 let from = (k * 211 + 17) % revised.count720 let b = revised.remove(at: from)721 revised.insert(b, at: (from + 1500) % revised.count)722 }723 let a = DocumentModel(body: original), b = DocumentModel(body: revised)724 let clock = ContinuousClock()725 var result: Comparison?726 let elapsed = clock.measure { result = DocumentComparer.compare(original: a, revised: b, options: options) }727 let seconds = Double(elapsed.components.seconds) + Double(elapsed.components.attoseconds) / 1e18728 let r = result!729 print(String(format: "[DocReview benchmark] 2 × 5 000 paragraphs (%d / %d blocks, %d changes, similarity %.3f): %.3f s",730 a.body.count, b.body.count, r.changes.count, r.summary.similarity, seconds))731 #expect(seconds < 5, "comparison of 2 × 5 000 paragraphs took \(seconds) s")732 #expect(r.summary.count(.modified) >= 200)733 #expect(r.summary.count(.moved) >= 10)734 expectInvariants(a, b, r)735 }736737 @Test func completelyDifferentLargeDocuments() {738 var g = SeededGenerator(seed: 7)739 let a = DocumentModel(body: (0..<3000).map { _ in .paragraph(Paragraph("A " + sentence(&g, words: 25))) })740 let b = DocumentModel(body: (0..<3000).map { _ in .paragraph(Paragraph("B " + sentence(&g, words: 25))) })741 let clock = ContinuousClock()742 var result: Comparison?743 let elapsed = clock.measure { result = DocumentComparer.compare(original: a, revised: b, options: options) }744 let seconds = Double(elapsed.components.seconds) + Double(elapsed.components.attoseconds) / 1e18745 print(String(format: "[DocReview benchmark] 2 × 3 000 unrelated paragraphs (worst case, %d changes): %.3f s", result!.changes.count, seconds))746 #expect(seconds < 10)747 expectInvariants(a, b, result!)748 }749}750