C# (CSharp) NuGetMetadataReference.MSTestTestFramework 예제들

예제 #1

파일: TestMethodShouldNotBeIgnoredTest.cs 프로젝트: slipalison/sonar-dotnet

 public void TestMethodShouldNotBeIgnored_MsTest_Legacy()
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldNotBeIgnored.MsTest.cs",
                             new TestMethodShouldNotBeIgnored(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework("1.1.11"),
                             checkMode: CompilationErrorBehavior.Ignore); // IgnoreAttribute doesn't contain any reason param
 }

예제 #2

파일: TestMethodShouldContainAssertionTest.cs 프로젝트: rehen/sonar-dotnet

 public static IEnumerable <MetadataReference> GetMsTestReferences(string msTestVersion) =>
 NuGetMetadataReference.MSTestTestFramework(msTestVersion)
 .Concat(NuGetMetadataReference.FluentAssertions(Constants.NuGetLatestVersion))
 .Concat(NuGetMetadataReference.NSubstitute(Constants.NuGetLatestVersion))
 .Concat(MetadataReferenceFacade.SystemXml)
 .Concat(MetadataReferenceFacade.SystemXmlLinq)
 .ToArray();

예제 #3

파일: TestClassShouldHaveTestMethodTest.cs 프로젝트: kelvinninja1/sonar-csharp

 public void TestClassShouldHaveTestMethod_MSTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestClassShouldHaveTestMethod.MsTest.cs",
                             new TestClassShouldHaveTestMethod(),
                             null,
                             NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

예제 #4

파일: MethodShouldBeNamedAccordingToSynchronicityTest.cs 프로젝트: slipalison/sonar-dotnet

 public void MethodShouldBeNamedAccordingToSynchronicity_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\MethodShouldBeNamedAccordingToSynchronicity.MsTest.cs",
                             new MethodShouldBeNamedAccordingToSynchronicity(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion)
                             .Concat(NuGetMetadataReference.SystemThreadingTasksExtensions("4.0.0")));
 }

예제 #5

파일: TestMethodShouldContainAssertionTest.cs 프로젝트: CedricAgoda/sonar-csharp

 public void TestMethodShouldContainAssertion_MSTest(string testFwkVersion, string fluentVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.MsTest.cs",
                             new TestMethodShouldContainAssertion(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion)
                             .Concat(NuGetMetadataReference.FluentAssertions(fluentVersion))
                             .ToArray());
 }

예제 #6

파일: TestMethodShouldContainAssertionTest.cs 프로젝트: ewin66/sonar-dotnet

 public void TestMethodShouldContainAssertion_MSTest(string testFwkVersion, string fluentVersion, string nSubstituteVersion) =>
 Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.MsTest.cs",
                         new TestMethodShouldContainAssertion(),
                         additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion)
                         .Concat(NuGetMetadataReference.FluentAssertions(fluentVersion))
                         .Concat(NuGetMetadataReference.NSubstitute(nSubstituteVersion))
                         .Concat(MetadataReferenceFacade.GetSystemXml())
                         .Concat(MetadataReferenceFacade.GetSystemXmlLinq())
                         .ToArray());

