public void AnalyzeWhenObjectTypesProvided()
{
var testCode = TestUtility.WrapInTestMethod(
@"
object o = 0;
Assert.That(o, Is.LessThan(↓1));
");
RoslynAssert.Diagnostics(analyzer,
ExpectedDiagnostic.Create(AnalyzerIdentifiers.ComparableOnObject), testCode);
}
public void AnalyzeWhenAssemblyAttributeIsImplicitlyParallelScopeSelf()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.ParallelScopeSelfNoEffectOnAssemblyUsage,
ParallelizableUsageAnalyzerConstants.ParallelScopeSelfNoEffectOnAssemblyMessage);
var testCode = $@"
using NUnit.Framework;
[assembly: ↓Parallelizable()]";
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public async Task FixesAreReportedForCompilerErrors()
{
var diagnostics = new ExpectedDiagnostic [] {
new ExpectedDiagnostic(6, DiagnosticSeverity.Hidden, "Accessibility modifiers required"),
new ExpectedDiagnostic(16, DiagnosticSeverity.Error, "'MyClass' does not implement interface member 'IDisposable.Dispose()'"),
new ExpectedDiagnostic(36, DiagnosticSeverity.Hidden, "Fix formatting"),
};
var expected = new ExpectedCodeFixes {
CodeFixData = new CodeActionData [] {
new CodeActionData {
Message = "Implement interface"
},
new CodeActionData {
Message = "Implement interface with Dispose pattern"
},
new CodeActionData {
Message = "Implement interface explicitly"
},
new CodeActionData {
Message = "Implement interface explicitly with Dispose pattern"
},
new CodeActionData {
Message = "Add accessibility modifiers"
},
new CodeActionData {
Message = "Fix formatting"
},
}.OrderBy(d => d.Message).ToArray(),
CodeRefactoringData = new CodeActionData [] {
// NOTE: This will return when we implement UI for it
//new CodeActionData { Message = "Move to namespace..." },
new CodeActionData {
Message = "Rename file to MyClass.cs"
},
new CodeActionData {
Message = "Rename type to a"
},
},
};
await RunTest(3, IDisposableImplement, async (remainingUpdates, doc) => {
if (remainingUpdates == 0)
{
AssertExpectedDiagnostics(diagnostics, doc);
doc.Editor.CaretOffset = diagnostics [2].Location;
await AssertExpectedCodeFixes(expected, doc);
}
});
}
public void AnalyzeWhenAsyncTestCaseMethodHasVoidReturnTypeAndNoExpectedResult()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodAsyncNoExpectedResultAndVoidReturnTypeUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenAsyncTestCaseMethodHasVoidReturnTypeAndNoExpectedResult
{
[↓TestCase(4)]
public async void AsyncVoidTest(int x) => await Task.FromResult(1);
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenTestCaseAttributeExpectedResultIsNotProvidedAndReturnTypeIsNotVoid()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodNoExpectedResultButNonVoidReturnType);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenTestCaseAttributeExpectedResultIsNotProvidedAndReturnTypeIsNotVoid
{
[↓TestCase(1)]
public string Test4(int i) => ""12"";
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void TwoClassesCodeFixOnlyCorrectFix()
{
var code1 = @"
namespace RoslynSandbox
{
using System;
public class Foo1
{
public event EventHandler Bar;
}
}";
var code2 = @"
namespace RoslynSandbox
{
using System;
public class Foo2
{
public event EventHandler Bar;
}
}";
var fixed1 = @"
namespace RoslynSandbox
{
using System;
public class Foo1
{
}
}";
var fixed2 = @"
namespace RoslynSandbox
{
using System;
public class Foo2
{
}
}";
AnalyzerAssert.MetadataReferences.Add(MetadataReference.CreateFromFile(typeof(EventHandler).Assembly.Location));
var expectedDiagnostic = ExpectedDiagnostic.Create("CS0067");
AnalyzerAssert.FixAll <RemoveUnusedFixProvider>(expectedDiagnostic, new[] { code1, code2 }, new[] { fixed1, fixed2 });
AnalyzerAssert.FixAll <RemoveUnusedFixProvider>(expectedDiagnostic, new[] { code2, code1 }, new[] { fixed2, fixed1 });
}
public static void TwoDocumentsTwoErrorsTwoFixes()
{
var before1 = @"
namespace N
{
using System;
public class C1
{
public event EventHandler ↓Bar;
}
}";
var before2 = @"
namespace N
{
using System;
public class C2
{
public event EventHandler ↓Bar;
}
}";
var fixed1 = @"
namespace N
{
using System;
public class C1
{
}
}";
var fixed2 = @"
namespace N
{
using System;
public class C2
{
}
}";
var expectedDiagnostic = ExpectedDiagnostic.Create("CS0067");
var fix = new RemoveUnusedFix();
RoslynAssert.FixAll(fix, expectedDiagnostic, new[] { before1, before2 }, new[] { fixed1, fixed2 });
RoslynAssert.FixAll(fix, expectedDiagnostic, new[] { before2, before1 }, new[] { fixed2, fixed1 });
}
public void AnalyzeWhenGenericIsNotInstanceOfIsUsed()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.IsNotInstanceOfUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenGenericIsNotInstanceOfIsUsed
{
public void Test()
{
↓Assert.IsNotInstanceOf<int>(2);
}
}");
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic, testCode);
}
public static void OneErrorWithExpectedDiagnosticIdOnly()
{
var code = @"
namespace N
{
class C
{
private readonly int _value1;
}
}";
var expectedDiagnostic = ExpectedDiagnostic.Create("SA1309");
RoslynAssert.Diagnostics(new FieldNameMustNotBeginWithUnderscore(), expectedDiagnostic, code);
}
public void AnalyzeWhenAreEqualIsUsedWithTolerance()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.AreEqualUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenAreEqualIsUsedWithTolerance
{
public void Test()
{
↓Assert.AreEqual(2d, 2d, 0.0000001d);
}
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void MissingMethodWhenKnownExactType(string type)
{
var code = @"
namespace RoslynSandbox
{
public class C
{
public object Bar(C foo) => typeof(C).GetMethod(↓""MISSING"");
}
}".AssertReplace("typeof(C).GetMethod(↓\"MISSING\")", type);
var message = "The type RoslynSandbox.C does not have a member named MISSING.";
AnalyzerAssert.Diagnostics(Analyzer, ExpectedDiagnostic.WithMessage(message), code);
}
public void Message()
{
var code = @"
namespace RoslynSandbox
{
public class Foo
{
public static readonly int Value1 = ↓Value2;
public static readonly int Value2 = 2;
}
}";
AnalyzerAssert.Diagnostics(Analyzer, ExpectedDiagnostic.Create("GU0023", "Member 'RoslynSandbox.Foo.Value2' must be declared before 'RoslynSandbox.Foo.Value1'"), code);
}
public void AnalyzeWhenTooManyRequiredAndOptionalArgumentsAreProvided()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseTooManyArgumentsUsage,
TestCaseUsageAnalyzerConstants.TooManyArgumentsMessage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenTooManyRequiredAndOptionalArgumentsAreProvided
{
[↓TestCase(2, 'b', 2d)]
public void Test(int a, char b = 'c') { }
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenContainsIsUsed()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.ContainsUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenContainsIsUsed
{
public void Test()
{
↓Assert.Contains(this, Array.Empty<object>());
}
}");
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenNotZeroIsUsed()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.NotZeroUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenNotZeroIsUsed
{
public void Test()
{
↓Assert.NotZero(2);
}
}");
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenMethodHasOnlyParamsAndArgumentPassesNullToValueType()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseParameterTypeMismatchUsage,
String.Format(TestCaseUsageAnalyzerConstants.ParameterTypeMismatchMessage, 0, "<null>", "a", "int[]"));
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenMethodHasOnlyParamsAndArgumentPassesNullToValueType
{
[TestCase(↓null)]
public void Test(params int[] a) { }
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenArgumentTypeIsIncorrect()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseParameterTypeMismatchUsage,
String.Format(TestCaseUsageAnalyzerConstants.ParameterTypeMismatchMessage, 0, "int", "a", "char"));
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenArgumentTypeIsIncorrect
{
[TestCase(↓2)]
public void Test(char a) { }
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenLessOrEqualIsUsed()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.LessOrEqualUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenLessOrEqualIsUsed
{
public void Test()
{
↓Assert.LessOrEqual(2, 3);
}
}");
AnalyzerAssert.Diagnostics(this.analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenExpectedResultIsProvidedAndReturnTypeIsVoid()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodSpecifiedExpectedResultForVoidUsage,
TestMethodUsageAnalyzerConstants.SpecifiedExpectedResultForVoidMethodMessage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenExpectedResultIsProvidedAndReturnTypeIsVoid
{
[TestCase(2, ↓ExpectedResult = '3')]
public void Test(int a) { }
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenTestMethodHasValueTaskReturnTypeAndExpectedResultIsIncorrect()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodExpectedResultTypeMismatchUsage,
string.Format(TestMethodUsageAnalyzerConstants.ExpectedResultTypeMismatchMessage, typeof(int).Name));
var testCode = TestUtility.WrapMethodInClassNamespaceAndAddUsings(@"
[TestCase(ExpectedResult = '1')]
public async ValueTask<int> GenericTaskTestCaseWithExpectedResult()
{
return 1;
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenIsTrueIsUsed()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(AnalyzerIdentifiers.IsTrueUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenIsTrueIsUsed
{
public void Test()
{
↓Assert.IsTrue(true);
}
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenTestMethodHasGenericTaskReturnTypeAndNoExpectedResult()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodAsyncNoExpectedResultAndNonTaskReturnTypeUsage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenTestMethodHasGenericTaskReturnTypeAndNotExpectedResult
{
[↓Test]
public Task<int> AsyncGenericTaskTest() => Task.FromResult(1);
}");
var message = "Async test method must have non-generic Task return type when no result is expected, but the return type was 'System.Threading.Tasks.Task<int>'.";
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic.WithMessage(message), testCode);
}
public void AnalyzeWhenExpectedResultIsProvidedAndPassesNullToValueType()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodExpectedResultTypeMismatchUsage,
String.Format(TestMethodUsageAnalyzerConstants.ExpectedResultTypeMismatchMessage, typeof(int).Name));
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenExpectedResultIsProvidedAndPassesNullToValueType
{
[TestCase(2, ↓ExpectedResult = null)]
public int Test(int a) { return 3; }
}");
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenTestCaseAttributeExpectedResultIsNotProvidedAndReturnTypeIsNotVoid()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestMethodNoExpectedResultButNonVoidReturnType);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenTestCaseAttributeExpectedResultIsNotProvidedAndReturnTypeIsNotVoid
{
[↓TestCase(1)]
public int Test4(int i) => ""12"";
}");
var message = "Method has non-void return type 'int', but no result is expected in ExpectedResult.";
AnalyzerAssert.Diagnostics(analyzer, expectedDiagnostic.WithMessage(message), testCode);
}
public static void Message()
{
var code = @"
namespace N
{
public class C
{
public static readonly int Value1 = ↓Value2;
public static readonly int Value2 = 2;
}
}";
RoslynAssert.Diagnostics(Analyzer, ExpectedDiagnostic.Create("GU0023", "Member 'N.C.Value2' must be declared before 'N.C.Value1'"), code);
}
public void AnalyzeArgumentIsEnumConvertedToString()
{
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
class AnalyzeArgumentIsEnumConvertedToString
{
public enum TestEnum { A,B,C }
[TestCase(↓TestEnum.A)]
[TestCase(↓TestEnum.B)]
public void Test(string e) { }
}");
RoslynAssert.Diagnostics(this.analyzer,
ExpectedDiagnostic.Create(AnalyzerIdentifiers.TestCaseParameterTypeMismatchUsage),
testCode);
}
public void AnalyzeWhenArgumentPassesNullToValueType()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseParameterTypeMismatchUsage,
string.Format(CultureInfo.InvariantCulture,
TestCaseUsageAnalyzerConstants.ParameterTypeMismatchMessage, 0, "<null>", "a", "char"));
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenArgumentPassesNullToValueType
{
[TestCase(↓null)]
public void Test(char a) { }
}");
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenMethodHasOnlyParamsAndArgumentTypeIsIncorrect()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseParameterTypeMismatchUsage,
string.Format(CultureInfo.InvariantCulture, TestCaseUsageAnalyzerConstants.ParameterTypeMismatchMessage,
0, "int", "a", "string[]"));
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenMethodHasOnlyParamsAndArgumentTypeIsIncorrect
{
[TestCase(↓2)]
public void Test(params string[] a) { }
}");
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic, testCode);
}
public void AnalyzeWhenTooManyRequiredAndOptionalArgumentsAreProvided()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseTooManyArgumentsUsage,
TestCaseUsageAnalyzerConstants.TooManyArgumentsMessage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenTooManyRequiredAndOptionalArgumentsAreProvided
{
[↓TestCase(2, 'b', 2d)]
public void Test(int a, char b = 'c') { }
}");
var message = "The TestCaseAttribute provided too many arguments. Expected '2', but got '3'.";
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic.WithMessage(message), testCode);
}
public void AnalyzeWhenNotEnoughRequiredArgumentsAreProvided()
{
var expectedDiagnostic = ExpectedDiagnostic.Create(
AnalyzerIdentifiers.TestCaseNotEnoughArgumentsUsage,
TestCaseUsageAnalyzerConstants.NotEnoughArgumentsMessage);
var testCode = TestUtility.WrapClassInNamespaceAndAddUsing(@"
public sealed class AnalyzeWhenNotEnoughRequiredArgumentsAreProvided
{
[↓TestCase(2)]
public void Test(int a, char b) { }
}");
var message = "The TestCaseAttribute provided too few arguments. Expected '2', but got '1'.";
RoslynAssert.Diagnostics(this.analyzer, expectedDiagnostic.WithMessage(message), testCode);
}
