Skip to content

Commit fc29488

Browse files
AArnottAArnott
committed
Resolve xunit build warnings
1 parent e120b4b commit fc29488

8 files changed

Lines changed: 93 additions & 93 deletions

File tree

‎src/ImmutableObjectGraph.Generation.Tests/CodeGenTests.cs‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -92,67 +92,67 @@ public async Task OneScalarFieldAndEmptyDerived_HasCreateMethod()
9292
public async Task OneScalarField_HasWithMethod()
9393
{
9494
var result = await this.GenerateFromStreamAsync("OneScalarField");
95-
Assert.True(result.DeclaredMethods.Any(m => m.Name == "With" && m.Parameters.Single().Name == "seeds" && !m.IsStatic));
95+
Assert.Contains(result.DeclaredMethods, m => m.Name == "With" && m.Parameters.Single().Name == "seeds" && !m.IsStatic);
9696
}
9797

9898
[Fact]
9999
public async Task OneScalarField_HasCreateMethod()
100100
{
101101
var result = await this.GenerateFromStreamAsync("OneScalarField");
102-
Assert.True(result.DeclaredMethods.Any(m => m.Name == "Create" && m.Parameters.Single().Name == "seeds"));
102+
Assert.Contains(result.DeclaredMethods, m => m.Name == "Create" && m.Parameters.Single().Name == "seeds");
103103
}
104104

105105
[Fact]
106106
public async Task OneScalarFieldWithBuilder_HasToBuilderMethod()
107107
{
108108
var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
109-
Assert.True(result.DeclaredMethods.Any(m => m.Name == "ToBuilder" && m.Parameters.Length == 0 && !m.IsStatic));
109+
Assert.Contains(result.DeclaredMethods, m => m.Name == "ToBuilder" && m.Parameters.Length == 0 && !m.IsStatic);
110110
}
111111

112112
[Fact]
113113
public async Task OneScalarFieldWithBuilder_HasCreateBuilderMethod()
114114
{
115115
var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
116-
Assert.True(result.DeclaredMethods.Any(m => m.Name == "CreateBuilder" && m.Parameters.Length == 0 && m.IsStatic));
116+
Assert.Contains(result.DeclaredMethods, m => m.Name == "CreateBuilder" && m.Parameters.Length == 0 && m.IsStatic);
117117
}
118118

119119
[Fact]
120120
public async Task OneScalarFieldWithBuilder_BuilderHasMutableProperties()
121121
{
122122
var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
123-
Assert.True(result.DeclaredProperties.Any(p => p.ContainingType?.Name == "Builder" && p.Name == "Seeds" && p.SetMethod != null && p.GetMethod != null));
123+
Assert.Contains(result.DeclaredProperties, p => p.ContainingType?.Name == "Builder" && p.Name == "Seeds" && p.SetMethod != null && p.GetMethod != null);
124124
}
125125

126126
[Fact]
127127
public async Task OneScalarFieldWithBuilder_BuilderHasToImmutableMethod()
128128
{
129129
var result = await this.GenerateFromStreamAsync("OneScalarFieldWithBuilder");
130-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Builder" && m.Name == "ToImmutable" && m.Parameters.Length == 0 && !m.IsStatic));
130+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Builder" && m.Name == "ToImmutable" && m.Parameters.Length == 0 && !m.IsStatic);
131131
}
132132

133133
[Fact]
134134
public async Task ClassDerivesFromAnotherWithFields_DerivedCreateParametersIncludeBaseFields()
135135
{
136136
var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFields");
137-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Fruit" && m.Name == "Create" && m.Parameters.Length == 1));
138-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Apple" && m.Name == "Create" && m.Parameters.Length == 2));
137+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Fruit" && m.Name == "Create" && m.Parameters.Length == 1);
138+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "Create" && m.Parameters.Length == 2);
139139
}
140140

141141
[Fact]
142142
public async Task ClassDerivesFromAnotherWithFields_DerivedWithParametersIncludeBaseFields()
143143
{
144144
var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFields");
145-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Fruit" && m.Name == "With" && m.Parameters.Length == 1));
146-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Apple" && m.Name == "With" && m.Parameters.Length == 2));
145+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Fruit" && m.Name == "With" && m.Parameters.Length == 1);
146+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "With" && m.Parameters.Length == 2);
147147
}
148148

