public void MessageDisplayed_OnFighterFullyHealed()
{
//arrange
_humanPlayer1.SetHealth(100, 1);
_humanPlayer1.SetMove(_doNothingMove);
_humanPlayer2.SetMove(_doNothingMove);
_humanTeam.SetDeathsOnRoundEndEvent();
_enemyPlayer1.SetMove(_doNothingMove);
_enemyPlayer2.SetMove(_doNothingMove);
_humanPlayer1.TurnEnded += delegate { _humanPlayer1.FullyHeal(); };
//Act
_battleManager.Battle(_humanTeam, _enemyTeam);
//Assert
MockOutputMessage[] outputs = _output.GetOutputs();
string expectedMessage = $"{_humanPlayer1.DisplayName}'s HP was fully restored!\n";
MockOutputMessage output = outputs.FirstOrDefault(o => o.Message == expectedMessage);
Assert.NotNull(output);
}
public void MessageDisplayed_OnStatIncrease([Values] StatType raisedStat, [Range(1, 5)] int boostAmount)
{
//arrange
_humanPlayer1.SetMove(_doNothingMove);
_humanPlayer2.SetMove(_doNothingMove);
_humanTeam.SetDeathsOnRoundEndEvent();
_enemyPlayer1.SetMove(_doNothingMove);
_enemyPlayer2.SetMove(_doNothingMove);
StatRaisedEventArgs e = new StatRaisedEventArgs(raisedStat, boostAmount);
_humanPlayer1.TurnEnded += delegate { _humanPlayer1.OnStatRaised(e); };
//Act
_battleManager.Battle(_humanTeam, _enemyTeam);
//Assert
MockOutputMessage[] outputs = _output.GetOutputs();
string statTypeString = raisedStat == StatType.Evade ? "evasion" : raisedStat.ToString().ToLower();
string expectedMessage = $"{_humanPlayer1.DisplayName}'s {statTypeString} was raised by {boostAmount}!\n";
MockOutputMessage output = outputs.FirstOrDefault(o => o.Message == expectedMessage);
Assert.NotNull(output);
}
public void CorrectlyDisallowsOutOfRangeInput([Values(-1, -5, 1, 7)] int overUnderValue)
{
int value;
if (overUnderValue < 0)
{
value = MinValue + overUnderValue;
}
else
{
value = MaxValue + overUnderValue;
}
_input.Push(value.ToString(), MinValue.ToString());
_menu.GetInput();
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(3, outputs.Length);
MockOutputMessage output = outputs[1];
string expectedError = $"input must be between { MinValue} and { MaxValue}, inclusive\n";
Assert.AreEqual(expectedError, output.Message);
Assert.AreEqual(ConsoleColor.Red, Globals.ErrorColor);
}
public void MessageDisplayed_OnFighterHealed([Values(5, 10, 25)] int healAmount, [Values] bool shouldTryToOverheal)
{
//arrange
_humanPlayer1.SetHealth(100, shouldTryToOverheal ? 99 : 1);
_humanPlayer1.SetMove(_doNothingMove);
_humanPlayer2.SetMove(_doNothingMove);
_humanTeam.SetDeathsOnRoundEndEvent();
_enemyPlayer1.SetMove(_doNothingMove);
_enemyPlayer2.SetMove(_doNothingMove);
_humanPlayer1.TurnEnded += delegate { _humanPlayer1.Heal(healAmount); };
//Act
_battleManager.Battle(_humanTeam, _enemyTeam);
//Assert
MockOutputMessage[] outputs = _output.GetOutputs();
int expectedHealAmount = shouldTryToOverheal ? 1 : healAmount;
string expectedMessage = $"{_humanPlayer1.DisplayName} was healed for {expectedHealAmount} HP!\n";
MockOutputMessage output = outputs.FirstOrDefault(o => o.Message == expectedMessage);
Assert.NotNull(output);
}
public void PrintsDefaultIntroString_UponEnteringRegion_NullOrEmptyIntroSuppliedToSubRegion([Values("", null)] string introMessage)
{
TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1));
SubRegion subRegion = new SubRegion(WorldSubRegion.Fields, 1, new[] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg }, new BattlefieldConfiguration(bossConfiguration),
regionIntro: introMessage);
SubRegion[] subRegions = { subRegion };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
_teamFactory.PushTeams(_oneEnemyTeam);
_regionManager = GetRegionManager();
_humanFighter1.SetMove(_runawayMove);
_humanFighter1.SetMoveTarget(_humanFighter1);
_humanFighter2.SetMove(_doNothingMove);
_regionManager.Battle(_battleManager, _humanTeam);
MockOutputMessage[] outputs = _output.GetOutputs();
MockOutputMessage output = outputs[0];
Assert.AreEqual($"You have entered the {WorldRegion.Fields} region\n", output.Message);
output = outputs[1];
Assert.AreEqual($"You have entered the {WorldSubRegion.Fields} sub region\n", output.Message);
}
public void CorrectlyPrintsIntro_UponEnteringRegion(
[Values("Welcome to the Jungle!", "flee, for you have entered the graveyard!")] string regionIntroMessage,
[Values("Welcome to a smaller subset of the jungle", "Spooky ghosts watch your every step")] string subRegionIntroMessage)
{
TeamConfiguration bossConfiguration = new TeamConfiguration(new EnemyConfiguration(FighterType.Egg, 1));
SubRegion subRegion = new SubRegion(WorldSubRegion.Fields, 1, new [] { new ChanceEvent <int>(1, 1) }, new[] { FighterType.Egg }, new BattlefieldConfiguration(bossConfiguration, null),
regionIntro: subRegionIntroMessage);
SubRegion[] subRegions = { subRegion };
Region fakeFieldsRegion = new Region(WorldRegion.Fields, new BattleMove[0], subRegions, regionIntroMessage);
_regionFactory.SetRegion(WorldRegion.Fields, fakeFieldsRegion);
_teamFactory.PushTeams(_oneEnemyTeam);
_regionManager = GetRegionManager();
_humanFighter1.SetMove(_runawayMove);
_humanFighter1.SetMoveTarget(_humanFighter1);
_humanFighter2.SetMove(_doNothingMove);
_regionManager.Battle(_battleManager, _humanTeam);
MockOutputMessage[] outputs = _output.GetOutputs();
MockOutputMessage output = outputs[0];
Assert.AreEqual(regionIntroMessage + "\n", output.Message);
output = outputs[1];
Assert.AreEqual(subRegionIntroMessage + "\n", output.Message);
}
public void CorrectlyOutputsColors_RecursiveSubStrings()
{
const string firstOutput = "what if ";
const string secondOutput = "there were ";
const string thirdOutput = "no rules?";
const ConsoleColor firstColor = ConsoleColor.White;
const ConsoleColor secondColor = ConsoleColor.Green;
const ConsoleColor thirdColor = ConsoleColor.Blue;
ColorString subString = new ColorString(new ColorString(secondOutput, secondColor), new ColorString(thirdOutput, thirdColor));
ColorString colorString = new ColorString(new ColorString(firstOutput, firstColor), subString);
_mockOutput.WriteLine(colorString);
MockOutputMessage[] outputs = _mockOutput.GetOutputs();
Assert.AreEqual(3, outputs.Length);
MockOutputMessage output = outputs[0];
Assert.AreEqual(firstOutput, output.Message);
Assert.AreEqual(firstColor, output.Color);
output = outputs[1];
Assert.AreEqual(secondOutput, output.Message);
Assert.AreEqual(secondColor, output.Color);
output = outputs[2];
Assert.AreEqual(thirdOutput + "\n", output.Message);
Assert.AreEqual(thirdColor, output.Color);
}
public void BattleManagerCorrectly_DisplaysSuccessMessage_BellBloodMoveFailed()
{
//Arrange
List <Shade> shades = _shadeGrouping.GetShades();
_humanFighter.SetSpeed(shades[0].Speed + 1);
List <Bell> bells = GetBells(BellType.Copper, BellType.Silver);
_input.Push("special", "blood copper", "1", "1", "run", "y");
_chanceService.PushEventOccurs(false); //sealing failed
int attackIndex = shades[0].AvailableMoves.FindIndex(am => am.MoveType == BattleMoveType.Attack);
_chanceService.PushWhichEventsOccur(attackIndex, attackIndex, attackIndex);
_chanceService.PushEventsOccur(false, false, false); //both remaining shades will attack and miss
//Act
_battleManager.Battle(_humanTeam, _shadeTeam, bells.Cast <TerrainInteractable>().ToList());
//Assert
MockOutputMessage[] outputs = _output.GetOutputs();
string expectedOutputMessage = $"but {shades[0].DisplayName} was too strong!\n";
MockOutputMessage outputWithSuccessMessage = outputs.FirstOrDefault(o => o.Message == expectedOutputMessage);
Assert.NotNull(outputWithSuccessMessage);
}
public void ShuffleFlag_ProperlyShufflesMenuOptions([Values(new [] { 2, 1, 0 }, new [] { 0, 2, 1 })] int[] newOrder)
{
string[] expectedMenuActions = { ". fight\n", ". item\n", ". run\n" };
MockChanceService chanceService = new MockChanceService();
chanceService.SetShuffleIndices(newOrder);
SetUpAndBuildMenu(false, false, false, true, chanceService);
_menuInput.Push("1");
_menu.GetInput();
MockOutputMessage[] outputs = _menuOutput.GetOutputs();
Assert.AreEqual(4, outputs.Length);
for (var i = 1; i < 4; ++i)
{
int expectedIndex = newOrder[i - 1];
string expectedMenuAction = expectedMenuActions[expectedIndex];
MockOutputMessage output = outputs[i];
Assert.AreEqual($"{i}{expectedMenuAction}", output.Message);
}
}
public void BattleManager_CorrectlyPrintsDamageOutput()
{
int damage = (_shield.MaxHealth + _shield.Defense) - 1;
_enemyPlayer1.SetMove(_basicAttackMove);
_enemyPlayer1.SetStrength(damage);
_enemyPlayer1.SetMoveTarget(_humanPlayer1);
_chanceService.PushEventsOccur(true, false); //attack hits, not crit
_humanPlayer1.SetBattleShield(_shield as BattleShield);
BattleShield fighterShield = _humanPlayer1.BattleShield;
_humanPlayer1.SetMove(_doNothingMove, 1);
_humanPlayer1.SetMove(_runawayMove);
_humanPlayer1.SetMoveTarget(_humanPlayer1);
_humanTeam = new Team(_menuManager, _humanPlayer1);
_enemyTeam = new Team(_menuManager, _enemyPlayer1);
BattleManagerBattleConfiguration config = new BattleManagerBattleConfiguration
{
ShowIntroAndOutroMessages = false
};
_battleManager.Battle(_humanTeam, _enemyTeam, config: config);
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(2, outputs.Length); //enemy attacks and shield took damage message
MockOutputMessage output = outputs[1];
Assert.AreEqual($"{fighterShield.Owner.DisplayName}'s {fighterShield.GetDisplayText(false)} took {damage} damage!\n", output.Message);
}
public void SetupMove_PrintsCorrectPrompts()
{
Fairy fairy = (Fairy)FighterFactory.GetFighter(FighterType.Fairy, 1);
_fighter.SetEnemy(fairy);
_input.Push("1", "1");
_fighter.SetupMove(_ownTeam, _enemyTeam);
MockOutputMessage[] outputs = _output.GetOutputs();
int expectedOutputLength = 5;
//menu prompt for both menus, plus "back," "help," and "status" option from target menu
expectedOutputLength += fairy.AvailableMoves.Count + _enemyTeam.Fighters.Count;
Assert.AreEqual(expectedOutputLength, outputs.Length);
int i = 0;
MockOutputMessage output = outputs[i++];
Assert.AreEqual($"You are currently selecting a move for {fairy.DisplayName}. What move will you use?\n", output.Message);
Assert.AreEqual(ConsoleColor.Cyan, output.Color);
for (int j = 0; j < fairy.AvailableMoves.Count; ++j)
{
BattleMove move = fairy.AvailableMoves[j];
output = outputs[i++];
Assert.AreEqual($"{j + 1}. {move.Description}\n", output.Message);
}
}
public void BattleManager_AppropriatelyDisplaysTransformMessage()
{
_humanFighter.SetStrength(_shade1.MaxHealth + _shade1.Defense);
_humanFighter.SetMove(_basicAttack, 1);
_humanFighter.SetMoveTarget(_shade1);
_humanFighter.SetMove(_runawayMove);
_chanceService.PushAttackHitsNotCrit();
//which moves will be selected by the shades
_chanceService.PushWhichEventsOccur(_malevolenceChargeIndex, _malevolenceChargeIndex, _malevolenceChargeIndex);
_chanceService.PushWhichEventsOccur(0, 0); //first is which remaining shade absorbs the fallen shade, second is which stat is boosted
//define the expected string here, since the shade's display name will be updated after the absorption
string displayNameBefore = _shade2.DisplayName;
_battleManager.Battle(_humanTeam, _shadeTeam, null, new SilentBattleConfiguration());
MockOutputMessage[] outputs = _output.GetOutputs();
string expectedTransformMessage = $"{displayNameBefore} has transformed to become a {_shade2.BaseName}!\n";
MockOutputMessage transformOutputMessage = outputs.FirstOrDefault(o => o.Message == expectedTransformMessage);
Assert.NotNull(transformOutputMessage);
}
public void CorrectlyOutputsColors_MultipleSubStrings()
{
const string firstOutput = "Hello ";
const string secondOutput = "World!";
const ConsoleColor firstColor = ConsoleColor.White;
const ConsoleColor secondColor = ConsoleColor.Red;
ColorString colorString = new ColorString(new ColorString(firstOutput, firstColor), new ColorString(secondOutput, secondColor));
_mockOutput.WriteLine(colorString);
MockOutputMessage[] outputs = _mockOutput.GetOutputs();
Assert.AreEqual(2, outputs.Length);
MockOutputMessage output = outputs[0];
Assert.AreEqual(firstOutput, output.Message);
Assert.AreEqual(firstColor, output.Color);
output = outputs[1];
Assert.AreEqual(secondOutput + "\n", output.Message);
Assert.AreEqual(secondColor, output.Color);
}
public void BlindnessStatusCorrectlyPrintsMessage([Values(1, 3)] int statusDuration)
{
StatusMove blindnessMove = new StatusMove("foo", TargetType.SingleEnemy, new BlindStatus(statusDuration));
_humanFighter.SetMove(blindnessMove, 1);
_chanceService.PushEventOccurs(true);
_humanFighter.SetMoveTarget(_enemy);
_humanFighter.SetMove(_runawayMove);
_enemy.SetMove(_doNothing);
SilentBattleConfiguration config = new SilentBattleConfiguration();
//act
_battleManager.Battle(_humanTeam, _enemyTeam, config: config);
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(1, outputs.Length);
MockOutputMessage output = outputs[0];
string turnOrTurns = statusDuration == 1 ? "turn" : "turns";
string expectedMessage = $"{_enemy.DisplayName} has been afflicted with blindness for {statusDuration} {turnOrTurns}!\n";
Assert.AreEqual(expectedMessage, output.Message);
}
public void HiddenMenuActions_NotAccessibleByNumberInput()
{
List <MenuAction> menuActions = new List <MenuAction>
{
new MenuAction("fight"),
new MenuAction("defend"),
new MenuAction("foo", isHidden: true),
new MenuAction("bar", isHidden: true)
};
const string prompt = "pick one";
Menu menu = new Menu(false, false, false, prompt, Globals.GenericErrorMessage, null, menuActions, _menuInput, _menuOutput);
menu.Build(null, null, null, null);
_menuInput.Push("3", "1");
MenuSelection selection = menu.GetInput();
Assert.AreEqual("fight", selection.Description);
MockOutputMessage[] outputs = _menuOutput.GetOutputs();
int menuOutputLength = 1 + menuActions.Count(ma => !ma.IsHidden);
int expectedOutputLengh = menuOutputLength * 2 + 1; //menu displayed twice, error message displayed once.
Assert.AreEqual(expectedOutputLengh, outputs.Length);
MockOutputMessage output = outputs[menuOutputLength];
Assert.AreEqual(Globals.GenericErrorMessage + "\n", output.Message);
Assert.AreEqual(MockOutputMessageType.Error, output.Type);
}
public void CorrectlyPrintsMessage_StatBonusAdded([Values] StatType statType, [Values(1, 3)] int bonusAmount)
{
StatBonusAppliedEventArgs e = new StatBonusAppliedEventArgs(statType, bonusAmount, false);
_fighter.OnStatBonusApplied(e);
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(1, outputs.Length);
MockOutputMessage output = outputs[0];
Assert.AreEqual($"{_fighter.DisplayName} gained +{bonusAmount} {statType.ToString().ToLower()}\n", output.Message);
}
public void CorrectlyDisallowsEmptyInput()
{
_input.Push("", "2");
_menu.GetInput();
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(3, outputs.Length);
MockOutputMessage output = outputs[1];
Assert.AreEqual("input is required\n", output.Message);
Assert.AreEqual(ConsoleColor.Red, Globals.ErrorColor);
}
public void CorrectlyPrintsMessage_MagicBonusAdded([Values(MagicType.Fire, MagicType.Ice, MagicType.Water)] MagicType magicType,
[Values(1, 3)] int bonusAmount,
[Values] MagicStatType magicStatType)
{
MagicBonusAppliedEventArgs e = new MagicBonusAppliedEventArgs(magicStatType, magicType, bonusAmount, false);
_fighter.OnMagicBonusApplied(e);
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(1, outputs.Length);
MockOutputMessage output = outputs[0];
Assert.AreEqual($"{_fighter.DisplayName} gained +{bonusAmount} {magicType.ToString().ToLower()} magic {magicStatType.ToString().ToLower()}\n", output.Message);
}
public void CorrectlyOutputsColors_NoSubStrings()
{
const string expectedOutput = "Hello World!";
const ConsoleColor expectedColor = ConsoleColor.Red;
ColorString colorString = new ColorString(expectedOutput, expectedColor);
_mockOutput.WriteLine(colorString);
MockOutputMessage[] outputs = _mockOutput.GetOutputs();
Assert.AreEqual(1, outputs.Length);
MockOutputMessage output = outputs[0];
Assert.AreEqual(expectedOutput + "\n", output.Message);
Assert.AreEqual(expectedColor, output.Color);
}
public void NewlyAddedEnemyTeam_CorrectlyWiredIntoEvents()
{
//Assert
_enemyTeam = new TestTeam(_enemyPlayer1);
_enemyPlayer1.SetMove(_doNothingMove, 2);
_enemyPlayer1.SetMove(_runawayMove);
_enemyPlayer2.SetMove(_doNothingMove);
bool alreadyAdded = false;
_enemyTeam.RoundEnded += delegate(object sender, RoundEndedEventArgs args)
{
if (!alreadyAdded)
{
args.Team.Add(_enemyPlayer2);
alreadyAdded = true;
}
};
_humanPlayer1.SetMove(_doNothingMove, 1);
_humanPlayer1.SetMove(_basicAttackMove, 1);
_humanPlayer1.SetMove(_doNothingMove);
_mockChanceService.PushAttackHitsNotCrit();
_humanPlayer1.SetMoveTarget(_enemyPlayer2);
_humanPlayer2.SetMove(_doNothingMove);
_humanPlayer2.SetMoveTarget(_humanPlayer2);
BattleManagerBattleConfiguration config = new BattleManagerBattleConfiguration
{
ShowExpAndLevelUpMessages = false,
ShowIntroAndOutroMessages = false
};
//Act
_battleManager.Battle(_humanTeam, _enemyTeam, config: config);
//Assert
MockOutputMessage output = _output.GetOutputs()[1];
Assert.AreEqual($"It did 1 damage!\n", output.Message);
}
public void CorrectlyReplacesMinAndMaxStringPlaceholders([Values(1, 3)] int minValue,
[Values(4, 9)] int maxValue)
{
string promptBeforeReplacement =
$"min: {Globals.MinValueReplacementString}, max: {Globals.MaxValueReplacementString}";
string minValueAsString = minValue.ToString();
string maxValueAsString = maxValue.ToString();
NumberInputMenu menu = new NumberInputMenu(promptBeforeReplacement, _input, _output, minValue, maxValue);
_input.Push(minValueAsString);
menu.GetInput();
MockOutputMessage output = _output.GetOutputs()[0];
string expectedOutput = promptBeforeReplacement.Replace(Globals.MinValueReplacementString, minValueAsString);
expectedOutput = expectedOutput.Replace(Globals.MaxValueReplacementString, maxValueAsString);
Assert.AreEqual(expectedOutput + "\n", output.Message);
}
public void PickNextAreaMethod_CorrectMenuPromptsDisplayed_DesertGroupings([Values(1, 2)] int whichPlayerGetsFlag)
{
//arrange
MapGrouping <SubRegion, WorldSubRegion> firstGrouping, secondGrouping;
MockMenu menu1, menu2;
string name1 = "Jeff";
string name2 = "Daniel";
PickNextArea_GroupingSetup_DesertGroupings(out firstGrouping, out secondGrouping);
PickNextArea_MenuSetup_DesertGroupings(WorldSubRegion.DesertCrypt, WorldSubRegion.CliffsOfAThousandPushups, out menu1, out menu2);
Team team = PickNextArea_TeamSetup_DesertGroupings(whichPlayerGetsFlag, name1, name2);
//Act
_decisionManager.PickNextArea(firstGrouping, team);
//Assert
string expectedName1, expectedName2;
if (whichPlayerGetsFlag == 1)
{
expectedName1 = name1;
expectedName2 = name2;
}
else
{
expectedName1 = name2;
expectedName2 = name1;
}
MockOutputMessage[] outputs = _output.GetOutputs();
MockOutputMessage firstPrompt = outputs[0];
Assert.True(firstPrompt.Message.StartsWith(expectedName1 + ":"));
MockOutputMessage secondPrompt = outputs[4]; //first menu prompt, 3 visible options
Assert.True(secondPrompt.Message.StartsWith(expectedName2 + ":"));
}
public void BattleManager_CorrectlyPrintsShadeAbsorbMoveExecutionText()
{
//arrange
ShadeAbsorbingMove absorbingMove = _shade1.GetExecutableMoves(_humanTeam).FirstOrDefault(m => m is ShadeAbsorbingMove) as ShadeAbsorbingMove;
_humanFighter.SetMove(_doNothingMove, 1);
_humanFighter.SetMove(_runawayMove);
_chanceService.PushWhichEventsOccur(_absorptionMoveIndex, 0, _malevolenceChargeIndex, _malevolenceChargeIndex);
_chanceService.PushWhichEventsOccur(_malevolenceChargeIndex, _malevolenceChargeIndex);
SilentBattleConfiguration config = new SilentBattleConfiguration();
//set up the output message now, before the display name chanegs from the absorption
string expectedOutputMessage = $"{_shade1.DisplayName} {absorbingMove?.ExecutionText.Replace(Globals.TargetReplaceText, _shade2.DisplayName)}\n";
//act
_battleManager.Battle(_humanTeam, _shadeTeam, config: config);
MockOutputMessage output = _output.GetOutputs()[0];
Assert.AreEqual(expectedOutputMessage, output.Message);
}
public void CorrectlyDisallowsNonNumberInput()
{
_menu = new NumberInputMenu("", _input, _output, 0, 5);
_input.Push("abc", "f12", "1");
_menu.GetInput();
MockOutputMessage[] outputs = _output.GetOutputs();
Assert.AreEqual(5, outputs.Length);
MockOutputMessage output = outputs[1];
const string nonNumberError = "input not recognized as a number\n";
Assert.AreEqual(nonNumberError, output.Message);
Assert.AreEqual(ConsoleColor.Red, Globals.ErrorColor);
output = outputs[3];
Assert.AreEqual(nonNumberError, output.Message);
Assert.AreEqual(ConsoleColor.Red, Globals.ErrorColor);
}
public void ShuffleFlag_DoesNotShuffleBackStatusHelpOptions()
{
MockChanceService chanceService = new MockChanceService();
chanceService.SetShuffleIndices(new [] { 2, 1, 0 });
SetUpAndBuildMenu(true, true, true, true, chanceService);
_menuInput.Push("1");
_menu.GetInput();
MockOutputMessage[] outputs = _menuOutput.GetOutputs();
Assert.AreEqual(_fullMenuPromptLength, outputs.Length);
for (int i = 4, j = 3; i < 7; ++i, --j)
{
string expectedOutput = _fullMenuPrompt[_fullMenuPromptLength - j];
MockOutputMessage output = outputs[i];
Assert.AreEqual(expectedOutput, output.Message);
}
}
public void BattleManagerCorrectlyIdentifiesBellInIntro()
{
List <Bell> bells = GetBells(BellType.Copper, BellType.Silver);
_humanFighter.SetMove(_runawayMove);
_enemy.SetMove(_doNothingMove);
_battleManager.Battle(_humanTeam, _enemyTeam, bells.Cast <TerrainInteractable>().ToList());
MockOutputMessage[] outputs = _output.GetOutputs();
int bellIntroIndex = 1 + _enemyTeam.Fighters.Count; //"time for a battle" and then each "encountered ____"
foreach (Bell bell in bells)
{
MockOutputMessage output = outputs[bellIntroIndex];
Assert.AreEqual($"There is a {bell.DisplayName} on the field\n", output.Message);
bellIntroIndex++;
}
Assert.AreEqual(bellIntroIndex, _output.GetClearIndices()[1]);
}
