NUnit.Framework.Assert.IsFalse(bool)

[TestCase(null)]
        [TestCase("")]
        [TestCase("whatev")]
        public void TryFindByTypeNamespace_ShouldReturnFalse_AndNull_ForInvalidTypeNamespace(string typeNamespace)
        {
            replacedert.IsFalse(FilterDescriptor.TryFindByTypeNamespace(typeNamespace, out FilterDescriptor descriptor));
            replacedert.IsNull(descriptor);
        }

[Test]
		public void OkCommand_CanExecute_ShouldReturnFalse_WhenMethodNameEmpty()
		{
			//Arange
			saveMethodViewModel.SelectedPackage = "SelectedPackage";
			saveMethodViewModel.MethodName = string.Empty;
			saveMethodViewModel.SelectedIdenreplacedyKeyedName = "SelectedIdenreplacedyKeyedName";

			//Act
			bool canExecute = saveMethodViewModel.OkCommand.CanExecute(null);

			//replacedert
			replacedert.IsFalse(canExecute);
		}

[Test]
        public void Overwrite_ShouldNotFirePropChange_WhenValueHasNotChanged()
        {
            mSut.Overwrite = true;

            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.Overwrite = true;

            replacedert.IsFalse(fired);
        }

[Test]
        public void Changed_ShouldBeFalse_WhenValueDoesMatchOriginal()
        {
            XmlDoreplacedent xmlDoc = new XmlDoreplacedent();
            xmlDoc.LoadXml($"<appender name=\"{OriginalName}\" type=\"log4net.Appender.ColoredConsoleAppender\">\r\n" +
                           "</appender>");

            mSut.Load(xmlDoc.FirstChild);

            replacedert.IsFalse(mSut.Changed);
        }

[Test]
        public void TryValidate_ShouldNotSucceed_WhenFilePathIsNotSpecified()
        {
            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();
            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("A file must be replacedigned to this appender.");
        }

[TestCase("HH:mm", ":")]
        [TestCase("HH<mm", "<")]
        [TestCase("HH>mm", ">")]
        [TestCase("HH\"mm", "\"")]
        [TestCase("HH/mm", "/")]
        [TestCase("HH\\mm", "\\")]
        [TestCase("HH|mm", "|")]
        [TestCase("HH?mm", "?")]
        [TestCase("HH*mm", "*")]
        //There's a lot more here, but these are the most common
        //See https://stackoverflow.com/a/62888/7355697
        public void TryValidate_ShouldShowMessageBoxAndReturnsFalse_WhenValueHasInvalidPathChars(string value, string invalidChar)
        {
            mSut.Value = value;

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();

            replacedert.IsFalse(mSut.TryValidate(messageBoxService));

            messageBoxService.Received(1).ShowError($"Date pattern must not contain invalid characters: '{invalidChar}'");
        }

[TestCase(null)]
        [TestCase("")]
        [TestCase("whatev")]
        public void TryFindByTypeNamespace_ShouldReturnFalse_AndNull_ForInvalidTypeNamespace(string typeNamespace)
        {
            replacedert.IsFalse(AppenderDescriptor.TryFindByTypeNamespace(typeNamespace, out AppenderDescriptor descriptor));
            replacedert.IsNull(descriptor);
        }

[Test]
        public void Convert_ShouldReturnFalse_WhenSimple()
        {
            object value = mSut.Convert(LayoutDescriptor.Simple, null, null, null);

            replacedert.IsNotNull(value);
            replacedert.IsFalse((bool)value);
        }

[Test]
		public void OkCommand_CanExecute_ShouldReturnFalse_WhenSelectedIdenreplacedyKeyedNameEmpty()
		{
			//Arange
			saveMethodViewModel.SelectedPackage = "SelectedPackage";
			saveMethodViewModel.MethodName = "MethodName";
			saveMethodViewModel.SelectedIdenreplacedyKeyedName = string.Empty;

			//Act
			bool canExecute = saveMethodViewModel.OkCommand.CanExecute(null);

			//replacedert
			replacedert.IsFalse(canExecute);
		}

[Test]
        public void EquatableEquals_ShouldReturnFalse_WhenNull()
        {
            replacedert.IsFalse(Sut.Equals(null));
        }

[Test]
        public void TryValidate_ShouldNotSucceed_WhenNotInt()
        {
            mSut.Value = "str";

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();
            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("Max size roll backups must be a valid integer.");
        }

