public void TryReadQuotedString_WithValidMultipleQuotedStrings_ReturnTheIndexPastTheQuote()
        {
            int index = ValidMultipleQuotedStrings.Length - 1;

            Assert.True(QuotedStringFormatReader.TryReadReverseQuoted(ValidMultipleQuotedStrings, index, false, out index, throwExceptionIfFail: true));

            Assert.Equal(8, index);
        }
示例#2
0
        public void ReadQuotedString_WithValidQuotedString_ShouldReadCorrectly()
        {
            int index = ValidQuotedString.Length - 1;

            index = QuotedStringFormatReader.ReadReverseQuoted(ValidQuotedString, index, false);

            Assert.Equal(-1, index);
        }
        public void TryReadQuotedString_WithValidUnicodeQuotedString_ShouldReadCorrectly()
        {
            int index = UnicodeQuotedString.Length - 1;

            Assert.True(QuotedStringFormatReader.TryReadReverseUnQuoted(UnicodeQuotedString, index, true, false, out index, throwExceptionIfFail: true));

            Assert.Equal(-1, index);
        }
        public void TryReadQuotedString_WithEscapedCharacters_ShouldReadCorrectly()
        {
            int index = ValidQuotedStringWithEscapedChars.Length - 1;

            Assert.True(QuotedStringFormatReader.TryReadReverseQuoted(ValidQuotedStringWithEscapedChars, index, false, out index, throwExceptionIfFail: true));

            Assert.Equal(-1, index);
        }
        public void ReadQuotedString_WithValidMultipleQuotedStrings_ReturnTheIndexPastTheQuote()
        {
            int index = ValidMultipleQuotedStrings.Length - 1;

            index = QuotedStringFormatReader.ReadReverseQuoted(ValidMultipleQuotedStrings, index, false);

            Assert.Equal(8, index);
        }
        public void ReadQuotedString_WithValidMultipleStrings_ReturnTheDelimterIndex()
        {
            int index = ValidMultipleStrings.Length - 1;

            index = QuotedStringFormatReader.ReadReverseUnQuoted(ValidMultipleStrings, index, false, true);

            Assert.Equal(5, index);
        }
        public void ReadQuotedString_WithEscapedCharacters_ShouldReadCorrectly()
        {
            int index = ValidQuotedStringWithEscapedChars.Length - 1;

            index = QuotedStringFormatReader.ReadReverseQuoted(ValidQuotedStringWithEscapedChars, index, false);

            Assert.Equal(-1, index);
        }
示例#8
0
        // Parses the display-name section of an address.  In departure from the RFC, we attempt to read data in the
        // quoted-string format even if the bounding quotes are omitted.  We also permit Unicode, which the RFC does
        // not allow for.
        // e.g. ("display name" <user@domain>) or (display name <user@domain>)
        //
        // Preconditions:
        //
        // Postconditions:
        // - data[index] should refer to the comma ',' separator, if any
        // - index == -1 if the beginning of the data string has been reached.
        // - returns the parsed display-name, excluding any bounding quotes around quoted-strings
        //
        // Throws a FormatException:
        // - For invalid un-escaped chars, except Unicode
        // - If the postconditions cannot be met.
        private static string ParseDisplayName(string data, ref int index, bool expectMultipleAddresses)
        {
            string displayName;

            // Whatever is left over must be the display name. The display name should be a single word/atom or a
            // quoted string, but for robustness we allow the quotes to be omitted, so long as we can find the comma
            // separator before the next address.

            // Read the comment (if any).  If the display name is contained in quotes, the surrounding comments are
            // omitted. Otherwise, mark this end of the comment so we can include it as part of the display name.
            int firstNonCommentIndex = WhitespaceReader.ReadCfwsReverse(data, index);

            // Check to see if there's a quoted-string display name
            if (firstNonCommentIndex >= 0 && data[firstNonCommentIndex] == MailBnfHelper.Quote)
            {
                // The preceding comment was not part of the display name.  Read just the quoted string.
                index = QuotedStringFormatReader.ReadReverseQuoted(data, firstNonCommentIndex, true);

                Debug.Assert(data[index + 1] == MailBnfHelper.Quote, "Mis-aligned index: " + index);

                // Do not include the bounding quotes on the display name
                int leftIndex = index + 2;
                displayName = data.Substring(leftIndex, firstNonCommentIndex - leftIndex);

                // Skip any CFWS after the display name
                index = WhitespaceReader.ReadCfwsReverse(data, index);

                // Check for completion. We are valid if we hit the end of the data string or if the rest of the data
                // belongs to another address.
                if (index >= 0 && !(expectMultipleAddresses && data[index] == MailBnfHelper.Comma))
                {
                    // If there was still data, only a comma could have been the next valid character
                    throw new FormatException(string.Format(Strings.MailHeaderFieldInvalidCharacter, data[index]));
                }
            }
            else
            {
                // The comment (if any) should be part of the display name.
                int startingIndex = index;

                // Read until the dividing comma or the end of the line.
                index = QuotedStringFormatReader.ReadReverseUnQuoted(data, index, true, expectMultipleAddresses);

                Debug.Assert(index < 0 || data[index] == MailBnfHelper.Comma, "Mis-aligned index: " + index);

                // Do not include the Comma (if any), and because there were no bounding quotes,
                // trim extra whitespace.
                displayName = data.SubstringTrim(index + 1, startingIndex - index);
            }
            return(NormalizeOrThrow(displayName));
        }
