Add JUnit tests for adversarial search

Author: jsuyash1514

aima-core/src/main/java/aima/core/environment/twoply/TwoPlyGame.java

@@ -0,0 +1,76 @@
+package aima.core.environment.twoply;
+
+import aima.core.environment.map.MoveToAction;
+import aima.core.search.adversarial.Game;
+
+import java.util.List;
+
+public class TwoPlyGame implements Game<TwoPlyGameState, MoveToAction, String> {
+	
+	@Override
+	public TwoPlyGameState getInitialState() {
+		return new TwoPlyGameState("A");
+	}
+	
+	@Override
+	public String[] getPlayers() {
+		return new String[]{"MAX", "MIN"};
+	}
+	
+	@Override
+	public String getPlayer(TwoPlyGameState state) {
+		switch (state.getLocation()) {
+			case "B":
+			case "C":
+			case "D":
+				return "MIN";
+			default:
+				return "MAX";
+		}
+	}
+	
+	
+	@Override
+	public List<MoveToAction> getActions(TwoPlyGameState state) {
+		return new TwoPlyGameTree().getActions(state);
+	}
+	
+	@Override
+	public TwoPlyGameState getResult(TwoPlyGameState state, MoveToAction action) {
+		return new TwoPlyGameState(action.getToLocation());
+	}
+	
+	@Override
+	public boolean isTerminal(TwoPlyGameState state) {
+		return (state.getLocation().charAt(0) > 'D');
+	}
+	
+	@Override
+	public double getUtility(TwoPlyGameState state, String player) {
+		switch (state.getLocation()) {
+			// B
+			case "E":
+				return 3;
+			case "F":
+				return 12;
+			case "G":
+				return 8;
+			// C
+			case "H":
+				return 2;
+			case "I":
+				return 4;
+			case "J":
+				return 6;
+			// D
+			case "K":
+				return 14;
+			case "L":
+				return 5;
+			case "M":
+				return 2;
+			default:
+				throw new IllegalArgumentException("State " + state.getLocation() + " unexpected.");
+		}
+	}
+}

aima-core/src/main/java/aima/core/environment/twoply/TwoPlyGameState.java

@@ -0,0 +1,31 @@
+package aima.core.environment.twoply;
+
+public class TwoPlyGameState {
+	private String location;
+	
+	public TwoPlyGameState(String location) {
+		this.location = location;
+	}
+	
+	public String getLocation() {
+		return location;
+	}
+	
+	@Override
+	public boolean equals(Object obj) {
+		if (obj instanceof TwoPlyGameState) {
+			return this.getLocation().equals(((TwoPlyGameState) obj).getLocation());
+		}
+		return super.equals(obj);
+	}
+	
+	@Override
+	public int hashCode() {
+		return getLocation().hashCode();
+	}
+	
+	@Override
+	public String toString() {
+		return location;
+	}
+}

aima-core/src/main/java/aima/core/environment/twoply/TwoPlyGameTree.java

@@ -0,0 +1,42 @@
+package aima.core.environment.twoply;
+
+import aima.core.environment.map.ExtendableMap;
+import aima.core.environment.map.Map;
+import aima.core.environment.map.MoveToAction;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TwoPlyGameTree {
+	Map aima3eFig5_2;
+	
+	public TwoPlyGameTree() {
+		aima3eFig5_2 = new ExtendableMap() {
+			{
+				addUnidirectionalLink("A", "B", 1.0);
+				addUnidirectionalLink("A", "C", 1.0);
+				addUnidirectionalLink("A", "D", 1.0);
+				addUnidirectionalLink("B", "E", 1.0);
+				addUnidirectionalLink("B", "F", 1.0);
+				addUnidirectionalLink("B", "G", 1.0);
+				addUnidirectionalLink("C", "H", 1.0);
+				addUnidirectionalLink("C", "I", 1.0);
+				addUnidirectionalLink("C", "J", 1.0);
+				addUnidirectionalLink("D", "K", 1.0);
+				addUnidirectionalLink("D", "L", 1.0);
+				addUnidirectionalLink("D", "M", 1.0);
+			}
+		};
+	}
+	
+	public List<MoveToAction> getActions(TwoPlyGameState state) {
+		List<MoveToAction> possibleActions = new ArrayList<>();
+		List<String> nextPossibleLocations = aima3eFig5_2.getPossibleNextLocations(state.getLocation());
+		for (String nextLocation : nextPossibleLocations) {
+			MoveToAction action = new MoveToAction(nextLocation);
+			possibleActions.add(action);
+		}
+		return possibleActions;
+	}
+	
+}

aima-core/src/test/java/aima/test/core/unit/search/SearchTestSuite.java

@@ -1,5 +1,7 @@
 package aima.test.core.unit.search;
 
