SPB Git

Repository Public

DocumentComparerTests.swift 40.1 KB 750 lines swift

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
Files main
Menu

Theme