public void CanProcessVocaLinkDoubleAlternateWithExceptionOne()
 {
     var accountDetails = new BankAccountDetails("118765", "64371389");
     accountDetails.WeightMappings = _fakedModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode);
     var result = _firstStepDblAlCalculator.Process(accountDetails);
     Assert.True(result);
 }

 public void CalculatesSumAsExpected()
 {
     var details = new BankAccountDetails("499273", "12345678");
     var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 1");
     var actual = _check.GetModulusSum(details, mapping);
     Assert.AreEqual(70,actual);
 }

 public void ExceptionFiveValidationTestSumCheck()
 {
     var details = new BankAccountDetails("938611", "07806039");
     var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5");
     var actual = _check.GetModulusSum(details, mapping);
     Assert.AreEqual(51, actual);
 }

 public void CalculatesExceptionSixTestCaseCorrectly()
 {
     var details = new BankAccountDetails("202959", "63748472");
     var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 1");
     var actual = _check.GetModulusSum(details, mapping);
     Assert.AreEqual(60,actual);
 }

 public void ExceptionFiveSecondCheckDigitIncorrect()
 {
     var accountDetails = new BankAccountDetails("938063", "15764273");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var result = _firstStepDblAlCalculator.Process(accountDetails);
     Assert.IsFalse(result);
 }

 public void CanProcessVocalinkStandardEleven()
 {
     var accountDetails = new BankAccountDetails("107999", "88837491");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var result = new FirstStandardModulusElevenCalculator().Process(accountDetails);
     Assert.True(result);
 }

 public void ExceptionFiveWhereFirstCheckPasses()
 {
     var accountDetails = new BankAccountDetails("938611", "07806039");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var result = _firstStepDblAlCalculator.Process(accountDetails);
     Assert.IsFalse(result);
 }

 public void ExceptionSixButNotAForeignAccount()
 {
     var accountDetails = new BankAccountDetails("202959", "63748472");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var result = _secondStepDblAlCalculator.Process(accountDetails);
     Assert.IsTrue(result);
 }

 public void ExceptionThreeWhereCisNeitherSixNorNine()
 {
     var accountDetails = new BankAccountDetails("827101", "28748352");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var result = _secondStepDblAlCalculator.Process(accountDetails);
     Assert.IsTrue(result);
 }

 public void CanProcessStandardElevenCheck()
 {
     var accountDetails = new BankAccountDetails("000000", "58177632");
     accountDetails.WeightMappings = _fakedModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode);
     var result = new FirstStandardModulusElevenCalculator().Process(accountDetails);
     Assert.True(result);
 }

 public void CanPassBasicModulus11Test()
 {
     var accountDetails = new BankAccountDetails("202959", "63748472");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var result = _calculator.Process(accountDetails);
     Assert.IsTrue(result);
 }

 public void KnownSortCodeIsTested(string sc, string an)
 {
     var accountDetails = new BankAccountDetails(sc, an);
     accountDetails.WeightMappings = _mockModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode);
     _ruleStep.Process(accountDetails);
     _firstModulusCalculatorStep.Verify(nr => nr.Process(accountDetails));
 }

 public void CanProcessDoubleAlternateCheck()
 {
     var accountDetails = new BankAccountDetails("499273", "12345678");
     accountDetails.WeightMappings = _fakedModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode);
     var result = _firstStepDblAlCalculator.Process(accountDetails);
     Assert.True(result);
 }

 public void ExceptionFiveFirstCheckCorrectSecondIncorrect()
 {
     var details = new BankAccountDetails("938063", "15764273");
     var mapping = new ModulusWeightMapping("012345 012346 dblal 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5");
     var actual = _check.GetModulusSum(details, mapping);
     Assert.AreEqual(58, actual);
 }

 protected bool ProcessWeightingRule(BankAccountDetails bankAccountDetails, IModulusWeightMapping modulusWeightMapping)
 {
     var weightingSum = new StandardModulusCheck().GetModulusSum(bankAccountDetails,modulusWeightMapping);
     var remainder = weightingSum%Modulus;
     return modulusWeightMapping.Exception == 4 
                ? bankAccountDetails.AccountNumber.GetExceptionFourCheckValue == remainder
                : remainder == 0;
 }

 //938000 938696 Mod11 7 6 5 4 3 2 7 6 5 4 3 2 0 0 5
 //938000 938696 DblAl 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5
 public void ExceptionFiveDoubleAlternateWhenBothPass()
 {
     var details = new BankAccountDetails("938063", "55065200");
     var mapping = new ModulusWeightMapping("938000 938696 DblAl 2 1 2 1 2 1 2 1 2 1 2 1 2 0 5");
     var actual = _check.GetModulusSum(details, mapping);
     Assert.AreEqual(40,actual);
     Assert.AreEqual(0,actual%10);
 }

 public void CanGetSecondAlternativeExceptionTwoValue()
 {
     var target = new BankAccountDetails("123456", "10000090")
                      {
                          WeightMappings = BuildMappingList("123456", 1, 1)
                      };
     Assert.AreEqual(BankAccountDetails.AisNotZeroAndGisNineWeights, target.GetExceptionTwoAlternativeWeights(new int[1]));
 }

 public void CorrectlySkipsUncheckableForeignAccount()
 {
     var accountDetails = new BankAccountDetails("200915", "41011166");
     accountDetails.WeightMappings = _mockModulusWeightTable.Object.GetRuleMappings(accountDetails.SortCode);
     _ruleStep.Process(accountDetails);
     Assert.IsTrue(accountDetails.FirstResult);
     _firstModulusCalculatorStep.Verify(nr => nr.Process(accountDetails), Times.Never());
 }

 public void CanCalculateForExceptionFiveWhereBothChecksPass()
 {
     var accountDetails = new BankAccountDetails("938063", "55065200");
     accountDetails.WeightMappings = ModulusWeightTable.GetInstance.GetRuleMappings(accountDetails.SortCode);
     var standardResult = _standardExceptionFiveCalculator.Process(accountDetails);
     var doubleResult = _secondDoubleAlternateExceptionFiveCalculator.Process(accountDetails);
     Assert.IsTrue(standardResult);
     Assert.IsTrue(doubleResult);
 }

 public override bool Process(BankAccountDetails bankAccountDetails)
 {
     if (!bankAccountDetails.AccountNumber.IsValidCouttsNumber)
     {
         return false;
     }
     bankAccountDetails.AccountNumber.SetElementAt(7, '0');
     return base.Process(bankAccountDetails);
 }