149149
[Fact]
150150
public async Task ClassDerivesFromAnotherWithFields_DerivedWithCoreParametersIncludeBaseFields()
151151
{
152152
var result = await this.GenerateFromStreamAsync("ClassDerivesFromAnotherWithFields");
153-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Fruit" && m.Name == "WithCore" && m.Parameters.Length == 1 && m.IsVirtual));
154-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Apple" && m.Name == "WithCore" && m.Parameters.Length == 1 && m.IsOverride));
155-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType?.Name == "Apple" && m.Name == "WithCore" && m.Parameters.Length == 2 && m.IsVirtual));
153+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Fruit" && m.Name == "WithCore" && m.Parameters.Length == 1 && m.IsVirtual);
154+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "WithCore" && m.Parameters.Length == 1 && m.IsOverride);
155+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType?.Name == "Apple" && m.Name == "WithCore" && m.Parameters.Length == 2 && m.IsVirtual);
156156
}
157157

158158
[Fact]
@@ -167,40 +167,40 @@ public async Task ClassDerivesFromAnotherWithFieldsAndBuilder_BuildersReflectTyp
167167
public async Task AbstractNonEmptyWithDerivedEmpty_HasCreateOnlyInNonAbstractClass()
168168
{
169169
var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
170-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "Create" && m.Parameters.Single().Name == "oneField"));
171-
Assert.False(result.DeclaredMethods.Any(m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "Create"));
170+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "Create" && m.Parameters.Single().Name == "oneField");
171+
Assert.DoesNotContain(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "Create");
172172
}
173173

174174
[Fact]
175175
public async Task AbstractNonEmptyWithDerivedEmpty_HasValidateMethodOnBothTypes()
176176
{
177177
var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
178-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "Validate"));
179-
Assert.False(result.DeclaredMethods.Any(m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "Validate"));
178+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "Validate");
179+
Assert.DoesNotContain(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "Validate");
180180
}
181181

182182
[Fact]
183183
public async Task AbstractNonEmptyWithDerivedEmpty_HasWithMethodOnBothTypes()
184184
{
185185
var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
186-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "With" && m.Parameters.Single().Name == "oneField"));
187-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "With" && m.Parameters.Single().Name == "oneField"));
186+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "With" && m.Parameters.Single().Name == "oneField");
187+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "With" && m.Parameters.Single().Name == "oneField");
188188
}
189189

190190
[Fact]
191191
public async Task AbstractNonEmptyWithDerivedEmpty_HasWithCoreMethodOnBothTypes()
192192
{
193193
var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
194-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "WithCore" && m.Parameters.Single().Name == "oneField"));
195-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "WithCore" && m.Parameters.Single().Name == "oneField"));
194+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "WithCore" && m.Parameters.Single().Name == "oneField");
195+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "WithCore" && m.Parameters.Single().Name == "oneField");
196196
}
197197

198198
[Fact]
199199
public async Task AbstractNonEmptyWithDerivedEmpty_HasWithFactoryMethodOnConcreteTypeOnly()
200200
{
201201
var result = await this.GenerateFromStreamAsync("AbstractNonEmptyWithDerivedEmpty");
202-
Assert.True(result.DeclaredMethods.Any(m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "WithFactory" && m.Parameters.Length == 2));
203-
Assert.False(result.DeclaredMethods.Any(m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "WithFactory" && m.Parameters.Length == 2));
202+
Assert.Contains(result.DeclaredMethods, m => m.ContainingType.Name == "EmptyDerivedFromAbstract" && m.Name == "WithFactory" && m.Parameters.Length == 2);
203+
Assert.DoesNotContain(result.DeclaredMethods, m => m.ContainingType.Name == "AbstractNonEmpty" && m.Name == "WithFactory" && m.Parameters.Length == 2);
204204
}
205205

206206
[Fact]

‎src/ImmutableObjectGraph.Generation.Tests/TestSources/DeepHierarchy.Tests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,7 @@ public void ToBaseType()
5858
{
5959
C1 c1 = C1.Create(1, 2, 3);
6060
A a = c1.ToA();
61-
Assert.IsType(typeof(A), a); // should not be a derived type.
61+
Assert.IsType<A>(a); // should not be a derived type.
6262
Assert.Equal(1, a.Field1);
6363
}
6464

‎src/ImmutableObjectGraph.Generation.Tests/TestSources/FileSystem.Tests.cs‎

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -29,10 +29,10 @@ public void RecursiveDirectories()
2929
{
3030
var emptyRoot = FileSystemDirectory.Create("c:");
3131
Assert.True(emptyRoot is IEnumerable<FileSystemEntry>);
32-
Assert.Equal(0, emptyRoot.Count()); // using Linq exercises the enumerable
32+
Assert.Empty(emptyRoot); // using Linq exercises the enumerable
3333

3434
Assert.Equal(3, this.root.Count()); // use Linq to exercise enumerator
35-
Assert.Equal(1, this.root.OfType<FileSystemDirectory>().Single().Count());
35+
Assert.Single(this.root.OfType<FileSystemDirectory>().Single());
3636
}
3737

