TestMapModel

java.lang.Object
- testing.shared.model.map.TestMapModel

public class TestMapModel
extends java.lang.Object

Field Summary

Fields
Modifier and Type Field and Description

private MapModel model

Fields
Modifier and Type	Field and Description
`private MapModel`	`model`

Constructor Summary

Constructors
Constructor and Description

TestMapModel()

Constructors
Constructor and Description
`TestMapModel()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`setUp()`
`void`	`tearDown()`
`void`	`testCanPlaceCity_CityExists()` A city cannot be placed on another city regardless of color.
`void`	`testCanPlaceCity_Invalid()` Attempt to place city on a coordinate that doesn't exist.
`void`	`testCanPlaceCity_NotEstablished()` A city requires a settlement to be placed.
`void`	`testCanPlaceCity_True()` A city can be placed on a settlement of like color.
`void`	`testCanPlacePip_False()` A pip cannot be placed on water.
`void`	`testCanPlacePip_Invalid()` Attempt to place pip on a hex that doesn't exist.
`void`	`testCanPlacePip_True()` Should be allowed to place pip.
`void`	`testCanPlacePip_Uninitialized()` Pips can't be placed until the hexes have been initialized.
`void`	`testCanPlaceRoad_InvalidEdge()` No end points are satisfied.
`void`	`testCanPlaceRoad_RoadExists()` Attempts to place roads on already existed roads.
`void`	`testCanPlaceRoad_RoadSatisfied()` Roads can be added to other roads of like color.
`void`	`testCanPlaceRoad_VillageSatisfied()` Village is used to refer to cities or settlements.
`void`	`testCanPlaceRobber_False()` The robber cannot be placed on water.
`void`	`testCanPlaceRobber_Invalid()` Hexes need to be generated, which is done in the MapGenerator.
`void`	`testCanPlaceRobber_Valid()` Test valid placement of robber.
`void`	`testCanPlaceSettlement_ExistingNeighbor()` A settlement can't be placed when too close to other villages.
`void`	`testCanPlaceSettlement_InvalidVertex()` Attempts to use a vertex that doesn't exist.
`void`	`testCanPlaceSettlement_VillageExists()` This village can't be placed as a village or city is already in the location.
`void`	`testCanPlaceSettlementInitial_True()` This settlement can be placed as the location is valid an no other pieces are on the board to restrict it.
`void`	`testContainsEdge_False()` Edges are initialized automatically.
`void`	`testContainsEdge_True()` Tests for an existing edge.
`void`	`testContainsHex_InvalidHex()` This checks a hex that shouldn't exist after initialization.
`void`	`testContainsVertex_False()` Vertices are initialized automatically.
`void`	`testContainsVertex_True()` Tests a valid vertex.
`void`	`testGetEdge_Invalid()` Attempt to get edge that doesn't exist.
`void`	`testGetEdge_Valid()` Valid attempt to get edge.
`void`	`testGetEdges()` Should return all the edges in the map.
`void`	`testGetHex_InvalidHex()` Thrown when trying to access a invalid hex coordinate.
`void`	`testGetHex_Valid()` Valid attempt to get hex.
`void`	`testGetHexes_Initialized()` When fully inititalized, 37 hexes should exist.
`void`	`testGetHexes_Uninitialized()` When uninitialized, a null iterator should be returned.
`void`	`testGetLongestRoad()`
`void`	`testGetLongestRoadSpecialCase()`
`void`	`testGetPips()` Test to make sure we get all the pips.
`void`	`testGetPorts()` Tests to make sure we get all the ports.
`void`	`testGetVertex_Invalid()` Attempt to access a vertex that doesn't exist.
`void`	`testGetVertex_Valid()` Should be able to access vertex.
`void`	`testGetVertices()` Should get a list of all vertices.
`void`	`testGetVerticesVertex_Center()` Gets the neighboring vertices.
`void`	`testGetVerticiesHex_Exterior()` Gets the vertices around an exterior hex.
`void`	`testGetVerticiesHex_Interior()` Gets the vertices around an interior hex.
`void`	`testHexExists_Initialized()` Map generator initializes the hexes.
`void`	`testIsRobberInitialized_True()` By running the map generator, the robber should get initialized.
`void`	`testPlaceCity_Invalid()` Attempt to place a city on a non-existent vertex.
`void`	`testPlaceCity_NotEstablished()` Attempt to place a city on a vertex that doesn't contain a settlement.
`void`	`testPlaceCity_Valid()` Valid placement of a city on a matching settlement.
`void`	`testPlaceCity_WrongColor()` Attempt to steal a settlement.
`void`	`testPlaceHex_Overflow()` The map can only store a certain amount of tiles for a valid board.
`void`	`testPlaceHex_Overwrite()` Can't use set hex to overwrite existing hexes.
`void`	`testPlaceHex_Valid()` Successfully adds hex.
`void`	`testPlacePort_DryPort()` Attempts to place port on something other than water.
`void`	`testPlacePort_InvalidVertices()` Uses invalid verticies for the edge.
`void`	`testPlaceRoad_EndNotSatisified()` Attempts to add road when the end condition isn't satisfied.
`void`	`testPlaceRoad_InvalidEdge()` Attempt to add road across hex.
`void`	`testPlaceRoad_RoadExists()` Can't place a road on an existing road.
`void`	`testPlaceRoad_Valid()` Satisfies all conditions to make road.
`void`	`testPlaceRobber_Fail()` Attempts to place robber in water, which is not valid.
`void`	`testPlaceRobber()` Successfully call of placing robber.
`void`	`testPlaceSettlement_ExistingNeighbor()` Settlements can't have neighbors.
`void`	`testPlaceSettlement_InvalidVertex()` Exception should be thrown for a vertex that doesn't exist.
`void`	`testPlaceSettlement_Valid()`
`void`	`testPlaceSettlement_VillageExists()` Can't place a village on an already occupied vertex.
`void`	`testSetPort_Valid()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - model
```
private MapModel model
```
- Constructor Detail
  - TestMapModel
