Add missing tests

lucaswkuipers · Mar 5, 2024 · 74a4e63 · 74a4e63
1 parent 4f18228
commit 74a4e63
Show file tree

Hide file tree

Showing 19 changed files with 845 additions and 29 deletions.
diff --git a/Sources/SafeTypes/Collections/MultiElementsArray.swift b/Sources/SafeTypes/Collections/MultiElementsArray.swift
@@ -126,7 +126,7 @@ extension MultiElementsArray {
     }
 
     public var last: Element {
-        tail.last ?? head
+        items.last ?? second
     }
 
     public func firstIndex(where predicate: (Element) throws -> Bool) rethrows -> Int? {
@@ -240,7 +240,7 @@ extension MultiElementsArray {
     }
 
     public mutating func remove(at i: Int) -> Element? {
-        guard items.count > 1 else {
+        guard items.count > 2 else {
             return nil
         }
 
@@ -260,6 +260,10 @@ extension MultiElementsArray {
     public static func +=(lhs: inout MultiElementsArray, rhs: MultiElementsArray) {
         lhs.append(contentsOf: rhs.items)
     }
+
+    public static func +=<S>(lhs: inout MultiElementsArray, rhs: S) where S : Sequence, Element == S.Element {
+        lhs.append(contentsOf: rhs)
+    }
 }
 
 // MARK: - Sequence

diff --git a/Sources/SafeTypes/Collections/NonEmptyArray.swift b/Sources/SafeTypes/Collections/NonEmptyArray.swift
@@ -251,9 +251,17 @@ extension NonEmptyArray {
         NonEmptyArray(lhs, rhs)
     }
 
+    public static func +(lhs: NonEmptyArray, rhs: NonEmptyArray) -> MultiElementsArray<Element> {
+        MultiElementsArray(lhs.items + rhs.items)!
+    }
+
      public static func +=(lhs: inout NonEmptyArray, rhs: NonEmptyArray) {
         lhs.append(contentsOf: rhs.items)
     }
+
+    public static func +=<S>(lhs: inout NonEmptyArray, rhs: S) where S : Sequence, Element == S.Element {
+        lhs.append(contentsOf: rhs)
+    }
 }
 
 // MARK: - Sequence

diff --git a/Sources/SafeTypes/Collections/NonEmptyString.swift b/Sources/SafeTypes/Collections/NonEmptyString.swift
@@ -174,11 +174,11 @@ extension NonEmptyString {
         characters.swapAt(i, j)
     }
 
-    public mutating func append(_ newElement: Element) {
-        characters.append(newElement)
+    public mutating func append(_ newElement: String) {
+        characters.append(contentsOf: newElement)
     }
 
-    public mutating func append(_ newElements: Element...) {
+    public mutating func append(_ newElements: Character...) {
         characters.append(contentsOf: newElements)
     }
 

diff --git a/Sources/SafeTypes/Numbers/MinusOneToOne.swift b/Sources/SafeTypes/Numbers/MinusOneToOne.swift
@@ -19,7 +19,7 @@ extension MinusOneToOne {
     }
 }
 
-// MARK: - Product
+// MARK: - Multiplication
 
 extension MinusOneToOne {
     public static func *(lhs: MinusOneToOne, rhs: MinusOneToOne) -> MinusOneToOne {

diff --git a/Sources/SafeTypes/Numbers/Negative.swift b/Sources/SafeTypes/Numbers/Negative.swift
@@ -9,7 +9,7 @@ public struct Negative<Value: Number> {
     }
 }
 
-// MARK: - Product
+// MARK: - Multiplication
 
 extension Negative {
     public static func *(lhs: Negative, rhs: Negative) -> NonNegative<Value> {

diff --git a/Sources/SafeTypes/Numbers/NonNegative.swift b/Sources/SafeTypes/Numbers/NonNegative.swift
@@ -17,6 +17,30 @@ public struct NonNegative<Value: Number> {
     }
 }
 
+// MARK: - Multiplication
+
+extension NonNegative {
+    public static func *(lhs: NonNegative, rhs: NonNegative) -> NonNegative<Value> {
+        NonNegative(lhs.value * rhs.value)!
+    }
+
+    public static func *(lhs: NonNegative<Value>, rhs: Negative<Value>) -> NonPositive<Value> {
+        NonPositive(lhs.value * rhs.value)!
+    }
+}
+
+// MARK: - Addition
+
+extension NonNegative {
+    public static func +(lhs: NonNegative, rhs: NonNegative) -> NonNegative {
+        NonNegative(lhs.value + rhs.value)!
+    }
+
+    static public func +=(lhs: inout NonNegative, rhs: NonNegative) {
+        lhs = NonNegative(lhs.value + rhs.value)!
+    }
+}
+
 // MARK: - Equatable
 
 extension NonNegative: Equatable where Value: Equatable {

diff --git a/Sources/SafeTypes/Numbers/NonPositive.swift b/Sources/SafeTypes/Numbers/NonPositive.swift
@@ -13,7 +13,7 @@ public struct NonPositive<Value: Number> {
     }
 }
 
-// MARK: - Product
+// MARK: - Multiplication
 
 extension NonPositive {
     public static func *(lhs: NonPositive, rhs: NonPositive) -> NonNegative<Value> {
@@ -27,6 +27,14 @@ extension NonPositive {
     public static func *(lhs: NonNegative<Value>, rhs: NonPositive) -> NonPositive {
         NonPositive(lhs.value * rhs.value)!
     }
+
+    public static func *(lhs: NonPositive, rhs: Negative<Value>) -> NonNegative<Value> {
+        NonNegative(lhs.value * rhs.value)!
+    }
+
+    public static func *(lhs: NonPositive, rhs: Positive<Value>) -> NonPositive {
+        NonPositive(lhs.value * rhs.value)!
+    }
 }
 
 // MARK: - Addition

diff --git a/Sources/SafeTypes/Numbers/Positive.swift b/Sources/SafeTypes/Numbers/Positive.swift
@@ -9,7 +9,7 @@ public struct Positive<Value: Number> {
     }
 }
 
-// MARK: - Product
+// MARK: - Multiplication
 
 extension Positive {
     public static func *(lhs: Positive, rhs: Positive) -> NonNegative<Value> {

diff --git a/Sources/SafeTypes/Numbers/ZeroToOne.swift b/Sources/SafeTypes/Numbers/ZeroToOne.swift
@@ -19,7 +19,7 @@ extension ZeroToOne {
     }
 }
 
-// MARK: - Product
+// MARK: - Multiplication
 
 extension ZeroToOne {
     public static func *(lhs: ZeroToOne, rhs: ZeroToOne) -> ZeroToOne {

diff --git a/Tests/SafeTypesTests/Collections/MultiElementsArrayTests.swift b/Tests/SafeTypesTests/Collections/MultiElementsArrayTests.swift
@@ -0,0 +1,236 @@
+import XCTest
+@testable import SafeTypes
+
+final class MultiElementsArrayTests: XCTestCase {
+
+    // MARK: - Init
+
+    func test_init_setsItemsCorrectly() {
+        XCTAssertNil(MultiElementsArray<Any>([]))
+        XCTAssertEqual(MultiElementsArray(1, 2).items, [1, 2])
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).items, [1, 2, 3])
+        XCTAssertEqual(MultiElementsArray(1, 2, 3, 4).items, [1, 2, 3, 4])
+        XCTAssertEqual(MultiElementsArray(MultiElementsArray(1, 2), MultiElementsArray(3, 4)), MultiElementsArray(1, 2, 3, 4))
+        XCTAssertNil(MultiElementsArray(repeating: 1, count: -1))
+        XCTAssertNil(MultiElementsArray(repeating: 1, count: 0))
+        XCTAssertNil(MultiElementsArray(repeating: 1, count: 1))
+        XCTAssertEqual(MultiElementsArray(repeating: 1, count: 2), MultiElementsArray(1, 1))
+    }
+
+    // MARK: - Array
+
+    func test_isEmpty_returnsFalse() {
+        XCTAssertFalse(MultiElementsArray(1, 2).isEmpty)
+        XCTAssertFalse(MultiElementsArray(1, 2, 3).isEmpty)
+        XCTAssertFalse(MultiElementsArray(1, 2, 3, 4).isEmpty)
+    }
+
+    func test_first_returnsCorrectly() {
+        XCTAssertEqual(MultiElementsArray(2, 1).first, 2)
+        XCTAssertEqual(MultiElementsArray(3, 2, 1).first, 3)
+        XCTAssertEqual(MultiElementsArray(4, 3, 2, 1).first, 4)
+    }
+
+    func test_last_returnsCorrectly() {
+        XCTAssertEqual(MultiElementsArray(1, 2).last, 2)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).last, 3)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3, 4).last, 4)
+    }
+
+    func test_count_returnsCorrectly() {
+        XCTAssertEqual(MultiElementsArray(1, 2).count, 2)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).count, 3)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3, 4).count, 4)
+    }
+
+    func test_append_appendsItemsCorrectly() {
+        var sut = MultiElementsArray(1, 2)
+        XCTAssertEqual(sut.items, [1, 2])
+
+        sut.append(3)
+        XCTAssertEqual(sut.items, [1, 2, 3])
+
+        sut.append(4, 5)
+        XCTAssertEqual(sut.items, [1, 2, 3, 4, 5])
+
+        sut.append(6, 7, 8)
+        XCTAssertEqual(sut.items, [1, 2, 3, 4, 5, 6, 7, 8])
+
+        sut.append(contentsOf: NonEmptyArray(9, 10))
+        XCTAssertEqual(sut.items, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    }
+
+    func test_insert_insertsItemsCorrectly() {
+        var sut = MultiElementsArray(1, 2)
+
+        sut.insert(3, at: 2)
+        XCTAssertEqual(sut.items, [1, 2, 3])
+
+        XCTAssertEqual(sut.items, [1, 2, 3])
+
+        sut.insert(4, at: 3)
+        XCTAssertEqual(sut.items, [1, 2, 3, 4])
+
+        sut.insert(0, at: 0)
+        XCTAssertEqual(sut.items, [0, 1, 2, 3, 4])
+
+        sut.insert(123, at: 0)
+        XCTAssertEqual(sut.items, [123, 0, 1, 2, 3, 4])
+    }
+
+    func test_comparable_correctlyComparesNonEmptyArrays() {
+        XCTAssertFalse(MultiElementsArray(1, 2) < MultiElementsArray(1, 2))
+        XCTAssertFalse(MultiElementsArray(1, 2) > MultiElementsArray(1, 2))
+
+        XCTAssertTrue(MultiElementsArray(1, 2) < MultiElementsArray(2, 1))
+        XCTAssertFalse(MultiElementsArray(1, 2) > MultiElementsArray(2, 1))
+
+        XCTAssertTrue(MultiElementsArray(1, 2) < MultiElementsArray(1, 2, 3))
+        XCTAssertFalse(MultiElementsArray(1, 2) > MultiElementsArray(1, 2, 3))
+
+        XCTAssertFalse(MultiElementsArray(1, 2, 3) < MultiElementsArray(1, 2))
+        XCTAssertTrue(MultiElementsArray(1, 2, 3) > MultiElementsArray(1, 2))
+    }
+
+    func test_remove_returnsCorrectly() {
+        var sut = MultiElementsArray(1, 2, 3)
+
+        XCTAssertEqual(sut.remove(at: 2), 3)
+        XCTAssertNil(sut.remove(at: 0))
+        XCTAssertNil(sut.remove(at: 0))
+        XCTAssertNil(sut.remove(at: 0))
+        XCTAssertEqual(sut.items, [1, 2])
+        XCTAssertEqual(sut.count, 2)
+        XCTAssertFalse(sut.isEmpty)
+    }
+
+    func test_remove_whenOutOfBounds_returnsNil() {
+        var sut = MultiElementsArray(1, 2, 3)
+
+        XCTAssertNil(sut.remove(at: -1))
+        XCTAssertNil(sut.remove(at: 42))
+        XCTAssertEqual(sut.items, [1, 2, 3])
+        XCTAssertEqual(sut.count, 3)
+        XCTAssertFalse(sut.isEmpty)
+    }
+
+    func test_addition_returnsCorrectly() {
+        var sut = MultiElementsArray(1, 2)
+
+        sut += NonEmptyArray(3)
+        XCTAssertEqual(sut, MultiElementsArray(1, 2, 3))
+
+        sut += MultiElementsArray(4, 5)
+        XCTAssertEqual(sut, MultiElementsArray(1, 2, 3, 4, 5))
+
+        XCTAssertEqual(MultiElementsArray(1, 2) + MultiElementsArray(3, 4), MultiElementsArray(1, 2, 3, 4))
+        XCTAssertEqual(MultiElementsArray("A", "B") + NonEmptyArray("C"), MultiElementsArray("A", "B", "C"))
+        XCTAssertEqual(MultiElementsArray("A", "B") + ["C"], MultiElementsArray("A", "B", "C"))
+    }
+
+    func test_reversed_returnsCorrectly() {
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).reversed(), MultiElementsArray(3, 2, 1))
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).reversed().reversed(), MultiElementsArray(1, 2, 3))
+        XCTAssertEqual(MultiElementsArray(3, 2, 1).reversed(), MultiElementsArray(1, 2, 3))
+    }
+
+    func test_random_returnsElementContained() {
+        let sut = MultiElementsArray(1, 2, 3, 4, 5)
+
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+        XCTAssertTrue(sut.contains(sut.randomElement()))
+    }
+
+    // MARK: - Sequence
+
+    func test_forIn_loopsCorrectly() {
+        let sut = MultiElementsArray(1, 2, 3)
+
+        var items: [Int] = []
+        for item in sut {
+            items.append(item)
+        }
+
+        XCTAssertEqual(items, sut.items)
+    }
+
+    func test_forEach_loopsCorrectly() {
+        let sut = MultiElementsArray(1, 2, 3)
+
+        var items: [Int] = []
+        sut.forEach {
+            items.append($0)
+        }
+
+        XCTAssertEqual(items, sut.items)
+    }
+
+    func test_map_mapsCorrectly() {
+        let sut = MultiElementsArray(1, 2, 3)
+
+        let items = sut.map { $0 }
+
+        XCTAssertEqual(items, sut.items)
+    }
+
+    func test_reduce_reducesItemsCorrectly() {
+        let sut = MultiElementsArray(1, 2, 3)
+
+        let sum = sut.reduce(0, +)
+
+        XCTAssertEqual(sum, 6)
+    }
+
+    // MARK: - Collection
+
+    func test_startIndex_returnsZero() {
+        XCTAssertEqual(MultiElementsArray(1, 2).startIndex, 0)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).startIndex, 0)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3, 4).startIndex, 0)
+    }
+
+    func test_endIndex_returnsCorrectly() {
+        XCTAssertEqual(MultiElementsArray(1, 2).endIndex, 2)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3).endIndex, 3)
+        XCTAssertEqual(MultiElementsArray(1, 2, 3, 4).endIndex, 4)
+    }
+
+    // MARK: - MutableCollection
+
+    func test_subscriptPosition_accessCorrectElement() {
+        var sut = MultiElementsArray(1, 2, 3, 4)
+
+        XCTAssertEqual(sut[0], 1)
+        XCTAssertEqual(sut[1], 2)
+        XCTAssertEqual(sut[2], 3)
+        XCTAssertEqual(sut[3], 4)
+
+        sut[0] = 4
+        sut[1] = 3
+        sut[2] = 2
+        sut[3] = 1
+
+        XCTAssertEqual(sut[0], 4)
+        XCTAssertEqual(sut[1], 3)
+        XCTAssertEqual(sut[2], 2)
+        XCTAssertEqual(sut[3], 1)
+    }
+
+    func test_max_returnsCorrectly() {
+        let sut = MultiElementsArray(1, 2, 3)
+
+        XCTAssertEqual(sut.max(), 3)
+    }
+}
diff --git a/...s/SafeTypesTests/NonEmptyArrayTests.swift → ...ests/Collections/NonEmptyArrayTests.swift b/...s/SafeTypesTests/NonEmptyArrayTests.swift → ...ests/Collections/NonEmptyArrayTests.swift