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);
}
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);
}
// 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));
}
// 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); });
}