```
public TestMapModel()
```
- Method Detail
  - setUp
```
public void setUp()
           throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - tearDown
```
public void tearDown()
              throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - testIsRobberInitialized_True
```
public void testIsRobberInitialized_True()
```
    By running the map generator, the robber should get initialized.
  - testContainsEdge_False
```
public void testContainsEdge_False()
```
    Edges are initialized automatically. The edge passed in shouldn't exist as it passes across the face of a hex. The method should return the same results regardless of the order the points are passed in.
  - testContainsEdge_True
```
public void testContainsEdge_True()
```
    Tests for an existing edge. The method should work regardless of the order the parameters are passed in.
  - testContainsVertex_False
```
public void testContainsVertex_False()
```
    Vertices are initialized automatically. They only exist if they border a hex that isn't water.
  - testContainsVertex_True
```
public void testContainsVertex_True()
```
    Tests a valid vertex.
  - testHexExists_Initialized
```
public void testHexExists_Initialized()
```
    Map generator initializes the hexes. Passing in a valid coordinate should return true.
  - testContainsHex_InvalidHex
```
public void testContainsHex_InvalidHex()
```
    This checks a hex that shouldn't exist after initialization. Ensures that the method still returns false even with hexes in the system.
  - testCanPlaceRoad_InvalidEdge
```
public void testCanPlaceRoad_InvalidEdge()
```
    No end points are satisfied. The road cannot be built. The method should return the same results regardless of point order.
  - testCanPlaceRoad_RoadExists
```
public void testCanPlaceRoad_RoadExists()
                                 throws MapException
```
    Attempts to place roads on already existed roads. This shouldn't be allowed. The method should return the same results regardless of point order.
    
    Throws:
    
    MapException - This shouldn't occur.
  - testCanPlaceRoad_VillageSatisfied
```
public void testCanPlaceRoad_VillageSatisfied()
                                       throws MapException
```
    Village is used to refer to cities or settlements. This tests that roads can be placed when one of the ends are satisfied. The method should return the same result regardless of point order.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testCanPlaceRoad_RoadSatisfied
