public override void Close()
{
int num = 3;
for (int i = 0; i < num; i++)
{
bool flag = i == num - 1;
try
{
HeaderList headerList = new HeaderList();
headerList.Add("content-type", this.contentType);
headerList.Add("x-amz-acl", "public-read");
this.s3OutputMethod.s3adaptor.put(this.s3OutputMethod.bucketName, this.s3key, new S3Content(this.ToArray()), headerList);
break;
}
catch (WebException)
{
if (flag)
{
throw;
}
}
catch (SoapException)
{
if (flag)
{
throw;
}
}
}
base.Close();
}
public void TestReplacingHeaders()
{
const string ReplacedContentType = "text/plain; charset=iso-8859-1; name=body.txt";
const string ReplacedContentDisposition = "inline; filename=body.txt";
const string ReplacedContentId = "<content.id.2@localhost>";
var headers = new HeaderList();
headers.Add("Content-Type", "text/plain");
headers.Add("Content-Disposition", "attachment");
headers.Add("Content-Id", "<content-id.1@localhost>");
headers.Replace("Content-Disposition", ReplacedContentDisposition);
Assert.AreEqual(3, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
Assert.AreEqual(ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
Assert.AreEqual(1, headers.IndexOf("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");
headers.Replace("Content-Type", ReplacedContentType);
Assert.AreEqual(3, headers.Count, "Unexpected number of headers after replacing Content-Type.");
Assert.AreEqual(ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
Assert.AreEqual(0, headers.IndexOf("Content-Type"), "Replaced Content-Type not in the expected position.");
headers.Replace("Content-Id", ReplacedContentId);
Assert.AreEqual(3, headers.Count, "Unexpected number of headers after replacing Content-Id.");
Assert.AreEqual(ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
Assert.AreEqual(2, headers.IndexOf("Content-Id"), "Replaced Content-Id not in the expected position.");
}
public void TestReplacingHeaders()
{
const string ReplacedContentType = "text/plain; charset=iso-8859-1; name=body.txt";
const string ReplacedContentDisposition = "inline; filename=body.txt";
const string ReplacedContentId = "<content.id.2@localhost>";
var headers = new HeaderList ();
headers.Add ("Content-Type", "text/plain");
headers.Add ("Content-Disposition", "attachment");
headers.Add ("Content-Id", "<content-id.1@localhost>");
headers.Replace ("Content-Disposition", ReplacedContentDisposition);
Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
Assert.AreEqual (ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
Assert.AreEqual (1, headers.IndexOf ("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");
headers.Replace ("Content-Type", ReplacedContentType);
Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing Content-Type.");
Assert.AreEqual (ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
Assert.AreEqual (0, headers.IndexOf ("Content-Type"), "Replaced Content-Type not in the expected position.");
headers.Replace ("Content-Id", ReplacedContentId);
Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing Content-Id.");
Assert.AreEqual (ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
Assert.AreEqual (2, headers.IndexOf ("Content-Id"), "Replaced Content-Id not in the expected position.");
}
public void TestSerializedContent()
{
const string expected = "Reporting-MTA: dns; mm1\nArrival-Date: Mon, 29 Jul 1996 02:12:50 -0700\n\nFinal-Recipient: RFC822; [email protected]\nAction: failed\nDiagnostic-Code: X-LOCAL; 500 (err.nosuchuser)\n\n";
var mds = new MessageDeliveryStatus();
var recipient = new HeaderList();
var status = new HeaderList();
status.Add("Reporting-MTA", "dns; mm1");
status.Add("Arrival-Date", DateUtils.FormatDate(new DateTimeOffset(1996, 7, 29, 2, 12, 50, new TimeSpan(-7, 0, 0))));
recipient.Add("Final-Recipient", "RFC822; [email protected]");
recipient.Add("Action", "failed");
recipient.Add("Diagnostic-Code", "X-LOCAL; 500 (err.nosuchuser)");
mds.StatusGroups.Add(status);
mds.StatusGroups.Add(recipient);
Assert.IsTrue(mds.StatusGroups.Contains(status), "Expected the groups to contain the per-message status group.");
Assert.IsTrue(mds.StatusGroups.Contains(recipient), "Expected the groups to contain the recipient status group.");
Assert.IsFalse(mds.StatusGroups.IsReadOnly, "The status groups should not be read-only.");
using (var memory = new MemoryStream()) {
mds.ContentObject.DecodeTo(memory);
var text = Encoding.ASCII.GetString(memory.GetBuffer(), 0, (int)memory.Length).Replace("\r\n", "\n");
Assert.AreEqual(expected, text);
}
var dummy = new HeaderList();
dummy.Add("Dummy-Header", "dummy value");
mds.StatusGroups.Add(dummy);
Assert.IsTrue(mds.StatusGroups.Contains(dummy), "Expected the groups to contain the dummy group.");
Assert.IsTrue(mds.StatusGroups.Remove(dummy), "Expected removal of the dummy group to be successful.");
var expectedContent = mds.ContentObject;
dummy.Add("Bogus-Header", "bogus value");
Assert.AreEqual(expectedContent, mds.ContentObject, "The content should not have changed since the dummy group has been removed.");
mds.StatusGroups.Clear();
using (var memory = new MemoryStream()) {
mds.ContentObject.DecodeTo(memory);
var text = Encoding.ASCII.GetString(memory.GetBuffer(), 0, (int)memory.Length).Replace("\r\n", "\n");
Assert.AreEqual(string.Empty, text);
}
}
public void TestSerializedContent ()
{
const string expected = "Reporting-MTA: dns; mm1\nArrival-Date: Mon, 29 Jul 1996 02:12:50 -0700\n\nFinal-Recipient: RFC822; [email protected]\nAction: failed\nDiagnostic-Code: X-LOCAL; 500 (err.nosuchuser)\n\n";
var mds = new MessageDeliveryStatus ();
var recipient = new HeaderList ();
var status = new HeaderList ();
status.Add ("Reporting-MTA", "dns; mm1");
status.Add ("Arrival-Date", DateUtils.FormatDate (new DateTimeOffset (1996, 7, 29, 2, 12, 50, new TimeSpan (-7, 0, 0))));
recipient.Add ("Final-Recipient", "RFC822; [email protected]");
recipient.Add ("Action", "failed");
recipient.Add ("Diagnostic-Code", "X-LOCAL; 500 (err.nosuchuser)");
mds.StatusGroups.Add (status);
mds.StatusGroups.Add (recipient);
Assert.IsTrue (mds.StatusGroups.Contains (status), "Expected the groups to contain the per-message status group.");
Assert.IsTrue (mds.StatusGroups.Contains (recipient), "Expected the groups to contain the recipient status group.");
Assert.IsFalse (mds.StatusGroups.IsReadOnly, "The status groups should not be read-only.");
using (var memory = new MemoryStream ()) {
mds.ContentObject.DecodeTo (memory);
var text = Encoding.ASCII.GetString (memory.GetBuffer (), 0, (int) memory.Length).Replace ("\r\n", "\n");
Assert.AreEqual (expected, text);
}
var dummy = new HeaderList ();
dummy.Add ("Dummy-Header", "dummy value");
mds.StatusGroups.Add (dummy);
Assert.IsTrue (mds.StatusGroups.Contains (dummy), "Expected the groups to contain the dummy group.");
Assert.IsTrue (mds.StatusGroups.Remove (dummy), "Expected removal of the dummy group to be successful.");
var expectedContent = mds.ContentObject;
dummy.Add ("Bogus-Header", "bogus value");
Assert.AreEqual (expectedContent, mds.ContentObject, "The content should not have changed since the dummy group has been removed.");
mds.StatusGroups.Clear ();
using (var memory = new MemoryStream ()) {
mds.ContentObject.DecodeTo (memory);
var text = Encoding.ASCII.GetString (memory.GetBuffer (), 0, (int) memory.Length).Replace ("\r\n", "\n");
Assert.AreEqual (string.Empty, text);
}
}
public object Get()
{
HeaderList list = new HeaderList();
NameValueCollection headers = HttpContext.Current.Request.Headers;
foreach (string header in headers.AllKeys)
{
list.Add(string.Format("{0}: {1}", header, headers[header]));
}
list.Add("Method: " + CommunicationContext.Request.HttpMethod);
return(list);
}
public object Get()
{
HeaderList list = new HeaderList();
NameValueCollection headers = HttpContext.Current.Request.Headers;
foreach (string header in headers.AllKeys)
{
list.Add(string.Format("{0}: {1}", header, headers[header]));
}
list.Add("Method: " + CommunicationContext.Request.HttpMethod);
return list;
}
protected bool ParseHeader()
{
var name = ParseFieldName();
if (name == null)
{
return(false);
}
if (c == ':')
{
c = TextStore.ReadChar();
}
else
{
throw new Exception(string.Format(ERROR_MALFORMED_HEADER, Name));
}
try
{
var value = ParseFieldValue();
ParseCRLF();
var h = HeaderList.Add(name, value.Trim());
if (h.Name == HttpHeaderContentType.NAME)
{
CheckEncoding(((HttpHeaderContentType)h).CharSet);
}
}
catch (Exception ex)
{
throw new Exception(string.Format(ERROR_MALFORMED_HEADER, Name), ex);
}
return(true);
}
public void TestReplacingMultipleHeaders()
{
const string CombinedRecpients = "first@localhost, second@localhost, third@localhost";
var headers = new HeaderList();
headers.Add("From", "sender@localhost");
headers.Add("To", "first@localhost");
headers.Add("To", "second@localhost");
headers.Add("To", "third@localhost");
headers.Add("Cc", "carbon.copy@localhost");
headers.Replace("To", CombinedRecpients);
Assert.AreEqual(3, headers.Count, "Unexpected number of headers after replacing To header.");
Assert.AreEqual(CombinedRecpients, headers["To"], "To header has unexpected value after being replaced.");
Assert.AreEqual(1, headers.IndexOf("To"), "Replaced To header not in the expected position.");
Assert.AreEqual(0, headers.IndexOf("From"), "From header not in the expected position.");
Assert.AreEqual(2, headers.IndexOf("Cc"), "Cc header not in the expected position.");
}
public void TestReplacingMultipleHeaders ()
{
const string CombinedRecpients = "first@localhost, second@localhost, third@localhost";
var headers = new HeaderList ();
headers.Add ("From", "sender@localhost");
headers.Add ("To", "first@localhost");
headers.Add ("To", "second@localhost");
headers.Add ("To", "third@localhost");
headers.Add ("Cc", "carbon.copy@localhost");
headers.Replace ("To", CombinedRecpients);
Assert.AreEqual (3, headers.Count, "Unexpected number of headers after replacing To header.");
Assert.AreEqual (CombinedRecpients, headers["To"], "To header has unexpected value after being replaced.");
Assert.AreEqual (1, headers.IndexOf ("To"), "Replaced To header not in the expected position.");
Assert.AreEqual (0, headers.IndexOf ("From"), "From header not in the expected position.");
Assert.AreEqual (2, headers.IndexOf ("Cc"), "Cc header not in the expected position.");
}
public void TestReplacingHeaders ()
{
const string ReplacedContentType = "text/plain; charset=iso-8859-1; name=body.txt";
const string ReplacedContentDisposition = "inline; filename=body.txt";
const string ReplacedContentLocation = "http://www.example.com/location";
const string ReplacedContentId = "<content.id.2@localhost>";
var headers = new HeaderList ();
headers.Add (HeaderId.ContentId, "<content-id.1@localhost>");
headers.Add ("Content-Location", "http://www.location.com");
headers.Insert (0, HeaderId.ContentDisposition, "attachment");
headers.Insert (0, "Content-Type", "text/plain");
Assert.IsTrue (headers.Contains (HeaderId.ContentType), "Expected the list of headers to contain HeaderId.ContentType.");
Assert.IsTrue (headers.Contains ("Content-Type"), "Expected the list of headers to contain a Content-Type header.");
Assert.AreEqual (0, headers.LastIndexOf (HeaderId.ContentType), "Expected the Content-Type header to be the first header.");
headers.Replace ("Content-Disposition", ReplacedContentDisposition);
Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
Assert.AreEqual (ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
Assert.AreEqual (1, headers.IndexOf ("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");
headers.Replace (HeaderId.ContentType, ReplacedContentType);
Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Type.");
Assert.AreEqual (ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
Assert.AreEqual (0, headers.IndexOf ("Content-Type"), "Replaced Content-Type not in the expected position.");
headers.Replace (HeaderId.ContentId, Encoding.UTF8, ReplacedContentId);
Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Id.");
Assert.AreEqual (ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
Assert.AreEqual (2, headers.IndexOf ("Content-Id"), "Replaced Content-Id not in the expected position.");
headers.Replace ("Content-Location", Encoding.UTF8, ReplacedContentLocation);
Assert.AreEqual (4, headers.Count, "Unexpected number of headers after replacing Content-Location.");
Assert.AreEqual (ReplacedContentLocation, headers["Content-Location"], "Content-Location has unexpected value after replacing it.");
Assert.AreEqual (3, headers.IndexOf ("Content-Location"), "Replaced Content-Location not in the expected position.");
headers.RemoveAll ("Content-Location");
Assert.AreEqual (3, headers.Count, "Unexpected number of headers after removing Content-Location.");
}
public void TestReplacingHeaders()
{
const string ReplacedContentType = "text/plain; charset=iso-8859-1; name=body.txt";
const string ReplacedContentDisposition = "inline; filename=body.txt";
const string ReplacedContentLocation = "http://www.example.com/location";
const string ReplacedContentId = "<content.id.2@localhost>";
var headers = new HeaderList();
headers.Add(HeaderId.ContentId, "<content-id.1@localhost>");
headers.Add("Content-Location", "http://www.location.com");
headers.Insert(0, HeaderId.ContentDisposition, "attachment");
headers.Insert(0, "Content-Type", "text/plain");
Assert.IsTrue(headers.Contains(HeaderId.ContentType), "Expected the list of headers to contain HeaderId.ContentType.");
Assert.IsTrue(headers.Contains("Content-Type"), "Expected the list of headers to contain a Content-Type header.");
Assert.AreEqual(0, headers.LastIndexOf(HeaderId.ContentType), "Expected the Content-Type header to be the first header.");
headers.Replace("Content-Disposition", ReplacedContentDisposition);
Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Disposition.");
Assert.AreEqual(ReplacedContentDisposition, headers["Content-Disposition"], "Content-Disposition has unexpected value after replacing it.");
Assert.AreEqual(1, headers.IndexOf("Content-Disposition"), "Replaced Content-Disposition not in the expected position.");
headers.Replace(HeaderId.ContentType, ReplacedContentType);
Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Type.");
Assert.AreEqual(ReplacedContentType, headers["Content-Type"], "Content-Type has unexpected value after replacing it.");
Assert.AreEqual(0, headers.IndexOf("Content-Type"), "Replaced Content-Type not in the expected position.");
headers.Replace(HeaderId.ContentId, Encoding.UTF8, ReplacedContentId);
Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Id.");
Assert.AreEqual(ReplacedContentId, headers["Content-Id"], "Content-Id has unexpected value after replacing it.");
Assert.AreEqual(2, headers.IndexOf("Content-Id"), "Replaced Content-Id not in the expected position.");
headers.Replace("Content-Location", Encoding.UTF8, ReplacedContentLocation);
Assert.AreEqual(4, headers.Count, "Unexpected number of headers after replacing Content-Location.");
Assert.AreEqual(ReplacedContentLocation, headers["Content-Location"], "Content-Location has unexpected value after replacing it.");
Assert.AreEqual(3, headers.IndexOf("Content-Location"), "Replaced Content-Location not in the expected position.");
headers.RemoveAll("Content-Location");
Assert.AreEqual(3, headers.Count, "Unexpected number of headers after removing Content-Location.");
}
private static HeaderList GenerateHeadersList(MailKit.IMessageSummary headers)
{
var headerList = new HeaderList();
foreach (var CcAddress in headers.Envelope.Cc)
{
headerList.Add("CC", CcAddress.ToString());
}
foreach (var CcAddress in headers.Envelope.Bcc)
{
headerList.Add("BCC", CcAddress.ToString());
}
foreach (var CcAddress in headers.Envelope.From)
{
headerList.Add("From", CcAddress.ToString());
}
foreach (var CcAddress in headers.Envelope.Sender)
{
headerList.Add("Sender", CcAddress.ToString());
}
headerList.Add("Subject", headers.Envelope.Subject);
if (headers.Envelope.Date != null)
{
headerList.Add("Date", MimeKit.Utils.DateUtils.FormatDate(headers.Date));
}
return(headerList);
}
public void TestRemovingHeaders()
{
var headers = new HeaderList();
headers.Add("From", "sender@localhost");
headers.Add("To", "first@localhost");
headers.Add("To", "second@localhost");
headers.Add("To", "third@localhost");
headers.Add("To", "fourth@localhost");
headers.Add("Cc", "carbon.copy@localhost");
Assert.IsFalse(headers.IsReadOnly);
Assert.IsFalse(headers.Contains(new Header(HeaderId.Received, "value")));
Assert.AreEqual(-1, headers.IndexOf(new Header(HeaderId.Received, "value")));
Assert.AreEqual(-1, headers.IndexOf("Received"));
Assert.AreEqual(-1, headers.LastIndexOf(HeaderId.Received));
Assert.AreEqual(null, headers[HeaderId.Received]);
Assert.IsTrue(headers.Remove("Cc"));
// try removing a header that no longer exists
Assert.IsFalse(headers.Remove(new Header(HeaderId.Cc, "value")));
Assert.IsFalse(headers.Remove(HeaderId.Cc));
Assert.IsFalse(headers.Remove("Cc"));
// removing this will change the result of headers[HeaderId.To]
Assert.AreEqual("first@localhost", headers[HeaderId.To]);
Assert.IsTrue(headers.Remove(HeaderId.To));
Assert.AreEqual("second@localhost", headers[HeaderId.To]);
Assert.IsTrue(headers.Remove("To"));
Assert.AreEqual("third@localhost", headers[HeaderId.To]);
headers.RemoveAt(headers.IndexOf("To"));
Assert.AreEqual("fourth@localhost", headers[HeaderId.To]);
}
public void TestRemovingHeaders()
{
var headers = new HeaderList();
headers.Add("From", "sender@localhost");
headers.Add("To", "first@localhost");
headers.Add("To", "second@localhost");
headers.Add("To", "third@localhost");
headers.Add("Cc", "carbon.copy@localhost");
Assert.IsTrue(headers.Remove("Cc"));
// try removing a header that no longer exists
Assert.IsFalse(headers.Remove(HeaderId.Cc));
Assert.IsFalse(headers.Remove("Cc"));
// removing this will change the result of headers[HeaderId.To]
Assert.AreEqual("first@localhost", headers[HeaderId.To]);
Assert.IsTrue(headers.Remove(HeaderId.To));
Assert.AreEqual("second@localhost", headers[HeaderId.To]);
Assert.IsTrue(headers.Remove("To"));
Assert.AreEqual("third@localhost", headers[HeaderId.To]);
}
/// <summary>
/// Initializes a new instance of the <see cref="MimeKit.MimeEntity"/> class
/// based on the <see cref="MimeEntityConstructorInfo"/>.
/// </summary>
/// <remarks>
/// Custom <see cref="MimeEntity"/> subclasses MUST implement this constructor
/// in order to register it using <see cref="ParserOptions.RegisterMimeType"/>.
/// </remarks>
/// <param name="entity">Information used by the constructor.</param>
protected MimeEntity (MimeEntityConstructorInfo entity)
{
if (entity == null)
throw new ArgumentNullException ("entity");
Headers = new HeaderList (entity.ParserOptions);
ContentType = entity.ContentType;
ContentType.Changed += ContentTypeChanged;
Headers.Changed += HeadersChanged;
foreach (var header in entity.Headers) {
if (entity.IsTopLevel && !header.Field.StartsWith ("Content-", StringComparison.OrdinalIgnoreCase))
continue;
Headers.Add (header);
}
}
public void SetField(string fieldName, IValue value, InternetMailMessageNonAsciiSymbolsEncodingMode?encodingMode = null)
{
if (encodingMode == null)
{
encodingMode = NonAsciiSymbolsEncodingMode;
}
var stringValue = value.AsString();
headers.Add(fieldName, stringValue);
if (fieldName.Equals("BCC", StringComparison.InvariantCultureIgnoreCase))
{
Bcc.Add(stringValue);
}
else if (fieldName.Equals("CC", StringComparison.InvariantCultureIgnoreCase))
{
Cc.Add(stringValue);
}
else if (fieldName.Equals("Date", StringComparison.InvariantCultureIgnoreCase))
{
DateTimeOffset res;
if (MimeKit.Utils.DateUtils.TryParse(stringValue, out res))
{
PostingDate = res.DateTime;
PostingDateOffset = new Decimal(res.Offset.TotalSeconds);
}
}
else if (fieldName.Equals("From", StringComparison.InvariantCultureIgnoreCase))
{
Sender = value;
}
else if (fieldName.Equals("Sender", StringComparison.InvariantCultureIgnoreCase))
{
SenderName = stringValue;
}
else if (fieldName.Equals("Subject", StringComparison.InvariantCultureIgnoreCase))
{
Theme = stringValue;
}
}
public void TestArgumentExceptions()
{
var list = new HeaderList();
Header header;
string value;
using (var stream = new MemoryStream()) {
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(null, "filename.txt"));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (string)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(null, stream));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (Stream)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(null, "filename.txt"));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (string)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(null, stream));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (Stream)null));
}
// Add
Assert.Throws <ArgumentNullException> (() => list.Add(null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Add(HeaderId.Unknown, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add(HeaderId.AdHoc, null));
Assert.Throws <ArgumentNullException> (() => list.Add(null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add("field", null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Add(HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add(HeaderId.AdHoc, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add(HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws <ArgumentNullException> (() => list.Add(null, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add("field", null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Add("field", Encoding.UTF8, null));
// Contains
Assert.Throws <ArgumentOutOfRangeException> (() => list.Contains(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.Contains((Header)null));
Assert.Throws <ArgumentNullException> (() => list.Contains((string)null));
// CopyTo
Assert.Throws <ArgumentOutOfRangeException> (() => list.CopyTo(new Header[0], -1));
Assert.Throws <ArgumentNullException> (() => list.CopyTo(null, 0));
// IndexOf
Assert.Throws <ArgumentOutOfRangeException> (() => list.IndexOf(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.IndexOf((Header)null));
Assert.Throws <ArgumentNullException> (() => list.IndexOf((string)null));
// Insert
list.Add("field", "value");
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, new Header(HeaderId.AdHoc, "value")));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, HeaderId.AdHoc, Encoding.UTF8, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, "field", Encoding.UTF8, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, HeaderId.AdHoc, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(-1, "field", "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(0, HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Insert(0, HeaderId.Unknown, "value"));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, HeaderId.AdHoc, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, HeaderId.AdHoc, null));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, "field", null));
Assert.Throws <ArgumentNullException> (() => list.Insert(0, null));
// LastIndexOf
Assert.Throws <ArgumentOutOfRangeException> (() => list.LastIndexOf(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.LastIndexOf((string)null));
// Remove
Assert.Throws <ArgumentOutOfRangeException> (() => list.Remove(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.Remove((Header)null));
Assert.Throws <ArgumentNullException> (() => list.Remove((string)null));
// RemoveAll
Assert.Throws <ArgumentOutOfRangeException> (() => list.RemoveAll(HeaderId.Unknown));
Assert.Throws <ArgumentNullException> (() => list.RemoveAll((string)null));
// RemoveAt
Assert.Throws <ArgumentOutOfRangeException> (() => list.RemoveAt(-1));
// Replace
Assert.Throws <ArgumentNullException> (() => list.Replace(null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Replace(HeaderId.Unknown, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace(HeaderId.AdHoc, null));
Assert.Throws <ArgumentNullException> (() => list.Replace(null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace("field", null));
Assert.Throws <ArgumentOutOfRangeException> (() => list.Replace(HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace(HeaderId.AdHoc, null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace(HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws <ArgumentNullException> (() => list.Replace(null, Encoding.UTF8, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace("field", null, "value"));
Assert.Throws <ArgumentNullException> (() => list.Replace("field", Encoding.UTF8, null));
using (var stream = new MemoryStream()) {
// Load
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (Stream)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(ParserOptions.Default, (string)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load(null, stream));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load((Stream)null));
Assert.Throws <ArgumentNullException> (() => HeaderList.Load((string)null));
// LoadAsync
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (Stream)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(ParserOptions.Default, (string)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync(null, stream));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync((Stream)null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await HeaderList.LoadAsync((string)null));
// WriteTo
Assert.Throws <ArgumentNullException> (() => list.WriteTo(FormatOptions.Default, null));
Assert.Throws <ArgumentNullException> (() => list.WriteTo(null, stream));
Assert.Throws <ArgumentNullException> (() => list.WriteTo(null));
// WriteToAsync
Assert.ThrowsAsync <ArgumentNullException> (async() => await list.WriteToAsync(FormatOptions.Default, null));
Assert.ThrowsAsync <ArgumentNullException> (async() => await list.WriteToAsync(null, stream));
Assert.ThrowsAsync <ArgumentNullException> (async() => await list.WriteToAsync(null));
}
// Indexers
Assert.Throws <ArgumentOutOfRangeException> (() => list[-1] = new Header(HeaderId.AdHoc, "value"));
Assert.Throws <ArgumentOutOfRangeException> (() => list[HeaderId.Unknown] = "value");
Assert.Throws <ArgumentOutOfRangeException> (() => value = list[HeaderId.Unknown]);
Assert.Throws <ArgumentOutOfRangeException> (() => header = list[-1]);
Assert.Throws <ArgumentNullException> (() => list[HeaderId.AdHoc] = null);
Assert.Throws <ArgumentNullException> (() => value = list[null]);
Assert.Throws <ArgumentNullException> (() => list[null] = "value");
Assert.Throws <ArgumentNullException> (() => list["field"] = null);
Assert.Throws <ArgumentNullException> (() => list[0] = null);
}
public void AddParameter(HeaderParameterStructure headerParameterStructure)
{
IsHeaderExist(headerParameterStructure.Name);
HeaderList.Add(headerParameterStructure);
}
private WebRequest BuildWebRequest(string method, string objectPath, HeaderList protoHeaders)
{
UriBuilder uriBuilder = new UriBuilder("http", "s3.amazonaws.com", 80, objectPath);
WebRequest webRequest = WebRequest.Create(uriBuilder.ToString());
((HttpWebRequest)webRequest).AllowWriteStreamBuffering = false;
webRequest.Method = method;
HeaderList headerList = new HeaderList(protoHeaders);
headerList.AddHeaderIfAbsent("x-amz-date", DateTime.UtcNow.ToString("ddd, dd MMM yyyy HH:mm:ss ", CultureInfo.InvariantCulture) + "GMT");
for (int i = 0; i < headerList.Count; i++)
{
string a = headerList.Keys[i];
string contentType = headerList.Values[i];
if (a == "content-type")
{
webRequest.ContentType = contentType;
}
else
{
webRequest.Headers.Add(headerList.Keys[i], headerList.Values[i]);
}
}
StringBuilder stringBuilder = new StringBuilder();
HeaderList headerList2 = new HeaderList();
foreach (string current in headerList.Keys)
{
string text = current.ToLower();
if (text == "content-type" || text == "content-md5" || text == "date" || text.StartsWith("x-amz-"))
{
headerList2.Add(text, headerList[current]);
}
}
if (headerList2.ContainsKey("x-amz-date"))
{
headerList2["date"] = "";
}
if (!headerList2.ContainsKey("content-type"))
{
headerList2["content-type"] = "";
}
if (!headerList2.ContainsKey("content-md5"))
{
headerList2["content-md5"] = "";
}
stringBuilder.Append(webRequest.Method);
stringBuilder.Append("\n");
for (int j = 0; j < headerList2.Count; j++)
{
if (headerList2.Keys[j].StartsWith("x-amz-"))
{
stringBuilder.Append(headerList2.Keys[j]);
stringBuilder.Append(":");
stringBuilder.Append(headerList2.Values[j].Trim());
}
else
{
stringBuilder.Append(headerList2.Values[j]);
}
stringBuilder.Append("\n");
}
stringBuilder.Append("/");
stringBuilder.Append(objectPath);
string text2 = stringBuilder.ToString();
Encoding encoding = new UTF8Encoding();
HMACSHA1 hMACSHA = new HMACSHA1(encoding.GetBytes(this.secretAccessKey));
byte[] inArray = hMACSHA.ComputeHash(encoding.GetBytes(text2.ToCharArray()));
string arg = Convert.ToBase64String(inArray);
webRequest.Headers.Add("Authorization", string.Format("AWS {0}:{1}", this.accessKeyId, arg));
return webRequest;
}
internal MimeMessage (ParserOptions options, IEnumerable<Header> headers)
{
addresses = new Dictionary<string, InternetAddressList> (StringComparer.OrdinalIgnoreCase);
Headers = new HeaderList (options);
// initialize our address lists
foreach (var name in StandardAddressHeaders) {
var list = new InternetAddressList ();
list.Changed += InternetAddressListChanged;
addresses.Add (name, list);
}
references = new MessageIdList ();
references.Changed += ReferencesChanged;
inreplyto = null;
Headers.Changed += HeadersChanged;
// add all of our message headers...
foreach (var header in headers) {
if (header.Field.StartsWith ("Content-", StringComparison.OrdinalIgnoreCase))
continue;
Headers.Add (header);
}
}
/// <summary>
/// 添加Header
/// </summary>
public void Addition()
{
HeaderList.Add(new Header());
}
public void TestArgumentExceptions ()
{
var list = new HeaderList ();
Header header;
string value;
// Add
Assert.Throws<ArgumentNullException> (() => list.Add (null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Add (HeaderId.Unknown, "value"));
Assert.Throws<ArgumentNullException> (() => list.Add (HeaderId.AdHoc, null));
Assert.Throws<ArgumentNullException> (() => list.Add (null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Add ("field", null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Add (HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws<ArgumentNullException> (() => list.Add (HeaderId.AdHoc, null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Add (HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws<ArgumentNullException> (() => list.Add (null, Encoding.UTF8, "value"));
Assert.Throws<ArgumentNullException> (() => list.Add ("field", null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Add ("field", Encoding.UTF8, null));
// Contains
Assert.Throws<ArgumentOutOfRangeException> (() => list.Contains (HeaderId.Unknown));
Assert.Throws<ArgumentNullException> (() => list.Contains ((Header) null));
Assert.Throws<ArgumentNullException> (() => list.Contains ((string) null));
// CopyTo
Assert.Throws<ArgumentOutOfRangeException> (() => list.CopyTo (new Header[0], -1));
Assert.Throws<ArgumentNullException> (() => list.CopyTo (null, 0));
// IndexOf
Assert.Throws<ArgumentOutOfRangeException> (() => list.IndexOf (HeaderId.Unknown));
Assert.Throws<ArgumentNullException> (() => list.IndexOf ((Header) null));
Assert.Throws<ArgumentNullException> (() => list.IndexOf ((string) null));
// Insert
list.Add ("field", "value");
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, new Header (HeaderId.AdHoc, "value")));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, HeaderId.AdHoc, Encoding.UTF8, "value"));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, "field", Encoding.UTF8, "value"));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, HeaderId.AdHoc, "value"));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (-1, "field", "value"));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (0, HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Insert (0, HeaderId.Unknown, "value"));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, HeaderId.AdHoc, null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, HeaderId.AdHoc, null));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, "field", null));
Assert.Throws<ArgumentNullException> (() => list.Insert (0, null));
// LastIndexOf
Assert.Throws<ArgumentOutOfRangeException> (() => list.LastIndexOf (HeaderId.Unknown));
Assert.Throws<ArgumentNullException> (() => list.LastIndexOf ((string) null));
// Remove
Assert.Throws<ArgumentOutOfRangeException> (() => list.Remove (HeaderId.Unknown));
Assert.Throws<ArgumentNullException> (() => list.Remove ((Header) null));
Assert.Throws<ArgumentNullException> (() => list.Remove ((string) null));
// RemoveAll
Assert.Throws<ArgumentOutOfRangeException> (() => list.RemoveAll (HeaderId.Unknown));
Assert.Throws<ArgumentNullException> (() => list.RemoveAll ((string) null));
// RemoveAt
Assert.Throws<ArgumentOutOfRangeException> (() => list.RemoveAt (-1));
// Replace
Assert.Throws<ArgumentNullException> (() => list.Replace (null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Replace (HeaderId.Unknown, "value"));
Assert.Throws<ArgumentNullException> (() => list.Replace (HeaderId.AdHoc, null));
Assert.Throws<ArgumentNullException> (() => list.Replace (null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Replace ("field", null));
Assert.Throws<ArgumentOutOfRangeException> (() => list.Replace (HeaderId.Unknown, Encoding.UTF8, "value"));
Assert.Throws<ArgumentNullException> (() => list.Replace (HeaderId.AdHoc, null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Replace (HeaderId.AdHoc, Encoding.UTF8, null));
Assert.Throws<ArgumentNullException> (() => list.Replace (null, Encoding.UTF8, "value"));
Assert.Throws<ArgumentNullException> (() => list.Replace ("field", null, "value"));
Assert.Throws<ArgumentNullException> (() => list.Replace ("field", Encoding.UTF8, null));
using (var stream = new MemoryStream ()) {
// Load
Assert.Throws<ArgumentNullException> (() => HeaderList.Load (ParserOptions.Default, (Stream) null));
Assert.Throws<ArgumentNullException> (() => HeaderList.Load (ParserOptions.Default, (string) null));
Assert.Throws<ArgumentNullException> (() => HeaderList.Load (null, stream));
Assert.Throws<ArgumentNullException> (() => HeaderList.Load ((Stream) null));
Assert.Throws<ArgumentNullException> (() => HeaderList.Load ((string) null));
// WriteTo
Assert.Throws<ArgumentNullException> (() => list.WriteTo (FormatOptions.Default, null));
Assert.Throws<ArgumentNullException> (() => list.WriteTo (null, stream));
Assert.Throws<ArgumentNullException> (() => list.WriteTo (null));
}
// Indexers
Assert.Throws<ArgumentOutOfRangeException> (() => list[-1] = new Header (HeaderId.AdHoc, "value"));
Assert.Throws<ArgumentOutOfRangeException> (() => list[HeaderId.Unknown] = "value");
Assert.Throws<ArgumentOutOfRangeException> (() => value = list[HeaderId.Unknown]);
Assert.Throws<ArgumentOutOfRangeException> (() => header = list[-1]);
Assert.Throws<ArgumentNullException> (() => list[HeaderId.AdHoc] = null);
Assert.Throws<ArgumentNullException> (() => value = list[null]);
Assert.Throws<ArgumentNullException> (() => list[null] = "value");
Assert.Throws<ArgumentNullException> (() => list["field"] = null);
Assert.Throws<ArgumentNullException> (() => list[0] = null);
}
public void TestRemovingHeaders ()
{
var headers = new HeaderList ();
headers.Add ("From", "sender@localhost");
headers.Add ("To", "first@localhost");
headers.Add ("To", "second@localhost");
headers.Add ("To", "third@localhost");
headers.Add ("Cc", "carbon.copy@localhost");
Assert.IsTrue (headers.Remove ("Cc"));
// try removing a header that no longer exists
Assert.IsFalse (headers.Remove (HeaderId.Cc));
Assert.IsFalse (headers.Remove ("Cc"));
// removing this will change the result of headers[HeaderId.To]
Assert.AreEqual ("first@localhost", headers[HeaderId.To]);
Assert.IsTrue (headers.Remove (HeaderId.To));
Assert.AreEqual ("second@localhost", headers[HeaderId.To]);
Assert.IsTrue (headers.Remove ("To"));
Assert.AreEqual ("third@localhost", headers[HeaderId.To]);
}
/// <summary>
/// Process Token
/// </summary>
/// <param name="TokenToAdd"></param>
/// <param name="InstanceData"></param>
/// <param name="DataStream"></param>
void ProcessToken(Token TokenToAdd)
{
switch (TokenToAdd.TokenTypeValue)
{
case TokenType.ISO1030321:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.ISO;
break;
case TokenType.ISO1030321END:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.READY;
break;
case TokenType.HEADER:
Lexer.Tokenizer(DataStream);
//InstanceData.aHeaderSection = new HeaderSection();
currStatus = ParserStatus.HEADER;
break;
case TokenType.ENDSEC:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.ISO;
break;
case TokenType.ENTITYINSTANCENAME:
switch (currStatus)
{
case ParserStatus.DATA:
Token oneToken = Lexer.Tokenizer(DataStream);
if (oneToken.TokenTypeValue != TokenType.EQUAL)
{
Console.WriteLine("Syntax Error in Entity Instance : #" + TokenToAdd.IntegerValue.ToString());
return;
}
oneToken = Lexer.Tokenizer(DataStream);
if (oneToken.TokenTypeValue == TokenType.KEYWORD)
{
SortedDictionary <uint, Instance> toAdd = DataList;
if (toAdd.ContainsKey((uint)TokenToAdd.IntegerValue))
{
// when instance is already created by other caller
//P21Instance a = toAdd[(uint)TokenToAdd.IntegerValue];
InstanceSimple aSimpleInstance = (InstanceSimple)toAdd[(uint)TokenToAdd.IntegerValue];
ModifySimpleInstanceRecord(aSimpleInstance, oneToken.StringValue);
}
else
{
// when it is the first time of parsing entity instance name #???
InstanceSimple aSimpleInstance = AddSimpleInstance((uint)TokenToAdd.IntegerValue, oneToken.StringValue);
toAdd.Add((uint)TokenToAdd.IntegerValue, aSimpleInstance);
}
// adding instances to instanceByType according to instance type
if (InstanceByType.ContainsKey(oneToken.StringValue))
{
List <uint> existingList = InstanceByType[oneToken.StringValue];
existingList.Add((uint)TokenToAdd.IntegerValue);
}
else
{
List <uint> newList = new List <uint>();
newList.Add((uint)TokenToAdd.IntegerValue);
InstanceByType.Add(oneToken.StringValue, newList);
}
}
else if (oneToken.TokenTypeValue == TokenType.LEFTPARENTHESIS)
{
// need update for complex type
SortedDictionary <uint, Instance> toAdd = DataList;
InstanceComplex aComplexInstance = AddComplexInstance((uint)TokenToAdd.IntegerValue);
if (toAdd.ContainsKey((uint)TokenToAdd.IntegerValue))
{
toAdd[(uint)TokenToAdd.IntegerValue] = aComplexInstance;
}
else
{
toAdd.Add((uint)TokenToAdd.IntegerValue, aComplexInstance);
}
}
else
{
Console.WriteLine("Syntax Error at value defintion in Entity Instance : #" + TokenToAdd.IntegerValue.ToString());
return;
}
break;
default:
Console.WriteLine("Parser Error : Not defined parsing condition in Entity Instance Name : " + currStatus);
break;
}
break;
case TokenType.KEYWORD:
switch (currStatus)
{
case ParserStatus.HEADER:
SimpleRecord aSimpleRecord = AddSimpleRecord(null, TokenToAdd.StringValue);
HeaderList.Add(aSimpleRecord);
Lexer.Tokenizer(DataStream); // cleans semicolon at the end of header instance
break;
case ParserStatus.DATA:
Console.WriteLine("Syntax Error : Instance without Entity Instance Name");
break;
default:
Console.WriteLine("Parser Error : Not defined parsing condition in Keyword");
break;
}
break;
case TokenType.DATA:
Lexer.Tokenizer(DataStream);
currStatus = ParserStatus.DATA;
//theDataSet.aDataSectionList.Add(new DataSection());
break;
default:
Console.WriteLine("not defined condition : " + TokenToAdd.TokenTypeValue.ToString());
break;
}
}