示例#9
0
        // Parses the local-part section of an address.  The local-part may be in dot-atom format or
        // quoted-string format. e.g. <user.name@domain> or <"user name"@domain>
        // We do not support the obsolete formats of user."name"@domain, "user".name@domain, or "user"."name"@domain.
        //
        // Preconditions:
        // - data[index + 1] is the '@' symbol
        //
        // Postconditions:
        // - data[index] should refer to the '<', if any, otherwise the next non-CFWS char.
        // - index == -1 if the beginning of the data string has been reached.
        // - returns the parsed local-part, including any bounding quotes around quoted-strings
        //
        // Throws a FormatException:
        // - For invalid un-escaped chars, including Unicode
        // - If the final value of data[index] is not a valid character to precede the local-part
        private static string ParseLocalPart(string data, ref int index, bool expectAngleBracket,
                                             bool expectMultipleAddresses)
        {
            // Skip comments and whitespace
            index = ReadCfwsAndThrowIfIncomplete(data, index);

            // Mark the start of the local-part
            int startingIndex = index;

            // Is the local-part component in quoted-string format or dot-atom format?
            if (data[index] == MailBnfHelper.Quote)
            {
                index = QuotedStringFormatReader.ReadReverseQuoted(data, index, true);
            }
            else
            {
                index = DotAtomReader.ReadReverse(data, index);

                // Check that the local-part is properly separated from the next component. It may be separated by a
                // comment, whitespace, an expected angle bracket, a quote for the display-name, or an expected comma
                // before the next address.
                if (index >= 0 &&
                    !(
                        MailBnfHelper.IsAllowedWhiteSpace(data[index]) ||  // < local@domain >
                        data[index] == MailBnfHelper.EndComment ||     // <(comment)local@domain>
                        (expectAngleBracket && data[index] == MailBnfHelper.StartAngleBracket) ||     // <local@domain>
                        (expectMultipleAddresses && data[index] == MailBnfHelper.Comma) // local@dom,local@dom
                                                                                        // Note: The following condition is more lax than the RFC.  This is done so we could support
                                                                                        // a common invalid formats as shown below.
                        || data[index] == MailBnfHelper.Quote                           // "display"local@domain
                        )
                    )
                {
                    throw new FormatException(string.Format(Strings.MailHeaderFieldInvalidCharacter, data[index]));
                }
            }

            string localPart = data.Substring(index + 1, startingIndex - index);

            index = WhitespaceReader.ReadCfwsReverse(data, index);

            return(NormalizeOrThrow(localPart));
        }
        public void TryReadQuotedString_WithInvalidCharacters_ShouldThrow()
        {
            int index = InvalidQuotedString.Length - 1;

            Assert.Throws <FormatException>(() => { QuotedStringFormatReader.TryReadReverseQuoted(InvalidQuotedString, index, false, out int _, throwExceptionIfFail: true); });
        }
        public void TryReadQuotedString_WithUnicodeAndUnicodeIsInvalid_ShouldThrow()
        {
            int index = UnicodeQuotedString.Length - 1;

            Assert.Throws <FormatException>(() => { QuotedStringFormatReader.TryReadReverseUnQuoted(UnicodeQuotedString, index, false, false, out int _, throwExceptionIfFail: true); });
        }