```
public void testCanPlaceRoad_RoadSatisfied()
                                    throws MapException
```
    Roads can be added to other roads of like color. The method return the same value regardless of point order.
    
    Throws:
    
    MapException - Shouldn't occur
  - testCanPlaceSettlement_VillageExists
```
public void testCanPlaceSettlement_VillageExists()
                                          throws MapException
```
    This village can't be placed as a village or city is already in the location.
    
    Throws:
    
    MapException - This shouldn't occur
  - testCanPlaceSettlement_ExistingNeighbor
```
public void testCanPlaceSettlement_ExistingNeighbor()
                                             throws MapException
```
    A settlement can't be placed when too close to other villages.
    
    Throws:
    
    MapException - Shouldn't occur
  - testCanPlaceSettlement_InvalidVertex
```
public void testCanPlaceSettlement_InvalidVertex()
```
    Attempts to use a vertex that doesn't exist. Shouldn't allow placement.
  - testCanPlaceSettlementInitial_True
```
public void testCanPlaceSettlementInitial_True()
```
    This settlement can be placed as the location is valid an no other pieces are on the board to restrict it.
  - testCanPlaceCity_CityExists
```
public void testCanPlaceCity_CityExists()
                                 throws MapException
```
    A city cannot be placed on another city regardless of color. A city cannot be placed on a settlement of another color.
    
    Throws:
    
    MapException - Shouldn't occur
  - testCanPlaceCity_NotEstablished
```
public void testCanPlaceCity_NotEstablished()
```
    A city requires a settlement to be placed.
  - testCanPlaceCity_Invalid
```
public void testCanPlaceCity_Invalid()
```
    Attempt to place city on a coordinate that doesn't exist.
  - testCanPlaceCity_True
```
public void testCanPlaceCity_True()
                           throws MapException
```
    A city can be placed on a settlement of like color.
    
    Throws:
    
    MapException - Shouldn't occur
  - testCanPlaceRobber_False
```
public void testCanPlaceRobber_False()
```
    The robber cannot be placed on water.
  - testCanPlaceRobber_Invalid
```
public void testCanPlaceRobber_Invalid()
```
    Hexes need to be generated, which is done in the MapGenerator. The hex (0,0) doesn't exist.
  - testCanPlaceRobber_Valid
```
public void testCanPlaceRobber_Valid()
```
    Test valid placement of robber.
  - testCanPlacePip_False
```
public void testCanPlacePip_False()
```
    A pip cannot be placed on water.
  - testCanPlacePip_Uninitialized
```
public void testCanPlacePip_Uninitialized()
```
    Pips can't be placed until the hexes have been initialized.
  - testCanPlacePip_Invalid
```
public void testCanPlacePip_Invalid()
```
    Attempt to place pip on a hex that doesn't exist.
  - testCanPlacePip_True
```
public void testCanPlacePip_True()
```
    Should be allowed to place pip.
  - testPlaceHex_Overwrite
```
public void testPlaceHex_Overwrite()
                            throws MapException
```
    Can't use set hex to overwrite existing hexes.
    
    Throws:
    
    MapException - Thrown due to attempt to overwrite.
  - testPlaceHex_Overflow
```
public void testPlaceHex_Overflow()
                           throws MapException
```
    The map can only store a certain amount of tiles for a valid board.
    
    Throws:
    
    MapException - Thrown because too many tiles are added.
  - testPlaceHex_Valid
```
public void testPlaceHex_Valid()
                        throws MapException
```
    Successfully adds hex.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testPlaceRoad_InvalidEdge
```
public void testPlaceRoad_InvalidEdge()
                               throws MapException
```
    Attempt to add road across hex.
    
    Throws:
    
    MapException - Thrown as the road doesn't exist.
  - testPlaceRoad_RoadExists
```
public void testPlaceRoad_RoadExists()
                              throws MapException
```
    Can't place a road on an existing road.
    
    Throws:
    
    MapException - Should be thrown at second road placement attempt.
  - testPlaceRoad_EndNotSatisified
