public void ReturnCountOfAllAims_WhenNoFilteringParametesArePassed()
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******"
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******"
},
new Aim()
{
Name = "visit china", OwnerUsername = "******"
},
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
int count = service.GetAimsCount(null, null);
// Assert
Assert.AreEqual(aims.Count(), count);
}
public void FilterBySearchWord(string searchWord)
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******"
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******"
},
new Aim()
{
Name = "visit china", OwnerUsername = "******"
},
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
var result = service.ExploreAims(searchWord, null, null);
// Assert
var expectedAims = aims.Where(x => x.Name.Contains(searchWord) || x.OwnerUsername.Contains(searchWord)).ToList();
CollectionAssert.AreEquivalent(expectedAims, result);
}
public void ReturnCorrectAim_WhenAimWithSuchIdExists(int id)
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var expectedAim = new Aim();
expectedAim.Id = id;
var oneMoreAim = new Aim();
oneMoreAim.Id = 13;
var oneMoreAimTwo = new Aim();
oneMoreAimTwo.Id = 55;
var aims = new List <Aim>
{
oneMoreAim,
oneMoreAimTwo,
expectedAim
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
Aim aim = service.GetAimById(id);
// Assert
Assert.AreEqual(expectedAim, aim);
}
/// <summary>
/// 这是查询的方法
/// </summary>
/// <param name="dgv"></param>
/// <param name="where"></param>
public void SourceSearch(DataGridView dgv, string lb, string where)
{
List <BillIndex> bi = new List <BillIndex>();
switch (lb)
{
case "目的港":
bi = new AimService().GetReocrdBySearch(where);
break;
case "来源":
bi = new SourceService().GetReocrdBySearch(where);
break;
case "流向":
bi = new DirectionService().GetReocrdBySearch(where);
break;
case "发往地":
bi = new SendPlaceService().GetReocrdBySearch(where);
break;
}
dgv.Rows.Clear();
foreach (BillIndex item in bi)
{
int index = dgv.Rows.Add();
dgv.Rows[index].Cells["dgvShipListID"].Value = item.ID;
dgv.Rows[index].Cells["dgvShipListName"].Value = item.Title;
dgv.Rows[index].Cells["dgvShipListDate"].Value = item.Reg_Date.ToString("yyyy-MM-dd");
}
}
public void FilterByAimCategories(params int[] categoriesIds)
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
AimCategoryId = 1
},
new Aim()
{
AimCategoryId = 2
},
new Aim()
{
AimCategoryId = 8
},
new Aim()
{
AimCategoryId = 1
},
new Aim()
{
AimCategoryId = 2
},
new Aim()
{
AimCategoryId = 1
},
new Aim()
{
AimCategoryId = 2
},
new Aim()
{
AimCategoryId = 2
}
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
var filteredAims = service.ExploreAims(null, categoriesIds, null);
// Assert
var expectedAims = aims.Where(x => categoriesIds.Contains(x.AimCategoryId)).ToList();
CollectionAssert.AreEquivalent(expectedAims, filteredAims);
}
public UnitAction GetAction(Unit unit, Game game, AiCup2019.Debug debug)
{
if (m_lastTick >= game.CurrentTick) // Verify this number
{
//TODO: Check number of bullets
LogService.WriteLine("Cached choice");
return(CreateAction(m_lastGame.Units.First(u => u.unit.Id == unit.Id), m_lastGame));
}
Const.Reset(game.Properties, game);
Debug = debug;
var myGame = new MyGame(game, unit);
var sim = m_lastGame = new SimGame(myGame, unit);
m_lastTick = game.CurrentTick;
DistService.CalcDists(sim);
ShootService.Initialize(sim);
foreach (var b in sim.Bullets)
{
b.CalcCollisionTime(sim);
}
foreach (var u in sim.Units)
{
u.WalkTarget = WalkService.FindWalkTarget(sim, u);
u.AimTarget = AimService.GetAimTarget(sim, u);
u.Shoot = ShootService.ShouldShoot(sim, u);
if (u.Player.Id == unit.PlayerId)
{
u.IsMine = true;
}
}
LogService.WriteLine("FIRETIMER: " + m_lastGame.Units.First(u => u.unit.Id == unit.Id).FireTimer);
MCTSService.Search(sim);
//foreach (var u in sim.Units) u.debug = true;
MCTSService.DoOneRound(sim, true);
//foreach (var u in sim.Units) u.debug = false;
if (game.CurrentTick % 300 == 10)
{
Console.Error.WriteLine("Time: " + Const.GetTime + " Evals: " + Const.Evals + " Sims: " + Const.Sims);
}
var targetUnit = m_lastGame.Units.First(u => u.unit.Id == unit.Id);
DistService.DrawPath(targetUnit.Position, targetUnit.WalkTarget);
return(CreateAction(targetUnit, m_lastGame));
}
public void CallAimDataMethodAddAim_WithCorrectAim()
{
// Arrange
var mockedAim = new Mock <Aim>();
var mockedData = new Mock <IDearDiaryData>();
mockedData.Setup(x => x.Aims.Add(mockedAim.Object)).Verifiable();
AimService service = new AimService(mockedData.Object);
// Act
service.AddAim(mockedAim.Object);
// Assert
mockedData.Verify(x => x.Aims.Add(mockedAim.Object), Times.Once);
}
public void CallDataAimsAddMethod()
{
// Arrange
var mockedAim = new Mock <Aim>();
var mockedData = new Mock <IDearDiaryData>();
mockedData.Setup(x => x.Aims.Add(It.IsAny <Aim>())).Verifiable();
AimService service = new AimService(mockedData.Object);
// Act
service.AddAim(mockedAim.Object);
// Assert
mockedData.Verify(x => x.Aims.Add(It.IsAny <Aim>()), Times.Once);
}
public void FilteringAndOrderingSimultaneously()
{
// Arrange
string searchWord = "visit";
var categoriesIds = new int[] { 4, 3 };
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******", AimCategoryId = 4
},
new Aim()
{
Name = "visit russia", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "visit usa", OwnerUsername = "******", AimCategoryId = 1
},
new Aim()
{
Name = "visit egypt", OwnerUsername = "******", AimCategoryId = 4
}
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
var filteredOrderedAims = service.ExploreAims(searchWord, categoriesIds, "name");
// Assert
var expectedAims = aims.Where(x => x.Name.Contains(searchWord) || x.OwnerUsername.Contains(searchWord))
.Where(x => categoriesIds.Contains(x.AimCategoryId))
.OrderBy(x => x.Name)
.ToList();
CollectionAssert.AreEqual(expectedAims, filteredOrderedAims);
}
public void GetTheCorrectAims_WhenPagingOptionsChosen()
{
int page = 2;
int perPage = 2;
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******", AimCategoryId = 4
},
new Aim()
{
Name = "visit russia", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "visit usa", OwnerUsername = "******", AimCategoryId = 1
},
new Aim()
{
Name = "visit egypt", OwnerUsername = "******", AimCategoryId = 4
}
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
var pagingAims = service.ExploreAims(null, null, null, page, perPage);
// Assert
var expectedAims = aims.OrderBy(x => x.Name).Skip(2).Take(perPage);
// has to take visit egypt & russia
CollectionAssert.AreEqual(expectedAims, pagingAims);
}
public void ReturnCorrectCount_WhenFilteringByCategoriesAndSearchWord()
{
// Arrange
var categoriesIds = new int[] { 2, 3 };
string searchWord = "juMP".ToLower();
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******", AimCategoryId = 2
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******", AimCategoryId = 1
},
new Aim()
{
Name = "visit niagara falls", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "visit china", OwnerUsername = "******", AimCategoryId = 2
}
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
int count = service.GetAimsCount(searchWord, categoriesIds);
int expectedCount = aims
.Where(x => categoriesIds.Contains(x.AimCategoryId))
.Where(x => x.Name.ToLower().Contains(searchWord) || x.OwnerUsername.ToLower().Contains(searchWord))
.ToList().Count;
// Assert
Assert.AreEqual(expectedCount, count);
}
public void ReturnOrderedAimsByOwnerUsername()
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******", AimCategoryId = 4
},
new Aim()
{
Name = "visit russia", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "visit usa", OwnerUsername = "******", AimCategoryId = 1
},
new Aim()
{
Name = "visit egypt", OwnerUsername = "******", AimCategoryId = 4
}
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
var filteredAndOrderedAims = service.ExploreAims(null, null, "ownerusername");
// Assert
var expectedAims = aims.OrderBy(x => x.OwnerUsername).ToList();
CollectionAssert.AreEqual(expectedAims, filteredAndOrderedAims);
}
public void ReturnAllAims_WhenNoParametersArePassed()
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******", AimCategoryId = 4
},
new Aim()
{
Name = "visit russia", OwnerUsername = "******", AimCategoryId = 3
},
new Aim()
{
Name = "visit usa", OwnerUsername = "******", AimCategoryId = 1
},
new Aim()
{
Name = "visit egypt", OwnerUsername = "******", AimCategoryId = 4
}
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
var filteredAims = service.ExploreAims(null, null, null);
// Assert
CollectionAssert.AreEquivalent(aims.ToList(), filteredAims);
}
public void ReturnNull_WhenAimIsNotFound(int id)
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Mock <Aim>().Object,
new Mock <Aim>().Object,
new Mock <Aim>().Object
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
Aim aim = service.GetAimById(id);
// Assert
Assert.IsNull(aim);
}
public void ReturnCorrectCount_WhenFilteringBySearchWord(string searchWord)
{
// Arrange
var mockedData = new Mock <IDearDiaryData>();
var aims = new List <Aim>
{
new Aim()
{
Name = "Jump with parachute", OwnerUsername = "******"
},
new Aim()
{
Name = "build a spacecraft", OwnerUsername = "******"
},
new Aim()
{
Name = "visit niagara falls", OwnerUsername = "******"
},
new Aim()
{
Name = "visit china", OwnerUsername = "******"
},
}.AsQueryable();
mockedData.Setup(x => x.Aims.All).Returns(aims);
AimService service = new AimService(mockedData.Object);
// Act
int count = service.GetAimsCount(searchWord, null);
int expectedCount = aims.Where(x => x.Name.Contains(searchWord) || x.OwnerUsername.Contains(searchWord)).ToList().Count;
// Assert
Assert.AreEqual(expectedCount, count);
}
