public void Verify_ExceptionThrownAndMessageContainsExpectedStrng_DoesnThrowExpection()
        {
            var constraint = CreateConstraint(typeof(ArgumentNullException), "argument1");
            var actualException = new ArgumentNullException("argument1");

            constraint.Verify(actualException);
        }

        public void ActivateOptionsTestLogFolderSet()
        {
            string tempPath = Path.Combine(System.IO.Path.GetTempPath() + "foobar");
            if (Directory.Exists(tempPath))
            {
                Directory.Delete(tempPath, true);
            }

            LogExceptionToFileFilter filter = new LogExceptionToFileFilter();
            filter.ExceptionLogFolder = tempPath;

            filter.ActivateOptions();

            var exception = new ArgumentNullException();
            ILoggerRepository logRepository = Substitute.For<ILoggerRepository>();

            var evt = new LoggingEvent(typeof(LogExceptionToFileFilterTests), logRepository, "test logger", Level.Debug, "test message", exception);

            var filterResult = filter.Decide(evt);
            Assert.AreEqual(FilterDecision.Neutral, filterResult);

            Assert.IsTrue(evt.Properties.Contains("log4net:syslog-exception-log"), "has an exception log param");
            Assert.IsTrue(Directory.Exists(tempPath));

            Assert.IsTrue(File.Exists(evt.Properties["log4net:syslog-exception-log"].ToString()), "exception file exists");

            Directory.Delete(tempPath, true);
        }

 public void TestBackupRestoreCallbackExceptionHandling()
 {
     var ex = new ArgumentNullException();
     var test = new DatabaseFileTestHelper("database", "backup", true);
     Assert.Inconclusive("ESENT bug means instance isn't torn down correctly");
     test.TestRestoreCallbackExceptionHandling(ex);
 }

        public void Verify_ExceptionThrownMessageDoesntContainExpectedString_ThrowsException()
        {
            var constraint = CreateConstraint(typeof(ArgumentNullException), "argument1");
            var actualException = new ArgumentNullException("argument52");

            NUnit.Framework.Assert.Throws<AssertFailedException>(() => constraint.Verify(actualException));
        }

        public HttpResponseMessage Authenticate([FromBody] SystemUser user)
        {
            if (user == null)
            {
                var ex = new ArgumentNullException("user");
                return Request.CreateResponse(HttpStatusCode.InternalServerError, ex);
            }

            if ((user = SystemUser.Authenticate(user.Username, user.Password)) != null)
            {
                var authUser = new SystemUser
                {
                    Id = user.Id,
                    Username = user.Username,
                };
                authUser.GenerateAuthToken();
                ApplicationContext.AddAuthenticatedUser(authUser);

                return Request.CreateResponse(HttpStatusCode.OK, authUser);
            }
            else
            {
                return Request.CreateResponse(HttpStatusCode.Forbidden);
            }
        }

        protected AcquireTokenHandlerBase(Authenticator authenticator, TokenCache tokenCache, string resource, ClientKey clientKey, TokenSubjectType subjectType, bool callSync)
        {
            this.Authenticator = authenticator;
            this.CallState = CreateCallState(this.Authenticator.CorrelationId, callSync);
            Logger.Information(this.CallState, 
                string.Format("=== Token Acquisition started:\n\tAuthority: {0}\n\tResource: {1}\n\tClientId: {2}\n\tCacheType: {3}\n\tAuthentication Target: {4}\n\t",
                authenticator.Authority, resource, clientKey.ClientId,
                (tokenCache != null) ? tokenCache.GetType().FullName + string.Format(" ({0} items)", tokenCache.Count) : "null",
                subjectType));

            this.tokenCache = tokenCache;

            if (string.IsNullOrWhiteSpace(resource))
            {
                var ex = new ArgumentNullException("resource");
                Logger.Error(this.CallState, ex);
                throw ex;
            }

            this.Resource = (resource != NullResource) ? resource : null;
            this.ClientKey = clientKey;
            this.TokenSubjectType = subjectType;

            this.LoadFromCache = (tokenCache != null);
            this.StoreToCache = (tokenCache != null);
            this.SupportADFS = false;
        }

        public void Constructor_StoresException()
        {
            var exception = new ArgumentNullException("foo");
            var poison = new Poison<int>(42, exception);

            Assert.Equal(new ExceptionDetails(exception), poison.Exception, GenericEqualityComparer<ExceptionDetails>.ByAllMembers());
        }

        public void ExceptionMessages_are_concatenated_by_GetSafeMessage()
        {
            var inner = new InvalidOperationException();
            var outer = new ArgumentNullException("Eine Message", inner);

            Assert.Equal(outer.Message + " ---> " + inner.Message, outer.GetSafeMessage());
        }

        public void ConstructorTestFailedNoLanguage()
        {
            ArgumentNullException expected = new ArgumentNullException("language", "Provided language must not be null or empty.");
            ArgumentNullException actual = Assert.Throws<ArgumentNullException>(() => new SeriesDetails(this.testExtractionPath, string.Empty));

            Assert.Equal(expected.Message, actual.Message);
        }

        internal void Arrange()
        {
            try
            {
                this.AppointmentGroups.ToDictionary(ag => ag.GroupId);
            }
            catch (ArgumentNullException ane)
            {
                ArgumentNullException ex = new ArgumentNullException(EX_ANEMSG, ane);
                throw ex;
            }
            catch (ArgumentException ae)
            {
                ArgumentException ex = new ArgumentException(EX_AEMSG, "AppointmentGroups", ae);
                throw ex;
            }

            foreach (var group in this.AppointmentGroups)
            {
                var movedItem = group.Where(a => a.GroupId != group.GroupId).FirstOrDefault();
                if (movedItem != default(Appointment))
                {
                    group.Remove(movedItem);
                    this.AppointmentGroups.Where(g => g.GroupId == movedItem.GroupId).First().Add(movedItem);
                }
            }
        }

        public void BuildExceptionStringMessageTest()
        {
            var ex = new ArgumentNullException("", "fakeMessage") { Source = "fakeSource" };
            var expected = "<strong>myMessage</strong><br /><br /><strong>fakeMessage</strong><br /><br />";

            Assert.AreEqual(expected, ExceptionsHelper.BuildExceptionString(ex, "myMessage"));
        }

		public void ConstructorWithParamNameWorks() {
			var ex = new ArgumentNullException("someParam");
			Assert.IsTrue((object)ex is ArgumentNullException, "is ArgumentNullException");
			Assert.AreEqual(ex.ParamName, "someParam", "ParamName");
			Assert.IsTrue(ex.InnerException == null, "InnerException");
			Assert.AreEqual(ex.Message, "Value cannot be null.\nParameter name: someParam");
		}

		public void ConstructorWithParamNameAndMessageWorks() {
			var ex = new ArgumentNullException("someParam", "The message");
			Assert.IsTrue((object)ex is ArgumentNullException, "is ArgumentNullException");
			Assert.AreEqual(ex.ParamName, "someParam", "ParamName");
			Assert.IsTrue(ex.InnerException == null, "InnerException");
			Assert.AreEqual(ex.Message, "The message");
		}

        public static Assembly LoadAssembly(string assemblyPath)
        {
            Assembly assembly = null;

            try
            {
                if (WzdUtils.FAddIn == null)
                {
                    ArgumentNullException exception = new ArgumentNullException("WzdUtils.FAddIn");

                    WzdUtils.Application_ThreadException(null, new ThreadExceptionEventArgs(exception));
                }
                else
                {
                    string path = WzdUtils.GetServerPath(WzdUtils.FAddIn, true);
                    path = path.Remove(path.LastIndexOf('\\')) + assemblyPath;
                    String fullDllName = path;
                    buffer = System.IO.File.ReadAllBytes(fullDllName);
                    assembly = Assembly.Load(buffer);
                }
            }
            catch (Exception ex)
            {
                WzdUtils.Application_ThreadException(null, new ThreadExceptionEventArgs(ex));
            }

            return assembly;
        }

		public void DefaultConstructorWorks() {
			var ex = new ArgumentNullException();
			Assert.IsTrue((object)ex is ArgumentNullException, "is ArgumentNullException");
			Assert.IsTrue(ex.ParamName == null, "ParamName");
			Assert.IsTrue(ex.InnerException == null, "InnerException");
			Assert.AreEqual(ex.Message, "Value cannot be null.");
		}

 protected override void Given()
 {
     base.Given();
     _thrownException = new ArgumentNullException();
     _config = new CircuitBreakerConfig();
     _circuitBreaker = new CircuitBreaker(_config);
 }

        public static string installOrUpgrade()
        {
            //if its not configured then we can continue
            if (ApplicationContext.Current == null || ApplicationContext.Current.IsConfigured)
            {
                throw new AuthenticationException("The application is already configured");
            }

            LogHelper.Info<p>("Running 'installOrUpgrade' service");

            var result = ApplicationContext.Current.DatabaseContext.CreateDatabaseSchemaAndDataOrUpgrade();
            
            // Remove legacy umbracoDbDsn configuration setting if it exists and connectionstring also exists
            if (ConfigurationManager.ConnectionStrings[Umbraco.Core.Configuration.GlobalSettings.UmbracoConnectionName] != null)
            {
                Umbraco.Core.Configuration.GlobalSettings.RemoveSetting(Umbraco.Core.Configuration.GlobalSettings.UmbracoConnectionName);
            }
            else
            {
                var ex = new ArgumentNullException(string.Format("ConfigurationManager.ConnectionStrings[{0}]", Umbraco.Core.Configuration.GlobalSettings.UmbracoConnectionName), "Install / upgrade did not complete successfully, umbracoDbDSN was not set in the connectionStrings section");
                LogHelper.Error<p>("", ex);
                throw ex;
            }

            var js = new JavaScriptSerializer();
            var jsonResult = js.Serialize(result);
            return jsonResult;
        }

        public static bool TryOpen(this IDbConnection connection, out Exception exception)
        {
            exception = null;

            try
            {
                if (connection == null)
                {
                    exception = new ArgumentNullException("connection");
                    return false;
                }

                if (connection.State == ConnectionState.Open)
                {
                    return true;
                }

                connection.Open();

                return true;
            }
            catch (Exception ex)
            {
                exception = ex;
                return false;
            }
        }

        public void LogMessageCallbackTest()
        {
            StatusLogger.MessageLogged += MessageLoggedCallback;

            const string messageText = "Test Message";
            const string messageSource = "MessageSource";
            const MessageType messageType = MessageType.Error;
            const string innerExceptionText = "Inner Exception TEST";
            const string exceptionText = "This is an exception.";
            ArgumentNullException exception = new ArgumentNullException(exceptionText, new ArgumentException(innerExceptionText));
            Message messageToLog = new Message(messageText, messageSource, messageType, exception);

            StatusLogger.LogMessage(messageToLog);

            Assert.IsTrue(resetEvent.WaitOne(TimeoutValue));
            Assert.IsNotNull(messageReceived);
            Assert.AreEqual(messageText, messageReceived.Text);
            Assert.AreEqual(messageSource, messageReceived.Source);
            Assert.AreEqual(messageType, messageReceived.Level);
            Assert.AreEqual(exceptionText, messageReceived.Exception.Message);
            Assert.AreEqual(innerExceptionText, messageReceived.Exception.InnerException.Message);

            // Test that another message is not logged if unsubscribed
            resetEvent.Reset();
            StatusLogger.MessageLogged -= MessageLoggedCallback;
            StatusLogger.LogMessage(messageToLog);
            Assert.IsFalse(resetEvent.WaitOne(TimeoutValue));
        }

        public void TestArgumentNullException()
        {
            ArgumentNullException ex = new ArgumentNullException("testArgument", "testArgument is out of range");
            this.ExecuteExceptionHandler(ex);

            this.mockFactory.VerifyAllExpectationsHaveBeenMet();
        }