```
public void testPlaceRoad_EndNotSatisified()
                                    throws MapException
```
    Attempts to add road when the end condition isn't satisfied.
    
    Throws:
    
    MapException - Thrown when road is placed.
  - testPlaceRoad_Valid
```
public void testPlaceRoad_Valid()
                         throws MapException
```
    Satisfies all conditions to make road.
    
    Throws:
    
    MapException
  - testPlaceSettlement_VillageExists
```
public void testPlaceSettlement_VillageExists()
                                       throws MapException
```
    Can't place a village on an already occupied vertex.
    
    Throws:
    
    MapException - Thrown when trying to replace village.
  - testPlaceSettlement_ExistingNeighbor
```
public void testPlaceSettlement_ExistingNeighbor()
                                          throws MapException
```
    Settlements can't have neighbors. An exception should be thrown.
    
    Throws:
    
    MapException - Thrown when attempt is made to add neighbor.
  - testPlaceSettlement_InvalidVertex
```
public void testPlaceSettlement_InvalidVertex()
                                       throws MapException
```
    Exception should be thrown for a vertex that doesn't exist.
    
    Throws:
    
    MapException - Thrown when attempting to place on invalid vertex.
  - testPlaceSettlement_Valid
```
public void testPlaceSettlement_Valid()
                               throws MapException
```
    Throws:
    
    MapException
  - testPlaceCity_Invalid
```
public void testPlaceCity_Invalid()
                           throws MapException
```
    Attempt to place a city on a non-existent vertex.
    
    Throws:
    
    MapException - Thrown in attempt to place city.
  - testPlaceCity_NotEstablished
```
public void testPlaceCity_NotEstablished()
                                  throws MapException
```
    Attempt to place a city on a vertex that doesn't contain a settlement.
    
    Throws:
    
    MapException - Thrown when placing city.
  - testPlaceCity_WrongColor
```
public void testPlaceCity_WrongColor()
                              throws MapException
```
    Attempt to steal a settlement.
    
    Throws:
    
    MapException - Thrown when placing city.
  - testPlaceCity_Valid
```
public void testPlaceCity_Valid()
                         throws MapException
```
    Valid placement of a city on a matching settlement.
    
    Throws:
    
    MapException - Shouldn't be thrown.
  - testPlacePort_DryPort
```
public void testPlacePort_DryPort()
                           throws MapException
```
    Attempts to place port on something other than water.
    
    Throws:
    
    MapException - Thrown when placing port.
  - testPlacePort_InvalidVertices
```
public void testPlacePort_InvalidVertices()
                                   throws MapException
```
    Uses invalid verticies for the edge.
    
    Throws:
    
    MapException - Thrown when placing port.
  - testSetPort_Valid
```
public void testSetPort_Valid()
                       throws MapException
```
    Throws:
    
    MapException
  - testPlaceRobber_Fail
```
public void testPlaceRobber_Fail()
                          throws MapException
```
    Attempts to place robber in water, which is not valid.
    
    Throws:
    
    MapException - Thrown upon placing robber.
  - testPlaceRobber
```
public void testPlaceRobber()
                     throws MapException
```
    Successfully call of placing robber.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testGetHex_InvalidHex
```
public void testGetHex_InvalidHex()
                           throws MapException
```
    Thrown when trying to access a invalid hex coordinate.
    
    Throws:
    
    MapException - Thrown accessing hex.
  - testGetHex_Valid
```
public void testGetHex_Valid()
                      throws MapException
```
    Valid attempt to get hex.
    
    Throws:
    
    MapException
  - testGetHexes_Uninitialized
```
public void testGetHexes_Uninitialized()
```
    When uninitialized, a null iterator should be returned.
  - testGetHexes_Initialized
```
public void testGetHexes_Initialized()
```
    When fully inititalized, 37 hexes should exist.
  - testGetEdge_Invalid
```
public void testGetEdge_Invalid()
                         throws MapException
```
    Attempt to get edge that doesn't exist.
    
    Throws:
    
    MapException - Thrown when getting edge.
  - testGetEdge_Valid
