Backfill some tests

Author: alicerunsonfedora

AllTests.xctestplan

@@ -16,30 +16,20 @@
           "identifier" : "950402CE2D4D522100F51903",
           "name" : "Alidade"
         },
-        {
-          "containerPath" : "container:MCMaps.xcodeproj",
-          "identifier" : "950402DF2D4D522200F51903",
-          "name" : "MCMapsTests"
-        },
         {
           "containerPath" : "container:AlidadeUI",
           "identifier" : "AlidadeUI",
           "name" : "AlidadeUI"
         },
-        {
-          "containerPath" : "container:MCMapFormat",
-          "identifier" : "MCMapFormat",
-          "name" : "MCMapFormat"
-        },
-        {
-          "containerPath" : "container:MCMapFormat",
-          "identifier" : "MCMapFormatTests",
-          "name" : "MCMapFormatTests"
-        },
         {
           "containerPath" : "container:AlidadeUI",
           "identifier" : "AlidadeUITests",
           "name" : "AlidadeUITests"
+        },
+        {
+          "containerPath" : "container:MCMaps.xcodeproj",
+          "identifier" : "950402DF2D4D522200F51903",
+          "name" : "MCMapsTests"
         }
       ]
     },

MCMaps/Shared/Models/Document/IndexedPinCollection.swift

@@ -29,7 +29,7 @@ import MCMap
 struct IndexedPinCollection {
     fileprivate typealias InternalContainer = [CartographyMapPin]
     /// A structure representing an element in the collection.
-    struct Element: Identifiable {
+    struct Element: Identifiable, Equatable, Hashable {
         /// A unique identifier for the element.
         var id: Int { index }
 

MCMaps/Shared/Models/RandomAccessDictionary.swift

@@ -67,9 +67,15 @@ extension RandomAccessDictionary: Collection {
     }
 }
 
+extension RandomAccessDictionary.Element: Equatable where Key: Equatable, Value: Equatable {}
+
 extension RandomAccessDictionary: RandomAccessCollection {
+    // NOTE: This is more or less a dummy function, because dictionaries are unordered!
     func index(before index: Index) -> Index {
-        dictionary.index(index, offsetBy: -1)
+        let offset = self.distance(from: startIndex, to: index)
+        return dictionary.index(
+            after: dictionary.index(dictionary.startIndex, offsetBy: offset - 1)
+        )
     }
 }
 

MCMapsTests/Extensions/MinecraftWorldTests.swift

@@ -0,0 +1,22 @@
+//
+//  MinecraftWorldTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 04-08-2025.
+//
+
+import CubiomesKit
+import MCMap
+import Testing
+
+@testable import Alidade
+
+struct MinecraftWorldTests {
+    @Test func worldInitFromSettings() async throws {
+        let worldSettings = MCMapManifestWorldSettings(version: "1.21", seed: 123)
+        let world = try MinecraftWorld(worldSettings: worldSettings)
+
+        #expect(world.version == MC_1_21)
+        #expect(world.seed == 123)
+    }
+}

MCMapsTests/IndexedPinCollectionTests.swift

@@ -0,0 +1,53 @@
+//
+//  IndexedPinCollectionTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 04-08-2025.
+//
+
+import Foundation
+import MCMap
+import Testing
+
+@testable import Alidade
+
+struct IndexedPinCollectionTests {
+    var myPins = [
+        CartographyMapPin(named: "Spawn", at: .zero),
+        CartographyMapPin(named: "Another Pin", at: CGPoint(x: 132, y: 132)),
+        CartographyMapPin(named: "Hotel Letztes Jahr", at: CGPoint(x: 1847, y: 1963))
+    ]
+
+    @Test func indexedPinCollectionConformances() async throws {
+        let collection = IndexedPinCollection(myPins)
+        #expect(collection.count == myPins.count)
+        #expect(collection.startIndex == myPins.startIndex)
+        #expect(collection.endIndex == myPins.endIndex)
+        #expect(collection.index(after: collection.startIndex) == myPins.index(after: myPins.startIndex))
+
+        let first = try #require(collection.first)
+        #expect(first == IndexedPinCollection.Element(index: 0, content: myPins[0]))
+    }
+
+    @Test func indexedPinCollectionHashable() async throws {
+        let collection = IndexedPinCollection(myPins)
+        let hashValue = collection.hashValue
+        #expect(hashValue != 0)
+    }
+
+    @Test func indexPinCollectionCodable() async throws {
+        let collection = IndexedPinCollection(myPins)
+        let jsonEncoder = JSONEncoder()
+        let encoded = try jsonEncoder.encode(collection)
+
+        #expect(!encoded.isEmpty)
+
+        let jsonDecoder = JSONDecoder()
+        let backToCollection = try jsonDecoder.decode(IndexedPinCollection.self, from: encoded)
+        #expect(backToCollection == collection)
+
+        #if swift(>=6.2)
+        Attachment.record(encoded)
+        #endif
+    }
+}

MCMapsTests/RandomAccessDictionaryTests.swift

@@ -0,0 +1,30 @@
+//
+//  RandomAccessDictionaryTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 04-08-2025.
+//
+
+import Foundation
+import Testing
+
+@testable import Alidade
+
+struct RandomAccessDictionaryTests {
+    let originalDict = ["foo": 1, "bar": 13, "baz": 1847]
+
+    @Test func collectionConformances() async throws {
+        let rad = RandomAccessDictionary(originalDict)
+
+        #expect(rad.count == 3)
+        #expect(rad.startIndex == originalDict.startIndex)
+        #expect(rad.endIndex == originalDict.endIndex)
+        #expect(rad.index(after: rad.startIndex) == originalDict.index(after: originalDict.startIndex))
+    }
+
+    @Test func randomAccessConformances() async throws {
+        let rad = RandomAccessDictionary(originalDict)
+
+        #expect(rad.index(before: rad.endIndex).hashValue != 0)
+    }
+}

MCMapsTests/Services/CartographyClockTests.swift

@@ -0,0 +1,43 @@
+//
+//  CartographyClockTests.swift
+//  MCMaps
+//
+//  Created by Marquis Kurt on 04-08-2025.
+//
+
+import Combine
+import Foundation
+import Testing
+
+@testable import Alidade
+
+struct CartographyClockTests {
+    @Test func clockInitialValues() async throws {
+        let clock = CartographyClock()
+
+        #expect(clock.realtime.upstream.interval == 0.5)
+        #expect(clock.realtime.upstream.mode == .common)
+        #expect(clock.realtime.upstream.runLoop == RunLoop.main)
+
+        // Verify that we've made this timer infinite so as to never execute.
+        #expect(clock.bluemap.upstream.interval == .greatestFiniteMagnitude)
+    }
+
+    @Test func clockSetup() async throws {
+        let clock = CartographyClock()
+        clock.setup(timer: .bluemap, at: 100)
+        clock.start(timer: .bluemap)
+
+        #expect(clock.bluemap.upstream.interval == 100)
+    }
+
+    @Test func clockDestroy() async throws {
+        let clock = CartographyClock()
+        clock.setup(timer: .bluemap, at: 100)
+        clock.start(timer: .bluemap)
+
+        try await Task.sleep(for: .seconds(1))
+        
+        clock.stop(timer: .bluemap)
+    }
+}