public async Task Winner_Score_Is_Total_Score()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var simulationRepository = new SimulationRepository(connection);
var gameService = new GameService(strategyService, gameSettingsProvider);
var populationService = new PopulationService(gameService);
//TODO: simplify /\
var simulationServce = new SimulationService(simulationRepository, populationService,
strategyService, new SimulationSettingsProvider());
Strategy cooperator = await strategyRepository
.GetByNameAsync(NoMemoryStrategies.GetSimpleCooperator().Name);
var players = new List <Player>();
for (int i = 0; i < 10; i++)
{
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
Simulation simulation = await simulationServce.Run(players);
GameSettings gameSettings = gameSettingsProvider.GetGameSettings();
int totalScore = gameSettings.TotalRounds
* (gameSettings.CooperateModifier + gameSettings.MoveModifier)
* (players.Count - 1);
Assert.AreEqual(totalScore, simulation.Winner.Score);
}
public async Task Get_Cooperator_Players_Strategies()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var simulationRepository = new SimulationRepository(connection);
var gameService = new GameService(strategyService, gameSettingsProvider);
var populationService = new PopulationService(gameService);
//TODO: simplify /\
var simulationServce = new SimulationService(simulationRepository, populationService,
strategyService, new SimulationSettingsProvider());
Strategy cooperator = await strategyRepository
.GetByNameAsync(NoMemoryStrategies.GetSimpleCooperator().Name);
var players = new List <Player>();
for (int i = 0; i < 10; i++)
{
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
players = simulationServce.GetPlayersStrategies(players);
bool badPlayers = players.Where(p => p.StrategyId != cooperator.Id).Any();
Assert.IsFalse(badPlayers);
}
public async Task Run_Once_When_Consistent()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var simulationRepository = new SimulationRepository(connection);
var gameService = new GameService(strategyService, gameSettingsProvider);
var populationService = new PopulationService(gameService);
//TODO: simplify /\
var simulationServce = new SimulationService(simulationRepository, populationService,
strategyService, new SimulationSettingsProvider());
Strategy cooperator = await strategyRepository
.GetByNameAsync(NoMemoryStrategies.GetSimpleCooperator().Name);
var players = new List <Player>();
for (int i = 0; i < 10; i++)
{
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
Simulation simulation = await simulationServce.Run(players);
Assert.IsNotNull(simulation.Winner);
Assert.AreEqual(1, simulation.PopulationsCompleated);
}
public void GetWithNull_Expected_ThrowsNullArgumentException()
{
lock (l)
{
SimulationRepository thisInstance = _testInstance;
thisInstance.Get(null, true);
}
}
public void SaveWithNullItem_Expected_NoOperationPerformed()
{
lock (l)
{
SimulationRepository thisInstance = _testInstance;
var expected = thisInstance.Count;
thisInstance.Save(null);
Assert.AreEqual(expected, thisInstance.Count);
}
}
public void SaveWithExistingItem_Expected_ItemCountIsSame()
{
lock (l)
{
SimulationRepository thisInstance = _testInstance;
var expected = thisInstance.Count;
thisInstance.Save(_testResult);
Assert.AreEqual(expected, thisInstance.Count);
}
}
public static void MyClassInitialize(TestContext testContext)
{
Directory.SetCurrentDirectory(testContext.TestDir);
_testInstance = SimulationRepository.Instance;
_testResult = new SimulationResult
{
Key = CreateKey(),
Value = Dev2BinaryDataListFactory.CreateDataList()
};
_testInstance.Save(_testResult);
}
public static void MyClassInitialize(TestContext testContext)
{
Directory.SetCurrentDirectory(testContext.TestDir);
_testInstance = SimulationRepository.Instance;
_testResult = new SimulationResult
{
Key = CreateKey(),
Value = Dev2BinaryDataListFactory.CreateDataList()
};
_testInstance.Save(_testResult);
}
public void SaveWithNewItem_Expected_ItemCountIncreasesByOne()
{
lock (l)
{
SimulationRepository thisInstance = _testInstance;
var expected = thisInstance.Count + 1;
var item = CreateResult(CreateKey());
thisInstance.Save(item);
Assert.AreEqual(expected, thisInstance.Count);
}
}
public async Task Get_New_Simulation_Id()
{
var simulationRepository = new SimulationRepository(connection);
var simulation = new Simulation()
{
StartDate = DateTime.Now,
PopulationsLimit = 10,
EntryPlayers = new List <Player>(),
Populations = new List <Population>()
};
string id = await simulationRepository.SaveAsync(simulation);
Assert.IsFalse(String.IsNullOrEmpty(id));
}
public void DeleteWithInvalidItem_Expected_ItemCountIsSame()
{
lock (l)
{
SimulationRepository thisInstance = _testInstance;
int expected = thisInstance.Count;
ISimulationKey theKey = CreateKey();
ISimulationResult item = CreateResult(theKey);
string id1 = theKey.ActivityID;
string id2 = theKey.ScenarioID;
string id3 = theKey.WorkflowID;
Assert.AreEqual(expected, thisInstance.Count, "Fail 1");
thisInstance.Delete(item); // Problem over here!
Assert.AreEqual(expected, thisInstance.Count, "Fail 2");
}
}
public async Task Update_Simulation()
{
//TODO: add GetAsync to test this
var simulationRepository = new SimulationRepository(connection);
var simulation = new Simulation()
{
StartDate = DateTime.Now,
PopulationsLimit = 10,
EntryPlayers = new List <Player>(),
Populations = new List <Population>()
};
string id = await simulationRepository.SaveAsync(simulation);
simulation.FinishDate = DateTime.Now;
simulation.PopulationsCompleated = 10;
await simulationRepository.UpdateAsync(simulation);
Simulation updatedSimulation = await simulationRepository.GetAsync(id);
Assert.IsFalse(String.IsNullOrEmpty(updatedSimulation.FinishDate.ToString()));
}
public void VerifySimulatedData(MasterDBContext dbContext, DataGeneratorContext dbGeneratorCtx,
ResultContext dbResultCtx, int simNumber)
{
var simulation = SimulationRepository.GetSimulationById(simNumber, dbGeneratorCtx);
if (simulation != null)
{
var approach = ApproachRepository.GetApproachById(dbGeneratorCtx, simulation.ApproachId);
if (approach.TransitionMatrixInput.ExtendedTransitionMatrix)
{
var generator = new MainGenerator();
generator.StartGeneration(approach, dbContext, dbResultCtx);
var articleCount =
ArticleRepository.GetArticleNamesAndCountForEachUsedArticleInSimulation(dbResultCtx, simNumber);
var articlesByNames =
ArticleRepository.GetArticlesByNames(articleCount.Keys.ToHashSet(), dbContext);
var capabilities = ResourceCapabilityRepository.GetParentResourceCapabilities(dbContext);
var actualTransitionMatrix = new TransitionMatrix
{
Pi = new double[capabilities.Count + 1, capabilities.Count + 1]
};
var capPosByCapId = new Dictionary <int, int>();
foreach (var cap in capabilities)
{
var number = cap.Name.Substring(0, cap.Name.IndexOf(" "));
var pos = AlphabeticNumbering.GetNumericRepresentation(number);
capPosByCapId.Add(cap.Id, pos);
}
foreach (var a in articlesByNames)
{
var operations = a.Value.Operations.ToList();
operations.Sort((o1, o2) => o1.HierarchyNumber.CompareTo(o2.HierarchyNumber));
var operationCount = 0;
var lastCapPos = 0;
do
{
var capPos =
capPosByCapId[
operations[operationCount].ResourceCapability.ParentResourceCapability.Id];
actualTransitionMatrix.Pi[lastCapPos, capPos] += articleCount[a.Key];
lastCapPos = capPos + 1;
operationCount++;
} while (operationCount < operations.Count);
actualTransitionMatrix.Pi[lastCapPos, capabilities.Count] += articleCount[a.Key];
}
for (var i = 0; i <= capabilities.Count; i++)
{
var sum = 0.0;
for (var j = 0; j <= capabilities.Count; j++)
{
sum += actualTransitionMatrix.Pi[i, j];
}
for (var j = 0; j <= capabilities.Count; j++)
{
actualTransitionMatrix.Pi[i, j] /= sum;
}
}
var transitionMatrixGenerator = new TransitionMatrixGenerator();
ActualOrganizationDegree = transitionMatrixGenerator.CalcOrganizationDegree(
actualTransitionMatrix.Pi,
capabilities.Count + 1);
GeneratedOrganizationDegree = transitionMatrixGenerator.CalcOrganizationDegree(
generator.TransitionMatrix.Pi,
capabilities.Count + 1);
System.Diagnostics.Debug.WriteLine("################################# Executed work plans have an organization degree of " + ActualOrganizationDegree + " (transition matrix has " + GeneratedOrganizationDegree + "; input was " + approach.TransitionMatrixInput.DegreeOfOrganization + ")");
}
}
}
