Skip to content

Commit 923e75e

Browse files
NoggogNoggog
committed
ShouldlyExt improvements
1 parent b2b5e54 commit 923e75e

File tree

10 files changed

+178
-54
lines changed

10 files changed

+178
-54
lines changed

‎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-
.ShouldBe(
52+
.ShouldEqual(
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-
.ShouldBe(
34+
.ShouldEqual(
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-
.ShouldBe(
47+
.ShouldEqual(
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-
.ShouldBe(
60+
.ShouldEqual(
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-
.ShouldBe(TestEnum.Second);
15+
.ShouldEqual(TestEnum.Second);
1616
Enums<FlagsTestEnum>.EnumerateContainedFlags(default(FlagsTestEnum), includeUndefined: includeUndefined)
1717
.ShouldBeEmpty();
1818
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two, includeUndefined: includeUndefined)
19-
.ShouldBe(FlagsTestEnum.Two);
19+
.ShouldEqual(FlagsTestEnum.Two);
2020
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four, includeUndefined: includeUndefined)
21-
.ShouldBe(FlagsTestEnum.Two, FlagsTestEnum.Four);
21+
.ShouldEqual(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-
.ShouldBe((TestEnum)17);
30+
.ShouldEqual((TestEnum)17);
3131
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four | (FlagsTestEnum)16, includeUndefined: false)
32-
.ShouldBe(FlagsTestEnum.Two, FlagsTestEnum.Four);
32+
.ShouldEqual(FlagsTestEnum.Two, FlagsTestEnum.Four);
3333
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four | (FlagsTestEnum)16, includeUndefined: true)
34-
.ShouldBe(FlagsTestEnum.Two, FlagsTestEnum.Four, (FlagsTestEnum)16);
34+
.ShouldEqual(FlagsTestEnum.Two, FlagsTestEnum.Four, (FlagsTestEnum)16);
3535
Enums<FlagsTestEnum>.EnumerateContainedFlags(FlagsTestEnum.Two | FlagsTestEnum.Four | (FlagsTestEnum)(-16), includeUndefined: false)
36-
.ShouldBe(FlagsTestEnum.Two, FlagsTestEnum.Four);
36+
.ShouldEqual(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-
.ShouldBe(UlongFlagsTestEnum.Two);
47+
.ShouldEqual(UlongFlagsTestEnum.Two);
4848
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two | UlongFlagsTestEnum.Four, includeUndefined: includeUndefined)
49-
.ShouldBe(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
49+
.ShouldEqual(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
5050
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Max, includeUndefined: includeUndefined)
51-
.ShouldBe(UlongFlagsTestEnum.Max);
51+
.ShouldEqual(UlongFlagsTestEnum.Max);
5252
}
5353

5454
[Fact]
5555
public void EnumerateContainedUlongFlagsUndefined()
5656
{
5757
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two | UlongFlagsTestEnum.Four | (UlongFlagsTestEnum)16, includeUndefined: false)
58-
.ShouldBe(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
58+
.ShouldEqual(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four);
5959
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Two | UlongFlagsTestEnum.Four | (UlongFlagsTestEnum)16, includeUndefined: true)
60-
.ShouldBe(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four, (UlongFlagsTestEnum)16);
60+
.ShouldEqual(UlongFlagsTestEnum.Two, UlongFlagsTestEnum.Four, (UlongFlagsTestEnum)16);
6161
Enums<UlongFlagsTestEnum>.EnumerateContainedFlags(UlongFlagsTestEnum.Max, includeUndefined: true)
62-
.ShouldBe(UlongFlagsTestEnum.Max);
62+
.ShouldEqual(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-
.ShouldBe(LongFlagsTestEnum.Two);
73+
.ShouldEqual(LongFlagsTestEnum.Two);
7474
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two | LongFlagsTestEnum.Four, includeUndefined: includeUndefined)
75-
.ShouldBe(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
75+
.ShouldEqual(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
7676
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Max, includeUndefined: includeUndefined)
77-
.ShouldBe(LongFlagsTestEnum.Max);
77+
.ShouldEqual(LongFlagsTestEnum.Max);
7878
}
7979

8080
[Fact]
8181
public void EnumerateContainedLongFlagsUndefined()
8282
{
8383
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two | LongFlagsTestEnum.Four | (LongFlagsTestEnum)16, includeUndefined: false)
84-
.ShouldBe(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
84+
.ShouldEqual(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four);
8585
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Two | LongFlagsTestEnum.Four | (LongFlagsTestEnum)16, includeUndefined: true)
86-
.ShouldBe(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four, (LongFlagsTestEnum)16);
86+
.ShouldEqual(LongFlagsTestEnum.Two, LongFlagsTestEnum.Four, (LongFlagsTestEnum)16);
8787
Enums<LongFlagsTestEnum>.EnumerateContainedFlags(LongFlagsTestEnum.Max, includeUndefined: false)
88-
.ShouldBe(LongFlagsTestEnum.Max);
88+
.ShouldEqual(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.ShouldBe(
12+
Enums<TestEnum>.Values.ShouldEqual(
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.ShouldBe(
27+
Enums<FlagsTestEnum>.Values.ShouldEqual(
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-
.ShouldBe(
116+
.ShouldEqual(
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-
.ShouldBe(
126+
.ShouldEqual(
127127
SomeFileTxt);
128128
}
129129

@@ -132,7 +132,7 @@ public void EnumerateFilesRecursive()
132132
{
133133
var fileSystem = TypicalFileSystem();
134134
fileSystem.Directory.EnumerateFilePaths(DirPath, recursive: true)
135-
.ShouldBe(
135+
.ShouldEqual(
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-
.ShouldBe(
147+
.ShouldEqual(
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-
.ShouldBe(
167+
.ShouldEqual(
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-
.ShouldBe(
177+
.ShouldEqual(
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-
.ShouldBe(
191+
.ShouldEqual(
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).ShouldBe("Hello", "World");
28+
(await tcs.Task).ShouldEqual("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].ShouldBe( "Hello", "World");
64-
results[1].ShouldBe("What", "Is", "Up");
63+
results[0].ShouldEqual( "Hello", "World");
64+
results[1].ShouldEqual("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].ShouldBe("What", "Is", "Up");
88-
results[1].ShouldBe("What", "Is", "Up");
87+
results[0].ShouldEqual("What", "Is", "Up");
88+
results[1].ShouldEqual("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.ShouldBe(secondWait);
64+
results.ShouldEqual(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.ShouldBe(str);
66+
result.Out.ShouldEqual(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.ShouldBe(str);
80+
result.Errors.ShouldEqual(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.ShouldBe(str);
125+
received.ShouldEqual(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.ShouldBe(str);
141+
received.ShouldEqual(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.ShouldBe(str);
188+
received.ShouldEqual(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.ShouldBe(str);
203+
received.ShouldEqual(str);
204204
}
205205

206206
[Theory, DefaultAutoData(ConfigureMembers: false)]

‎CSharpExt.UnitTests/ShouldlyExtTests.cs

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
using Noggog;
2+
using Noggog.Testing.AutoFixture;
3+
using Noggog.Testing.Extensions;
4+
using Shouldly;
5+
6+
namespace CSharpExt.UnitTests;
7+
8+
public class ShouldlyExtTests
9+
{
10+
[Theory, DefaultAutoData]
11+
public void ShouldEqual(
12+
byte b)
13+
{
14+
b.ShouldEqual((int)b);
15+
}
16+
17+
[Theory, DefaultAutoData]
18+
public void ShouldEqualParams(
19+
byte b,
20+
byte b2)
21+
{
22+
byte[] bs = [b, b2];
23+
bs.ShouldEqual((int)b, (int)b2);
24+
}
25+
26+
[Theory, DefaultAutoData]
27+
public void ShouldEqualEnumerable(
28+
IEnumerable<byte> bytes)
29+
{
30+
bytes.ShouldEqual(bytes.Select(x => (int)x));
31+
}
32+
33+
[Theory, DefaultAutoData]
34+
public void ShouldEqualArray(
35+
byte[] bytes)
36+
{
37+
bytes.ShouldEqual(bytes.Select(x => (int)x));
38+
}
39+
40+
[Theory, DefaultAutoData]
41+
public void ShouldEqualStringEnumerable(
42+
IEnumerable<string> str)
43+
{
44+
str.ShouldEqual(str);
45+
}
46+
47+
[Theory, DefaultAutoData]
48+
public void ShouldEqualStringArray(
49+
string str)
50+
{
51+
new[] { str }.ShouldEqual(str);
52+
}
53+
54+
[Theory, DefaultAutoData]
55+
public void ShouldEqualFilePathString(
56+
FilePath path)
57+
{
58+
path.ShouldEqual(path.Path);
59+
path.Path.ShouldEqual(path);
60+
}
61+
62+
[Theory, DefaultAutoData]
63+
public void ShouldEqualFilePathStringEnumerable(
64+
IEnumerable<FilePath> paths)
65+
{
66+
paths.Select(x => x.Path).ShouldEqual(paths);
67+
}
68+
69+
[Theory, DefaultAutoData]
70+
public void ShouldEqualFilePathStringArray(
71+
IEnumerable<FilePath> paths)
72+
{
73+
paths.Select(x => x.Path).ShouldEqual(paths.ToArray());
74+
}
75+
}

0 commit comments

Comments
 (0)