public void InvalidControlDigitsShouldNotValidate()
{
foreach (var n in TestData.InvalidControlDigits)
{
Assert.AreEqual(NinValidation.InvalidControlDigit, Nin.Validate(n));
}
}
public void ValidNumberButUnsupportedKindShouldNotValidate()
{
var noKinds = new NinKind[0];
var allKinds = Enum.GetValues(typeof(NinKind)).Cast <NinKind>().ToArray();
foreach (var test in TestData.AllTestCases())
{
var allExceptThis = allKinds.Except(new[] { test.NumberKind }).ToArray();
Assert.IsTrue(Nin.IsValid(test.Number), "Valid number IsValid");
Assert.AreEqual(NinValidation.Valid, Nin.Validate(test.Number), "Valid number gives Valid result");
Assert.AreEqual(NinValidation.Valid, Nin.Validate(test.Number, allowedKinds: allKinds), "Valid number should validate when all kinds are specified");
Assert.AreEqual(NinValidation.Valid, Nin.Validate(test.Number, test.NumberKind), "Valid number should validate when its kind is specified");
foreach (var kind in allExceptThis)
{
Assert.AreEqual(NinValidation.Valid, Nin.Validate(test.Number, test.NumberKind, kind), "Valid number should validate when its kind is specified");
Assert.AreEqual(NinValidation.UnsupportedKind, Nin.Validate(test.Number, kind), "Valid number should give unsupportedkind when its kind is not specified");
}
Assert.AreEqual(NinValidation.UnsupportedKind, Nin.Validate(test.Number, allowedKinds: noKinds), "Valid number should give unsupportedkind when no kinds are specified");
Assert.AreEqual(NinValidation.UnsupportedKind, Nin.Validate(test.Number, allowedKinds: allExceptThis), "Valid number should give unsupportedkind when kind is missing");
}
}
public void SortOrder()
{
var n1 = new Nin("28122418857");
var n2 = new Nin("13128045818");
var correctOrder = new List <Nin>()
{
n2, n1
};
var nums = new List <Nin>()
{
n1, n2
};
nums.Sort();
CollectionAssert.AreEqual(correctOrder, nums);
Assert.IsTrue(n2 < n1, "Operator <");
Assert.IsTrue(n2 <= n1, "Operator <");
Assert.IsFalse(n1 < n2, "Operator <");
Assert.IsTrue(n1 > n2, "Operator >");
Assert.IsTrue(n1 >= n2, "Operator >");
Assert.IsFalse(n2 > n1, "Operator >");
}
public void ConvertToNumber()
{
foreach (var n in TestData.RandomNumbers)
{
var fnr = new Nin(n);
var num = long.Parse(n);
Assert.AreEqual(num, fnr.ToNumber());
}
}
private void RunTests(TestData.TestCase testcase)
{
var nin = new Nin(testcase.Number);
TestDateOfBirth(testcase, nin);
TestNumberType(testcase, nin);
TestGender(testcase, nin);
TestLongConversion(testcase, nin);
TestStringConversion(testcase, nin);
}
public Manager(Name name, Nin nin, Password password)
{
AddNotifications(
name.contract,
nin.contract,
password.contract);
if (Valid)
{
Name = name;
Nin = nin;
Password = password;
}
}
public Worker(int id, Name name, DateTime birthDate, Nin nin) : base(id)
{
AddNotifications(
name.contract,
ValidateBirthDate(birthDate),
nin.contract);
if (Valid)
{
Name = name;
BirthDate = birthDate;
Nin = nin;
}
}
public void Equality()
{
var notEqualStr = TestData.RandomNumbers.First();
var notEqual = new Nin(notEqualStr);
foreach (var n in TestData.RandomNumbers.Except(new[] { notEqualStr }))
{
var a = new Nin(n);
var b = new Nin(n);
Assert.AreEqual(a.GetHashCode(), b.GetHashCode(), "HashCode");
Assert.IsTrue(a.Equals(b), "Equals");
Assert.IsTrue(b.Equals(a), "Equals");
Assert.AreEqual(a, b);
Assert.IsFalse(a.Equals(null), "Equals null");
Assert.IsTrue(a.CompareTo(null) > 0, "Compare to null");
Assert.IsTrue(a == b, "Operator ==");
Assert.IsTrue(b == a, "Operator ==");
Assert.IsFalse(a == null, "Operator == null");
Assert.IsFalse(null == a, "Operator == null");
Assert.IsTrue(a > null, "Operator > null");
Assert.IsFalse(a < null, "Operator > null");
Assert.IsTrue(null < a, "Operator < null");
Assert.IsFalse(null > a, "Operator < null");
Assert.AreEqual(0, a.CompareTo(b), "CompareTo<T>");
Assert.AreEqual(0, b.CompareTo(a), "CompareTo<T>");
Assert.AreEqual(0, a.CompareTo((object)b), "CompareTo");
Assert.AreEqual(0, b.CompareTo((object)a), "CompareTo");
Assert.AreNotEqual(a, notEqual);
Assert.AreNotEqual(a.GetHashCode(), notEqual.GetHashCode());
Assert.IsFalse(a.Equals(notEqual));
Assert.AreNotEqual(0, a.CompareTo(notEqual));
Assert.AreNotEqual(0, a.CompareTo((object)notEqual));
}
}
public void ValidNumbersWithOneChangedDigitShouldNotValidate()
{
foreach (var testCase in TestData.AllTestCases())
{
for (var idxToMutate = 0; idxToMutate < testCase.Number.Length; ++idxToMutate)
{
var num = testCase.Number.ToCharArray();
var oldDigit = (int)(num[idxToMutate] - '0');
int newDigit;
do
{
newDigit = rand.Next(0, 9);
} while (newDigit == oldDigit);
num[idxToMutate] = newDigit.ToString()[0];
var changedStr = new string(num);
Assert.IsFalse(Nin.IsValid(changedStr), "A Nin with one digit changed should never validate (original {0}, changed {1})", testCase.Number, changedStr);
}
}
}
public bool Nonin()
{
return(Nin.IsValid(Value));
}
private void TestDateOfBirth(TestData.TestCase n, Nin f)
{
Assert.AreEqual(n.DateOfBirth, f.DateOfBirth, "DoB in " + n.Number);
}
private void TestNumberType(TestData.TestCase n, Nin f)
{
Assert.AreEqual(n.NumberKind, f.Kind, "Type in " + n.Number);
}
private void TestGender(TestData.TestCase n, Nin f)
{
Assert.AreEqual(n.Gender, f.Gender, "Gender in " + n.Number);
}
private void TestLongConversion(TestData.TestCase n, Nin f)
{
var l = Convert.ToInt64(n.Number);
Assert.AreEqual(l, f.ToNumber(), "ToNumber in " + n.Number);
}
private void TestStringConversion(TestData.TestCase n, Nin f)
{
Assert.AreEqual(n.Number, f.ToString(), "ToString in " + n.Number);
}