```
public void testGetEdge_Valid()
                       throws MapException
```
    Valid attempt to get edge. Edge should be able to be accessed regardless of the point order.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testGetEdges
```
public void testGetEdges()
```
    Should return all the edges in the map. Edges get created on creation, so they should always exist.
  - testGetVertex_Invalid
```
public void testGetVertex_Invalid()
                           throws MapException
```
    Attempt to access a vertex that doesn't exist.
    
    Throws:
    
    MapException - Thrown when accessing invalid vertex.
  - testGetVertex_Valid
```
public void testGetVertex_Valid()
                         throws MapException
```
    Should be able to access vertex.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testGetVertices
```
public void testGetVertices()
```
    Should get a list of all vertices. Vertices are initialized on creation, so they should always exist.
  - testGetVerticiesHex_Interior
```
public void testGetVerticiesHex_Interior()
                                  throws MapException
```
    Gets the vertices around an interior hex. There should be 6.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testGetVerticiesHex_Exterior
```
public void testGetVerticiesHex_Exterior()
                                  throws MapException
```
    Gets the vertices around an exterior hex. There should be 3.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testGetVerticesVertex_Center
```
public void testGetVerticesVertex_Center()
                                  throws MapException
```
    Gets the neighboring vertices. There should be 3.
    
    Throws:
    
    MapException - Shouldn't occur.
  - testGetPorts
```
public void testGetPorts()
```
    Tests to make sure we get all the ports.
  - testGetPips
```
public void testGetPips()
```
    Test to make sure we get all the pips.
  - testGetLongestRoad
```
public void testGetLongestRoad()
                        throws MapException
```
    Throws:
    
    MapException
  - testGetLongestRoadSpecialCase
```
public void testGetLongestRoadSpecialCase()
                                   throws MapException
```
    Throws:
    
    MapException

Class TestMapModel

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

model

Constructor Detail

TestMapModel

Method Detail

setUp

tearDown

testIsRobberInitialized_True

testContainsEdge_False

testContainsEdge_True

testContainsVertex_False

testContainsVertex_True

testHexExists_Initialized

testContainsHex_InvalidHex

testCanPlaceRoad_InvalidEdge

testCanPlaceRoad_RoadExists

testCanPlaceRoad_VillageSatisfied

testCanPlaceRoad_RoadSatisfied

testCanPlaceSettlement_VillageExists

testCanPlaceSettlement_ExistingNeighbor

testCanPlaceSettlement_InvalidVertex

testCanPlaceSettlementInitial_True

testCanPlaceCity_CityExists

testCanPlaceCity_NotEstablished

testCanPlaceCity_Invalid

testCanPlaceCity_True

testCanPlaceRobber_False

testCanPlaceRobber_Invalid

testCanPlaceRobber_Valid

testCanPlacePip_False

testCanPlacePip_Uninitialized

testCanPlacePip_Invalid

testCanPlacePip_True

testPlaceHex_Overwrite

testPlaceHex_Overflow

testPlaceHex_Valid

testPlaceRoad_InvalidEdge

testPlaceRoad_RoadExists

testPlaceRoad_EndNotSatisified

testPlaceRoad_Valid

testPlaceSettlement_VillageExists

testPlaceSettlement_ExistingNeighbor

testPlaceSettlement_InvalidVertex

testPlaceSettlement_Valid

testPlaceCity_Invalid

testPlaceCity_NotEstablished

testPlaceCity_WrongColor

testPlaceCity_Valid

testPlacePort_DryPort

testPlacePort_InvalidVertices

testSetPort_Valid

testPlaceRobber_Fail

testPlaceRobber

testGetHex_InvalidHex

testGetHex_Valid

testGetHexes_Uninitialized

testGetHexes_Initialized

testGetEdge_Invalid

testGetEdge_Valid

testGetEdges

testGetVertex_Invalid

testGetVertex_Valid

testGetVertices

testGetVerticiesHex_Interior

testGetVerticiesHex_Exterior

testGetVerticesVertex_Center

testGetPorts

testGetPips

testGetLongestRoad

testGetLongestRoadSpecialCase