Skip to content

Commit c79bf3f

Browse files
NoggogNoggog
committed
Merge branch 'dev'
2 parents 70a47d4 + 467cac2 commit c79bf3f

10 files changed

Lines changed: 65 additions & 92 deletions

File tree

‎CSharpExt.UnitTests/Autofac/FillUsagesTests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ public void Typical()
4949
{
5050
new GetUsages().Get(
5151
typeof(SomeParams))
52-
.ShouldEqual(
52+
.ShouldEqualEnumerable(
5353
typeof(NoCtorClass),
5454
typeof(SubClass));
5555
}

‎CSharpExt.UnitTests/Autofac/RegistrationsTests.cs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ public void NormalNeedsValidation()
3131
new Registrations(cont).Items
3232
.Where(x => x.Key == typeof(Class))
3333
.SelectMany(x => x.Value)
34-
.ShouldEqual(
34+
.ShouldEqualEnumerable(
3535
new Registration(typeof(Class), true));
3636
}
3737

@@ -44,7 +44,7 @@ public void InstanceDoesNotNeedValidation()
4444
new Registrations(cont).Items
4545
.Where(x => x.Key == typeof(Class))
4646
.SelectMany(x => x.Value)
47-
.ShouldEqual(
47+
.ShouldEqualEnumerable(
4848
new Registration(typeof(Class), false));
4949
}
5050

@@ -57,7 +57,7 @@ public void LambdaDoesNotNeedValidation()
5757
new Registrations(cont).Items
5858
.Where(x => x.Key == typeof(Class))
5959
.SelectMany(x => x.Value)
60-
.ShouldEqual(
60+
.ShouldEqualEnumerable(
6161
new Registration(typeof(Class), false));
6262
}
6363

‎CSharpExt.UnitTests/Enum/EnumerateContainedFlagsTests.cs‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -12,13 +12,13 @@ public class EnumerateContainedFlagsTests
1212
public void EnumerateContainedFlags(bool includeUndefined)
1313
{
1414
Enums<TestEnum>.EnumerateContainedFlags(TestEnum.Second, includeUndefined: includeUndefined)
15-
.ShouldEqual(TestEnum.Second);
15+
.ShouldEqualEnumerable(TestEnum.Second);
1616
Enums<FlagsTestEnum>.EnumerateContainedFlags(default(FlagsTestEnum), includeUndefined: includeUndefined)
1717
.ShouldBeEmpty();
1818
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two, includeUndefined: includeUndefined)
19-
.ShouldEqual(FlagsTestEnum.Two);
19+
.ShouldEqualEnumerable(FlagsTestEnum.Two);
2020
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four, includeUndefined: includeUndefined)
21-
.ShouldEqual(FlagsTestEnum.Two, FlagsTestEnum.Four);
21+
.ShouldEqualEnumerable(FlagsTestEnum.Two, FlagsTestEnum.Four);
2222
}
2323

2424
[Fact]
@@ -27,13 +27,13 @@ public void EnumerateContainedFlagsUndefined()
2727
Enums<TestEnum>.EnumerateContainedFlags((TestEnum)17, includeUndefined: false)
2828
.ShouldBeEmpty();
2929
Enums<TestEnum>.EnumerateContainedFlags((TestEnum)17, includeUndefined: true)
30-
.ShouldEqual((TestEnum)17);
30+
.ShouldEqualEnumerable((TestEnum)17);
3131
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four | (FlagsTestEnum)16, includeUndefined: false)
32-
.ShouldEqual(FlagsTestEnum.Two, FlagsTestEnum.Four);
32+
.ShouldEqualEnumerable(FlagsTestEnum.Two, FlagsTestEnum.Four);
3333
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four | (FlagsTestEnum)16, includeUndefined: true)
34-
.ShouldEqual(FlagsTestEnum.Two, FlagsTestEnum.Four, (FlagsTestEnum)16);
34+
.ShouldEqualEnumerable(FlagsTestEnum.Two, FlagsTestEnum.Four, (FlagsTestEnum)16);
3535
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four | (FlagsTestEnum)(-16), includeUndefined: false)
36-
.ShouldEqual(FlagsTestEnum.Two, FlagsTestEnum.Four);
36+
.ShouldEqualEnumerable(FlagsTestEnum.Two, FlagsTestEnum.Four);
3737
}
3838

