[Test] Add more RouteMapping tests.

Author: inamiy

Tests/MachineTests.swift

@@ -297,4 +297,74 @@ class MachineTests: _TestCase
 
         XCTAssertEqual(invokeCount, 0, "Handler should NOT be performed")
     }
+    
+    //--------------------------------------------------
+    // MARK: - EventRouteMapping
+    //--------------------------------------------------
+    
+    func testAddEventRouteMapping()
+    {
+        var invokeCount = 0
+        
+        let machine = Machine<MyState2, MyEvent2>(state: .State0("initial")) { machine in
+            
+            // add EventRouteMapping
+            machine.addRouteMapping { event, fromState, userInfo -> MyState2? in
+                // no route for no-event
+                guard let event = event else { return nil }
+                
+                switch (event, fromState) {
+                    case (.Event0("gogogo"), .State0("initial")):
+                        return .State0("Phase 1")
+                    case (.Event0("gogogo"), .State0("Phase 1")):
+                        return .State0("Phase 2")
+                    case (.Event0("finish"), .State0("Phase 2")):
+                        return .State0("end")
+                    default:
+                        return nil
+                }
+            }
+            
+            machine.addHandler(event: .Event0("gogogo")) { context in
+                invokeCount++
+                return
+            }
+            
+        }
+        
+        // initial
+        XCTAssertEqual(machine.state, MyState2.State0("initial"))
+        
+        // tryEvent (fails)
+        machine <-! .Event0("go?")
+        XCTAssertEqual(machine.state, MyState2.State0("initial"), "No change.")
+        XCTAssertEqual(invokeCount, 0, "Handler should NOT be performed")
+        
+        // tryEvent
+        machine <-! .Event0("gogogo")
+        XCTAssertEqual(machine.state, MyState2.State0("Phase 1"))
+        XCTAssertEqual(invokeCount, 1)
+        
+        // tryEvent (fails)
+        machine <-! .Event0("finish")
+        XCTAssertEqual(machine.state, MyState2.State0("Phase 1"), "No change.")
+        XCTAssertEqual(invokeCount, 1, "Handler should NOT be performed")
+        
+        // tryEvent
+        machine <-! .Event0("gogogo")
+        XCTAssertEqual(machine.state, MyState2.State0("Phase 2"))
+        XCTAssertEqual(invokeCount, 2)
+        
+        // tryEvent (fails)
+        machine <-! .Event0("gogogo")
+        XCTAssertEqual(machine.state, MyState2.State0("Phase 2"), "No change.")
+        XCTAssertEqual(invokeCount, 2, "Handler should NOT be performed")
+        
+        // tryEvent
+        machine <-! .Event0("finish")
+        XCTAssertEqual(machine.state, MyState2.State0("end"))
+        XCTAssertEqual(invokeCount, 2, "gogogo-Handler should NOT be performed")
+        
+    }
+    
 }

Tests/RouteMappingTests.swift

@@ -80,6 +80,7 @@ class RouteMappingTests: _TestCase
 
         let machine = StateMachine<_State, _Event>(state: .Pending) { machine in
 
+            // add EventRouteMapping
             machine.addRouteMapping { event, fromState, userInfo in
                 // no routes for no event
                 guard let event = event else {
@@ -119,7 +120,6 @@ class RouteMappingTests: _TestCase
 
         // LoadAction(1) (same as before)
         machine <-! .LoadAction(1)
-        print(machine.state)
         XCTAssertEqual(machine.state, _State.Loading(1))
         XCTAssertEqual(count, 1, "`tryEvent()` failed, and `count` should not be incremented.")
 
@@ -131,4 +131,55 @@ class RouteMappingTests: _TestCase
         XCTAssertEqual(machine.state, _State.Pending)
         XCTAssertEqual(count, 3)
     }
+    
+    func testStateWithAssociatedValue()
+    {
+        var count = 0
+        
+        let machine = StateMachine<_State, _Event>(state: .Pending) { machine in
+            
+            // add StateRouteMapping
+            machine.addRouteMapping { fromState, userInfo in
+                switch fromState {
+                    case .Pending:
+                        return [.Loading(1)]
+                    case .Loading(let actionId):
+                        return [.Loading(actionId+10), .Loading(actionId+100)]
+                }
+            }
+            
+            // increment `count` when any events i.e. `.CancelAction` and `.LoadAction(x)` succeed.
+            machine.addHandler(.Any => .Any) { event, transition, order, userInfo in
+                count++
+            }
+            
+        }
+        
+        // initial
+        XCTAssertEqual(machine.state, _State.Pending)
+        XCTAssertEqual(count, 0)
+        
+        // .Loading(999) (fails)
+        machine <- .Loading(999)
+        XCTAssertEqual(machine.state, _State.Pending)
+        XCTAssertEqual(count, 0, "`tryState()` failed, and `count` should not be incremented.")
+        
+        // .Loading(1)
+        machine <- .Loading(1)
+        XCTAssertEqual(machine.state, _State.Loading(1))
+        XCTAssertEqual(count, 1)
+        
+        // .Loading(999) (fails)
+        machine <- .Loading(999)
+        XCTAssertEqual(machine.state, _State.Loading(1))
+        XCTAssertEqual(count, 1, "`tryState()` failed, and `count` should not be incremented.")
+        
+        machine <- .Loading(11)
+        XCTAssertEqual(machine.state, _State.Loading(11))
+        XCTAssertEqual(count, 2)
+        
+        machine <- .Loading(111)
+        XCTAssertEqual(machine.state, _State.Loading(111))
+        XCTAssertEqual(count, 3)
+    }
 }

Tests/StateMachineTests.swift

@@ -544,10 +544,11 @@ class StateMachineTests: _TestCase
     }
 
     //--------------------------------------------------
-    // MARK: - StateRouteMapping
+    // MARK: - Event/StateRouteMapping
     //--------------------------------------------------
 
-    func testStateRouteMapping()
+    /// Test `Event/StateRouteMapping`s.
+    func testRouteMapping()
     {
         var routeMappingDisposable: Disposable?