[TestCase("")]
        [TestCase(null)]
        public void TryValidate_ShouldReturnFalse_WhenPatternIsNullOrEmpty_WhenRequired(string pattern)
        {
            mSut.Pattern = pattern;

            replacedert.IsFalse(mSut.TryValidate(Subsreplacedute.For<IMessageBoxService>()));
        }

[TestCase(-2147483649)]
        [TestCase(2147483648)]
        public void TryValidate_ShouldNotValidateAnInt(long value)
        {
            NumericProperty<int> sut = CreateSut<int>();

            sut.Value = value.ToString();

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();
            replacedert.IsFalse(sut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("'Num Prop' must be a valid Int32.");
        }

[TestCase("")]
        [TestCase(null)]
        public void TryValidate_ShouldShowUnreplacedignedMessageBox_WhenValueIsNullOrEmpty_AndReturnFalse(string value)
        {
            mSut.Value = value;

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();

            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("A valid rendered clreplaced must be replacedigned.");
        }

[Test]
        public void Convert_ShouldReturnFalse_WhenValueIsNotFilterModel()
        {
            object result = mSut.Convert(new object(), null, null, null);

            replacedert.IsNotNull(result);
            replacedert.IsFalse((bool)result);
        }

[Test]
        public void Debug_ShouldBeInitializedToFalse()
        {
            replacedert.IsFalse(mSut.Debug);
        }

[Test]
        public void FilePath_ShouldNotFirePropChange_WhenValueHasNotChanged()
        {
            mSut.FilePath = "filepath";

            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.FilePath = "filepath";

            replacedert.IsFalse(fired);
        }

[Test]
		public void OkCommand_CanExecuteReturnFalse()
		{
			//Arange
			ICodeItemProvider codeItemProvider = Subsreplacedute.For<ICodeItemProvider>();
			bool usedVSFormatting = true;

			CreateCodeItemViewModel viewModel = new CreateCodeItemViewModel(codeItemProvider, usedVSFormatting);
			viewModel.FileName = string.Empty;

			//Act
			bool canExecute = viewModel.OKCommand.CanExecute(null);

			//replacedert
			replacedert.IsFalse(canExecute);
		}

[Test]
        public void TryValidate_ShouldReturnFalse_WhenValueNotSpecified()
        {
            replacedert.IsFalse(mSut.TryValidate(Subsreplacedute.For<IMessageBoxService>()));
        }

[Test]
		public void OkCommand_CanExecute_ReturnFalse()
		{
			//Act
			bool result = this.openFromArasViewModel.OkCommand.CanExecute(null);

			//replacedert
			replacedert.IsFalse(result);
		}

[Test]
        public void PatternString_ShouldNotFirePropChange_WhenValueHasNotChanged()
        {
            mSut.PatternString = true;

            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.PatternString = true;

            replacedert.IsFalse(fired);
        }

[Test]
        public void Properties_ShouldBeInitializedCorrectly()
        {
            replacedert.AreSame(mHistoricalFiles, mSut.HistoricalFiles);
            replacedert.IsNull(mSut.FilePath);
            replacedert.IsFalse(mSut.PatternString);
            replacedert.IsFalse(mSut.Overwrite);
        }

[Test]
        public void SelectedMode_ShouldNotFirePropChange_WhenValueHasNotChanged()
        {
            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.SelectedMode = mSut.SelectedMode;

            replacedert.IsFalse(fired);
        }

[Test]
        public void SelectedPreset_ShouldNotFirePropChange_WhenUnchanged()
        {
            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.SelectedPreset = mSut.SelectedPreset;

            replacedert.IsFalse(fired);
        }

[Test]
        public void EquatableEquals_ShouldReturnFalse_WhenDifferentInstance_ButStructurallyUnequal()
        {
            foreach (TSutType other in GetOthersNotEqual())
            {
                replacedert.IsFalse(Sut.Equals(other));
            }
        }

[TestCase("10kb")]
        [TestCase("10")]
        [TestCase("10Gb")]
        public void TryValidate_ShouldFail(string value)
        {
            mSut.Value = value;

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();
            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("Maximum file size must end with either \"KB\", \"MB\", or \"GB\".");
        }

[Test]
        public void Pattern_ShouldNotFirePropChange_WhenValueHasNotChanged()
        {
            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };
            mSut.Pattern = mSut.Pattern;

            replacedert.IsFalse(fired);
        }

[Test]
        public void ObjectEquals_ShouldReturnFalse_WhenDifferentInstance_ButStructurallyUnequal()
        {
            foreach (TSutType other in GetOthersNotEqual())
            {
                replacedert.IsFalse(Sut.Equals((object)other));
            }
        }

