public void TestAddingGettingStrategyToStrategyHolder()
{
StrategyHolder holder = new StrategyHolder();
BurnableDisposalStrategy burnStrategy = new BurnableDisposalStrategy();
RecyclableDisposalStrategy recStrategy = new RecyclableDisposalStrategy();
StorableDisposalStrategy storeStrategy = new StorableDisposalStrategy();
holder.AddStrategy(
typeof(BurnableDisposableAttribute),
burnStrategy);
holder.AddStrategy(
typeof(RecyclableDisposableAttribute),
recStrategy);
holder.AddStrategy(
typeof(StorableDisposableAttribute),
storeStrategy);
Assert.AreEqual(burnStrategy,
holder.GetDisposalStrategy(typeof(BurnableDisposableAttribute)));
Assert.AreEqual(recStrategy,
holder.GetDisposalStrategy(typeof(RecyclableDisposableAttribute)));
Assert.AreEqual(storeStrategy,
holder.GetDisposalStrategy(typeof(StorableDisposableAttribute)));
}
public void Constructor_NotNullFieldStrategyHolder_Success()
{
var holder = new StrategyHolder();
var garbage = new GarbageProcessor(holder);
Assert.That(garbage.StrategyHolder, Is.SameAs(holder));
}
public void TestAddingStrategyHolderToConstructor()
{
IStrategyHolder strategyHolder = new StrategyHolder();
IGarbageProcessor processor = new GarbageProcessor(strategyHolder);
Assert.AreEqual(strategyHolder, processor.StrategyHolder);
}
public void Constructor_ShouldInitializeCorrectlyTheObject()
{
// Arrange
var strategyHolder = new StrategyHolder();
// Act and Assert
Assert.IsNotNull(strategyHolder);
}
public void CheckGarbageProcessorInitializationWithAGivenStrategyHolder()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(RecyclableGarbage), new RecyclableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
Assert.AreEqual(1, this.garbageProcessor.StrategyHolder.GetDisposalStrategies.Count);
}
private StrategyHolder GetAllStrategies()
{
StrategyHolder stratHolder = new StrategyHolder();
stratHolder.AddStrategy(typeof(RecyclableGarbage), new RecyclableStrategy());
stratHolder.AddStrategy(typeof(BurnableGarbage), new BurnableStrategy());
stratHolder.AddStrategy(typeof(StorableGarbage), new StorableStrategy());
return(stratHolder);
}
public static void Main()
{
var strategyHolder = new StrategyHolder();
var garbageProcessor = new GarbageProcessor(strategyHolder);
var recyclingStationManager = new RecyclingStationManager(garbageProcessor);
var processStarter = new ProcessStarter(recyclingStationManager);
processStarter.Start();
}
public void AddStrategy()
{
//Arrange
Type disType = typeof(DisposableAttribute);
IStrategyHolder sut = new StrategyHolder(strategies);
//Assert
Assert.IsTrue(sut.AddStrategy(disType, ds));
}
public void GivingNullGarbageToProcessShouldThrowError()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(RecyclableGarbage), new RecyclableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
IWaste burnableWasteTestObject = null;
IProcessingData tempData = this.garbageProcessor.ProcessWaste(burnableWasteTestObject);
}
public void GarbageProcessorShouldThrowErrorIfNoStrategyIsPresentForGivenType()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(RecyclableGarbage), new RecyclableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
IWaste burnableWasteTestObject = new BurnableGarbage("RecyclMePls", 10, 10);
IProcessingData tempData = this.garbageProcessor.ProcessWaste(burnableWasteTestObject);
}
public void ProcessWaste_SomeWaste_ThrowsException()
{
var holder = new StrategyHolder();
var garbage = new GarbageProcessor(holder);
var waste = new StorableWaste("NuclearWaste", 10, 10);
Assert.That(() => garbage.ProcessWaste(waste), Throws.ArgumentException);
}
public async Task Atack(string row, string col)
{
var socketId = Context.ConnectionId;
int posX = Int32.Parse(row);
int posY = Int32.Parse(col);
if (duelsController.isPlayerTurn(socketId) == false)
{
await Clients.Caller.SendAsync("invalidTurn", row, col);
}
else
{
string enemySockeId = duelsController.GetOpponentSocketId(socketId);
//returns active caller's strategy
Strategy activeStrategy = StrategyHolder.GetPlayerStrategy(socketId);
//executing the strategy returns all affected cells as AttackOutcome and cell coordinates
List <CellOutcome> outcomes = strategyController.Attack(posX, posY, socketId);
//for every outcome we inform both players
foreach (CellOutcome outcome in outcomes)
{
switch (outcome.attackOutcome)
{
case AttackOutcome.Hit:
await Clients.Client(enemySockeId).SendAsync("pingAttack", outcome.posX, outcome.posY, "Hit", false);
await Clients.Caller.SendAsync("pingAttack", outcome.posX, outcome.posY, "Hit", true);
break;
case AttackOutcome.Armor:
duelsController.ChangeTurns(socketId);
await Clients.Client(enemySockeId).SendAsync("pingAttack", outcome.posX, outcome.posY, "Armor", false);
await Clients.Caller.SendAsync("pingAttack", outcome.posX, outcome.posY, "Armor", true);
break;
//For now, both [Missed and Invalid] trigger default switch
default:
duelsController.ChangeTurns(socketId);
await Clients.Client(enemySockeId).SendAsync("pingAttack", outcome.posX, outcome.posY, "Missed", false);
await Clients.Caller.SendAsync("pingAttack", outcome.posX, outcome.posY, "Missed", true);
//turn change using the proxy class
TurnOutcome turn = proxyPlayerTurn.ChangeTurn();
await Clients.Client(turn.InactiveId).SendAsync("changedTurn", turn.CallerTurn);
await Clients.Client(turn.ActiveId).SendAsync("changedTurn", turn.OpponetTurn);
break;
}
}
}
}
public void RemoveStrategy_ShouldReturnTrue_WhenRecieveValidParameters()
{
// Arrange
var strategy = new BurnableDisposalStrategy();
var type = new DisposableAttribute();
var holder = new StrategyHolder();
// Act and Assert
Assert.IsTrue(holder.RemoveStrategy(type));
}
public void ProcessWaste_ShouldThrowArgumentException()
{
// Arrange
var garbage = new StorableWaste("glass", 10.5, 1.2);
var strategyHolder = new StrategyHolder();
var garbageProcessor = new GarbageProcessor(strategyHolder);
// Act and Assert
garbageProcessor.ProcessWaste(garbage);
}
public void GetDisposalStrategies_CollectionIsReadOnly()
{
var sh = new StrategyHolder();
var strategiesType = sh.GetDisposalStrategies.GetType();
var implementedInterfacesByCollection = ((System.Reflection.TypeInfo)strategiesType).ImplementedInterfaces;
var implementIReadOnlyInterface = implementedInterfacesByCollection.Any(x => x.Name.Contains("IReadOnly"));
Assert.That(implementIReadOnlyInterface);
}
public void RemoveStrategies()
{
//Arrange
Type disType = typeof(DisposableAttribute);
IStrategyHolder sut = new StrategyHolder(strategies);
bool result = sut.AddStrategy(disType, ds);
//Assert
Assert.IsTrue(sut.RemoveStrategy(disType));
}
public List <CellOutcome> Attack(int posx, int posy, string socketId)
{
Strategy strategy = StrategyHolder.GetPlayerStrategy(socketId);
List <Ship> ships = GetEnemyShips(GetOpponentSocketId(socketId));
List <Cell> cells = GetEnemyCells(GetOpponentArenaId(socketId));
List <CellOutcome> outcomes = strategy.Attack(posx, posy, cells, ships);
_context.SaveChanges();
return(outcomes);
}
public void GarbageProcessorProperlyProcessingBurnableGarbageWithBurnableStrategy()
{
IStrategyHolder testStrategy = new StrategyHolder();
testStrategy.AddStrategy(typeof(BurnableGarbage), new BurnableStrategy());
this.garbageProcessor = new GarbageProcessor(testStrategy);
IWaste burnableWasteTestObject = new BurnableGarbage("BurnItUp", 10, 10);
IProcessingData tempData = this.garbageProcessor.ProcessWaste(burnableWasteTestObject);
Assert.AreEqual(0, tempData.CapitalBalance);
Assert.AreEqual(80, tempData.EnergyBalance);
}
public void Constructor_ShouldInitializeObject_WhenValidItemIsPassed()
{
// Arrange
var strategyHolder = new StrategyHolder();
// Act
var garbageProcessor = new GarbageProcessor(strategyHolder);
// Assert
Assert.AreEqual(strategyHolder, garbageProcessor.StrategyHolder);
}
public void PropertyStrategyHolder_ShouldGetCorrectly()
{
// Arrange
var strategyHolder = new StrategyHolder();
var garbageProcessor = new GarbageProcessor(strategyHolder);
// Act
var actualStrategyHolder = garbageProcessor.StrategyHolder;
// Assert
Assert.AreEqual(strategyHolder, actualStrategyHolder);
}
public static void Main()
{
var processingData = new ProcessingData();
var strategyHolder = new StrategyHolder();
var garbageProcessor = new GarbageProcessor(processingData, strategyHolder);
var reader = new ConsoleReader();
var writer = new ConsoleWriter();
var interpreter = new CommandInterpreter();
var engine = new Engine(interpreter, garbageProcessor, reader, writer);
engine.Run();
}
public void AddSameStrategiesAndCheckCollectionHaveOne()
{
//Arrange
Type disType = typeof(DisposableAttribute);
IStrategyHolder sut = new StrategyHolder(strategies);
bool result = sut.AddStrategy(disType, ds);
bool result1 = sut.AddStrategy(disType, ds);
bool result2 = sut.AddStrategy(disType, ds);
//Assert
Assert.AreEqual(1, sut.GetDisposalStrategies.Count);
}
private static void Main(string[] args)
{
var garbageFactory = new GarbageFactory();
var strategyHolder = new StrategyHolder();
var recyclingStation = new RecyclingStation();
var recyclingStationController = new RecyclingStationController(garbageFactory, strategyHolder, recyclingStation);
var commandInterpreter = new CommandInterpreter(recyclingStationController);
var writer = new ConsoleWriter();
var reader = new ConsoleReader();
var engine = new Engine(writer, reader, commandInterpreter);
engine.Run();
}
public void TestPropertyForReadOnlyCollection()
{
//Arrange
Type disType = typeof(DisposableAttribute);
IStrategyHolder sut = new StrategyHolder(strategies);
//Act
Type type = sut.GetDisposalStrategies.GetType();
//Assert
Assert.IsTrue(type.GetInterfaces().Contains(typeof(IReadOnlyCollection <>)));
}
public static void Main()
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
Dictionary <Type, IGarbageDisposalStrategy> strategies = new Dictionary <Type, IGarbageDisposalStrategy>();
IStrategyHolder strategyHolder = new StrategyHolder(strategies);
IGarbageProcessor garbageProcessor = new GarbageProcessor(strategyHolder);
IWasteFactory wasteFactory = new WasteFactory();
IRecyclingManager recyclingManager = new RecyclingManager(garbageProcessor, wasteFactory);
IEngine engine = new Engine(reader, writer, recyclingManager);
engine.Run();
}
private static void Main()
{
IOutputWriter outputWriter = new ConsoleWriter();
IInputReader inputReader = new ConsoleReader();
IRepository repo = new Repository();
IWasteFactory wasteFactory = new WasteFactory();
StrategyHolder strategies = new StrategyHolder();
IGarbageProcessor processor = new GarbageProcessor(strategies);
ICommandInterpreter commandInterpreter = new CommandInterpreter(repo, wasteFactory, processor);
IRunable engine = new Engine(commandInterpreter, inputReader, outputWriter);
engine.Run();
}
public void RemoveStrategies()
{
//Arrange
IGarbageDisposalStrategy ds = new BurnableGarbageDisposalStrategy();
Type disType = typeof(DisposableAttribute);
IDictionary <Type, IGarbageDisposalStrategy> strategies = new Dictionary <Type, IGarbageDisposalStrategy>();
IStrategyHolder sut = new StrategyHolder(strategies);
//Act
bool reult2 = sut.AddStrategy(disType, ds);
//Assert
Assert.IsTrue(sut.RemoveStrategy(disType));
}
public override async Task OnConnectedAsync()
{
var socketId = Context.ConnectionId;
int createdId = playersController.CreatePlayer(socketId);
int CreatedBAId = baController.CreateBA(createdId);
bool editedBAId = playersController.AddPlayerID(createdId, CreatedBAId);
//setting Strategy for newly connected player to -> BasicAttack
StrategyHolder.AddStrategy(socketId, new BasicAttack());
await Clients.All.SendAsync("UserConnected", Context.ConnectionId);
await base.OnConnectedAsync();
}
public void AddStrategy()
{
//Arrange
Type dystype = typeof(DisposableAttribute);
IStrategyHolder sut = new StrategyHolder(strategies);
//Act
bool result = sut.AddStrategy(dystype, ds);
//Assert
Assert.IsTrue(result);
}
public void TestPropertyForReadOnlyCollection()
{
//Arrange
IGarbageDisposalStrategy ds = new BurnableGarbageDisposalbeStrategy();
Type disType = typeof(DisposableAttribute);
Dictionary <Type, IGarbageDisposalStrategy> strategies = new Dictionary <Type, IGarbageDisposalStrategy>();
IStrategyHolder sut = new StrategyHolder(strategies);
//Act
Type type = sut.GetDisposalStrategies.GetType();
//Assert
Assert.IsTrue(sut.AddStrategy(disType, ds));
}