3838
[Fact]
@@ -99,7 +99,7 @@ public void AddDescendentWithLookupTableFixup()
9999
FileSystemDirectory updatedRoot = root.AddDescendent(newLeaf, subdir);
100100
Assert.Equal(root.Identity, updatedRoot.Identity);
101101
FileSystemDirectory updatedSubdir = updatedRoot.OfType<FileSystemDirectory>().First();
102-
Assert.True(updatedSubdir.Contains(newLeaf));
102+
Assert.Contains(newLeaf, updatedSubdir);
103103
}
104104

105105
[Fact]
@@ -110,7 +110,7 @@ public void AddDescendent()
110110
FileSystemDirectory updatedRoot = this.root.AddDescendent(newLeaf, subdir);
111111
Assert.Equal(this.root.Identity, updatedRoot.Identity);
112112
FileSystemDirectory updatedSubdir = updatedRoot.OfType<FileSystemDirectory>().First();
113-
Assert.True(updatedSubdir.Contains(newLeaf));
113+
Assert.Contains(newLeaf, updatedSubdir);
114114
}
115115

116116
[Fact]
@@ -122,7 +122,7 @@ public void RemoveDescendentWithLookupTableFixup()
122122
FileSystemDirectory updatedRoot = root.RemoveDescendent(fileUnderSubdir);
123123
Assert.Equal(root.Identity, updatedRoot.Identity);
124124
FileSystemDirectory updatedSubdir = (FileSystemDirectory)updatedRoot.Single(c => c.Identity == subdir.Identity);
125-
Assert.False(updatedSubdir.Contains(fileUnderSubdir));
125+
Assert.DoesNotContain(fileUnderSubdir, updatedSubdir);
126126
}
127127

128128
[Fact]
@@ -133,7 +133,7 @@ public void RemoveDescendent()
133133
FileSystemDirectory updatedRoot = this.root.RemoveDescendent(fileUnderSubdir);
134134
Assert.Equal(this.root.Identity, updatedRoot.Identity);
135135
FileSystemDirectory updatedSubdir = (FileSystemDirectory)updatedRoot.Single(c => c.Identity == subdir.Identity);
136-
Assert.False(updatedSubdir.Contains(fileUnderSubdir));
136+
Assert.DoesNotContain(fileUnderSubdir, updatedSubdir);
137137
}
138138

139139
[Fact]
@@ -142,8 +142,8 @@ public void RedNodeStuff()
142142
var redRoot = this.root.AsRoot;
143143
Assert.Equal(this.root.PathSegment, redRoot.PathSegment);
144144
Assert.Equal(this.root.Children.Count, redRoot.Children.Count);
145-
Assert.True(redRoot.Children.Any(c => c.PathSegment == "a.cs" && c.IsFileSystemFile));
146-
Assert.True(redRoot.Children.Any(c => c.PathSegment == "b.cs" && c.IsFileSystemFile));
145+
Assert.Contains(redRoot.Children, c => c.PathSegment == "a.cs" && c.IsFileSystemFile);
146+
Assert.Contains(redRoot.Children, c => c.PathSegment == "b.cs" && c.IsFileSystemFile);
147147

148148
RootedFileSystemDirectory subdir = redRoot.Children.Last().AsFileSystemDirectory;
149149
Assert.Equal("d.cs", subdir.Children.Single().PathSegment);
@@ -502,7 +502,7 @@ public void ChangesSinceWithPropertyChangeInChild()
502502
var root2 = root1["file1.txt"].AsFileSystemFile.AddAttributes("att2").Root;
503503
IReadOnlyList<FileSystemEntry.DiffGram> changes = root2.ChangesSince(root1);
504504
var changesList = changes.ToList();
505-
Assert.Equal(1, changesList.Count);
505+
Assert.Single(changesList);
506506
Assert.Same(root1["file1.txt"].FileSystemEntry, changesList[0].Before);
507507
Assert.Same(root2["file1.txt"].FileSystemEntry, changesList[0].After);
508508
Assert.Equal(ChangeKind.Replaced, changesList[0].Kind);
@@ -582,11 +582,11 @@ public void Builder_INotifyPropertyChanged_SimpleValue()
582582
// Set a value property and assert it raises the changed event once.
583583
builder.PathSegment = "fo";
584584
Assert.Equal(nameof(builder.PathSegment), raisedName.Pop());
585-
Assert.Equal(0, raisedName.Count);
585+
Assert.Empty(raisedName);
586586