[TestCase("")]
        [TestCase(null)]
        public void TryValidate_ShouldShowUnreplacedignedMessageBox_WhenValueIsNullOrEmpty_AndReturnFalse(string value)
        {
            mSut.Value = value;

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();

            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("A name must be replacedigned to this appender.");
        }

[Test]
        public void IsReadOnly_ShouldBeFalse_RegularCtor()
        {
            mSut = new TypeAttribute();

            replacedert.IsFalse(mSut.IsReadOnly);
        }

[Test]
        public void TryValidate_ShouldShowCollisionMessageBox_WhenAppenderNameCollides()
        {
            mSut.Value = OriginalName;
            mXmlDoc.CreateElementWithAttribute("appender", "name", mSut.Value).AppendTo(mLog4NetNode);

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();

            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("Name must be unique.");
        }

[TestCase(null)]
        [TestCase("")]
        public void TryValidate_ShouldShowMessageBoxAndReturnsFalse_WhenValueIsNullOrEmpty(string value)
        {
            mSut.Value = value;

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();

            replacedert.IsFalse(mSut.TryValidate(messageBoxService));

            messageBoxService.Received(1).ShowError("A valid date pattern must be replacedigned.");
        }

[TestCase("")]
        [TestCase(null)]
        public void TryValidate_ShouldShowUnreplacedignedMessageBox_WhenValueIsNullOrEmpty_AndReturnFalse(string value)
        {
            mSut.Value = value;

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();

            replacedert.IsFalse(mSut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("A valid rendering clreplaced must be replacedigned.");
        }

[TestCase(-1)]
        [TestCase(65536)]
        public void TryValidate_ShouldNotValidateUShort(int value)
        {
            NumericProperty<ushort> sut = CreateSut<ushort>();

            sut.Value = value.ToString();

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();
            replacedert.IsFalse(sut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("'Num Prop' must be a valid UInt16.");
        }

[Test]
        public void TryCreate_ShouldReturnFalse_ForUnknownAppenders()
        {
            XmlDoreplacedent xmlDoc = new XmlDoreplacedent();
            xmlDoc.LoadXml("<log4net>" +
                           "<appender>" +
                           "</appender>" +
                           "</log4net>");

            replacedert.IsFalse(AppenderModel.TryCreate(xmlDoc.FirstChild.FirstChild, xmlDoc.FirstChild, out AppenderModel _));
        }

[TestCase(null)]
        [TestCase("<appendToFile />")]
        [TestCase("<appendToFile value=\"\" />")]
        public void Load_ShouldNotLoadNonExistentAppendToFile(string appendToFile)
        {
            XmlDoreplacedent xmlDoc = new XmlDoreplacedent();
            xmlDoc.LoadXml("<appender type=\"log4net.Appender.FileAppender\" name=\"file\">\n" +
                           $"    {appendToFile}\n" +
                           "</appender>");

            mSut.Load(xmlDoc.FirstChild);

            replacedert.IsFalse(mSut.Overwrite);
        }

[Test]
        public void Reload_ShouldLoadDefaultAttributes_WhenNonExistent()
        {
            mXmlDoc.LoadXml("<?xml version=\"1.0\" encoding=\"utf-8\"?><log4net></log4net>");
            mSut.Load();
            mSut.Reload();

            replacedert.IsFalse(mSut.Debug);
            replacedert.AreEqual(Update.Merge, mSut.Update);
            replacedert.AreEqual(Level.All, mSut.Threshold);
        }

[Test]
        public void Convert_ShouldReturnFalse_WhenNone()
        {
            object value = mSut.Convert(LayoutDescriptor.None, null, null, null);

            replacedert.IsNotNull(value);
            replacedert.IsFalse((bool)value);
        }

[Test]
		public void SetSelectedDB_ShouldSetExpectedUserNameAndFieldsEnabled()
		{
			//Arange
			this.authenticationManager.TryWindowsLogin_SetResult(true);
			this.innovatorUser.userName = "TestUserName";

			//Act
			this.loginViewModel.SelectedDatabase = "selectedDB";

			//replacedert
			replacedert.AreEqual("TestUserName", this.loginViewModel.Login);
			replacedert.IsTrue(this.loginViewModel.IsLoginEnabled);
			replacedert.IsFalse(this.loginViewModel.IsPreplacedwordEnabled);
		}

[Test]
        public void Overwrite_ShouldFirePropChange_AndChange_WhenValueHasChanged()
        {
            mSut.Overwrite = true;

            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.Overwrite = false;

            replacedert.IsTrue(fired);
            replacedert.IsFalse(mSut.Overwrite);
        }

[Test]
		public void OkCommand_CanExecute_ShouldReturnFalse_WhenSelectedPackageEmpty()
		{
			//Arange
			saveMethodViewModel.SelectedPackage = string.Empty;
			saveMethodViewModel.MethodName = "MethodName";
			saveMethodViewModel.SelectedIdenreplacedyKeyedName = "SelectedIdenreplacedyKeyedName";

			//Act
			bool canExecute = saveMethodViewModel.OkCommand.CanExecute(null);

			//replacedert
			replacedert.IsFalse(canExecute);
		}

[Test]
        public void InvalidLicenseKeyPreplacededToInit()
        {
            var licenseKey = "07C54D83E0CC806F017B369D33E755E8253E8F95";

            replacedert.Catch<VideoPlayerLicenseException>(() => FormsVideoPlayer.Init(licenseKey), "FormsVideoPlayer.Init(licenseKey)");
            replacedert.IsFalse(FormsVideoPlayer.IsInitialized, "FormsVideoPlayer.IsInitialized");
            replacedert.AreEqual(VideoPlayerLicense.LicenseType, LicenseType.Trial, "License should be in trial mode.");
        }

[Test]
		public void DeletePackageElementByNameFromPackageDefinition_NameisNull_ShouldReturnFalse()
		{
			//Arrange
			string configId = null;

			//Act
			var expected = packageManager.DeletePackageByElementIdFromPackageDefinition(configId);

			//replacedert
			replacedert.IsFalse(expected);
		}

[Test]
        public void PatternString_ShouldFirePropChange_AndChange_WhenValueHasChanged()
        {
            mSut.PatternString = true;

            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };

            mSut.PatternString = false;

            replacedert.IsTrue(fired);
            replacedert.IsFalse(mSut.PatternString);
        }

[Test]
        public void Execute_ShouldNotAddModel_AndShouldreplacedignNode_WhenModelNodeIsNotNull()
        {
            ModelBase model = new RendererModel(null);
            XmlDoreplacedent xmlDoc = new XmlDoreplacedent();
            XmlElement newElement = xmlDoc.CreateElement("element");
            model.Node = xmlDoc.CreateElement("oldElement");
            bool addCalled = false;

            ISaveStrategy sut = new AddSaveStrategy<ModelBase>(model, modelParam => { addCalled = true; }, newElement);
            sut.Execute();

            replacedert.IsFalse(addCalled);
            replacedert.AreSame(newElement, model.Node);
        }

[Test]
        public void IsInitializedStateChangesWhenCallingInit()
        {
            var initializedBeforeCallingInit = FormsVideoPlayer.IsInitialized;
            FormsVideoPlayer.Init();
            var initializedAfterCallingInit = FormsVideoPlayer.IsInitialized;

            replacedert.IsFalse(initializedBeforeCallingInit);
            replacedert.IsTrue(initializedAfterCallingInit);
            replacedert.AreEqual(VideoPlayerLicense.LicenseType, LicenseType.Trial);
        }

[TestCase(-32769)]
        [TestCase(32768)]
        public void TryValidate_ShouldNotValidateShort(int value)
        {
            NumericProperty<short> sut = CreateSut<short>();

            sut.Value = value.ToString();

            IMessageBoxService messageBoxService = Subsreplacedute.For<IMessageBoxService>();
            replacedert.IsFalse(sut.TryValidate(messageBoxService));
            messageBoxService.Received(1).ShowError("'Num Prop' must be a valid Int16.");
        }

[Test]
        public void TryValidate_ShouldCallValidate()
        {
            //Test sanity check
            replacedert.IsFalse(mValidateCalled);

            mSut.TryValidate(Subsreplacedute.For<IMessageBoxService>());

            replacedert.IsTrue(mValidateCalled);
        }

[Test]
        public void ObjectEquals_ShouldReturnFalse_WhenNull()
        {
            replacedert.IsFalse(Sut.Equals((object)null));
        }

[Test]
        public void SelectedLayout_ShouldNotFirePropChange_WhenValueHasNotChanged()
        {
            bool fired = false;
            mSut.PropertyChanged += (sender, args) => { fired = true; };
            mSut.SelectedLayout = mSut.SelectedLayout;

            replacedert.IsFalse(fired);
        }