AWSSDK_DotNet.IntegrationTests.Tests.General.TestException C# (CSharp) Method

        private static void TestException(Exception e)
        {
            string[] headers = null;
            var here = e.InnerException as HttpErrorResponseException;
            var hasHttpResponse = here != null;
            if (hasHttpResponse)
            {
                Assert.IsNotNull(here.Response);
                headers = here.Response.GetHeaderNames();
                Assert.IsNotNull(headers);
                Assert.AreNotEqual(0, headers.Length);
            }

            var serializer = new BinaryFormatter();
            using (var ms = new MemoryStream())
            {
                serializer.Serialize(ms, e);
                ms.Seek(0, SeekOrigin.Begin);
                var deserialized = serializer.Deserialize(ms) as Exception;

                Assert.IsNotNull(deserialized);

                Assert.AreEqual(e.Message, deserialized.Message);
                if (e is AmazonS3Exception)
                {
                    var as3e = e as AmazonS3Exception;
                    var dAs3e = deserialized as AmazonS3Exception;
                    Assert.AreEqual(as3e.ErrorType, dAs3e.ErrorType);
                    Assert.AreEqual(as3e.ErrorCode, dAs3e.ErrorCode);
                    Assert.AreEqual(as3e.RequestId, dAs3e.RequestId);
                    Assert.AreEqual(as3e.StatusCode, dAs3e.StatusCode);
                    Assert.AreEqual(as3e.AmazonId2, dAs3e.AmazonId2);
                    Assert.AreEqual(as3e.ResponseBody, dAs3e.ResponseBody);
                }

                if (hasHttpResponse)
                {
                    var hereDeserialized = deserialized.InnerException as HttpErrorResponseException;
                    Assert.IsNotNull(hereDeserialized);
                    Assert.IsNotNull(hereDeserialized.Response);
                    var headersDeserialized = hereDeserialized.Response.GetHeaderNames();
                    Assert.IsNotNull(headersDeserialized);
                    Assert.AreNotEqual(0, headersDeserialized.Length);
                    Assert.AreEqual(headers.Length, headersDeserialized.Length);

                    Assert.AreEqual(here.Response.StatusCode, hereDeserialized.Response.StatusCode);
                    Assert.AreEqual(here.Response.IsSuccessStatusCode, hereDeserialized.Response.IsSuccessStatusCode);
                    Assert.AreEqual(here.Response.ContentLength, hereDeserialized.Response.ContentLength);
                    Assert.AreEqual(here.Response.ContentType, hereDeserialized.Response.ContentType);

                    foreach (var header in headers)
                    {
                        Assert.IsTrue(hereDeserialized.Response.IsHeaderPresent(header));
                        var value = hereDeserialized.Response.GetHeaderValue(header);
                        Assert.IsNotNull(value);
                        Assert.AreEqual(here.Response.GetHeaderValue(header), value);
                    }
                }

                if (e is DeleteObjectsException)
                {
                    var doe = e as DeleteObjectsException;
                    var dDoe = deserialized as DeleteObjectsException;

                    Assert.AreEqual(doe.Response.DeletedObjects.Count, dDoe.Response.DeletedObjects.Count);
                    foreach(var deleted in dDoe.Response.DeletedObjects)
                    {
                        Assert.IsNotNull(deleted.DeleteMarkerVersionId);
                        Assert.IsNotNull(deleted.Key);
                        Assert.IsNotNull(deleted.VersionId);
                        Assert.IsNotNull(deleted.DeleteMarker);
                        Assert.AreEqual(deleted.Key.EndsWith("1"), deleted.DeleteMarker);
                    }
                    Assert.AreEqual(doe.Response.DeleteErrors.Count, dDoe.Response.DeleteErrors.Count);
                    foreach (var error in dDoe.Response.DeleteErrors)
                    {
                        Assert.IsNotNull(error.Code);
                        Assert.IsNotNull(error.Key);
                        Assert.IsNotNull(error.Message);
                        Assert.IsNotNull(error.VersionId);
                    }
                }

                if (e is S3PostUploadException)
                {
                    var pue = e as S3PostUploadException;
                    var dPue = deserialized as S3PostUploadException;

                    Assert.AreEqual(pue.ErrorCode, dPue.ErrorCode);
                    Assert.AreEqual(pue.RequestId, dPue.RequestId);
                    Assert.AreEqual(pue.HostId, dPue.HostId);
                    Assert.AreEqual(pue.StatusCode, dPue.StatusCode);
                    Assert.AreEqual(pue.ExtraFields.Count, dPue.ExtraFields.Count);
                    foreach(var kvp in dPue.ExtraFields)
                    {
                        Assert.IsFalse(string.IsNullOrEmpty(kvp.Key));
                        Assert.IsFalse(string.IsNullOrEmpty(kvp.Value));
                    }
                }
            }
        }