formatting source

Author: BusyByte

core/src/test/scala/aima/core/environment/vacuum/ModelBasedReflexVacuumAgentSpec.scala

@@ -42,7 +42,7 @@ class ModelBasedReflexVacuumAgentSpec extends Specification {
       case LeftMoveAction => ok
     }
   }
-  
+
   "should assume dirty after moving to location A" in new context {
     agent.agentFunction.apply(LocationBPercept)
     agent.agentFunction.apply(CleanPercept)

core/src/test/scala/aima/core/environment/vacuum/ReflexVacuumAgentProgramSpec.scala

@@ -16,20 +16,19 @@ class ReflexVacuumAgentProgramSpec extends Specification with ScalaCheck {
 
   "should eventually clean environment" in prop { env: VacuumEnvironment =>
     val agentProgram = new AgentProgram {
-      lazy val agent = new SimpleReflexVacuumAgent
+      lazy val agent     = new SimpleReflexVacuumAgent
       lazy val actuators = Seq[Actuator](new SuckerActuator(agent), new MoveActuator(agent))
-      lazy val sensors = Seq[Sensor](new DirtSensor(agent), new AgentLocationSensor(agent))
+      lazy val sensors   = Seq[Sensor](new DirtSensor(agent), new AgentLocationSensor(agent))
     }
 
     @tailrec def eventuallyClean(currentEnv: Environment): Boolean = {
       currentEnv match {
         case ve: VacuumEnvironment if ve.isClean() => true
-        case _ => eventuallyClean(agentProgram.run(currentEnv))
+        case _                                     => eventuallyClean(agentProgram.run(currentEnv))
       }
     }
 
     eventuallyClean(env.addAgent(agentProgram.agent)) must beTrue
   }
 
-
 }

core/src/test/scala/aima/core/environment/vacuum/TableDrivenVacuumAgentSpec.scala

@@ -23,45 +23,44 @@ class TableDrivenVacuumAgentSpec extends Specification {
     invokeAgent(List(LocationBPercept, CleanPercept)) must_== List(NoAction, LeftMoveAction)
   }
 
-
   "second level dirty sucks" in new context {
-    val givenPercepts = List.fill(2)(NoPercept) ++ List(NoPercept, DirtyPercept)
+    val givenPercepts   = List.fill(2)(NoPercept) ++ List(NoPercept, DirtyPercept)
     val expectedActions = List.fill(2)(NoAction) ++ List(NoAction, Suck)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "second level A and Clean moves Right" in new context {
-    val givenPercepts = List.fill(2)(NoPercept) ++ List(LocationAPercept, CleanPercept)
+    val givenPercepts   = List.fill(2)(NoPercept) ++ List(LocationAPercept, CleanPercept)
     val expectedActions = List.fill(2)(NoAction) ++ List(NoAction, RightMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "second level B and Clean moves Right" in new context {
-    val givenPercepts = List.fill(2)(NoPercept) ++ List(LocationBPercept, CleanPercept)
+    val givenPercepts   = List.fill(2)(NoPercept) ++ List(LocationBPercept, CleanPercept)
     val expectedActions = List.fill(2)(NoAction) ++ List(NoAction, LeftMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "fourth level dirty sucks" in new context {
-    val givenPercepts = List.fill(6)(NoPercept) ++ List(NoPercept, DirtyPercept)
+    val givenPercepts   = List.fill(6)(NoPercept) ++ List(NoPercept, DirtyPercept)
     val expectedActions = List.fill(6)(NoAction) ++ List(NoAction, Suck)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "fourth level A and Clean moves Right" in new context {
-    val givenPercepts = List.fill(6)(NoPercept) ++ List(LocationAPercept, CleanPercept)
+    val givenPercepts   = List.fill(6)(NoPercept) ++ List(LocationAPercept, CleanPercept)
     val expectedActions = List.fill(6)(NoAction) ++ List(NoAction, RightMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "fourth level B and Clean moves Right" in new context {
-    val givenPercepts = List.fill(6)(NoPercept) ++ List(LocationBPercept, CleanPercept)
+    val givenPercepts   = List.fill(6)(NoPercept) ++ List(LocationBPercept, CleanPercept)
     val expectedActions = List.fill(6)(NoAction) ++ List(NoAction, LeftMoveAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
 
   "twenty dirty percepts is undefined because out of table definition range" in new context {
-    val givenPercepts = List.fill(20)(NoPercept)
+    val givenPercepts   = List.fill(20)(NoPercept)
     val expectedActions = List.fill(20)(NoAction)
     invokeAgent(givenPercepts) must_== expectedActions
   }
@@ -70,9 +69,9 @@ class TableDrivenVacuumAgentSpec extends Specification {
     val rnd = new Random()
     val randomPerceptStream: Stream[Percept] = Stream.continually {
       val selector = rnd.nextInt(3)
-      if(selector == 0)
+      if (selector == 0)
         LocationPercept.randomValue
-      else if(selector == 1)
+      else if (selector == 1)
         DirtPercept.randomValue
       else
         NoPercept

core/src/test/scala/aima/core/environment/vacuum/VacuumMapSpec.scala

@@ -49,96 +49,79 @@ class VacuumMapSpec extends Specification with ScalaCheck {
 
   "dirt status of agent must be dirty if all dirty" in {
     val agent = noopAgent
-    val map = VacuumMap(Vector(dirtyNode, dirtyNode)).addAgent(agent)
+    val map   = VacuumMap(Vector(dirtyNode, dirtyNode)).addAgent(agent)
 
     map.getDirtStatus(agent) must beSome(DirtyPercept)
   }
 
   "dirt status of agent must be clean if all clean" in {
     val agent = noopAgent
-    val map = VacuumMap(Vector(cleanNode, cleanNode)).addAgent(agent)
+    val map   = VacuumMap(Vector(cleanNode, cleanNode)).addAgent(agent)
 
     map.getDirtStatus(agent) must beSome(CleanPercept)
   }
 
-
   "agent location of agent not on map must be none" in prop { map: VacuumMap =>
     val agent = noopAgent
     map.getAgentLocation(agent) must beNone
   }
 
   "agent location must be A if in first spot" in {
     val agent = noopAgent
-    val map = VacuumMap(Vector(agentNode(agent), cleanNode)).addAgent(agent)
+    val map   = VacuumMap(Vector(agentNode(agent), cleanNode)).addAgent(agent)
 
     map.getAgentLocation(agent) must beSome(LocationAPercept)
   }
 
   "agent location must be B if in second spot" in {
     val agent = noopAgent
-    val map = VacuumMap(Vector(cleanNode, agentNode(agent))).addAgent(agent)
+    val map   = VacuumMap(Vector(cleanNode, agentNode(agent))).addAgent(agent)
 
     map.getAgentLocation(agent) must beSome(LocationBPercept)
   }
 
   "moving right will put in spot B" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .moveAgent(agent, RightMoveAction)
-      .getAgentLocation(agent) must beSome(LocationBPercept)
+    map.addAgent(agent).moveAgent(agent, RightMoveAction).getAgentLocation(agent) must beSome(LocationBPercept)
   }
 
   "moving left will put in spot A" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .moveAgent(agent, LeftMoveAction)
-      .getAgentLocation(agent) must beSome(LocationAPercept)
+    map.addAgent(agent).moveAgent(agent, LeftMoveAction).getAgentLocation(agent) must beSome(LocationAPercept)
   }
 
-
   "updating dirt status of dirty will return dirt percept of dirty" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .updateStatus(agent, DirtyPercept)
-      .getDirtStatus(agent) must beSome(DirtyPercept)
+    map.addAgent(agent).updateStatus(agent, DirtyPercept).getDirtStatus(agent) must beSome(DirtyPercept)
   }
 
   "updating dirt status of clean will return clean percept of dirty" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .updateStatus(agent, CleanPercept)
-      .getDirtStatus(agent) must beSome(CleanPercept)
+    map.addAgent(agent).updateStatus(agent, CleanPercept).getDirtStatus(agent) must beSome(CleanPercept)
   }
 
   "removing agent must have no location percept" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .removeAgent(agent)
-      .getAgentLocation(agent) must beNone
+    map.addAgent(agent).removeAgent(agent).getAgentLocation(agent) must beNone
   }
 
   "removing agent must have no status percept" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .removeAgent(agent)
-      .getDirtStatus(agent) must beNone
+    map.addAgent(agent).removeAgent(agent).getDirtStatus(agent) must beNone
   }
 
   "adding an agent and then removing them should be the original input, eg f'(f(x)) = x" in prop { map: VacuumMap =>
     val agent = noopAgent
-    map.addAgent(agent)
-      .removeAgent(agent) must_== map
+    map.addAgent(agent).removeAgent(agent) must_== map
   }
 
-
-
   def noopAgent = new Agent {
-    def agentFunction: AgentFunction = {_ => NoAction}
+    def agentFunction: AgentFunction = { _ =>
+      NoAction
+    }
   }
 
-
-
   def agentNode(agent: Agent = noopAgent) = VacuumMapNode(maybeAgent = Some(agent))
-  def dirtyNode = VacuumMapNode(DirtyPercept, None)
-  def cleanNode = VacuumMapNode(CleanPercept, None)
+  def dirtyNode                           = VacuumMapNode(DirtyPercept, None)
+  def cleanNode                           = VacuumMapNode(CleanPercept, None)
 }

core/src/test/scala/aima/core/search/problems/RomaniaRoadMapSpec.scala

@@ -2,6 +2,7 @@ package aima.core.search.problems
 
 import org.specs2.mutable.Specification
 import Romania._
+
 /**
   * @author Shawn Garner
   */

core/src/test/scala/aima/core/search/uninformed/RomaniaBreadthFirstSearchSpec.scala

@@ -17,11 +17,6 @@ class RomaniaBreadthFirstSearchSpec extends Specification {
     search(new RomaniaRoadProblem(In(Arad), In(Bucharest))) must_== List(GoTo(Sibiu), GoTo(Fagaras), GoTo(Bucharest))
   }
 
-  trait context extends Scope with BreadthFirstSearch {
-
-
-  }
-
-
+  trait context extends Scope with BreadthFirstSearch {}
 
 }

core/src/test/scala/aima/core/search/uninformed/RomaniaDepthLimitedTreeSearchSpec.scala

@@ -18,28 +18,22 @@ class RomaniaDepthLimitedTreeSearchSpec extends Specification {
 
   "going from Arad to Bucharest must return a list of actions with depth 19" in new context {
     search(new RomaniaRoadProblem(In(Arad), In(Bucharest)), 19) must beSuccessfulTry.like {
-      case Solution(GoTo(Sibiu)::GoTo(RimnicuVilcea)::GoTo(Pitesti)::GoTo(Bucharest)::Nil) => ok
+      case Solution(GoTo(Sibiu) :: GoTo(RimnicuVilcea) :: GoTo(Pitesti) :: GoTo(Bucharest) :: Nil) => ok
     }
   }
 
   "going from Arad to Bucharest must return a list of actions with depth 9" in new context {
     search(new RomaniaRoadProblem(In(Arad), In(Bucharest)), 9) must beSuccessfulTry.like {
-      case Solution(GoTo(Sibiu)::GoTo(RimnicuVilcea)::GoTo(Pitesti)::GoTo(Bucharest)::Nil) => ok
+      case Solution(GoTo(Sibiu) :: GoTo(RimnicuVilcea) :: GoTo(Pitesti) :: GoTo(Bucharest) :: Nil) => ok
     }
   }
 
   "going from Arad to Bucharest must return a Cuttoff with depth 1" in new context {
     search(new RomaniaRoadProblem(In(Arad), In(Bucharest)), 1) must beSuccessfulTry.like {
-      case CutOff(GoTo(Zerind)::Nil) => ok
+      case CutOff(GoTo(Zerind) :: Nil) => ok
     }
   }
 
-
-  trait context extends Scope with DepthLimitedTreeSearch {
-
-
-  }
-
-
+  trait context extends Scope with DepthLimitedTreeSearch {}
 
 }

core/src/test/scala/aima/core/search/uninformed/RomaniaIterativeDeepeningSearchSpec.scala

@@ -17,16 +17,13 @@ class RomaniaIterativeDeepeningSearchSpec extends Specification {
 
   "going from Arad to Bucharest must return a list of actions" in new context {
     search(new RomaniaRoadProblem(In(Arad), In(Bucharest))) must beSuccessfulTry.like {
-      case Solution(GoTo(Sibiu)::GoTo(Fagaras)::GoTo(Bucharest)::Nil) => ok
+      case Solution(GoTo(Sibiu) :: GoTo(Fagaras) :: GoTo(Bucharest) :: Nil) => ok
     }
   }
 
-
   trait context extends Scope with IterativeDeepeningSearch {
 
     lazy val depthLimitedTreeSearch = new DepthLimitedTreeSearch {}
   }
 
-
-
 }

core/src/test/scala/aima/core/search/uninformed/RomaniaUniformCostSearchSpec.scala

@@ -14,14 +14,12 @@ class RomaniaUniformCostSearchSpec extends Specification {
   }
 
   "going from Arad to Bucharest must return a list of actions" in new context {
-    search(new RomaniaRoadProblem(In(Arad), In(Bucharest))) must_== List(GoTo(Sibiu), GoTo(RimnicuVilcea), GoTo(Pitesti), GoTo(Bucharest))
+    search(new RomaniaRoadProblem(In(Arad), In(Bucharest))) must_== List(GoTo(Sibiu),
+                                                                         GoTo(RimnicuVilcea),
+                                                                         GoTo(Pitesti),
+                                                                         GoTo(Bucharest))
   }
 
-  trait context extends Scope with UniformCostSearch {
-
-
-  }
-
-
+  trait context extends Scope with UniformCostSearch {}
 
 }