public void SedolsWithIncorrectChecksum(string sedol)
        {
            var actual   = new SedolValidate().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, false, false, Constants.CHECKSUM_NOT_VALID);

            AssertValidationResult(expected, actual);
        }
        public void ValidSedols(string sedol)
        {
            var actual   = new SedolValidate().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, true, false, null);

            AssertValidationResult(expected, actual);
        }
        public void UserDefinedSedolsWithCorrectChecksum(string sedol)
        {
            var actual   = new SedolValidate().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, true, true, null);

            AssertValidationResult(expected, actual);
        }
        public void SedolsContainingInvalidCharacters(string sedol)
        {
            var actual   = new SedolValidate().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, false, false, Constants.SEDOL_CONTAINS_INVALID_CHARACTERS);

            AssertValidationResult(expected, actual);
        }
        public void SedolsNotSevenCharacters(string sedol)
        {
            var actual   = new SedolValidate().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, false, false, Constants.INPUT_STRING_NOT_VALID_LENGTH);

            AssertValidationResult(expected, actual);
        }
        public void StringContainingVowelsWillReturnExpectedValidationDetails(string sedol)
        {
            var actual   = new SedolValidator().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, false, false, Constants.INPUT_STRING_CONTAINS_VOWELS);

            AssertValidationResult(expected, actual);
        }
        public void SedolsContainingNonAlphanumericCharacters(string sedol)
        {
            var actual   = new SedolValidator().ValidateSedol(sedol);
            var expected = new SedolValidationResult(sedol, false, false, Constants.INPUT_STRING_NOT_ALPHANUMERIC);

            AssertValidationResult(expected, actual);
        }
示例#8
0
        public void Constructor_GivenValidParamenters_ConstructsValidInstance()
        {
            // Arrange
            var testInput             = "testInput";
            var isValid               = true;
            var isUserDefined         = false;
            var testValidationDetails = "testDetails";

            // Act
            var actual = new SedolValidationResult(testInput, isValid, isUserDefined, testValidationDetails);

            // Assert
            Assert.IsNotNull(actual);
            Assert.AreEqual(testInput, actual.InputString);
            Assert.AreEqual(isValid, actual.IsValidSedol);
            Assert.AreEqual(isUserDefined, actual.IsUserDefined);
            Assert.AreEqual(testValidationDetails, actual.ValidationDetails);
        }
示例#9
0
    public ISedolValidationResult ValidateSedol(string input)
    {
        SedolValidationResult result = new SedolValidationResult()
        {
            InputString       = input,
            IsValidSedol      = false,
            IsUserDefined     = false,
            ValidationDetails = null
        };

        if (String.IsNullOrEmpty(input) || (input.Length != 7))
        {
            result.ValidationDetails = "Input string was not 7-characters long";
        }
        else
        {
            #region calculate checkdigit
            int[] weights          = new int[] { 1, 3, 1, 7, 3, 9, 1 };
            int   weightedCheckSum = 0;

            for (int i = 0; i < 6; i++)
            {
                char letterOrDigit      = input[i];
                int  letterOrDigitValue = 0;

                if (letterOrDigit >= 'A' && letterOrDigit <= 'Z')
                {
                    letterOrDigitValue = GetLetterValue(letterOrDigit);
                }
                else
                {
                    int  digitValue = 0;
                    bool parseOk    = int.TryParse(letterOrDigit.ToString(), out digitValue);
                    if (parseOk)
                    {
                        letterOrDigitValue = digitValue;
                    }
                }

                weightedCheckSum += letterOrDigitValue * weights[i];
            }

            int checkDigit = (10 - (weightedCheckSum % 10)) % 10;
            #endregion

            int  inputCheckDigit        = 0;
            bool inputCheckDigitParseOk = int.TryParse(input[6].ToString(), out inputCheckDigit);
            if (inputCheckDigitParseOk && checkDigit != inputCheckDigit)
            {
                result.ValidationDetails = "Checksum digit does not agree with the rest of the input";
                result.IsValidSedol      = false;
            }
            else
            {
                result.IsValidSedol = true;
            }

            //There's no information in the readme file about what "IsUserDefined" means.
            //From the scenarios we can assume that if the SEDOL starts with 9 it's user defined ;)
            result.IsUserDefined = input[0] == '9';
        }

        return(result);
    }