/// <summary>
/// SortOrderIndex per syntaxKind.
/// Kinds with 0 are considered unsorted and will be placed at the end.
/// </summary>
private static CompareHelper[] CreateCompareHelpers()
{
int numberOfSyntaxKinds = (int)TypeScript.Net.Types.SyntaxKind.Count;
var helpers = new CompareHelper[numberOfSyntaxKinds];
// Start SortOrder with 1, to catch accidental uninitialized values.
ushort sortOrder = 1;
CompareHelper.Register <IExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.NumericLiteral, (l, r) => CompareNumericLiteralExpression(l, r));
CompareHelper.Register <IExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.PrefixUnaryExpression, (l, r) => CompareNumericLiteralExpression(l, r));
sortOrder++;
CompareHelper.Register <ILiteralExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.StringLiteral, (l, r) => CompareStringLiteralExpression(l, r));
CompareHelper.Register <ILiteralExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.FirstTemplateToken, (l, r) => CompareStringLiteralExpression(l, r));
sortOrder++;
CompareHelper.Register <ITemplateExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.TemplateExpression, (l, r) => CompareTemplateExpression(l, r));
sortOrder++;
CompareHelper.Register <ITaggedTemplateExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.TaggedTemplateExpression, (l, r) => CompareTaggedTemplateExpression(l, r));
sortOrder++;
CompareHelper.Register <IExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.Identifier, (l, r) => CompareReferences(l, r));
CompareHelper.Register <IExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.PropertyAccessExpression, (l, r) => CompareReferences(l, r));
sortOrder++;
CompareHelper.Register <IElementAccessExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.ElementAccessExpression, (l, r) => CompareElementAccessExpression(l, r));
sortOrder++;
CompareHelper.Register <IExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.VoidExpression, (l, r) => CompareNodeAsText(l, r));
sortOrder++;
CompareHelper.Register <ICallExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.CallExpression, (l, r) => CompareCallExpression(l, r));
sortOrder++;
CompareHelper.Register <IParenthesizedExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.CallExpression, (l, r) => CompareParenthesisedExpression(l, r));
sortOrder++;
CompareHelper.Register <IConditionalExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.ConditionalExpression, (l, r) => CompareConditionalExpression(l, r));
sortOrder++;
CompareHelper.Register <ISwitchExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.SwitchExpression, (l, r) => CompareSwitchExpression(l, r));
sortOrder++;
CompareHelper.Register <ISpreadElementExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.SpreadElementExpression, (l, r) => CompareSpreadElementExpression(l, r));
sortOrder++;
CompareHelper.Register <IArrayLiteralExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.ArrayLiteralExpression, (l, r) => CompareArrayLiteralExpression(l, r));
sortOrder++;
CompareHelper.Register <IObjectLiteralExpression>(helpers, sortOrder, TypeScript.Net.Types.SyntaxKind.ObjectLiteralExpression, (l, r) => CompareObjectLiteralExpression(l, r));
return(helpers);
}
public byte[] VerifyMac(byte[] data, byte[] seed)
{
using (var rand = new DeterministicCryptoRandomGenerator(seed, false))
{
var hmacKey = new byte[PaddingOracleManger.HmacKeyLen];
rand.GetBytes(hmacKey, 0, hmacKey.Length);
using (HMAC hmac = new HMACSHA256(hmacKey))
{
var dataToCheck = data.Take(data.Length - (hmac.HashSize / 8)).ToArray();
var mac = data.Skip(dataToCheck.Length).ToArray();
var computedMac = hmac.ComputeHash(dataToCheck);
if (!CompareHelper.CompareArrays(mac, computedMac))
{
throw new Exception("Invalid MAC!");
}
return(dataToCheck);
}
}
}
public IActionResult OnGet(string answer)
{
if (!dayValidation.HasAccess(door))
{
return(RedirectToPage("Index", new { invalidDoor = door }));
}
if (string.IsNullOrEmpty(answer))
{
return(Page());
}
else if (CompareHelper.AreEqual(answer, "library"))
{
Solved = true;
}
else
{
ModelState.AddModelError(string.Empty, $"No, {answer} is not the correct solution.");
}
return(Page());
}
public override bool IsValid(object target, object value)
{
const string errorText = "The value {0} must fall within the range ({1} - {2}) .";
ErrorMessage = null;
if (CompareHelper.Compare(CompareOp.LessThan, value as IComparable, MinimumValue as IComparable))
{
ErrorMessage = string.Format(errorText, value, MinimumValue, MaximumValue);
return(false);
}
if (CompareHelper.Compare(CompareOp.GreaterThan, value as IComparable, MaximumValue as IComparable))
{
ErrorMessage = string.Format(errorText, value, MinimumValue, MaximumValue);
return(false);
}
return(true);
}
public void TestReadingJpyterDocument1()
{
var jupyterText = JupyterDocumentHelper.GetFileStringByFileName("Discover Sentiments in Tweets.ipynb");
var document = Jupyter.Parse(jupyterText);
//convert to json
var documentJson = ConvertDocumentToJson(document);
//convert to document again
var document2 = Jupyter.Parse(documentJson);
//Two class's property should be equal
Assert.IsTrue(CompareHelper.CompareWithJsonFormat(document, document2));
//Change name
document2.Metadata.KernelInfo.Name = "AAAA";
//Should not equal
Assert.IsFalse(CompareHelper.CompareWithJsonFormat(document, document2));
}
public IActionResult OnGet(string answer)
{
if (!dayValidation.HasAccess(door))
{
return(RedirectToPage("Index", new { invalidDoor = door }));
}
if (string.IsNullOrEmpty(answer))
{
return(Page());
}
if (CompareHelper.AreEqual("inception", answer))
{
Solved = true;
}
else
{
ModelState.AddModelError(string.Empty, $"The path connection {answer} does not match the available instructions.");
}
return(Page());
}
public T[] Sort <T>(T[] array) where T : IComparable
{
for (int curIndex = 0; curIndex < array.Length; curIndex++)
{
for (int prevIndex = curIndex - 1; prevIndex >= 0; prevIndex--)
{
var prevVal = array[prevIndex];
var curVal = array[prevIndex + 1];
var compareResult = CompareHelper.ComparesTo(curVal, prevVal);
if (compareResult == Comparison.LessThan)
{
array[prevIndex + 1] = prevVal;
array[prevIndex] = curVal;
}
}
}
return(array);
}
public T[] Sort <T>(T[] array) where T : IComparable
{
for (int ii = 0; ii < array.Length; ii++)
{
for (int jj = 0; jj < array.Length - ii - 1; jj++)
{
var result = CompareHelper.ComparesTo(
array[jj],
array[jj + 1]);
if (result == Comparison.GreaterThan)
{
var temp = array[jj];
array[jj] = array[jj + 1];
array[jj + 1] = temp;
}
}
}
return(array);
}
public void GetFolderTest(string dataKey)
{
Service service = new Service();
using (LiteDatabaseHelper db = new LiteDatabaseHelper())
{
// Prepare Test Data
Folder folder = TestDataStorage.GetFolder(dataKey, userStoryId);
// Given: I has existed folder (*) with known id in database
Guid id = db.Folder.Insert(folder).AsGuid;
// When: I use method GetFolder by id
Folder result = service.GetFolder(id);
// Then: It return exact folder's data that i want to get from database
Assert.IsTrue(CompareHelper.AreEqualFolders(folder, result));
}
Debug.WriteLine(userStoryId + " - GetFolderTest");
}
public static ObjectWorkspaceList GetObjectWorkspaces(CompareHelper compareHelper)
{
var lst = new ObjectWorkspaceList();
var fromObjs = compareHelper.FromDataSource.CurrentDatabase.GetDatabaseObjects(true);
var toObjs = compareHelper.ToDataSource.CurrentDatabase.GetDatabaseObjects(true);
foreach (var def in fromObjs)
{
if (def.ObjectType == typeof(Schema).Name && compareHelper.FromDataSource.GetType() != compareHelper.ToDataSource.GetType() &&
(!compareHelper.FromDataSource.CurrentDatabase.Schemas.Any(s => string.IsNullOrEmpty(s.SchemaName)) ||
!compareHelper.ToDataSource.CurrentDatabase.Schemas.Any(s => string.IsNullOrEmpty(s.SchemaName))))
{
continue;
}
DatabaseObjectBase sourceDef = def;
DatabaseObjectBase targetDef = toObjs.FirstOrDefault(t => objectsAreEqual(t, def));
lst.Workspaces.Add(new ObjectWorkspace(sourceDef, compareHelper.ToDataSource.CurrentDatabase, targetDef, compareHelper.IgnoreCase));
}
foreach (var def in toObjs
.Where(x => !fromObjs.Any(d => d.ToString() == x.ToString() && d.ObjectType == x.ObjectType)))
{
// TODO:
//if (compareHelper.FromDatabase.IsSQLite)
//{
// if (def.ObjectType == typeof(Schema).Name) continue;
// if (def.ObjectType == "WindowsUser") continue;
// if (def.ObjectType == "SQLUser") continue;
// if (def.ObjectType == "DatabaseRole") continue;
// if (def.ObjectType == "SQLLogin") continue;
//}
lst.DropWorkspaces.Add(new DropWorkspace(def));
}
return(lst);
}
public void LevelOrderBottomTest_3()
{
object[] nodes = { 1, 2, null, null, 3, 4, null, null, 5 };
TreeNode tree = TreeHelper.CreateBinaryTreeByArray(nodes);
IList <IList <int> > result = t107.LevelOrderBottom(tree);
IList <IList <int> > expect = new List <IList <int> >()
{
new List <int> {
5
}, new List <int> {
4
}, new List <int> {
3
}, new List <int> {
2
}, new List <int> {
1
}
};
Assert.IsTrue(CompareHelper.CompareListList(expect, result));
}
public void LevelOrderBottomTest_2()
{
object[] nodes = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, null, null, null, null, null, null, null, null, null, null, 11 };
TreeNode tree = TreeHelper.CreateBinaryTreeByArray(nodes);
IList <IList <int> > result = t107.LevelOrderBottom(tree);
IList <IList <int> > expect = new List <IList <int> >()
{
new List <int> {
11
}, new List <int> {
8, 9, 10
}, new List <int> {
4, 5, 6, 7
}, new List <int> {
2, 3
}, new List <int> {
1
}
};
Assert.IsTrue(CompareHelper.CompareListList(expect, result));
}
/// <summary>
/// Describes all strings to compare
/// </summary>
private void LetsCompare()
{
var comparer = new CompareHelper();
adsCount++;
if ((adsCount % adsNum) == 0)
{
if (mInterstitialAd.IsLoaded)
{
mInterstitialAd.Show();
}
else
{
var adRequest = new AdRequest.Builder().Build();
mInterstitialAd.LoadAd(adRequest);
}
}
comparer.CompareWhenLowIsGood(tvT_RepairCost1, tvT_RepairCost2);
comparer.CompareWhenHighIsGood(tvT_FirstYear1, tvT_FirstYear2);
comparer.CompareWhenLowIsGood(tvT_BattleRating1, tvT_BattleRating2);
comparer.CompareWhenHighIsGood(tvT_Penetration1, tvT_Penetration2);
comparer.CompareWhenHighIsGood(tvT_MuzzleVelocity1, tvT_MuzzleVelocity2);
comparer.CompareWhenLowIsGood(tvT_ReloadTime1, tvT_ReloadTime2);
comparer.CompareWhenHighIsGood(tvT_GunDepression1, tvT_GunDepression2);
comparer.CompareWhenHighIsGood(tvT_ReducedArmorFrontTurret1, tvT_ReducedArmorFrontTurret2);
comparer.CompareWhenHighIsGood(tvT_ReducedArmorTopSheet1, tvT_ReducedArmorTopSheet2);
comparer.CompareWhenHighIsGood(tvT_ReducedArmorBottomSheet1, tvT_ReducedArmorBottomSheet2);
comparer.CompareWhenHighIsGood(tvT_MaxSpeedAtRoad1, tvT_MaxSpeedAtRoad2);
comparer.CompareWhenHighIsGood(tvT_MaxSpeedAtTerrain1, tvT_MaxSpeedAtTerrain2);
comparer.CompareWhenHighIsGood(tvT_MaxReverseSpeed1, tvT_MaxReverseSpeed2);
comparer.CompareWhenLowIsGood(tvT_AccelerationTo1001, tvT_AccelerationTo1002);
comparer.CompareWhenLowIsGood(tvT_TurnTurretTime1, tvT_TurnTurretTime2);
comparer.CompareWhenLowIsGood(tvT_TurnHullTime1, tvT_TurnHullTime2);
comparer.CompareWhenHighIsGood(tvT_EnginePower1, tvT_EnginePower2);
comparer.CompareWhenLowIsGood(tvT_Weight1, tvT_Weight2);
comparer.CompareWhenHighIsGood(tvT_PowerToWeight1, tvT_PowerToWeight2);
}
private bool CheckExistingDevicePropertiesForUpdate(UpdateDevicePayload updateDevice, DeviceStateEnum deviceState, Guid?currentOwningCustomerUID, DeviceProperties existingDeviceProp)
{
bool areEqual = false;
updateDevice.DeviceState = deviceState.ToString();
if (updateDevice.DeregisteredUTC.HasValue)
{
updateDevice.DeregisteredUTC = CompareHelper.ConvertDateTimeForComparison(updateDevice.DeregisteredUTC.Value);
}
if (existingDeviceProp.DeregisteredUTC.HasValue)
{
existingDeviceProp.DeregisteredUTC = CompareHelper.ConvertDateTimeForComparison(existingDeviceProp.DeregisteredUTC.Value);
}
if (updateDevice.OwningCustomerUID == currentOwningCustomerUID &&
CompareHelper.AreObjectsEqual(updateDevice, existingDeviceProp, "DeviceUID", "DeviceType", "ActionUTC", "ReceivedUTC", "OwningCustomerUID"))
{
areEqual = true;
}
return(areEqual);
}
private async Task <IEnumerable <CompareHelper.Differ> > GetDiff(IEnumerable <string> exists)
{
var list = new List <CompareHelper.Differ>();
foreach (var objectName in exists)
{
var leftSqlTextOriginal = await SqlHelper.GetObjectDefinition(_leftConnectionString, objectName).ConfigureAwait(false);
var rightSqlTextOriginal = await SqlHelper.GetObjectDefinition(_rightConnectionString, objectName).ConfigureAwait(false);
var leftSqlText = CompareHelper.AdjustForCompare(leftSqlTextOriginal);
var rightSqlText = CompareHelper.AdjustForCompare(rightSqlTextOriginal);
if (leftSqlText == rightSqlText)
{
continue;
}
list.Add(new CompareHelper.Differ(objectName, leftSqlTextOriginal, rightSqlTextOriginal));
}
return(list);
}
public void UpdateResultTest()
{
var origenalData = Enumerable.Range(0, 5).Select(index => new TestClass()
{
Id = index,
Value1 = $"{index}",
Value2 = $"{index * 2}"
}).ToList();
var origenalTable = origenalData.ToDataTable();
Assert.IsNotNull(origenalData);
Assert.AreEqual(origenalTable.Rows[0]["Value1"].ToString(), "0");
origenalTable.Rows[0]["Value1"] = "1";
Assert.AreEqual(origenalTable.Rows[0]["Value1"].ToString(), "1");
var compareResult = CompareHelper.Compare(origenalData, origenalTable);
Assert.IsNotNull(compareResult);
Assert.AreEqual(compareResult.First(c => c.Type == CompareType.Update).Data.Count(), 1);
Assert.AreEqual(compareResult.First(c => c.Type == CompareType.Update).Data.First().Id, 0);
}
private void BuildRowDictionary(DataTable dt, DataRowKeysComparer keyComparer, Dictionary <KeyCollection, int> dict)
{
dict.Clear();
foreach (DataRow row in dt.Rows)
{
CompareHelper hlpr = new CompareHelper();
var keys = keyComparer.GetKeys(row);
hlpr.Keys = keys;
//Check that the rows in the reference are unique
// All the rows should be unique regardless of whether it is the system under test or the result set.
if (dict.ContainsKey(keys))
{
dict[keys]++;
}
else
{
dict.Add(keys, 1);
}
}
}
private async Task <IEnumerable <CompareHelper.Differ> > GetDiff(IEnumerable <string> exists)
{
var list = new List <CompareHelper.Differ>();
foreach (var file in exists)
{
var objectName = Path.GetFileNameWithoutExtension(file);
var fileTextOriginal = await FileHelper.ReadText(file).ConfigureAwait(false);
var fileText = CompareHelper.AdjustForCompare(fileTextOriginal);
var sqlTextOriginal = await SqlHelper.GetObjectDefinition(_connectionstring, objectName).ConfigureAwait(false);
var sqlText = CompareHelper.AdjustForCompare(sqlTextOriginal);
if (sqlText != fileText)
{
list.Add(new CompareHelper.Differ(objectName, sqlTextOriginal, fileTextOriginal));
}
}
return(list);
}
/// <nodoc />
public static void Register <T>(CompareHelper[] helpers, ushort relativeSortOrder, TypeScript.Net.Types.SyntaxKind syntaxKind, Comparison <T> comparable)
where T : class, IExpression
{
var helper = new CompareHelper(syntaxKind, relativeSortOrder,
(l, r) =>
{
var left = l.As <T>();
var right = r.As <T>();
if (left == null)
{
return(right == null ? 0 : -1);
}
if (right == null)
{
return(1);
}
return(comparable(left.As <T>(), right.As <T>()));
});
helpers[(int)syntaxKind] = helper;
}
public IActionResult OnGet(string answer)
{
CanSolve = dayValidation.HasAccess(door);
if (!CanSolve || string.IsNullOrEmpty(answer))
{
return(Page());
}
if (CompareHelper.AreEqual(answer, "book"))
{
ModelState.AddModelError(string.Empty, $"Yeah, it could be a book. But which one, what is the missing book called?");
}
else if (CompareHelper.AreEqual(answer, "gilli") ||
CompareHelper.AreEqual(answer, "seran"))
{
ModelState.AddModelError(string.Empty, $"No, the book {answer} is on the floor.");
}
else if (CompareHelper.AreEqual(answer, "sulien"))
{
ModelState.AddModelError(string.Empty, "I think Odin never owned the fifth book sulien.");
}
else if (CompareHelper.AreEqual(answer, "ring"))
{
ModelState.AddModelError(string.Empty, "Are you sure the ring is gone?");
}
else if (CompareHelper.AreEqual(answer, "mohidna"))
{
IsSolved = true;
}
else
{
ModelState.AddModelError(string.Empty, $"No, {answer} is not missing.");
}
Answer = answer;
return(Page());
}
public IActionResult OnGet(string answer)
{
if (!dayValidation.HasAccess(door))
{
return(RedirectToPage("Index", new { invalidDoor = door }));
}
if (string.IsNullOrEmpty(answer))
{
return(Page());
}
if (string.Equals(answer, "dollhouse", StringComparison.InvariantCultureIgnoreCase))
{
Solved = true;
}
else if (CompareHelper.AreEqual(answer, "topuvdppuollhideorainoguasmee"))
{
ModelState.AddModelError(string.Empty, $"His code is not a real christmas whish. His wish must be encrypted inside this code.");
}
else
{
ModelState.AddModelError(string.Empty, $"No, {answer} is not the Christmas wish from Juan.");
}
return(Page());
}
public IActionResult OnGet(string answer)
{
if (!dayValidation.HasAccess(door))
{
return(RedirectToPage("Index", new { invalidDoor = door }));
}
if (string.IsNullOrEmpty(answer))
{
return(Page());
}
if (CompareHelper.AreEqual("bank", answer))
{
Solved = true;
}
else if (CompareHelper.Contains(listedWords, answer))
{
ModelState.AddModelError(string.Empty, $"Just copying a single word from the list wont solve this riddle.");
}
else
{
ModelState.AddModelError(string.Empty, $"No, {answer} cannot be the solution.");
}
return(Page());
}
public IActionResult OnGet(string answer)
{
if (!dayValidation.HasAccess(door))
{
return(RedirectToPage("Index", new { invalidDoor = door }));
}
if (string.IsNullOrEmpty(answer))
{
return(Page());
}
if (CompareHelper.AreEqual(answer, "otis"))
{
Solved = true;
}
else if (CompareHelper.AreEqual(answer, "sito"))
{
ModelState.AddModelError(string.Empty, $"No, {answer} is wrong, what about the item above the numbers?");
}
else
{
ModelState.AddModelError(string.Empty, $"No, {answer} is not the saboteur.");
}
return(Page());
}
public IActionResult OnGet(string answer)
{
if (!dayValidation.HasAccess(door))
{
return RedirectToPage("Index", new { invalidDoor = door });
}
if (string.IsNullOrEmpty(answer))
{
return Page();
}
if (CompareHelper.AreEqual("train", answer))
{
Solved = true;
}
else if (CompareHelper.Contains(shapeNames, answer))
{
ModelState.AddModelError(string.Empty, $"Repeating the names is not the answer. We need to combine the shape and the number.");
}
else
{
ModelState.AddModelError(string.Empty, $"No, {answer} cannot be the solution.");
}
return Page();
}
public void SaveFolderTest_Success1()
{
string testCaseId = "TC100";
Service service = new Service();
using (LiteDatabaseHelper db = new LiteDatabaseHelper())
{
// Prepare Test Data
Folder result;
Folder folder = TestDataStorage.GetFolder("Folder Origin", userStoryId, testCaseId);
List <List <MyAttribute> > attributeList = new List <List <MyAttribute> >
{
TestDataStorage.GetAttributeList("Attribute List Origin", userStoryId, testCaseId),
TestDataStorage.GetAttributeList("Attribute List 1stUpdate", userStoryId, testCaseId),
TestDataStorage.GetAttributeList("Attribute List 2ndUpdate", userStoryId, testCaseId)
};
// Given: I has existed folder (*) with known id in database
Guid id = db.Folder.Insert(folder).AsGuid;
for (int i = 0; i < attributeList.Count; i++)
{
// And: I have changed its attributes
folder.Attributes = attributeList[i];
// When: I save it by using method SaveFolder
result = service.SaveFolder(folder, folder.Id);
// Then: It return exact folder's data that i have saved with new id
folder.Id = result.Id;
Assert.IsTrue(CompareHelper.AreEqualFolders(folder, result));
}
}
Debug.WriteLine(userStoryId + " - SaveFolderTest_Success1");
}
public static ObjectWorkspaceList GetObjectWorkspaces(CompareHelper compareHelper)
{
var lst = new ObjectWorkspaceList();
var fromObjs = compareHelper.FromDatabase.GetDatabaseObjects(true);
var toObjs = compareHelper.ToDatabase.GetDatabaseObjects(true);
foreach (var def in fromObjs)
{
DatabaseObjectBase sourceDef = def;
DatabaseObjectBase targetDef = toObjs.FirstOrDefault(t =>
t.ToString() == def.ToString() && t.ObjectType == def.ObjectType);
lst.Workspaces.Add(new ObjectWorkspace(compareHelper, sourceDef, targetDef));
}
foreach (var def in toObjs
.Where(x => !fromObjs.Any(d => d.ToString() == x.ToString() && d.ObjectType == x.ObjectType)))
{
lst.DropWorkspaces.Add(new DropWorkspace(def));
}
return(lst);
}
/// <summary>
/// Describes all strings to compare
/// </summary>
private void LetsCompare()
{
var comparer = new CompareHelper();
adsCount++;
if ((adsCount % adsNum) == 0)
{
if (mInterstitialAd.IsLoaded)
{
mInterstitialAd.Show();
}
else
{
var adRequest = new AdRequest.Builder().Build();
mInterstitialAd.LoadAd(adRequest);
}
}
comparer.CompareWhenLowIsGood(tvH_RepairCost1, tvH_RepairCost2);
comparer.CompareWhenHighIsGood(tvH_FirstYear1, tvH_FirstYear2);
comparer.CompareWhenLowIsGood(tvH_BattleRating1, tvH_BattleRating2);
comparer.CompareWhenHighIsGood(tvH_agmCount1, tvH_agmCount2);
comparer.CompareWhenHighIsGood(tvH_agmPenetration1, tvH_agmPenetration2);
comparer.CompareWhenHighIsGood(tvH_agmSpeed1, tvH_agmSpeed2);
comparer.CompareWhenHighIsGood(tvH_agmRange1, tvH_agmRange2);
comparer.CompareWhenHighIsGood(tvH_aamCount1, tvH_aamCount2);
comparer.CompareWhenHighIsGood(tvH_asmCount1, tvH_asmCount2);
comparer.CompareWhenHighIsGood(tvH_bombPayload1, tvH_bombPayload2);
comparer.CompareWhenHighIsGood(tvH_maxSpeed1, tvH_maxSpeed2);
comparer.CompareWhenLowIsGood(tvH_climbTo10001, tvH_climbTo10002);
comparer.CompareWhenLowIsGood(tvH_TurnTime1, tvH_TurnTime2);
comparer.CompareWhenHighIsGood(tvH_EnginePower1, tvH_EnginePower2);
comparer.CompareWhenLowIsGood(tvH_TakeOffWeight1, tvH_TakeOffWeight2);
comparer.CompareWhenHighIsGood(tvH_PowerToWeight1, tvH_PowerToWeight2);
}
public void Compare_EqualsObjectWithValueTypeAndClasses()
{
var productA = new Product()
{
Id = 1,
Name = "Name",
Category = new Category()
{
Id = 1,
Name = "CategoryName"
},
Company = new Company()
{
Id = 1
}
};
var productB = new Product()
{
Id = 1,
Name = "Name",
Category = new Category()
{
Id = 1,
Name = "CategoryName"
},
Company = new Company()
{
Id = 1
}
};
var result = CompareHelper.Compare(productA, productB);
Assert.AreEqual(true, result);
}
/// <summary>
/// Describes all strings to compare
/// </summary>
private void LetsCompare()
{
var comparer = new CompareHelper();
adsCount++;
if ((adsCount % adsNum) == 0)
{
if (mInterstitialAd.IsLoaded)
{
mInterstitialAd.Show();
}
else
{
var adRequest = new AdRequest.Builder().Build();
mInterstitialAd.LoadAd(adRequest);
}
}
comparer.CompareWhenLowIsGood(tvP_RepairCost1, tvP_RepairCost2);
comparer.CompareWhenHighIsGood(tvP_FirstYear1, tvP_FirstYear2);
comparer.CompareWhenLowIsGood(tvP_BattleRating1, tvP_BattleRating2);
comparer.CompareWhenHighIsGood(tvP_BurstMass1, tvP_BurstMass2);
comparer.CompareWhenHighIsGood(tvP_BombsPayload1, tvP_BombsPayload2);
comparer.CompareWhenHighIsGood(tvP_MaxSpeedAt0m1, tvP_MaxSpeedAt0m2);
comparer.CompareWhenHighIsGood(tvP_MaxSpeedAt5000m1, tvP_MaxSpeedAt5000m2);
comparer.CompareWhenLowIsGood(tvP_Climb1, tvP_Climb2);
comparer.CompareWhenLowIsGood(tvP_TurnTime1, tvP_TurnTime2);
comparer.CompareWhenHighIsGood(tvP_EnginePower1, tvP_EnginePower2);
comparer.CompareWhenLowIsGood(tvP_TakeOffWeight1, tvP_TakeOffWeight2);
comparer.CompareWhenHighIsGood(tvP_Flutter1, tvP_Flutter2);
comparer.CompareWhenHighIsGood(tvP_OptimalElevator1, tvP_OptimalElevator2);
comparer.CompareWhenHighIsGood(tvP_OptimalAilerons1, tvP_OptimalAilerons2);
comparer.CompareWhenHighIsGood(tvP_PowerToWeight1, tvP_PowerToWeight2);
}
public void FindErrorNumsTest_1()
{
int[] nums = { 1, 2, 5, 4, 6, 7, 8, 9, 10, 11, 12, 6, 13, 14, 15, 16, 17, 18, 19, 20 };
int[] expect = { 6, 3 };
Assert.IsTrue(CompareHelper.CompareArrays(expect, t563.FindErrorNums(nums)));
}
