From ed9829fff15451246cddcfb608377ef923752d3f Mon Sep 17 00:00:00 2001
From: Rory Hinnen <rory@hinnen.us>
Date: Sat, 11 Jul 2026 13:33:44 -0500
Subject: [PATCH] updated unit tests

---
 .../UserInterfaceState.xcuserstate            | Bin 16892 -> 16890 bytes
 .../Interject!Tests/Interject_Tests.swift     | 216 ++++++++++++++++--
 2 files changed, 193 insertions(+), 23 deletions(-)

diff --git a/interject/Interject!.xcodeproj/project.xcworkspace/xcuserdata/roryhinnen.xcuserdatad/UserInterfaceState.xcuserstate b/interject/Interject!.xcodeproj/project.xcworkspace/xcuserdata/roryhinnen.xcuserdatad/UserInterfaceState.xcuserstate
index dcaf34d574617b1932e687099cd1986d62f87ae5..c51babb8e052065f5ebba82b306c933a9dfbe28d 100644
GIT binary patch
delta 417
zcmWNLF-RM67{$NuzFM(08jZvnDvkAW+^2)I9S*cuv$asL&~_3;Ne-3R3)Bd@$p1(u
zp$_>AE@~wioCM2Z(V|kRP)o_8SuEAMI0#xAB#T7wKfK?2Z+X0O8n4p0n${}UX_LOu
zo;R(XHnf3`yPzxnz&-q_{1+I)C#IErVn!^8MdhDFtuSOX(jfoqx8y}*joi_n%9hAK
zd3G-sfjpK(x0n@1-{^>Azi{IAggw?DPsYaI*-q-E?F^-cz0XZi#FBRzTDx0O6xSl-
ztr*oB)vMt{vsG@I&9ZFXY4;$QBb(wBb5U~<U4)#b(Heab^Dg>btP{pQZ9px3l}jPL
za-X(T-j)L){r&;?phmSF+J#^ii}YP&TnuFKJ(gsio8<-v)P+1J@OII~7WJXKJyFer
z&z<vS7p<h<4{sm|aTtV22rH%(A3-NP1}oeFue^e_LbTQRTYl*3#jIE88X@biS>`JC
zbAW@~#9@BO5jMGvpKuSq=C|C>37%rXA34LbJje6A$V;5{QqN*qMZr3<j^&@|13b9_
D+8B&p

delta 396
zcmW-aUr1A77>D2YysSU8a&xkDXiiuM--gsK<bZ-Q5X1;pU_l5{>>N^-XJiZV?mJGr
z@Io&>FQ>wWmt)RDtDw-5QjviS4D7}byy$lADkpf92cF+^_xqp5dK%Z#%GDBmq;K@Y
zo>NYm?%@`MF2HTv!ChzfKoxW1<|XrDNh~|HA{vBhZ-gGB{M($ni!~^VMbRhJQ9T)d
zH({8mM~3+-H8%2k+%$$v-FR=jwTmrL#G3st@ZpB5D$azo^Qv1RuTbStXPZo^;idwu
zgFlN^Dhg?#CySF<lVxt}`b1yApCg?Nid%>lDi%VHzA6fBSlB2s7W#x*q3_T@TQb6`
z>!(xO@<kvd1z(e&+2>rBIe}NI7Irw_ec^;V9NXMKeQKeW^mt(ylAyy&n1Z0=l;a3I
zfF9@uEqEWIc16n*m2Mx%>E0Nw+LhjM(hfW8e4THxhke}40dD0x+{HZ{<pCb#hx~+x
j`58aw5!U$)&+sfSaE1%^WPe<7{nC!KKk|399goie))9lA

diff --git a/interject/Interject!Tests/Interject_Tests.swift b/interject/Interject!Tests/Interject_Tests.swift
index a0d4579..61a5aac 100644
--- a/interject/Interject!Tests/Interject_Tests.swift
+++ b/interject/Interject!Tests/Interject_Tests.swift
@@ -5,29 +5,199 @@
 //  Created by Rory Hinnen on 21/11/18.
 //
 
-import XCTest
+import Testing
 @testable import Interject_
 
-class Interject_Tests: XCTestCase {
-
-    override func setUpWithError() throws {
-        // Put setup code here. This method is called before the invocation of each test method in the class.
-    }
-
-    override func tearDownWithError() throws {
-        // Put teardown code here. This method is called after the invocation of each test method in the class.
-    }
-
-    func testExample() throws {
-        // This is an example of a functional test case.
-        // Use XCTAssert and related functions to verify your tests produce the correct results.
-    }
-
-    func testPerformanceExample() throws {
-        // This is an example of a performance test case.
-        self.measure {
-            // Put the code you want to measure the time of here.
-        }
-    }
-
+@Suite("Place") struct PlaceTests {
+    @Test func firstSize() { #expect(Place.first.size() == 35.0) }
+    @Test func secondSize() { #expect(Place.second.size() == 55.0) }
+    @Test func nounSize() { #expect(Place.noun.size() == 75.0) }
+}
+
+@Suite("Locked") struct LockedTests {
+    @Test func defaultsUnlocked() {
+        let locked = Locked()
+        #expect(!locked.isLocked(.first))
+        #expect(!locked.isLocked(.second))
+        #expect(!locked.isLocked(.noun))
+    }
+
+    @Test func toggleFirstLocks() {
+        var locked = Locked()
+        locked.toggle(.first)
+        #expect(locked.isLocked(.first))
+        #expect(!locked.isLocked(.second))
+        #expect(!locked.isLocked(.noun))
+    }
+
+    @Test func toggleSecondLocks() {
+        var locked = Locked()
+        locked.toggle(.second)
+        #expect(!locked.isLocked(.first))
+        #expect(locked.isLocked(.second))
+        #expect(!locked.isLocked(.noun))
+    }
+
+    @Test func toggleNounLocks() {
+        var locked = Locked()
+        locked.toggle(.noun)
+        #expect(!locked.isLocked(.first))
+        #expect(!locked.isLocked(.second))
+        #expect(locked.isLocked(.noun))
+    }
+
+    @Test func toggleTwiceUnlocks() {
+        var locked = Locked()
+        locked.toggle(.first)
+        locked.toggle(.first)
+        #expect(!locked.isLocked(.first))
+    }
+}
+
+@Suite("Entry") struct EntryTests {
+    @Test func sfwWordReturnedWhenSfw() {
+        let entry = Entry(nsfw: "badword", nsfwMeaning: nil, word: "goodword", meaning: "a meaning")
+        #expect(entry.word(true) == "goodword")
+    }
+
+    @Test func nsfwWordReturnedWhenNsfw() {
+        let entry = Entry(nsfw: "badword", nsfwMeaning: nil, word: "goodword", meaning: "a meaning")
+        #expect(entry.word(false) == "badword")
+    }
+
+    @Test func sfwWordFallbackWhenNoNsfw() {
+        let entry = Entry(nsfw: nil, nsfwMeaning: nil, word: "goodword", meaning: "a meaning")
+        #expect(entry.word(false) == "goodword")
+    }
+
+    @Test func sfwDefinitionReturnedWhenSfw() {
+        let entry = Entry(nsfw: nil, nsfwMeaning: "bad meaning", word: "word", meaning: "good meaning")
+        #expect(entry.definition(true) == "good meaning")
+    }
+
+    @Test func nsfwDefinitionReturnedWhenNsfw() {
+        let entry = Entry(nsfw: nil, nsfwMeaning: "bad meaning", word: "word", meaning: "good meaning")
+        #expect(entry.definition(false) == "bad meaning")
+    }
+
+    @Test func sfwDefinitionFallbackWhenNoNsfwMeaning() {
+        let entry = Entry(nsfw: nil, nsfwMeaning: nil, word: "word", meaning: "good meaning")
+        #expect(entry.definition(false) == "good meaning")
+    }
+}
+
+@Suite("Sentence") struct SentenceTests {
+    let sentence = Sentence(
+        adjective1: Entry(nsfw: "nsfw1", nsfwMeaning: "nsfw meaning 1", word: "sfw1", meaning: "sfw meaning 1"),
+        adjective2: Entry(nsfw: nil, nsfwMeaning: nil, word: "sfw2", meaning: "sfw meaning 2"),
+        noun: Entry(nsfw: "nsfwNoun", nsfwMeaning: nil, word: "sfwNoun", meaning: "noun meaning")
+    )
+
+    @Test func wordFirstSfw() { #expect(sentence.word(.first, safe: true) == "sfw1") }
+    @Test func wordFirstNsfw() { #expect(sentence.word(.first, safe: false) == "nsfw1") }
+    @Test func wordSecondSfw() { #expect(sentence.word(.second, safe: true) == "sfw2") }
+    @Test func wordSecondNsfwFallsBackToSfw() { #expect(sentence.word(.second, safe: false) == "sfw2") }
+    @Test func wordNounSfw() { #expect(sentence.word(.noun, safe: true) == "sfwNoun") }
+    @Test func wordNounNsfw() { #expect(sentence.word(.noun, safe: false) == "nsfwNoun") }
+    @Test func definitionFirstSfw() { #expect(sentence.definition(.first, safe: true) == "sfw meaning 1") }
+    @Test func definitionFirstNsfw() { #expect(sentence.definition(.first, safe: false) == "nsfw meaning 1") }
+    @Test func definitionSecondSfw() { #expect(sentence.definition(.second, safe: true) == "sfw meaning 2") }
+    @Test func definitionNounSfw() { #expect(sentence.definition(.noun, safe: true) == "noun meaning") }
+}
+
+// These tests require words.json to be in Bundle.main, which is true when
+// the test host is the main app target (the default Xcode setup).
+@Suite("Word pool") struct WordPoolTests {
+    @Test func firstNotEmpty() { #expect(!Sentence.first.isEmpty) }
+    @Test func adjectivesNotEmpty() { #expect(!Sentence.adjectives.isEmpty) }
+    @Test func nounsNotEmpty() { #expect(!Sentence.nouns.isEmpty) }
+    @Test func firstHasThreeEntries() { #expect(Sentence.first.count == 3) }
+
+    @Test func newSentenceHasNonEmptyWords() {
+        let next = Sentence().new(current: Sentence())
+        #expect(!next.word(.first, safe: true).isEmpty)
+        #expect(!next.word(.second, safe: true).isEmpty)
+        #expect(!next.word(.noun, safe: true).isEmpty)
+    }
+
+    @Test func newSentenceExcludesCurrentWords() {
+        let current = Sentence().new(current: Sentence())
+        let next = current.new(current: current)
+        #expect(next.word(.first, safe: true) != current.word(.first, safe: true))
+        #expect(next.word(.second, safe: true) != current.word(.second, safe: true))
+        #expect(next.word(.noun, safe: true) != current.word(.noun, safe: true))
+    }
+}
+
+@Suite("Settings") struct SettingsTests {
+    func makeSettings(phrases: [Sentence] = [Sentence()]) -> Settings {
+        Settings(phrases: phrases, sfw: true, locked: Locked(), font: .helvetica, colorScheme: .automatic)
+    }
+
+    @Test func addIncreasesCount() {
+        let settings = makeSettings()
+        let before = settings.phrases.count
+        settings.add()
+        #expect(settings.phrases.count == before + 1)
+    }
+
+    @Test func removeDecreasesCount() {
+        let settings = makeSettings(phrases: [Sentence(), Sentence()])
+        settings.remove()
+        #expect(settings.phrases.count == 1)
+    }
+
+    @Test func removeDoesNotGoBelowOne() {
+        let settings = makeSettings()
+        settings.remove()
+        #expect(settings.phrases.count == 1)
+    }
+
+    @Test func addRespectsMaximumOfOneHundred() {
+        let phrases = (0..<100).map { _ in Sentence() }
+        let settings = makeSettings(phrases: phrases)
+        settings.add()
+        #expect(settings.phrases.count == 100)
+    }
+
+    @Test func addWithLockedFirstPreservesAdjective1() {
+        let initial = Sentence().new(current: Sentence())
+        var locked = Locked()
+        locked.toggle(.first)
+        let settings = Settings(phrases: [initial], sfw: true, locked: locked, font: .helvetica, colorScheme: .automatic)
+        let originalWord = settings.phrases[0].word(.first, safe: true)
+        settings.add()
+        #expect(settings.phrases[0].word(.first, safe: true) == originalWord)
+    }
+
+    @Test func addWithLockedSecondPreservesAdjective2() {
+        let initial = Sentence().new(current: Sentence())
+        var locked = Locked()
+        locked.toggle(.second)
+        let settings = Settings(phrases: [initial], sfw: true, locked: locked, font: .helvetica, colorScheme: .automatic)
+        let originalWord = settings.phrases[0].word(.second, safe: true)
+        settings.add()
+        #expect(settings.phrases[0].word(.second, safe: true) == originalWord)
+    }
+
+    @Test func addWithLockedNounPreservesNoun() {
+        let initial = Sentence().new(current: Sentence())
+        var locked = Locked()
+        locked.toggle(.noun)
+        let settings = Settings(phrases: [initial], sfw: true, locked: locked, font: .helvetica, colorScheme: .automatic)
+        let originalNoun = settings.phrases[0].word(.noun, safe: true)
+        settings.add()
+        #expect(settings.phrases[0].word(.noun, safe: true) == originalNoun)
+    }
+
+    @Test func removeWithLockedFirstCopiesAdjective1ToNext() {
+        let first = Sentence().new(current: Sentence())
+        let second = first.new(current: first)
+        var locked = Locked()
+        locked.toggle(.first)
+        let settings = Settings(phrases: [first, second], sfw: true, locked: locked, font: .helvetica, colorScheme: .automatic)
+        let originalWord = settings.phrases[0].word(.first, safe: true)
+        settings.remove()
+        #expect(settings.phrases[0].word(.first, safe: true) == originalWord)
+    }
 }