3939
[Theory]
@@ -44,22 +44,22 @@ public void EnumerateContainedUlongFlags(bool includeUndefined)
4444
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(default(UlongFlagsTestEnum), includeUndefined: includeUndefined)
4545
.ShouldBeEmpty();
4646
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two, includeUndefined: includeUndefined)
47-
.ShouldEqual(UlongFlagsTestEnum.Two);
47+
.ShouldEqualEnumerable(UlongFlagsTestEnum.Two);
4848
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two | UlongFlagsTestEnum.Four, includeUndefined: includeUndefined)
49-
.ShouldEqual(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
49+
.ShouldEqualEnumerable(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
5050
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Max, includeUndefined: includeUndefined)
51-
.ShouldEqual(UlongFlagsTestEnum.Max);
51+
.ShouldEqualEnumerable(UlongFlagsTestEnum.Max);
5252
}
5353

5454
[Fact]
5555
public void EnumerateContainedUlongFlagsUndefined()
5656
{
5757
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two | UlongFlagsTestEnum.Four | (UlongFlagsTestEnum)16, includeUndefined: false)
58-
.ShouldEqual(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
58+
.ShouldEqualEnumerable(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
5959
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two | UlongFlagsTestEnum.Four | (UlongFlagsTestEnum)16, includeUndefined: true)
60-
.ShouldEqual(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four, (UlongFlagsTestEnum)16);
60+
.ShouldEqualEnumerable(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four, (UlongFlagsTestEnum)16);
6161
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Max, includeUndefined: true)
62-
.ShouldEqual(UlongFlagsTestEnum.Max);
62+
.ShouldEqualEnumerable(UlongFlagsTestEnum.Max);
6363
}
6464

6565
[Theory]
@@ -70,21 +70,21 @@ public void EnumerateContainedLongFlags(bool includeUndefined)
7070
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(default(LongFlagsTestEnum), includeUndefined: includeUndefined)
7171
.ShouldBeEmpty();
7272
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two, includeUndefined: includeUndefined)
73-
.ShouldEqual(LongFlagsTestEnum.Two);
73+
.ShouldEqualEnumerable(LongFlagsTestEnum.Two);
7474
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two | LongFlagsTestEnum.Four, includeUndefined: includeUndefined)
75-
.ShouldEqual(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
75+
.ShouldEqualEnumerable(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
7676
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Max, includeUndefined: includeUndefined)
77-
.ShouldEqual(LongFlagsTestEnum.Max);
77+
.ShouldEqualEnumerable(LongFlagsTestEnum.Max);
7878
}
7979

8080
[Fact]
8181
public void EnumerateContainedLongFlagsUndefined()
8282
{
8383
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two | LongFlagsTestEnum.Four | (LongFlagsTestEnum)16, includeUndefined: false)
84-
.ShouldEqual(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
84+
.ShouldEqualEnumerable(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
8585
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two | LongFlagsTestEnum.Four | (LongFlagsTestEnum)16, includeUndefined: true)
86-
.ShouldEqual(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four, (LongFlagsTestEnum)16);
86+
.ShouldEqualEnumerable(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four, (LongFlagsTestEnum)16);
8787
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Max, includeUndefined: false)
88-
.ShouldEqual(LongFlagsTestEnum.Max);
88+
.ShouldEqualEnumerable(LongFlagsTestEnum.Max);
8989
}
9090
}

