From 96c956e03c0e08a288db34cc47ea94251574bcb6 Mon Sep 17 00:00:00 2001
From: Christian Treffs <ctreffs@gmail.com>
Date: Tue, 8 May 2018 18:29:14 +0200
Subject: [PATCH] Add SparseSet tests

---
 Sources/FirebladeECS/SparseSet.swift         |  14 +-
 Tests/FirebladeECSTests/SparseSetTests.swift | 169 ++++++++++++++++---
 2 files changed, 153 insertions(+), 30 deletions(-)

diff --git a/Sources/FirebladeECS/SparseSet.swift b/Sources/FirebladeECS/SparseSet.swift
index 74aa43e..126a93b 100644
--- a/Sources/FirebladeECS/SparseSet.swift
+++ b/Sources/FirebladeECS/SparseSet.swift
@@ -13,6 +13,10 @@ public class SparseSet<Element>: UniformStorage, Sequence {
 	private var denseData: ContiguousArray<Element>
 	private var sparse: [Index: DenseIndex]
 
+    // TODO: implement
+    // a) RandomAccessCollection conformance
+    // b) subscript
+
 	//private typealias Pair = (key: Index, value: Element)
 
 	public init() {
@@ -26,9 +30,7 @@ public class SparseSet<Element>: UniformStorage, Sequence {
 	}
 
 	public var count: Int { return size }
-	var isEmpty: Bool { return size == 0 }
-	var capacitySparse: Int { return sparse.capacity }
-	var capacityDense: Int { return denseIndices.capacity }
+	public var isEmpty: Bool { return size == 0 }
 
 	public func has(_ index: Index) -> Bool {
 		return sparse[index] ?? Int.max < count /*&&
@@ -54,12 +56,10 @@ public class SparseSet<Element>: UniformStorage, Sequence {
 
 	@discardableResult
 	public func remove(at index: Index) -> Bool {
-		guard has(index) else {
-			return false
-		}
-		guard let removeIdx: DenseIndex = sparse[index] else {
+		guard has(index), let removeIdx: DenseIndex = sparse[index] else {
 			return false
 		}
+
 		let lastIdx: DenseIndex = count - 1
 		denseIndices.swapAt(removeIdx, lastIdx)
 		denseData.swapAt(removeIdx, lastIdx)
diff --git a/Tests/FirebladeECSTests/SparseSetTests.swift b/Tests/FirebladeECSTests/SparseSetTests.swift
index a2afe5b..3f79a71 100644
--- a/Tests/FirebladeECSTests/SparseSetTests.swift
+++ b/Tests/FirebladeECSTests/SparseSetTests.swift
@@ -9,29 +9,152 @@
 import XCTest
 
 class SparseSetTests: XCTestCase {
+    
+    func testSparseSetAdd() {
+        let set = SparseSet<Position>()
+        let num: Int = 100
+        
+        for idx in 0..<num {
+            let pos = Position(x: idx, y: idx)
+            set.add(pos, at: idx)
+        }
+        
+        XCTAssertEqual(set.count, num)
+        XCTAssertEqual(set.get(at: 0)?.x, 0)
+        XCTAssertEqual(set.get(at: 1)?.x, 1)
+        XCTAssertEqual(set.get(at: 2)?.x, 2)
+        XCTAssertEqual(set.get(at: 3)?.x, 3)
+        XCTAssertEqual(set.get(at: 4)?.x, 4)
+        XCTAssertEqual(set.get(at: 5)?.x, 5)
+        XCTAssertEqual(set.get(at: 6)?.x, 6)
+        XCTAssertEqual(set.get(at: 7)?.x, 7)
+        XCTAssertEqual(set.get(at: 8)?.x, 8)
+        XCTAssertEqual(set.get(at: 9)?.x, 9)
+        XCTAssertEqual(set.get(at: 99)?.x, 99)
+        XCTAssertEqual(set.get(at: 100)?.x, nil)
+    }
+    
+    func testSparseSetAddNoReplace() {
+        let set = SparseSet<Position>()
+        let p1 = Position(x: 1, y: 1)
+        let p2 = Position(x: 2, y: 2)
+        
+        set.add(p1, at: 10)
+        
+        XCTAssertEqual(set.get(at: 10)?.x, p1.x)
+        XCTAssertEqual(set.count, 1)
+        
+        set.add(p2, at: 10)
+        
+        XCTAssertEqual(set.get(at: 10)?.x, p1.x)
+        XCTAssertEqual(set.count, 1)
+        
+    }
+    
+    func testSparseSetRemove() {
+        let set = SparseSet<Position>()
+        let num: Int = 100
+        
+        for idx in 0..<num {
+            let pos = Position(x: idx, y: idx)
+            set.add(pos, at: idx)
+        }
+        
+        XCTAssertEqual(set.count, num)
+        set.remove(at: 33)
+        XCTAssertEqual(set.count, num-1)
+        set.remove(at: 54)
+        XCTAssertEqual(set.count, num-2)
+        
+        for idx in 0..<num {
+            set.remove(at: idx)
+        }
+        
+        XCTAssertEqual(set.count, 0)
+    }
+    
+    func testSparseSetRemoveNonPresent() {
+        let set = SparseSet<Position>()
+        XCTAssertTrue(set.isEmpty)
+        XCTAssertFalse(set.remove(at: 100))
+        XCTAssertTrue(set.isEmpty)
+    }
+    
+    func testSparseSetNonCongiuousData() {
+        let set = SparseSet<Position>()
+        
+        var indices: Set<Int> = [0, 30, 1, 21, 78, 56, 99, 3]
+        
+        for idx in indices {
+            let pos = Position(x: idx, y: idx)
+            set.add(pos, at: idx)
+        }
+        
+        XCTAssertEqual(set.count, indices.count)
 
-	func testSparseComponentSet() {
-		/*
-		let s = SparseComponentSet()
+        func recurseValueTest() {
+            for idx in indices {
+                XCTAssertEqual(set.get(at: idx)?.x, idx)
+                XCTAssertEqual(set.get(at: idx)?.y, idx)
+            }
+        }
 
-		let num: Int = 100
-
-		for i in 0..<num {
-			s.add(Position(x: i, y: i), at: EntityIndex(i))
-		}
-
-		XCTAssert(s.count == num)
-
-		for i in 0..<num {
-			let idx = num - i - 1
-			let p: Position = s.get(at: idx) as! Position
-			XCTAssertEqual(idx, p.x)
-		}
-
-		for i in 0..<num {
-			s.remove(at: EntityIndex(i))
-		}
-
-		XCTAssert(s.count == 0)*/
-	}
+        recurseValueTest()
+        
+        while let idx = indices.popFirst() {
+            set.remove(at: idx)
+            recurseValueTest()
+            XCTAssertEqual(set.count, indices.count)
+        }
+        
+        XCTAssertEqual(set.count, indices.count)
+        XCTAssertEqual(set.count, 0)
+    }
+    
+    func testSparseSetClear() {
+        let set = SparseSet<Position>()
+        let num: Int = 100
+        
+        XCTAssertEqual(set.count, 0)
+        XCTAssertTrue(set.isEmpty)
+        
+        for idx in 0..<num {
+            let pos = Position(x: idx, y: idx)
+            set.add(pos, at: idx)
+        }
+        
+        XCTAssertEqual(set.count, num)
+        XCTAssertFalse(set.isEmpty)
+        
+        set.clear()
+        
+        XCTAssertEqual(set.count, 0)
+        XCTAssertTrue(set.isEmpty)
+    }
+    
+    func testSparseSetReduce() {
+        let characters = SparseSet<Character>()
+        
+        
+        characters.add("H", at: 4)
+        characters.add("e", at: 13)
+        characters.add("l", at: 34)
+        characters.add("l", at: 44)
+        characters.add("o", at: 55)
+        characters.add(" ", at: 66)
+        characters.add("W", at: 77)
+        characters.add("o", at: 89)
+        characters.add("r", at: 90)
+        characters.add("l", at: 123)
+        characters.add("d", at: 140)
+        
+        XCTAssertEqual(characters.count, 11)
+        
+        let string: String = characters.reduce("") { (res, char) in
+            return res + "\(char)"
+        }
+        
+        XCTAssertEqual(string, "Hello World")
+        
+    }
 }