├── .devcontainer ├── Dockerfile ├── devcontainer.json └── get-nunit-apidocs.sh ├── .github ├── ISSUE_TEMPLATE │ └── config.yml ├── linters │ └── .markdownlint.yml └── workflows │ ├── build-process.yml │ └── closed-pr.yml ├── .gitignore ├── .markdownlintrc ├── .tours └── codespaces-onboarding.tour ├── .vscode ├── extensions.json └── settings.json ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE.md ├── README.md ├── VISION.md ├── cSpell.json ├── docs ├── .gitignore ├── 404.md ├── CNAME ├── articles │ ├── developer-info │ │ ├── Best-practices-for-XML-documentation.md │ │ ├── Coding-Standards.md │ │ ├── Contributions.md │ │ ├── Issue-Tracking.md │ │ ├── Notes-Toward-NUnit-4.0.md │ │ ├── Packaging-Extensions.md │ │ ├── Packaging-the-Console-and-Engine.md │ │ ├── Packaging-the-Framework.md │ │ ├── Packaging-the-Installer.md │ │ ├── Packaging-the-V2-Adapter.md │ │ ├── Packaging-the-V3-Adapter.md │ │ ├── Packaging-the-V3-and-V4-Adapter.md │ │ ├── Team-Practices.md │ │ ├── The-Teams.md │ │ └── toc.yml │ ├── legacy │ │ └── index.md │ ├── nunit-analyzers │ │ ├── NUnit-Analyzers.md │ │ ├── NUnit1001.md │ │ ├── NUnit1002.md │ │ ├── NUnit1003.md │ │ ├── NUnit1004.md │ │ ├── NUnit1005.md │ │ ├── NUnit1006.md │ │ ├── NUnit1007.md │ │ ├── NUnit1008.md │ │ ├── NUnit1009.md │ │ ├── NUnit1010.md │ │ ├── NUnit1011.md │ │ ├── NUnit1012.md │ │ ├── NUnit1013.md │ │ ├── NUnit1014.md │ │ ├── NUnit1015.md │ │ ├── NUnit1016.md │ │ ├── NUnit1017.md │ │ ├── NUnit1018.md │ │ ├── NUnit1019.md │ │ ├── NUnit1020.md │ │ ├── NUnit1021.md │ │ ├── NUnit1022.md │ │ ├── NUnit1023.md │ │ ├── NUnit1024.md │ │ ├── NUnit1025.md │ │ ├── NUnit1026.md │ │ ├── NUnit1027.md │ │ ├── NUnit1028.md │ │ ├── NUnit1029.md │ │ ├── NUnit1030.md │ │ ├── NUnit1031.md │ │ ├── NUnit1032.md │ │ ├── NUnit1033.md │ │ ├── NUnit2001.md │ │ ├── NUnit2002.md │ │ ├── NUnit2003.md │ │ ├── NUnit2004.md │ │ ├── NUnit2005.md │ │ ├── NUnit2006.md │ │ ├── NUnit2007.md │ │ ├── NUnit2008.md │ │ ├── NUnit2009.md │ │ ├── NUnit2010.md │ │ ├── NUnit2011.md │ │ ├── NUnit2012.md │ │ ├── NUnit2013.md │ │ ├── NUnit2014.md │ │ ├── NUnit2015.md │ │ ├── NUnit2016.md │ │ ├── NUnit2017.md │ │ ├── NUnit2018.md │ │ ├── NUnit2019.md │ │ ├── NUnit2020.md │ │ ├── NUnit2021.md │ │ ├── NUnit2022.md │ │ ├── NUnit2023.md │ │ ├── NUnit2024.md │ │ ├── NUnit2025.md │ │ ├── NUnit2026.md │ │ ├── NUnit2027.md │ │ ├── NUnit2028.md │ │ ├── NUnit2029.md │ │ ├── NUnit2030.md │ │ ├── NUnit2031.md │ │ ├── NUnit2032.md │ │ ├── NUnit2033.md │ │ ├── NUnit2034.md │ │ ├── NUnit2035.md │ │ ├── NUnit2036.md │ │ ├── NUnit2037.md │ │ ├── NUnit2038.md │ │ ├── NUnit2039.md │ │ ├── NUnit2040.md │ │ ├── NUnit2041.md │ │ ├── NUnit2042.md │ │ ├── NUnit2043.md │ │ ├── NUnit2044.md │ │ ├── NUnit2045.md │ │ ├── NUnit2046.md │ │ ├── NUnit2047.md │ │ ├── NUnit2048.md │ │ ├── NUnit2049.md │ │ ├── NUnit2050.md │ │ ├── NUnit2051.md │ │ ├── NUnit2052.md │ │ ├── NUnit2053.md │ │ ├── NUnit2054.md │ │ ├── NUnit3001.md │ │ ├── NUnit3002.md │ │ ├── NUnit3003.md │ │ ├── NUnit3004.md │ │ ├── NUnit4001.md │ │ └── toc.yml │ ├── nunit-engine │ │ ├── Getting-Started.md │ │ ├── Index.md │ │ ├── Test-Engine-API.md │ │ ├── extensions │ │ │ ├── AvailableExtensions.md │ │ │ ├── Index.md │ │ │ ├── Installing-Extensions.md │ │ │ ├── creating-extensions │ │ │ │ ├── Event-Listeners.md │ │ │ │ ├── Framework-Drivers.md │ │ │ │ ├── Index.md │ │ │ │ ├── Project-Loaders.md │ │ │ │ ├── Result-Writers.md │ │ │ │ ├── Writing-Engine-Extensions.md │ │ │ │ └── toc.yml │ │ │ └── toc.yml │ │ ├── release-notes.md │ │ └── toc.yml │ ├── nunit │ │ ├── Towards-NUnit4.md │ │ ├── extending-nunit │ │ │ ├── Action-Attributes.md │ │ │ ├── Custom-Attributes.md │ │ │ ├── Custom-Constraints.md │ │ │ ├── Framework-Extensibility.md │ │ │ ├── IApplyToContext-Interface.md │ │ │ ├── IApplyToTest-Interface.md │ │ │ ├── ICommandWrapper-Interface.md │ │ │ ├── IFixtureBuilder-Interface.md │ │ │ ├── IImplyFixture-Interface.md │ │ │ ├── IParameterDataSource-Interface.md │ │ │ ├── ISimpleTestBuilder-Interface.md │ │ │ ├── ITestBuilder-Interface.md │ │ │ ├── Index.md │ │ │ └── toc.yml │ │ ├── getting-started │ │ │ ├── dotnet-core-and-dotnet-standard.md │ │ │ ├── installation.md │ │ │ ├── samples.md │ │ │ ├── toc.yml │ │ │ └── upgrading.md │ │ ├── intro.md │ │ ├── license.md │ │ ├── release-notes │ │ │ ├── Nunit4.0-MigrationGuide.md │ │ │ ├── Pre-3.5-Release-Notes.md │ │ │ ├── breaking-changes.md │ │ │ ├── framework.md │ │ │ └── toc.yml │ │ ├── running-tests │ │ │ ├── Console-Command-Line.md │ │ │ ├── Console-Runner.md │ │ │ ├── Index.md │ │ │ ├── NUnit-Test-Projects.md │ │ │ ├── NUnitLite-Options.md │ │ │ ├── NUnitLite-Runner.md │ │ │ ├── Template-Based-Test-Naming.md │ │ │ ├── Test-Selection-Language.md │ │ │ └── toc.yml │ │ ├── technical-notes │ │ │ ├── nunit-internals │ │ │ │ ├── Active-Attributes.md │ │ │ │ ├── Architectural-Overview.md │ │ │ │ ├── Attribute-Hierarchy.md │ │ │ │ ├── Framework-Api.md │ │ │ │ ├── Framework-Design.md │ │ │ │ ├── NUnit-3.0-Architecture-(2009).md │ │ │ │ ├── NUnit-APIs.md │ │ │ │ ├── NUnit-Internals.md │ │ │ │ ├── Test-Discovery-And-Execution.md │ │ │ │ ├── specs │ │ │ │ │ ├── Dynamic-Test-Cases-Spec.md │ │ │ │ │ ├── Engine-Addins-Spec.md │ │ │ │ │ ├── Extended-Constraint-Syntax-Spec.md │ │ │ │ │ ├── Include and Exclude Attributes (Alternatives).md │ │ │ │ │ ├── Include-and-Exclude-Attributes-Spec.md │ │ │ │ │ ├── Internal-Trace-Spec.md │ │ │ │ │ ├── Parameterized-Test-Fixtures-Spec.md │ │ │ │ │ ├── Specifications.md │ │ │ │ │ ├── Test-Dependency-Attribute-Spec.md │ │ │ │ │ └── toc.yml │ │ │ │ └── toc.yml │ │ │ ├── toc.yml │ │ │ └── usage │ │ │ │ ├── Addin-Replacement-in-the-Framework.md │ │ │ │ ├── Assembly-Isolation.md │ │ │ │ ├── Configuration-Files.md │ │ │ │ ├── Counting-Tests.md │ │ │ │ ├── Debugging-Support.md │ │ │ │ ├── Engine-Parallel-Test-Execution.md │ │ │ │ ├── Framework-Parallel-Test-Execution.md │ │ │ │ ├── NUnit-Project-XML-Format.md │ │ │ │ ├── Parameterized-Tests.md │ │ │ │ ├── Platform-Selection.md │ │ │ │ ├── Runtime-Selection.md │ │ │ │ ├── SetUp-and-TearDown.md │ │ │ │ ├── Test-Filters.md │ │ │ │ ├── Test-Result-XML-Format.md │ │ │ │ ├── Trace-and-Debug-Output.md │ │ │ │ ├── Usage-Notes.md │ │ │ │ ├── Visual-Studio-Support.md │ │ │ │ ├── XML-Formats.md │ │ │ │ └── toc.yml │ │ ├── toc.yml │ │ └── writing-tests │ │ │ ├── AssertionHelper.md │ │ │ ├── Assumptions.md │ │ │ ├── ListMapper.md │ │ │ ├── Randomizer-Methods.md │ │ │ ├── TestCaseData.md │ │ │ ├── TestContext.md │ │ │ ├── TestFixtureData.md │ │ │ ├── Warnings.md │ │ │ ├── assertions │ │ │ ├── assertion-models │ │ │ │ ├── classic.md │ │ │ │ ├── constraint.md │ │ │ │ ├── special.md │ │ │ │ └── toc.yml │ │ │ ├── assertions.md │ │ │ ├── classic-assertions │ │ │ │ ├── Assert.AreEqual.md │ │ │ │ ├── Assert.AreNotEqual.md │ │ │ │ ├── Assert.AreNotSame.md │ │ │ │ ├── Assert.AreSame.md │ │ │ │ ├── Assert.Catch.md │ │ │ │ ├── Assert.CatchAsync.md │ │ │ │ ├── Assert.Contains.md │ │ │ │ ├── Assert.DoesNotThrow.md │ │ │ │ ├── Assert.DoesNotThrowAsync.md │ │ │ │ ├── Assert.Fail.md │ │ │ │ ├── Assert.False.md │ │ │ │ ├── Assert.Greater.md │ │ │ │ ├── Assert.GreaterOrEqual.md │ │ │ │ ├── Assert.Ignore.md │ │ │ │ ├── Assert.Inconclusive.md │ │ │ │ ├── Assert.IsAssignableFrom.md │ │ │ │ ├── Assert.IsEmpty.md │ │ │ │ ├── Assert.IsInstanceOf.md │ │ │ │ ├── Assert.IsNaN.md │ │ │ │ ├── Assert.IsNotAssignableFrom.md │ │ │ │ ├── Assert.IsNotEmpty.md │ │ │ │ ├── Assert.IsNotInstanceOf.md │ │ │ │ ├── Assert.Less.md │ │ │ │ ├── Assert.LessOrEqual.md │ │ │ │ ├── Assert.Negative.md │ │ │ │ ├── Assert.NotNull.md │ │ │ │ ├── Assert.NotZero.md │ │ │ │ ├── Assert.Null.md │ │ │ │ ├── Assert.Pass.md │ │ │ │ ├── Assert.Positive.md │ │ │ │ ├── Assert.Throws.md │ │ │ │ ├── Assert.ThrowsAsync.md │ │ │ │ ├── Assert.True.md │ │ │ │ ├── Assert.Zero.md │ │ │ │ ├── Collection-Assert.md │ │ │ │ ├── Directory-Assert.md │ │ │ │ ├── File-Assert.md │ │ │ │ ├── String-Assert.md │ │ │ │ └── toc.yml │ │ │ ├── multiple-asserts.md │ │ │ ├── special-assertions │ │ │ │ ├── Assert.Fail.md │ │ │ │ ├── Assert.Ignore.md │ │ │ │ ├── Assert.Inconclusive.md │ │ │ │ ├── Assert.Pass.md │ │ │ │ └── toc.yml │ │ │ └── toc.yml │ │ │ ├── attributes.md │ │ │ ├── attributes │ │ │ ├── apartment.md │ │ │ ├── author.md │ │ │ ├── cancelafter.md │ │ │ ├── category.md │ │ │ ├── combinatorial.md │ │ │ ├── culture.md │ │ │ ├── datapoint.md │ │ │ ├── datapointsource.md │ │ │ ├── defaultfloatingpointtolerance.md │ │ │ ├── description.md │ │ │ ├── explicit.md │ │ │ ├── fixturelifecycle.md │ │ │ ├── ignore.md │ │ │ ├── levelofparallelism.md │ │ │ ├── maxtime.md │ │ │ ├── nonparallelizable.md │ │ │ ├── nontestassembly.md │ │ │ ├── onetimesetup.md │ │ │ ├── onetimeteardown.md │ │ │ ├── order.md │ │ │ ├── pairwise.md │ │ │ ├── parallelizable.md │ │ │ ├── platform.md │ │ │ ├── property.md │ │ │ ├── random.md │ │ │ ├── range.md │ │ │ ├── repeat.md │ │ │ ├── requiresthread.md │ │ │ ├── retry.md │ │ │ ├── sequential.md │ │ │ ├── setculture.md │ │ │ ├── setuiculture.md │ │ │ ├── setup.md │ │ │ ├── setupfixture.md │ │ │ ├── singlethreaded.md │ │ │ ├── teardown.md │ │ │ ├── test.md │ │ │ ├── testcase.md │ │ │ ├── testcasesource.md │ │ │ ├── testfixture.md │ │ │ ├── testfixturesetup.md │ │ │ ├── testfixturesource.md │ │ │ ├── testfixtureteardown.md │ │ │ ├── testof.md │ │ │ ├── theory.md │ │ │ ├── timeout.md │ │ │ ├── toc.yml │ │ │ ├── values.md │ │ │ └── valuesource.md │ │ │ ├── constraints │ │ │ ├── AllItemsConstraint.md │ │ │ ├── AndConstraint.md │ │ │ ├── AnyOfConstraint.md │ │ │ ├── AssignableFromConstraint.md │ │ │ ├── AssignableToConstraint.md │ │ │ ├── AttributeConstraint.md │ │ │ ├── AttributeExistsConstraint.md │ │ │ ├── BinarySerializableConstraint.md │ │ │ ├── CollectionContainsConstraint.md │ │ │ ├── CollectionEquivalentConstraint.md │ │ │ ├── CollectionOrderedConstraint.md │ │ │ ├── CollectionSubsetConstraint.md │ │ │ ├── CollectionSupersetConstraint.md │ │ │ ├── Constraints.md │ │ │ ├── DelayedConstraint.md │ │ │ ├── DictionaryContainsKeyConstraint.md │ │ │ ├── DictionaryContainsKeyValuePairConstraint.md │ │ │ ├── DictionaryContainsValueConstraint.md │ │ │ ├── EmptyCollectionConstraint.md │ │ │ ├── EmptyConstraint.md │ │ │ ├── EmptyDirectoryConstraint.md │ │ │ ├── EmptyStringConstraint.md │ │ │ ├── EndsWithConstraint.md │ │ │ ├── EqualConstraint.md │ │ │ ├── ExactCountConstraint.md │ │ │ ├── ExactTypeConstraint.md │ │ │ ├── FalseConstraint.md │ │ │ ├── FileOrDirectoryExistsConstraint.md │ │ │ ├── GreaterThanConstraint.md │ │ │ ├── GreaterThanOrEqualConstraint.md │ │ │ ├── InstanceOfTypeConstraint.md │ │ │ ├── LessThanConstraint.md │ │ │ ├── LessThanOrEqualConstraint.md │ │ │ ├── NaNConstraint.md │ │ │ ├── NoItemConstraint.md │ │ │ ├── NotConstraint.md │ │ │ ├── NullConstraint.md │ │ │ ├── OrConstraint.md │ │ │ ├── PropertyConstraint.md │ │ │ ├── PropertyExistsConstraint.md │ │ │ ├── RangeConstraint.md │ │ │ ├── RegexConstraint.md │ │ │ ├── ReusableConstraint.md │ │ │ ├── SameAsConstraint.md │ │ │ ├── SamePathConstraint.md │ │ │ ├── SamePathOrUnderConstraint.md │ │ │ ├── SomeItemsConstraint.md │ │ │ ├── StartsWithConstraint.md │ │ │ ├── SubPathConstraint.md │ │ │ ├── SubstringConstraint.md │ │ │ ├── ThrowsConstraint.md │ │ │ ├── ThrowsNothingConstraint.md │ │ │ ├── TrueConstraint.md │ │ │ ├── UniqueItemsConstraint.md │ │ │ ├── WhiteSpaceConstraint.md │ │ │ ├── XmlSerializableConstraint.md │ │ │ └── toc.yml │ │ │ ├── setup-teardown │ │ │ ├── SetUp-and-TearDown-Changes.md │ │ │ ├── index.md │ │ │ └── toc.yml │ │ │ └── toc.yml │ ├── toc.yml │ ├── vs-test-adapter │ │ ├── Adapter-Engine-Compatibility.md │ │ ├── Adapter-Installation.md │ │ ├── Adapter-License.md │ │ ├── Adapter-Release-Notes.html │ │ ├── Adapter-Source-Stepping.md │ │ ├── AdapterV2-Release-Notes.md │ │ ├── AdapterV3-Release-Notes.md │ │ ├── AdapterV4-Release-Notes.md │ │ ├── Debugging.md │ │ ├── Index.md │ │ ├── Known-Problems.md │ │ ├── NUnit-And-Microsoft-Test-Platform.md │ │ ├── Resources.md │ │ ├── Supported-Frameworks.md │ │ ├── Tips-And-Tricks.md │ │ ├── Trace-and-Debug.md │ │ ├── Usage.md │ │ └── toc.yml │ ├── vs-test-generator │ │ ├── TestGenerator-Installation.md │ │ ├── TestGenerator-Release-Notes-VS2015.md │ │ ├── TestGenerator-Release-Notes-VS2017-VS2019.md │ │ ├── TestGenerator-Release-Notes.md │ │ ├── Visual-Studio-Test-Generator.md │ │ └── toc.yml │ └── xamarin-runners │ │ ├── Getting-Started-in-Visual-Studio-for-Mac.md │ │ ├── Getting-Started-in-Visual-Studio.md │ │ ├── index.md │ │ └── toc.yml ├── css │ ├── img │ │ ├── bulletOff.gif │ │ └── bulletOn.gif │ └── main.css ├── custom_template │ ├── favicon.ico │ ├── logo.svg │ └── styles │ │ └── main.css ├── docfx.json ├── favicons │ ├── android-chrome-192x192.png │ ├── android-chrome-384x384.png │ ├── apple-touch-icon.png │ ├── browserconfig.xml │ ├── favicon-16x16.png │ ├── favicon-32x32.png │ ├── favicon.png │ ├── favicon.svg │ ├── manifest.json │ ├── mstile-150x150.png │ └── safari-pinned-tab.svg ├── files │ ├── Results.xsd │ ├── Summary.xslt │ └── TestResult.xml ├── filterConfig.yml ├── fonts │ └── bootstrap │ │ ├── glyphicons-halflings-regular.eot │ │ ├── glyphicons-halflings-regular.svg │ │ ├── glyphicons-halflings-regular.ttf │ │ ├── glyphicons-halflings-regular.woff │ │ └── glyphicons-halflings-regular.woff2 ├── images │ ├── AssertNull.png │ ├── IDE0002-ClassicAssert-into-Assert.png │ ├── NUnit.Analyzer-ClassicAssert-CodeFix.png │ ├── NUnit.Analyzer-ClassicAssert-Warning.png │ ├── NUnit.Analyzer-ReplaceFormatSpecification.png │ ├── TraceDebug1.png │ ├── TraceDebug2.png │ ├── console-mock.png │ ├── disable-just-my-code.png │ ├── enable-source-link-support.png │ ├── nunit-classic-asserts-fails.png │ ├── nunit-topology.png │ ├── nunit-xtp-2008.png │ ├── nunitTestAdapter.png │ ├── nunitlite-mock.png │ ├── right-click-create-tests-select-nunit.png │ └── right-click-create-tests.png ├── img │ ├── addinsDialog.jpg │ ├── advancedSettings.jpg │ ├── assembliesTab.jpg │ ├── assemblyReloadSettings.jpg │ ├── bulletOff.gif │ ├── bulletOn.gif │ ├── configEditor.jpg │ ├── console-mock.jpg │ ├── dotnetfoundation.png │ ├── generalSettings.jpg │ ├── generalTab.jpg │ ├── gui-screenshot.jpg │ ├── gui-verify.jpg │ ├── internalTraceSettings.jpg │ ├── langFilter.gif │ ├── logo.gif │ ├── miniGui.jpg │ ├── nunit.svg │ ├── nunitTestAdapter.png │ ├── nunit_128.png │ ├── nunit_dotnetfoundation.png │ ├── nunit_logo.svg │ ├── nunit_logo_128.png │ ├── projectEditorSettings.jpg │ ├── runtimeSelectionSettings.jpg │ ├── testLoadSettings.jpg │ ├── testOutputSettings.jpg │ ├── testProperties.jpg │ ├── testResultSettings.jpg │ ├── textOutputSettings.jpg │ ├── treeDisplaySettings.jpg │ ├── visualStudioSettings.jpg │ └── xmlView.jpg ├── index.md ├── js │ ├── bootstrap-sprockets.js │ ├── bootstrap.js │ ├── bootstrap.min.js │ ├── bootstrap │ │ ├── affix.js │ │ ├── alert.js │ │ ├── button.js │ │ ├── carousel.js │ │ ├── collapse.js │ │ ├── dropdown.js │ │ ├── modal.js │ │ ├── popover.js │ │ ├── scrollspy.js │ │ ├── tab.js │ │ ├── tooltip.js │ │ └── transition.js │ ├── codeFuncs.js │ ├── jquery.js │ ├── jquery.min.js │ └── jquery.min.map ├── legacy │ ├── 2.2.1 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.10 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.2 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.3 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.4 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.5 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.6 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.7 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.8 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2.9 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── stringAssert.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.2 │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── comparisonAsserts.html │ │ ├── conditionAsserts.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── contextMenu.html │ │ ├── docHome.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── features.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── optionsDialog.html │ │ ├── projectEditor.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.1 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.2 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.3 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.4 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.5 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.6 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.7 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4.8 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setCulture.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.4 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── customAsserts.html │ │ ├── customConstraints.html │ │ ├── description.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── exception.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── features.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── mainMenu.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── optionsDialog.html │ │ ├── platform.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── releaseNotes.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ └── vsSupport.html │ ├── 2.5.1 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.10 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.2 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.3 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.4 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.5 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.6 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.7 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.8 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5.9 │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.5 │ │ ├── addinsDialog.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseBreakdown.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ └── vsSupport.html │ ├── 2.6.1 │ │ ├── actionAttributes.html │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseBreakdown.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testContext.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ ├── vsSupport.html │ │ └── writingTests.html │ ├── 2.6.2 │ │ ├── actionAttributes.html │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseBreakdown.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testContext.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ ├── vsSupport.html │ │ └── writingTests.html │ ├── 2.6.3 │ │ ├── actionAttributes.html │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseBreakdown.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testContext.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ ├── vsSupport.html │ │ └── writingTests.html │ ├── 2.6.4 │ │ ├── actionAttributes.html │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── classicModel.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseBreakdown.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testContext.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ ├── vsSupport.html │ │ └── writingTests.html │ └── 2.6 │ │ ├── actionAttributes.html │ │ ├── addinsDialog.html │ │ ├── assemblyIsolation.html │ │ ├── assertions.html │ │ ├── attributes.html │ │ ├── category.html │ │ ├── collectionAssert.html │ │ ├── collectionConstraints.html │ │ ├── combinatorial.html │ │ ├── comparisonAsserts.html │ │ ├── comparisonConstraints.html │ │ ├── compoundConstraints.html │ │ ├── conditionAsserts.html │ │ ├── conditionConstraints.html │ │ ├── configEditor.html │ │ ├── configFiles.html │ │ ├── consoleCommandLine.html │ │ ├── constraintModel.html │ │ ├── contextMenu.html │ │ ├── culture.html │ │ ├── customConstraints.html │ │ ├── datapoint.html │ │ ├── datapointProviders.html │ │ ├── delayedConstraint.html │ │ ├── description.html │ │ ├── directoryAssert.html │ │ ├── docHome.html │ │ ├── equalConstraint.html │ │ ├── equalityAsserts.html │ │ ├── eventListeners.html │ │ ├── exception.html │ │ ├── exceptionAsserts.html │ │ ├── explicit.html │ │ ├── extensibility.html │ │ ├── extensionTips.html │ │ ├── fileAssert.html │ │ ├── fixtureSetup.html │ │ ├── fixtureTeardown.html │ │ ├── getStarted.html │ │ ├── guiCommandLine.html │ │ ├── identityAsserts.html │ │ ├── ignore.html │ │ ├── installation.html │ │ ├── license.html │ │ ├── listMapper.html │ │ ├── mainMenu.html │ │ ├── maxtime.html │ │ ├── multiAssembly.html │ │ ├── nunit-agent.html │ │ ├── nunit-console.html │ │ ├── nunit-gui.html │ │ ├── nunitAddins.html │ │ ├── pairwise.html │ │ ├── parameterizedTests.html │ │ ├── pathConstraints.html │ │ ├── platform.html │ │ ├── pnunit.html │ │ ├── projectEditor.html │ │ ├── property.html │ │ ├── propertyConstraint.html │ │ ├── quickStart.html │ │ ├── quickStartSource.html │ │ ├── random.html │ │ ├── range.html │ │ ├── releaseBreakdown.html │ │ ├── releaseNotes.html │ │ ├── repeat.html │ │ ├── requiredAddin.html │ │ ├── requiresMTA.html │ │ ├── requiresSTA.html │ │ ├── requiresThread.html │ │ ├── reusableConstraint.html │ │ ├── runningTests.html │ │ ├── runtimeSelection.html │ │ ├── sameasConstraint.html │ │ ├── samples.html │ │ ├── sequential.html │ │ ├── setCulture.html │ │ ├── setUICulture.html │ │ ├── settingsDialog.html │ │ ├── setup.html │ │ ├── setupFixture.html │ │ ├── stringAssert.html │ │ ├── stringConstraints.html │ │ ├── suite.html │ │ ├── suiteBuilders.html │ │ ├── teardown.html │ │ ├── test.html │ │ ├── testCase.html │ │ ├── testCaseSource.html │ │ ├── testContext.html │ │ ├── testDecorators.html │ │ ├── testFixture.html │ │ ├── testProperties.html │ │ ├── testcaseBuilders.html │ │ ├── testcaseProviders.html │ │ ├── theory.html │ │ ├── throwsConstraint.html │ │ ├── timeout.html │ │ ├── typeAsserts.html │ │ ├── typeConstraints.html │ │ ├── upgrade.html │ │ ├── utilityAsserts.html │ │ ├── valueSource.html │ │ ├── values.html │ │ ├── vsSupport.html │ │ └── writingTests.html ├── snippets │ ├── .gitignore │ ├── Snippets.NUnit │ │ ├── AssertThrows.cs │ │ ├── AssertThrowsAsync.cs │ │ ├── Assumptions.cs │ │ ├── Attributes │ │ │ ├── AuthorAttributeExamples.cs │ │ │ ├── TestCaseAttributeExamples.cs │ │ │ └── TestFixtureAttributeExamples.cs │ │ ├── ClassicVsConstraintAssertions.cs │ │ ├── MultipleAsserts.cs │ │ ├── Snippets.NUnit.csproj │ │ ├── TestCaseDataExample.cs │ │ ├── TestCaseSourceExamples.cs │ │ ├── TestFixtureDataExample.cs │ │ └── WarningExamples.cs │ ├── Snippets.NUnitLite │ │ ├── GlobalUsings.cs │ │ ├── Program.cs │ │ ├── Snippets.NUnitLite.csproj │ │ └── UnitTest1.cs │ ├── Snippets.sln │ ├── Snippets.v3.ncrunchsolution │ ├── naming.runsettings │ └── nuget.config ├── styles │ └── main.js └── toc.yml ├── nunit.vssettings ├── renovate.json └── tools └── AddH1s.ps1 /.devcontainer/devcontainer.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "nunit-docs", 3 | "build": { 4 | "dockerfile": "Dockerfile" 5 | }, 6 | "forwardPorts": [8080], 7 | "customizations": { 8 | "vscode": { 9 | "extensions": [ 10 | "streetsidesoftware.code-spell-checker", 11 | "oderwat.indent-rainbow", 12 | "mdickin.markdown-shortcuts", 13 | "davidanson.vscode-markdownlint", 14 | "redhat.vscode-yaml", 15 | "vsls-contrib.codetour", 16 | "GitHub.vscode-pull-request-github", 17 | "shuworks.vscode-table-formatter", 18 | "ms-dotnettools.csharp", 19 | "github.vscode-github-actions", 20 | "ms-azuretools.vscode-docker", 21 | "stkb.rewrap" 22 | ] 23 | } 24 | } 25 | } -------------------------------------------------------------------------------- /.devcontainer/get-nunit-apidocs.sh: -------------------------------------------------------------------------------- 1 | # This script gets the the latest version of NUnit and extracts it. This is because docfx is capable of generating API docs, and this way the Codespace will be automatically enabled to do that. 2 | 3 | # This is hard-coded for now. 4 | NUNIT_VERSION_FOR_API_DOCS="4.3.2" 5 | 6 | first_workspace="$(cd /workspaces && ls | head -1)" 7 | 8 | wget "https://github.com/nunit/nunit/releases/download/$NUNIT_VERSION_FOR_API_DOCS/NUnit.Framework-$NUNIT_VERSION_FOR_API_DOCS.zip" -O /apidocs.zip 9 | 10 | 11 | mkdir -p /workspaces/$first_workspace/code-output 12 | unzip -o /apidocs.zip -d /apidocs 13 | cp -r /apidocs/bin/net8.0/* /workspaces/$first_workspace/code-output 14 | rm -rf /apidocs.zip 15 | rm -rf /apidocs -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/config.yml: -------------------------------------------------------------------------------- 1 | blank_issues_enabled: true 2 | contact_links: 3 | - name: Test Framework Issue 4 | url: https://github.com/nunit/nunit/issues/new 5 | about: For issues encountered when using the test framework (and not specifically with documentation) 6 | - name: Console Runner Issue 7 | url: https://github.com/nunit/nunit-console/issues/new 8 | about: For issues encountered when using the console runner (and not specifically with documentation) 9 | - name: VS Test Adapter 10 | url: https://github.com/nunit/nunit3-vs-adapter/issues/new 11 | about: For issues encountered when using the NUnit Visual Studio Test Adapter (and not specifically with documentation) 12 | - name: Issue while using another NUnit project / component (and not specifically with documentation) 13 | url: https://github.com/nunit#org-repositories 14 | about: Please find the appropriate repository at this list and file an issue there. 15 | - name: Definitely docs-related 16 | url: https://github.com/nunit/docs/issues/new 17 | about: We'd love to hear about it! 18 | 19 | 20 | -------------------------------------------------------------------------------- /.github/linters/.markdownlint.yml: -------------------------------------------------------------------------------- 1 | --- 2 | ########################### 3 | ########################### 4 | ## Markdown Linter rules ## 5 | ########################### 6 | ########################### 7 | 8 | # Linter rules doc: 9 | # - https://github.com/DavidAnson/markdownlint 10 | # 11 | # Note: 12 | # To comment out a single error: 13 | # 14 | # any violations you want 15 | # 16 | # 17 | 18 | ############### 19 | # Rules by id # 20 | ############### 21 | MD024: false 22 | MD013: false 23 | MD026: false 24 | MD046: false # Mix of indented and fenced code blocks 25 | MD004: false 26 | # MD004: false # Unordered list style 27 | # MD007: 28 | # indent: 2 # Unordered list indentation 29 | # MD013: 30 | # line_length: 808 # Line length 31 | # MD026: 32 | # punctuation: ".,;:!。，；:" # List of not allowed 33 | # MD029: false # Ordered list item prefix 34 | # MD033: false # Allow inline HTML 35 | # MD036: false # Emphasis used instead of a heading 36 | 37 | ################# 38 | # Rules by tags # 39 | ################# 40 | # blank_lines: false # Error on blank lines 41 | -------------------------------------------------------------------------------- /.github/workflows/closed-pr.yml: -------------------------------------------------------------------------------- 1 | on: 2 | pull_request: 3 | types: [ closed ] 4 | jobs: 5 | prune: 6 | permissions: 7 | deployments: write 8 | runs-on: ubuntu-latest 9 | steps: 10 | - name: delete environment 11 | uses: bobheadxi/deployments@v1 12 | with: 13 | step: delete-env 14 | token: ${{ secrets.SEAN_PAT_TO_MANAGE_ENVIRONMENTS }} 15 | env: preview_${{github.event.number}} 16 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | code-output/ -------------------------------------------------------------------------------- /.markdownlintrc: -------------------------------------------------------------------------------- 1 | { 2 | "MD024": false, 3 | "MD013": false, 4 | "MD026": false, 5 | "MD046": false, 6 | "MD004": false 7 | } -------------------------------------------------------------------------------- /.vscode/extensions.json: -------------------------------------------------------------------------------- 1 | { 2 | // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations. 3 | // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp 4 | 5 | // List of extensions which should be recommended for users of this workspace. 6 | "recommendations": [ 7 | "streetsidesoftware.code-spell-checker", 8 | "oderwat.indent-rainbow", 9 | "mdickin.markdown-shortcuts", 10 | "davidanson.vscode-markdownlint", 11 | "redhat.vscode-yaml", 12 | "vsls-contrib.codetour", 13 | "GitHub.vscode-pull-request-github", 14 | "shuworks.vscode-table-formatter", 15 | "ms-dotnettools.csharp", 16 | "github.vscode-github-actions", 17 | "ms-azuretools.vscode-docker", 18 | "stkb.rewrap" 19 | ], 20 | // List of extensions recommended by VS Code that should not be recommended for users of this workspace. 21 | "unwantedRecommendations": [ 22 | 23 | ] 24 | } -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "cSpell.words": [ 3 | "Linq", 4 | "addin", 5 | "addins", 6 | "intellisense", 7 | "langword", 8 | "nunit", 9 | "NUnit", 10 | "paramref", 11 | "typeparam", 12 | "typeparamref", 13 | "wiki" 14 | ], 15 | "cSpell.enabled": true, 16 | "cSpell.enableFiletypes": [ 17 | "aspnetcorerazor" 18 | ], 19 | "editor.wordWrap": "wordWrapColumn", 20 | "editor.wrappingIndent": "same", 21 | "editor.wordWrapColumn": 120, 22 | "editor.rulers": [120], 23 | "editor.codeActionsOnSave": { 24 | "source.fixAll.markdownlint": "always" 25 | } 26 | } -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Code of Conduct 2 | 3 | This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. 4 | 5 | For more information, see the [.NET Foundation Code of Conduct](https://dotnetfoundation.org/code-of-conduct). 6 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2021 NUnit.org 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /docs/.gitignore: -------------------------------------------------------------------------------- 1 | ##################### 2 | # NUNit Specific # 3 | ##################### 4 | _exported_templates 5 | # ignored because we auto-generate it at build time rather than locally 6 | /api/*.yml 7 | /api/*.manifest 8 | 9 | # Because they are ignored at the root level of the source but are needed here. 10 | !/images** 11 | 12 | 13 | ############### 14 | # folder # 15 | ############### 16 | /**/DROP/ 17 | /**/TEMP/ 18 | /**/packages/ 19 | /**/bin/ 20 | /**/obj/ 21 | _site 22 | -------------------------------------------------------------------------------- /docs/404.md: -------------------------------------------------------------------------------- 1 | # Page Not Found 2 | 3 | We're sorry, but the page you're looking for cannot be found on the site. 4 | 5 | Feel free to [Open an issue in the NUnit Docs GitHub Repository](https://github.com/nunit/docs/issues/new) with the URL 6 | or content you expected to exist, and we'll be happy to look into it. 7 | -------------------------------------------------------------------------------- /docs/CNAME: -------------------------------------------------------------------------------- 1 | docs.nunit.org -------------------------------------------------------------------------------- /docs/articles/developer-info/Notes-Toward-NUnit-4.0.md: -------------------------------------------------------------------------------- 1 | # Notes Toward NUnit 4.0 2 | 3 | This page describes plans for the next major releases of NUnit, focusing on major changes we expect to make. 4 | 5 | Also see [Towards NUnit 4](xref:towardsnunit4) for more details on the changes. 6 | 7 | ## Extensions 8 | 9 | With the release of nunit3-console 4.0, we intend to stop distributing the **teamcity-event-listener** bundled with the 10 | console as a standard extension. We will continue to support the `--teamcity` option in the console runner when the 11 | extension is installed separately by the user. 12 | 13 | ## API possibilities 14 | 15 | 16 | -------------------------------------------------------------------------------- /docs/articles/developer-info/Packaging-the-V3-Adapter.md: -------------------------------------------------------------------------------- 1 | --- 2 | redirect_url: ./Packaging-the-V3-and-V4-Adapter.html 3 | --- 4 | -------------------------------------------------------------------------------- /docs/articles/developer-info/Team-Practices.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: teampractices 3 | --- 4 | 5 | # Team Practices 6 | 7 | ## How We Work As a Team 8 | 9 | ||| 10 | |--- |--- | 11 | |[Issue Tracking](Issue-Tracking.md)|How we track bugs, enhancements and features on GitHub.| 12 | |[Contributions](Contributions.md)|Explains how to review and merge code submitted by other developers.| 13 | 14 | ## Technical Practices 15 | 16 | ||| 17 | |--- |--- | 18 | |Building and testing|See BUILDING.md in each repository.| 19 | |[Coding Standards](Coding-Standards.md)|Describes coding standards used in NUnit.| 20 | |[Best practices for XML documentation](Best-practices-for-XML-documentation.md)|Guidelines to consider when dealing with public APIs.| 21 | |[Packaging the Framework](Packaging-the-Framework.md)|How to create the packages for a new NUnit Framework release.| 22 | |[Packaging the Console and Engine](Packaging-the-Console-and-Engine.md)|How to create the packages for a new NUnit Console and Engine release.| 23 | |[Packaging Extensions](Packaging-Extensions.md)|How to create the packages and release NUnit Extensions.| 24 | |[Packaging the Installer](Packaging-the-Installer.md)|How to create and release the NUnit MSI Installer.| 25 | |[Packaging the V2 Adapter](Packaging-the-V2-Adapter.md)|How to create the packages for a new NUnit 2 VS Adapter release.| 26 | |[Packaging the V3 Adapter](Packaging-the-V3-and-V4-Adapter.md)|How to create the packages for a new NUnit 3 VS Adapter release.| 27 | -------------------------------------------------------------------------------- /docs/articles/developer-info/toc.yml: -------------------------------------------------------------------------------- 1 | - name: The Teams 2 | href: The-Teams.md 3 | - name: Team Practices 4 | href: Team-Practices.md 5 | - name: Specifications 6 | topicUid: specifications 7 | - name: Notes Toward NUnit 4.0 8 | href: Notes-Toward-NUnit-4.0.md 9 | - name: Best Practices for XML Documentation 10 | href: Best-practices-for-XML-documentation.md 11 | - name: Coding Standards 12 | href: Coding-Standards.md 13 | - name: Contributions 14 | href: Contributions.md 15 | - name: Issue Tracking 16 | href: Issue-Tracking.md 17 | - name: Packaging Extensions 18 | href: Packaging-Extensions.md 19 | - name: Packaging the Console and Engine 20 | href: Packaging-the-Console-and-Engine.md 21 | - name: Packaging the Framework 22 | href: Packaging-the-Framework.md 23 | - name: Packaging the Installer 24 | href: Packaging-the-Installer.md 25 | - name: Packaging the V2 Adapter 26 | href: Packaging-the-V2-Adapter.md 27 | - name: Packaging the V3/V4 Adapter 28 | href: Packaging-the-V3-and-V4-Adapter.md 29 | -------------------------------------------------------------------------------- /docs/articles/nunit-engine/Index.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: nunitengine 3 | --- 4 | 5 | # NUnit Engine 6 | 7 | The NUnit Engine is the component used as the foundation of any test runner. It contains all the logic required to run 8 | tests built against both NUnit 3.X and other frameworks, and exposes an API allowing test runners to interact with the 9 | engine and run tests as required. 10 | 11 | > [!NOTE] 12 | > The NUnit Engine is a component targeted at advanced users of NUnit, who are building their own test runner, 13 | > rather than using one of the many existing test runners in the ecosystem. If you are looking to simply run tests that 14 | > you have written, see the [running tests](xref:runningtests) section. 15 | 16 | The engine exposes [an API](xref:testengineapi) designed to be used by test runners, which will be maintained in a 17 | backwards-compatible fashion wherever possible. The engine also hosts various extension points, to allow further 18 | customization. 19 | -------------------------------------------------------------------------------- /docs/articles/nunit-engine/extensions/Index.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: engineextensionsindex 3 | --- 4 | 5 | # NUnit Engine Extensions 6 | 7 | NUnit has [several extensions to the engine currently available](xref:availableengineextensions). 8 | 9 | We've also made it possible to [create your own](xref:creatingengineextensionsindex). 10 | 11 | Once you obtain or create an extension, you'll need to [install the extension into the engine](xref:installingextensions). 12 | -------------------------------------------------------------------------------- /docs/articles/nunit-engine/extensions/creating-extensions/Index.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: creatingengineextensionsindex 3 | --- 4 | 5 | # Creating Engine Extensions 6 | 7 | The NUnit Test Engine uses a plugin architecture that allows users and third parties to add new functionality to the 8 | engine. The extensibility model defines a number of Extension Points to which Extensions may be added. 9 | 10 | There are currently four extension points: 11 | 12 | * [Project Loaders](Project-Loaders.md) 13 | * [Result Writers](Result-Writers.md) 14 | * [Framework Drivers](Framework-Drivers.md) 15 | * [Event Listeners](Event-Listeners.md) 16 | 17 | Extensions are generally created in their own assemblies, with some shared characteristics described in [Writing Engine 18 | Extensions](xref:writingengineextensions). They then need to be installed to the engine, which is covered in [Installing 19 | Engine Extensions](xref:installingextensions). 20 | -------------------------------------------------------------------------------- /docs/articles/nunit-engine/extensions/creating-extensions/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Introduction 2 | href: Index.md 3 | - name: Writing Engine Extensions 4 | href: Writing-Engine-Extensions.md 5 | - name: Event Listener Extensions 6 | href: Event-Listeners.md 7 | - name: Framework Driver Extensions 8 | href: Framework-Drivers.md 9 | - name: Project Loader Extensions 10 | href: Project-Loaders.md 11 | - name: Result Writer Extensions 12 | href: Result-Writers.md 13 | -------------------------------------------------------------------------------- /docs/articles/nunit-engine/extensions/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Introduction 2 | href: Index.md 3 | - name: Available Engine Extensions 4 | href: AvailableExtensions.md 5 | - name: Installing Engine Extensions 6 | href: Installing-Extensions.md 7 | - name: Creating Engine Extensions 8 | href: creating-extensions/toc.yml 9 | topicHref: creating-extensions/Index.md 10 | -------------------------------------------------------------------------------- /docs/articles/nunit-engine/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Introduction 2 | href: Index.md 3 | - name: Getting Started 4 | href: Getting-Started.md 5 | - name: Test Engine API 6 | href: Test-Engine-API.md 7 | - name: Engine Extensions 8 | href: extensions/toc.yml 9 | topicHref: extensions/Index.md 10 | - name: Release Notes 11 | href: release-notes.md 12 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/Framework-Extensibility.md: -------------------------------------------------------------------------------- 1 | # Framework Extensibility 2 | 3 | The NUnit Framework is the part of NUnit that is referenced by user tests. It contains the definition of all of NUnit's 4 | Attributes, Constraints and Asserts as well as the code that discovers and executes tests. Most extensions to exactly 5 | how tests are recognized and how they execute are Framework extensions. 6 | 7 | In this documentation, we refer to three different types of Framework extension: 8 | 9 | [Custom Attributes](Custom-Attributes.md) allow creation of new types of tests and suites, new sources of data and 10 | modification of the environment in which a test runs as well as its final result. 11 | 12 | [Action Attributes](Action-Attributes.md) are an NUnit V2 feature, still supported in NUnit 3. They were designed to 13 | better enable composability of test logic by creating attributes that encapsulate specific actions to be taken before or 14 | after a test is run. For most work, [Custom Attributes](Custom-Attributes.md) are the way to go, but [Action 15 | Attributes](Action-Attributes.md) continue to be the only way to apply an attribute at a higher level and have it apply 16 | to many tests. 17 | 18 | [Custom Constraints](Custom-Constraints.md) allow the user to define new constraints for use in tests along with the 19 | associated fluent syntax that allows them to be used with `Assert.That`. 20 | 21 | ## Links to Blog Posts 22 | 23 | ### On Custom constraints 24 | 25 | [How to extend the NUnit constraints](https://hermit.no/how-to-extend-the-nunit-constraints/) 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/IApplyToContext-Interface.md: -------------------------------------------------------------------------------- 1 | # IApplyToContext Interface 2 | 3 | NUnit tests run within a context, known as the `TestExecutionContext`. The context for a test case is nested within the 4 | context for its containing suite and so on, up to the assembly level. Attributes that implement `IApplyToContext` are 5 | called immediately after the context is created and before the test is run in order to make changes to the context. Once 6 | the test execution has completed, the context is discarded so that - effectively - any changes are reverted to their 7 | original values. 8 | 9 | The `IApplyToContext` interface is defined as follows: 10 | 11 | ```csharp 12 | public interface IApplyToContext 13 | { 14 | void ApplyToContext(TestExecutionContext context); 15 | } 16 | ``` 17 | 18 | An example of the use of the context may be helpful. One item in the `TestExecutionContext` is the default timeout value 19 | for test cases. When any test is marked with `[Timeout(nnn)]` the context value is replaced by the supplied argument. 20 | The new timeout applies for any test case it appears on and any test case that is contained in a suite that it appears 21 | on. When the test or suite completes, the new value is discarded and the value contained in the original context is once 22 | against used. 23 | 24 | Custom attributes that implement `IApplyToContext` should modify the TestExecutionContext in accordance with the 25 | arguments supplied to them. They are not called after the test is run and have no cleanup to perform. 26 | 27 | The NUnit attributes that implement `IApplyToContext` are as follows: 28 | 29 | * `DefaultFloatingPointToleranceAttribute` 30 | * `ParallelizableAttribute` 31 | * `SetCultureAttribute` 32 | * `SetUICultureAttribute` 33 | * `SingleThreadedAttribute` 34 | * `TimeoutAttribute` 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/ICommandWrapper-Interface.md: -------------------------------------------------------------------------------- 1 | # ICommandWrapper Interface 2 | 3 | In NUnit 3, test execution is done using command objects, which are constructed for each test case. Execution of a 4 | single test case will generally require multiple nested commands. Some attributes placed on a test method are able to 5 | contribute to the chain of commands. For example, `MaxTimeAttribute` adds a command, which examines the elapsed time to 6 | complete a test and fails it if a specified maximum was exceeded. 7 | 8 | Attributes add to the command chain by implementing one of the two interfaces that derive from the `ICommandWrapper` 9 | interface. The interfaces are defined as follows: 10 | 11 | ```csharp 12 | public interface ICommandWrapper 13 | { 14 | TestCommand Wrap(TestCommand command); 15 | } 16 | 17 | public interface IWrapTestMethod : ICommandWrapper 18 | { 19 | } 20 | 21 | public interface IWrapSetUpTearDown : ICommandWrapper 22 | { 23 | } 24 | ``` 25 | 26 | Attributes should __not__ implement the `ICommandWrapper` interface directly but should select one of the derived 27 | interfaces. NUnit applies the `IWrapSetUpTearDown` interface before SetUp and after TearDown. It applies the 28 | `IWrapTestMethod` interface after SetUp and before the test is run. 29 | 30 | Attributes implementing one of these interfaces must be placed on a test method. Otherwise, they have no effect. The 31 | `Wrap` method should return an appropriate command in which the original command has been nested. For an example, see 32 | the implementation of `MaxTimeAttribute`. 33 | 34 | The following NUnit attributes implement the `IWrapSetUpTearDown` interface: 35 | 36 | * `MaxTimeAttribute` 37 | * `RepeatAttribute` 38 | * `RetryAttribute` 39 | 40 | The `IWrapTestMethod`interface is not currently used by any NUnit attributes. 41 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/IFixtureBuilder-Interface.md: -------------------------------------------------------------------------------- 1 | # IFixtureBuilder Interface 2 | 3 | This interface is used by attributes that know how to build a fixture from a user class. `IFixtureBuilder` is defined as 4 | follows: 5 | 6 | ```csharp 7 | public interface IFixtureBuilder 8 | { 9 | TestSuite BuildFrom(ITypeInfo type); 10 | } 11 | ``` 12 | 13 | Custom fixture builders should examine the provided `ITypeInfo` and return an appropriate type of fixture based on it. 14 | If the fixture is intended to be an NUnit `TestFixture`, then the helper class `NUnitTestFixtureBuilder` may be used to 15 | create it. 16 | 17 | The following NUnit attributes currently implement this interface: 18 | 19 | * `TestFixtureAttribute` 20 | * `TestFixtureSourceAttribute` 21 | * `SetUpFixtureAttribute` 22 | 23 | **Notes:** 24 | 25 | 1. `ITypeInfo` is an internal interface used by NUnit to wrap a Type. See [source 26 | code](https://github.com/nunit/nunit/blob/master/src/NUnitFramework/framework/Interfaces/ITypeInfo.cs) for details. 27 | 28 | 2. It would make more sense for this interface method to return `TestFixture` rather than `TestSuite`. We use 29 | `TestSuite` because it is the common base for both `TestFixture` and `SetupFixture`. In a future version, we will try 30 | to adjust the hierarchy so that all suites based on a class are derived from `TestFixture`. 31 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/IImplyFixture-Interface.md: -------------------------------------------------------------------------------- 1 | # IImplyFixture Interface 2 | 3 | The `IImplyFixture` interface is an empty interface, used solely as a marker: 4 | 5 | ```csharp 6 | public interface IImplyFixture 7 | { 8 | } 9 | ``` 10 | 11 | If a class contains any method with an attribute that implements this interface, that class is treated as an NUnit 12 | TestFixture without any `TestFixture` attribute being specified. The following NUnit attributes currently implement this 13 | interface: 14 | 15 | * `TestAttribute` 16 | * `TestCaseAttribute` 17 | * `TestCaseSourceAttribute` 18 | * `TheoryAttribute` 19 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/IParameterDataSource-Interface.md: -------------------------------------------------------------------------------- 1 | # IParameterDataSource Interface 2 | 3 | The `IParameterDataSource` interface is implemented by attributes that provide data for use as an argument to a single 4 | parameter. Other attributes and test builders combine the values in various ways to produce test cases. The interface is 5 | defined as follows: 6 | 7 | ```csharp 8 | public interface IParameterDataSource 9 | { 10 | IEnumerable GetData(IParameterInfo parameter); 11 | } 12 | ``` 13 | 14 | `IParameterInfo` is an NUnit internal class used to wrap a `ParameterInfo`. See the [source 15 | code](https://github.com/nunit/nunit/blob/master/src/NUnitFramework/framework/Interfaces/IParameterInfo.cs) for more 16 | info. 17 | 18 | A custom attribute implementing this interface should examine the `IParameterInfo` and return data values that are 19 | compatible with the parameter. The attribute has no control over how this data is combined with other arguments - that's 20 | up to other attributes and ultimately NUnit itself. 21 | 22 | The following NUnit attributes currently implement `IParameterDataSource`: 23 | 24 | * `RandomAttribute` 25 | * `ValuesAttribute`, with the derived class 26 | * `RangeAttribute` 27 | * `ValueSourceAttribute` 28 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/ISimpleTestBuilder-Interface.md: -------------------------------------------------------------------------------- 1 | # ISimpleTestBuilder 2 | 3 | This interface is used by attributes that know how to build a single, non-parameterized test from a `MethodInfo`. 4 | `ISimpleTestBuilder` is defined as follows: 5 | 6 | ```csharp 7 | public interface ISimpleTestBuilder 8 | { 9 | TestMethod BuildFrom(IMethodInfo method, Test suite); 10 | } 11 | ``` 12 | 13 | `IMethodInfo` is an NUnit internal class used to wrap a `MethodInfo`. See the [source 14 | code](https://github.com/nunit/nunit/blob/master/src/NUnitFramework/framework/Interfaces/IMethodInfo.cs) for more info. 15 | The `suite` argument is the test suite that contains the method in question. 16 | 17 | Custom attributes implementing `ISimpleTestFixture` should examine the IMethodInfo provided and return a single 18 | `TestMethod` instance, as appropriate to that method. The BuildFrom method should never return null, even if the 19 | specified method is not valid for a test. In that case, it should return a `TestMethod` with a RunState of NonRunnable, 20 | in order to provide feedback to the user who placed the attribute on the method. 21 | 22 | NUnit treats attributes implementing this interface specially. They are ignored if any other attributes are present that 23 | implement `ITestBuilder`. This allows, for example, use of `[Test]` on a method that also has `[Combinatorial]` 24 | specified, without any error arising. Such usage has existed in NUnit for some time and this special handling of the 25 | interface allows us to preserve it. 26 | 27 | In the current build, only `TestAttribute` implements this interface. 28 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/ITestBuilder-Interface.md: -------------------------------------------------------------------------------- 1 | # ITestBuilder Interface 2 | 3 | This interface is used by attributes that know how to build one or more parameterized `TestMethod` instances from a 4 | `MethodInfo`. `ITestMethodBuilder` is defined as follows: 5 | 6 | ```csharp 7 | public interface ITestBuilder 8 | { 9 | IEnumerable BuildFrom(IMethodInfo method, Test suite); 10 | } 11 | ``` 12 | 13 | `IMethodInfo` is an NUnit internal class used to wrap a MethodInfo. See the [source 14 | code](https://github.com/nunit/nunit/blob/master/src/NUnitFramework/framework/Interfaces/IMethodInfo.cs) for more info. 15 | The `suite` argument is the test suite that contains the method in question. 16 | 17 | A custom attribute implementing this interface should examine the IMethodInfo and return as many `TestMethod` instances 18 | as it is able to construct, using the parameters available to it. Some attributes will only return a single test, just 19 | as `TestCaseAttribute` does. Others, working like `TheoryAttribute` may return multiple tests. If no data is available 20 | to create tests, an empty collection should be returned. 21 | 22 | If the returned tests are standard NUnit TestMethods, the helper class `NUnitTestCaseBuilder` may be used to create 23 | them. 24 | 25 | The following NUnit attributes currently implement `ITestBuilder`: 26 | 27 | * `CombiningStrategyAttribute`, with the following derived classes: 28 | * `CombinatorialAttribute` 29 | * `PairwiseAttribute` 30 | * `SequentialAttribute` 31 | * `TestCaseAttribute` 32 | * `TestCaseSourceAttribute` 33 | * `TheoryAttribute` 34 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/Index.md: -------------------------------------------------------------------------------- 1 | # Extending NUnit 2 | 3 | NUnit is intended to be extensible. We can't do everything for everybody but we want to make it reasonably easy to 4 | extend NUnit. In many cases, users will be able to implement a special feature outside of our scope by simply creating a 5 | new attribute that embeds the required logic. In other cases, particularly in extending the engine, we rely on a 6 | plugin-architecture. 7 | 8 | ## Types of Extensibility 9 | 10 | * [Framework Extensibility](Framework-Extensibility.md) 11 | * [Engine Extensibility](xref:engineextensionsindex) 12 | -------------------------------------------------------------------------------- /docs/articles/nunit/extending-nunit/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Engine Extensibility 2 | xref: engineextensionsindex 3 | - name: Framework Extensibility 4 | href: Framework-Extensibility.md 5 | items: 6 | - name: Action Attributes 7 | href: Action-Attributes.md 8 | - name: Custom Attributes 9 | href: Custom-Attributes.md 10 | items: 11 | - name: IApplyToContext Interface 12 | href: IApplyToContext-Interface.md 13 | - name: IApplyToTest Interface 14 | href: IApplyToTest-Interface.md 15 | - name: ICommandWrapper Interface 16 | href: ICommandWrapper-Interface.md 17 | - name: IFixtureBuilder Interface 18 | href: IFixtureBuilder-Interface.md 19 | - name: IImplyFixture Interface 20 | href: IImplyFixture-Interface.md 21 | - name: IParameterDataSource Interface 22 | href: IParameterDataSource-Interface.md 23 | - name: ISimpleTestBuilder Interface 24 | href: ISimpleTestBuilder-Interface.md 25 | - name: ITestBuilder Interface 26 | href: ITestBuilder-Interface.md 27 | - name: Custom Constraints 28 | href: Custom-Constraints.md 29 | 30 | -------------------------------------------------------------------------------- /docs/articles/nunit/getting-started/samples.md: -------------------------------------------------------------------------------- 1 | # Samples 2 | 3 | Samples of NUnit usage are available in each of the languages listed below. 4 | 5 | * [C# Samples](https://github.com/nunit/nunit-csharp-samples) 6 | * [VB.NET Samples](https://github.com/nunit/nunit-vb-samples) 7 | * [F# Samples](https://github.com/nunit/nunit-fsharp-samples) 8 | * [C++ Samples](https://github.com/nunit/nunit-cpp-samples) 9 | -------------------------------------------------------------------------------- /docs/articles/nunit/getting-started/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Installation 2 | href: installation.md 3 | - name: Upgrading 4 | href: upgrading.md 5 | - name: Samples 6 | href: samples.md 7 | - name: Breaking Changes 8 | topicUid: breakingchanges 9 | - name: .NET Core and .NET Standard 10 | href: dotnet-core-and-dotnet-standard.md 11 | -------------------------------------------------------------------------------- /docs/articles/nunit/intro.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: intro 3 | --- 4 | 5 | # NUnit Documentation 6 | 7 | This documentation covers NUnit 3.0 and higher. 8 | 9 | Where applicable, we have marked sections with the version in which a feature first appeared. 10 | 11 | If you are new to NUnit, we suggest you begin by reading the Getting Started section of this site. Those who have used 12 | earlier releases may want to begin with the Upgrading section. 13 | 14 | See the [Release Notes](xref:frameworkreleasenotes) for more information on each release. 15 | -------------------------------------------------------------------------------- /docs/articles/nunit/license.md: -------------------------------------------------------------------------------- 1 | # NUnit License 2 | 3 | ## Copyright (c) 2004-2021 Charlie Poole, Rob Prouse and Contributors. 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /docs/articles/nunit/release-notes/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Framework 2 | href: framework.md 3 | - name: Console and Engine 4 | topicUid: consoleenginereleasenotes 5 | - name: Migration Guidance 6 | topicUid: migrationguidance 7 | - name: Breaking Changes 8 | topicUid: breakingchanges 9 | - name: Pre-3.5 Release notes 10 | href: Pre-3.5-Release-Notes.md -------------------------------------------------------------------------------- /docs/articles/nunit/running-tests/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Console Runner 2 | href: Console-Runner.md 3 | - name: Console Command Line 4 | href: Console-Command-Line.md 5 | - name: NUnit Test Projects 6 | href: NUnit-Test-Projects.md 7 | - name: NUnitLite Runner 8 | href: NUnitLite-Runner.md 9 | - name: NUnitLite Options 10 | href: NUnitLite-Options.md 11 | - name: Template Based Test Naming 12 | href: Template-Based-Test-Naming.md 13 | - name: Test Selection Language 14 | href: Test-Selection-Language.md -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/nunit-internals/NUnit-Internals.md: -------------------------------------------------------------------------------- 1 | # NUnit Internals 2 | 3 | * [Architectural Overview](Architectural-Overview.md) 4 | * [NUnit APIs](NUnit-APIs.md) 5 | * [Test Engine API](xref:testengineapi) 6 | * [Framework Driver API](xref:frameworkdrivers) 7 | * [Framework API](Framework-Api.md) 8 | * [Framework Design](Framework-Design.md) 9 | * [Active Attributes](Active-Attributes.md) 10 | * [Attribute Hierarchy](Attribute-Hierarchy.md) 11 | * [Test Discovery And Execution](Test-Discovery-And-Execution.md) 12 | * [Engine Extensibility](xref:engineextensionsindex) 13 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/nunit-internals/specs/Specifications.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: specifications 3 | --- 4 | 5 | # Specifications 6 | 7 | > [!NOTE] 8 | > Some of these items are actually implemented in the latest release. We are in the process of reviewing all the 9 | > specs in this section to determine what needs to be converted into actual documentation pages. 10 | 11 | Specifications are descriptions of work we are doing or plan to do. They may vary in degree of specificity and the 12 | actual code may sometimes deviate from the spec as work progresses, without necessarily going back to change the spec. 13 | When the work is done, the spec is removed from the site or incorporated into a tech note as needed. 14 | 15 | | Component | Title | Implemented? | 16 | |-----------------|--------------------------------------------|----------------| 17 | | **General** | [Internal Trace Spec](Internal-Trace-Spec.md) | Partial? | 18 | | **Framework** | [Include and Exclude Attributes Spec](Include-and-Exclude-Attributes-Spec.md) | No | 19 | | | [Extended Constraint Syntax Spec](Extended-Constraint-Syntax-Spec.md) | No | 20 | | | [Dynamic Test Cases Spec](Dynamic-Test-Cases-Spec.md) | No | 21 | | | [Parameterized Test Fixtures Spec](Parameterized-Test-Fixtures-Spec.md) | Partial | 22 | | | [Test Dependency Attribute Spec](Test-Dependency-Attribute-Spec.md) | No | 23 | | **Test Engine** | [Engine Addins Spec](Engine-Addins-Spec.md) | Partial | 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/nunit-internals/specs/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Specifications 2 | href: Specifications.md 3 | - name: Dynamic Test Cases Spec 4 | href: Dynamic-Test-Cases-Spec.md 5 | - name: Engine Addins Spec 6 | href: Engine-Addins-Spec.md 7 | - name: Extended Constraint Syntax Spec 8 | href: Extended-Constraint-Syntax-Spec.md 9 | - name: Include and Exclude Attributes (Alternatives) 10 | href: Include and Exclude Attributes (Alternatives).md 11 | - name: Internal Trace Spec 12 | href: Internal-Trace-Spec.md 13 | - name: Parameterized Test Fixtures Spec 14 | href: Parameterized-Test-Fixtures-Spec.md 15 | - name: Test Dependency Attribute Spec 16 | href: Test-Dependency-Attribute-Spec.md -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/nunit-internals/toc.yml: -------------------------------------------------------------------------------- 1 | - name: NUnit Internals 2 | href: NUnit-Internals.md 3 | - name: Architectural Overview 4 | href: Architectural-Overview.md 5 | - name: NUnit APIs 6 | href: NUnit-APIs.md 7 | items: 8 | - name: Test Engine API 9 | xref: testengineapi 10 | - name: Engine Driver API 11 | xref: frameworkdrivers 12 | - name: Framework API 13 | href: Framework-Api.md 14 | - name: Framework Design 15 | href: Framework-Design.md 16 | - name: Active Attributes 17 | href: Active-Attributes.md 18 | - name: Attribute Hierarchy 19 | href: Attribute-Hierarchy.md 20 | - name: Test Discovery And Execution 21 | href: Test-Discovery-And-Execution.md 22 | - name: NUnit 3.0 Architecture (2009) 23 | href: NUnit-3.0-Architecture-(2009).md 24 | - name: Specifications 25 | href: specs/toc.yml 26 | topicHref: specs/Specifications.md -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Usage Notes 2 | href: usage/toc.yml 3 | topicHref: usage/Usage-Notes.md 4 | - name: NUnit Internals 5 | href: nunit-internals/toc.yml 6 | topicHref: nunit-internals/NUnit-Internals.md 7 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/Assembly-Isolation.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: assemblyisolation 3 | --- 4 | 5 | # Assembly Isolation 6 | 7 | NUnit isolates test assemblies from its own code and from one another 8 | by use of separate Processes and AppDomains. 9 | 10 | By default, NUnit loads each test assembly into a separate **Process** 11 | under the control of the NUnit Agent 12 | program. This allows NUnit to ensure that each assembly is loaded in the environment 13 | for which it was built. Within the agent process, NUnit's own code runs in the primary 14 | **AppDomain** while the tests run in a separate **AppDomain**. 15 | 16 | If desired, multiple test assemblies may be loaded into the same process and 17 | even the same domain by use of the **-process** and **-domain** command-line 18 | options. See [Console Command Line](xref:consolecommandline). 19 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/Configuration-Files.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: configurationfiles 3 | --- 4 | 5 | # Configuration Files 6 | 7 | Normally, a configuration file used to provide settings or to control the environment 8 | in which tests are run, should be given the name as the assembly file with the 9 | suffix ".config" added. For example, the configuration file used to run nunit.tests.dll must 10 | be named nunit.tests.dll.config and located in the same directory as the dll. 11 | 12 | **Notes:** 13 | 14 | 1. When multiple assemblies are specified in an NUnit project (file extension `.nunit`), 15 | it is possible to specify a common config file for the included test assemblies. 16 | 17 | 2. When multiple assemblies are specified on the command-line using the `--domain:Single` 18 | option, no config file is currently used. 19 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/Debugging-Support.md: -------------------------------------------------------------------------------- 1 | # Debugging Support 2 | 3 | This document describes framework functionality for debugging support of tests and tested code. 4 | 5 | ## `ThrowOnEachFailureUnderDebugger` Setting 6 | 7 | (From version 4.2.0) 8 | 9 | Setting name defined by `FrameworkPackageSettings.ThrowOnEachFailureUnderDebugger` constant. 10 | It may sometimes be necessary to debug the current state of a test during an `Assertion.Multiple` block. Typically, 11 | assertion exceptions are thrown only after the block is completed. 12 | 13 | This boolean framework setting will cause the debugger to throw on a failed assertion during an `Assert.Multiple` 14 | block. This allows user to break execution on exception and inspect tested code state 15 | at time of failure. 16 | 17 | Because this behavior is useful only for debugging, it is not activated without an attached debugger 18 | (`Debugger.IsAttached = true`). 19 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/Platform-Selection.md: -------------------------------------------------------------------------------- 1 | # Platform Selection 2 | 3 | If your tests are compiled x86 or x64, NUnit will run each assembly 4 | by default in a process targeted at the appropriate platform as well as 5 | the targeted runtime. If you run multiple assemblies in the same process, 6 | you may not mix x86 and x64 assemblies. 7 | 8 | On an x64 machine, if your test assembly is compiled x86, you **must not** 9 | use **/process=Single** on the command line. This is because NUnit is already 10 | running in a 64-bit process and will fail when it tries to load your assembly 11 | into the same process. 12 | 13 | If your test assembly references any x86 or x64 assemblies, it should be built 14 | for the same platform. Consequently, you may not mix x86 and x64 references. 15 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/Runtime-Selection.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: runtimeselection 3 | --- 4 | 5 | # Runtime Selection 6 | 7 | By default, NUnit runs tests under the runtime version for which the test 8 | assembly was built, provided it is available on the test machine. If it is not available, 9 | NUnit runs the assembly under the best available runtime that will allow it to run. If 10 | no suitable runtime can be found, an error is reported. 11 | 12 | ## Overriding the Defaults 13 | 14 | The default runtime framework may be overridden using command line options. 15 | In all cases, NUnit will attempt to honor the options given, issuing an 16 | error message if the assembly cannot be loaded. 17 | See [Console Command Line](xref:consolecommandline) for more information. 18 | 19 | * The **/framework** option of console runner allows you to specify 20 | the framework type and version to be used for a test run. When this option 21 | is used, NUnit will attempt to run the tests under the framework specified 22 | even if the assembly targets a different runtime. 23 | * The **/process:Single** command-line option indicates that tests should 24 | be run in the NUnit process itself. This forces usage of the runtime under which 25 | NUnit is already running. 26 | * The **process:Separate** causes a single separate process to be used 27 | for all assemblies. In this case, NUnit will use the highest level runtime targeted 28 | by any of the assemblies, if it is available. 29 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/Usage-Notes.md: -------------------------------------------------------------------------------- 1 | # Usage Notes 2 | 3 | * [Runtime Selection](Runtime-Selection.md) 4 | * [Platform Selection](Platform-Selection.md) 5 | * [Assembly Isolation](Assembly-Isolation.md) 6 | * [Configuration Files](Configuration-Files.md) 7 | * [XML Formats](XML-Formats.md) 8 | * [Visual Studio Support](Visual-Studio-Support.md) 9 | * [SetUp and TearDown](SetUp-and-TearDown.md) 10 | * [Parameterized Tests](Parameterized-Tests.md) 11 | * [Addin Replacement in the Framework](Addin-Replacement-in-the-Framework.md) 12 | * [Counting Tests](Counting-Tests.md) 13 | * [Framework Parallel Test Execution](Framework-Parallel-Test-Execution.md) 14 | * [Engine Parallel Test Execution](Engine-Parallel-Test-Execution.md) 15 | -------------------------------------------------------------------------------- /docs/articles/nunit/technical-notes/usage/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Usage Notes 2 | href: Usage-Notes.md 3 | - name: Addin Replacement in the Framework 4 | href: Addin-Replacement-in-the-Framework.md 5 | - name: Assembly Isolation 6 | href: Assembly-Isolation.md 7 | - name: Configuration Files 8 | href: Configuration-Files.md 9 | - name: Counting Tests 10 | href: Counting-Tests.md 11 | - name: Debugging Support 12 | href: Debugging-Support.md 13 | - name: Engine Parallel Test Execution 14 | href: Engine-Parallel-Test-Execution.md 15 | - name: Framework Parallel Test Execution 16 | href: Framework-Parallel-Test-Execution.md 17 | - name: NUnit Project XML Format 18 | href: NUnit-Project-XML-Format.md 19 | - name: Parameterized Tests 20 | href: Parameterized-Tests.md 21 | - name: Platform Selection 22 | href: Platform-Selection.md 23 | - name: Runtime Selection 24 | href: Runtime-Selection.md 25 | - name: SetUp and TearDown 26 | href: SetUp-and-TearDown.md 27 | - name: Test Filters 28 | href: Test-Filters.md 29 | - name: Test Result XML Format 30 | href: Test-Result-XML-Format.md 31 | - name: Trace and Debug Output 32 | href: Trace-and-Debug-Output.md 33 | - name: Visual Studio Support 34 | href: Visual-Studio-Support.md 35 | - name: XML Formats 36 | href: XML-Formats.md -------------------------------------------------------------------------------- /docs/articles/nunit/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Introduction 2 | href: intro.md 3 | - name: NUnit 4 plans 4 | href: Towards-NUnit4.md 5 | - name: Migration Guidance 6 | uid: migrationguidance 7 | - name: Release Notes 8 | href: release-notes/toc.yml 9 | topicHref: release-notes/framework.md 10 | - name: License 11 | href: license.md 12 | - name: Getting Started 13 | href: getting-started/toc.yml 14 | topicHref: getting-started/installation.md 15 | - name: Writing Tests 16 | href: writing-tests/toc.yml 17 | topicHref: writing-tests/attributes.md 18 | - name: Running Tests 19 | href: running-tests/toc.yml 20 | topicHref: running-tests/Index.md 21 | - name: Extending NUnit 22 | href: extending-nunit/toc.yml 23 | topicHref: extending-nunit/Index.md 24 | - name: Technical Notes 25 | href: technical-notes/toc.yml 26 | topicHref: technical-notes/usage/Usage-Notes.md 27 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/AssertionHelper.md: -------------------------------------------------------------------------------- 1 | # Assertion Helper 2 | 3 | > AssertionHelper has been deprecated as of NUnit Framework 3.7. The syntax is now maintained and being enhanced as an 4 | > independent library, [NUnit.StaticExpect](https://github.com/fluffynuts/NUnit.StaticExpect). 5 | 6 | Some users prefer a shorter form of assertion than is given by Assert.That. If you derive your test fixture class from 7 | **AssertionHelper**, the Expect() method may be used instead... 8 | 9 | ```csharp 10 | Expect(bool condition); 11 | Expect(bool condition, string message, params object[] params); 12 | 13 | Expect(ActualValueDelegate del, IResolveConstraint constraint) 14 | Expect(ActualValueDelegate del, IResolveConstraint constraint, 15 | string message, params object[] params) 16 | 17 | Expect(TActual actual, IResolveConstraint constraint) 18 | Expect(TActual actual, IResolveConstraint constraint, 19 | string message, params object[] params) 20 | 21 | Expect(TestDelegate del, IResolveConstraint constraint); 22 | ``` 23 | 24 | In addition, **AssertionHelper** allows the derived class to make direct use of many of the syntactic elements that 25 | would normally require you to specify the **Is**, **Has** or **Does** class in order to use them. For example, you can 26 | write... 27 | 28 | ```csharp 29 | Expect(actual, EqualTo("Hello")); 30 | ``` 31 | 32 | Use Intellisense to determine which syntactic elements are available in the current release. 33 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/Assumptions.md: -------------------------------------------------------------------------------- 1 | # Assumptions 2 | 3 | Assumptions are intended to express the state a test must be in to provide a meaningful result. They are functionally 4 | similar to assertions, however an unmet assumption will produce an `Inconclusive` test result, as opposed to a 5 | `Failure`. 6 | 7 | Assumptions make use of the `Assume` static class. 8 | 9 | ## Syntax Example 10 | 11 | [!code-csharp[AssumptionsTests](~/snippets/Snippets.NUnit/Assumptions.cs#TestThatUsesAssume)] 12 | 13 | `Assume.That()` has the same set of overloads as `Assert.That()`. For further details, see the [Constraint 14 | Model](xref:constraintmodel) documentation. 15 | 16 | > [!NOTE] 17 | > Failing assumptions indicate that running tests is invalid, while [Multiple Asserts](xref:multipleasserts) 18 | > allow testing to continue after a failure. For that reason, the two features are incompatible and assumptions may not 19 | > be used within a [multiple assert](xref:multipleasserts) block. 20 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/ListMapper.md: -------------------------------------------------------------------------------- 1 | # ListMapper 2 | 3 | > [!IMPORTANT] 4 | > > ListMapper has been deprecated as of NUnit Framework 3.13.2. The functionality was removed in NUnit Framework 4.0. 5 | 6 | Unlike Constraint classes, `ListMapper` is used to modify the actual 7 | value argument to `Assert.That()`. It transforms the actual value, which 8 | must be a collection, creating a new collection to be tested against the 9 | supplied constraint. Currently, `ListMapper` supports one transformation: creating 10 | a collection of property values. 11 | 12 | Normally, `ListMapper` will be used through the `List.Map()` syntax helper. The following example 13 | shows two forms of the same assert. 14 | 15 | ```csharp 16 | string[] strings = new string[] { "a", "ab", "abc" }; 17 | int[] lengths = new int[] { 1, 2, 3 }; 18 | 19 | Assert.That(List.Map(strings).Property("Length"), 20 | Is.EqualTo(lengths)); 21 | 22 | Assert.That(new ListMapper(strings).Property("Length"), 23 | Is.EqualTo(lengths)); 24 | ``` 25 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/TestCaseData.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: testcasedata 3 | --- 4 | 5 | # TestCaseData 6 | 7 | The `TestCaseData` class provides extended test case information for a parameterized test, although any object deriving 8 | from `TestCaseParameters` may be used. Unlike NUnit 2, you cannot implement `ITestCaseData`, you must derive from 9 | `TestCaseParameters`. 10 | 11 | [!code-csharp[TestCaseDataExample](~/snippets/Snippets.NUnit/TestCaseDataExample.cs#TestCaseDataExample)] 12 | 13 | This example uses the fluent interface supported by **TestCaseData** to make the program more readable. 14 | 15 | **TestCaseData** supports the following properties and methods, which may be appended to an instance in any order. 16 | 17 | * **Explicit()** or **Explicit(string)** causes the test case to be marked explicit, optionally specifying the reason 18 | for doing so. 19 | * **Ignore(string)** causes the test case to be ignored and specifies the reason, which is required. 20 | * **Returns** specifies the expected result to be returned from the method, which must have a compatible return type. 21 | * **SetArgDisplayNames(string[])** sets the list of display names to use as the parameters in the test name. 22 | * **SetCategory(string)** applies a category to the test. 23 | * **SetDescription(string)** sets the description property of the test. 24 | * **SetName(string)** provides a name for the test. If not specified, a name is generated based on the method name and 25 | the arguments provided. See [Template Based Test Naming](xref:templatebasedtestnaming). 26 | * **SetProperty(string, string)**, **SetProperty(string, int)** and **SetProperty(string, double)** apply a named 27 | property and value to the test. 28 | * **TypeArgs** specifies the `Type`s to be used when targeting a generic test method. (_NUnit 4.1+_) 29 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/TestFixtureData.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: testfixturedata 3 | --- 4 | 5 | # TestFixtureData 6 | 7 | The `TestFixtureData` class provides specific instance information for a parameterized fixture, although any object 8 | deriving from `TestFixtureParameters` may be used. Unlike NUnit 2, you cannot implement `IFixtureData`, you must derive 9 | from `TestFixtureParameters`. 10 | 11 | The following example varies the example shown under [TestFixture Attribute](xref:testfixtureattribute) by using a 12 | `TestFixtureSourceAttribute` with a data source in a separately defined class. 13 | 14 | [!code-csharp[TestFixtureDataExample](~/snippets/Snippets.NUnit/TestFixtureDataExample.cs#TestFixtureDataExample)] 15 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/Warnings.md: -------------------------------------------------------------------------------- 1 | # Warnings 2 | 3 | Sometimes - especially in integration testing - it's desirable to give a warning message but continue execution. 4 | Beginning with release 3.6, NUnit supports this with the `Warn` class and the `Assert.Warn` method. 5 | 6 | ## Syntax 7 | 8 | [!code-csharp[WarningExamples](~/snippets/Snippets.NUnit/WarningExamples.cs#WarningExamples)] 9 | 10 | Each of the above items would fail. The test would continue to execute, however, and the warning messages would only be 11 | reported at the end of the test. If the test subsequently fails, the warnings will be reported along with the failure 12 | message or - in the case of `Assert.Multiple` - messages. 13 | 14 | All of the overloads above also have a variant that accepts a function, `Func`, that is used to build the 15 | message included with the Exception. 16 | 17 | > [!NOTE] 18 | > The framework reports warnings by including information about them in the XML result that is sent to the 19 | > runner in use. If you are using this facility, make sure the runner you use supports warnings. Generally, the runners 20 | > released by the NUnit team after the release of the 3.6 framework will have this support. Earlier releases will not. 21 | > Many third party runners will not know what to do with warnings either. 22 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/assertion-models/special.md: -------------------------------------------------------------------------------- 1 | 2 | # Special Assertions 3 | 4 | The special assertions do not check any condition. They are used for special purposes, like unconditional failure or 5 | success, ignoring a test, etc. 6 | 7 | * [Assert.Pass](../special-assertions/Assert.Pass.md) 8 | * [Assert.Fail](../special-assertions/Assert.Fail.md) 9 | * [Assert.Ignore](../special-assertions/Assert.Ignore.md) 10 | * [Assert.Inconclusive](../special-assertions/Assert.Inconclusive.md) 11 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/assertion-models/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Constraint Model (Assert.That) 2 | href: constraint.md 3 | - name: Special Asserts 4 | href: special.md 5 | - name: Classic Model 6 | href: classic.md 7 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreNotEqual.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.AreNotEqual 2 | 3 | **ClassicAssert.AreNotEqual** tests whether the two arguments are unequal. 4 | 5 | ```csharp 6 | ClassicAssert.AreNotEqual(object expected, object actual); 7 | ClassicAssert.AreNotEqual(object expected, object actual, 8 | string message, params object[] params); 9 | ``` 10 | 11 | See [ClassicAssert.AreEqual](Assert.AreEqual.md) for details of how NUnit performs equality comparisons. 12 | 13 | ## See Also 14 | 15 | * [ClassicAssert.AreEqual](Assert.AreEqual.md) 16 | * [Equal Constraint](xref:equalconstraint) 17 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreNotSame.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.AreNotSame 2 | 3 | **ClassicAssert.AreNotSame** tests that the two arguments do not reference the same object. 4 | 5 | ```csharp 6 | ClassicAssert.AreNotSame(object expected, object actual); 7 | ClassicAssert.AreNotSame(object expected, object actual, 8 | string message, params object[] params); 9 | ``` 10 | 11 | ## See Also 12 | 13 | * [SameAs Constraint](xref:sameasconstraint) 14 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.AreSame.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.AreSame 2 | 3 | **ClassicAssert.AreSame** tests that the two arguments reference the same object. 4 | 5 | ```csharp 6 | ClassicAssert.AreSame(object expected, object actual); 7 | ClassicAssert.AreSame(object expected, object actual, 8 | string message, params object[] params); 9 | ``` 10 | 11 | ## See Also 12 | 13 | * [SameAs Constraint](xref:sameasconstraint) 14 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Catch.md: -------------------------------------------------------------------------------- 1 | # Assert.Catch 2 | 3 | **Assert.Catch** is similar to **Assert.Throws** but will pass for an exception 4 | that is derived from the one specified. 5 | 6 | ```csharp 7 | Exception Assert.Catch(TestDelegate code); 8 | Exception Assert.Catch(TestDelegate code, 9 | string message, params object[] params); 10 | 11 | Exception Assert.Catch(Type expectedExceptionType, TestDelegate code); 12 | Exception Assert.Catch(Type expectedExceptionType, TestDelegate code, 13 | string message, params object[] params); 14 | 15 | T Assert.Catch(TestDelegate code); 16 | T Assert.Catch(TestDelegate code, 17 | string message, params object[] params); 18 | ``` 19 | 20 | ## See Also 21 | 22 | * [Assert.CatchAsync](Assert.CatchAsync.md) 23 | * [Assert.Throws](Assert.Throws.md) 24 | * [Assert.ThrowsAsync](Assert.ThrowsAsync.md) 25 | * [ThrowsConstraint](xref:throwsconstraint) 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.CatchAsync.md: -------------------------------------------------------------------------------- 1 | # Assert.CatchAsync 2 | 3 | **Assert.CatchAsync** is similar to [Assert.ThrowsAsync](Assert.ThrowsAsync.md) but will pass for an exception 4 | that is derived from the one specified. 5 | 6 | ```csharp 7 | Exception Assert.CatchAsync(AsyncTestDelegate code); 8 | Exception Assert.CatchAsync(AsyncTestDelegate code, 9 | string message, params object[] params); 10 | 11 | Exception Assert.CatchAsync(Type expectedExceptionType, AsyncTestDelegate code); 12 | Exception Assert.CatchAsync(Type expectedExceptionType, AsyncTestDelegate code, 13 | string message, params object[] params); 14 | 15 | T Assert.CatchAsync(AsyncTestDelegate code); 16 | T Assert.CatchAsync(AsyncTestDelegate code, 17 | string message, params object[] params); 18 | ``` 19 | 20 | ## See Also 21 | 22 | * [Assert.Catch](Assert.Catch.md) 23 | * [Assert.Throws](Assert.Throws.md) 24 | * [Assert.ThrowsAsync](Assert.ThrowsAsync.md) 25 | * [ThrowsConstraint](xref:throwsconstraint) 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Contains.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.Contains 2 | 3 | **ClassicAssert.Contains** is used to test whether an object is contained in a 4 | collection. 5 | 6 | ```csharp 7 | ClassicAssert.Contains(object anObject, ICollection collection); 8 | ClassicAssert.Contains(object anObject, ICollection collection, 9 | string message, params object[] params); 10 | ``` 11 | 12 | ## See Also 13 | 14 | * [CollectionContainsConstraint](xref:collectioncontainsconstraint) 15 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.DoesNotThrow.md: -------------------------------------------------------------------------------- 1 | # Assert.DoesNotThrow 2 | 3 | **Assert.DoesNotThrow** verifies that the delegate provided as an argument 4 | does not throw an exception. See [Assert.DoesNotThrowAsync](Assert.DoesNotThrowAsync.md) for asynchronous code. 5 | 6 | ```csharp 7 | void Assert.DoesNotThrow(TestDelegate code); 8 | void Assert.DoesNotThrow(TestDelegate code, 9 | string message, params object[] params); 10 | ``` 11 | 12 | ## See Also 13 | 14 | * [Assert.Throws](Assert.Throws.md) 15 | * [ThrowsConstraint](xref:throwsconstraint) 16 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.DoesNotThrowAsync.md: -------------------------------------------------------------------------------- 1 | # Assert.DoesNotThrowAsync 2 | 3 | **Assert.DoesNotThrowAsync** verifies that the delegate provided as an argument 4 | does not throw an exception. See [Assert.DoesNotThrow](Assert.DoesNotThrow.md) for synchronous code. 5 | 6 | ```csharp 7 | void Assert.DoesNotThrowAsync(AsyncTestDelegate code); 8 | void Assert.DoesNotThrowAsync(AsyncTestDelegate code, 9 | string message, params object[] params); 10 | ``` 11 | 12 | ## See Also 13 | 14 | * [Assert.ThrowsAsync](Assert.ThrowsAsync.md) 15 | * [ThrowsConstraint](xref:throwsconstraint) 16 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Fail.md: -------------------------------------------------------------------------------- 1 | --- 2 | redirect_url: ../special-assertions/Assert.Fail.html 3 | --- -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.False.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.False 2 | 3 | **ClassicAssert.False** and **ClassicAssert.IsFalse** test that the specified condition is false. 4 | The two forms are provided for compatibility with past versions of NUnit and 5 | NUnitLite. 6 | 7 | ```csharp 8 | ClassicAssert.False(bool condition); 9 | ClassicAssert.False(bool condition, string message, params object[] params); 10 | 11 | ClassicAssert.IsFalse(bool condition); 12 | ClassicAssert.IsFalse(bool condition, string message, params object[] params); 13 | ``` 14 | 15 | ## See Also 16 | 17 | * [Condition Constraints](xref:constraints#condition-constraints) 18 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Ignore.md: -------------------------------------------------------------------------------- 1 | --- 2 | redirect_url: ../special-assertions/Assert.Ignore.html 3 | --- -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Inconclusive.md: -------------------------------------------------------------------------------- 1 | --- 2 | redirect_url: ../special-assertions/Assert.Inconclusive.html 3 | --- -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsAssignableFrom.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsAssignableFrom 2 | 3 | **ClassicAssert.IsAssignableFrom** succeeds if the object provided may be assigned a value of the expected type. 4 | 5 | ```csharp 6 | ClassicAssert.IsAssignableFrom(Type expected, object actual); 7 | ClassicAssert.IsAssignableFrom(Type expected, object actual, 8 | string message, params object[] params); 9 | ClassicAssert.IsAssignableFrom(object actual); 10 | ClassicAssert.IsAssignableFrom(object actual, 11 | string message, params object[] params); 12 | ``` 13 | 14 | ## See Also 15 | 16 | * [Type Constraints](xref:constraints#type-constraints) 17 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsEmpty.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsEmpty 2 | 3 | **ClassicAssert.IsEmpty** may be used to test either a string or a collection or IEnumerable. When used with a string, 4 | it succeeds if the string is the empty string. When used with a collection, it succeeds if the collection is empty. 5 | 6 | ```csharp 7 | ClassicAssert.IsEmpty(string aString); 8 | ClassicAssert.IsEmpty(string aString, string message, params object[] args); 9 | 10 | ClassicAssert.IsEmpty(IEnumerable collection); 11 | ClassicAssert.IsEmpty(IEnumerable collection, string message, 12 | params object[] args); 13 | ``` 14 | 15 | > [!NOTE] 16 | > When used with an IEnumerable that is not also an ICollection, **ClassicAssert.IsEmpty** attempts to enumerate 17 | > the contents. It should not be used in cases where this results in an unwanted side effect. 18 | 19 | ## See Also 20 | 21 | * [Condition Constraints](xref:constraints#condition-constraints) 22 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsInstanceOf.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsInstanceOf 2 | 3 | **ClassicAssert.IsInstanceOf** succeeds if the object provided as an actual value is an instance of the expected type. 4 | 5 | ```csharp 6 | ClassicAssert.IsInstanceOf(Type expected, object actual); 7 | ClassicAssert.IsInstanceOf(Type expected, object actual, 8 | string message, params object[] params); 9 | ClassicAssert.IsInstanceOf(object actual); 10 | ClassicAssert.IsInstanceOf(object actual, 11 | string message, params object[] params); 12 | ``` 13 | 14 | ## See Also 15 | 16 | * [Type Constraints](xref:constraints#type-constraints) 17 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNaN.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsNaN 2 | 3 | **ClassicAssert.IsNaN** tests that the specified double value is NaN. 4 | 5 | ```csharp 6 | ClassicAssert.IsNaN(double aDouble); 7 | ClassicAssert.IsNaN(double aDouble, string message, params object[] params); 8 | ``` 9 | 10 | ## See Also 11 | 12 | * [Condition Constraints](xref:constraints#condition-constraints) 13 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNotAssignableFrom.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsNotAssignableFrom 2 | 3 | **ClassicAssert.IsNotAssignableFrom** succeeds if the object provided may not be assigned a value of the expected type. 4 | 5 | ```csharp 6 | ClassicAssert.IsNotAssignableFrom(Type expected, object actual); 7 | ClassicAssert.IsNotAssignableFrom(Type expected, object actual, 8 | string message, params object[] params); 9 | ClassicAssert.IsNotAssignableFrom(object actual); 10 | ClassicAssert.IsNotAssignableFrom(object actual, 11 | string message, params object[] params); 12 | ``` 13 | 14 | ## See also 15 | 16 | * [Type Constraints](xref:constraints#type-constraints) 17 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNotEmpty.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsNotEmpty 2 | 3 | **ClassicAssert.IsNotEmpty** may be used to test either a string or a collection or IEnumerable. When used with a 4 | string, it succeeds if the string is not the empty string. When used with a collection, it succeeds if the collection is 5 | not empty. 6 | 7 | ```csharp 8 | ClassicAssert.IsNotEmpty(string aString); 9 | ClassicAssert.IsNotEmpty(string aString, string message, params object[] args); 10 | 11 | ClassicAssert.IsNotEmpty(IEnumerable collection); 12 | ClassicAssert.IsNotEmpty(IEnumerable collection, string message, 13 | params object[] args); 14 | ``` 15 | 16 | > [!NOTE] 17 | > When used with an IEnumerable that is not also an ICollection, **ClassicAssert.IsEmpty** attempts to enumerate 18 | > the contents. It should not be used in cases where this results in an unwanted side effect. 19 | 20 | ## See Also 21 | 22 | * [Condition Constraints](xref:constraints#condition-constraints) 23 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.IsNotInstanceOf.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.IsNotInstanceOf 2 | 3 | **ClassicAssert.IsNotInstanceOf** succeeds if the object provided as an actual value is not an instance of the expected type. 4 | 5 | ```csharp 6 | ClassicAssert.IsNotInstanceOf(Type expected, object actual); 7 | ClassicAssert.IsNotInstanceOf(Type expected, object actual, 8 | string message, params object[] params); 9 | ClassicAssert.IsNotInstanceOf(object actual); 10 | ClassicAssert.IsNotInstanceOf(object actual, 11 | string message, params object[] params); 12 | ``` 13 | 14 | ## See Also 15 | 16 | * [Type Constraints](xref:constraints#type-constraints) 17 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Negative.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.Negative 2 | 3 | Asserts that a number is negative. 4 | 5 | ```csharp 6 | //true 7 | ClassicAssert.Negative(-1); 8 | //false 9 | ClassicAssert.Negative(1); 10 | ``` 11 | 12 | All the overloads of the method are 13 | 14 | ```csharp 15 | ClassicAssert.Negative(int actual); 16 | ClassicAssert.Negative(int actual, string message, params object[] args); 17 | 18 | ClassicAssert.Negative(uint actual); 19 | ClassicAssert.Negative(uint actual, string message, params object[] args); 20 | 21 | ClassicAssert.Negative(long actual); 22 | ClassicAssert.Negative(long actual, string message, params object[] args); 23 | 24 | ClassicAssert.Negative(ulong actual); 25 | ClassicAssert.Negative(ulong actual, string message, params object[] args); 26 | 27 | ClassicAssert.Negative(decimal actual); 28 | ClassicAssert.Negative(decimal actual, string message, params object[] args); 29 | 30 | ClassicAssert.Negative(double actual); 31 | ClassicAssert.Negative(double actual, string message, params object[] args); 32 | 33 | ClassicAssert.Negative(float actual); 34 | ClassicAssert.Negative(float actual, string message, params object[] args); 35 | ``` 36 | 37 | You may also use **ClassicAssert.That** with a **Is.Negative** constraint to achieve the same result. 38 | 39 | ## See Also 40 | 41 | * [ClassicAssert.Positive](Assert.Positive.md) 42 | * [ClassicAssert.Zero](Assert.Zero.md) 43 | * [ClassicAssert.NotZero](Assert.NotZero.md) 44 | * [ClassicAssert.IsNaN](Assert.IsNaN.md) 45 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.NotNull.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.NotNull 2 | 3 | **ClassicAssert.NotNull** and **ClassicAssert.IsNotNull** test that the specified object is non-null. 4 | The two forms are provided for compatibility with past versions of NUnit and 5 | NUnitLite. 6 | 7 | ```csharp 8 | ClassicAssert.NotNull(object anObject); 9 | ClassicAssert.NotNull(object anObject, string message, params object[] params); 10 | 11 | ClassicAssert.IsNotNull(object anObject); 12 | ClassicAssert.IsNotNull(object anObject, string message, params object[] params); 13 | ``` 14 | 15 | ## See Also 16 | 17 | * [Condition Constraints](xref:constraints#condition-constraints) 18 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.NotZero.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.NotZero 2 | 3 | **ClassicAssert.NotZero** tests that a value is not zero. 4 | 5 | ```csharp 6 | ClassicAssert.NotZero(int actual); 7 | ClassicAssert.NotZero(int actual, string message, params object[] args); 8 | 9 | ClassicAssert.NotZero(uint actual); 10 | ClassicAssert.NotZero(uint actual, string message, params object[] args); 11 | 12 | ClassicAssert.NotZero(long actual); 13 | ClassicAssert.NotZero(long actual, string message, params object[] args); 14 | 15 | ClassicAssert.NotZero(ulong actual); 16 | ClassicAssert.NotZero(ulong actual, string message, params object[] args); 17 | 18 | ClassicAssert.NotZero(decimal actual); 19 | ClassicAssert.NotZero(decimal actual, string message, params object[] args); 20 | 21 | ClassicAssert.NotZero(double actual); 22 | ClassicAssert.NotZero(double actual, string message, params object[] args); 23 | 24 | ClassicAssert.NotZero(float actual); 25 | ClassicAssert.NotZero(float actual, string message, params object[] args); 26 | ``` 27 | 28 | You may also use **ClassicAssert.That** with a `Is.Not.Zero` constraint to achieve the 29 | same result. 30 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Null.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.Null 2 | 3 | **ClassicAssert.Null** and **ClassicAssert.IsNull** test that the specified object is null. 4 | The two forms are provided for compatibility with past versions of NUnit and 5 | NUnitLite. 6 | 7 | ```csharp 8 | ClassicAssert.Null(object anObject); 9 | ClassicAssert.Null(object anObject, string message, params object[] params); 10 | 11 | ClassicAssert.IsNull(object anObject); 12 | ClassicAssert.IsNull(object anObject, string message, params object[] params); 13 | ``` 14 | 15 | ## See Also 16 | 17 | * [Condition Constraints](xref:constraints#condition-constraints) 18 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Pass.md: -------------------------------------------------------------------------------- 1 | --- 2 | redirect_url: ../special-assertions/Assert.Pass.html 3 | --- -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Positive.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.Positive 2 | 3 | Asserts that a number is positive. 4 | 5 | ```csharp 6 | //false 7 | ClassicAssert.Positive(-1); 8 | //true 9 | ClassicAssert.Positive(1); 10 | ``` 11 | 12 | All the overloads of the method are 13 | 14 | ```csharp 15 | ClassicAssert.Positive(int actual); 16 | ClassicAssert.Positive(int actual, string message, params object[] args); 17 | 18 | ClassicAssert.Positive(uint actual); 19 | ClassicAssert.Positive(uint actual, string message, params object[] args); 20 | 21 | ClassicAssert.Positive(long actual); 22 | ClassicAssert.Positive(long actual, string message, params object[] args); 23 | 24 | ClassicAssert.Positive(ulong actual); 25 | ClassicAssert.Positive(ulong actual, string message, params object[] args); 26 | 27 | ClassicAssert.Positive(decimal actual); 28 | ClassicAssert.Positive(decimal actual, string message, params object[] args); 29 | 30 | ClassicAssert.Positive(double actual); 31 | ClassicAssert.Positive(double actual, string message, params object[] args); 32 | 33 | ClassicAssert.Positive(float actual); 34 | ClassicAssert.Positive(float actual, string message, params object[] args); 35 | ``` 36 | 37 | You may also use **ClassicAssert.That** with a **Is.Positive** constraint to achieve the same result. 38 | 39 | ## See Also 40 | 41 | * [ClassicAssert.Negative](Assert.Negative.md) 42 | * [ClassicAssert.Zero](Assert.Zero.md) 43 | * [ClassicAssert.NotZero](Assert.NotZero.md) 44 | * [ClassicAssert.IsNaN](Assert.IsNaN.md) 45 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.True.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.True 2 | 3 | **ClassicAssert.True** and **ClassicAssert.IsTrue** test that the specified condition is true. 4 | The two forms are provided for compatibility with past versions of NUnit and 5 | NUnitLite. 6 | 7 | ```csharp 8 | ClassicAssert.True(bool condition); 9 | ClassicAssert.True(bool condition, string message, params object[] params); 10 | 11 | ClassicAssert.IsTrue(bool condition); 12 | ClassicAssert.IsTrue(bool condition, string message, params object[] params); 13 | ``` 14 | 15 | You can also use **Assert.That** with a Boolean argument to achieve the 16 | same result. 17 | 18 | ```csharp 19 | Assert.That(condition); 20 | ``` 21 | 22 | ## See Also 23 | 24 | * [Condition Constraints](xref:constraints#condition-constraints) 25 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Assert.Zero.md: -------------------------------------------------------------------------------- 1 | # ClassicAssert.Zero 2 | 3 | **ClassicAssert.Zero** tests that a value is zero. 4 | 5 | ```csharp 6 | ClassicAssert.Zero(int actual); 7 | ClassicAssert.Zero(int actual, string message, params object[] args); 8 | 9 | ClassicAssert.Zero(uint actual); 10 | ClassicAssert.Zero(uint actual, string message, params object[] args); 11 | 12 | ClassicAssert.Zero(long actual); 13 | ClassicAssert.Zero(long actual, string message, params object[] args); 14 | 15 | ClassicAssert.Zero(ulong actual); 16 | ClassicAssert.Zero(ulong actual, string message, params object[] args); 17 | 18 | ClassicAssert.Zero(decimal actual); 19 | ClassicAssert.Zero(decimal actual, string message, params object[] args); 20 | 21 | ClassicAssert.Zero(double actual); 22 | ClassicAssert.Zero(double actual, string message, params object[] args); 23 | 24 | ClassicAssert.Zero(float actual); 25 | ClassicAssert.Zero(float actual, string message, params object[] args); 26 | ``` 27 | 28 | You may also use **Assert.That** with a Is.Zero constraint to achieve the 29 | same result. 30 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/classic-assertions/Directory-Assert.md: -------------------------------------------------------------------------------- 1 | # DirectoryAssert 2 | 3 | The DirectoryAssert class provides methods for comparing two directories 4 | or verifying the existence of a directory. Directories may be provided 5 | as DirectoryInfos or as strings giving the path to each directory. 6 | 7 | ```csharp 8 | DirectoryAssert.AreEqual(DirectoryInfo expected, DirectoryInfo actual); 9 | DirectoryAssert.AreEqual(DirectoryInfo expected, DirectoryInfo actual, 10 | string message, params object[] args); 11 | 12 | DirectoryAssert.AreNotEqual(DirectoryInfo expected, DirectoryInfo actual); 13 | DirectoryAssert.AreNotEqual(DirectoryInfo expected, DirectoryInfo actual, 14 | string message, params object[] args); 15 | 16 | DirectoryAssert.Exists(DirectoryInfo actual); 17 | DirectoryAssert.Exists(DirectoryInfo actual, 18 | string message, params object[] args); 19 | 20 | DirectoryAssert.Exists(string actual); 21 | DirectoryAssert.Exists(string actual, 22 | string message, params object[] args); 23 | 24 | DirectoryAssert.DoesNotExist(DirectoryInfo actual); 25 | DirectoryAssert.DoesNotExist(DirectoryInfo actual, 26 | string message, params object[] args); 27 | 28 | DirectoryAssert.DoesNotExist(string actual); 29 | DirectoryAssert.DoesNotExist(string actual, 30 | string message, params object[] args); 31 | ``` 32 | 33 | ## See Also 34 | 35 | * [File and Directory Constraints](xref:constraints#file-and-directory-constraints) 36 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/special-assertions/Assert.Fail.md: -------------------------------------------------------------------------------- 1 | # Assert.Fail 2 | 3 | The **Assert.Fail** method provides you with the ability to generate a failure based 4 | on tests that are not encapsulated by the other methods. It is also useful in 5 | developing your own project-specific assertions. 6 | 7 | ```csharp 8 | Assert.Fail(); 9 | Assert.Fail(string message); 10 | 11 | ``` 12 | 13 | Here's an example of its use to create a private assertion that tests whether a 14 | string contains an expected value. 15 | 16 | ```csharp 17 | public void AssertStringContains(string expected, string actual) 18 | { 19 | AssertStringContains(expected, actual, string.Empty); 20 | } 21 | 22 | public void AssertStringContains(string expected, string actual, string message) 23 | { 24 | if (actual.IndexOf(expected) < 0) 25 | Assert.Fail(message); 26 | } 27 | ``` 28 | 29 | ## See Also 30 | 31 | * [Assert.Pass](Assert.Pass.md) 32 | * [Assert.Ignore](Assert.Ignore.md) 33 | * [Assert.Inconclusive](Assert.Inconclusive.md) 34 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/special-assertions/Assert.Ignore.md: -------------------------------------------------------------------------------- 1 | # Assert.Ignore 2 | 3 | The **Assert.Ignore** method provides you with the ability to dynamically cause a 4 | test or suite to be ignored at runtime. It may be called in a test, setup or 5 | fixture setup method. We recommend that you use this only in isolated cases. 6 | The category facility is provided for more extensive inclusion or exclusion of 7 | tests or you may elect to simply divide tests run on different occasions into 8 | different assemblies. 9 | 10 | ```csharp 11 | Assert.Ignore(); 12 | Assert.Ignore(string message); 13 | ``` 14 | 15 | ## See Also 16 | 17 | * [Assert.Pass](Assert.Pass.md) 18 | * [Assert.Fail](Assert.Fail.md) 19 | * [Assert.Inconclusive](Assert.Inconclusive.md) 20 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/special-assertions/Assert.Inconclusive.md: -------------------------------------------------------------------------------- 1 | # Assert.Inconclusive 2 | 3 | The **Assert.Inconclusive** method indicates that the test could not be 4 | completed with the data available. It should be used in situations where 5 | another run with different data might run to completion, with either a 6 | success or failure outcome. 7 | 8 | ```csharp 9 | Assert.Inconclusive(); 10 | Assert.Inconclusive(string message); 11 | ``` 12 | 13 | ## See Also 14 | 15 | * [Assert.Pass](Assert.Pass.md) 16 | * [Assert.Fail](Assert.Fail.md) 17 | * [Assert.Ignore](Assert.Ignore.md) 18 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/special-assertions/Assert.Pass.md: -------------------------------------------------------------------------------- 1 | # Assert.Pass 2 | 3 | The **Assert.Pass** method allows you to immediately end the test, recording 4 | it as successful. Since it causes an exception to be thrown, it is more 5 | efficient to simply allow the test to return. However, Assert.Pass allows 6 | you to record a message in the test result and may also make the test 7 | easier to read in some situations. Additionally, like the other methods 8 | on this page, it can be invoked from a nested method call with the 9 | result of immediately terminating test execution. 10 | 11 | ```csharp 12 | Assert.Pass(); 13 | Assert.Pass(string message); 14 | ``` 15 | 16 | ## See Also 17 | 18 | * [Assert.Fail](Assert.Fail.md) 19 | * [Assert.Ignore](Assert.Ignore.md) 20 | * [Assert.Inconclusive](Assert.Inconclusive.md) 21 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/special-assertions/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Assert.Pass 2 | href: Assert.Pass.md 3 | - name: Assert.Fail 4 | href: Assert.Fail.md 5 | - name: Assert.Ignore 6 | href: Assert.Ignore.md 7 | - name: Assert.Inconclusive 8 | href: Assert.Inconclusive.md -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/assertions/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Assertions 2 | href: assertions.md 3 | - name: Assertion Models 4 | href: assertion-models/toc.yml 5 | topicHref: assertion-models/classic.md 6 | - name: Multiple Asserts 7 | href: multiple-asserts.md 8 | - name: Special Assertions 9 | href: special-assertions/toc.yml 10 | - name: Classic Assertions 11 | href: classic-assertions/toc.yml 12 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/author.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: author-attribute 3 | --- 4 | 5 | # Author 6 | 7 | The **Author** Attribute adds information about the author of the tests. It can be applied to test fixtures and to 8 | tests. 9 | 10 | The constructor takes the name of the test author and optionally the author's email address. Author can also be 11 | specified on a TestFixture or Test attribute. 12 | 13 | [!code-csharp[AuthorAttributeExample](~/snippets/Snippets.NUnit/Attributes/AuthorAttributeExamples.cs#AuthorAttributeExample)] 14 | 15 | > [!NOTE] 16 | > From NUnit version 3.7, you can have multiple Author attributes per fixture or test. Before version 3.7 you 17 | > could only have one Author attribute per fixture or test. 18 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/combinatorial.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: combinatorialattribute 3 | --- 4 | 5 | # Combinatorial 6 | 7 | The **CombinatorialAttribute** is used on a test to specify that NUnit should 8 | generate test cases for all possible combinations of the individual 9 | data items provided for the parameters of a test. Since this is the 10 | default, use of this attribute is optional. 11 | 12 | ## Example 13 | 14 | The following test will be executed six times: 15 | 16 | ```csharp 17 | [Test, Combinatorial] 18 | public void MyTest( 19 | [Values(1, 2, 3)] int x, 20 | [Values("A", "B")] string s) 21 | { 22 | ... 23 | } 24 | ``` 25 | 26 | MyTest is called six times, as follows: 27 | 28 | ```csharp 29 | MyTest(1, "A") 30 | MyTest(1, "B") 31 | MyTest(2, "A") 32 | MyTest(2, "B") 33 | MyTest(3, "A") 34 | MyTest(3, "B") 35 | ``` 36 | 37 | ## Limitations 38 | 39 | When used on a generic method the programmer must ensure that all 40 | possible combinations of arguments are valid. When multiple parameters 41 | use the same generic type (e.g.: T) this may not be possible and the 42 | attribute may generate invalid test cases. 43 | 44 | ## See Also 45 | 46 | * [Sequential Attribute](sequential.md) 47 | * [Pairwise Attribute](pairwise.md) 48 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/culture.md: -------------------------------------------------------------------------------- 1 | # Culture 2 | 3 | The Culture attribute is used to specify cultures for which a test or fixture should be run. It does not affect the 4 | culture setting, but merely uses it to determine whether to run the test. If you wish to change the culture when running 5 | a test, use the SetCulture attribute instead. 6 | 7 | If the specified culture requirements for a test are not met it is skipped. In the gui, the tree node for the test 8 | remains gray and the status bar color is not affected. 9 | 10 | One use of the Culture attribute is to provide alternative tests under different cultures. You may specify either 11 | specific cultures, like "en-GB" or neutral cultures like "de". 12 | 13 | ## Test Fixture Syntax 14 | 15 | ```csharp 16 | namespace NUnit.Tests 17 | { 18 | using System; 19 | using NUnit.Framework; 20 | 21 | [TestFixture] 22 | [Culture("fr-FR")] 23 | public class FrenchCultureTests 24 | { 25 | // ... 26 | } 27 | } 28 | ``` 29 | 30 | ## Test Syntax 31 | 32 | ```csharp 33 | namespace NUnit.Tests 34 | { 35 | using System; 36 | using NUnit.Framework; 37 | 38 | [TestFixture] 39 | public class SuccessTests 40 | { 41 | [Test] 42 | [Culture(Exclude="en,de")] 43 | public void SomeTest() 44 | { /* ... */ } 45 | } 46 | ``` 47 | 48 | ## See Also 49 | 50 | * [SetCulture Attribute](setculture.md) 51 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/datapoint.md: -------------------------------------------------------------------------------- 1 | # Datapoint 2 | 3 | The **Datapoint** attribute is used 4 | to provide data for **Theories** and is ignored for ordinary 5 | tests - including tests with parameters. 6 | 7 | When a Theory is loaded, NUnit creates arguments for each 8 | of its parameters by using any fields of the same type 9 | as the parameter annotated with the **DatapointAttribute**. 10 | Fields must be members of the class containing the Theory 11 | and their Type must exactly match the argument for which 12 | data is being supplied. 13 | 14 | ## Automatically Supplied Datapoints 15 | 16 | It is normally not necessary to specify datapoints for 17 | **boolean** or **enum** arguments. 18 | NUnit automatically supplies values of **true** 19 | and **false** for **boolean** arguments and will supply all 20 | defined values of any enumeration. 21 | 22 | If for some reason you don't wish to use all possible values, you 23 | can override this behavior by supplying your own datapoints. If you 24 | supply any datapoints for an argument, automatic datapoint generation 25 | is suppressed. 26 | 27 | ## Example 28 | 29 | For an example of use, see [Theory Attribute](theory.md) 30 | 31 | ## See Also 32 | 33 | * [Theory Attribute](theory.md) 34 | * [Parameterized Tests](xref:parameterizedtests) 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/datapointsource.md: -------------------------------------------------------------------------------- 1 | # DatapointSource 2 | 3 | The **DatapointSource** attribute is used 4 | to provide data for **Theories** and is ignored for ordinary 5 | tests - including tests with parameters. 6 | 7 | Collections of datapoints may be provided by use of the **DatapointSourceAttribute**. 8 | This attribute may be placed on methods or 9 | properties in addition to fields. The returned value must be 10 | either an array of the required type or an `IEnumerable` returning an enumeration 11 | of the required type. The data Type must exactly match the argument 12 | for which data is being supplied. 13 | 14 | > In earlier versions of NUnit, the obsolete **DatapointsAttribute** 15 | > was used in place of **DatapointSourceAttribute**. 16 | 17 | ## Automatically Supplied Datapoints 18 | 19 | It is normally not necessary to specify datapoints for 20 | **boolean** or **enum** arguments. 21 | NUnit automatically supplies values of **true** 22 | and **false** for **boolean** arguments and will supply all 23 | defined values of any enumeration. 24 | 25 | If for some reason you don't wish to use all possible values, you 26 | can override this behavior by supplying your own datapoints. If you 27 | supply any datapoints for an argument, automatic datapoint generation 28 | is suppressed. 29 | 30 | ## Example 31 | 32 | For an example of use, see [Theory Attribute](theory.md) 33 | 34 | ## See Also 35 | 36 | * [Theory Attribute](theory.md) 37 | * [Parameterized Tests](xref:parameterizedtests) 38 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/defaultfloatingpointtolerance.md: -------------------------------------------------------------------------------- 1 | # DefaultFloatingPointTolerance 2 | 3 | The **DefaultFloatingPointToleranceAttribute** is used to indicate that 4 | comparisons of values of types `float` and `double` - within the test method, 5 | class, or assembly marked with the attribute - should use the tolerance 6 | specified in the constructor unless a specific tolerance is given for the 7 | comparison. 8 | 9 | ## Examples 10 | 11 | ```csharp 12 | [TestFixture] 13 | [DefaultFloatingPointTolerance(1)] 14 | public class ToleranceTest 15 | { 16 | [Test] 17 | public void ComparisonUsingDefaultFloatingPointToleranceFromFixture() 18 | { 19 | // Passes due to the DefaultFloatingPointToleranceAttribute from the fixture. 20 | Assert.That(1f, Is.EqualTo(2)); 21 | } 22 | 23 | [Test] 24 | public void ComparisonOfIntegersDoNotUseTolerance() 25 | { 26 | // Fails as DefaultFloatingPointTolerance only effects comparisons 27 | // of floats and doubles. 28 | Assert.That(1, Is.EqualTo(2)); 29 | } 30 | 31 | [Test] 32 | public void ComparisonUsingSpecificTolerance() 33 | { 34 | // Fails as 1 is not equal to 2 using the specified tolerance 0. 35 | Assert.That(1f, Is.EqualTo(2).Within(0)); 36 | } 37 | 38 | [Test] 39 | [DefaultFloatingPointTolerance(2)] 40 | public void ComparisonUsingDefaultFloatingPointToleranceFromTest() 41 | { 42 | // Passes due to the DefaultFloatingPointTolerance from the test. 43 | Assert.That(2f, Is.EqualTo(4)); 44 | } 45 | } 46 | ``` 47 | 48 | ## See Also 49 | 50 | * [Assert.AreEqual](../assertions/classic-assertions/Assert.AreEqual.md) 51 | * [EqualConstraint](../constraints/EqualConstraint.md) 52 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/description.md: -------------------------------------------------------------------------------- 1 | # Description 2 | 3 | The Description attribute is used to apply descriptive text to a Test, TestFixture or Assembly. The text appears in the 4 | XML output file. 5 | 6 | ## Example 7 | 8 | ```csharp 9 | [assembly: Description("Assembly description here")] 10 | 11 | namespace NUnit.Tests 12 | { 13 | using System; 14 | using NUnit.Framework; 15 | 16 | [TestFixture, Description("Fixture description here")] 17 | public class SomeTests 18 | { 19 | [Test, Description("Test description here")] 20 | public void OneTest() 21 | { /* ... */ } 22 | } 23 | } 24 | ``` 25 | 26 | > [!NOTE] 27 | > The Test and TestFixture attributes continue to support an optional Description property. The Description 28 | > attribute should be used for new applications. If both are used, the Description attribute takes precedence. 29 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/levelofparallelism.md: -------------------------------------------------------------------------------- 1 | # LevelOfParallelism 2 | 3 | This is an _assembly-level_ attribute, which may be used to specify the level of parallelism, that is, the maximum 4 | number of worker threads executing tests in the assembly. It may be overridden using a command-line option in the 5 | console runner. 6 | 7 | This attribute is optional. If it is not specified, NUnit uses the processor count or 2, whichever is greater. For 8 | example, on a four processor machine the default value is 4. 9 | 10 | ## Example 11 | 12 | The following code, which might be placed in AssemblyInfo.cs, sets the level of parallelism to 3: 13 | 14 | ```csharp 15 | [assembly:LevelOfParallelism(3)] 16 | ``` 17 | 18 | ## Platform Support 19 | 20 | Parallel execution is supported by the NUnit framework on desktop .NET runtimes. It is not supported in our Portable or 21 | .NET Standard builds at this time, although the attributes are recognized without error in order to allow use in 22 | projects that build against multiple targets. 23 | 24 | ## See Also 25 | 26 | * [Parallelizable Attribute](parallelizable.md) 27 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/maxtime.md: -------------------------------------------------------------------------------- 1 | # MaxTime 2 | 3 | The **MaxTimeAttribute** is used on test methods to specify a maximum time 4 | in milliseconds for a test case. If the test case takes longer than the 5 | specified time to complete, it is reported as a failure. 6 | 7 | ## Example 8 | 9 | ```csharp 10 | [Test, MaxTime(2000)] 11 | public void TimedTest() 12 | { 13 | /* ... */ 14 | } 15 | ``` 16 | 17 | ## Notes 18 | 19 | 1. Any assertion failures take precedence over the elapsed time check. 20 | 21 | 2. This attribute does not cancel the test if the time 22 | is exceeded. It merely waits for the test to complete and then 23 | compares the elapsed time to the specified maximum. If you want to 24 | cancel long-running tests, see [Timeout Attribute](timeout.md). 25 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/nonparallelizable.md: -------------------------------------------------------------------------------- 1 | # NonParallelizable 2 | 3 | This attribute is used to indicate that the test on which it appears may not be run in parallel with any other tests. 4 | The attribute takes no arguments and may be used at the assembly, class or method level. 5 | 6 | When used at the assembly level, its only effect is that execution begins on the non-parallel queue. Test suites, 7 | fixtures and test cases will continue to run on the same thread unless a fixture or method is marked with the 8 | [Parallelizable Attribute](parallelizable.md). 9 | 10 | When used on a test fixture or method, that test will be queued on the non-parallel queue and will not run while other 11 | tests marked as Parallelizable are being run. 12 | 13 | ## Platform Support 14 | 15 | Parallel execution is not supported by all builds of the NUnit Framework, although the attributes are recognized without 16 | error in order to allow use in projects that build against multiple targets. Currently, only the .NET Standard 1.6 build 17 | does not support parallelization. 18 | 19 | ## See Also 20 | 21 | * [Parallelizable Attribute](parallelizable.md) 22 | * [LevelOfParallelism Attribute](levelofparallelism.md) 23 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/nontestassembly.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: nontestassembly 3 | --- 4 | 5 | # NonTestAssembly 6 | 7 | This is an _assembly-level_ attribute, which may be used to specify that even though 8 | the assembly refers to NUnit it does not contain any tests. This attribute can be 9 | used in connection with the command line option `--skipnontestassemblies` of the 10 | console to skip assemblies without failing. 11 | 12 | ## Example 13 | 14 | The following code, which might be placed in AssemblyInfo.cs, specifies that the 15 | assembly does not contain any tests. 16 | 17 | ```csharp 18 | [assembly: NonTestAssembly] 19 | ``` 20 | 21 | ## See Also 22 | 23 | * `--skipnontestassemblies` in [Console Command Line](xref:consolecommandline) 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/order.md: -------------------------------------------------------------------------------- 1 | # Order 2 | 3 | The **OrderAttribute** may be placed on a test method or fixture to specify the order in which tests are run within the 4 | fixture or other suite in which they are contained. Ordering is given by the required `order` argument to the attribute, 5 | an `int`. 6 | 7 | ## Example 8 | 9 | The following tests will be run in the order: 10 | 11 | * TestA 12 | * TestB 13 | * TestC 14 | 15 | ```csharp 16 | public class MyFixture 17 | { 18 | [Test, Order(1)] 19 | public void TestA() { /* ... */ } 20 | 21 | 22 | [Test, Order(2)] 23 | public void TestB() { /* ... */ } 24 | 25 | [Test] 26 | public void TestC() { /* ... */ } 27 | } 28 | ``` 29 | 30 | ## Notes 31 | 32 | 1. As stated, ordering is local to the test that contains the ordered tests. For test cases (methods) ordering applies 33 | within the containing fixture. For fixtures it applies within the containing namespace. There is no facility in NUnit 34 | to order tests globally. 35 | 2. Tests with an `OrderAttribute` argument are started before any tests without the attribute. 36 | 3. Ordered tests are started in ascending order of the `order` argument. 37 | 4. Among tests with the same `order` value or without the attribute, execution order is indeterminate. 38 | 5. Tests do not wait for prior tests to finish. If multiple threads are in use, a test may be started while some earlier 39 | tests are still being run. 40 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/pairwise.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: pairwiseattribute 3 | --- 4 | 5 | # Pairwise 6 | 7 | The **PairwiseAttribute** is used on a test to specify that NUnit should 8 | generate test cases in such a way that all possible pairs of 9 | values are used. This is a well-known approach for combatting 10 | the combinatorial explosion of test cases when more than 11 | two features (parameters) are involved. 12 | 13 | ## Example 14 | 15 | Using the Combinatorial attribute, the following test would be executed 12 (3x2x2) times. 16 | With **Pairwise** it is executed only enough times so that each possible pair is covered.. 17 | 18 | ```csharp 19 | [Test, Pairwise] 20 | public void MyTest( 21 | [Values("a", "b", "c")] string a, 22 | [Values("+", "-")] string b, 23 | [Values("x", "y")] string c) 24 | { 25 | Console.WriteLine("{0} {1} {2}", a, b, c); 26 | } 27 | ``` 28 | 29 | For this test, NUnit currently calls the method six times, producing the following output: 30 | 31 | ```none 32 | a - x 33 | a + y 34 | b - y 35 | b + x 36 | c - x 37 | c + y 38 | ``` 39 | 40 | Note that this is not the optimal output. The pairs (-, x) and (+, y) 41 | appear twice. NUnit uses a heuristic algorithm to reduce the number of test cases as much 42 | as it can. Improvements may be made in the future. 43 | 44 | ## Limitations 45 | 46 | When used on a generic method the programmer must ensure that all 47 | possible combinations of arguments are valid. When multiple parameters 48 | use the same generic type (e.g.: T) this may not be possible and the 49 | attribute may generate invalid test cases. 50 | 51 | ## See Also 52 | 53 | * [Sequential Attribute](sequential.md) 54 | * [Combinatorial Attribute](combinatorial.md) 55 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/range.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: rangeattribute 3 | --- 4 | 5 | # Range 6 | 7 | The **RangeAttribute** is used to specify a range of values to be provided 8 | for an individual parameter of a parameterized test method. Since 9 | NUnit combines the data provided for each parameter into a set of 10 | test cases, data must be provided for all parameters if it is 11 | provided for any of them. 12 | 13 | By default, NUnit creates test cases from all possible combinations 14 | of the datapoints provided on parameters - the combinatorial approach. 15 | This default may be modified by use of specific attributes on the 16 | test method itself. 17 | 18 | RangeAttribute supports the following constructors: 19 | 20 | ```csharp 21 | public RangeAttribute(int from, int to); 22 | public RangeAttribute(int from, int to, int step); 23 | public RangeAttribute(long from, long to, long step); 24 | public RangeAttribute(float from, float to, float step); 25 | public RangeAttribute(double from, double to, double step); 26 | ``` 27 | 28 | ## Example 29 | 30 | The following test will be executed nine times. 31 | 32 | ```csharp 33 | [Test] 34 | public void MyTest( 35 | [Values(1, 2, 3)] int x, 36 | [Range(0.2, 0.6, 0.2)] double d) 37 | { 38 | /* ... */ 39 | } 40 | ``` 41 | 42 | The MyTest method is called nine times, as follows: 43 | 44 | ```csharp 45 | MyTest(1, 0.2) 46 | MyTest(1, 0.4) 47 | MyTest(1, 0.6) 48 | MyTest(2, 0.2) 49 | MyTest(2, 0.4) 50 | MyTest(2, 0.6) 51 | MyTest(3, 0.2) 52 | MyTest(3, 0.4) 53 | MyTest(3, 0.6) 54 | ``` 55 | 56 | ## See Also 57 | 58 | * [Values Attribute](values.md) 59 | * [Random Attribute](random.md) 60 | * [Sequential Attribute](sequential.md) 61 | * [Combinatorial Attribute](combinatorial.md) 62 | * [Pairwise Attribute](pairwise.md) 63 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/repeat.md: -------------------------------------------------------------------------------- 1 | # Repeat 2 | 3 | **RepeatAttribute** is used on a test method to specify that it should be 4 | executed multiple times. If any repetition fails, the remaining ones are 5 | not run and a failure is reported. 6 | 7 | ## Notes 8 | 9 | 1. If RepeatAttribute is used on a parameterized method, each individual 10 | test case created for that method is repeated. 11 | 2. It is not currently possible to use RepeatAttribute on a TestFixture 12 | or any higher level suite. Only test cases may be repeated. 13 | 14 | ## Examples 15 | 16 | ```csharp 17 | [Test] 18 | [Repeat(25)] 19 | public void MyTest() 20 | { 21 | /* The contents of this test will be run 25 times. */ 22 | } 23 | ``` 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/requiresthread.md: -------------------------------------------------------------------------------- 1 | # RequiresThread 2 | 3 | The **RequiresThreadAttribute** is used to indicate that a test method, class or assembly should be run on a separate 4 | thread. Optionally, the desired apartment for the thread may be specified in the constructor. 5 | 6 | > [!NOTE] 7 | > This attribute, used with or without an ApartmentState argument will **always** result in creation of a new 8 | > thread. To create a thread **only** if the current ApartmentState is not appropriate, use the **ApartmentAttribute**. 9 | 10 | ## Examples 11 | 12 | ```csharp 13 | // A thread will be created and used to run 14 | // all the tests in the assembly 15 | [assembly:RequiresThread] 16 | 17 | /* ... */ 18 | 19 | // TestFixture requiring a separate thread 20 | [TestFixture, RequiresThread] 21 | public class FixtureOnThread 22 | { 23 | // A separate thread will be created and all 24 | // tests in the fixture will run on it. 25 | } 26 | 27 | [TestFixture] 28 | public class AnotherFixture 29 | { 30 | [Test, RequiresThread] 31 | public void TestRequiringThread() 32 | { 33 | // A separate thread will be created for this test 34 | } 35 | 36 | [Test, RequiresThread(ApartmentState.STA)] 37 | public void TestRequiringSTAThread() 38 | { 39 | // A separate STA thread will be created for this test. 40 | } 41 | } 42 | ``` 43 | 44 | ## See Also 45 | 46 | * [Apartment Attribute](apartment.md) 47 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/retry.md: -------------------------------------------------------------------------------- 1 | # Retry 2 | 3 | RetryAttribute is used on a test method to specify that it should be rerun if it fails, up to a maximum number of times. 4 | 5 | Notes: 6 | 7 | 1. The argument you specify is the total number of attempts and __not__ the number of retries after an initial failure. 8 | So `[Retry(1)]` does nothing and should not be used. 9 | 2. It is not currently possible to use `RetryAttribute` on a `TestFixture` or any other type of test suite. Only single 10 | tests may be repeated. 11 | 3. If a test has an unexpected exception, an error result is returned and it is not retried. Only assertion failures can 12 | trigger a retry. To convert an unexpected exception into an assertion failure, see the 13 | [ThrowsConstraint](xref:throwsconstraint). 14 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/sequential.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: sequentialattribute 3 | --- 4 | 5 | # Sequential 6 | 7 | The **SequentialAttribute** is used on a test to specify that NUnit should generate test cases by selecting individual 8 | data items provided for the parameters of the test, without generating additional combinations. 9 | 10 | > [!NOTE] 11 | > If parameter data is provided by multiple attributes, the order in which NUnit uses the data items is not 12 | > guaranteed. However, it can be expected to remain constant for a given runtime and operating system. For best results 13 | with **SequentialAttribute** use only one data attribute on each parameter. 14 | 15 | ## Example 16 | 17 | The following test will be executed three times. 18 | 19 | ```csharp 20 | [Test, Sequential] 21 | public void MyTest( 22 | [Values(1, 2, 3)] int x, 23 | [Values("A", "B")] string s) 24 | { 25 | /* ... */ 26 | } 27 | ``` 28 | 29 | MyTest is called three times, as follows: 30 | 31 | ```csharp 32 | MyTest(1, "A") 33 | MyTest(2, "B") 34 | MyTest(3, null) 35 | ``` 36 | 37 | ## See also 38 | 39 | * [Combinatorial Attribute](combinatorial.md) 40 | * [Pairwise Attribute](pairwise.md) 41 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/setculture.md: -------------------------------------------------------------------------------- 1 | # SetCulture 2 | 3 | The SetCulture attribute is used to set the current Culture for the duration 4 | of a test. It may be specified at the level of a test, fixture or assembly. The culture 5 | remains set until the test or fixture completes and is then reset to its original 6 | value. If you wish to use the current culture setting to decide whether to run 7 | a test, use the Culture attribute instead of this one. 8 | 9 | Only one culture may be specified. Running a test under 10 | multiple cultures is a planned future enhancement. At this time, you can 11 | achieve the same result by factoring out your test code into a private method 12 | that is called by each individual test method. 13 | 14 | ## Examples 15 | 16 | ```csharp 17 | namespace NUnit.Tests 18 | { 19 | using System; 20 | using NUnit.Framework; 21 | 22 | [TestFixture] 23 | [SetCulture("fr-FR")] 24 | public class FrenchCultureTests 25 | { 26 | // ... 27 | } 28 | } 29 | ``` 30 | 31 | ## See also 32 | 33 | * [Culture Attribute](culture.md) 34 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/setuiculture.md: -------------------------------------------------------------------------------- 1 | # SetUICulture 2 | 3 | The SetUICulture attribute is used to set the current UI Culture for the duration 4 | of a test. It may be specified at the level of a test or a fixture. The UI culture 5 | remains set until the test or fixture completes and is then reset to its original 6 | value. If you wish to use the current culture setting to decide whether to run 7 | a test, use the Culture attribute instead of this one. 8 | 9 | Only one culture may be specified. Running a test under 10 | multiple cultures is a planned future enhancement. At this time, you can 11 | achieve the same result by factoring out your test code into a private method 12 | that is called by each individual test method. 13 | 14 | ## Examples 15 | 16 | ```csharp 17 | namespace NUnit.Tests 18 | { 19 | using System; 20 | using NUnit.Framework; 21 | 22 | [TestFixture] 23 | [SetUICulture("fr-FR")] 24 | public class FrenchCultureTests 25 | { 26 | // ... 27 | } 28 | } 29 | ``` 30 | 31 | ## See also 32 | 33 | * [Culture Attribute](culture.md)] 34 | * [SetCulture Attribute](setculture.md) 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/singlethreaded.md: -------------------------------------------------------------------------------- 1 | # SingleThreaded 2 | 3 | `SingleThreadedAttribute` is used on a TestFixture and indicates that the OneTimeSetUp, OneTimeTearDown and all the 4 | child tests must run on the same thread. 5 | 6 | When using this attribute, any `ParallelScope` setting is ignored. 7 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/testfixturesetup.md: -------------------------------------------------------------------------------- 1 | # TestFixtureSetUp 2 | 3 | > [!IMPORTANT] 4 | > The TestFixtureSetUp attribute has been deprecated. Use [OneTimeSetUp Attribute](onetimesetup.md) instead. 5 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/testfixtureteardown.md: -------------------------------------------------------------------------------- 1 | # TestFixtureTearDown 2 | 3 | > [!IMPORTANT] 4 | > The TextFixtureTearDown attribute has been deprecated. Use [OneTimeTearDown Attribute](onetimeteardown.md) instead. 5 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/testof.md: -------------------------------------------------------------------------------- 1 | # TestOf 2 | 3 | The `TestOf` attribute adds information about the class that is being tested. It can be applied to test fixtures and to tests. 4 | 5 | The constructor takes the string name or the type of the class being tested. TestOf can also be specified on 6 | a TestFixture or Test attribute. 7 | 8 | ```csharp 9 | [TestFixture] 10 | [TestOf(typeof(MyClass))] 11 | public class MyTests 12 | { 13 | [Test] 14 | public void Test1() { /* ... */ } 15 | 16 | [Test] 17 | [TestOf(nameof(MySubClass))] 18 | public void Test2() { /* ... */ } 19 | } 20 | 21 | [TestFixture(TestOf = typeof(MyClass))] 22 | public class MyOtherTests 23 | { 24 | [Test] 25 | public void Test1() { /* ... */ } 26 | 27 | [Test(TestOf = typeof(MySubClass))] 28 | public void Test2() { /* ... */ } 29 | } 30 | ``` 31 | 32 | > [!NOTE] 33 | > You can currently only have one TestOf attribute per fixture or test. 34 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/attributes/timeout.md: -------------------------------------------------------------------------------- 1 | # Timeout 2 | 3 | > [!NOTE] 4 | > From version 3.12 this is also available in the .NET Standard 2.0 builds of the framework. 5 | 6 | Normally, NUnit simply runs tests and waits for them to terminate -- the test is allowed to run indefinitely. For 7 | certain kinds of tests, however, it may be desirable to specify a timeout value. 8 | 9 | The **TimeoutAttribute** is used to specify a timeout value in milliseconds for a test case. If the test case runs 10 | longer than the time specified it is immediately cancelled and reported as a failure, with a message indicating that the 11 | timeout was exceeded. 12 | 13 | The specified timeout value covers the test setup and teardown as well as the test method itself. Before and after 14 | actions may also be included, depending on where they were specified. Since the timeout may occur during any of these 15 | execution phases, no guarantees can be made as to what will be run and any of these phases of execution may be 16 | incomplete. If only used on a test, once a test has timed out, its teardown methods are executed. 17 | 18 | The attribute may also be specified on a fixture or assembly, in which case it indicates the default timeout for any 19 | subordinate test cases. When using the console runner, it is also possible to specify a default timeout on the 20 | command-line. 21 | 22 | ## Example 23 | 24 | ```csharp 25 | [Test, Timeout(2000)] 26 | public void PotentiallyLongRunningTest() 27 | { 28 | /* ... */ 29 | } 30 | ``` 31 | 32 | > [!NOTE] 33 | > When debugging a unit test, i.e. when a debugger is attached to the process, then the timeout is not enforced. 34 | 35 | ## See Also 36 | 37 | * [MaxTime Attribute](./maxtime.md) 38 | * [CancelAfter Attribute](./cancelafter.md) 39 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AllItemsConstraint.md: -------------------------------------------------------------------------------- 1 | # AllItems Constraint 2 | 3 | `AllItemsConstraint` applies a constraint to each item in an `IEnumerable`, succeeding only if all of them succeed. An 4 | exception is thrown if the actual value passed does not implement `IEnumerable`. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | AllItemsConstraint(Constraint itemConstraint) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.All... 16 | Has.All... 17 | ``` 18 | 19 | ## Examples of Use 20 | 21 | ```csharp 22 | int[] iarray = new int[] { 1, 2, 3 }; 23 | string[] sarray = new string[] { "a", "b", "c" }; 24 | Assert.That(iarray, Is.All.Not.Null); 25 | Assert.That(sarray, Is.All.InstanceOf()); 26 | Assert.That(iarray, Is.All.GreaterThan(0)); 27 | Assert.That(iarray, Has.All.GreaterThan(0)); 28 | ``` 29 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AndConstraint.md: -------------------------------------------------------------------------------- 1 | # And Constraint 2 | 3 | `AndConstraint` combines two other constraints and succeeds only if they both succeed. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | AndConstraint(Constraint left, Constraint right) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | .And. 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(2.3, Is.GreaterThan(2.0).And.LessThan(3.0)); 21 | ``` 22 | 23 | ## Evaluation Order and Precedence 24 | 25 | Note that the constraint evaluates the sub-constraints left to right, meaning that `Assert.That(i, 26 | Is.Not.Null.And.GreaterThan(9));` where `i` is a nullable `int` will work for `10`, but fail for `null` with the message 27 | `Expected: not null and greater than 9. But was: null`. `Assert.That(i, Is.GreaterThan(9).And.Not.Null);` will also 28 | succeed for `10`, but throw an exception for `null`, as `null` cannot be compared to `9`. 29 | 30 | The **OrConstraint** has precedence over the **AndConstraint**. 31 | 32 | ## See also 33 | 34 | * [OrConstraint](OrConstraint.md) 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AnyOfConstraint.md: -------------------------------------------------------------------------------- 1 | # AnyOf Constraint 2 | 3 | `AnyOfConstraint` is used to determine whether a value is equal to any of the expected values. 4 | 5 | > [!NOTE] 6 | > Values provided must be as parameters to the method, not as e.g. a separate array. If you are instead looking 7 | > to see if a collection contains a value, see the [CollectionContains Constraint](xref:collectioncontainsconstraint). 8 | 9 | ## Constructor 10 | 11 | ```csharp 12 | AnyOfConstraint(object[] expected) 13 | ``` 14 | 15 | ## Syntax 16 | 17 | ```csharp 18 | Is.AnyOf(object[] expected) 19 | ``` 20 | 21 | ## Modifiers 22 | 23 | ```csharp 24 | ...IgnoreCase 25 | ...IgnoreWhiteSpace // From version 4.2 26 | ...Using(IEqualityComparer comparer) 27 | ...Using(IComparer comparer) 28 | ...Using(IEqualityComparer comparer) 29 | ...Using(IComparer comparer) 30 | ...Using(Comparison comparer) 31 | ...Using(Func comparer) 32 | ...UsingPropertiesComparer() // From version 4.1 33 | ...UsingPropertiesComparer( 34 | Func configure) // From version 4.4 36 | ``` 37 | 38 | ## Examples of Use 39 | 40 | ```csharp 41 | Assert.That(42, Is.AnyOf(0, -1, 42, 100)); 42 | 43 | // You can use a custom comparer as well 44 | Assert.That(myOwnObject, Is.AnyOf(myArray).Using(myComparer)); 45 | ``` 46 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AssignableFromConstraint.md: -------------------------------------------------------------------------------- 1 | # AssignableFrom Constraint 2 | 3 | `AssignableFromConstraint` tests that one type is assignable from another 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | AssignableFromConstraint(Type) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.AssignableFrom(Type) 15 | Is.AssignableFrom() 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That("Hello", Is.AssignableFrom(typeof(string))); 22 | Assert.That(5, Is.Not.AssignableFrom(typeof(string))); 23 | ``` 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AssignableToConstraint.md: -------------------------------------------------------------------------------- 1 | # AssignableTo Constraint 2 | 3 | `AssignableToConstraint` tests that one type is assignable to another 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | AssignableToConstraint(Type) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.AssignableTo(Type) 15 | Is.AssignableTo() 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That("Hello", Is.AssignableTo(typeof(object))); 22 | Assert.That(5, Is.Not.AssignableTo(typeof(string))); 23 | ``` 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AttributeConstraint.md: -------------------------------------------------------------------------------- 1 | # Attribute Constraint 2 | 3 | `AttributeConstraint` tests for the existence of an attribute on a Type and then applies a constraint to that attribute. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | AttributeConstraint(Type type, IConstraint baseConstraint) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Has.Attribute(typeof(TestFixtureAttribute))... 15 | Has.Attribute()... 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That(someObject, Has.Attribute(typeof(TestFixtureAttribute)) 22 | .Property("Description").EqualTo("My description")); 23 | Assert.That(someObject, Has.Attribute() 24 | .Property("Description").EqualTo("My description")); 25 | ``` 26 | 27 | ## See also 28 | 29 | * [AttributeExistsConstraint](AttributeExistsConstraint.md) 30 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/AttributeExistsConstraint.md: -------------------------------------------------------------------------------- 1 | # AttributeExists Constraint 2 | 3 | `AttributeExistsConstraint` tests for the existence of an attribute on a Type. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | AttributeExistsConstraint(Type type) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Has.Attribute(typeof(TestFixtureAttribute)) 15 | Has.Attribute() 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That(someObject, Has.Attribute(typeof(TestFixtureAttribute))); 22 | Assert.That(someObject, Has.Attribute()); 23 | ``` 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/BinarySerializableConstraint.md: -------------------------------------------------------------------------------- 1 | # BinarySerializable Constraint 2 | 3 | `BinarySerializableConstraint` tests whether an object is serializable in binary format. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | BinarySerializableConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.BinarySerializable 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(someObject, Is.BinarySerializable)); 21 | ``` 22 | 23 | ## See also 24 | 25 | * [XmlSerializableConstraint](XmlSerializableConstraint.md) 26 | 27 | > [!WARNING] 28 | > Binary Serialization is no longer supported in .NET 8 due to security concerns. From NUnit 4.x onward, this 29 | > constraint is not available. More information can be found in these Microsoft Learn articles [on BinaryFormatter's 30 | > removal](https://learn.microsoft.com/en-us/dotnet/core/compatibility/serialization/8.0/binaryformatter-disabled) and 31 | > [on the BinaryFormatter security 32 | > guide](https://learn.microsoft.com/en-au/dotnet/standard/serialization/binaryformatter-security-guide) 33 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/CollectionContainsConstraint.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: collectioncontainsconstraint 3 | --- 4 | 5 | # CollectionContains Constraint 6 | 7 | `CollectionContainsConstraint` tests that an `IEnumerable` contains an object. If the actual value passed does not 8 | implement `IEnumerable`, an exception is thrown. 9 | 10 | ## Constructor 11 | 12 | ```csharp 13 | CollectionContainsConstraint(object) 14 | ``` 15 | 16 | ## Syntax 17 | 18 | ```csharp 19 | Has.Member(object) 20 | Contains.Item(object) 21 | Does.Contain(object) 22 | ``` 23 | 24 | ## Modifiers 25 | 26 | ```csharp 27 | ...Using(IComparer comparer) 28 | ...Using(IComparer comparer) 29 | ...Using(Comparison comparer) 30 | ``` 31 | 32 | ## Examples of Use 33 | 34 | ```csharp 35 | int[] iarray = new int[] { 1, 2, 3 }; 36 | string[] sarray = new string[] { "a", "b", "c" }; 37 | Assert.That(iarray, Has.Member(3)); 38 | Assert.That(sarray, Has.Member("b")); 39 | Assert.That(sarray, Contains.Item("c")); 40 | Assert.That(sarray, Has.No.Member("x")); 41 | Assert.That(iarray, Does.Contain(3)); 42 | ``` 43 | 44 | ## Note 45 | 46 | `Has.Member()`, `Contains.Item()` and `Does.Contain()` work the same as `Has.Some.EqualTo()`. The last statement 47 | generates a [SomeItemsConstraint](SomeItemsConstraint.md) based on an [EqualConstraint](EqualConstraint.md) and offers 48 | additional options such as ignoring case or specifying a tolerance. The syntax on this page may be viewed as a shortcut 49 | for specifying simpler cases. 50 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/CollectionEquivalentConstraint.md: -------------------------------------------------------------------------------- 1 | # CollectionEquivalent Constraint 2 | 3 | `CollectionEquivalentConstraint` tests that two `IEnumerables` are equivalent - that they contain 4 | the same items, in any order. If the actual value passed does not implement `IEnumerable` an exception is thrown. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | CollectionEquivalentConstraint(IEnumerable other) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.EquivalentTo(IEnumerable other) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...IgnoreCase 22 | ...IgnoreWhiteSpace // From version 4.2 23 | ...Using(IEqualityComparer comparer) 24 | ...Using(IComparer comparer) 25 | ...Using(IEqualityComparer comparer) 26 | ...Using(IComparer comparer) 27 | ...Using(Comparison comparer) 28 | ...Using(Func comparer) 29 | ...Using(Func comparison) 30 | ...UsingPropertiesComparer() // From version 4.1 31 | ...UsingPropertiesComparer( 32 | Func configure) // From version 4.4 34 | ``` 35 | 36 | ## Examples of Use 37 | 38 | ```csharp 39 | int[] iarray = new int[] { 1, 2, 3 }; 40 | string[] sarray = new string[] { "a", "b", "c" }; 41 | Assert.That(new string[] { "c", "a", "b" }, Is.EquivalentTo(sarray)); 42 | Assert.That(new int[] { 1, 2, 2 }, Is.Not.EquivalentTo(iarray)); 43 | ``` 44 | 45 | ## Notes 46 | 47 | 1. To compare items in order, use Is.EqualTo(). 48 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/CollectionSubsetConstraint.md: -------------------------------------------------------------------------------- 1 | # CollectionSubset Constraint 2 | 3 | `CollectionSubsetConstraint` tests that one `IEnumerable` is a subset of another. If the actual value passed does not 4 | implement `IEnumerable`, an exception is thrown. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | CollectionSubsetConstraint(IEnumerable) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.SubsetOf(IEnumerable) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...Using(IEqualityComparer comparer) 22 | ...Using(IComparer comparer) 23 | ...Using(IEqualityComparer comparer) 24 | ...Using(IComparer comparer) 25 | ...Using(Comparison comparer) 26 | ...Using(Func comparer) 27 | ...Using(Func comparison) 28 | ...UsingPropertiesComparer() // From version 4.1 29 | ...UsingPropertiesComparer( 30 | Func configure) // From version 4.4 32 | ``` 33 | 34 | ## Example of Use 35 | 36 | ```csharp 37 | int[] iarray = new int[] { 1, 3 }; 38 | Assert.That(iarray, Is.SubsetOf(new int[] { 1, 2, 3 })); 39 | ``` 40 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/CollectionSupersetConstraint.md: -------------------------------------------------------------------------------- 1 | # CollectionSuperset Constraint 2 | 3 | `CollectionSupersetConstraint` tests that one `IEnumerable` is a superset of another. If the actual value passed does 4 | not implement `IEnumerable`, an exception is thrown. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | CollectionSupersetConstraint(IEnumerable) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.SupersetOf(IEnumerable) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...Using(IEqualityComparer comparer) 22 | ...Using(IComparer comparer) 23 | ...Using(IEqualityComparer comparer) 24 | ...Using(IComparer comparer) 25 | ...Using(Comparison comparer) 26 | ...Using(Func comparer) 27 | ...Using(Func comparison) 28 | ...UsingPropertiesComparer() // From version 4.1 29 | ...UsingPropertiesComparer( 30 | Func configure) // From version 4.4 32 | ``` 33 | 34 | ## Example of Use 35 | 36 | ```csharp 37 | int[] iarray = new int[] { 1, 2, 3 }; 38 | Assert.That(iarray, Is.SupersetOf(new int[] { 1, 3 })); 39 | ``` 40 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/DelayedConstraint.md: -------------------------------------------------------------------------------- 1 | # Delayed Constraint 2 | 3 | `DelayedConstraint` delays the application of another constraint until a certain 4 | amount of time has passed. In its simplest form, it replaces use of a Sleep 5 | in the code but it also supports polling, which may allow use of a longer 6 | maximum time while still keeping the tests as fast as possible. 7 | 8 | The **After** modifier is permitted on any constraint, and the delay applies to 9 | the entire expression up to the point where **After** appears. 10 | 11 | Use of a **DelayedConstraint** with a value argument makes no sense, since 12 | the value will be extracted at the point of call. Its intended use is with 13 | delegates and references. If a delegate is used with polling, it may be called 14 | multiple times so only methods without side effects should be used in this way. 15 | 16 | | Syntax Helper | Constructor | Operation | 17 | | ------------- | ------------| --------- | 18 | | After(int) | DelayedConstraint(Constraint, int) | tests that a constraint is satisfied after a delay. | 19 | | After(int, int) | DelayedConstraint(Constraint, int, int) | tests that a constraint is satisfied after a delay using polling. | 20 | 21 | ## Enhanced Syntax 22 | 23 | With NUnit 3.6, an enhanced syntax is available that allows expressing the delay and polling interval more fluently. 24 | 25 | ```csharp 26 | After(4).Seconds 27 | After(1).Minutes.PollEvery(500).MilliSeconds 28 | ``` 29 | 30 | Only Minutes, Seconds and MilliSeconds (note capital-S) are accepted as time modifiers. The default is to use MilliSeconds. 31 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/DictionaryContainsValueConstraint.md: -------------------------------------------------------------------------------- 1 | # DictionaryContainsValue Constraint 2 | 3 | `DictionaryContainsValueConstraint` is used to test whether a dictionary 4 | contains an expected object as a value. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | DictionaryContainsValueConstraint(object) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Contains.Value(object) 16 | Does.ContainValue(object) 17 | Does.Not.ContainValue(object) 18 | ``` 19 | 20 | ## Modifiers 21 | 22 | ```csharp 23 | ...Using(IComparer comparer) 24 | ...Using(IEqualityComparer comparer) 25 | ...Using(IComparer comparer) 26 | ...Using(Comparison comparer) 27 | ...Using(Func comparer) 28 | ...Using(IEqualityComparer comparer) 29 | ...Using(Func comparison) 30 | ...UsingPropertiesComparer() // From version 4.1 31 | ...UsingPropertiesComparer( 32 | Func configure) // From version 4.4 34 | ``` 35 | 36 | ## Examples of Use 37 | 38 | ```csharp 39 | IDictionary idict = new IDictionary { { 1, 4 }, { 2, 5 } }; 40 | 41 | Assert.That(idict, Contains.Value(4)); 42 | Assert.That(idict, Does.ContainValue(5)); 43 | Assert.That(idict, Does.Not.ContainValue(3)); 44 | Assert.That(mydict, Contains.Value(myOwnObject).Using(myComparer)); 45 | ``` 46 | 47 | ## See also 48 | 49 | * [DictionaryContainsKeyConstraint](DictionaryContainsKeyConstraint.md) 50 | * [DictionaryContainsKeyValuePairConstraint.md](DictionaryContainsKeyValuePairConstraint.md) 51 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/EmptyCollectionConstraint.md: -------------------------------------------------------------------------------- 1 | # EmptyCollection Constraint 2 | 3 | The **EmptyCollectionConstraint** tests if a Collection or other `IEnumerable` is empty. An `ArgumentException` is 4 | thrown if the actual value is not an `IEnumerable` or is null. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | EmptyCollectionConstraint() 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.Empty 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That(new int[] { }, Is.Empty); 22 | Assert.That(new int[] { 1, 2, 3 }, Is.Not.Empty); 23 | ``` 24 | 25 | > [!NOTE] 26 | > `Is.Empty` actually creates an `EmptyConstraint`. Subsequently applying it to an `IEnumerable` or 27 | > `ICollection` causes an `EmptyCollectionConstraint` to be created. 28 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/EmptyConstraint.md: -------------------------------------------------------------------------------- 1 | # Empty Constraint 2 | 3 | `EmptyConstraint` tests that an object is an empty string, directory or collection. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | EmptyConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.Empty 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That("", Is.Empty); 21 | Assert.That(new Dictionary(), Is.Empty); 22 | Assert.That(new List(), Is.Empty); 23 | ``` 24 | 25 | ## Notes 26 | 27 | * **EmptyConstraint** creates and uses either an [EmptyStringConstraint](EmptyStringConstraint.md), 28 | [EmptyDirectoryConstraint](EmptyDirectoryConstraint.md) or [EmptyCollectionConstraint](EmptyCollectionConstraint.md) 29 | depending on the argument tested. 30 | * A `DirectoryInfo` argument is required in order to test for an empty directory. To test whether a string represents a 31 | directory path, you must first construct a `DirectoryInfo`. 32 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/EmptyDirectoryConstraint.md: -------------------------------------------------------------------------------- 1 | # EmptyDirectory Constraint 2 | 3 | The `EmptyDirectoryConstraint` tests if a Directory is empty. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | EmptyDirectoryConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.Empty 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(new DirectoryInfo(actual), Is.Empty); 21 | Assert.That(new DirectoryInfo(actual), Is.Not.Empty); 22 | ``` 23 | 24 | > [!NOTE] 25 | > `Is.Empty` actually creates an `EmptyConstraint`. Subsequently applying it to a `DirectoryInfo` causes an 26 | > `EmptyDirectoryConstraint` to be created. 27 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/EmptyStringConstraint.md: -------------------------------------------------------------------------------- 1 | # EmptyString Constraint 2 | 3 | The `EmptyStringConstraint` tests if a string is empty. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | EmptyStringConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.Empty 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(string.Empty, Is.Empty); 21 | Assert.That("A String", Is.Not.Empty); 22 | ``` 23 | 24 | > [!NOTE] 25 | > `Is.Empty` actually creates an `EmptyConstraint`. Subsequently applying it to a `string` causes an 26 | > `EmptyStringConstraint` to be created. 27 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/EndsWithConstraint.md: -------------------------------------------------------------------------------- 1 | # EndsWith Constraint 2 | 3 | `EndsWithConstraint` tests for an ending string. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | EndsWithConstraint(string expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Does.EndWith(string expected) 15 | EndsWith(string expected) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...IgnoreCase 22 | ``` 23 | 24 | ## Examples of Use 25 | 26 | ```csharp 27 | string phrase = "Make your tests fail before passing!"; 28 | 29 | Assert.That(phrase, Does.EndWith("!")); 30 | Assert.That(phrase, Does.EndWith("PASSING!").IgnoreCase); 31 | ``` 32 | 33 | ## Notes 34 | 35 | 1. **EndsWith** may appear only in the body of a constraint expression or when the inherited syntax is used. 36 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/ExactCountConstraint.md: -------------------------------------------------------------------------------- 1 | # ExactCount Constraint 2 | 3 | `ExactCountConstraint` has two functions. 4 | 5 | In its simplest use, it simply verifies the number of items in an array, collection or `IEnumerable`, providing a way to 6 | count items that is independent of any `Length` or `Count` property. 7 | 8 | When used with another constraint, it applies that constraint to each item in the array, collection or `IEnumerable`, 9 | succeeding if the specified number of items succeed. 10 | 11 | An exception is thrown if the actual value passed does not implement `IEnumerable`. 12 | 13 | ## Constructor 14 | 15 | ```csharp 16 | ExactCountConstraint(int expectedCount) 17 | ExactCountConstraint(int expectedCount, Constraint itemConstraint) 18 | ``` 19 | 20 | ## Syntax 21 | 22 | ```csharp 23 | Has.Exactly(int expectedCount)... 24 | ``` 25 | 26 | ## Examples of Use 27 | 28 | ```csharp 29 | int[] array = new int[] { 1, 2, 3 }; 30 | 31 | Assert.That(array, Has.Exactly(3).Items); 32 | Assert.That(array, Has.Exactly(2).Items.GreaterThan(1)); 33 | Assert.That(array, Has.Exactly(3).LessThan(100)); 34 | Assert.That(array, Has.Exactly(2).Items.EqualTo(1).Or.EqualTo(3)); 35 | Assert.That(array, Has.Exactly(1).EqualTo(1).And.Exactly(1).EqualTo(3)); 36 | ``` 37 | 38 | > [!NOTE] 39 | > The keyword `Items` is optional when used before a constraint but required when merely counting items with no 40 | > constraint specified. 41 | 42 | ## See also 43 | 44 | * [PropertyConstraint](PropertyConstraint.md) - For constraints on the `Count` or `Length` property, e.g. 45 | `Has.Count.GreaterThan(10)` or `Has.Length.EqualTo(6)`. 46 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/ExactTypeConstraint.md: -------------------------------------------------------------------------------- 1 | # ExactType Constraint 2 | 3 | `ExactTypeConstraint` tests that an object is an exact Type. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | ExactTypeConstraint(Type) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.TypeOf(Type) 15 | Is.TypeOf() 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That("Hello", Is.TypeOf(typeof(string))); 22 | Assert.That("Hello", Is.Not.TypeOf(typeof(int))); 23 | 24 | Assert.That("World", Is.TypeOf()); 25 | ``` 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/FalseConstraint.md: -------------------------------------------------------------------------------- 1 | # False Constraint 2 | 3 | `FalseConstraint` tests that a value is false. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | FalseConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.False 15 | ``` 16 | 17 | ## Example of Use 18 | 19 | ```csharp 20 | Assert.That(condition, Is.False); 21 | ``` 22 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/FileOrDirectoryExistsConstraint.md: -------------------------------------------------------------------------------- 1 | # FileOrDirectoryExists Constraint 2 | 3 | `FileOrDirectoryExistsConstraint` tests that a File or Directory exists. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | FileOrDirectoryExistsConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Does.Exist 15 | Does.Not.Exist 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | IgnoreDirectories 22 | IgnoreFiles 23 | ``` 24 | 25 | ## Examples of Use 26 | 27 | ```csharp 28 | Assert.That(fileStr, Does.Exist); 29 | Assert.That(dirStr, Does.Exist); 30 | Assert.That(fileStr, Does.Not.Exist); 31 | Assert.That(dirStr, Does.Not.Exist); 32 | 33 | Assert.That(new FileInfo(fileStr), Does.Exist); 34 | Assert.That(new DirectoryInfo(dirStr), Does.Exist); 35 | ``` 36 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/GreaterThanConstraint.md: -------------------------------------------------------------------------------- 1 | # GreaterThan Constraint 2 | 3 | `GreaterThanConstraint` tests that one value is greater than another. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | GreaterThanConstraint(object expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.GreaterThan(object expected) 15 | Is.Positive // Equivalent to Is.GreaterThan(0) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...Using(IComparer comparer) 22 | ...Using(IComparer comparer) 23 | ...Using(Comparison comparer) 24 | ...Within(object tolerance) 25 | ``` 26 | 27 | ## Examples of Use 28 | 29 | ```csharp 30 | Assert.That(7, Is.GreaterThan(3)); 31 | Assert.That(myOwnObject, Is.GreaterThan(theExpected).Using(myComparer)); 32 | Assert.That(42, Is.Positive); 33 | Assert.That(myDateTime, Is.GreaterThan(expectedDateTime).Within(TimeSpan.FromSeconds(1))) 34 | ``` 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/GreaterThanOrEqualConstraint.md: -------------------------------------------------------------------------------- 1 | # GreaterThanOrEqual Constraint 2 | 3 | `GreaterThanOrEqualConstraint` tests that one value is greater than or equal to another. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | GreaterThanOrEqualConstraint(object expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.GreaterThanOrEqualTo(object expected) 15 | Is.AtLeast(object expected) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...Using(IComparer comparer) 22 | ...Using(IComparer comparer) 23 | ...Using(Comparison comparer) 24 | ...Within(object tolerance) 25 | ``` 26 | 27 | ## Examples of Use 28 | 29 | ```csharp 30 | Assert.That(7, Is.GreaterThanOrEqualTo(3)); 31 | Assert.That(7, Is.AtLeast(3)); 32 | Assert.That(7, Is.GreaterThanOrEqualTo(7)); 33 | Assert.That(7, Is.AtLeast(7)); 34 | Assert.That(myOwnObject, Is.GreaterThanOrEqualTo(theExpected).Using(myComparer)); 35 | Assert.That(myDateTime, Is.GreaterThanOrEqualTo(expectedDateTime).Within(TimeSpan.FromSeconds(1))) 36 | ``` 37 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/InstanceOfTypeConstraint.md: -------------------------------------------------------------------------------- 1 | # InstanceOfType Constraint 2 | 3 | `InstanceOfTypeConstraint` tests that an object is of the type supplied or a derived type. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | InstanceOfTypeConstraint(Type) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.InstanceOf(Type) 15 | Is.InstanceOf() 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That("Hello", Is.InstanceOf(typeof(string))); 22 | Assert.That(5, Is.Not.InstanceOf(typeof(string))); 23 | 24 | Assert.That(5, Is.Not.InstanceOf()); 25 | ``` 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/LessThanConstraint.md: -------------------------------------------------------------------------------- 1 | # LessThan Constraint 2 | 3 | `LessThanConstraint` tests that one value is less than another. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | LessThanConstraint(object expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.LessThan(object expected) 15 | Is.Negative // Equivalent to Is.LessThan(0) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...Using(IComparer comparer) 22 | ...Using(IComparer comparer) 23 | ...Using(Comparison comparer) 24 | ...Within(object tolerance) 25 | ``` 26 | 27 | ## Examples of Use 28 | 29 | ```csharp 30 | Assert.That(3, Is.LessThan(7)); 31 | Assert.That(myOwnObject, Is.LessThan(theExpected).Using(myComparer)); 32 | Assert.That(-5, Is.Negative); 33 | Assert.That(myDateTime, Is.LessThan(expectedDateTime).Within(TimeSpan.FromSeconds(1))) 34 | ``` 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/LessThanOrEqualConstraint.md: -------------------------------------------------------------------------------- 1 | # LessThanOrEqual Constraint 2 | 3 | `LessThanOrEqualConstraint` tests that one value is less than or equal to another. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | LessThanOrEqualConstraint(object expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.LessThanOrEqualTo(object expected) 15 | Is.AtMost(object expected) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...Using(IComparer comparer) 22 | ...Using(IComparer comparer) 23 | ...Using(Comparison comparer) 24 | ...Within(object tolerance) 25 | ``` 26 | 27 | ## Examples of Use 28 | 29 | ```csharp 30 | Assert.That(3, Is.LessThanOrEqualTo(7)); 31 | Assert.That(3, Is.AtMost(7)); 32 | Assert.That(3, Is.LessThanOrEqualTo(3)); 33 | Assert.That(3, Is.AtMost(3)); 34 | Assert.That(myOwnObject, Is.LessThanOrEqualTo(theExpected).Using(myComparer)); 35 | Assert.That(myDateTime, Is.LessThanOrEqualTo(expectedDateTime).Within(TimeSpan.FromSeconds(1))) 36 | ``` 37 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/NaNConstraint.md: -------------------------------------------------------------------------------- 1 | # NaN Constraint 2 | 3 | `NaNConstraint` tests that a value is floating-point NaN. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | NaNConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.NaN 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(aDouble, Is.NaN); 21 | Assert.That(aDouble, Is.Not.NaN); 22 | ``` 23 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/NoItemConstraint.md: -------------------------------------------------------------------------------- 1 | # NoItem Constraint 2 | 3 | `NoItemConstraint` applies a constraint to each item in a collection, succeeding only if all of them fail. An exception 4 | is thrown if the actual value passed does not implement `IEnumerable`. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | NoItemConstraint(Constraint itemConstraint) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Has.None... 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | int[] iarray = new int[] { 1, 2, 3 }; 22 | string[] sarray = new string[] { "a", "b", "c" }; 23 | Assert.That(iarray, Has.None.Null); 24 | Assert.That(sarray, Has.None.EqualTo("d")); 25 | Assert.That(iarray, Has.None.LessThan(0)); 26 | ``` 27 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/NotConstraint.md: -------------------------------------------------------------------------------- 1 | # Not Constraint 2 | 3 | `NotConstraint` reverses the effect of another constraint. If the base constraint fails, NotConstraint succeeds. If the 4 | base constraint succeeds, NotConstraint fails. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | NotConstraint() 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.Not... 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That(collection, Is.Not.Unique); 22 | Assert.That(2 + 2, Is.Not.EqualTo(5)); 23 | ``` 24 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/NullConstraint.md: -------------------------------------------------------------------------------- 1 | # Null Constraint 2 | 3 | `NullConstraint` tests that a value is null. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | NullConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.Null 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(anObject, Is.Null); 21 | Assert.That(anObject, Is.Not.Null); 22 | ``` 23 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/OrConstraint.md: -------------------------------------------------------------------------------- 1 | # Or Constraint 2 | 3 | `OrConstraint` combines two other constraints and succeeds if either of them succeeds. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | OrConstraint(Constraint left, Constraint right) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | .Or. 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(3, Is.LessThan(5).Or.GreaterThan(10)); 21 | ``` 22 | 23 | ## Evaluation Order and Precedence 24 | 25 | Note that the constraint evaluates the sub-constraints left to right, meaning that 26 | `Assert.That(i,Is.Null.Or.GreaterThan(9));` where `i` is a nullable `int` will work for both `12` and `null`. On the 27 | other hand, `Assert.That(i, Is.GreaterThan(9).Or.Null);` will only work for `12`, but throw an exception for `null`, as 28 | `null` cannot be compared to `9`. 29 | 30 | The **OrConstraint** has precedence over the **AndConstraint**. 31 | 32 | ## See also 33 | 34 | * [AndConstraint](AndConstraint.md) 35 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/PropertyConstraint.md: -------------------------------------------------------------------------------- 1 | # Property Constraint 2 | 3 | `PropertyConstraint` tests for the existence of a named property on an object and then applies a constraint test to the 4 | property value. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | PropertyConstraint(string name, IConstraint baseConstraint) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Has.Property(string name)... // followed by further constraint syntax 16 | ``` 17 | 18 | ## Examples of Use 19 | 20 | ```csharp 21 | Assert.That(someObject, Has.Property("Version").EqualTo("2.0")); 22 | Assert.That(collection, Has.Property("Count").GreaterThan(10)); 23 | Assert.That(collection, Has.Count.GreaterThan(10); 24 | ``` 25 | 26 | As shown in the example, certain common properties are known to NUnit and may be tested using a shorter form. The 27 | following properties are supported: 28 | 29 | ```csharp 30 | Has.Length... 31 | Has.Count... 32 | Has.Message... 33 | Has.InnerException... 34 | ``` 35 | 36 | ## See also 37 | 38 | * [PropertyExistsConstraint](PropertyExistsConstraint.md) 39 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/PropertyExistsConstraint.md: -------------------------------------------------------------------------------- 1 | # PropertyExists Constraint 2 | 3 | The `PropertyExistsConstraint` tests for the existence of a named property on an object. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | PropertyExistsConstraint(string name) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Has.Property(string) 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(someObject, Has.Property("Version")); 21 | ``` 22 | 23 | ## See also 24 | 25 | * [PropertyConstraint](PropertyConstraint.md) 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/RangeConstraint.md: -------------------------------------------------------------------------------- 1 | # Range Constraint 2 | 3 | `RangeConstraint` tests that a value is in an (inclusive) range. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | RangeConstraint(IComparable from, IComparable to) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.InRange(IComparable from, IComparable to) 15 | ``` 16 | 17 | ## Modifiers 18 | 19 | ```csharp 20 | ...Using(IComparer comparer) 21 | ...Using(IComparer comparer) 22 | ...Using(Comparison comparer) 23 | ``` 24 | 25 | ## Examples of Use 26 | 27 | ```csharp 28 | int[] iarray = new int[] { 1, 2, 3 }; 29 | 30 | Assert.That(42, Is.InRange(1, 100)); 31 | Assert.That(iarray, Is.All.InRange(1, 3)); 32 | Assert.That(myOwnObject, Is.InRange(lowExpected, highExpected).Using(myComparer)); 33 | ``` 34 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/RegexConstraint.md: -------------------------------------------------------------------------------- 1 | # RegexConstraint 2 | 3 | `RegexConstraint` tests that a pattern is matched. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | RegexConstraint(string pattern) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Does.Match(string pattern) 15 | Matches(string pattern) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...IgnoreCase 22 | ``` 23 | 24 | ## Examples of Use 25 | 26 | ```csharp 27 | string phrase = "Make your tests fail before passing!"; 28 | 29 | Assert.That(phrase, Does.Match("Make.*tests.*pass")); 30 | Assert.That(phrase, Does.Match("make.*tests.*PASS").IgnoreCase); 31 | Assert.That(phrase, Does.Not.Match("your.*passing.*tests")); 32 | ``` 33 | 34 | ## Notes 35 | 36 | 1. **Matches** may appear only in the body of a constraint 37 | expression or when the inherited syntax is used. 38 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/SameAsConstraint.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: sameasconstraint 3 | --- 4 | 5 | # SameAs Constraint 6 | 7 | A `SameAsConstraint` is used to test whether the object passed 8 | as an actual value has the same identity as the object supplied 9 | in its constructor. 10 | 11 | ## Constructor 12 | 13 | ```csharp 14 | SameAsConstraint(object expected) 15 | ``` 16 | 17 | ## Syntax 18 | 19 | ```csharp 20 | Is.SameAs(object expected) 21 | ``` 22 | 23 | ## Examples of Use 24 | 25 | ```csharp 26 | Exception ex1 = new Exception(); 27 | Exception ex2 = ex1; 28 | Assert.That(ex2, Is.SameAs(ex1)); 29 | Exception ex3 = new Exception(); 30 | Assert.That(ex3, Is.Not.SameAs(ex1)); 31 | ``` 32 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/SamePathConstraint.md: -------------------------------------------------------------------------------- 1 | # SamePath Constraint 2 | 3 | `SamePathConstraint` tests that two paths are equivalent. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | SamePathConstraint(string expectedPath) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.SamePath(string expectedPath) 15 | ``` 16 | 17 | ## Modifiers 18 | 19 | ```csharp 20 | ...IgnoreCase 21 | ...RespectCase 22 | ``` 23 | 24 | ## Examples of Use 25 | 26 | ```csharp 27 | Assert.That("/folder1/./junk/../folder2", Is.SamePath("/folder1/folder2")); 28 | Assert.That("/folder1/./junk/../folder2/x", Is.Not.SamePath("/folder1/folder2")); 29 | 30 | Assert.That(@"C:\folder1\folder2", Is.SamePath(@"C:\Folder1\Folder2").IgnoreCase); 31 | Assert.That("/folder1/folder2", Is.Not.SamePath("/Folder1/Folder2").RespectCase); 32 | ``` 33 | 34 | ## Notes 35 | 36 | 1. Path constraints perform tests on paths, without reference to any 37 | actual files or directories. This allows testing paths that are 38 | created by an application for reference or later use, without 39 | any effect on the environment. 40 | 41 | 2. Path constraints are intended to work across multiple file systems, 42 | and convert paths to a canonical form before comparing them. 43 | 44 | 3. It is usually not necessary to know the file system of the paths 45 | in order to compare them. Where necessary, the programmer may 46 | use the **IgnoreCase** and **RespectCase** modifiers to provide 47 | behavior other than the system default. 48 | 49 | ## See also 50 | 51 | * [SubPathConstraint](SubPathConstraint.md) 52 | * [SamePathOrUnderConstraint](SamePathOrUnderConstraint.md) 53 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/SamePathOrUnderConstraint.md: -------------------------------------------------------------------------------- 1 | # SamePathOrUnder Constraint 2 | 3 | `SamePathOrUnderConstraint` tests that one path is equivalent to another path or that it is under it. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | SamePathOrUnderConstraint(string expectedPath) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.SamePathOrUnder(string expectedPath) 15 | ``` 16 | 17 | ## Modifiers 18 | 19 | ```csharp 20 | ...IgnoreCase 21 | ...RespectCase 22 | ``` 23 | 24 | ## Examples of Use 25 | 26 | ```csharp 27 | Assert.That("/folder1/./junk/../folder2", Is.SamePathOrUnder("/folder1/folder2")); 28 | Assert.That("/folder1/junk/../folder2/./folder3", Is.SamePathOrUnder("/folder1/folder2")); 29 | Assert.That("/folder1/junk/folder2/folder3", Is.Not.SamePathOrUnder("/folder1/folder2")); 30 | 31 | Assert.That(@"C:\folder1\folder2\folder3", Is.SamePathOrUnder(@"C:\Folder1\Folder2").IgnoreCase); 32 | Assert.That("/folder1/folder2/folder3", Is.Not.SamePathOrUnder("/Folder1/Folder2").RespectCase); 33 | ``` 34 | 35 | ## Notes 36 | 37 | 1. Path constraints perform tests on paths, without reference to any 38 | actual files or directories. This allows testing paths that are 39 | created by an application for reference or later use, without 40 | any effect on the environment. 41 | 42 | 2. Path constraints are intended to work across multiple file systems, 43 | and convert paths to a canonical form before comparing them. 44 | 45 | 3. It is usually not necessary to know the file system of the paths 46 | in order to compare them. Where necessary, the programmer may 47 | use the **IgnoreCase** and **RespectCase** modifiers to provide 48 | behavior other than the system default. 49 | 50 | ## See also 51 | 52 | * [SamePathConstraint](SamePathConstraint.md) 53 | * [SubPathConstraint](SubPathConstraint.md) 54 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/SomeItemsConstraint.md: -------------------------------------------------------------------------------- 1 | # SomeItems Constraint 2 | 3 | `SomeItemsConstraint` applies a constraint to each item in an `IEnumerable`, succeeding if at least one of them 4 | succeeds. An exception is thrown if the actual value passed does not implement `IEnumerable`. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | SomeItemsConstraint(Constraint itemConstraint) 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Has.Some... 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...IgnoreCase 22 | ...IgnoreWhiteSpace // From version 4.2 23 | ...Using(IEqualityComparer comparer) 24 | ...Using(IComparer comparer) 25 | ...Using(IEqualityComparer comparer) 26 | ...Using(IComparer comparer) 27 | ...Using(Comparison comparer) 28 | ...Using(Func comparer) 29 | ...UsingPropertiesComparer() // From version 4.1 30 | ...UsingPropertiesComparer( 31 | Func configure) // From version 4.4 33 | ``` 34 | 35 | ## Examples of Use 36 | 37 | ```csharp 38 | int[] iarray = new int[] { 1, 2, 3 }; 39 | string[] sarray = new string[] { "a", "b", "c" }; 40 | Assert.That(iarray, Has.Some.GreaterThan(2)); 41 | Assert.That(sarray, Has.Some.Length.EqualTo(1)); 42 | ``` 43 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/StartsWithConstraint.md: -------------------------------------------------------------------------------- 1 | # StartsWith Constraint 2 | 3 | `StartsWithConstraint` tests for an initial string. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | StartsWithConstraint(string expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Does.StartWith(string expected) 15 | StartsWith(string expected) 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...IgnoreCase 22 | ``` 23 | 24 | ## Examples of Use 25 | 26 | ```csharp 27 | string phrase = "Make your tests fail before passing!"; 28 | 29 | Assert.That(phrase, Does.StartWith("Make")); 30 | Assert.That(phrase, Does.Not.StartWith("Break")); 31 | ``` 32 | 33 | ## Notes 34 | 35 | 1. **StartsWith** may appear only in the body of a constraint 36 | expression or when the inherited syntax is used. 37 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/SubPathConstraint.md: -------------------------------------------------------------------------------- 1 | # SubPath Constraint 2 | 3 | `SubPathConstraint` tests that one path is under another path. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | SubPathConstraint(string expectedPath) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.SubPathOf(string expectedPath) 15 | ``` 16 | 17 | ## Modifiers 18 | 19 | ```csharp 20 | ...IgnoreCase 21 | ...RespectCase 22 | ``` 23 | 24 | ## Examples of Use 25 | 26 | ```csharp 27 | Assert.That("/folder1/./junk/../folder2", Is.SubPathOf("/folder1/")); 28 | Assert.That("/folder1/junk/folder2", Is.Not.SubPathOf("/folder1/folder2")); 29 | 30 | Assert.That(@"C:\folder1\folder2\Folder3", Is.SubPathOf(@"C:\Folder1\Folder2").IgnoreCase); 31 | Assert.That("/folder1/folder2/folder3", Is.Not.SubPathOf("/Folder1/Folder2/Folder3").RespectCase); 32 | ``` 33 | 34 | ## Notes 35 | 36 | 1. Path constraints perform tests on paths, without reference to any 37 | actual files or directories. This allows testing paths that are 38 | created by an application for reference or later use, without 39 | any effect on the environment. 40 | 41 | 2. Path constraints are intended to work across multiple file systems, 42 | and convert paths to a canonical form before comparing them. 43 | 44 | 3. It is usually not necessary to know the file system of the paths 45 | in order to compare them. Where necessary, the programmer may 46 | use the **IgnoreCase** and **RespectCase** modifiers to provide 47 | behavior other than the system default. 48 | 49 | ## See also 50 | 51 | * [SamePathConstraint](SamePathConstraint.md) 52 | * [SamePathOrUnderConstraint](SamePathOrUnderConstraint.md) 53 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/SubstringConstraint.md: -------------------------------------------------------------------------------- 1 | # Substring Constraint 2 | 3 | `SubstringConstraint` tests for a substring. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | SubstringConstraint(string expected) 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Does.Contain(string expected) 15 | ``` 16 | 17 | ## Modifiers 18 | 19 | ```csharp 20 | ...IgnoreCase 21 | ``` 22 | 23 | ## Examples of Use 24 | 25 | ```csharp 26 | string phrase = "Make your tests fail before passing!"; 27 | 28 | Assert.That(phrase, Does.Contain("tests fail")); 29 | Assert.That(phrase, Does.Not.Contain("tests pass")); 30 | Assert.That(phrase, Does.Contain("make").IgnoreCase); 31 | ``` 32 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/ThrowsNothingConstraint.md: -------------------------------------------------------------------------------- 1 | # ThrowsNothing Constraint 2 | 3 | `ThrowsNothingConstraint` asserts that the delegate passed as its argument does not throw an exception. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | ThrowsNothingConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Throws.Nothing 15 | ``` 16 | 17 | ## Example of Use 18 | 19 | ```csharp 20 | Assert.That(() => SomeMethod(actual), Throws.Nothing); 21 | ``` 22 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/TrueConstraint.md: -------------------------------------------------------------------------------- 1 | # True Constraint 2 | 3 | `TrueConstraint` tests that a value is true. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | TrueConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.True 15 | ``` 16 | 17 | ## Example of Use 18 | 19 | ```csharp 20 | Assert.That(condition, Is.True); 21 | ``` 22 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/UniqueItemsConstraint.md: -------------------------------------------------------------------------------- 1 | # UniqueItems Constraint 2 | 3 | **UniqueItemsConstraint** tests that an array, collection or other IEnumerable is composed 4 | of unique items with no duplicates. 5 | 6 | ## Constructor 7 | 8 | ```csharp 9 | UniqueItemsConstraint() 10 | ``` 11 | 12 | ## Syntax 13 | 14 | ```csharp 15 | Is.Unique 16 | ``` 17 | 18 | ## Modifiers 19 | 20 | ```csharp 21 | ...IgnoreCase 22 | ...IgnoreWhiteSpace // From version 4.2 23 | ...Using(IEqualityComparer comparer) 24 | ...Using(IComparer comparer) 25 | ...Using(IEqualityComparer comparer) 26 | ...Using(IComparer comparer) 27 | ...Using(Comparison comparer) 28 | ...Using(Func comparer) 29 | ...UsingPropertiesComparer() // From version 4.1 30 | ...UsingPropertiesComparer( 31 | Func configure) // From version 4.4 33 | ``` 34 | 35 | ## Example of Use 36 | 37 | ```csharp 38 | int[] iarray = new int[] { 1, 2, 3 }; 39 | Assert.That(iarray, Is.Unique); 40 | ``` 41 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/WhiteSpaceConstraint.md: -------------------------------------------------------------------------------- 1 | # WhiteSpace Constraint 2 | 3 | The `WhiteSpaceConstraint` tests if a string contains only white-space. 4 | 5 | The constraint is the equivalent of 6 | [String.IsNullOrWhiteSpace](https://learn.microsoft.com/en-us/dotnet/api/system.string.isnullorwhitespace?view=net-8.0) 7 | 8 | White-space characters are defined by the Unicode standard as interpreted by 9 | [Char.IsWhiteSpace](https://learn.microsoft.com/en-us/dotnet/api/system.char.iswhitespace?view=net-8.0) method. 10 | 11 | ## Constructor 12 | 13 | ```csharp 14 | WhiteSpaceConstraint() 15 | ``` 16 | 17 | ## Syntax 18 | 19 | ```csharp 20 | Is.WhiteSpace // From version 4.2 21 | ``` 22 | 23 | ## Examples of Use 24 | 25 | ```csharp 26 | Assert.That(" ", Is.WhiteSpace); 27 | Assert.That("A String", Is.Not.WhiteSpace); 28 | ``` 29 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/constraints/XmlSerializableConstraint.md: -------------------------------------------------------------------------------- 1 | # XmlSerializable Constraint 2 | 3 | `XmlSerializableConstraint` tests whether an object is serializable in XML format. 4 | 5 | ## Constructor 6 | 7 | ```csharp 8 | XmlSerializableConstraint() 9 | ``` 10 | 11 | ## Syntax 12 | 13 | ```csharp 14 | Is.XmlSerializable 15 | ``` 16 | 17 | ## Examples of Use 18 | 19 | ```csharp 20 | Assert.That(someObject, Is.XmlSerializable)); 21 | ``` 22 | 23 | ## See also 24 | 25 | * [BinarySerializableConstraint](BinarySerializableConstraint.md) 26 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/setup-teardown/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Index 2 | href: index.md 3 | - name: "Changes 2.6.x --> 3.x" 4 | href: SetUp-and-TearDown-Changes.md 5 | -------------------------------------------------------------------------------- /docs/articles/nunit/writing-tests/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Attributes 2 | href: attributes.md 3 | - name: Attribute Descriptions 4 | href: attributes/toc.yml 5 | topicHref: attributes/apartment.md 6 | - name: Assertions 7 | href: assertions/toc.yml 8 | topicHref: assertions/assertions.md 9 | - name: Assumptions 10 | href: Assumptions.md 11 | - name: Warnings 12 | href: Warnings.md 13 | - name: Constraints 14 | href: constraints/toc.yml 15 | topicHref: constraints/Constraints.md 16 | - name: "[SetUp] and [TearDown]" 17 | href: setup-teardown/toc.yml 18 | topicHref: setup-teardown/index.md 19 | - name: TestCaseData 20 | href: TestCaseData.md 21 | - name: TestFixtureData 22 | href: TestFixtureData.md 23 | - name: TestContext 24 | href: TestContext.md 25 | - name: AssertionHelper 26 | href: AssertionHelper.md 27 | - name: ListMapper 28 | href: ListMapper.md 29 | - name: Randomizer Methods 30 | href: Randomizer-Methods.md 31 | 32 | -------------------------------------------------------------------------------- /docs/articles/toc.yml: -------------------------------------------------------------------------------- 1 | - name: NUnit 2 | href: nunit/toc.yml 3 | topicHref: nunit/intro.md 4 | - name: VS Test Adapter 5 | href: vs-test-adapter/toc.yml 6 | topicHref: vs-test-adapter/Index.md 7 | - name: NUnit Engine 8 | href: nunit-engine/toc.yml 9 | topicHref: nunit-engine/Index.md 10 | - name: NUnit Xamarin Runners 11 | href: xamarin-runners/toc.yml 12 | topicHref: xamarin-runners/index.md 13 | - name: VS Test Generator 14 | href: vs-test-generator/toc.yml 15 | topicHref: vs-test-generator/Visual-Studio-Test-Generator.md 16 | - name: NUnit Analyzers 17 | href: nunit-analyzers/toc.yml 18 | topicHref: nunit-analyzers/NUnit-Analyzers.md 19 | - name: Related Project Links 20 | items: 21 | - name: TestCentric GUI 22 | href: https://github.com/TestCentric/testcentric-gui/wiki 23 | - name: NUnit Project Editor 24 | href: https://github.com/nunit-legacy/nunit-project-editor/wiki/Project-Editor 25 | - name: Developer Info 26 | href: developer-info/toc.yml 27 | - name: "Legacy (2.x) Docs" 28 | href: legacy/index.md 29 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Adapter-License.md: -------------------------------------------------------------------------------- 1 | # License - NUnit and NUnit3 Test Adapters for Visual Studio 2 | 3 | ## MIT License 4 | 5 | Copyright (c) 2011-2021 Charlie Poole, 2014-2023 Terje Sandstrom 6 | 7 | Permission is hereby granted, free of charge, to any person obtaining a copy 8 | of this software and associated documentation files (the "Software"), to deal 9 | in the Software without restriction, including without limitation the rights 10 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 | copies of the Software, and to permit persons to whom the Software is 12 | furnished to do so, subject to the following conditions: 13 | 14 | The above copyright notice and this permission notice shall be included in 15 | all copies or substantial portions of the Software. 16 | 17 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 20 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 | THE SOFTWARE. 24 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Adapter-Release-Notes.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Debugging.md: -------------------------------------------------------------------------------- 1 | # Debugging the NUnit3TestAdapter 2 | 3 | ## Enable Tracing 4 | 5 | Before debugging the adapter, check the trace outputs, which can be enabled using runsettings, either from a file or 6 | the command line. 7 | 8 | Enable the following [features](https://docs.nunit.org/articles/vs-test-adapter/Tips-And-Tricks.html#dumpxmltestdiscovery-and-dumpxmltestresults): 9 | 10 | ```xml 11 | true 12 | true 13 | ``` 14 | 15 | This will create a Dump folder under the executing bin directory, containing one file for each setting. These files 16 | include both the input from the testhost and the resulting data returned by the framework/engine. 17 | 18 | ## Enabling debugging 19 | 20 | Debugging the adapter is done by first creating a debug version of the adapter. 21 | You can then enable a debug run by passing one of the NUnit debug settings using runsettings. 22 | 23 | The symbols are: 24 | 25 | ```cmd 26 | NUnit.DebugExecution 27 | NUnit.DebugDiscovery 28 | NUnit.Debug 29 | ``` 30 | 31 | The last setting is equal to setting both of the two above. 32 | 33 | From command line, you can set these by adding 34 | 35 | ```cmd 36 | dotnet test -- NUnit.DebugExecution=true 37 | ``` 38 | 39 | If you want to do this using Visual Studio, you must add a runsettings file, and add these settings there to the NUnit 40 | section. 41 | 42 | A detailed explanation of the process can be found in [this blog post](https://hermit.no/debugging-the-nunit3testadapter-take-2/) 43 | 44 | ## Debugging earlier versions 45 | 46 | See [this blog post](https://hermit.no/debugging-the-nunit3testadapter/) for details on that process. 47 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Index.md: -------------------------------------------------------------------------------- 1 | # Visual Studio Test Adapter 2 | 3 | The NUnit 3 Test Adapter allows you to run NUnit 3 and 4 tests inside Visual Studio or with `dotnet` on the command line. 4 | 5 | The current release is designed to work with Visual Studio 2012, 2013, 2015, 2017, 2019 and 2022. Some features are not 6 | available under VS2012 RTM. It also works from the command line using either `vstest.console` or `dotnet test`. 7 | 8 | The current release works with .net framework 3.5 and higher, with .net core `3.*`, and with .net 5, .net 6, and .net 7. 9 | 10 | Releases of Visual Studio prior to VS 2012 did not have the ability to directly run tests built with Open Source testing 11 | frameworks like NUnit. 12 | 13 | [Download Released versions](https://www.nuget.org/packages/NUnit3TestAdapter/) 14 | 15 | [Download Pre-release versions](https://www.myget.org/feed/nunit/package/nuget/NUnit3TestAdapter) 16 | 17 | The adapter is delivered as a nuget package to be installed into all test projects. 18 | 19 | > [!NOTE] 20 | > Up to version 3.17 there is also a VSIX extension version, which was used earlier for Visual Studio up to 21 | > version 2019. The support for this has been deprecated, and the existing VSIX version does not work for VS 2022. The 22 | > recommendation is to avoid this altogether and use the nuget version. It is not possible to run NUnit 2.x tests using 23 | > this adapter. Use the original adapter for that purpose. If you need to work with projects using NUnit 2.x and other 24 | > projects using NUnit 3, you may install both versions of the adapter. 25 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Resources.md: -------------------------------------------------------------------------------- 1 | # Resources 2 | 3 | ## Further information 4 | 5 | For more information see the blogs by [Charlie Poole](http://nunit.com/articles/), [Rob Prouse](https://alteridem.net/) 6 | and [Terje Sandstrom](https://hermit.no) 7 | 8 | The MSDN ALM blog post series on _How to Manage Unit Tests in Visual Studio 2012 Update 1_ is useful for later versions 9 | as well: 10 | 11 | * [Part 1: Using Traits in the Unit Test 12 | Explorer](https://devblogs.microsoft.com/devops/how-to-manage-unit-tests-in-visual-studio-2012-update-1-part-1using-traits-in-the-unit-test-explorer/) 13 | 14 | * [Part 2: Using Traits with different test frameworks in the Unit Test 15 | Explorer](https://devblogs.microsoft.com/devops/part-2using-traits-with-different-test-frameworks-in-the-unit-test-explorer/) 16 | 17 | * [Part 3: Unit testing with Traits and code coverage in Visual Studio 2012 using the TFS 18 | Build](https://devblogs.microsoft.com/devops/part-3-unit-testing-with-traits-and-code-coverage-in-visual-studio-2012-using-the-tfs-build-and-the-new-nuget-adapter-approach/) 19 | 20 | For Information on testing .Net core see [Testing .NET Core with NUnit in Visual Studio 21 | 2017](https://alteridem.net/2017/05/04/test-net-core-nunit-vs2017/) 22 | 23 | ## Reporting Problems 24 | 25 | Bugs should be reported using the [issue tracker](https://github.com/nunit/nunit3-vs-adapter/issues) on Github. 26 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Trace-and-Debug.md: -------------------------------------------------------------------------------- 1 | # How to enable Trace and Debug output 2 | 3 | Trace and Debug output is by default not sent to the console output, or anywhere else. If you want to have this output, 4 | you must add a `TraceListener` as documented [in this article on trace and debug output](xref:traceanddebugoutput). 5 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/Usage.md: -------------------------------------------------------------------------------- 1 | # Usage 2 | 3 | In preparation for using the test adapter, make sure that the Unit Test Explorer is shown in your window. If you don't 4 | see it, use the menu ( Test | Windows | Test Explorer ) to show it and position the window where you would like it 5 | within Visual Studio. 6 | 7 | ![The unit test explorer window within Visual Studio](~/images/nunitTestAdapter.png) 8 | 9 | When you initially open a solution, no tests will be displayed. After compiling the assemblies in the solution, Visual 10 | Studio will interact with the NUnit Test Adapter to discover tests and a list of them will be shown in the Test 11 | Explorer. 12 | 13 | Click on Run All in the Test Explorer to run all the tests. You may also select one or more tests in the list and run 14 | them by right-clicking and using the context menu. The context menu also contains entries for debugging tests and for 15 | navigating to the source code of a test. 16 | 17 | Tests may be grouped by Duration and Outcome under VS2012 RTM and also by Traits and Project using Update 1 or later, 18 | and Class using Update 2 or later. NUnit translates any Categories and Properties used on your tests to Visual Studio 19 | as Traits. 20 | 21 | Tests may be filtered in Visual Studio under Update 1 or later by Trait, Project, Error Message, File Path, Fully 22 | Qualified Name, Output and Outcome. Use the search edit box at the top of the list of tests to specify a filter. 23 | 24 | Tests may be organized by play lists in Visual Studio under Update 2 or later. Playlists are more or less equal to the 25 | old test lists from VS 2010. 26 | 27 | Parameterized tests will show up as separate test cases for each set of parameters. 28 | 29 | For settings options, see the [Tips and Tricks](xref:tipsandtricks) 30 | -------------------------------------------------------------------------------- /docs/articles/vs-test-adapter/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Visual Studio Test Adapter 2 | href: Index.md 3 | - name: Installation 4 | href: Adapter-Installation.md 5 | - name: Usage 6 | href: Usage.md 7 | - name: Resources 8 | href: Resources.md 9 | - name: Known Problems 10 | href: Known-Problems.md 11 | - name: Configuration with runsettings 12 | href: Tips-And-Tricks.md 13 | - name: Microsoft.Testing.Platform (MTP) 14 | href: NUnit-And-Microsoft-Test-Platform.md 15 | - name: Trace And Debug Output 16 | href: Trace-and-Debug.md 17 | - name: Supported Frameworks 18 | href: Supported-Frameworks.md 19 | - name: Adapter-Engine Compatibility 20 | href: Adapter-Engine-Compatibility.md 21 | - name: Debugging the Adapter 22 | href: Debugging.md 23 | - name: Debugger Source-Stepping 24 | href: Adapter-Source-Stepping.md 25 | - name: Release Notes V4 26 | href: AdapterV4-Release-Notes.md 27 | - name: Release Notes V3 28 | href: AdapterV3-Release-Notes.md 29 | - name: Release Notes V2 30 | href: AdapterV2-Release-Notes.md 31 | - name: License 32 | href: Adapter-License.md 33 | -------------------------------------------------------------------------------- /docs/articles/vs-test-generator/TestGenerator-Installation.md: -------------------------------------------------------------------------------- 1 | # TestGenerator Extension for NUnit in Visual Studio Installation 2 | 3 | You can download this extension from inside Visual Studio, choosing Tools/Extensions and Updates and search for Test 4 | Generator. You will then find the appropriate extension for VS 2015 or VS 2017/2019. 5 | 6 | ## For Visual Studio 2022 7 | 8 | You can download from the marketplace [Visual Studio 9 | Gallery](https://marketplace.visualstudio.com/items?itemName=NUnitDevelopers.nunittestgeneratorextension2022) or from 10 | the [GitHub Release page](https://github.com/nunit/nunit-vs-testgenerator/releases) 11 | 12 | ## For Visual Studio 2017/2019 13 | 14 | You can download from the marketplace [Visual Studio 15 | Gallery](https://marketplace.visualstudio.com/items?itemName=NUnitDevelopers.TestGeneratorNUnitextension-18371) or from 16 | the [GitHub Release page](https://github.com/nunit/nunit-vs-testgenerator/releases) 17 | 18 | ## For Visual Studio 2015 19 | 20 | You can download from the marketplace [Visual Studio 21 | Gallery](https://visualstudiogallery.msdn.microsoft.com/bd30bf3f-4183-4b00-a245-1875316b8cd3) or from the [GitHub 22 | Release page](https://github.com/nunit/nunit-vs-testgenerator/releases) 23 | -------------------------------------------------------------------------------- /docs/articles/vs-test-generator/TestGenerator-Release-Notes-VS2015.md: -------------------------------------------------------------------------------- 1 | # TestGenerator Release Notes - VS2015 2 | 3 | ## TestGenerator Extension for NUnit in Visual Studio 2015 - Version 1.1 - March 5, 2017 4 | 5 | ### Bugs and minor fixes 6 | 7 | * #6 NUnit3 tests using removed ExpectedException attribute 8 | * #10 Specify NUnit versions as v2 and v3 9 | * #11 Update `more information` link 10 | * #14 Update NUnit version (will use latest version) 11 | 12 | ### Notes 13 | 14 | * The TestGenerator extension is released as separate VSIXes for VS 2015 and VS 2017/2019. See 15 | [Installation](TestGenerator-Installation.md) for details. The Version 2.X is for VS2017/2019, the Version 1.X is for 16 | VS 2015. 17 | -------------------------------------------------------------------------------- /docs/articles/vs-test-generator/TestGenerator-Release-Notes-VS2017-VS2019.md: -------------------------------------------------------------------------------- 1 | # TestGenerator Release Notes - VS 2017 and 2019 2 | 3 | ## TestGenerator Extension for NUnit in Visual Studio 2017 and 2019 - Version 2.3 - September 20, 2019 4 | 5 | ### Features 6 | 7 | * [PR 33](https://github.com/nunit/nunit-vs-testgenerator/pull/33) [Create Unit Test] Fixing package versions. This is 8 | needed in order to work for .net core projects. With Visual Studio 2019, Update 3, it is possible to use this 9 | extension to create tests. 10 | 11 | ## TestGenerator Extension for NUnit in Visual Studio 2017/2019 - Version 2.1 - November 22, 2018 12 | 13 | Visual Studio 2017 15.9 and forward should have the adapter added to each test project. This release ensures that by 14 | fixing #25. 15 | 16 | ### Features 17 | 18 | * [25](https://github.com/nunit/nunit-vs-testgenerator/issues/25) Add the test adapter as part of the package. Thanks 19 | to [yowko](https://github.com/yowko) for the PR 20 | 21 | ## TestGenerator Extension for NUnit in Visual Studio 2017/2019 - Version 2 - March 5, 2017 22 | 23 | ### Features 24 | 25 | * #8 Support for VS 2017/2019 26 | 27 | ### Bugs and minor fixes 28 | 29 | * #6 NUnit3 tests using removed ExpectedException attribute 30 | * #10 Specify NUnit versions as v2 and v3 31 | * #11 Update more information link 32 | * #14 Update NUnit version (will use latest version) 33 | 34 | ### Notes 35 | 36 | * The TestGenerator extension is released as separate VSIXes for VS 2015 and VS 2017/2019. See 37 | [Installation](TestGenerator-Installation.md) for details. The Version 2 is for VS2017/2019, the Version 1 is for VS 38 | 2015. 39 | -------------------------------------------------------------------------------- /docs/articles/vs-test-generator/TestGenerator-Release-Notes.md: -------------------------------------------------------------------------------- 1 | # TestGenerator Release Notes - VS 2022 2 | 3 | ## TestGenerator Extension for NUnit in Visual Studio 2022 - Version 3.0 - March 7, 2023 4 | 5 | This version is an x64 only release. It is compatible with Visual Studio 2022. 6 | 7 | ### Fixes 8 | 9 | * [41](https://github.com/nunit/nunit-vs-testgenerator/issues/41) Add Support for VS2022 10 | * [47](https://github.com/nunit/nunit-vs-testgenerator/issues/47) Remove NUnit 2 11 | -------------------------------------------------------------------------------- /docs/articles/vs-test-generator/Visual-Studio-Test-Generator.md: -------------------------------------------------------------------------------- 1 | --- 2 | uid: vstestgenerator 3 | --- 4 | 5 | # Visual Studio Test Generator 6 | 7 | This is an extension for Visual Studio 2015, 2017/2019 and 2022 that extends the test functionality to allow you to 8 | create unit tests and IntelliTests. This extension extends the built in test generator functionality allowing developers 9 | to generate tests using NUnit 2.6.x (not for VS2022) or NUnit 3.X. 10 | 11 | Please note that IntelliTest is only available in Visual Studio Enterprise edition. Other versions of Visual Studio only 12 | have the `Create Unit Tests` menu option. 13 | 14 | ## Download 15 | 16 | You can download this extension in Visual Studio using **Tools | Extensions and Updates...** 17 | and searching for **Test Generator NUnit Extension**. You can also download from the [Visual Studio 18 | Gallery](https://marketplace.visualstudio.com/items?itemName=NUnitDevelopers.TestGeneratorNUnitextension) for VS 2015 19 | and [here for VS 20 | 2017](https://marketplace.visualstudio.com/items?itemName=NUnitDevelopers.TestGeneratorNUnitextension-18371), or from 21 | the [GitHub Releases Page](https://github.com/nunit/nunit-vs-testgenerator/releases). 22 | 23 | ### How to Use 24 | 25 | For more information on using IntelliTest and this extension, please see the [Microsoft 26 | documentation][IntelliTestLink]. 27 | 28 | #### Right-Click to Create Tests 29 | 30 | ![Right-Click to Create Tests](~/images/right-click-create-tests.png) 31 | 32 | #### Select NUnit from the Test Framework dropdown 33 | 34 | ![Selecting NUnit](~/images/right-click-create-tests-select-nunit.png) 35 | 36 | [IntelliTestLink]: https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2015/test/generate-unit-tests-for-your-code-with-intellitest?view=vs-2015&redirectedfrom=MSDN 37 | -------------------------------------------------------------------------------- /docs/articles/vs-test-generator/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Visual Studio Test Generator 2 | href: Visual-Studio-Test-Generator.md 3 | - name: Installation 4 | href: TestGenerator-Installation.md 5 | - name: Release Notes 6 | href: TestGenerator-Release-Notes.md 7 | - name: Release Notes VS2017/VS2019 8 | href: TestGenerator-Release-Notes-VS2017-VS2019.md 9 | - name: Release Notes VS2015 10 | href: TestGenerator-Release-Notes-VS2015.md -------------------------------------------------------------------------------- /docs/articles/xamarin-runners/toc.yml: -------------------------------------------------------------------------------- 1 | - name: "Index & Options" 2 | href: index.md 3 | - name: Getting Started in Visual Studio 4 | href: Getting-Started-in-Visual-Studio.md 5 | - name: Getting Started in VS for Mac 6 | href: Getting-Started-in-Visual-Studio-for-Mac.md 7 | -------------------------------------------------------------------------------- /docs/css/img/bulletOff.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/css/img/bulletOff.gif -------------------------------------------------------------------------------- /docs/css/img/bulletOn.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/css/img/bulletOn.gif -------------------------------------------------------------------------------- /docs/custom_template/favicon.ico: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/custom_template/favicon.ico -------------------------------------------------------------------------------- /docs/custom_template/styles/main.css: -------------------------------------------------------------------------------- 1 | div.across ul 2 | { 3 | width:100%; 4 | display:block; 5 | list-style:none 6 | } 7 | div.across ul li 8 | { 9 | float:left; 10 | display:block; 11 | width:9em 12 | } -------------------------------------------------------------------------------- /docs/favicons/android-chrome-192x192.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/android-chrome-192x192.png -------------------------------------------------------------------------------- /docs/favicons/android-chrome-384x384.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/android-chrome-384x384.png -------------------------------------------------------------------------------- /docs/favicons/apple-touch-icon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/apple-touch-icon.png -------------------------------------------------------------------------------- /docs/favicons/browserconfig.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | #222222 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /docs/favicons/favicon-16x16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/favicon-16x16.png -------------------------------------------------------------------------------- /docs/favicons/favicon-32x32.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/favicon-32x32.png -------------------------------------------------------------------------------- /docs/favicons/favicon.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/favicon.png -------------------------------------------------------------------------------- /docs/favicons/favicon.svg: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /docs/favicons/manifest.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "docs.nunit.org", 3 | "short_name": "NUnit Docs", 4 | "icons": [ 5 | { 6 | "src": "android-chrome-192x192.png", 7 | "sizes": "192x192", 8 | "type": "image/png" 9 | }, 10 | { 11 | "src": "android-chrome-384x384.png", 12 | "sizes": "384x384", 13 | "type": "image/png" 14 | } 15 | ], 16 | "theme_color": "#222222", 17 | "background_color": "#222222", 18 | "display": "standalone" 19 | } 20 | -------------------------------------------------------------------------------- /docs/favicons/mstile-150x150.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/favicons/mstile-150x150.png -------------------------------------------------------------------------------- /docs/files/Summary.xslt: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | Tests run: 11 | 12 | , Failures: 13 | 14 | , Not run: 15 | 16 | , Time: 17 | 18 | seconds 19 | 20 | 21 | 22 | 23 | Failures: 24 | 25 | 26 | Tests not run: 27 | 28 | 29 | 30 | 31 | 32 | 33 | ) 34 | 35 | : 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | -------------------------------------------------------------------------------- /docs/filterConfig.yml: -------------------------------------------------------------------------------- 1 | apiRules: 2 | - exclude: 3 | uidRegex: ^NUnit\.Framework\.Internal 4 | type: Namespace -------------------------------------------------------------------------------- /docs/fonts/bootstrap/glyphicons-halflings-regular.eot: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/fonts/bootstrap/glyphicons-halflings-regular.eot -------------------------------------------------------------------------------- /docs/fonts/bootstrap/glyphicons-halflings-regular.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/fonts/bootstrap/glyphicons-halflings-regular.ttf -------------------------------------------------------------------------------- /docs/fonts/bootstrap/glyphicons-halflings-regular.woff: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/fonts/bootstrap/glyphicons-halflings-regular.woff -------------------------------------------------------------------------------- /docs/fonts/bootstrap/glyphicons-halflings-regular.woff2: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/fonts/bootstrap/glyphicons-halflings-regular.woff2 -------------------------------------------------------------------------------- /docs/images/AssertNull.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/AssertNull.png -------------------------------------------------------------------------------- /docs/images/IDE0002-ClassicAssert-into-Assert.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/IDE0002-ClassicAssert-into-Assert.png -------------------------------------------------------------------------------- /docs/images/NUnit.Analyzer-ClassicAssert-CodeFix.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/NUnit.Analyzer-ClassicAssert-CodeFix.png -------------------------------------------------------------------------------- /docs/images/NUnit.Analyzer-ClassicAssert-Warning.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/NUnit.Analyzer-ClassicAssert-Warning.png -------------------------------------------------------------------------------- /docs/images/NUnit.Analyzer-ReplaceFormatSpecification.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/NUnit.Analyzer-ReplaceFormatSpecification.png -------------------------------------------------------------------------------- /docs/images/TraceDebug1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/TraceDebug1.png -------------------------------------------------------------------------------- /docs/images/TraceDebug2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/TraceDebug2.png -------------------------------------------------------------------------------- /docs/images/console-mock.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/console-mock.png -------------------------------------------------------------------------------- /docs/images/disable-just-my-code.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/disable-just-my-code.png -------------------------------------------------------------------------------- /docs/images/enable-source-link-support.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/enable-source-link-support.png -------------------------------------------------------------------------------- /docs/images/nunit-classic-asserts-fails.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/nunit-classic-asserts-fails.png -------------------------------------------------------------------------------- /docs/images/nunit-topology.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/nunit-topology.png -------------------------------------------------------------------------------- /docs/images/nunit-xtp-2008.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/nunit-xtp-2008.png -------------------------------------------------------------------------------- /docs/images/nunitTestAdapter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/nunitTestAdapter.png -------------------------------------------------------------------------------- /docs/images/nunitlite-mock.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/nunitlite-mock.png -------------------------------------------------------------------------------- /docs/images/right-click-create-tests-select-nunit.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/right-click-create-tests-select-nunit.png -------------------------------------------------------------------------------- /docs/images/right-click-create-tests.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/images/right-click-create-tests.png -------------------------------------------------------------------------------- /docs/img/addinsDialog.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/addinsDialog.jpg -------------------------------------------------------------------------------- /docs/img/advancedSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/advancedSettings.jpg -------------------------------------------------------------------------------- /docs/img/assembliesTab.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/assembliesTab.jpg -------------------------------------------------------------------------------- /docs/img/assemblyReloadSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/assemblyReloadSettings.jpg -------------------------------------------------------------------------------- /docs/img/bulletOff.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/bulletOff.gif -------------------------------------------------------------------------------- /docs/img/bulletOn.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/bulletOn.gif -------------------------------------------------------------------------------- /docs/img/configEditor.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/configEditor.jpg -------------------------------------------------------------------------------- /docs/img/console-mock.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/console-mock.jpg -------------------------------------------------------------------------------- /docs/img/dotnetfoundation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/dotnetfoundation.png -------------------------------------------------------------------------------- /docs/img/generalSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/generalSettings.jpg -------------------------------------------------------------------------------- /docs/img/generalTab.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/generalTab.jpg -------------------------------------------------------------------------------- /docs/img/gui-screenshot.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/gui-screenshot.jpg -------------------------------------------------------------------------------- /docs/img/gui-verify.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/gui-verify.jpg -------------------------------------------------------------------------------- /docs/img/internalTraceSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/internalTraceSettings.jpg -------------------------------------------------------------------------------- /docs/img/langFilter.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/langFilter.gif -------------------------------------------------------------------------------- /docs/img/logo.gif: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/logo.gif -------------------------------------------------------------------------------- /docs/img/miniGui.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/miniGui.jpg -------------------------------------------------------------------------------- /docs/img/nunitTestAdapter.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/nunitTestAdapter.png -------------------------------------------------------------------------------- /docs/img/nunit_128.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/nunit_128.png -------------------------------------------------------------------------------- /docs/img/nunit_dotnetfoundation.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/nunit_dotnetfoundation.png -------------------------------------------------------------------------------- /docs/img/nunit_logo_128.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/nunit_logo_128.png -------------------------------------------------------------------------------- /docs/img/projectEditorSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/projectEditorSettings.jpg -------------------------------------------------------------------------------- /docs/img/runtimeSelectionSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/runtimeSelectionSettings.jpg -------------------------------------------------------------------------------- /docs/img/testLoadSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/testLoadSettings.jpg -------------------------------------------------------------------------------- /docs/img/testOutputSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/testOutputSettings.jpg -------------------------------------------------------------------------------- /docs/img/testProperties.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/testProperties.jpg -------------------------------------------------------------------------------- /docs/img/testResultSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/testResultSettings.jpg -------------------------------------------------------------------------------- /docs/img/textOutputSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/textOutputSettings.jpg -------------------------------------------------------------------------------- /docs/img/treeDisplaySettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/treeDisplaySettings.jpg -------------------------------------------------------------------------------- /docs/img/visualStudioSettings.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/visualStudioSettings.jpg -------------------------------------------------------------------------------- /docs/img/xmlView.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nunit/docs/d560bf3bc774f194ad02fe93034adea6f414dc39/docs/img/xmlView.jpg -------------------------------------------------------------------------------- /docs/index.md: -------------------------------------------------------------------------------- 1 | # NUnit Documentation Site 2 | 3 | This web site contains the documentation for all active NUnit projects as well as developer documentation for those 4 | working on NUnit or wishing to do so. 5 | 6 | ## User Documentation 7 | 8 | * [NUnit](xref:intro) covers the core tools of NUnit, including the framework, NUnitLite, and the console runner. 9 | * [NUnit VS Adapter](xref:vstestadapterinstallation) covers the test adapters for Visual Studio and .Net. 10 | * [NUnit Analyzers](xref:nunitanalyzers) covers the NUnit Analyzers. 11 | * [NUnit VS Test Generator](xref:vstestgenerator) covers the Visual Studio extension for generating tests in both NUnit 12 | V2 and V3. 13 | * [NUnit Xamarin Runners](xref:xamarinrunners) covers the NUnit test runners for Xamarin and mobile devices. 14 | * [NUnit Engine](xref:nunitengine) covers the NUnit Engine, the central component all test runners are built around. 15 | 16 | ## Developer Documentation 17 | 18 | * [Team practices](xref:teampractices) describe how NUnit works and how our teams work. 19 | * [Specifications](xref:specifications) are descriptions of features we plan to add. 20 | -------------------------------------------------------------------------------- /docs/js/bootstrap-sprockets.js: -------------------------------------------------------------------------------- 1 | //= require ./bootstrap/affix 2 | //= require ./bootstrap/alert 3 | //= require ./bootstrap/button 4 | //= require ./bootstrap/carousel 5 | //= require ./bootstrap/collapse 6 | //= require ./bootstrap/dropdown 7 | //= require ./bootstrap/modal 8 | //= require ./bootstrap/scrollspy 9 | //= require ./bootstrap/tab 10 | //= require ./bootstrap/transition 11 | //= require ./bootstrap/tooltip 12 | //= require ./bootstrap/popover 13 | -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/AssertThrowsAsync.cs: -------------------------------------------------------------------------------- 1 | using NUnit.Framework; 2 | using static Snippets.NUnit.AssertThrows; 3 | #pragma warning disable NUnit2045 4 | #pragma warning disable CA1822 5 | 6 | namespace Snippets.NUnit; 7 | 8 | #pragma warning disable CS8602, CS8600 9 | public class AssertThrowsAsync 10 | { 11 | #region AssertThrowsAsync 12 | [TestFixture] 13 | public class AssertThrowsTests 14 | { 15 | [Test] 16 | public void Tests() 17 | { 18 | // Using a method as a delegate 19 | Assert.ThrowsAsync(async () => await MethodThatThrows()); 20 | } 21 | 22 | private async Task MethodThatThrows() 23 | { 24 | await Task.Delay(100); 25 | throw new ArgumentException(); 26 | } 27 | } 28 | #endregion 29 | 30 | #region UsingReturnValue 31 | [TestFixture] 32 | public class UsingReturnValue 33 | { 34 | [Test] 35 | public void TestException() 36 | { 37 | MyException ex = Assert.ThrowsAsync(async () => await MethodThatThrows()); 38 | 39 | Assert.That(ex.Message, Is.EqualTo("message")); 40 | Assert.That(ex.MyParam, Is.EqualTo(42)); 41 | } 42 | 43 | private async Task MethodThatThrows() 44 | { 45 | await Task.Delay(100); 46 | throw new MyException("message", 42); 47 | } 48 | } 49 | #endregion 50 | } -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/Assumptions.cs: -------------------------------------------------------------------------------- 1 | // ReSharper disable ConvertToLambdaExpression 2 | 3 | using NUnit.Framework; 4 | 5 | namespace Snippets.NUnit 6 | { 7 | public class Assumptions 8 | { 9 | #region TestThatUsesAssume 10 | [TestCase(5)] 11 | [TestCase(0)] 12 | [TestCase(-5)] 13 | public void Number_Divided_By_Itself_Is1(int numberToCheck) 14 | { 15 | var divisor = GetMatchingDivisor(numberToCheck); 16 | 17 | Assume.That(divisor, Is.Not.EqualTo(0), () => "divisor must not be zero in order for this test to be valid"); 18 | 19 | var result = numberToCheck / divisor; 20 | Assert.That(result, Is.EqualTo(1)); 21 | } 22 | 23 | /// 24 | /// Returns same number that's passed in 25 | /// 26 | private int GetMatchingDivisor(int inputNumber) 27 | { 28 | // If this ever returned 0, we'd be in trouble 29 | return inputNumber; 30 | } 31 | #endregion 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/Attributes/AuthorAttributeExamples.cs: -------------------------------------------------------------------------------- 1 | using NUnit.Framework; 2 | 3 | // ReSharper disable ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract 4 | #pragma warning disable NUnit2041 5 | #pragma warning disable NUnit1001 6 | #pragma warning disable NUnit2045 7 | #pragma warning disable CS8625 8 | 9 | namespace Snippets.NUnit.Attributes 10 | { 11 | public class AuthorAttributeExamples 12 | { 13 | #region AuthorAttributeExample 14 | [TestFixture] 15 | [Author("Jane Doe", "jane.doe@example.com")] 16 | [Author("Another Developer", "email@example.com")] 17 | public class MyTests 18 | { 19 | [Test] 20 | public void Test1() { /* ... */ } 21 | 22 | [Test] 23 | [Author("Joe Developer")] 24 | [Author("Yet Another Developer", "not.my.email@example.com")] 25 | public void Test2() { /* ... */ } 26 | } 27 | 28 | [TestFixture(Author = "Jane Doe")] 29 | public class MyOtherTests 30 | { 31 | [Test] 32 | public void Test1() { /* ... */ } 33 | 34 | [Test(Author = "Joe Developer")] 35 | public void Test2() { /* ... */ } 36 | } 37 | #endregion 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/Attributes/TestCaseAttributeExamples.cs: -------------------------------------------------------------------------------- 1 | using NUnit.Framework; 2 | using System; 3 | using System.Collections.Generic; 4 | using System.Linq; 5 | using System.Text; 6 | using System.Threading.Tasks; 7 | 8 | namespace Snippets.NUnit.Attributes 9 | { 10 | public class TestCaseAttributeExamples 11 | { 12 | #region BasicTestCase 13 | [TestCase(12, 3, 4)] 14 | [TestCase(12, 2, 6)] 15 | [TestCase(12, 4, 3)] 16 | public void DivideTest(int n, int d, int q) 17 | { 18 | Assert.That(n / d, Is.EqualTo(q)); 19 | } 20 | #endregion 21 | 22 | #region TestCaseWithExpectedResult 23 | [TestCase(12, 3, ExpectedResult = 4)] 24 | [TestCase(12, 2, ExpectedResult = 6)] 25 | [TestCase(12, 4, ExpectedResult = 3)] 26 | public int DivideTest(int n, int d) 27 | { 28 | return n / d; 29 | } 30 | #endregion 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/ClassicVsConstraintAssertions.cs: -------------------------------------------------------------------------------- 1 | using NUnit.Framework; 2 | 3 | #pragma warning disable NUnit2007 4 | #pragma warning disable NUnit2005 5 | 6 | using NUnit.Framework.Legacy; 7 | namespace Snippets.NUnit; 8 | 9 | 10 | public class ClassicVsConstraintAssertions 11 | { 12 | [Test] 13 | public void TheTest() 14 | { 15 | #region ConstraintWithoutClassicEquivalent 16 | int[] array = { 1, 2, 3 }; 17 | Assert.That(array, Has.Exactly(1).EqualTo(3)); 18 | Assert.That(array, Has.Exactly(2).GreaterThan(1)); 19 | Assert.That(array, Has.Exactly(3).LessThan(100)); 20 | #endregion 21 | 22 | #region ClassicAndConstraintsAreEquivalent 23 | ClassicAssert.AreEqual(4, 2 + 2); 24 | Assert.That(2 + 2, Is.EqualTo(4)); 25 | #endregion 26 | } 27 | } -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/Snippets.NUnit.csproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | net8.0 5 | enable 6 | enable 7 | 8 | false 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | all 17 | runtime; build; native; contentfiles; analyzers; buildtransitive 18 | 19 | 20 | all 21 | runtime; build; native; contentfiles; analyzers; buildtransitive 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/TestCaseDataExample.cs: -------------------------------------------------------------------------------- 1 | using System.Collections; 2 | using NUnit.Framework; 3 | 4 | namespace Snippets.NUnit; 5 | 6 | public class TestCaseDataExample 7 | { 8 | 9 | #region TestCaseDataExample 10 | [TestFixture] 11 | public class MyTests 12 | { 13 | [TestCaseSource(typeof(MyDataClass), nameof(MyDataClass.TestCases))] 14 | public int DivideTest(int n, int d) 15 | { 16 | return n / d; 17 | } 18 | } 19 | 20 | public class MyDataClass 21 | { 22 | public static IEnumerable TestCases 23 | { 24 | get 25 | { 26 | yield return new TestCaseData(12, 3).Returns(4); 27 | yield return new TestCaseData(12, 2).Returns(6); 28 | yield return new TestCaseData(12, 4).Returns(3); 29 | } 30 | } 31 | } 32 | #endregion 33 | 34 | #region TestCaseDataTypeArgsExample 35 | [TestFixture] 36 | public class MyExplicitlyTypedTests 37 | { 38 | [TestCaseSource(nameof(ExplicitTypeArgsTestCases))] 39 | public void ExplicitTypeArgs(T input) 40 | { 41 | Assert.That(typeof(T), Is.EqualTo(typeof(long))); 42 | } 43 | 44 | private static IEnumerable ExplicitTypeArgsTestCases() 45 | { 46 | yield return new TestCaseData(2) { TypeArgs = new[] { typeof(long) } }; 47 | yield return new TestCaseData(2L) { TypeArgs = new[] { typeof(long) } }; 48 | } 49 | } 50 | #endregion 51 | } -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnit/WarningExamples.cs: -------------------------------------------------------------------------------- 1 | using NUnit.Framework; 2 | 3 | namespace Snippets.NUnit; 4 | 5 | public class WarningExamples 6 | { 7 | [Test] 8 | public void DummyTestForWarningSyntax() 9 | { 10 | #region WarningExamples 11 | // Use Warn with reversed condition 12 | Warn.If(2 + 2 != 5); 13 | Warn.If(() => 2 + 2 != 5); 14 | Warn.If(2 + 2, Is.Not.EqualTo(5)); 15 | Warn.If(() => 2 + 2, Is.Not.EqualTo(5).After(500)); 16 | 17 | // Use Warn with original condition 18 | Warn.Unless(2 + 2 == 5); 19 | Warn.Unless(() => 2 + 2 == 5); 20 | Warn.Unless(2 + 2, Is.EqualTo(5)); 21 | Warn.Unless(() => 2 + 2, Is.EqualTo(5).After(500)); 22 | 23 | // Issue a warning message 24 | Assert.Warn("Warning message"); 25 | #endregion 26 | } 27 | } -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnitLite/GlobalUsings.cs: -------------------------------------------------------------------------------- 1 | global using NUnit.Framework; -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnitLite/Program.cs: -------------------------------------------------------------------------------- 1 | using NUnitLite; 2 | 3 | return new AutoRun().Execute(args); -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnitLite/Snippets.NUnitLite.csproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | net8.0 5 | Snippets.NUnitLite 6 | enable 7 | enable 8 | Exe 9 | false 10 | true 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | runtime; build; native; contentfiles; analyzers; buildtransitive 19 | all 20 | 21 | 22 | 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /docs/snippets/Snippets.NUnitLite/UnitTest1.cs: -------------------------------------------------------------------------------- 1 | namespace Snippets.NUnitLite; 2 | 3 | public class Tests 4 | { 5 | [Test] 6 | public void PassingTest() 7 | { 8 | Assert.Pass(); 9 | } 10 | 11 | [Test] 12 | [Ignore("Ignored test")] 13 | public void IgnoredTest() 14 | { 15 | Assert.Fail(); 16 | Assert.Pass(); 17 | } 18 | 19 | [Test] 20 | public void FailingTest() 21 | { 22 | Assert.That(()=>Assert.Fail(),Throws.TypeOf()); 23 | } 24 | 25 | 26 | } -------------------------------------------------------------------------------- /docs/snippets/Snippets.v3.ncrunchsolution: -------------------------------------------------------------------------------- 1 |  2 | 3 | True 4 | True 5 | 6 | -------------------------------------------------------------------------------- /docs/snippets/nuget.config: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /docs/styles/main.js: -------------------------------------------------------------------------------- 1 | var currentYear= new Date().getFullYear(); 2 | document.getElementById("currentYear").innerHTML = currentYear; 3 | -------------------------------------------------------------------------------- /docs/toc.yml: -------------------------------------------------------------------------------- 1 | - name: Articles 2 | href: articles/ 3 | - name: API Reference 4 | href: api/ -------------------------------------------------------------------------------- /renovate.json: -------------------------------------------------------------------------------- 1 | { 2 | "$schema": "https://docs.renovatebot.com/renovate-schema.json", 3 | "extends": [ 4 | "config:recommended" 5 | ], 6 | "customManagers": [ 7 | { 8 | "customType": "regex", 9 | "fileMatch": [ 10 | "^\\.github\\/workflows\\/build-process\\.yml$" 11 | ], 12 | "matchStrings": [ 13 | "NUNIT_VERSION_FOR_API_DOCS: \"(?.*?)\"" 14 | ], 15 | "depNameTemplate": "NUnit", 16 | "datasourceTemplate": "nuget" 17 | } 18 | ] 19 | } --------------------------------------------------------------------------------