public void StarbaseListPersist()
{
ResponseCache.Clear();
StarbaseList starbaseList = EveApi.GetStarbaseList(432435, 234523, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
StarbaseList cachedStarbaseList = EveApi.GetStarbaseList(432435, 234523, "apiKey");
Assert.AreEqual(starbaseList.CachedUntilLocal, cachedStarbaseList.CachedUntilLocal);
for (int i = 0; i < starbaseList.StarbaseListItems.Length; i++)
{
Assert.AreEqual(starbaseList.StarbaseListItems[i].ItemId, cachedStarbaseList.StarbaseListItems[i].ItemId);
Assert.AreEqual(starbaseList.StarbaseListItems[i].TypeId, cachedStarbaseList.StarbaseListItems[i].TypeId);
Assert.AreEqual(starbaseList.StarbaseListItems[i].LocationId, cachedStarbaseList.StarbaseListItems[i].LocationId);
Assert.AreEqual(starbaseList.StarbaseListItems[i].MoonId, cachedStarbaseList.StarbaseListItems[i].MoonId);
Assert.AreEqual(starbaseList.StarbaseListItems[i].State, cachedStarbaseList.StarbaseListItems[i].State);
Assert.AreEqual(starbaseList.StarbaseListItems[i].StateTimestamp, cachedStarbaseList.StarbaseListItems[i].StateTimestamp);
Assert.AreEqual(starbaseList.StarbaseListItems[i].OnlineTimestamp, cachedStarbaseList.StarbaseListItems[i].OnlineTimestamp);
Assert.AreEqual(starbaseList.StarbaseListItems[i].StateTimestampLocal, cachedStarbaseList.StarbaseListItems[i].StateTimestampLocal);
Assert.AreEqual(starbaseList.StarbaseListItems[i].OnlineTimestampLocal, cachedStarbaseList.StarbaseListItems[i].OnlineTimestampLocal);
}
}
public void PersistSkillInTraining()
{
ResponseCache.Clear();
SkillQueue skillqueue = EveApi.GetSkillQueue(56456, 4564356, "asdf");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
SkillQueue cached = EveApi.GetSkillQueue(4563456, 36456, "asdf");
//Test the Cache Time
Assert.AreEqual(skillqueue.CachedUntilLocal, cached.CachedUntilLocal);
//Attributes of the first skill in the queue
Assert.AreEqual(cached.SkillList[0].QueuePosition, skillqueue.SkillList[0].QueuePosition);
Assert.AreEqual(cached.SkillList[0].TrainingTypeId, skillqueue.SkillList[0].TrainingTypeId);
Assert.AreEqual(cached.SkillList[0].TrainingToLevel, skillqueue.SkillList[0].TrainingToLevel);
Assert.AreEqual(cached.SkillList[0].TrainingStartSP, skillqueue.SkillList[0].TrainingStartSP);
Assert.AreEqual(cached.SkillList[0].TrainingEndSP, skillqueue.SkillList[0].TrainingEndSP);
Assert.AreEqual(cached.SkillList[0].TrainingStartTime, skillqueue.SkillList[0].TrainingStartTime);
Assert.AreEqual(cached.SkillList[0].TrainingEndTime, skillqueue.SkillList[0].TrainingEndTime);
Assert.AreEqual(cached.SkillList[0].TrainingStartTimeLocal, skillqueue.SkillList[0].TrainingStartTimeLocal);
Assert.AreEqual(cached.SkillList[0].TrainingEndTimeLocal, skillqueue.SkillList[0].TrainingEndTimeLocal);
//Attributes of the second skill in the queue
Assert.AreEqual(cached.SkillList[1].QueuePosition, skillqueue.SkillList[1].QueuePosition);
Assert.AreEqual(cached.SkillList[1].TrainingTypeId, skillqueue.SkillList[1].TrainingTypeId);
Assert.AreEqual(cached.SkillList[1].TrainingToLevel, skillqueue.SkillList[1].TrainingToLevel);
Assert.AreEqual(cached.SkillList[1].TrainingStartSP, skillqueue.SkillList[1].TrainingStartSP);
Assert.AreEqual(cached.SkillList[1].TrainingEndSP, skillqueue.SkillList[1].TrainingEndSP);
Assert.AreEqual(cached.SkillList[1].TrainingStartTime, skillqueue.SkillList[1].TrainingStartTime);
Assert.AreEqual(cached.SkillList[1].TrainingEndTime, skillqueue.SkillList[1].TrainingEndTime);
Assert.AreEqual(cached.SkillList[1].TrainingStartTimeLocal, skillqueue.SkillList[1].TrainingStartTimeLocal);
Assert.AreEqual(cached.SkillList[1].TrainingEndTimeLocal, skillqueue.SkillList[1].TrainingEndTimeLocal);
}
public void FactionSystemsPersist()
{
ResponseCache.Clear();
MapFacWarSystems systems = EveApi.GetFactionWarSystems();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
MapFacWarSystems cache = EveApi.GetFactionWarSystems();
Assert.AreEqual(cache.CachedUntilLocal, systems.CachedUntilLocal);
Assert.AreEqual(cache.FactionWarSystems.Length, systems.FactionWarSystems.Length);
for (int i = 0; i < systems.FactionWarSystems.Length; i++)
{
MapFacWarSystems.FactionWarSystem system = systems.FactionWarSystems[i];
MapFacWarSystems.FactionWarSystem cached = cache.FactionWarSystems[i];
Assert.AreEqual(cached.SolarSystemId, system.SolarSystemId);
Assert.AreEqual(cached.SolarSystemName, system.SolarSystemName);
Assert.AreEqual(cached.OccupyingFactionId, system.OccupyingFactionId);
Assert.AreEqual(cached.OccupyingFactionName, system.OccupyingFactionName);
Assert.AreEqual(cached.Contested, system.Contested);
}
}
public void GetSkillInTraining()
{
ResponseCache.Clear();
SkillQueue skillqueue = EveApi.GetSkillQueue(456456, 456436, "asdf");
SkillQueue.Skill skill0 = skillqueue.SkillList[0];
SkillQueue.Skill skill1 = skillqueue.SkillList[1];
//Attributes of the first skill in the queue
Assert.AreEqual(1, skill0.QueuePosition);
Assert.AreEqual(11441, skill0.TrainingTypeId);
Assert.AreEqual(3, skill0.TrainingToLevel);
Assert.AreEqual(7072, skill0.TrainingStartSP);
Assert.AreEqual(40000, skill0.TrainingEndSP);
Assert.AreEqual(new DateTime(2009, 03, 18, 02, 01, 06), skill0.TrainingStartTime);
Assert.AreEqual(new DateTime(2009, 03, 18, 15, 19, 21), skill0.TrainingEndTime);
Assert.AreEqual(new DateTime(2009, 03, 17, 21, 01, 06), skill0.TrainingStartTimeLocal);
Assert.AreEqual(new DateTime(2009, 03, 18, 10, 19, 21), skill0.TrainingEndTimeLocal);
//Attributes of the second skill in the queue
Assert.AreEqual(2, skill1.QueuePosition);
Assert.AreEqual(20533, skill1.TrainingTypeId);
Assert.AreEqual(4, skill1.TrainingToLevel);
Assert.AreEqual(112000, skill1.TrainingStartSP);
Assert.AreEqual(633542, skill1.TrainingEndSP);
Assert.AreEqual(new DateTime(2009, 03, 18, 15, 19, 21), skill1.TrainingStartTime);
Assert.AreEqual(new DateTime(2009, 03, 30, 03, 16, 14), skill1.TrainingEndTime);
Assert.AreEqual(new DateTime(2009, 03, 18, 10, 19, 21), skill1.TrainingStartTimeLocal);
Assert.AreEqual(new DateTime(2009, 03, 29, 22, 16, 14), skill1.TrainingEndTimeLocal);
}
public void GetSkillTree()
{
ResponseCache.Clear();
SkillTree skillTree = EveApi.GetSkillTree();
SkillTree.Skill skill = findSkill(3368, skillTree);
Assert.AreEqual("Ethnic Relations", skill.TypeName);
Assert.AreEqual(266, skill.GroupId);
Assert.AreEqual(3368, skill.TypeId);
Assert.AreEqual("Skill at operating multiracial", skill.Description.Substring(0, 30));
Assert.AreEqual(2, skill.Rank);
Assert.AreEqual(2, skill.RequiredSkills.Length);
Assert.AreEqual(3363, skill.RequiredSkills[0].TypeId);
Assert.AreEqual(2, skill.RequiredSkills[0].SkillLevel);
Assert.AreEqual(3355, skill.RequiredSkills[1].TypeId);
Assert.AreEqual(3, skill.RequiredSkills[1].SkillLevel);
Assert.AreEqual(SkillTree.AttributeType.Memory, skill.PrimaryAttribute);
Assert.AreEqual(SkillTree.AttributeType.Charisma, skill.SecondaryAttribute);
Assert.AreEqual(1, skill.SkillBonuses.Length);
Assert.AreEqual("nonRaceCorporationMembersBonus", skill.SkillBonuses[0].BonusType);
Assert.AreEqual(20, skill.SkillBonuses[0].BonusValue);
Assert.AreEqual("Corporation Management", skillTree.SkillGroups[0].GroupName);
Assert.AreEqual(266, skillTree.SkillGroups[0].GroupId);
}
public void UsingStreams()
{
ResponseCache.Clear();
string errorListLocation = Constants.ErrorList;
Constants.ErrorList = "/ErrorListNotExpired.xml.aspx";
ErrorList errorList = EveApi.GetErrorList();
using (Stream s = new FileStream("ResponseCache.xml", FileMode.Create))
{
ResponseCache.Save(s);
}
ResponseCache.Clear();
using (Stream s = new FileStream("ResponseCache.xml", FileMode.Open))
{
ResponseCache.Load(s);
}
ErrorList cached = EveApi.GetErrorList();
Assert.AreEqual(errorList.CachedUntilLocal, cached.CachedUntilLocal);
Assert.AreEqual(false, errorList.FromCache);
Assert.AreEqual(true, cached.FromCache);
Constants.ErrorList = errorListLocation;
}
public void StarbaseDetailPersist()
{
ResponseCache.Clear();
StarbaseDetail starbaseDetail = EveApi.GetStarbaseDetail(432435, 234523, "fullApiKey", 25245);
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
StarbaseDetail cachedStarbaseDetail = EveApi.GetStarbaseDetail(432435, 234523, "fullApiKey", 25245);
Assert.AreEqual(starbaseDetail.CachedUntilLocal, cachedStarbaseDetail.CachedUntilLocal);
Assert.AreEqual(starbaseDetail.UsageFlags, cachedStarbaseDetail.UsageFlags);
Assert.AreEqual(starbaseDetail.DeployFlags, cachedStarbaseDetail.DeployFlags);
Assert.AreEqual(starbaseDetail.AllowCorporationMembers, cachedStarbaseDetail.AllowCorporationMembers);
Assert.AreEqual(starbaseDetail.AllowAllianceMembers, cachedStarbaseDetail.AllowAllianceMembers);
Assert.AreEqual(starbaseDetail.ClaimSovereignty, cachedStarbaseDetail.ClaimSovereignty);
Assert.AreEqual(starbaseDetail.OnStandingDropEnabled, cachedStarbaseDetail.OnStandingDropEnabled);
Assert.AreEqual(starbaseDetail.OnStandingDropStanding, cachedStarbaseDetail.OnStandingDropStanding);
Assert.AreEqual(starbaseDetail.OnStatusDropEnabled, cachedStarbaseDetail.OnStatusDropEnabled);
Assert.AreEqual(starbaseDetail.OnStatusDropStanding, cachedStarbaseDetail.OnStatusDropStanding);
Assert.AreEqual(starbaseDetail.OnAgressionEnabled, cachedStarbaseDetail.OnAgressionEnabled);
Assert.AreEqual(starbaseDetail.OnCorporationWarEnabled, cachedStarbaseDetail.OnCorporationWarEnabled);
for (int i = 0; i < starbaseDetail.FuelList.Length; i++)
{
Assert.AreEqual(starbaseDetail.FuelList[i].TypeId, cachedStarbaseDetail.FuelList[i].TypeId);
Assert.AreEqual(starbaseDetail.FuelList[i].Quantity, cachedStarbaseDetail.FuelList[i].Quantity);
}
}
public void Add_KeyIsNotNullValueIsNull_AddsNullValue()
{
ResponseCache.Clear();
ResponseCache.Add("test", null);
var item = ResponseCache.Get("test");
Assert.That(string.IsNullOrEmpty(item), Is.True);
}
public void Add_KeyIsNotNullValueIsNotNull_AddsNonNullValue()
{
ResponseCache.Clear();
ResponseCache.Add("test", "value");
var item = ResponseCache.Get("test");
Assert.That(item, Is.EqualTo("value"));
}
public void GetErrorList()
{
ResponseCache.Clear();
ErrorList errorList = EveApi.GetErrorList();
Assert.AreEqual("Expected before ref/trans ID = 0: wallet not previously loaded.", errorList.GetMessageForErrorCode("100"));
Assert.AreEqual("Current security level not high enough.", errorList.GetMessageForErrorCode("200"));
Assert.AreEqual("User forced test error condition.", errorList.GetMessageForErrorCode("999"));
}
public void GetServerStatusTest()
{
ResponseCache.Clear();
ServerStatus serverStatus = EveApi.GetServerStatus();
Assert.AreEqual(true, serverStatus.ServerOpen);
Assert.AreEqual(28968, serverStatus.OnlinePlayers);
}
public void GetCorporationSheet()
{
ResponseCache.Clear();
CorporationSheet cs = EveApi.GetCorporationSheet(432435, 234523, "apiKey");
testCorporationSheet(cs);
ResponseCache.Clear();
CorporationSheet cs2 = EveApi.GetCorporationSheet(432435, 234523, "apiKey", 2345);
testCorporationSheet(cs2);
}
public void RefTypePersist()
{
ResponseCache.Clear();
RefTypes referenceType = EveApi.GetRefTypesList();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
RefTypes cachedReferenceType = EveApi.GetRefTypesList();
Assert.AreEqual(referenceType.CachedUntilLocal, cachedReferenceType.CachedUntilLocal);
}
public void ServerStatusPersist()
{
ResponseCache.Clear();
ServerStatus ss = EveApi.GetServerStatus();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
ServerStatus cached = EveApi.GetServerStatus();
Assert.AreEqual(cached.CachedUntilLocal, ss.CachedUntilLocal);
Assert.AreEqual(cached.ServerOpen, ss.ServerOpen);
Assert.AreEqual(cached.OnlinePlayers, ss.OnlinePlayers);
}
public void CommonElementParsing()
{
ResponseCache.Clear();
CharacterList characterList = EveApi.GetAccountCharacters(432435, "apiKey");
DateTime currentTime = new DateTime(2007, 12, 12, 11, 48, 50);
DateTime cachedUntil = new DateTime(2008, 12, 12, 12, 48, 50);
Assert.AreEqual(currentTime, characterList.CurrentTime);
Assert.AreEqual(cachedUntil, characterList.CachedUntil);
Assert.AreEqual(currentTime.ToLocalTime(), characterList.CurrentTimeLocal);
Assert.AreEqual(cachedUntil.ToLocalTime(), characterList.CachedUntilLocal);
Assert.AreEqual(false, characterList.FromCache);
}
public void GetSkillInTraining()
{
ResponseCache.Clear();
SkillInTraining skillintraining = EveApi.GetSkillInTraining(456456, 456436, "asdf");
//Attributes of the currently training skill
Assert.AreEqual(new DateTime(2008, 01, 27, 01, 42, 38), skillintraining.TrainingEndTime);
Assert.AreEqual(new DateTime(2008, 01, 25, 01, 04, 23), skillintraining.TrainingStartTime);
Assert.AreEqual(3412, skillintraining.TrainingTypeId);
Assert.AreEqual(36253, skillintraining.TrainingStartSP);
Assert.AreEqual(135765, skillintraining.TrainingDestinationSP);
Assert.AreEqual(4, skillintraining.TrainingToLevel);
Assert.AreEqual(true, skillintraining.SkillCurrentlyInTraining);
}
public void ExpiredApiResponse()
{
ResponseCache.Clear();
string errorListLocation = Constants.ErrorList;
Constants.ErrorList = "/ErrorListExpired.xml.aspx";
ErrorList errorList = EveApi.GetErrorList();
ErrorList errorList2 = EveApi.GetErrorList();
Assert.AreEqual(false, errorList.FromCache);
Assert.AreEqual(false, errorList2.FromCache);
Constants.ErrorList = errorListLocation;
}
public static void Main(String[] args)
{
Console.WriteLine("*******\nExample\n*******\n");
UseLocalUrls();
ResponseCache.Clear();
//MemberTrackingExample();
//MapSovereigntyExample();
//CharFacWarStatsExample();
WalletJournalExample();
JournalExample();
ResponseCache.Save("ResponseCache.xml");
Console.WriteLine("Press Any Key to Continue");
Console.ReadKey();
}
public void PersistCharacterId()
{
ResponseCache.Clear();
CharacterIdName cid = EveApi.GetCharacterIdName("test");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
CharacterIdName ccid = EveApi.GetCharacterIdName("test");
Assert.AreEqual(cid.CachedUntilLocal, ccid.CachedUntilLocal);
Assert.AreEqual(cid.CharacterIdItems[0].Name, ccid.CharacterIdItems[0].Name);
Assert.AreEqual(cid.CharacterIdItems[0].CharacterId, ccid.CharacterIdItems[0].CharacterId);
}
public void CorporationSheetPersist()
{
ResponseCache.Clear();
CorporationSheet cs = EveApi.GetCorporationSheet(432435, 234523, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
CorporationSheet cached = EveApi.GetCorporationSheet(432435, 234523, "apiKey");
Assert.AreEqual(cs.CachedUntilLocal, cached.CachedUntilLocal);
Assert.AreEqual(cs.CorporationId, cached.CorporationId);
Assert.AreEqual(cs.CorporationName, cached.CorporationName);
Assert.AreEqual(cs.Ticker, cached.Ticker);
Assert.AreEqual(cs.CeoId, cached.CeoId);
Assert.AreEqual(cs.CeoName, cached.CeoName);
Assert.AreEqual(cs.StationId, cached.StationId);
Assert.AreEqual(cs.StationName, cached.StationName);
Assert.AreEqual(cs.Description, cached.Description);
Assert.AreEqual(cs.Url, cached.Url);
Assert.AreEqual(cs.AllianceId, cached.AllianceId);
Assert.AreEqual(cs.AllianceName, cached.AllianceName);
Assert.AreEqual(cs.TaxRate, cached.TaxRate);
Assert.AreEqual(cs.MemberCount, cached.MemberCount);
Assert.AreEqual(cs.MemberLimit, cached.MemberLimit);
Assert.AreEqual(cs.Shares, cached.Shares);
for (int i = 0; i < cs.Divisions.Length; i++)
{
Assert.AreEqual(cs.Divisions[i].AccountKey, cached.Divisions[i].AccountKey);
Assert.AreEqual(cs.Divisions[i].Description, cached.Divisions[i].Description);
}
for (int i = 0; i < cs.WalletDivisions.Length; i++)
{
Assert.AreEqual(cs.WalletDivisions[i].AccountKey, cached.WalletDivisions[i].AccountKey);
Assert.AreEqual(cs.WalletDivisions[i].Description, cached.WalletDivisions[i].Description);
}
Assert.AreEqual(cs.Logo.GraphicId, cached.Logo.GraphicId);
Assert.AreEqual(cs.Logo.Shape1, cached.Logo.Shape1);
Assert.AreEqual(cs.Logo.Shape2, cached.Logo.Shape2);
Assert.AreEqual(cs.Logo.Shape3, cached.Logo.Shape3);
Assert.AreEqual(cs.Logo.Color1, cached.Logo.Color1);
Assert.AreEqual(cs.Logo.Color2, cached.Logo.Color2);
Assert.AreEqual(cs.Logo.Color3, cached.Logo.Color3);
}
public void ErrorListPersist()
{
ResponseCache.Clear();
ErrorList errorList = EveApi.GetErrorList();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
ErrorList cachedErrorList = EveApi.GetErrorList();
Assert.AreEqual(errorList.CachedUntilLocal, cachedErrorList.CachedUntilLocal);
Assert.AreEqual(errorList.GetMessageForErrorCode("100"), cachedErrorList.GetMessageForErrorCode("100"));
Assert.AreEqual(errorList.GetMessageForErrorCode("200"), cachedErrorList.GetMessageForErrorCode("200"));
Assert.AreEqual(errorList.GetMessageForErrorCode("999"), cachedErrorList.GetMessageForErrorCode("999"));
}
public void PersistSkillTree()
{
ResponseCache.Clear();
SkillTree skillTree = EveApi.GetSkillTree();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
SkillTree cached = EveApi.GetSkillTree();
Assert.AreEqual(skillTree.CachedUntilLocal, cached.CachedUntilLocal);
// Skill Groups
for (int i = 0; i < skillTree.SkillGroups.Length; i++)
{
Assert.AreEqual(skillTree.SkillGroups[i].GroupName, cached.SkillGroups[i].GroupName);
Assert.AreEqual(skillTree.SkillGroups[i].GroupId, cached.SkillGroups[i].GroupId);
}
// Skills
for (int i = 0; i < skillTree.Skills.Length; i++)
{
SkillTree.Skill skill = skillTree.Skills[i];
SkillTree.Skill cskill = cached.Skills[i];
Assert.AreEqual(skill.TypeName, cskill.TypeName);
Assert.AreEqual(skill.GroupId, cskill.GroupId);
Assert.AreEqual(skill.TypeId, cskill.TypeId);
Assert.AreEqual(skill.Description, cskill.Description);
Assert.AreEqual(skill.Rank, cskill.Rank);
Assert.AreEqual(skill.PrimaryAttribute, cskill.PrimaryAttribute);
Assert.AreEqual(skill.SecondaryAttribute, cskill.SecondaryAttribute);
for (int j = 0; j < skill.RequiredSkills.Length; j++)
{
Assert.AreEqual(skill.RequiredSkills[j].TypeId, cskill.RequiredSkills[j].TypeId);
Assert.AreEqual(skill.RequiredSkills[j].SkillLevel, cskill.RequiredSkills[j].SkillLevel);
}
for (int j = 0; j < skill.SkillBonuses.Length; j++)
{
Assert.AreEqual(skill.SkillBonuses[j].BonusType, cskill.SkillBonuses[j].BonusType);
Assert.AreEqual(skill.SkillBonuses[j].BonusType, cskill.SkillBonuses[j].BonusType);
}
}
}
public void CharacterSheetPersist()
{
ResponseCache.Clear();
CharacterSheet cs = EveApi.GetCharacterSheet(432435, 234523, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
CharacterSheet cached = EveApi.GetCharacterSheet(432435, 234523, "apiKey");
Assert.AreEqual(cached.CachedUntilLocal, cs.CachedUntilLocal);
Assert.AreEqual(cached.CharacterId, cs.CharacterId);
Assert.AreEqual(cached.Name, cs.Name);
Assert.AreEqual(cached.Race, cs.Race);
Assert.AreEqual(cached.BloodLine, cs.BloodLine);
Assert.AreEqual(cached.Gender, cs.Gender);
Assert.AreEqual(cached.CorporationName, cs.CorporationName);
Assert.AreEqual(cached.CorporationId, cs.CorporationId);
Assert.AreEqual(cached.Balance, cs.Balance);
Assert.AreEqual(cached.MemoryBonus.Name, cs.MemoryBonus.Name);
Assert.AreEqual(cached.MemoryBonus.Value, cs.MemoryBonus.Value);
Assert.AreEqual(cached.WillpowerBonus.Name, cs.WillpowerBonus.Name);
Assert.AreEqual(cached.WillpowerBonus.Value, cs.WillpowerBonus.Value);
Assert.AreEqual(cached.PerceptionBonus.Name, cs.PerceptionBonus.Name);
Assert.AreEqual(cached.PerceptionBonus.Value, cs.PerceptionBonus.Value);
Assert.AreEqual(cached.IntelligenceBonus.Name, cs.IntelligenceBonus.Name);
Assert.AreEqual(cached.IntelligenceBonus.Value, cs.IntelligenceBonus.Value);
Assert.AreEqual(cached.CharismaBonus.Name, cs.CharismaBonus.Name);
Assert.AreEqual(cached.CharismaBonus.Value, cs.CharismaBonus.Value);
Assert.AreEqual(cached.Intelligence, cs.Intelligence);
Assert.AreEqual(cached.Memory, cs.Memory);
Assert.AreEqual(cached.Charisma, cs.Charisma);
Assert.AreEqual(cached.Perception, cs.Perception);
Assert.AreEqual(cached.Willpower, cs.Willpower);
for (int i = 0; i < cs.SkillItemList.Length; i++)
{
Assert.AreEqual(cached.SkillItemList[i].TypeId, cs.SkillItemList[i].TypeId);
Assert.AreEqual(cached.SkillItemList[i].Skillpoints, cs.SkillItemList[i].Skillpoints);
Assert.AreEqual(cached.SkillItemList[i].Level, cs.SkillItemList[i].Level);
Assert.AreEqual(cached.SkillItemList[i].Unpublished, cs.SkillItemList[i].Unpublished);
}
}
public void GetAllianceList()
{
ResponseCache.Clear();
AllianceList al = EveApi.GetAllianceList();
AllianceList.AllianceListItem ali = al.AllianceListItems[0];
Assert.AreEqual("GoonSwarm", ali.Name);
Assert.AreEqual("OHGOD", ali.ShortName);
Assert.AreEqual(824518128, ali.AllianceId);
Assert.AreEqual(749147334, ali.ExecutorCorpId);
Assert.AreEqual(5620, ali.MemberCount);
Assert.AreEqual(new DateTime(2006, 6, 3, 00, 50, 00), ali.StartDate);
AllianceList.CorporationListItem cli = ali.CorporationListItems[0];
Assert.AreEqual(109788662, cli.CorporationId);
Assert.AreEqual(new DateTime(2007, 9, 9, 19, 12, 00), cli.StartDate);
}
public void PersistKillLog()
{
ResponseCache.Clear();
KillLog killLog = EveApi.GetKillLog(KillLogType.Character, 432435, 346, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
KillLog cachedKillLog = EveApi.GetKillLog(KillLogType.Character, 432435, 346, "apiKey");
Assert.AreEqual(killLog.CachedUntilLocal, cachedKillLog.CachedUntilLocal);
KillLog.Kill firstKill = getKill(63, killLog.Kills);
KillLog.Kill cachedFirstKill = getKill(63, cachedKillLog.Kills);
Assert.AreEqual(firstKill.Victim.CharacterId, cachedFirstKill.Victim.CharacterId);
}
public void PersistAssetList()
{
ResponseCache.Clear();
AssetList assetList = EveApi.GetAssetList(AssetListType.Corporation, 432435, 234523, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
AssetList cachedAssetList = EveApi.GetAssetList(AssetListType.Corporation, 432435, 234523, "apiKey");
Assert.AreEqual(assetList.CachedUntilLocal, cachedAssetList.CachedUntilLocal);
for (int i = 0; i < assetList.AssetListItems.Length; i++)
{
Assert.AreEqual(true, CompareAssets(assetList.AssetListItems[i], cachedAssetList.AssetListItems[i]));
}
}
public void JumpsPersist()
{
ResponseCache.Clear();
MapKills mapKills = EveApi.GetMapKills();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
MapKills cachedmapKills = EveApi.GetMapKills();
Assert.AreEqual(mapKills.CachedUntilLocal, cachedmapKills.CachedUntilLocal);
for (int i = 0; i < mapKills.MapSystemKills.Length; i++)
{
Assert.AreEqual(mapKills.MapSystemKills[i].PodKills, cachedmapKills.MapSystemKills[i].PodKills);
Assert.AreEqual(mapKills.MapSystemKills[i].ShipKills, cachedmapKills.MapSystemKills[i].ShipKills);
}
}
public void JumpsPersist()
{
ResponseCache.Clear();
MapJumps mapJumps = EveApi.GetMapJumps();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
MapJumps cachedMapJumps = EveApi.GetMapJumps();
Assert.AreEqual(mapJumps.CachedUntilLocal, cachedMapJumps.CachedUntilLocal);
for (int i = 0; i < mapJumps.MapSystemJumps.Length; i++)
{
Assert.AreEqual(mapJumps.MapSystemJumps[i].ShipJumps, cachedMapJumps.MapSystemJumps[i].ShipJumps);
Assert.AreEqual(mapJumps.MapSystemJumps[i].SolarSystemId, cachedMapJumps.MapSystemJumps[i].SolarSystemId);
}
}
public void GetMemberTracking()
{
ResponseCache.Clear();
MemberTracking memberTracking = EveApi.GetMemberTracking(432435, 234523, "fullApiKey");
Assert.AreEqual(memberTracking.Members.Length, 2);
// First member
MemberTracking.Member tracking = memberTracking.Members[0];
Assert.AreEqual(150336922, tracking.CharacterId);
Assert.AreEqual("corpexport", tracking.Name);
Assert.AreEqual(0, tracking.BaseId);
Assert.AreEqual(string.Empty, tracking.Base);
Assert.AreEqual("asdf", tracking.Title);
Assert.AreEqual(60011566, tracking.LocationId);
Assert.AreEqual("Bourynes VII - Moon 2 - University of Caille School", tracking.Location);
Assert.AreEqual(606, tracking.ShipTypeId);
Assert.AreEqual("Velator", tracking.ShipType);
Assert.AreEqual("0", tracking.RolesMask);
Assert.AreEqual("0", tracking.GrantableRoles);
Assert.AreEqual(new DateTime(2007, 6, 13, 14, 39, 00), tracking.StartDateTime);
Assert.AreEqual(new DateTime(2007, 6, 16, 21, 12, 00), tracking.LogonDateTime);
Assert.AreEqual(new DateTime(2007, 6, 16, 21, 36, 00), tracking.LogoffDateTime);
// Second Member
tracking = memberTracking.Members[1];
Assert.AreEqual(150337897, tracking.CharacterId);
Assert.AreEqual("corpslave", tracking.Name);
Assert.AreEqual(0, tracking.BaseId);
Assert.AreEqual(string.Empty, tracking.Base);
Assert.AreEqual(string.Empty, tracking.Title);
Assert.AreEqual(60011566, tracking.LocationId);
Assert.AreEqual("Bourynes VII - Moon 2 - University of Caille School", tracking.Location);
Assert.AreEqual(670, tracking.ShipTypeId);
Assert.AreEqual("Capsule", tracking.ShipType);
Assert.AreEqual("22517998271070336", tracking.RolesMask);
Assert.AreEqual("0", tracking.GrantableRoles);
Assert.AreEqual(new DateTime(2007, 6, 14, 13, 14, 00), tracking.StartDateTime);
Assert.AreEqual(new DateTime(2007, 6, 16, 21, 14, 00), tracking.LogonDateTime);
Assert.AreEqual(new DateTime(2007, 6, 16, 21, 35, 00), tracking.LogoffDateTime);
}
public void WalletTransactionsPersist()
{
ResponseCache.Clear();
WalletTransactions walletTransactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Corporation, 0, 0, "apiKey");
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
WalletTransactions cachedwalletTransactions = EveApi.GetWalletTransactionsList(WalletTransactionListType.Corporation, 0, 0, "apiKey");
Assert.AreEqual(walletTransactions.CachedUntilLocal, cachedwalletTransactions.CachedUntilLocal);
for (int i = 0; i < walletTransactions.WalletTransactionItems.Length; i++)
{
Assert.AreEqual(walletTransactions.WalletTransactionItems[i].CharacterId, cachedwalletTransactions.WalletTransactionItems[i].CharacterId);
Assert.AreEqual(walletTransactions.WalletTransactionItems[i].ClientName, cachedwalletTransactions.WalletTransactionItems[i].ClientName);
Assert.AreEqual(walletTransactions.WalletTransactionItems[i].Quantity, cachedwalletTransactions.WalletTransactionItems[i].Quantity);
}
}