public void TestEncodingMailboxWithArabicName()
{
var mailbox = new MailboxAddress ("هل تتكلم اللغة الإنجليزية /العربية؟", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var expected = "=?utf-8?b?2YfZhCDYqtiq2YPZhNmFINin2YTZhNi62Kk=?=\n =?utf-8?b?INin2YTYpdmG2KzZhNmK2LLZitipIC/Yp9mE2LnYsdio2YrYqdif?=\n\t<*****@*****.**>";
var actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding arabic mailbox did not match expected result: {0}", expected);
Assert.IsTrue (InternetAddressList.TryParse (actual, out list), "Failed to parse arabic mailbox");
Assert.AreEqual (mailbox.Name, list[0].Name);
}
public void TestSimpleAddrSpec ()
{
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
InternetAddressList result;
string text;
expected.Add (mailbox);
text = "*****@*****.**";
mailbox.Address = "*****@*****.**";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
text = "fejj";
mailbox.Address = "fejj";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
}
public void TestSimpleAddrSpecWithTrailingDot()
{
const string encoded = "*****@*****.**";
const string text = "[email protected].";
var expected = new InternetAddressList();
var mailbox = new MailboxAddress("", "*****@*****.**");
expected.Add(mailbox);
mailbox.Address = "*****@*****.**";
AssertParseAndTryParse(text, encoded, expected);
}
public void TestExampleMailboxWithCommentsFromRfc5322()
{
InternetAddressList expected = new InternetAddressList();
InternetAddressList result;
string text;
text = "Pete(A nice \\) chap) <pete(his account)@silly.test(his host)>";
expected.Add(new MailboxAddress("Pete", "*****@*****.**"));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestEncodingSimpleAddressList()
{
const string expectedEncoded = "Kristoffer =?iso-8859-1?q?Br=E5nemyr?= <*****@*****.**>, Jeffrey Stedfast\n\t<*****@*****.**>";
const string expectedDisplay = "\"Kristoffer Brånemyr\" <*****@*****.**>, \"Jeffrey Stedfast\" <*****@*****.**>";
var latin1 = Encoding.GetEncoding("iso-8859-1");
var options = FormatOptions.Default.Clone();
var list = new InternetAddressList();
list.Add(new MailboxAddress(latin1, "Kristoffer Brånemyr", "*****@*****.**"));
list.Add(new MailboxAddress("Jeffrey Stedfast", "*****@*****.**"));
options.NewLineFormat = NewLineFormat.Unix;
var display = list.ToString(options, false);
Assert.AreEqual(expectedDisplay, display, "Display value does not match the expected result: {0}", display);
var encoded = list.ToString(options, true);
Assert.AreEqual(expectedEncoded, encoded, "Encoded value does not match the expected result: {0}", display);
}
public void TestEncodingSimpleMailboxWithQuotedName()
{
var mailbox = new MailboxAddress("Stedfast, Jeffrey", "*****@*****.**");
var list = new InternetAddressList();
list.Add(mailbox);
var expected = "\"Stedfast, Jeffrey\" <*****@*****.**>";
var actual = list.ToString(UnixFormatOptions, true);
Assert.AreEqual(expected, actual, "Encoding quoted mailbox did not match expected result: {0}", expected);
}
public void TestObsoleteMailboxRoutingSyntaxWithEmptyDomains()
{
InternetAddressList expected = new InternetAddressList();
InternetAddressList result;
string text;
text = "Routed Address <@route1,,@route2,,,@route3:[email protected]>";
expected.Add(new MailboxAddress("Routed Address", new string[] { "route1", "route2", "route3" }, "*****@*****.**"));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestMailboxWith8bitName()
{
InternetAddressList expected = new InternetAddressList();
InternetAddressList result;
string text;
text = "Patrik F¥dltstr¥vm <*****@*****.**>";
expected.Add(new MailboxAddress("Patrik F¥dltstr¥vm", "*****@*****.**"));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestMailboxWithDotsInTheName()
{
InternetAddressList expected = new InternetAddressList();
InternetAddressList result;
string text;
text = "Nathaniel S. Borenstein <*****@*****.**>";
expected.Add(new MailboxAddress("Nathaniel S. Borenstein", "*****@*****.**"));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestArgumentExceptions ()
{
var mailbox = new MailboxAddress ("MimeKit Unit Tests", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (new MailboxAddress ("Example User", "*****@*****.**"));
Assert.Throws<ArgumentNullException> (() => new InternetAddressList (null));
Assert.Throws<ArgumentNullException> (() => list.Add (null));
Assert.Throws<ArgumentNullException> (() => list.AddRange (null));
Assert.Throws<ArgumentNullException> (() => list.CompareTo (null));
Assert.Throws<ArgumentNullException> (() => list.Contains (null));
Assert.Throws<ArgumentNullException> (() => list.CopyTo (null, 0));
Assert.Throws<ArgumentOutOfRangeException> (() => list.CopyTo (new InternetAddress[0], -1));
Assert.Throws<ArgumentNullException> (() => list.IndexOf (null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, mailbox));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, null));
Assert.Throws<ArgumentNullException> (() => list.Remove (null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.RemoveAt (-1));
Assert.Throws<ArgumentOutOfRangeException> (() => list[-1] = mailbox);
Assert.Throws<ArgumentNullException> (() => list[0] = null);
}
public void TestArgumentExceptions()
{
var mailbox = new MailboxAddress("MimeKit Unit Tests", "*****@*****.**");
var list = new InternetAddressList();
list.Add(new MailboxAddress("Example User", "*****@*****.**"));
Assert.Throws <ArgumentNullException> (() => new InternetAddressList(null));
Assert.Throws <ArgumentNullException> (() => list.Add(null));
Assert.Throws <ArgumentNullException> (() => list.AddRange(null));
Assert.Throws <ArgumentNullException> (() => list.CompareTo(null));
Assert.Throws <ArgumentNullException> (() => list.Contains(null));
Assert.Throws <ArgumentNullException> (() => list.CopyTo(null, 0));
Assert.Throws <ArgumentOutOfRangeException> (() => list.CopyTo(new InternetAddress[0], -1));
Assert.Throws <ArgumentNullException> (() => list.IndexOf(null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, mailbox));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, null));
Assert.Throws <ArgumentNullException> (() => list.Remove(null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.RemoveAt(-1));
Assert.Throws <ArgumentOutOfRangeException> (() => list[-1] = mailbox);
Assert.Throws <ArgumentNullException> (() => list[0] = null);
}
public void TestDecodedMailboxHasCorrectCharsetEncoding()
{
var latin1 = Encoding.GetEncoding ("iso-8859-1");
var mailbox = new MailboxAddress (latin1, "Kristoffer Brånemyr", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var encoded = list.ToString (UnixFormatOptions, true);
InternetAddressList parsed;
Assert.IsTrue (InternetAddressList.TryParse (encoded, out parsed), "Failed to parse address");
Assert.AreEqual (latin1.HeaderName, parsed[0].Encoding.HeaderName, "Parsed charset does not match");
}
/// <summary>
/// Splits the recipients.
/// </summary>
/// <param name="list">The list.</param>
/// <param name="mailboxes">The mailboxes.</param>
private static void SplitRecipients(InternetAddressList list, string mailboxes)
{
if (string.IsNullOrEmpty(mailboxes) || list is null)
{
return;
}
var SplitMailboxes = mailboxes?.Split(new string[] { ",", ";" }, StringSplitOptions.RemoveEmptyEntries) ?? Array.Empty <string>();
for (int i = 0; i < SplitMailboxes.Length; i++)
{
list.Add(new MailboxAddress("", SplitMailboxes[i]));
}
}
static void AddEnvelopeAddress(InternetAddressList list, ImapEngine engine, CancellationToken cancellationToken)
{
var values = new string[4];
ImapToken token;
int index = 0;
do
{
token = engine.ReadToken(cancellationToken);
switch (token.Type)
{
case ImapTokenType.Literal:
values[index] = engine.ReadLiteral(cancellationToken);
break;
case ImapTokenType.QString:
case ImapTokenType.Atom:
values[index] = (string)token.Value;
break;
case ImapTokenType.Nil:
break;
default:
throw ImapEngine.UnexpectedToken(token, false);
}
index++;
} while (index < 4);
token = engine.ReadToken(cancellationToken);
if (token.Type != ImapTokenType.CloseParen)
{
throw ImapEngine.UnexpectedToken(token, false);
}
string name = null;
if (values[0] != null)
{
// Note: since the ImapEngine.ReadLiteral() uses iso-8859-1
// to convert bytes to unicode, we can undo that here:
name = Rfc2047.DecodePhrase(Latin1.GetBytes(values[0]));
}
string address = values[3] != null ? values[2] + "@" + values[3] : values[2];
list.Add(new MailboxAddress(name, address));
}
public void TestSimpleMailboxes()
{
InternetAddressList expected = new InternetAddressList();
MailboxAddress mailbox = new MailboxAddress("", "");
InternetAddressList result;
string text;
expected.Add(mailbox);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <*****@*****.**>";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
mailbox.Name = "this is a folded name";
mailbox.Address = "*****@*****.**";
text = "this is\n\ta folded name <*****@*****.**>";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
mailbox.Name = "Jeffrey fejj Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey \"fejj\" Stedfast <*****@*****.**>";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
mailbox.Name = "Jeffrey \"fejj\" Stedfast";
mailbox.Address = "*****@*****.**";
text = "\"Jeffrey \\\"fejj\\\" Stedfast\" <*****@*****.**>";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
mailbox.Name = "Stedfast, Jeffrey";
mailbox.Address = "*****@*****.**";
text = "\"Stedfast, Jeffrey\" <*****@*****.**>";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
// mailbox.Name = "Jeffrey Stedfast";
// mailbox.Address = "*****@*****.**";
// text = "[email protected] (Jeffrey Stedfast)";
// Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
// AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <fejj(recursive (comment) block)@helixcode.(and a comment here)com>";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestCompareTo()
{
var list1 = new InternetAddressList();
list1.Add(new GroupAddress("Local recipients", new InternetAddress[] {
new MailboxAddress("", "phil"),
new MailboxAddress("", "joe"),
new MailboxAddress("", "alex"),
new MailboxAddress("", "bob"),
}));
list1.Add(new MailboxAddress("Joey", "*****@*****.**"));
list1.Add(new MailboxAddress("Chandler", "*****@*****.**"));
var list2 = new InternetAddressList();
list2.Add(new MailboxAddress("Chandler", "*****@*****.**"));
list2.Add(new GroupAddress("Local recipients", new InternetAddress[] {
new MailboxAddress("", "phil"),
new MailboxAddress("", "joe"),
new MailboxAddress("", "alex"),
new MailboxAddress("", "bob"),
}));
list2.Add(new MailboxAddress("Joey", "*****@*****.**"));
Assert.IsTrue(list1.CompareTo(list2) > 0, "CompareTo() should return < 0.");
Assert.IsTrue(list2.CompareTo(list1) < 0, "CompareTo() should return > 0.");
var mailbox = new MailboxAddress("Joe", "*****@*****.**");
var group = new GroupAddress("Joe", new InternetAddress[] {
new MailboxAddress("Joe", "*****@*****.**")
});
// MailboxAddresses with the same name should always sort first
Assert.IsTrue(mailbox.CompareTo(group) < 0, "CompareTo() should return < 0.");
Assert.IsTrue(group.CompareTo(mailbox) > 0, "CompareTo() should return > 0.");
Assert.IsTrue(mailbox.CompareTo(group.Members[0]) == 0, "CompareTo() should return 0.");
}
/// <summary>
/// 转换成Internet地址列表
/// </summary>
/// <param name="addresses">邮箱地址集合</param>
private static InternetAddressList ToInternetAddressList(this MailAddressCollection addresses)
{
if (addresses == null)
{
return(null);
}
var list = new InternetAddressList();
foreach (var address in addresses)
{
list.Add(address.ToMailboxAddress());
}
return(list);
}
public void TestEncodingMailboxWithArabicName()
{
const string expected = "=?utf-8?b?2YfZhCDYqtiq2YPZhNmFINin2YTZhNi62Kkg2KfZhNil2YbYrNmE2YrYstmK2Kk=?=\n =?utf-8?b?IC/Yp9mE2LnYsdio2YrYqdif?= <*****@*****.**>";
var mailbox = new MailboxAddress("هل تتكلم اللغة الإنجليزية /العربية؟", "*****@*****.**");
var list = new InternetAddressList();
list.Add(mailbox);
var actual = list.ToString(UnixFormatOptions, true);
Assert.AreEqual(expected, actual, "Encoding arabic mailbox did not match expected result: {0}", expected);
Assert.IsTrue(InternetAddressList.TryParse(actual, out list), "Failed to parse arabic mailbox");
Assert.AreEqual(mailbox.Name, list[0].Name);
}
static void ExtractRecipientTable(TnefReader reader, MimeMessage message)
{
var prop = reader.TnefPropertyReader;
// Note: The RecipientTable uses rows of properties...
while (prop.ReadNextRow ()) {
string transmitableDisplayName = null;
string recipientDisplayName = null;
string displayName = string.Empty;
InternetAddressList list = null;
string addr = null;
while (prop.ReadNextProperty ()) {
switch (prop.PropertyTag.Id) {
case TnefPropertyId.RecipientType:
int recipientType = prop.ReadValueAsInt32 ();
switch (recipientType) {
case 1: list = message.To; break;
case 2: list = message.Cc; break;
case 3: list = message.Bcc; break;
}
break;
case TnefPropertyId.TransmitableDisplayName:
transmitableDisplayName = prop.ReadValueAsString ();
break;
case TnefPropertyId.RecipientDisplayName:
recipientDisplayName = prop.ReadValueAsString ();
break;
case TnefPropertyId.DisplayName:
displayName = prop.ReadValueAsString ();
break;
case TnefPropertyId.EmailAddress:
if (string.IsNullOrEmpty (addr))
addr = prop.ReadValueAsString ();
break;
case TnefPropertyId.SmtpAddress:
// The SmtpAddress, if it exists, should take precedence over the EmailAddress
// (since the SmtpAddress is meant to be used in the RCPT TO command).
addr = prop.ReadValueAsString ();
break;
}
}
if (list != null && !string.IsNullOrEmpty (addr)) {
var name = recipientDisplayName ?? transmitableDisplayName ?? displayName;
list.Add (new MailboxAddress (name, addr));
}
}
}
public void TestExampleGroupWithCommentsFromRfc5322()
{
const string text = "A Group(Some people):Chris Jones <c@(Chris's host.)public.example>, [email protected], John <*****@*****.**> (my dear friend); (the end of the group)";
const string encoded = "A Group: Chris Jones <*****@*****.**>, [email protected], John <*****@*****.**>;";
var expected = new InternetAddressList();
expected.Add(new GroupAddress("A Group", new InternetAddress[] {
new MailboxAddress("Chris Jones", "*****@*****.**"),
new MailboxAddress("", "*****@*****.**"),
new MailboxAddress("John", "*****@*****.**")
}));
AssertParseAndTryParse(text, encoded, expected);
}
public void TestEncodingMailboxWithJapaneseName()
{
const string expected = "=?utf-8?b?54uC44Gj44Gf44GT44Gu5LiW44Gn54uC44GG44Gq44KJ5rCX44Gv56K644GL44Gg?=\n =?utf-8?b?44CC?= <*****@*****.**>";
var mailbox = new MailboxAddress("狂ったこの世で狂うなら気は確かだ。", "*****@*****.**");
var list = new InternetAddressList();
list.Add(mailbox);
var actual = list.ToString(UnixFormatOptions, true);
Assert.AreEqual(expected, actual, "Encoding japanese mailbox did not match expected result: {0}", expected);
Assert.IsTrue(InternetAddressList.TryParse(actual, out list), "Failed to parse japanese mailbox");
Assert.AreEqual(mailbox.Name, list[0].Name);
}
public void TestEncodingMailboxWithReallyLongWord()
{
const string expected = "=?us-ascii?q?reeeeeeeeeeeeeeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaallllllllllll?=\n =?us-ascii?q?llllllllllllllllllllllllllllllllllllllllllly?= long word\n\t<*****@*****.**>";
const string name = "reeeeeeeeeeeeeeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaallllllllllllllllllllllllllllllllllllllllllllllllllllllly long word";
var mailbox = new MailboxAddress(name, "*****@*****.**");
var list = new InternetAddressList();
list.Add(mailbox);
var actual = list.ToString(UnixFormatOptions, true);
Assert.AreEqual(expected, actual, "Encoding really long mailbox did not match expected result: {0}", expected);
Assert.IsTrue(InternetAddressList.TryParse(actual, out list), "Failed to parse really long mailbox");
Assert.AreEqual(mailbox.Name, list[0].Name);
}
public void TestMailboxWith8bitName()
{
const string encoded = "Patrik =?iso-8859-1?b?RqVkbHRzdHKldm0=?= <*****@*****.**>";
const string text = "Patrik F¥dltstr¥vm <*****@*****.**>";
var expected = new InternetAddressList();
InternetAddressList result;
expected.Add(new MailboxAddress("Patrik F¥dltstr¥vm", "*****@*****.**"));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(encoded, expected, result);
result = InternetAddressList.Parse(text);
AssertInternetAddressListsEqual(encoded, expected, result);
}
public void TestDecodedMailboxHasCorrectCharsetEncoding()
{
var latin1 = Encoding.GetEncoding("iso-8859-1");
var mailbox = new MailboxAddress(latin1, "Kristoffer Brånemyr", "*****@*****.**");
var list = new InternetAddressList();
list.Add(mailbox);
var encoded = list.ToString(UnixFormatOptions, true);
InternetAddressList parsed;
Assert.IsTrue(InternetAddressList.TryParse(encoded, out parsed), "Failed to parse address");
Assert.AreEqual(latin1.HeaderName, parsed[0].Encoding.HeaderName, "Parsed charset does not match");
}
public void TestSimpleMailboxes()
{
var expected = new InternetAddressList();
var mailbox = new MailboxAddress("", "*****@*****.**");
string text;
expected.Add(mailbox);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <*****@*****.**>";
AssertParseAndTryParse(text, text, expected);
mailbox.Name = "this is a folded name";
mailbox.Address = "*****@*****.**";
text = "this is\n\ta folded name <*****@*****.**>";
AssertParseAndTryParse(text, "this is a folded name <*****@*****.**>", expected);
mailbox.Name = "Jeffrey fejj Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey \"fejj\" Stedfast <*****@*****.**>";
AssertParseAndTryParse(text, "Jeffrey fejj Stedfast <*****@*****.**>", expected);
mailbox.Name = "Jeffrey \"fejj\" Stedfast";
mailbox.Address = "*****@*****.**";
text = "\"Jeffrey \\\"fejj\\\" Stedfast\" <*****@*****.**>";
AssertParseAndTryParse(text, text, expected);
mailbox.Name = "Stedfast, Jeffrey";
mailbox.Address = "*****@*****.**";
text = "\"Stedfast, Jeffrey\" <*****@*****.**>";
AssertParseAndTryParse(text, text, expected);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "[email protected] (Jeffrey Stedfast)";
AssertParseAndTryParse(text, "Jeffrey Stedfast <*****@*****.**>", expected);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <fejj(recursive (comment) block)@helixcode.(and a comment here)com>";
AssertParseAndTryParse(text, "Jeffrey Stedfast <*****@*****.**>", expected);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <[email protected].>";
AssertParseAndTryParse(text, "Jeffrey Stedfast <*****@*****.**>", expected);
}
private static void AddMailAddressCollection(InternetAddressList collection, IEnumerable <string> emails)
{
foreach (var email in emails)
{
var splitedEmails = email.Split(';');
foreach (var m in splitedEmails)
{
Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
Match match = regex.Match(m);
if (match.Success)
{
collection.Add(new MailboxAddress(m, m));
}
}
}
}
public void TestObsoleteMailboxRoutingSyntax()
{
var expected = new InternetAddressList();
InternetAddressList result;
string text;
text = "Routed Address <@route:[email protected]>";
expected.Add(new MailboxAddress("Routed Address", new [] { "route" }, "*****@*****.**"));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
result = InternetAddressList.Parse(text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestSimpleAddrSpec()
{
var expected = new InternetAddressList();
var mailbox = new MailboxAddress("", "*****@*****.**");
string text;
expected.Add(mailbox);
text = "*****@*****.**";
mailbox.Address = "*****@*****.**";
AssertParseAndTryParse(text, text, expected);
text = "fejj";
mailbox.Address = "fejj";
AssertParseAndTryParse(text, text, expected);
}
public void TestExampleGroupWithCommentsFromRfc5322()
{
InternetAddressList expected = new InternetAddressList();
InternetAddressList result;
string text;
text = "A Group(Some people):Chris Jones <c@(Chris's host.)public.example>, [email protected], John <*****@*****.**> (my dear friend); (the end of the group)";
expected.Add(new GroupAddress("A Group", new InternetAddress[] {
new MailboxAddress("Chris Jones", "*****@*****.**"),
new MailboxAddress("", "*****@*****.**"),
new MailboxAddress("John", "*****@*****.**")
}));
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(text, expected, result);
}
public void TestSimpleAddrSpecWithTrailingDot()
{
const string encoded = "*****@*****.**";
const string text = "[email protected].";
var expected = new InternetAddressList();
var mailbox = new MailboxAddress("", "");
InternetAddressList result;
expected.Add(mailbox);
mailbox.Address = "*****@*****.**";
Assert.IsTrue(InternetAddressList.TryParse(text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual(encoded, expected, result);
result = InternetAddressList.Parse(text);
AssertInternetAddressListsEqual(encoded, expected, result);
}
public void TestLocalGroupWithoutSemicolon()
{
const string text = "Local recipients: phil, joe, alex, bob";
const string encoded = "Local recipients: phil, joe, alex, bob;";
var expected = new InternetAddressList();
expected.Add(new GroupAddress("Local recipients", new InternetAddress[] {
new MailboxAddress("", "phil"),
new MailboxAddress("", "joe"),
new MailboxAddress("", "alex"),
new MailboxAddress("", "bob"),
}));
AssertTryParse(text, encoded, expected);
//Assert.Throws<ParseException> (() => InternetAddressList.Parse (text), "Parsing should have failed.");
}
public void SendMail(List <string> to, string subject, string body, IOptions <MailSettings> mailSettings, List <string> ccMailAddress = null)
{
FromName = FromName ?? "Slack Admin";
FromEmail = FromEmail ?? "*****@*****.**";
try
{
SetupMailSettings(mailSettings);
var message = new MimeMessage();
message.From.Add(new MailboxAddress(FromName, FromEmail));
InternetAddressList sentToList = new InternetAddressList();
foreach (string email in to)
{
sentToList.Add(new MailboxAddress(email));
}
InternetAddressList ccToList = new InternetAddressList();
if (ccMailAddress != null)
{
foreach (string cc in ccMailAddress)
{
ccToList.Add(new MailboxAddress(cc));
}
}
message.Cc.AddRange(ccToList);
message.To.AddRange(sentToList);
message.Subject = subject;
message.Body = new MimeKit.TextPart("html")
{
Text = body
};
using (var client = new SmtpClient())
{
client.ServerCertificateValidationCallback = (s, c, h, e) => true;
client.Connect(Host, Port, true);
client.Authenticate(AuthEmail, AuthPassword);
client.Send(message);
client.Disconnect(true);
}
}
catch (Exception ex)
{
throw;
}
}
public void TestMailboxesWithRfc2047EncodedNames()
{
var expected = new InternetAddressList();
var mailbox = new MailboxAddress("", "*****@*****.**");
string text;
expected.Add(mailbox);
mailbox.Name = "Kristoffer Brånemyr";
mailbox.Address = "*****@*****.**";
text = "=?iso-8859-1?q?Kristoffer_Br=E5nemyr?= <*****@*****.**>";
AssertParseAndTryParse(text, "Kristoffer =?iso-8859-1?q?Br=E5nemyr?= <*****@*****.**>", expected);
mailbox.Name = "François Pons";
mailbox.Address = "*****@*****.**";
text = "=?iso-8859-1?q?Fran=E7ois?= Pons <*****@*****.**>";
AssertParseAndTryParse(text, text, expected);
}
public static void AddAdresses(this InternetAddressList internetAddressList, string addresses)
{
if (string.IsNullOrEmpty(addresses))
{
return;
}
var emailChecker = new EmailAddressAttribute();
foreach (string adress in addresses.Split(';'))
{
if (!emailChecker.IsValid(adress))
{
continue;
}
internetAddressList.Add(new MailboxAddress("", adress));
}
}
public void TestUnsupportedCharsetExceptionNotThrown ()
{
var mailbox = new MailboxAddress (Encoding.UTF8, "狂ったこの世で狂うなら気は確かだ。", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var encoded = list.ToString (true);
encoded = encoded.Replace ("utf-8", "x-unknown");
InternetAddressList parsed;
try {
Assert.IsTrue (InternetAddressList.TryParse (encoded, out parsed), "Failed to parse address");
} catch (Exception ex) {
Assert.Fail ("Exception thrown parsing address with unsupported charset: {0}", ex);
}
}
public void TestEncodingSimpleAddressList ()
{
const string expectedEncoded = "Kristoffer =?iso-8859-1?q?Br=E5nemyr?= <*****@*****.**>, Jeffrey Stedfast\n\t<*****@*****.**>";
const string expectedDisplay = "\"Kristoffer Brånemyr\" <*****@*****.**>, \"Jeffrey Stedfast\" <*****@*****.**>";
var latin1 = Encoding.GetEncoding ("iso-8859-1");
var options = FormatOptions.Default.Clone ();
var list = new InternetAddressList ();
list.Add (new MailboxAddress (latin1, "Kristoffer Brånemyr", "*****@*****.**"));
list.Add (new MailboxAddress ("Jeffrey Stedfast", "*****@*****.**"));
options.NewLineFormat = NewLineFormat.Unix;
var display = list.ToString (options, false);
Assert.AreEqual (expectedDisplay, display, "Display value does not match the expected result: {0}", display);
var encoded = list.ToString (options, true);
Assert.AreEqual (expectedEncoded, encoded, "Encoded value does not match the expected result: {0}", display);
}
public void TestEncodingMailboxWithJapaneseName ()
{
const string expected = "=?utf-8?b?54uC44Gj44Gf44GT44Gu5LiW44Gn54uC44GG44Gq44KJ5rCX44Gv56K644GL44Gg?=\n =?utf-8?b?44CC?= <*****@*****.**>";
var mailbox = new MailboxAddress ("狂ったこの世で狂うなら気は確かだ。", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding japanese mailbox did not match expected result: {0}", expected);
Assert.IsTrue (InternetAddressList.TryParse (actual, out list), "Failed to parse japanese mailbox");
Assert.AreEqual (mailbox.Name, list[0].Name);
}
public void TestEncodingMailboxWithReallyLongWord ()
{
const string expected = "=?us-ascii?q?reeeeeeeeeeeeeeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaallllllllllll?=\n =?us-ascii?q?llllllllllllllllllllllllllllllllllllllllllly?= long word\n\t<*****@*****.**>";
const string name = "reeeeeeeeeeeeeeaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaallllllllllllllllllllllllllllllllllllllllllllllllllllllly long word";
var mailbox = new MailboxAddress (name, "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding really long mailbox did not match expected result: {0}", expected);
Assert.IsTrue (InternetAddressList.TryParse (actual, out list), "Failed to parse really long mailbox");
Assert.AreEqual (mailbox.Name, list[0].Name);
}
public void TestEncodingSimpleMailboxWithLatin1Name ()
{
var latin1 = Encoding.GetEncoding ("iso-8859-1");
var mailbox = new MailboxAddress (latin1, "Kristoffer Brånemyr", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var expected = "Kristoffer =?iso-8859-1?q?Br=E5nemyr?= <*****@*****.**>";
var actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding latin1 mailbox did not match expected result: {0}", expected);
mailbox = new MailboxAddress (latin1, "Tõivo Leedjärv", "*****@*****.**");
list = new InternetAddressList ();
list.Add (mailbox);
expected = "=?iso-8859-1?b?VIH1aXZvIExlZWRqgeRydg==?= <*****@*****.**>";
actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding latin1 mailbox did not match expected result: {0}", expected);
}
public void TestMailboxesWithRfc2047EncodedNames ()
{
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
string text;
expected.Add (mailbox);
mailbox.Name = "Kristoffer Brånemyr";
mailbox.Address = "*****@*****.**";
text = "=?iso-8859-1?q?Kristoffer_Br=E5nemyr?= <*****@*****.**>";
AssertParseAndTryParse (text, "Kristoffer =?iso-8859-1?q?Br=E5nemyr?= <*****@*****.**>", expected);
mailbox.Name = "François Pons";
mailbox.Address = "*****@*****.**";
text = "=?iso-8859-1?q?Fran=E7ois?= Pons <*****@*****.**>";
AssertParseAndTryParse (text, text, expected);
}
public void TestListWithGroupAndAddrspec ()
{
const string text = "GNOME Hackers: Miguel de Icaza <*****@*****.**>, Havoc Pennington <*****@*****.**>;, [email protected]";
const string encoded = "GNOME Hackers: Miguel de Icaza <*****@*****.**>, Havoc Pennington\n\t<*****@*****.**>;, [email protected]";
var expected = new InternetAddressList ();
expected.Add (new GroupAddress ("GNOME Hackers", new InternetAddress[] {
new MailboxAddress ("Miguel de Icaza", "*****@*****.**"),
new MailboxAddress ("Havoc Pennington", "*****@*****.**")
}));
expected.Add (new MailboxAddress ("", "*****@*****.**"));
AssertParseAndTryParse (text, encoded, expected);
}
public void TestExampleAddrSpecWithQuotedLocalPartAndCommentsFromRfc822 ()
{
const string text = "\":sysmail\"@ Some-Group. Some-Org,\n Muhammed.(I am the greatest) Ali @(the)Vegas.WBA";
const string encoded = "\":sysmail\"@Some-Group.Some-Org, [email protected]";
var expected = new InternetAddressList ();
expected.Add (new MailboxAddress ("", "\":sysmail\"@Some-Group.Some-Org"));
expected.Add (new MailboxAddress ("", "*****@*****.**"));
AssertParseAndTryParse (text, encoded, expected);
}
public void TestEquality ()
{
var list1 = new InternetAddressList ();
list1.Add (new GroupAddress ("Local recipients", new InternetAddress[] {
new MailboxAddress ("", "phil"),
new MailboxAddress ("", "joe"),
new MailboxAddress ("", "alex"),
new MailboxAddress ("", "bob"),
}));
list1.Add (new MailboxAddress ("Joey", "*****@*****.**"));
list1.Add (new MailboxAddress ("Chandler", "*****@*****.**"));
var list2 = new InternetAddressList ();
list2.Add (new MailboxAddress ("Chandler", "*****@*****.**"));
list2.Add (new GroupAddress ("Local recipients", new InternetAddress[] {
new MailboxAddress ("", "phil"),
new MailboxAddress ("", "joe"),
new MailboxAddress ("", "alex"),
new MailboxAddress ("", "bob"),
}));
list2.Add (new MailboxAddress ("Joey", "*****@*****.**"));
Assert.IsTrue (list1.Equals (list2), "The 2 lists should be equal.");
}
public void TestMailboxWithDotsInTheName ()
{
const string encoded = "\"Nathaniel S. Borenstein\" <*****@*****.**>";
const string text = "Nathaniel S. Borenstein <*****@*****.**>";
var expected = new InternetAddressList ();
expected.Add (new MailboxAddress ("Nathaniel S. Borenstein", "*****@*****.**"));
AssertParseAndTryParse (text, encoded, expected);
}
public void TestExampleGroupWithCommentsFromRfc5322 ()
{
const string text = "A Group(Some people):Chris Jones <c@(Chris's host.)public.example>, [email protected], John <*****@*****.**> (my dear friend); (the end of the group)";
const string encoded = "A Group: Chris Jones <*****@*****.**>, [email protected], John <*****@*****.**>;";
var expected = new InternetAddressList ();
expected.Add (new GroupAddress ("A Group", new InternetAddress[] {
new MailboxAddress ("Chris Jones", "*****@*****.**"),
new MailboxAddress ("", "*****@*****.**"),
new MailboxAddress ("John", "*****@*****.**")
}));
AssertParseAndTryParse (text, encoded, expected);
}
public void TestLocalGroupWithoutSemicolon ()
{
const string text = "Local recipients: phil, joe, alex, bob";
const string encoded = "Local recipients: phil, joe, alex, bob;";
var expected = new InternetAddressList ();
expected.Add (new GroupAddress ("Local recipients", new InternetAddress[] {
new MailboxAddress ("", "phil"),
new MailboxAddress ("", "joe"),
new MailboxAddress ("", "alex"),
new MailboxAddress ("", "bob"),
}));
AssertTryParse (text, encoded, expected);
//Assert.Throws<ParseException> (() => InternetAddressList.Parse (text), "Parsing should have failed.");
}
public void TestCompareTo ()
{
var list1 = new InternetAddressList ();
list1.Add (new GroupAddress ("Local recipients", new InternetAddress[] {
new MailboxAddress ("", "phil"),
new MailboxAddress ("", "joe"),
new MailboxAddress ("", "alex"),
new MailboxAddress ("", "bob"),
}));
list1.Add (new MailboxAddress ("Joey", "*****@*****.**"));
list1.Add (new MailboxAddress ("Chandler", "*****@*****.**"));
var list2 = new InternetAddressList ();
list2.Add (new MailboxAddress ("Chandler", "*****@*****.**"));
list2.Add (new GroupAddress ("Local recipients", new InternetAddress[] {
new MailboxAddress ("", "phil"),
new MailboxAddress ("", "joe"),
new MailboxAddress ("", "alex"),
new MailboxAddress ("", "bob"),
}));
list2.Add (new MailboxAddress ("Joey", "*****@*****.**"));
Assert.IsTrue (list1.CompareTo (list2) > 0, "CompareTo() should return < 0.");
Assert.IsTrue (list2.CompareTo (list1) < 0, "CompareTo() should return > 0.");
}
static void ParseEnvelopeAddressList (InternetAddressList list, ImapEngine engine, CancellationToken cancellationToken)
{
var token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.Nil)
return;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
GroupAddress group = null;
do {
token = engine.ReadToken (cancellationToken);
if (token.Type == ImapTokenType.CloseParen)
break;
if (token.Type != ImapTokenType.OpenParen)
throw ImapEngine.UnexpectedToken (token, false);
var item = ParseEnvelopeAddress (engine, cancellationToken);
if (item.IsGroupStart && !engine.IsGMail && group == null) {
group = item.ToGroupAddress ();
list.Add (group);
} else if (item.IsGroupEnd) {
group = null;
} else if (group != null) {
group.Members.Add (item.ToMailboxAddress ());
} else {
list.Add (item.ToMailboxAddress ());
}
} while (true);
}
public void TestSimpleAddrSpecWithTrailingDot ()
{
const string encoded = "*****@*****.**";
const string text = "[email protected].";
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
expected.Add (mailbox);
mailbox.Address = "*****@*****.**";
AssertParseAndTryParse (text, encoded, expected);
}
public void TestExampleMailboxWithCommentsFromRfc5322 ()
{
const string text = "Pete(A nice \\) chap) <pete(his account)@silly.test(his host)>";
const string encoded = "Pete <*****@*****.**>";
var expected = new InternetAddressList ();
expected.Add (new MailboxAddress ("Pete", "*****@*****.**"));
AssertParseAndTryParse (text, encoded, expected);
}
/// <summary>
/// Expand a mailing address alias.
/// </summary>
/// <remarks>
/// Expands a mailing address alias.
/// </remarks>
/// <returns>The expanded list of mailbox addresses.</returns>
/// <param name="alias">The mailing address alias.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <exception cref="System.ArgumentNullException">
/// <paramref name="alias"/> is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentException">
/// <paramref name="alias"/> is an empty string.
/// </exception>
/// <exception cref="System.ObjectDisposedException">
/// The <see cref="SmtpClient"/> has been disposed.
/// </exception>
/// <exception cref="ServiceNotConnectedException">
/// The <see cref="SmtpClient"/> is not connected.
/// </exception>
/// <exception cref="ServiceNotAuthenticatedException">
/// Authentication is required before verifying the existence of an address.
/// </exception>
/// <exception cref="System.OperationCanceledException">
/// The operation has been canceled.
/// </exception>
/// <exception cref="System.IO.IOException">
/// An I/O error occurred.
/// </exception>
/// <exception cref="SmtpCommandException">
/// The SMTP command failed.
/// </exception>
/// <exception cref="SmtpProtocolException">
/// An SMTP protocol exception occurred.
/// </exception>
public InternetAddressList Expand (string alias, CancellationToken cancellationToken = default (CancellationToken))
{
if (alias == null)
throw new ArgumentNullException (nameof (alias));
if (alias.Length == 0)
throw new ArgumentException ("The alias cannot be empty.", nameof (alias));
if (alias.IndexOfAny (new [] { '\r', '\n' }) != -1)
throw new ArgumentException ("The alias cannot contain newline characters.", nameof (alias));
CheckDisposed ();
if (!IsConnected)
throw new ServiceNotConnectedException ("The SmtpClient is not connected.");
var response = SendCommand (string.Format ("EXPN {0}", alias), cancellationToken);
if (response.StatusCode != SmtpStatusCode.Ok)
throw new SmtpCommandException (SmtpErrorCode.UnexpectedStatusCode, response.StatusCode, response.Response);
var lines = response.Response.Split ('\n');
var list = new InternetAddressList ();
for (int i = 0; i < lines.Length; i++) {
InternetAddress address;
if (InternetAddress.TryParse (lines[i], out address))
list.Add (address);
}
return list;
}
public void TestSimpleAddrSpec ()
{
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
string text;
expected.Add (mailbox);
text = "*****@*****.**";
mailbox.Address = "*****@*****.**";
AssertParseAndTryParse (text, text, expected);
text = "fejj";
mailbox.Address = "fejj";
AssertParseAndTryParse (text, text, expected);
}
public void TestMailboxWithDotsInTheName()
{
var expected = new InternetAddressList ();
InternetAddressList result;
string text;
text = "Nathaniel S. Borenstein <*****@*****.**>";
expected.Add (new MailboxAddress ("Nathaniel S. Borenstein", "*****@*****.**"));
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
}
public void TestObsoleteMailboxRoutingSyntaxWithEmptyDomains()
{
var expected = new InternetAddressList ();
InternetAddressList result;
string text;
text = "Routed Address <@route1,,@route2,,,@route3:[email protected]>";
expected.Add (new MailboxAddress ("Routed Address", new [] { "route1", "route2", "route3" }, "*****@*****.**"));
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
}
public void TestMailboxWith8bitName ()
{
const string encoded = "Patrik =?iso-8859-1?b?RqVkbHRzdHKldm0=?= <*****@*****.**>";
const string text = "Patrik F¥dltstr¥vm <*****@*****.**>";
var expected = new InternetAddressList ();
expected.Add (new MailboxAddress ("Patrik F¥dltstr¥vm", "*****@*****.**"));
AssertParseAndTryParse (text, encoded, expected);
}
public void TestEncodingSimpleMailboxWithQuotedName ()
{
const string expected = "\"Stedfast, Jeffrey\" <*****@*****.**>";
var mailbox = new MailboxAddress ("Stedfast, Jeffrey", "*****@*****.**");
var list = new InternetAddressList ();
list.Add (mailbox);
var actual = list.ToString (UnixFormatOptions, true);
Assert.AreEqual (expected, actual, "Encoding quoted mailbox did not match expected result: {0}", expected);
}
public void TestObsoleteMailboxRoutingSyntax ()
{
const string text = "Routed Address <@route:[email protected]>";
var expected = new InternetAddressList ();
expected.Add (new MailboxAddress ("Routed Address", new [] { "route" }, "*****@*****.**"));
AssertParseAndTryParse (text, text, expected);
}
public void TestObsoleteMailboxRoutingSyntaxWithEmptyDomains ()
{
const string text = "Routed Address <@route1,,@route2,,,@route3:[email protected]>";
const string encoded = "Routed Address <@route1,@route2,@route3:[email protected]>";
var expected = new InternetAddressList ();
expected.Add (new MailboxAddress ("Routed Address", new [] { "route1", "route2", "route3" }, "*****@*****.**"));
AssertParseAndTryParse (text, encoded, expected);
}
public void TestSimpleMailboxes ()
{
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
string text;
expected.Add (mailbox);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <*****@*****.**>";
AssertParseAndTryParse (text, text, expected);
mailbox.Name = "this is a folded name";
mailbox.Address = "*****@*****.**";
text = "this is\n\ta folded name <*****@*****.**>";
AssertParseAndTryParse (text, "this is a folded name <*****@*****.**>", expected);
mailbox.Name = "Jeffrey fejj Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey \"fejj\" Stedfast <*****@*****.**>";
AssertParseAndTryParse (text, "Jeffrey fejj Stedfast <*****@*****.**>", expected);
mailbox.Name = "Jeffrey \"fejj\" Stedfast";
mailbox.Address = "*****@*****.**";
text = "\"Jeffrey \\\"fejj\\\" Stedfast\" <*****@*****.**>";
AssertParseAndTryParse (text, text, expected);
mailbox.Name = "Stedfast, Jeffrey";
mailbox.Address = "*****@*****.**";
text = "\"Stedfast, Jeffrey\" <*****@*****.**>";
AssertParseAndTryParse (text, text, expected);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "[email protected] (Jeffrey Stedfast)";
AssertParseAndTryParse (text, "Jeffrey Stedfast <*****@*****.**>", expected);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <fejj(recursive (comment) block)@helixcode.(and a comment here)com>";
AssertParseAndTryParse (text, "Jeffrey Stedfast <*****@*****.**>", expected);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <[email protected].>";
AssertParseAndTryParse (text, "Jeffrey Stedfast <*****@*****.**>", expected);
}
public void TestSimpleMailboxes()
{
var expected = new InternetAddressList ();
var mailbox = new MailboxAddress ("", "");
InternetAddressList result;
string text;
expected.Add (mailbox);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <*****@*****.**>";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "this is a folded name";
mailbox.Address = "*****@*****.**";
text = "this is\n\ta folded name <*****@*****.**>";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "Jeffrey fejj Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey \"fejj\" Stedfast <*****@*****.**>";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "Jeffrey \"fejj\" Stedfast";
mailbox.Address = "*****@*****.**";
text = "\"Jeffrey \\\"fejj\\\" Stedfast\" <*****@*****.**>";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "Stedfast, Jeffrey";
mailbox.Address = "*****@*****.**";
text = "\"Stedfast, Jeffrey\" <*****@*****.**>";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "[email protected] (Jeffrey Stedfast)";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
mailbox.Name = "Jeffrey Stedfast";
mailbox.Address = "*****@*****.**";
text = "Jeffrey Stedfast <fejj(recursive (comment) block)@helixcode.(and a comment here)com>";
Assert.IsTrue (InternetAddressList.TryParse (text, out result), "Failed to parse: {0}", text);
AssertInternetAddressListsEqual (text, expected, result);
result = InternetAddressList.Parse (text);
AssertInternetAddressListsEqual (text, expected, result);
}