+import aima.test.core.unit.search.adversarial.AlphaBetaSearchTest;
+import aima.test.core.unit.search.adversarial.MinimaxSearchTest;
 import aima.test.core.unit.search.csp.AssignmentTest;
 import aima.test.core.unit.search.csp.CSPTest;
 import aima.test.core.unit.search.csp.MapCSPTest;
@@ -19,8 +21,8 @@
 import org.junit.runners.Suite;
 
 @RunWith(Suite.class)
-@Suite.SuiteClasses({ AssignmentTest.class, CSPTest.class, MapCSPTest.class, MetricsTest.class, TreeCspSolverTest.class,
-		AStarSearchTest.class, GreedyBestFirstSearchTest.class, RecursiveBestFirstSearchTest.class,
+@Suite.SuiteClasses({AlphaBetaSearchTest.class, MinimaxSearchTest.class, AssignmentTest.class, CSPTest.class, MapCSPTest.class,
+		MetricsTest.class, TreeCspSolverTest.class, AStarSearchTest.class, GreedyBestFirstSearchTest.class, RecursiveBestFirstSearchTest.class,
 		SimulatedAnnealingSearchTest.class, AndOrSearchTest.class, LRTAStarAgentTest.class, OnlineDFSAgentTest.class,
 		BidirectionalSearchTest.class, BreadthFirstSearchTest.class, DepthFirstSearchTest.class,
 		DepthLimitedSearchTest.class, IterativeDeepeningSearchTest.class, UniformCostSearchTest.class, NodeTest.class,

aima-core/src/test/java/aima/test/core/unit/search/adversarial/AlphaBetaSearchTest.java

@@ -0,0 +1,38 @@
+package aima.test.core.unit.search.adversarial;
+
+import aima.core.environment.twoply.TwoPlyGame;
+import aima.core.environment.twoply.TwoPlyGameState;
+import aima.core.search.adversarial.AlphaBetaSearch;
+import aima.core.search.adversarial.Game;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class AlphaBetaSearchTest {
+	Game game;
+	AlphaBetaSearch alphaBetaSearch;
+	
+	@Before
+	public void setup() {
+		this.game = new TwoPlyGame();
+		this.alphaBetaSearch = new AlphaBetaSearch(game);
+	}
+	
+	@Test
+	public void testUtilities() {
+		TwoPlyGameState state = new TwoPlyGameState("E");
+		Assert.assertEquals(3, game.getUtility(state, game.getPlayer(state)), 0);
+		state = new TwoPlyGameState("I");
+		Assert.assertEquals(4, game.getUtility(state, game.getPlayer(state)), 0);
+		state = new TwoPlyGameState("K");
+		Assert.assertEquals(14, game.getUtility(state, game.getPlayer(state)), 0);
+		
+	}
+	
+	@Test
+	public void testMinimaxDecision() {
+		Assert.assertEquals("A", game.getInitialState().toString());
+		Assert.assertEquals("MAX", game.getPlayer(game.getInitialState()));
+		Assert.assertEquals("Action[name=moveTo, location=B]", alphaBetaSearch.makeDecision(game.getInitialState()).toString());
+	}
+}

aima-core/src/test/java/aima/test/core/unit/search/adversarial/MinimaxSearchTest.java

@@ -0,0 +1,38 @@
+package aima.test.core.unit.search.adversarial;
+
+import aima.core.environment.twoply.TwoPlyGame;
+import aima.core.environment.twoply.TwoPlyGameState;
+import aima.core.search.adversarial.Game;
+import aima.core.search.adversarial.MinimaxSearch;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class MinimaxSearchTest {
+	Game game;
+	MinimaxSearch minimaxSearch;
+	
+	@Before
+	public void setup() {
+		this.game = new TwoPlyGame();
+		this.minimaxSearch = new MinimaxSearch(game);
+	}
+	
+	@Test
+	public void testUtilities() {
+		TwoPlyGameState state = new TwoPlyGameState("E");
+		Assert.assertEquals(3, game.getUtility(state, game.getPlayer(state)), 0);
+		state = new TwoPlyGameState("I");
+		Assert.assertEquals(4, game.getUtility(state, game.getPlayer(state)), 0);
+		state = new TwoPlyGameState("K");
+		Assert.assertEquals(14, game.getUtility(state, game.getPlayer(state)), 0);
+		
+	}
+	
+	@Test
+	public void testMinimaxDecision() {
+		Assert.assertEquals("A", game.getInitialState().toString());
+		Assert.assertEquals("MAX", game.getPlayer(game.getInitialState()));
+		Assert.assertEquals("Action[name=moveTo, location=B]", minimaxSearch.makeDecision(game.getInitialState()).toString());
+	}
+}