public void DefaultConstructorWorks()
 {
     var ex = new NotImplementedException();
     Assert.True((object)ex is NotImplementedException, "is NotImplementedException");
     Assert.AreEqual(ex.InnerException, null, "InnerException");
     Assert.AreEqual(ex.Message, "The method or operation is not implemented.");
 }

 public void TestChainTo()
 {
     var pipeline = SpatialImplementation.CurrentImplementation.CreateBuilder();
     var pipeline2 = SpatialImplementation.CurrentImplementation.CreateBuilder();
     var e = new NotImplementedException();
     SpatialTestUtils.VerifyExceptionThrown<NotImplementedException>(() => pipeline.ChainTo(pipeline2), e.Message);
 }

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

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

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

        public void moves_to_the_error_queue_if_the_exception_matches()
        {
            var handler = new MoveToErrorQueueHandler<NotImplementedException>();
            var ex = new NotImplementedException();

            handler.DetermineContinuation(null, ex).ShouldBeOfType<MoveToErrorQueue>()
                .Exception.ShouldBeTheSameAs(ex);
        }

        public void write_exception()
        {
            var ex = new NotImplementedException();

            writer.Exception(ex);

            writer.FailureCount.ShouldEqual(1);
        }

        public void BuildExceptionTitleUnhandledExceptionTest()
        {
            var innerEx = new NotImplementedException() { Source = "fakeInnerSource" };
            var ex = new System.Web.HttpUnhandledException("message", innerEx) { Source = "fakeSource" };

            var expected = "System.NotImplementedException - fakeInnerSource";
            Assert.AreEqual(expected, ExceptionsHelper.BuildExceptionTitle(ex));
        }

 public void ConstructingWithMessageAndInnerException()
 {
     Exception inner = new NotImplementedException();
       string message = "message";
       PluginSettingException ex = new PluginSettingException(message, inner);
       Assert.AreEqual(message, ex.Message);
       Assert.AreSame(inner, ex.InnerException);
 }

 public void BuildExceptionTitleInnerExceptionTest()
 {
     var innerEx = new NotImplementedException();
     var ex = new ArgumentNullException("message", innerEx) { Source = "fakeSource" };
     
     var expected = "System.ArgumentNullException - fakeSource";
     Assert.AreEqual(expected, ExceptionsHelper.BuildExceptionTitle(ex));
 }

        public void BuildExceptionStringInnerExceptionTest()
        {
            var innerEx = new NotImplementedException("fakeInnerMessage");
            var ex = new ArgumentNullException("fakeMessage", innerEx) { Source = "fakeSource" };

            var expected = "<strong>fakeMessage</strong><br /><br /><br /><br /><i><u>Inner Exception:</u></i><br /><strong>fakeInnerMessage</strong><br /><br />";
            Assert.AreEqual(expected, ExceptionsHelper.BuildExceptionString(ex));
        }

        public void BuildExceptionStringUnhandledExceptionTest()
        {
            var innerEx = new NotImplementedException("fakeMessage") { Source = "fakeInnerSource" };
            var ex = new System.Web.HttpUnhandledException("message", innerEx) { Source = "fakeSource" };

            var expected = "<strong>fakeMessage</strong><br /><br />";
            Assert.AreEqual(expected, ExceptionsHelper.BuildExceptionString(ex));
        }

        public void doesnt_Run_test_when_establish_context_fails()
        {
            var ex = new NotImplementedException();
            contextMock.Setup(x => x.Before()).Throws(ex);

            RunTest();

            testMock.Verify(x => x.Run(TestResult), Times.Never());
        }

        public void report_AfterFailure_if_excpetion_raished_during_cleanup()
        {
            var ex = new NotImplementedException();
            contextMock.Setup(x => x.After(TestResult)).Throws(ex);

            RunTest();

            testResultMock.Verify(x => x.AfterFailure(ex));
        }

        public void no_conversion_errors_but_the_action_blows_up()
        {
            var ex = new NotImplementedException();
            theLineGrammar.Execute(values, context).Throws(ex);

            afterExecuting();

            context.AssertTheOnlyResultIs(new StepResult(values.id, ResultStatus.error){error = ex.ToString(), position = thePosition});
        }

        public void ExceptionTest()
        {
            var target = new ExecutionResult<String>();
            var expected = new NotImplementedException();
            target.Exception = expected;

            target.Exception.Should()
                  .BeSameAs( expected );
        }

        public void report_BeforeFailure_if_exception_raised_when_establishing_context()
        {
            var ex = new NotImplementedException();
            contextMock.Setup(x => x.Before()).Throws(ex);

            RunTest();

            testResultMock.Verify(x => x.BeforeFailure(ex));
        }

			ReceiveCommand_When_exception_is_thrown_by_component_Then_exceptionHandler_calls_HandleException_instead_of_throwing()
		{
			var expectedException = new NotImplementedException();
			_inputProviderMock.Setup(x => x.GetLine()).Throws(expectedException);

			_application.ReadCommand();

			_exceptionHandlerMock.Verify(x => x.HandleException(expectedException), Times.Once);
		}

        public void log_exception_logs_a_result()
        {
            var exception = new NotImplementedException();
            theContext.LogException("1", exception, Stage.setup);

            var result = theContext.Results.Single().ShouldBeOfType<StepResult>();
            result.status.ShouldBe(ResultStatus.error);
            result.error.ShouldBe(exception.ToString());
            result.position.ShouldBe(Stage.setup.ToString());
        }

        public void WriteExceptionTests()
        {
            var unthrownException = new NotImplementedException("Sample Exception Message");

            Assert.DoesNotThrow(() =>
            {
                _sut.Write(unthrownException);
                _sut.Write(unthrownException, _strCategory);
            });
        }