587587
// Set it to the same value and assert no event is raised.
588588
builder.PathSegment = builder.PathSegment;
589-
Assert.Equal(0, raisedName.Count);
589+
Assert.Empty(raisedName);
590590
}
591591

592592
[Fact]
@@ -599,16 +599,16 @@ public void Builder_INotifyPropertyChanged_LazyImmutable()
599599
// Set a Builder property and assert it raises the changed event once.
600600
builder.Data = RichData.CreateBuilder();
601601
Assert.Equal(nameof(builder.Data), raisedName.Pop());
602-
Assert.Equal(0, raisedName.Count);
602+
Assert.Empty(raisedName);
603603

604604
// Set it to the same value and assert no event is raised.
605605
builder.Data = builder.Data;
606-
Assert.Equal(0, raisedName.Count);
606+
Assert.Empty(raisedName);
607607

608608
// Set it to another value.
609609
builder.Data = RichData.CreateBuilder();
610610
Assert.Equal(nameof(builder.Data), raisedName.Pop());
611-
Assert.Equal(0, raisedName.Count);
611+
Assert.Empty(raisedName);
612612
}
613613

614614
private static void VerifyDescendentsShareRoot(RootedFileSystemDirectory directory)

‎src/ImmutableObjectGraph.Generation.Tests/TestSources/ImmutableDictionaryHelpers.Tests.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -44,10 +44,10 @@ public void RemoveMatch()
4444
.AddMatch("six", 6);
4545
Assert.Equal(2, obj.Matches.Count);
4646
obj = obj.RemoveMatch("five");
47-
Assert.Equal(1, obj.Matches.Count);
47+
Assert.Single(obj.Matches);
4848

4949
var rooted = obj.AsRoot.RemoveMatch("six");
50-
Assert.Equal(0, rooted.Matches.Count);
50+
Assert.Empty(rooted.Matches);
5151
}
5252
}
5353
}

‎src/ImmutableObjectGraph.Generation.Tests/TestSources/Person.Tests.cs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ public void DefaultInstance()
3232
var defaultPerson = Person.Create(null);
3333
Assert.NotNull(defaultPerson);
3434
Assert.Equal(0, defaultPerson.Age);
35-
Assert.Equal(null, defaultPerson.Name);
35+
Assert.Null(defaultPerson.Name);
3636
}
3737

3838
[Fact]
@@ -111,7 +111,7 @@ public void WithRevertsToDefaultValues()
111111

112112
var age10 = billAge10.With(name: null);
113113
Assert.Equal(10, age10.Age);
114-
Assert.Equal(null, age10.Name);
114+
Assert.Null(age10.Name);
115115
}
116116

117117
[Fact]
@@ -139,7 +139,7 @@ public void DefaultValues()
139139
// We expect Members to be non-null because we have a partial class defined that specifies that.
140140
var family = Family.Create();
141141
Assert.NotNull(family.Members);
142-
Assert.Equal(0, family.Members.Count);
142+
Assert.Empty(family.Members);
143143
}
144144

145145
[Fact]
@@ -179,26 +179,26 @@ public void CollectionsAlternateMutationMethods()
179179
{
180180
var family = Family.Create();
181181
var familyAdd1 = family.AddMembers(Person.Create("billy", age: 5));
182-
Assert.Equal(0, family.Members.Count);
183-
Assert.Equal(1, familyAdd1.Members.Count);
182+
Assert.Empty(family.Members);
183+
Assert.Single(familyAdd1.Members);
184184

185185
var familyAdd1More = familyAdd1.AddMembers(Person.Create("sally", age: 8));
186186
Assert.Equal(2, familyAdd1More.Members.Count);
187187

188188
var familyRemove1 = familyAdd1More.RemoveMembers(familyAdd1.Members[0]);
189189
Assert.Equal(2, familyAdd1More.Members.Count);
190-
Assert.Equal(1, familyRemove1.Members.Count);
190+
Assert.Single(familyRemove1.Members);
191191

192192
var familyAddMany = familyAdd1.AddMembers(
193193
Person.Create("sally", age: 8),
194194
Person.Create("sam", age: 4));
195195
Assert.Equal(3, familyAddMany.Members.Count);
196196

197197
var familyRemoveMany = familyAddMany.RemoveMembers(familyAdd1More.Members);
198-
Assert.Equal(1, familyRemoveMany.Members.Count);
198+
Assert.Single(familyRemoveMany.Members);
199199

200200
var familyCleared = familyAddMany.RemoveMembers();
201-
Assert.Equal(0, familyCleared.Members.Count);
201+
Assert.Empty(familyCleared.Members);
202202
}
203203
}
204204
}

0 commit comments

Comments
 (0)