예제 #7

        public void IsTest_ReturnsTrueForTestFrameworks()
        {
            IsTest(NuGetMetadataReference.JetBrainsDotMemoryUnit(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.MSTestTestFrameworkV1).Should().BeTrue();
            IsTest(NuGetMetadataReference.MSTestTestFramework(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.MicrosoftVisualStudioQualityToolsUnitTestFramework).Should().BeTrue();
            IsTest(NuGetMetadataReference.MachineSpecifications(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.NUnit(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.NUnitLite(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.SpecFlow(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.XunitFrameworkV1).Should().BeTrue();
            IsTest(NuGetMetadataReference.XunitFramework(Constants.NuGetLatestVersion)).Should().BeTrue();

            // Assertion
            IsTest(NuGetMetadataReference.FluentAssertions(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.Shouldly(Constants.NuGetLatestVersion)).Should().BeTrue();

            // Mock
            IsTest(NuGetMetadataReference.FakeItEasy(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.JustMock(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.Moq(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.NSubstitute(Constants.NuGetLatestVersion)).Should().BeTrue();
            IsTest(NuGetMetadataReference.RhinoMocks(Constants.NuGetLatestVersion)).Should().BeTrue();
        }

예제 #8

 public void TestMethodShouldContainAssertion_CustomAssertionMethod() =>
 Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldContainAssertion.Custom.cs",
                         new CS.TestMethodShouldContainAssertion(),
                         NuGetMetadataReference.MSTestTestFramework(Constants.NuGetLatestVersion));

예제 #9

 public void AssertionArgsShouldBePassedInCorrectOrder_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\AssertionArgsShouldBePassedInCorrectOrder.MsTest.cs",
                             new AssertionArgsShouldBePassedInCorrectOrder(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

예제 #10

파일: TestMethodShouldHaveCorrectSignature.cs 프로젝트: arunsidhu90/sonar-dotnet

 public void TestMethodShouldHaveCorrectSignature_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldHaveCorrectSignature.MsTest.cs",
                             new TestMethodShouldHaveCorrectSignature(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

예제 #11

파일: TestMethodShouldNotBeIgnoredTest.cs 프로젝트: slipalison/sonar-dotnet

 public void TestMethodShouldNotBeIgnored_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldNotBeIgnored.MsTest.cs",
                             new TestMethodShouldNotBeIgnored(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

예제 #12

파일: DoNotUseLiteralBoolInAssertionsTest.cs 프로젝트: slipalison/sonar-dotnet

 public void DoNotUseLiteralBoolInAssertions_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\DoNotUseLiteralBoolInAssertions.MsTest.cs",
                             new DoNotUseLiteralBoolInAssertions(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

예제 #13

 public void AsyncVoidMethod_MsTestV2(string testFwkVersion) =>
 Verifier.VerifyAnalyzer(@"TestCases\AsyncVoidMethod_MsTestV2.cs",
                         new CS.AsyncVoidMethod(),
                         NuGetMetadataReference.MSTestTestFramework(testFwkVersion));

예제 #14

 public void TestClassShouldHaveTestMethod_CSharp9() =>
 Verifier.VerifyAnalyzerFromCSharp9Library(@"TestCases\TestClassShouldHaveTestMethod.CSharp9.cs",
                                           new CS.TestClassShouldHaveTestMethod(),
                                           NuGetMetadataReference.MSTestTestFramework(Constants.NuGetLatestVersion)
                                           .Concat(NuGetMetadataReference.NUnit(Constants.NuGetLatestVersion)));

예제 #15

파일: TestMethodShouldNotBeIgnoredTest.cs 프로젝트: zhamppx97/sonar-dotnet

 public void TestMethodShouldNotBeIgnored_MsTest_Legacy() =>
 Verifier.VerifyAnalyzer(@"TestCases\TestMethodShouldNotBeIgnored.MsTest.cs",
                         new CS.TestMethodShouldNotBeIgnored(),
                         CompilationErrorBehavior.Ignore,        // IgnoreAttribute doesn't contain any reason param
                         NuGetMetadataReference.MSTestTestFramework("1.1.11"));

예제 #16

 public void TestMethodShouldContainAssertion_MSTest(string testFwkVersion) =>
 Verifier.VerifyAnalyzer(new[] { @"TestCases\TestMethodShouldContainAssertion.MsTest.cs", @"TestCases\TestMethodShouldContainAssertion.MsTest.AnotherFile.cs" },
                         new CS.TestMethodShouldContainAssertion(),
                         AdditionalTestReferences(NuGetMetadataReference.MSTestTestFramework(testFwkVersion)));

예제 #17

 public void ExpectedExceptionAttributeShouldNotBeUsed_MsTest(string testFwkVersion)
 {
     Verifier.VerifyAnalyzer(@"TestCases\ExpectedExceptionAttributeShouldNotBeUsed.MsTest.cs",
                             new ExpectedExceptionAttributeShouldNotBeUsed(),
                             additionalReferences: NuGetMetadataReference.MSTestTestFramework(testFwkVersion));
 }

예제 #18

파일: AssertionArgsShouldBePassedInCorrectOrderTest.cs 프로젝트: zhamppx97/sonar-dotnet

 public void AssertionArgsShouldBePassedInCorrectOrder_MsTest(string testFwkVersion) =>
 Verifier.VerifyAnalyzer(@"TestCases\AssertionArgsShouldBePassedInCorrectOrder.MsTest.cs",
                         new CS.AssertionArgsShouldBePassedInCorrectOrder(),
                         NuGetMetadataReference.MSTestTestFramework(testFwkVersion).ToArray());