Expand test coverage

Tests/iMessageTests/DatabaseTests.swift

@@ -129,6 +129,15 @@ struct DatabaseTests {
         #expect(!rangeMessages.isEmpty)
     }
 
+    @Test
+    func testFetchWithDefaultPredicates() async throws {
+        let chats = try db.fetch(Database.ChatFetchRequest())
+        #expect(chats.count == 2)
+
+        let messages = try db.fetch(Database.MessageFetchRequest())
+        #expect(messages.count == 5)
+    }
+
     @Test
     func testMessageFetchRequestSortAndPagination() async throws {
         let request = Database.MessageFetchRequest(

Tests/iMessageTests/DecodingTests.swift

@@ -91,4 +91,68 @@ struct DecodingTests {
         #expect(!text.contains("NSString"))
         #expect(!text.contains("NSAttributedString"))
     }
+
+    @Test
+    func testTypeGetArrayLength() {
+        #expect(Type.getArrayLength(types: []) == nil)
+        #expect(Type.getArrayLength(types: [0x40]) == nil)
+
+        let result1 = Type.getArrayLength(types: [0x5B, 0x31])
+        #expect(result1?.0 == [.array(1)])
+        #expect(result1?.1 == 2)
+
+        let result10 = Type.getArrayLength(types: [0x5B, 0x31, 0x30])
+        #expect(result10?.0 == [.array(10)])
+        #expect(result10?.1 == 3)
+
+        let result123 = Type.getArrayLength(types: [0x5B, 0x31, 0x32, 0x33])
+        #expect(result123?.0 == [.array(123)])
+        #expect(result123?.1 == 4)
+
+        #expect(Type.getArrayLength(types: [0x5B, 0x5D]) == nil)
+        #expect(Type.getArrayLength(types: [0x5B, 0x61]) == nil)
+    }
+
+    @Test
+    func testArchivableIntegerValue() throws {
+        let data = Data(hexString: Fixtures.attributedBody)!
+        let decoded = try TypedStreamDecoder.decode(data)
+
+        let nsNumberMinusOne = decoded[3]
+        #expect(nsNumberMinusOne.integerValue == -1)
+
+        let nsNumberZero = decoded[5]
+        #expect(nsNumberZero.integerValue == 0)
+
+        let nsString = decoded[0]
+        #expect(nsString.integerValue == nil)
+    }
+
+    @Test
+    func testArchivableDoubleValue() {
+        let nsNumber = Archivable.object(
+            Class(name: "NSNumber", version: 0),
+            [.double(100.001)]
+        )
+        #expect(nsNumber.doubleValue == 100.001)
+
+        let nsString = Archivable.object(
+            Class(name: "NSString", version: 1),
+            [.string("Hello")]
+        )
+        #expect(nsString.doubleValue == nil)
+
+        let nsNumberWithInt = Archivable.object(
+            Class(name: "NSNumber", version: 0),
+            [.signedInteger(42)]
+        )
+        #expect(nsNumberWithInt.doubleValue == nil)
+    }
+
+    @Test
+    func testDataHexStringInvalidReturnsNil() {
+        #expect(Data(hexString: "0g") == nil)
+        #expect(Data(hexString: "GG") == nil)
+        #expect(Data(hexString: "") != nil)
+    }
 }

Tests/iMessageTests/ModelTests.swift

@@ -0,0 +1,86 @@
+import Foundation
+import Testing
+
+@testable import iMessage
+
+@Suite
+struct ModelTests {
+    @Test
+    func testChatComparable() {
+        let older = Chat(
+            id: "chat-1",
+            displayName: nil,
+            participants: [],
+            lastMessageDate: Date.distantPast
+        )
+        let newer = Chat(
+            id: "chat-2",
+            displayName: nil,
+            participants: [],
+            lastMessageDate: Date.distantFuture
+        )
+        #expect(older < newer)
+        #expect(!(newer < older))
+
+        let noDate1 = Chat(id: "a", displayName: nil, participants: [], lastMessageDate: nil)
+        let noDate2 = Chat(id: "b", displayName: nil, participants: [], lastMessageDate: nil)
+        #expect(!(noDate1 < noDate2))
+        #expect(!(noDate2 < noDate1))
+    }
+
+    @Test
+    func testAccountServiceRawValue() {
+        #expect(Account.Service(rawValue: "iMessage") == .iMessage)
+        #expect(Account.Service(rawValue: "imessage") == .iMessage)
+        #expect(Account.Service(rawValue: "iMESSAGE") == .iMessage)
+        #expect(Account.Service(rawValue: "SMS") == .sms)
+        #expect(Account.Service(rawValue: "sms") == .sms)
+        #expect(Account.Service(rawValue: "other") == .sms)
+    }
+
+    @Test
+    func testAccountHandleCodable() throws {
+        let handle = Account.Handle(rawValue: "+1234567890")
+        let data = try JSONEncoder().encode(handle)
+        let decoded = try JSONDecoder().decode(Account.Handle.self, from: data)
+        #expect(decoded.rawValue == handle.rawValue)
+    }
+
+    @Test
+    func testAccountHandleStringLiteral() {
+        let handle: Account.Handle = "+1234567890"
+        #expect(handle.rawValue == "+1234567890")
+    }
+
+    @Test
+    func testAccountHandleDescription() {
+        let handle = Account.Handle(rawValue: "user@example.com")
+        #expect(handle.description == "user@example.com")
+    }
+
+    @Test
+    func testGUIDComparable() {
+        #expect(GUID(rawValue: "a") < GUID(rawValue: "b"))
+        #expect(!(GUID(rawValue: "b") < GUID(rawValue: "a")))
+    }
+
+    @Test
+    func testGUIDCodable() throws {
+        let guid = GUID(rawValue: "chat-guid-1")
+        let data = try JSONEncoder().encode(guid)
+        let decoded = try JSONDecoder().decode(GUID.self, from: data)
+        #expect(decoded.rawValue == guid.rawValue)
+    }
+
+    @Test
+    func testGUIDStringLiteral() {
+        let guid: GUID = "msg-123"
+        #expect(guid.rawValue == "msg-123")
+    }
+
+    @Test
+    func testGUIDDescription() {
+        let guid = GUID(rawValue: "chat-guid-1")
+        #expect(guid.description == "chat-guid-1")
+    }
+}