public void InsertLetterTileTest() { bool exceptionWasThrown = false; LetterTile lt = new LetterTile('A', 1); LetterTileRack ltr = new LetterTileRack(); try { for (int i = 0; i < 7; ++i) { ltr.InsertLetterTile(lt); } } catch (LetterTileRack.InvalidLetterTileInsertionException) { exceptionWasThrown = true; } Assert.IsFalse(exceptionWasThrown); try { ltr.InsertLetterTile(lt); } catch (Exception) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); }
public void IsNullLetterTileTest() { LetterTile lt = new LetterTile('n', 0); Assert.IsTrue(lt.IsNullLetterTile()); lt = new LetterTile('A', 1); Assert.IsFalse(lt.IsNullLetterTile()); }
public void EqualsTest() { LetterTile lt1 = new LetterTile('A', 1); LetterTile lt2 = new LetterTile('A', 1); Assert.IsTrue(lt1.Equals(lt2)); lt2 = new LetterTile('E', 1); Assert.IsFalse(lt1.Equals(lt2)); lt2 = new LetterTile('A', 2); Assert.IsFalse(lt1.Equals(lt2)); }
public void LetterTileTest() { bool exceptionWasThrown = false; // Test that the null LetterTile can be created. LetterTile lt = new LetterTile('n', 0); Assert.IsTrue(lt.LetterValue == 'n' && lt.PointValue == 0); // Test that a valid LetterTile can be created lt = new LetterTile('A', 1); Assert.IsTrue(lt.LetterValue == 'A' && lt.PointValue == 1); // Test that creating a LetterTile with an invalid LetterValue throws an exception. try { lt = new LetterTile('f', 2); } catch (LetterTile.InvalidLetterValueException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); exceptionWasThrown = false; // Test that creating a LetterTile with a negative PointValue throws an exception. try { lt = new LetterTile('A', -1); } catch (LetterTile.InvalidPointValueException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); exceptionWasThrown = false; // Test that creating a LetterTile with a PointValue greater than 10 throws an exception. try { lt = new LetterTile('A', 11); } catch (LetterTile.InvalidPointValueException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); }
public void GetAllLetterTilesTest() { LetterTileRack ltr = new LetterTileRack(); LetterTile lt = new LetterTile('A', 1); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); List<LetterTile> lst = new List<LetterTile>(); lst = ltr.GetAllLetterTiles(); Assert.IsTrue(lst.Count == 3); Assert.IsTrue(lst[1].Equals(lt)); }
/// <summary> /// Inserts a LetterTile into the LetterTileRack. Throws InvalidLetterTileInsertionException. /// </summary> /// <param name="letterTileToBeInserted">The LetterTile that is being inserted into the LetterTileRack.</param> public void InsertLetterTile(LetterTile letterTileToBeInserted) { if (this.containedLetterTileSet.Count == 7) { throw new InvalidLetterTileInsertionException("The insertion of letter tile with LetterValue == " + letterTileToBeInserted.LetterValue + " and PointValue == " + letterTileToBeInserted.PointValue + " is invalid. The LetterTileRack is full."); } else { // Inserting a null LetterTile is the equivalent of not inserting anything. if (!letterTileToBeInserted.IsNullLetterTile()) { this.containedLetterTileSet.Add(letterTileToBeInserted); } } }
public void LetterTileCountTest() { LetterTileRack ltr = new LetterTileRack(); Assert.IsTrue(ltr.LetterTileCount() == 0); LetterTile lt = new LetterTile('A', 1); ltr.InsertLetterTile(lt); Assert.IsTrue(ltr.LetterTileCount() == 1); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); Assert.IsTrue(ltr.LetterTileCount() == 7); ltr.PopLetterTile(5); Assert.IsTrue(ltr.LetterTileCount() == 6); }
public void IsEmptyTest() { LetterTile lt = new LetterTile('n', 0); GameBoardSquare gbs = new GameBoardSquare(0, 0, 1, 1); Assert.IsTrue(gbs.IsEmpty()); Assert.IsTrue(gbs.ContainedLetterTile.Equals(lt)); lt = new LetterTile('A', 1); gbs.InsertLetterTile(lt); Assert.IsFalse(gbs.IsEmpty()); Assert.IsFalse(gbs.ContainedLetterTile.Equals(new LetterTile('n', 0))); }
public void InsertLetterTileTest() { GameBoardSquare gbs = new GameBoardSquare(0, 0, 1, 1); LetterTile lt = new LetterTile('A', 1); gbs.InsertLetterTile(lt); Assert.IsFalse(gbs.IsEmpty()); }
/// <summary> /// Removes the contained letter tile from the GameBoardSquare, and returns it. /// </summary> /// <returns>The LetterTile contained in the GameBoardSquare</returns> public LetterTile RemoveLetterTile() { if (this.containedTile.IsNullLetterTile()) { InvalidGameBoardSquareConfigurationException invalidGameBoardSquareConfiguration = new InvalidGameBoardSquareConfigurationException("Invalid removal of LetterTile from an already empty GameBoardSquare object."); throw invalidGameBoardSquareConfiguration; } else { LetterTile letterTileToBeReturned = this.containedTile; this.containedTile = new LetterTile('n', 0); return letterTileToBeReturned; } }
public void TestPopTile() { LetterTileRack ltr = new LetterTileRack(); LetterTile lt = new LetterTile('A', 1); ltr.InsertLetterTile(lt); bool exceptionWasThrown = false; try { ltr.PopLetterTile(new LetterTile('E', 1)); } catch { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); }
public void RemoveLetterTileTest() { GameBoardSquare gbs = new GameBoardSquare(0, 0, 1, 1); LetterTile lt1 = new LetterTile('A', 1); gbs.InsertLetterTile(lt1); Assert.IsFalse(gbs.IsEmpty()); LetterTile lt2 = gbs.RemoveLetterTile(); Assert.IsTrue(gbs.IsEmpty()); bool exceptionWasThrown = false; try { lt2 = gbs.RemoveLetterTile(); } catch (GameBoardSquare.InvalidGameBoardSquareConfigurationException e) { exceptionWasThrown = true; Assert.IsTrue(e.ToString() == "InvalidGameBoardSquareConfigurationException: Invalid removal of LetterTile from an already empty GameBoardSquare object."); } Assert.IsTrue(exceptionWasThrown); }
/// <summary> /// Inserts a LetterTile object into the GameBoardSquare, unless the GameBoardSquare already contains a LetterTile. /// Then it throw an InvalidGameBoardSquareConfigurationException. /// </summary> /// <param name="letterTileToBeInserted">The letter tile that is being inserted into the GameBoardSquare.</param> public void InsertLetterTile(LetterTile letterTileToBeInserted) { if (this.IsEmpty()) { this.containedTile = letterTileToBeInserted; } else { InvalidGameBoardSquareConfigurationException invalidGameBoardSquareConfiguration = new InvalidGameBoardSquareConfigurationException("Invalid insertion of LetterTile object into GameBoardSquareObject."); throw invalidGameBoardSquareConfiguration; } }
/// <summary> /// Initializes a new instance of the <see cref="GameBoardSquare"/> class. Throws InvalidGameBoardSquareConfigurationException. /// </summary> /// <param name="coordinateX">The private member coordinateX will be set to this value (must be from 0 - 14).</param> /// <param name="coordinateY">The private member coordinateY will be set to this value (must be from 0 - 14).</param> /// <param name="wordMultiplier">The private member wordMultiplier will be set to this value (must be from 1 - 3, /// and must be 1 if letterMultiplier is not 1).</param> /// <param name="letterMultiplier">The private member letterMultiplier will be set to this value (must be from 1 - 3, /// and must be 1 if wordMultiplier is not 1).</param> public GameBoardSquare(int coordinateX, int coordinateY, int wordMultiplier, int letterMultiplier) { if (coordinateX >= 0 && coordinateX < 15) { this.coordinateX = coordinateX; } else { InvalidGameBoardSquareConfigurationException invalidSquare = new InvalidGameBoardSquareConfigurationException("coordinateX set to " + coordinateX.ToString()); throw invalidSquare; } if (coordinateY >= 0 && coordinateY < 15) { this.coordinateY = coordinateY; } else { InvalidGameBoardSquareConfigurationException invalidSquare = new InvalidGameBoardSquareConfigurationException("coordinateY set to " + coordinateY.ToString()); throw invalidSquare; } this.isStartSquare = this.coordinateX == 7 && this.coordinateY == 7; if (wordMultiplier != 1 && letterMultiplier != 1) { InvalidGameBoardSquareConfigurationException invalidSquare = new InvalidGameBoardSquareConfigurationException("wordMultiplier = " + wordMultiplier.ToString() + ", and letterMultiplier = " + letterMultiplier.ToString()); throw invalidSquare; } if (wordMultiplier < 1 || wordMultiplier > 3) { InvalidGameBoardSquareConfigurationException invalidSquare = new InvalidGameBoardSquareConfigurationException("wordMultiplier out of bounds (wordMultiplier = " + wordMultiplier.ToString() + ")"); throw invalidSquare; } if (letterMultiplier < 1 || letterMultiplier > 3) { InvalidGameBoardSquareConfigurationException invalidSquare = new InvalidGameBoardSquareConfigurationException("letterMultiplier out of bounds (wordMultiplier = " + letterMultiplier.ToString() + ")"); throw invalidSquare; } this.wordMultiplier = wordMultiplier; this.letterMultiplier = letterMultiplier; this.containedTile = new LetterTile('n', 0); }
/// <summary> /// Pops a <see cref="LetterTile"/> from the <see cref="LetterTileRack"/>, and returns it. Throws <see cref="InvalidLetterTileAccessException"/> /// if the <see cref="LetterTile"/> was not present in the <see cref="LetterTileRack"/>. /// </summary> /// <param name="tile"></param> /// <returns></returns> public LetterTile PopLetterTile(LetterTile tile) { for (int i = 0; i < this.LetterTileCount(); ++i) { if (this.containedLetterTileSet[i].Equals(tile)) { this.containedLetterTileSet.Remove(this.containedLetterTileSet[i]); return tile; } } throw new InvalidLetterTileAccessException("InvalidLetterTileAccess: The LetterTile " + tile.LetterValue.ToString() + ", " + tile.PointValue.ToString() + " could not be found."); }
/// <summary> /// Insert a LetterTile into the bag. Throws InvalidLetterTileInsertionException. /// </summary> /// <param name="insertedLetterTile">The LetterTile to be inserted into the bag.</param> public void InsertLetterTile(LetterTile insertedLetterTile) { if (this.letterTilePointValues[insertedLetterTile.LetterValue] != insertedLetterTile.PointValue) { throw new InvalidLetterTileInsertionException("The LetterValue " + insertedLetterTile.LetterValue + " does not match the PointValue " + insertedLetterTile.PointValue.ToString() + "."); } int countOfInsertedLetterTilesAlreadyPresent = 0; foreach (LetterTile lt in this.letterTileSet) { if (lt.Equals(insertedLetterTile)) { ++countOfInsertedLetterTilesAlreadyPresent; } } if (countOfInsertedLetterTilesAlreadyPresent >= this.letterTileMaxQuantities[insertedLetterTile.LetterValue]) { throw new InvalidLetterTileInsertionException(insertedLetterTile.LetterValue.ToString()); } this.letterTileSet.Add(insertedLetterTile); }
/// <summary> /// Initialize the letterTileSet to the standard set of Scrabble letter tiles. /// </summary> private void InitializeLetterTiles() { // Add 2 blank tiles (0 points each) LetterTile lt = new LetterTile(' ', 0); this.letterTilePointValues.Add(' ', 0); this.letterTileMaxQuantities.Add(' ', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 9 'A' tiles (1 point each). lt = new LetterTile('A', 1); this.letterTilePointValues.Add('A', 1); this.letterTileMaxQuantities.Add('A', 9); for (int i = 0; i < 9; ++i) { this.letterTileSet.Add(lt); } // Add 2 'B' tiles (3 points each). lt = new LetterTile('B', 3); this.letterTilePointValues.Add('B', 3); this.letterTileMaxQuantities.Add('B', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 2 'C' tiles (3 points each). lt = new LetterTile('C', 3); this.letterTilePointValues.Add('C', 3); this.letterTileMaxQuantities.Add('C', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 4 'D' tiles (2 points each). lt = new LetterTile('D', 2); this.letterTilePointValues.Add('D', 2); this.letterTileMaxQuantities.Add('D', 4); for (int i = 0; i < 4; ++i) { this.letterTileSet.Add(lt); } // Add 12 'E' tiles (1 point each). lt = new LetterTile('E', 1); this.letterTilePointValues.Add('E', 1); this.letterTileMaxQuantities.Add('E', 12); for (int i = 0; i < 12; ++i) { this.letterTileSet.Add(lt); } // Add 2 'F' tiles (4 points each). lt = new LetterTile('F', 4); this.letterTilePointValues.Add('F', 4); this.letterTileMaxQuantities.Add('F', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 3 'G' tiles (2 points each). lt = new LetterTile('G', 2); this.letterTilePointValues.Add('G', 2); this.letterTileMaxQuantities.Add('G', 3); for (int i = 0; i < 3; ++i) { this.letterTileSet.Add(lt); } // Add 2 'H' tiles (4 points each). lt = new LetterTile('H', 4); this.letterTilePointValues.Add('H', 4); this.letterTileMaxQuantities.Add('H', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 9 'I' tiles (1 point each). lt = new LetterTile('I', 1); this.letterTilePointValues.Add('I', 1); this.letterTileMaxQuantities.Add('I', 9); for (int i = 0; i < 9; ++i) { this.letterTileSet.Add(lt); } // Add 1 'J' tile (8 points each). lt = new LetterTile('J', 8); this.letterTilePointValues.Add('J', 8); this.letterTileMaxQuantities.Add('J', 1); for (int i = 0; i < 1; ++i) { this.letterTileSet.Add(lt); } // Add 1 'K' tile (5 points each). lt = new LetterTile('K', 5); this.letterTilePointValues.Add('K', 5); this.letterTileMaxQuantities.Add('K', 1); for (int i = 0; i < 1; ++i) { this.letterTileSet.Add(lt); } // Add 4 'L' tiles (1 points each). lt = new LetterTile('L', 1); this.letterTilePointValues.Add('L', 1); this.letterTileMaxQuantities.Add('L', 4); for (int i = 0; i < 4; ++i) { this.letterTileSet.Add(lt); } // Add 2 'M' tiles (3 points each). lt = new LetterTile('M', 3); this.letterTilePointValues.Add('M', 3); this.letterTileMaxQuantities.Add('M', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 6 'N' tiles (1 points each). lt = new LetterTile('N', 1); this.letterTilePointValues.Add('N', 1); this.letterTileMaxQuantities.Add('N', 6); for (int i = 0; i < 6; ++i) { this.letterTileSet.Add(lt); } // Add 8 'O' tiles (1 points each). lt = new LetterTile('O', 1); this.letterTilePointValues.Add('O', 1); this.letterTileMaxQuantities.Add('O', 8); for (int i = 0; i < 8; ++i) { this.letterTileSet.Add(lt); } // Add 2 'P' tiles (3 points each). lt = new LetterTile('P', 3); this.letterTilePointValues.Add('P', 3); this.letterTileMaxQuantities.Add('P', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 1 'Q' tile (10 points each). lt = new LetterTile('Q', 10); this.letterTilePointValues.Add('Q', 10); this.letterTileMaxQuantities.Add('Q', 1); for (int i = 0; i < 1; ++i) { this.letterTileSet.Add(lt); } // Add 6 'R' tiles (1 points each). lt = new LetterTile('R', 1); this.letterTilePointValues.Add('R', 1); this.letterTileMaxQuantities.Add('R', 6); for (int i = 0; i < 6; ++i) { this.letterTileSet.Add(lt); } // Add 4 'S' tiles (1 points each). lt = new LetterTile('S', 1); this.letterTilePointValues.Add('S', 1); this.letterTileMaxQuantities.Add('S', 4); for (int i = 0; i < 4; ++i) { this.letterTileSet.Add(lt); } // Add 6 'T' tiles (1 points each). lt = new LetterTile('T', 1); this.letterTilePointValues.Add('T', 1); this.letterTileMaxQuantities.Add('T', 6); for (int i = 0; i < 6; ++i) { this.letterTileSet.Add(lt); } // Add 4 'U' tiles (1 points each). lt = new LetterTile('U', 1); this.letterTilePointValues.Add('U', 1); this.letterTileMaxQuantities.Add('U', 4); for (int i = 0; i < 4; ++i) { this.letterTileSet.Add(lt); } // Add 2 'V' tiles (4 points each). lt = new LetterTile('V', 4); this.letterTilePointValues.Add('V', 4); this.letterTileMaxQuantities.Add('V', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 2 'W' tiles (4 points each). lt = new LetterTile('W', 4); this.letterTilePointValues.Add('W', 4); this.letterTileMaxQuantities.Add('W', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 1 'X' tile (8 points each). lt = new LetterTile('X', 8); this.letterTilePointValues.Add('X', 8); this.letterTileMaxQuantities.Add('X', 1); for (int i = 0; i < 1; ++i) { this.letterTileSet.Add(lt); } // Add 2 'Y' tiles (4 points each). lt = new LetterTile('Y', 4); this.letterTilePointValues.Add('Y', 4); this.letterTileMaxQuantities.Add('Y', 2); for (int i = 0; i < 2; ++i) { this.letterTileSet.Add(lt); } // Add 1 'Z' tile (10 points each). lt = new LetterTile('Z', 10); this.letterTilePointValues.Add('Z', 10); this.letterTileMaxQuantities.Add('Z', 1); for (int i = 0; i < 1; ++i) { this.letterTileSet.Add(lt); } }
public void RemoveLetterTileTest() { GameBoardSquare gbs = new GameBoardSquare(0, 0, 1, 1); LetterTile lt1 = new LetterTile('A', 1); gbs.InsertLetterTile(lt1); Assert.IsFalse(gbs.IsEmpty()); LetterTile lt2 = gbs.RemoveLetterTile(); Assert.IsTrue(gbs.IsEmpty()); }
public void SquareBracketOperatorTest() { LetterTileRack ltr = new LetterTileRack(); LetterTile lt = new LetterTile('A', 1); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); Assert.IsTrue(ltr[3].Equals(lt)); bool exceptionWasThrown = false; try { char ch = ltr[4].LetterValue; } catch (LetterTileRack.InvalidLetterTileAccessException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); exceptionWasThrown = false; try { char ch = ltr[-1].LetterValue; } catch (LetterTileRack.InvalidLetterTileAccessException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); exceptionWasThrown = false; }
/// <summary> /// Compares two <see cref="LetterTile"/> objects, and tells whether they are equal. /// </summary> /// <param name="other">The <see cref="LetterTile"/> to be compared with this.</param> /// <returns>True if this == other. Returns false otherwise.</returns> public bool Equals(LetterTile other) { return this.PointValue == other.PointValue && this.LetterValue == other.LetterValue; }
public void InsertLetterTileTest() { GameBoardSquare gbs = new GameBoardSquare(0, 0, 1, 1); LetterTile lt = new LetterTile('A', 1); gbs.InsertLetterTile(lt); Assert.IsFalse(gbs.IsEmpty()); bool exceptionsWasThrown = false; try { gbs.InsertLetterTile(lt); } catch (GameBoardSquare.InvalidGameBoardSquareConfigurationException e) { exceptionsWasThrown = true; Assert.IsTrue(e.ToString() == "InvalidGameBoardSquareConfigurationException: Invalid insertion of LetterTile object into GameBoardSquareObject."); } Assert.IsTrue(exceptionsWasThrown); }
public void PopLetterTileTest() { LetterTileRack ltr = new LetterTileRack(); LetterTile lt = new LetterTile('A', 1); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); ltr.InsertLetterTile(lt); Assert.IsTrue(ltr.LetterTileCount() == 3); LetterTile lt2 = ltr.PopLetterTile(2); Assert.IsTrue(ltr.LetterTileCount() == 2); Assert.IsTrue(lt2.Equals(lt)); bool exceptionWasThrown = false; try { ltr.PopLetterTile(-1); } catch(LetterTileRack.InvalidLetterTileAccessException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); exceptionWasThrown = false; try { ltr.PopLetterTile(2); } catch (LetterTileRack.InvalidLetterTileAccessException) { exceptionWasThrown = true; } Assert.IsTrue(exceptionWasThrown); exceptionWasThrown = false; }
public void GameStateTest() { // should be able to create empty game state GameState emptyGameState = new GameState(); var user1 = new Scrabble.PlayerClass.Player(1, "user1"); emptyGameState.AddPlayer(user1); this.AssertPlayerEqual(emptyGameState.PlayerList[0], user1); // set up Board board = new Board(); List<Scrabble.PlayerClass.Player> playerList = new List<Scrabble.PlayerClass.Player>(); Bag tileBag = new Bag(); var letterTileA = new LetterTile('A', 1); var letterTileN = new LetterTile('N', 1); var letterTileT = new LetterTile('T', 1); var letterTileS = new LetterTile('S', 1); List<LetterTile> word = new List<LetterTile> { letterTileA, letterTileN, letterTileT, letterTileS }; var coordsX = new List<int>() { 6, 7, 8, 9 }; var coordsY = new List<int>() { 7, 7, 7, 7 }; Play recentPlay = new Play(word, coordsX, coordsY, 42); try { board.AddPlayToBoard(recentPlay); } catch (Exception err) { Assert.Fail(); } for (int i = 1; i <= 3; ++i) { playerList.Add(new Scrabble.PlayerClass.Player(i, "user" + i)); playerList[i - 1].AddToScore(i * 10); } playerList[2].IncrementSkipCount(); playerList[1].ToggleVote(); TurnOrder playerOrder = new TurnOrder(playerList); GameState gameState = new GameState(board, playerList, tileBag, playerOrder, recentPlay); playerList.Add(new Scrabble.PlayerClass.Player(4, "user" + 4)); playerList[3].AddToScore(4 * 10); gameState.AddPlayer(playerList[3]); var player5 = new Scrabble.PlayerClass.Player(5, "user" + 5); player5.AddToScore(5 * 10); gameState.AddPlayer(player5); Assert.IsTrue(gameState.PlayerList.Count == 4); for (int i = 0; i < playerList.Count; ++i) { this.AssertPlayerEqual(gameState.PlayerList[i], playerList[i]); } Assert.IsTrue(board.Equals(gameState.GameBoard)); Assert.IsTrue(tileBag.Equals(gameState.TileBag)); Assert.IsTrue(playerOrder.Equals(gameState.PlayerOrder)); Assert.IsTrue(recentPlay.Equals(gameState.RecentPlay)); }