public void ReturnsTrueForClassWithValueType()
{
object target = new OtherValueType();
var result = Testers.CheckNullInequality(target);
Assert.True(result);
}
public static PenetrationTesterAccount getAccount(string name)
{
PenetrationTesterAccount account = new PenetrationTesterAccount();
account = Testers.FirstOrDefault(x => x.Name == name);
return(account);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ProjectId,FirstName,LastName")] Testers testers)
{
if (id != testers.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(testers);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TestersExists(testers.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjectId"] = new SelectList(_context.Projects, "Id", "Name", testers.ProjectId);
return(View(testers));
}
public void ReturnsTrueForDefaultClass()
{
object target = new AnotherClass();
var result = Testers.CheckNullInequality(target);
Assert.True(result);
}
public void ReturnsTrueForClassWithStructuralEquality()
{
object target = new OtherClassWithEquality();
var result = Testers.CheckNullInequality(target);
Assert.True(result);
}
public void AndReturnsFalseIfBothAreDifferentTypes()
{
object left = new OtherClassWithEquality();
var result = Testers.CheckEquality(left, "Hello");
Assert.False(result);
}
public IEnumerable <Tester> GetAllTesters(Func <Tester, bool> predicat = null)
{
IEnumerable <Tester> Testers;
try
{
Testers = from p in TesterRoot.Elements()
select new Tester()
{
ID = Convert.ToInt32(p.Element("TesterID").Value),
FamilyName = (p.Element("FamilyName").Value).ToString(),
FirstName = (p.Element("FirstName").Value).ToString(),
Birthday = (p.Element("Birthday").Value).ToString(),
Gender = (p.Element("Gender").Value).ToString(),
PhoneNum = Convert.ToInt32(p.Element("PhoneNum").Value),
Address = (p.Element("Address").Value).ToString(),
Experience = Convert.ToInt32(p.Element("Address").Value),
MaxTestAmt = Convert.ToInt32(p.Element("MaxTestAmt").Value),
Model = (p.Element("Model").Value).ToString(),
Hours = (p.Element("Hours").Value).ToString(),
MaxDist = Convert.ToInt32(p.Element("MaxDist").Value),
};
if (predicat != null)
{
Testers = Testers.Where(predicat);
}
}
catch
{
Testers = null;
}
return(Testers);
}
public void AndReturnTrueForBasicObjects()
{
object target = new AnotherClass();
var result = Testers.CheckTypeInequality(typeof(AnotherClass), target);
Assert.True(result);
}
public void AndReturnsFalseIfRightObjectIsNull()
{
object left = new OtherClassWithEquality {
SomeNumber = 6
};
var result = Testers.CheckEquality(left, null);
Assert.False(result);
}
public void AndReturnsTrueForForTheSameBasicObject()
{
object thing = new AnotherClass {
SomeNumber = 5
};
var result = Testers.CheckEquality(thing, thing);
Assert.True(result);
}
public async Task <IActionResult> Create([Bind("Id,ProjectId,FirstName,LastName")] Testers testers)
{
if (ModelState.IsValid)
{
_context.Add(testers);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjectId"] = new SelectList(_context.Projects, "Id", "Name", testers.ProjectId);
return(View(testers));
}
public void AndReturnsFalseForObjectIfNotStructurallyEqual()
{
object left = new OtherClassWithEquality {
SomeNumber = 5
};
object right = new OtherClassWithEquality {
SomeNumber = 6
};
var result = Testers.CheckEquality(left, right);
Assert.False(result);
}
public bool IsLikelyValid()
{
if (TestName == null || Included == null || Testers == null || Required == null)
{
return(false);
}
TestDescription ??= "";
Included.ForEach(o => Path.GetFileName(o));
Testers.ForEach(o => Path.GetFileName(o));
Required.ForEach(o => Path.GetFileName(o));
return(true);
}
public void ReturnsTrueForClassImplementingStructuralEqualityAndIsNotStructuralEqual()
{
object left = new OtherClassWithEquality {
SomeNumber = 5
};
object right = new OtherClassWithEquality {
SomeNumber = 6
};
var result = Testers.CheckInequality(left, right);
Assert.True(result);
}
public void AndReturnsFalseForDefaultObjectEvenIfStructurallyEqual()
{
object left = new AnotherClass {
SomeNumber = 5, SomeString = "High-Low", someByte = 24, someChar = 'Z'
};
object right = new AnotherClass {
SomeNumber = 5, SomeString = "High-Low", someByte = 24, someChar = 'Z'
};
var result = Testers.CheckEquality(left, right);
Assert.False(result);
}
public void ReturnsTrueForDefaultClassEvenIfStructurallyEqual()
{
object left = new AnotherClass {
SomeNumber = 5, SomeString = "Hi", someByte = 2, someChar = 'B'
};
object right = new AnotherClass {
SomeNumber = 5, SomeString = "Hi", someByte = 2, someChar = 'B'
};
var result = Testers.CheckInequality(left, right);
Assert.True(result);
}
private static bool TestEmptyTypes(Func <object> constructor)
{
var a = constructor();
var b = constructor();
var correctNullEquality = Testers.CheckNullInequality(a);
var correctEquality = Testers.CheckEquality(a, b);
var commutativeEquality = Testers.CheckEquality(b, a);
return(correctNullEquality &&
correctEquality &&
commutativeEquality);
}
public void InitialTesters()
{
for (var i = 0; i < MinersCount; i++)
{
var keyPair = CryptoHelpers.GenerateKeyPair();
MinersKeyPairs.Add(keyPair);
var tester = new ContractTester <DPoSSideChainTestAElfModule>(ChainId, keyPair);
AsyncHelper.RunSync(
() => tester.InitialSideChainAsync());
Testers.Add(tester);
}
DPoSSideChainContractAddress = Testers[0].GetConsensusContractAddress();
}
public void ReturnsFalseIfNonOfTheObjectsMatchTheTypeOfThePopulatedItem()
{
object populatedItem = new OtherClassWithEquality {
SomeNumber = 42
};
IEnumerable <object> others = new object[]
{
"Hello",
5,
'A',
};
var result = Testers.CheckInequality(others, populatedItem);
Assert.True(result);
}
public ActionResult Create([Bind("Id,ProjectId,FirstName,LastName")] Testers tester)
{
try
{
if (ModelState.IsValid)
{
testerRepository.Add(tester);
return(RedirectToAction(nameof(Index)));
}
}
catch
{
return(NotFound());
}
return(View());
}
private static bool TestPopulatedTypes(Type t, IDictionary <Type, Func <object> > constructors)
{
var ctor = constructors[t];
var a = ctor();
var b = ctor();
var c = ctor();
var equalMembers = new[] { a, b, c };
var tType = a.GetType();
var(propertyValues, fieldValues) = Creator.GetPropertyAndFieldValues(tType, constructors);
var memberUnequalItems = SetupEqualityChecksBasedOnProperties(propertyValues, equalMembers, ctor, fieldValues);
var badFields = SetupEqualityChecksBasedOnFields(fieldValues, equalMembers, ctor, propertyValues);
memberUnequalItems.AddRange(badFields);
var empty = ctor();
var emptyInequality = Testers.CheckInequality(a, empty);
var bEquality = Testers.CheckEquality(a, b);
var bCommutativeEquality = Testers.CheckEquality(b, a);
var cEquality = Testers.CheckEquality(a, c);
var associativeEquality = Testers.CheckEquality(b, c);
var memberInequality = Testers.CheckInequality(memberUnequalItems, a);
var nullInequality = Testers.CheckNullInequality(a);
var selfEquality = Testers.CheckEquality(a, a);
var typeInequality = Testers.CheckTypeInequality(tType, a);
return
(nullInequality &&
emptyInequality &&
bEquality &&
bCommutativeEquality &&
cEquality &&
associativeEquality &&
memberInequality &&
selfEquality &&
typeInequality);
}
public void ReturnsFalseIfOneObjectIsThePopulatedObject()
{
object populatedItem = new OtherClassWithEquality {
SomeNumber = 42
};
IEnumerable <object> others = new[]
{
new OtherClassWithEquality {
SomeNumber = 42
},
new OtherClassWithEquality {
SomeNumber = 40
},
populatedItem,
};
var result = Testers.CheckInequality(others, populatedItem);
Assert.False(result);
}
public void ReturnsFalseForBasicObjectsIfOneOfThemIsThePopulatedItem()
{
object populatedItem = new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
};
IEnumerable <object> others = new []
{
new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
},
populatedItem,
new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
},
};
var result = Testers.CheckInequality(others, populatedItem);
Assert.False(result);
}
public void ReturnsTrueForBasicObjectsEvenIfStructurallyTheSame()
{
IEnumerable <object> others = new []
{
new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
},
new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
},
new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
},
};
object populatedItem = new AnotherClass {
someChar = 'T', someByte = 32, SomeNumber = 42, SomeString = "String"
};
var result = Testers.CheckInequality(others, populatedItem);
Assert.True(result);
}
public ActionResult Edit([Bind("Id,ProjectId,FirstName,LastName")] Testers model)
{
Testers tester = testerRepository.GetTester(model.Id);
try
{
if (ModelState.IsValid)
{
tester.ProjectId = model.ProjectId;
tester.FirstName = model.FirstName;
tester.LastName = model.LastName;
testerRepository.Update(tester);
return(RedirectToAction(nameof(Index)));
}
}
catch
{
return(NotFound());
}
return(View());
}
public void ReturnsTrueForObjectsThatDifferStructurally()
{
IEnumerable <object> others = new[]
{
new OtherClassWithEquality {
SomeNumber = 39
},
new OtherClassWithEquality {
SomeNumber = 40
},
new OtherClassWithEquality {
SomeNumber = 41
},
};
object populatedItem = new OtherClassWithEquality {
SomeNumber = 42
};
var result = Testers.CheckInequality(others, populatedItem);
Assert.True(result);
}
public void InitialTesters(Timestamp blockchainStartTime)
{
for (var i = 0; i < MinersCount; i++)
{
var keyPair = CryptoHelpers.GenerateKeyPair();
MinersKeyPairs.Add(keyPair);
}
foreach (var minersKeyPair in MinersKeyPairs)
{
var tester = new ContractTester <DPoSContractTestAElfModule>(ChainId, minersKeyPair);
AsyncHelper.RunSync(() =>
tester.InitialCustomizedChainAsync(MinersKeyPairs.Select(m => m.PublicKey.ToHex()).ToList(), 4000,
blockchainStartTime));
Testers.Add(tester);
}
AsyncHelper.RunSync(() => Testers.RunConsensusAsync(2));
ConsensusContractAddress = Testers[0].GetConsensusContractAddress();
}
public ActionResult Edit(int?id)
{
var tester = testerRepository.GetTester(id); //Retrieve Testers data from database
if (id == null)
{
return(NotFound());
}
//Instance of Testers created and populated with data retrieved from database
Testers testers = new Testers
{
Id = tester.Id,
ProjectId = tester.ProjectId,
FirstName = tester.FirstName,
LastName = tester.LastName
};
ViewData["ProjectId"] = new SelectList(projectRepository.GetAllProjects(), "Id", "Name");
return(View(testers));
}
public IEnumerable <Tester> getAllTesters(Func <Tester, bool> predicat = null)
{
IEnumerable <Tester> Testers;
try
{
Testers = from p in TesterRoot.Elements()
// where predicat
select new Tester()
{
id = Convert.ToInt32(p.Element("Identify address").Value),
familyName = p.Element("Family Name").Value,
Name = p.Element("Name").Value,
phoneNum = Convert.ToInt32(p.Element("PhoneNumber").Value),
Address = p.Element("Address").Value,
birthday = Convert.ToDateTime(p.Element("Birthday").Value),
Experience = Convert.ToInt32(p.Element("Experience").Value),
MaxTests = Convert.ToInt32(p.Element("Max_Test").Value),
/* valid = Convert.ToBoolean(p.Element("Valid").Value)*//*,*/
Vehile = (BE.vehicle)Enum.Parse(typeof(vehicle), p.Element("Vechile_Expert").Value),
Gender = (BE.gender)Enum.Parse(typeof(gender), p.Element("Gender").Value)
};
if (predicat != null)
{
Testers = Testers.Where(predicat);
}
}
catch
{
Testers = null;
}
return(Testers);
}
public void ReturnsFalseForNull()
{
var result = Testers.CheckNullInequality(null);
Assert.False(result);
}
/// <summary>
/// Create a new Testers object.
/// </summary>
/// <param name="ID">Initial value of Id.</param>
public static Testers CreateTesters(int ID)
{
Testers testers = new Testers();
testers.Id = ID;
return testers;
}
/// <summary>
/// There are no comments for Testers in the schema.
/// </summary>
public void AddToTesters(Testers testers)
{
base.AddObject("Testers", testers);
}
