public void ConstructorWithMessageWorks()
 {
     var ex = new NullReferenceException("The message");
     Assert.True((object)ex is NullReferenceException, "is NullReferenceException");
     Assert.AreEqual(ex.InnerException, null, "InnerException");
     Assert.AreEqual(ex.Message, "The message");
 }

 public void TypePropertiesAreCorrect()
 {
     Assert.AreEqual(typeof(NullReferenceException).GetClassName(), "Bridge.NullReferenceException", "Name");
     object d = new NullReferenceException();
     Assert.True(d is NullReferenceException, "is NullReferenceException");
     Assert.True(d is Exception, "is Exception");
 }

 public void DefaultConstructorWorks()
 {
     var ex = new NullReferenceException();
     Assert.True((object)ex is NullReferenceException, "is NullReferenceException");
     Assert.AreEqual(ex.InnerException, null, "InnerException");
     Assert.AreEqual(ex.Message, "Object is null.");
 }

        public void RunTestsOfJUUTTestClassWithFailingClassSetUp()
        {
            TestClassSession session = new TestClassSession(typeof(TestClassMockWithFailingClassSetUp));
            session.Add(typeof(TestClassMockWithFailingClassSetUp).GetMethod("Bar"));

            //Testing the run of a specific testMethod
            TestRunner runner = new SimpleTestRunner();
            ClassReport classReport = runner.Run(session);
            AssertThatTheMethodsAreCalledInTheCorrectOrderAfterRunningATestWithFailingClassSetUp();

            //Checking the returned test report
            Report report = GetFirstMethodReportFrom(classReport.MethodReports);
            Exception raisedException = new NullReferenceException("Failing class set up.");
            Report expectedReport = new MethodReport(typeof(TestClassMockWithFailingClassSetUp).GetMethod("ClassSetUp"), raisedException);
            AssertEx.That(report, Is.EqualTo(expectedReport));

            //Testing the run of all tests
            MethodCallOrder = new List<string>();
            session.AddAll();
            classReport = runner.Run(session);
            AssertThatTheMethodsAreCalledInTheCorrectOrderAfterRunningATestWithFailingClassSetUp();

            //Checking the returned test reports
            ICollection<MethodReport> reports = classReport.MethodReports;
            raisedException = new NullReferenceException("Failing class set up.");
            expectedReport = new MethodReport(typeof(TestClassMockWithFailingClassSetUp).GetMethod("ClassSetUp"), raisedException);
            AssertEx.That(reports.Count, Is.EqualTo(1));
            AssertEx.That(GetFirstMethodReportFrom(reports), Is.EqualTo(expectedReport));
        }

 public static void Test2()
 {
     var e1 = new NullReferenceException();
     var e2 = new NullReferenceException("бла бла", e1);
     var e3 = new Exception("Ураааа", e2);
     throw e3;
 }

        public void AgainstNull_WithValidLambdaExpression_DoesNotThrow()
        {
            NullReferenceException ex = new NullReferenceException();

            // valid cast, does not evaluate to null
            Assert.DoesNotThrow(() => Guard.AgainstNull(() => ex as Exception));
        }

 public void Throw_Test()
 {
     var exception = new NullReferenceException();
     var expected = Observable.Throw<string>(exception);
     var actual = FactoryMethods.Throw<string>(exception);
     ReactiveAssert.AreElementsEqual(expected, actual);
 }

        public Models.Repository Create(string RepositoryName, string Description, string HomePage, bool Public)
        {
            LogProvider.LogMessage(string.Format("Repository.Create - RepositoryName : '{0}' , Description : '{1}' , HomePage : '{2}', Public : '{3}'",
                RepositoryName,
                Description,
                HomePage,
                Public));

            Authenticate();

            var url = "repos/create";

            var formValues = new NameValueCollection();
            if (string.IsNullOrEmpty(RepositoryName))
            {
                var error = new NullReferenceException("RepositoryName was null or empty");
                if (LogProvider.HandleAndReturnIfToThrowError(error))
                    throw error;
                return null;
            }
            formValues.Add("name", RepositoryName);

            if (!string.IsNullOrEmpty(Description))
                formValues.Add("description", Description);
            if (!string.IsNullOrEmpty(HomePage))
                formValues.Add("homepage", HomePage);

            formValues.Add("public", (Public ? 1 : 0).ToString());

            var result = ConsumeJsonUrlAndPostData<Models.Internal.RepositoryContainer<Models.Repository>>(url, formValues);

            return result == null ? null : result.Repository;
        }

 public void ResponseIsNullForNonWebExceptions()
 {
   NullReferenceException exception = new NullReferenceException("The thing is null");
   _builder.SetExceptionDetails(exception);
   RaygunMessage message = _builder.Build();
   Assert.IsNull(message.Details.Response);
 }

        public void ShouldWrite()
        {
            var inner1Ex = new NullReferenceException("inner1Message");
            var inner2Ex = new InvalidOperationException("inner2Message", inner1Ex);
            var outerEx = new Exception("outerMessage", inner2Ex);

            var expectedOutput = @"----------
            outerMessage
            ----------
            Debug information:
            ----------
            Exception: outerMessage
            [StackTrace:Exception]
            ----------
            inner InvalidOperationException: inner2Message
            [StackTrace:InvalidOperationException]
            ----------
            inner NullReferenceException: inner1Message
            [StackTrace:NullReferenceException]
            ----------
            ";

            Func<Exception, string> stackTraceFormatter = ex => string.Format("[StackTrace:{0}]", ex.GetType().Name);

            var actual = outerEx.ToLogString(stackTraceFormatter);

            Assert.That(expectedOutput, Is.EqualTo(actual));
        }

		public void ConstructorWithMessageAndInnerExceptionWorks() {
			var inner = new Exception("a");
			var ex = new NullReferenceException("The message", inner);
			Assert.IsTrue((object)ex is NullReferenceException, "is NullReferenceException");
			Assert.IsTrue(ReferenceEquals(ex.InnerException, inner), "InnerException");
			Assert.AreEqual(ex.Message, "The message");
		}

        public HttpResponseMessage SuccessPayment(Guid invoiceKey, Guid paymentKey, string token, string payerId)
        {
            var invoice = _merchelloContext.Services.InvoiceService.GetByKey(invoiceKey);
            var payment = _merchelloContext.Services.PaymentService.GetByKey(paymentKey);
            if (invoice == null || payment == null || String.IsNullOrEmpty(token) || String.IsNullOrEmpty(payerId))
            {
                var ex = new NullReferenceException(string.Format("Invalid argument exception. Arguments: invoiceKey={0}, paymentKey={1}, token={2}, payerId={3}.", invoiceKey, paymentKey, token, payerId));
                LogHelper.Error<PayPalApiController>("Payment is not authorized.", ex);
                throw ex;
            }

	        var providerKeyGuid = new Guid(Constants.PayPalPaymentGatewayProviderKey);
			var paymentGatewayMethod = _merchelloContext.Gateways.Payment
				.GetPaymentGatewayMethods()
				.First(item => item.PaymentMethod.ProviderKey == providerKeyGuid);
	        //var paymentGatewayMethod = _merchelloContext.Gateways.Payment.GetPaymentGatewayMethodByKey(providerKeyGuid);

            // Authorize
            var authorizeResult = _processor.AuthorizePayment(invoice, payment, token, payerId);
	        /*
			var authorizePaymentProcArgs = new ProcessorArgumentCollection();

	        authorizePaymentProcArgs[Constants.ProcessorArgumentsKeys.internalTokenKey] = token;
			authorizePaymentProcArgs[Constants.ProcessorArgumentsKeys.internalPayerIDKey] = payerId;
			authorizePaymentProcArgs[Constants.ProcessorArgumentsKeys.internalPaymentKeyKey] = payment.Key.ToString();

	        var authorizeResult = paymentGatewayMethod.AuthorizeCapturePayment(invoice, payment.Amount, authorizePaymentProcArgs);
            */
            _merchelloContext.Services.GatewayProviderService.Save(payment);
            if (!authorizeResult.Payment.Success)
            {
                LogHelper.Error<PayPalApiController>("Payment is not authorized.", authorizeResult.Payment.Exception);
				_merchelloContext.Services.GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, "PayPal: request capture authorization error: " + authorizeResult.Payment.Exception.Message, 0);
                return ShowError(authorizeResult.Payment.Exception.Message);
            }
			_merchelloContext.Services.GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, "PayPal: capture authorized", 0);

			// The basket can be empty
            var customerContext = new Merchello.Web.CustomerContext(this.UmbracoContext);
            var currentCustomer = customerContext.CurrentCustomer;
	        if (currentCustomer != null) {
				var basket = Merchello.Web.Workflow.Basket.GetBasket(currentCustomer);
				basket.Empty();
	        }

            // Capture
            var captureResult = paymentGatewayMethod.CapturePayment(invoice, payment, payment.Amount, null);
            if (!captureResult.Payment.Success)
            {
                LogHelper.Error<PayPalApiController>("Payment is not captured.", captureResult.Payment.Exception);
                return ShowError(captureResult.Payment.Exception.Message);
            }

            // redirect to Site
			var returnUrl = payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.ReturnUrl);
            var response = Request.CreateResponse(HttpStatusCode.Moved);
            response.Headers.Location = new Uri(returnUrl.Replace("%INVOICE%", invoice.Key.ToString().EncryptWithMachineKey()));
            return response;
        }

 public ErrorPage(Server server, Request request, Exception e) {
     if (e == null)
         e = new NullReferenceException("Error page passed a null exception");
     this.exception = e;
     this.httpException = (e is HttpException) ? (HttpException)e : new HttpException(e);
     this.server = server;
     this.request = request;
 }

        public static void NullReferenceException_Ctor_String_Exception()
        {
            Exception ex = new Exception(innerExceptionMessage);
            NullReferenceException i = new NullReferenceException(exceptionMessage, ex);

            Assert.Equal(exceptionMessage, i.Message);
            Assert.Equal(i.InnerException.Message, innerExceptionMessage);
            Assert.Equal(i.InnerException.HResult, ex.HResult);
            Assert.Equal(E_POINTER, (uint)i.HResult);
        }

 protected override void Given()
 {
     base.Given();
     _caughtExceptions = new List<Exception>();
     _config = new CircuitBreakerConfig {ExpectedExceptionListType = ExceptionListType.BlackList};
     _config.ExpectedExceptionList.Add(typeof(ArgumentNullException));
     _circuitBreaker = new CircuitBreaker(_config);
     _circuitBreaker.ToleratedOpenCircuitBreaker += (sender, args) => _toleratedOpenEventFired = true;
     _thrownException = new NullReferenceException();
 }

        public void LogException_SHOULD_log_with_severity_Error()
        {
            var dummyException = new NullReferenceException();
            var fakeWriter = new Mock<ILogWriter>();

            var sut = new Logger(fakeWriter.Object);
            sut.LogException(dummyException);

            fakeWriter.Verify(m => m.Write(Match.Create<LogEntry>(e => e.Severity == Severity.Error)));
        }

 protected override void Given()
 {
     base.Given();
     _config = new CircuitBreakerConfig
     {
         ExpectedExceptionListType = ExceptionListType.BlackList
     };
     _config.ExpectedExceptionList.Add(typeof(ArgumentNullException));
     _circuitBreaker = new CircuitBreaker(_config);
     _thrownException = new NullReferenceException();
 }

		public void ReturnFalseGivenExceptionIsNotOfType()
		{
			// Arrange
			var exception = new NullReferenceException();

			// Act
			var isOfType = exception.IsOrContainsExceptionOfType<NotImplementedException>();

			// Assert
			Assert.IsFalse(isOfType);
		}

		public void ReturnNullGivenExceptionIsNotOfType()
		{
			// Arrange
			var exception = new NullReferenceException();

			// Act
			var returnedException = exception.GetFirstExceptionOfType<NotImplementedException>();

			// Assert
			Assert.IsTrue(returnedException == null);
		}

		public void TypePropertiesAreCorrect() {
			Assert.AreEqual(typeof(NullReferenceException).FullName, "ss.NullReferenceException", "Name");
			Assert.IsTrue(typeof(NullReferenceException).IsClass, "IsClass");
			Assert.AreEqual(typeof(NullReferenceException).BaseType, typeof(Exception), "BaseType");
			object d = new NullReferenceException();
			Assert.IsTrue(d is NullReferenceException, "is NullReferenceException");
			Assert.IsTrue(d is Exception, "is Exception");

			var interfaces = typeof(NullReferenceException).GetInterfaces();
			Assert.AreEqual(interfaces.Length, 0, "Interfaces length");
		}