public void WithBackingFieldToSetUnderscoreNames()
{
var testCode = @"
namespace RoslynSandbox
{
public class ViewModel : Microsoft.Practices.Prism.Mvvm.BindableBase
{
private string _name;
↓public string Name
{
get { return _name; }
set { _name = value; }
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class ViewModel : Microsoft.Practices.Prism.Mvvm.BindableBase
{
private string _name;
public string Name
{
get { return _name; }
set { SetProperty(ref _name, value); }
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "BindableBase.SetProperty.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "BindableBase.SetProperty.");
}
public void AutoPropertyToSet()
{
var testCode = @"
namespace RoslynSandbox.Client
{
public class Foo : RoslynSandbox.Core.ViewModelBase
{
↓public int Bar { get; set; }
}
}";
var fixedCode = @"
namespace RoslynSandbox.Client
{
public class Foo : RoslynSandbox.Core.ViewModelBase
{
private int bar;
public int Bar
{
get => this.bar;
set => this.TrySet(ref this.bar, value);
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { ViewModelBaseCode, testCode }, fixedCode, fixTitle: "ViewModelBase.TrySet.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { ViewModelBaseCode, testCode }, fixedCode, fixTitle: "ViewModelBase.TrySet.");
}
public void PreservesDocumentOrder()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
↓public int A { get; set; }
↓public int B { get; private set; }
↓public int C { get; set; }
↓public int D { get; private set; }
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public int B { get; private set; }
public int D { get; private set; }
public int A { get; set; }
public int C { get; set; }
}
}";
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void WithBackingFieldToSetUnderscoreNames()
{
var testCode = @"
namespace RoslynSandbox
{
public class ViewModel : Stylet.PropertyChangedBase
{
private string _name;
↓public string Name
{
get { return _name; }
set { _name = value; }
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class ViewModel : Stylet.PropertyChangedBase
{
private string _name;
public string Name
{
get { return _name; }
set { SetAndNotify(ref _name, value); }
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.SetAndNotify.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.SetAndNotify.");
}
public void IfNotSetReturnSetAffectsSecondCalculatedProperty()
{
var testCode = @"
namespace RoslynSandbox
{
public class ViewModel : MvvmCross.Core.ViewModels.MvxNotifyPropertyChanged
{
private string name;
public string Greeting1 => $""Hello {this.Name}"";
public string Greeting2 => $""Hej {this.Name}"";
public string Name
{
get { return this.name; }
set
{
if (!this.SetProperty(↓ref this.name, value))
{
return;
}
this.RaisePropertyChanged(nameof(this.Greeting1));
}
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class ViewModel : MvvmCross.Core.ViewModels.MvxNotifyPropertyChanged
{
private string name;
public string Greeting1 => $""Hello {this.Name}"";
public string Greeting2 => $""Hej {this.Name}"";
public string Name
{
get { return this.name; }
set
{
if (!this.SetProperty(ref this.name, value))
{
return;
}
this.RaisePropertyChanged(nameof(this.Greeting1));
this.RaisePropertyChanged(nameof(this.Greeting2));
}
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void CallPublicMethodRefParameter()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
using System.IO;
public sealed class Foo : IDisposable
{
private readonly Stream stream = File.OpenRead(string.Empty);
private Foo()
{
this.Assign(↓ref this.stream);
}
public void Dispose()
{
this.stream?.Dispose();
}
public void Assign(ref Stream stream)
{
stream = File.OpenRead(string.Empty);
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System;
using System.IO;
public sealed class Foo : IDisposable
{
private readonly Stream stream = File.OpenRead(string.Empty);
private Foo()
{
this.stream?.Dispose();
this.Assign(ref this.stream);
}
public void Dispose()
{
this.stream?.Dispose();
}
public void Assign(ref Stream stream)
{
stream = File.OpenRead(string.Empty);
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void WhenMutableBeforeGetOnlyFirst()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
↓public int A { get; set; }
↓public int B { get; }
public int C { get; }
public int D { get; }
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public int B { get; }
public int C { get; }
public int D { get; }
public int A { get; set; }
}
}";
AnalyzerAssert.FixAll <GU0020SortProperties, SortPropertiesCodeFixProvider>(testCode, fixedCode);
}
public void FactoryMethodCallingPrivateCtorWithCreatedDisposable()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
public sealed class Foo
{
↓private readonly IDisposable value;
private Foo(IDisposable value)
{
this.value = value;
}
public static Foo Create() => new Foo(new Disposable());
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System;
public sealed class Foo : IDisposable
{
private readonly IDisposable value;
private bool disposed;
private Foo(IDisposable value)
{
this.value = value;
}
public static Foo Create() => new Foo(new Disposable());
public void Dispose()
{
if (this.disposed)
{
return;
}
this.disposed = true;
}
private void ThrowIfDisposed()
{
if (this.disposed)
{
throw new ObjectDisposedException(this.GetType().FullName);
}
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { DisposableCode, testCode }, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { DisposableCode, testCode }, fixedCode);
}
public void FieldInitializationAndBaseCallUnderscoreNames()
{
var fooCode = @"
namespace RoslynSandbox
{
public class Foo : FooBase
{
private readonly Bar _bar;
public Foo(ServiceLocator locator)
: base(locator.↓Bar)
{
_bar = locator.↓Bar;
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo : FooBase
{
private readonly Bar _bar;
public Foo(ServiceLocator locator, Bar bar)
: base(bar)
{
_bar = bar;
}
}
}";
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { BarCode, LocatorCode, FooBaseCode, fooCode }, fixedCode);
}
public void WithBackingFieldToSet()
{
var testCode = @"
namespace RoslynSandbox
{
public class ViewModel : Caliburn.Micro.Screen
{
private string name;
↓public string Name
{
get { return this.name; }
set { this.name = value; }
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class ViewModel : Caliburn.Micro.Screen
{
private string name;
public string Name
{
get { return this.name; }
set { this.Set(ref this.name, value); }
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.Set.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.Set.");
}
public void AutoPropertyInitializedToSet()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo : Caliburn.Micro.Screen
{
↓public int Bar { get; set; } = 1;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo : Caliburn.Micro.Screen
{
private int bar = 1;
public int Bar
{
get => this.bar;
set => this.Set(ref this.bar, value);
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.Set.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.Set.");
}
public void AddUsingForIgnoredReturnEmpty()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
public sealed class Foo
{
public void Meh()
{
↓new Disposable();
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System;
public sealed class Foo
{
public void Meh()
{
using (new Disposable())
{
}
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { DisposableCode, testCode }, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { DisposableCode, testCode }, fixedCode);
}
public void StyletSetAndNotify()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo : Stylet.PropertyChangedBase
{
private int bar;
public int Bar
{
get => this.bar;
set => this.SetAndNotify(ref this.bar, value, ↓nameof(this.Bar));
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo : Stylet.PropertyChangedBase
{
private int bar;
public int Bar
{
get => this.bar;
set => this.SetAndNotify(ref this.bar, value);
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void InternalClassInternalPropertyAutoPropertyToSet()
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo : Microsoft.Practices.Prism.Mvvm.BindableBase
{
↓internal int Bar { get; set; }
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
internal class Foo : Microsoft.Practices.Prism.Mvvm.BindableBase
{
private int bar;
internal int Bar
{
get => this.bar;
set => this.SetProperty(ref this.bar, value);
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "BindableBase.SetProperty.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "BindableBase.SetProperty.");
}
public void TwoErrorsCorrectFix()
{
var code = @"
namespace RoslynSandbox
{
class Foo
{
private readonly int ↓_value1;
private readonly int ↓_value2;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
class Foo
{
private readonly int value1;
private readonly int value2;
}
}";
AnalyzerAssert.MetadataReferences.Add(MetadataReference.CreateFromFile(typeof(int).Assembly.Location));
AnalyzerAssert.FixAll <FieldNameMustNotBeginWithUnderscore, DontUseUnderscoreCodeFixProvider>(code, fixedCode);
}
public void GetPrivateSetPropertyWithBackingFieldWhenInitializedInCtor()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
using System.IO;
public sealed class Foo : IDisposable
{
↓private Stream _stream;
public Foo()
{
Stream = File.OpenRead(string.Empty);
}
public Stream Stream
{
get { return _stream; }
private set { _stream = value; }
}
public void Dispose()
{
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System;
using System.IO;
public sealed class Foo : IDisposable
{
private Stream _stream;
public Foo()
{
Stream = File.OpenRead(string.Empty);
}
public Stream Stream
{
get { return _stream; }
private set { _stream = value; }
}
public void Dispose()
{
_stream?.Dispose();
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void NotDisposingGetPrivateSetPropertyWithBackingFieldWhenInitializedInCtor()
{
var testCode = @"
namespace RoslynSandbox
{
using System;
using System.IO;
public sealed class Foo : IDisposable
{
↓private Stream _stream;
public Foo()
{
this.Stream = File.OpenRead(string.Empty);
}
public Stream Stream
{
get { return _stream; }
private set { _stream = value; }
}
public void Dispose()
{
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System;
using System.IO;
public sealed class Foo : IDisposable
{
private Stream _stream;
public Foo()
{
this.Stream = File.OpenRead(string.Empty);
}
public Stream Stream
{
get { return _stream; }
private set { _stream = value; }
}
public void Dispose()
{
_stream?.Dispose();
}
}
}";
AnalyzerAssert.CodeFix <IDISP002DisposeMember, DisposeMemberCodeFixProvider>(testCode, fixedCode);
AnalyzerAssert.FixAll <IDISP002DisposeMember, DisposeMemberCodeFixProvider>(testCode, fixedCode);
}
public void IfNotSetReturnSetAffectsSecondCalculatedProperty()
{
var testCode = @"
namespace RoslynSandbox.Client
{
public class ViewModel : RoslynSandbox.Core.ViewModelBase
{
private string name;
public string Greeting1 => $""Hello {this.Name}"";
public string Greeting2 => $""Hej {this.Name}"";
public string Name
{
get { return this.name; }
set
{
if (!this.TrySet(↓ref this.name, value))
{
return;
}
this.OnPropertyChanged(nameof(this.Greeting1));
}
}
}
}";
var fixedCode = @"
namespace RoslynSandbox.Client
{
public class ViewModel : RoslynSandbox.Core.ViewModelBase
{
private string name;
public string Greeting1 => $""Hello {this.Name}"";
public string Greeting2 => $""Hej {this.Name}"";
public string Name
{
get { return this.name; }
set
{
if (!this.TrySet(ref this.name, value))
{
return;
}
this.OnPropertyChanged(nameof(this.Greeting1));
this.OnPropertyChanged(nameof(this.Greeting2));
}
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { ViewModelBaseCode, testCode }, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { ViewModelBaseCode, testCode }, fixedCode);
}
public void WhenAMess1()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
↓public int A { get; set; }
↓public int B { get; private set; }
↓public int C { get; }
public int D => C;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public int C { get; }
public int D => C;
public int B { get; private set; }
public int A { get; set; }
}
}";
AnalyzerAssert.FixAll <GU0020SortProperties, SortPropertiesCodeFixProvider>(testCode, fixedCode);
}
public void AssigningFieldInOneTimeSetUpWhenOneTimeTearDownExists()
{
var testCode = @"
namespace RoslynSandbox
{
using NUnit.Framework;
public class Tests
{
↓private Disposable disposable;
[OneTimeSetUp]
public void SetUp()
{
this.disposable = new Disposable();
}
[OneTimeTearDown]
public void TearDown()
{
}
[Test]
public void Test()
{
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using NUnit.Framework;
public class Tests
{
private Disposable disposable;
[OneTimeSetUp]
public void SetUp()
{
this.disposable = new Disposable();
}
[OneTimeTearDown]
public void TearDown()
{
this.disposable?.Dispose();
}
[Test]
public void Test()
{
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { DisposableCode, testCode }, fixedCode);
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { DisposableCode, testCode }, fixedCode);
}
public void PrivateSetSingeLine()
{
var testCode = @"
namespace RoslynSandbox
{
using System.ComponentModel;
using System.Runtime.CompilerServices;
public class Foo : INotifyPropertyChanged
{
private int value;
public event PropertyChangedEventHandler PropertyChanged;
↓public int Value { get { return this.value; } private set { this.value = value; }}
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System.ComponentModel;
using System.Runtime.CompilerServices;
public class Foo : INotifyPropertyChanged
{
private int value;
public event PropertyChangedEventHandler PropertyChanged;
public int Value
{
get { return this.value; }
private set
{
if (value == this.value)
{
return;
}
this.value = value;
this.OnPropertyChanged();
}
}
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
this.PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "Notify when value changes.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "Notify when value changes.");
}
public void SingleClassOneErrorCorrectFixExplicitTitleExpectedDiagnosticWithPositionAnalyserSupposrtTwoDiagnostics2()
{
var code = @"
namespace RoslynSandbox
{
class Foo
{
private readonly int ↓_value;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
class Foo
{
private readonly int value;
}
}";
AnalyzerAssert.MetadataReferences.Add(MetadataReference.CreateFromFile(typeof(int).Assembly.Location));
var expectedDiagnostic = ExpectedDiagnostic.Create(FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic.Id2);
AnalyzerAssert.FixAll <FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic, DontUseUnderscoreCodeFixProvider>(expectedDiagnostic, code, fixedCode);
AnalyzerAssert.FixAll <FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic, DontUseUnderscoreCodeFixProvider>(expectedDiagnostic, new[] { code }, fixedCode);
AnalyzerAssert.FixAll(new FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic(), new DontUseUnderscoreCodeFixProvider(), expectedDiagnostic, code, fixedCode);
AnalyzerAssert.FixAll(new FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic(), new DontUseUnderscoreCodeFixProvider(), expectedDiagnostic, new[] { code }, fixedCode);
AnalyzerAssert.FixAll <FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic, DontUseUnderscoreCodeFixProvider>(expectedDiagnostic, code, fixedCode, "Rename to: value");
AnalyzerAssert.FixAll <FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic, DontUseUnderscoreCodeFixProvider>(expectedDiagnostic, new[] { code }, fixedCode, "Rename to: value");
AnalyzerAssert.FixAll(new FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic(), new DontUseUnderscoreCodeFixProvider(), expectedDiagnostic, code, fixedCode, fixTitle: "Rename to: value");
AnalyzerAssert.FixAll(new FieldNameMustNotBeginWithUnderscoreDifferentDiagnosticsForPublic(), new DontUseUnderscoreCodeFixProvider(), expectedDiagnostic, new[] { code }, fixedCode, fixTitle: "Rename to: value");
}
public void InternalClassInternalPropertyAutoPropertyToSet()
{
var testCode = @"
namespace RoslynSandbox
{
internal class Foo : Stylet.PropertyChangedBase
{
↓internal int Bar { get; set; }
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
internal class Foo : Stylet.PropertyChangedBase
{
private int bar;
internal int Bar
{
get => this.bar;
set => this.SetAndNotify(ref this.bar, value);
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.SetAndNotify.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode, fixTitle: "PropertyChangedBase.SetAndNotify.");
}
public void TwoClassesOneFixCorrectFixPassOnlyFixedCode(string title, string expected)
{
var code1 = @"
namespace RoslynSandbox
{
class Foo1
{
private readonly int ↓_value;
}
}";
var code2 = @"
namespace RoslynSandbox
{
class Foo2
{
private readonly int value;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
class Foo1
{
private readonly int value;
}
}";
fixedCode = fixedCode.AssertReplace("value", expected);
AnalyzerAssert.MetadataReferences.Add(MetadataReference.CreateFromFile(typeof(int).Assembly.Location));
AnalyzerAssert.FixAll <FieldNameMustNotBeginWithUnderscore, DontUseUnderscoreManyCodeFixProvider>(new[] { code1, code2 }, fixedCode, title);
}
public void WithBackingFieldToSetUnderscoreNames()
{
var testCode = @"
namespace RoslynSandbox.Client
{
public class ViewModel : RoslynSandbox.Core.ViewModelBase
{
private string _name;
↓public string Name
{
get { return _name; }
set { _name = value; }
}
}
}";
var fixedCode = @"
namespace RoslynSandbox.Client
{
public class ViewModel : RoslynSandbox.Core.ViewModelBase
{
private string _name;
public string Name
{
get { return _name; }
set { TrySet(ref _name, value); }
}
}
}";
AnalyzerAssert.CodeFix(Analyzer, Fix, ExpectedDiagnostic, new[] { ViewModelBaseCode, testCode }, fixedCode, fixTitle: "ViewModelBase.TrySet.");
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, new[] { ViewModelBaseCode, testCode }, fixedCode, fixTitle: "ViewModelBase.TrySet.");
}
public void SingleClassCodeFixOnlyCorrectFix()
{
var code = @"
namespace RoslynSandbox
{
using System;
public class Foo
{
public event EventHandler ↓Bar;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
using System;
public class Foo
{
}
}";
AnalyzerAssert.MetadataReferences.Add(MetadataReference.CreateFromFile(typeof(EventHandler).Assembly.Location));
var expectedDiagnostic = ExpectedDiagnostic.CreateFromCodeWithErrorsIndicated("CS0067", code, out code);
AnalyzerAssert.FixAll <RemoveUnusedFixProvider>(expectedDiagnostic, code, fixedCode);
}
public void WhenMutableBeforeGetOnlyFirst()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
↓public int A { get; set; }
↓public int B { get; }
public int C { get; }
public int D { get; }
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public int B { get; }
public int C { get; }
public int D { get; }
public int A { get; set; }
}
}";
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void WithExpectedDiagnosticWhenOneReportsError()
{
var code = @"
namespace RoslynSandbox
{
class Foo
{
private readonly int ↓wrongName;
public int WrongName { get; set; }
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
class Foo
{
private readonly int foo;
public int WrongName { get; set; }
}
}";
AnalyzerAssert.MetadataReferences.Add(MetadataReference.CreateFromFile(typeof(int).Assembly.Location));
var expectedDiagnostic = ExpectedDiagnostic.Create(FieldAndPropertyMustBeNamedFooAnalyzer.FieldDiagnosticId);
AnalyzerAssert.FixAll <FieldAndPropertyMustBeNamedFooAnalyzer, RenameToFooCodeFixProvider>(expectedDiagnostic, code, fixedCode);
AnalyzerAssert.FixAll(new FieldAndPropertyMustBeNamedFooAnalyzer(), new RenameToFooCodeFixProvider(), expectedDiagnostic, code, fixedCode);
}
public void WhenAMess1()
{
var testCode = @"
namespace RoslynSandbox
{
public class Foo
{
↓public int A { get; set; }
↓public int B { get; private set; }
↓public int C { get; }
public int D => C;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo
{
public int C { get; }
public int D => C;
public int B { get; private set; }
public int A { get; set; }
}
}";
AnalyzerAssert.FixAll(Analyzer, Fix, ExpectedDiagnostic, testCode, fixedCode);
}
public void ExplicitImplementation()
{
var interfaceCode = @"
namespace RoslynSandbox
{
interface IValue
{
object Value { get; }
}
}";
var testCode = @"
namespace RoslynSandbox
{
public class Foo : IValue
{
↓private int Value { get; } = 5;
↓object IValue.Value { get; } = 5;
}
}";
var fixedCode = @"
namespace RoslynSandbox
{
public class Foo : IValue
{
object IValue.Value { get; } = 5;
private int Value { get; } = 5;
}
}";
AnalyzerAssert.FixAll <GU0020SortProperties, SortPropertiesCodeFixProvider>(new[] { interfaceCode, testCode }, fixedCode);
}