public void OneVsOne(string enemyName)
{
var myRobot = "MyBot";
var enemyRobotNamess = new[]
{
enemyName
};
var testCase = new BattleTestCase(myRobot, enemyRobotNamess);
var errors = enemyName == "ErrorBot" ? new[] { "Blah ErrorBot Blah" } : new string[] { };
var sortedResults = new List <BattleResults>();
if (enemyName == "LostBot")
{
sortedResults.Add(new BattleResults("LostBot", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
}
sortedResults.Add(new BattleResults("MyBot", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
if (enemyName == "WonBot")
{
sortedResults.Add(new BattleResults("WonBot", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
}
var adapter = new BattleResultAdapter();
var outcomes = adapter.RecordOutcomes(testCase, sortedResults, errors, true);
var o = outcomes.Single();
Assert.AreEqual(BattleType.OneVsOne, o.BattleType);
Assert.AreEqual(enemyName, o.EnemyName);
Assert.AreEqual(myRobot, o.MyRobotName);
switch (enemyName)
{
case "WonBot":
Assert.AreEqual(OutcomeType.Won, o.OutcomeType);
break;
case "LostBot":
Assert.AreEqual(OutcomeType.Lost, o.OutcomeType);
break;
case "NoShowBot":
Assert.AreEqual(OutcomeType.NoShow, o.OutcomeType);
break;
case "ErrorBot":
Assert.AreEqual(OutcomeType.Error, o.OutcomeType);
Assert.AreEqual("Blah ErrorBot Blah", o.Error);
break;
default:
Assert.Fail(enemyName);
break;
}
}
public void RecordUnfinishedBusiness(string enemyNames)
{
var adapter = new BattleResultAdapter();
var btc = new BattleTestCase("A", enemyNames.Split(','));
var outcomes = adapter.RecordUnfinishedBusiness(btc);
Assert.IsNotNull(outcomes);
}
public void Battle(BattleTestCase testCase)
{
TestCaseFactory.SaveToDisk(testCase);
RobotSpecification[] robots = _robocode.GetLocalRepository(testCase.AllRobotsCsv);
var battle = new BattleSpecification(
testCase.NumberOfRounds,
testCase.BattlefieldSpecification,
robots);
_battleErrorEvents.Clear();
_battleCompletedEvent = null;
using (_wait = new AutoResetEvent(false))
{
_robocode.RunBattle(battle, false);
_wait.WaitOne(testCase.TimeOut);
}
bool finished = _battleCompletedEvent != null;
var adapter = new BattleResultAdapter();
var outcomes = adapter.RecordOutcomes(
testCase,
finished ? _battleCompletedEvent.SortedResults : null,
_battleErrorEvents.Select(e => e.Error),
finished);
TestCaseFactory.AddResult(outcomes);
TestCaseFactory.ForgetAnyUnfinishedBusiness();
var grouped = outcomes.GroupBy(o => o.OutcomeType).ToDictionary(g => g.Key);
if (grouped.ContainsKey(OutcomeType.Lost))
{
var robotsThatBeatMe = grouped[OutcomeType.Lost];
Assert.Fail("Lost to: " + robotsThatBeatMe.Select(e => e.EnemyName).Aggregate((n1, n2) => n1 + ", " + n2));
}
else if (grouped.ContainsKey(OutcomeType.Won))
{
var robotsThatIBeat = grouped[OutcomeType.Won];
Console.WriteLine("Beat: " + robotsThatIBeat.Select(e => e.EnemyName).Aggregate((n1, n2) => n1 + ", " + n2));
}
else
{
Assert.Inconclusive();
}
}
public IEnumerable <Outcome> RecordUnfinishedBusiness(BattleTestCase testCase)
{
var outcometype = testCase.BattleType == BattleType.OneVsOne ? OutcomeType.NoShow : OutcomeType.PossibleNoShow;
var utcNow = DateTime.UtcNow;
return(testCase.EnemyRobots.Select(enemyName => new Outcome
{
MyRobotName = testCase.MyRobot,
EnemyName = enemyName,
OutcomeType = outcometype,
BattleType = testCase.BattleType,
TimeStamp = utcNow,
Error = null
}).ToList());
}
public void Serialization()
{
string expectedMe = "A";
string[] enemies = { "1", "2" };
var btc = new BattleTestCase(expectedMe, enemies);
var serialized = btc.Serialize();
Assert.IsNotNullOrEmpty(serialized);
var deserialized = BattleTestCase.Deserialize(serialized);
Assert.IsNotNull(deserialized);
}
public void Melee()
{
var myRobot = "MyBot";
var enemyRobotNamess = new[]
{
"WonBot",
"LostBot",
"NoShowBot",
"ErrorBot"
};
var testCase = new BattleTestCase(myRobot, enemyRobotNamess);
var errors = new[] { "Blah ErrorBot Blah" };
var sortedResults = new[]
{
new BattleResults("LostBot", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
new BattleResults("MyBot", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
new BattleResults("WonBot", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
};
var adapter = new BattleResultAdapter();
var outcomes = adapter.RecordOutcomes(testCase, sortedResults, errors, true);
//Assert.AreEqual(4, mra.Outcomes.Count());
var outcomeDic = outcomes.ToDictionary(k => k.EnemyName);
Assert.AreEqual(OutcomeType.Lost, outcomeDic["LostBot"].OutcomeType);
Assert.AreEqual(OutcomeType.Won, outcomeDic["WonBot"].OutcomeType);
Assert.AreEqual(OutcomeType.NoShow, outcomeDic["NoShowBot"].OutcomeType);
Assert.AreEqual(OutcomeType.Error, outcomeDic["ErrorBot"].OutcomeType);
Assert.AreEqual("Blah ErrorBot Blah", outcomeDic["ErrorBot"].Error);
}
public IEnumerable <Outcome> RecordOutcomes(
BattleTestCase testCase,
IEnumerable <BattleResults> sortedResults,
IEnumerable <string> battleErrors,
bool finished)
{
var retval = new Dictionary <string, Outcome>();
var utcNow = DateTime.UtcNow;
if (finished)
{
var actual = sortedResults.Select(r => r.TeamLeaderName);
var noShows = testCase.EnemyRobots.Except(actual);
foreach (var expectedRobotName in testCase.EnemyRobots)
{
var name = expectedRobotName;
var roboterrors = battleErrors.Where(em => em.Contains(name));
//Can't load cb.nano.Chasseur 1.0, because it is invalid robot or team.
if (roboterrors.Any())
{
retval.Add(expectedRobotName, new Outcome
{
MyRobotName = testCase.MyRobot,
EnemyName = expectedRobotName,
OutcomeType = OutcomeType.Error,
BattleType = testCase.BattleType,
TimeStamp = utcNow,
Error = roboterrors.Distinct().Aggregate((e1, e2) => e1 + Environment.NewLine + e2)
});
}
else if (noShows.Contains(expectedRobotName))
{
retval.Add(expectedRobotName, new Outcome
{
MyRobotName = testCase.MyRobot,
EnemyName = expectedRobotName,
OutcomeType = OutcomeType.NoShow,
BattleType = testCase.BattleType,
TimeStamp = utcNow,
Error = null
});
}
}
bool isWin = false;
foreach (var result in sortedResults)
{
if (result.TeamLeaderName == testCase.MyRobot)
{
isWin = true;
}
else if (!retval.ContainsKey(result.TeamLeaderName))
{
retval.Add(result.TeamLeaderName, new Outcome
{
MyRobotName = testCase.MyRobot,
EnemyName = result.TeamLeaderName,
OutcomeType = isWin ? OutcomeType.Won : OutcomeType.Lost,
BattleType = testCase.BattleType,
TimeStamp = utcNow,
Error = null
});
}
}
}
else
{
var noShows = testCase.EnemyRobots;
noShows.ForEach(noShow =>
{
retval.Add(noShow, new Outcome
{
MyRobotName = testCase.MyRobot,
EnemyName = noShow,
OutcomeType = testCase.BattleType == BattleType.OneVsOne ? OutcomeType.NoShow : OutcomeType.PossibleNoShow,
BattleType = testCase.BattleType,
TimeStamp = utcNow,
Error = null
});
});
}
return(retval.Values.ToList());
}