‎CSharpExt.UnitTests/Enum/ValuesTests.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ public class ValuesTests
99
[Fact]
1010
public void Typical()
1111
{
12-
Enums<TestEnum>.Values.ShouldEqual(
12+
Enums<TestEnum>.Values.ShouldEqualEnumerable(
1313
TestEnum.First,
1414
TestEnum.Second,
1515
TestEnum.Third);
@@ -24,7 +24,7 @@ public void Empty()
2424
[Fact]
2525
public void TypicalFlags()
2626
{
27-
Enums<FlagsTestEnum>.Values.ShouldEqual(
27+
Enums<FlagsTestEnum>.Values.ShouldEqualEnumerable(
2828
FlagsTestEnum.One,
2929
FlagsTestEnum.Two,
3030
FlagsTestEnum.Four);

‎CSharpExt.UnitTests/IFileSystemExtTests.cs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -113,7 +113,7 @@ public void EnumerateFiles()
113113
{
114114
var fileSystem = TypicalFileSystem();
115115
fileSystem.Directory.EnumerateFilePaths(DirPath)
116-
.ShouldEqual(
116+
.ShouldEqualEnumerable(
117117
SomeFile,
118118
SomeFileTxt);
119119
}
@@ -123,7 +123,7 @@ public void EnumerateFiles_SearchPattern()
123123
{
124124
var fileSystem = TypicalFileSystem();
125125
fileSystem.Directory.EnumerateFilePaths(DirPath, "*.txt")
126-
.ShouldEqual(
126+
.ShouldEqualEnumerable(
127127
SomeFileTxt);
128128
}
129129

@@ -132,7 +132,7 @@ public void EnumerateFilesRecursive()
132132
{
133133
var fileSystem = TypicalFileSystem();
134134
fileSystem.Directory.EnumerateFilePaths(DirPath, recursive: true)
135-
.ShouldEqual(
135+
.ShouldEqualEnumerable(
136136
SomeFile,
137137
SomeFileTxt,
138138
SomeSubFile,
@@ -144,7 +144,7 @@ public void EnumerateFilesRecursive_SearchPattern()
144144
{
145145
var fileSystem = TypicalFileSystem();
146146
fileSystem.Directory.EnumerateFilePaths(DirPath, "*.txt", recursive: true)
147-
.ShouldEqual(
147+
.ShouldEqualEnumerable(
148148
SomeFileTxt,
149149
SomeSubFileTxt);
150150
}
@@ -164,7 +164,7 @@ public void EnumerateDirectories()
164164
{ subSubDir, new MockFileData("Doop") },
165165
});
166166
fileSystem.Directory.EnumerateDirectoryPaths(DirPath, includeSelf: true, recursive: true)
167-
.ShouldEqual(
167+
.ShouldEqualEnumerable(
168168
DirPath,
169169
SomeSubDir);
170170
}
@@ -174,7 +174,7 @@ public void EnumerateDirectories_NoSelf()
174174
{
175175
var fileSystem = TypicalFileSystem();
176176
fileSystem.Directory.EnumerateDirectoryPaths(DirPath, includeSelf: false, recursive: true)
177-
.ShouldEqual(
177+
.ShouldEqualEnumerable(
178178
SomeSubDir);
179179
}
180180

@@ -188,7 +188,7 @@ public void EnumerateDirectories_NoRecursive()
188188
{ Path.Combine(SomeSubDir, "SubSubDir"), new MockFileData("Doop") },
189189
});
190190
fileSystem.Directory.EnumerateDirectoryPaths(DirPath, includeSelf: true, recursive: false)
191-
.ShouldEqual(
191+
.ShouldEqualEnumerable(
192192
DirPath,
193193
SomeSubDir);
194194
}

‎CSharpExt.UnitTests/IO/SingleApplicationEnforcerTests.cs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ public async Task SendingMessageIsReceivedOnExistingApp(string appName)
2525

2626
singleApp.ForwardArgs(new []{ "Hello", "World" });
2727

28-
(await tcs.Task).ShouldEqual("Hello", "World");
28+
(await tcs.Task).ShouldEqualEnumerable("Hello", "World");
2929
}
3030

3131
[Theory, DefaultAutoData]
@@ -60,8 +60,8 @@ public async Task SendingMultipleMessagesWithDelayGetsAll(string appName)
6060
await Task.Delay(100);
6161

6262
results.Count.ShouldBe(2);
63-
results[0].ShouldEqual( "Hello", "World");
64-
results[1].ShouldEqual("What", "Is", "Up");
63+
results[0].ShouldEqualEnumerable( "Hello", "World");
64+
results[1].ShouldEqualEnumerable("What", "Is", "Up");
6565
}
6666

6767
[Theory, DefaultAutoData]
@@ -84,7 +84,7 @@ public async Task SendingMultipleMessagesImmediatelyProblematic(string appName)
8484

8585
// Notified twice, but only see the last message twice
8686
results.Count.ShouldBe(2);
87-
results[0].ShouldEqual("What", "Is", "Up");
88-
results[1].ShouldEqual("What", "Is", "Up");
87+
results[0].ShouldEqualEnumerable("What", "Is", "Up");
88+
results[1].ShouldEqualEnumerable("What", "Is", "Up");
8989
}
9090
}

‎CSharpExt.UnitTests/ObservableExtTests.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -61,7 +61,7 @@ public class ObservableExtTests
6161
scheduler.AdvanceBy(20);
6262
await complete.Task;
6363
results.Count.ShouldBe(1);
64-
results.ShouldEqual(secondWait);
64+
results.ShouldEqualEnumerable(secondWait);
6565
});
6666

6767
[Theory, TestData(FileSystem: TargetFileSystem.Fake)]

‎CSharpExt.UnitTests/Processes/ProcessRunnerTests.cs‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -63,7 +63,7 @@ public async Task RunAndCapture_PutsOutIntoOut(
6363
process.Output.Returns(Observable.Return(str));
6464
sut.Factory.Create(default!).ReturnsForAnyArgs(process);
6565
var result = await sut.RunAndCapture(startInfo, cancel);
66-
result.Out.ShouldEqual(str);
66+
result.Out.ShouldEqualEnumerable(str);
6767
}
6868

6969
[Theory, DefaultAutoData(ConfigureMembers: false)]
@@ -77,7 +77,7 @@ public async Task RunAndCapture_PutsErrIntoErr(
7777
process.Error.Returns(Observable.Return(str));
7878
sut.Factory.Create(default!).ReturnsForAnyArgs(process);
7979
var result = await sut.RunAndCapture(startInfo, cancel);
80-
result.Errors.ShouldEqual(str);
80+
result.Errors.ShouldEqualEnumerable(str);
8181
}
8282

8383
[Theory, DefaultAutoData(ConfigureMembers: false)]
@@ -122,7 +122,7 @@ public async Task RunWithCallbacks_CallsOutCallback(
122122
sut.Factory.Create(default!).ReturnsForAnyArgs(process);
123123
var received = new List<string>();
124124
await sut.RunWithCallback(startInfo, received.Add, errCb, cancel);
125-
received.ShouldEqual(str);
125+
received.ShouldEqualEnumerable(str);
126126
}
127127

128128
[Theory, DefaultAutoData(ConfigureMembers: false)]
@@ -138,7 +138,7 @@ public async Task RunWithCallbacks_PutsErrIntoErr(
138138
sut.Factory.Create(default!).ReturnsForAnyArgs(process);
139139
var received = new List<string>();
140140
await sut.RunWithCallback(startInfo, outCb, received.Add, cancel);
141-
received.ShouldEqual(str);
141+
received.ShouldEqualEnumerable(str);
142142
}
143143

144144
[Theory, DefaultAutoData(ConfigureMembers: false)]
@@ -185,7 +185,7 @@ public async Task RunWithCallback_CallsOutCallback(
185185
sut.Factory.Create(default!).ReturnsForAnyArgs(process);
186186
var received = new List<string>();
187187
await sut.RunWithCallback(startInfo, received.Add, cancel);
188-
received.ShouldEqual(str);
188+
received.ShouldEqualEnumerable(str);
189189
}
190190

191191
[Theory, DefaultAutoData(ConfigureMembers: false)]
@@ -200,7 +200,7 @@ public async Task RunWithCallback_PutsErrIntoCallback(
200200
sut.Factory.Create(default!).ReturnsForAnyArgs(process);
201201
var received = new List<string>();
202202
await sut.RunWithCallback(startInfo, received.Add, cancel);
203-
received.ShouldEqual(str);
203+
received.ShouldEqualEnumerable(str);
204204
}
205205

206206
[Theory, DefaultAutoData(ConfigureMembers: false)]

‎CSharpExt.UnitTests/ShouldlyExtTests.cs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -34,35 +34,35 @@ public void ShouldEqualParams(
3434
byte b2)
3535
{
3636
byte[] bs = [b, b2];
37-
bs.ShouldEqual((int)b, (int)b2);
37+
bs.ShouldEqualEnumerable((int)b, (int)b2);
3838
}
3939

4040
[Theory, DefaultAutoData]
4141
public void ShouldEqualEnumerable(
4242
IEnumerable<byte> bytes)
4343
{
44-
bytes.ShouldEqual(bytes.Select(x => (int)x));
44+
bytes.ShouldEqualEnumerable(bytes.Select(x => (int)x));
4545
}
4646

4747
[Theory, DefaultAutoData]
4848
public void ShouldEqualArray(
4949
byte[] bytes)
5050
{
51-
bytes.ShouldEqual(bytes.Select(x => (int)x));
51+
bytes.ShouldEqualEnumerable(bytes.Select(x => (int)x));
5252
}
5353

5454
[Theory, DefaultAutoData]
5555
public void ShouldEqualStringEnumerable(
5656
IEnumerable<string> str)
5757
{
58-
str.ShouldEqual(str);
58+
str.ShouldEqualEnumerable(str);
5959
}
6060

6161
[Theory, DefaultAutoData]
6262
public void ShouldEqualStringArray(
6363
string str)
6464
{
65-
new[] { str }.ShouldEqual(str);
65+
new[] { str }.ShouldEqualEnumerable(str);
6666
}
6767

6868
[Theory, DefaultAutoData]
@@ -77,13 +77,13 @@ public void ShouldEqualFilePathString(
7777
public void ShouldEqualFilePathStringEnumerable(
7878
IEnumerable<FilePath> paths)
7979
{
80-
paths.Select(x => x.Path).ShouldEqual(paths);
80+
paths.Select(x => x.Path).ShouldEqualEnumerable(paths);
8181
}
8282

8383
[Theory, DefaultAutoData]
8484
public void ShouldEqualFilePathStringArray(
8585
IEnumerable<FilePath> paths)
8686
{
87-
paths.Select(x => x.Path).ShouldEqual(paths.ToArray());
87+
paths.Select(x => x.Path).ShouldEqualEnumerable(paths.ToArray());
8888
}
8989
}

0 commit comments

Comments
 (0)