Skip to content

Commit 57ec098

Browse files
Meir017Meir017
authored
feat: add nunit collection Assert.That All InstanceOf (#362)
1 parent 071740a commit 57ec098

File tree

6 files changed

+311
-4
lines changed

6 files changed

+311
-4
lines changed

‎docs/Nunit3Analyzer.md‎

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -719,6 +719,10 @@ var collection = new object[] { 1, 2, 3 };
719719

720720
// old assertion:
721721
CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int));
722+
Assert.That(collection, Is.All.InstanceOf(typeof(int)));
723+
Assert.That(collection, Is.All.InstanceOf<int>());
724+
Assert.That(collection, Has.All.InstanceOf(typeof(int)));
725+
Assert.That(collection, Has.All.InstanceOf<int>());
722726

723727
// new assertion:
724728
collection.Should().AllBeOfType<int>();
@@ -734,6 +738,22 @@ CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int)); /* fail me
734738
But was: < 1, 2, "3" >
735739
First non-matching item at index [2]: "3"
736740
*/
741+
Assert.That(collection, Is.All.InstanceOf(typeof(int))); /* fail message: Expected: all items instance of <System.Int32>
742+
But was: < 1, 2, "3" >
743+
First non-matching item at index [2]: "3"
744+
*/
745+
Assert.That(collection, Is.All.InstanceOf<int>()); /* fail message: Expected: all items instance of <System.Int32>
746+
But was: < 1, 2, "3" >
747+
First non-matching item at index [2]: "3"
748+
*/
749+
Assert.That(collection, Has.All.InstanceOf(typeof(int))); /* fail message: Expected: all items instance of <System.Int32>
750+
But was: < 1, 2, "3" >
751+
First non-matching item at index [2]: "3"
752+
*/
753+
Assert.That(collection, Has.All.InstanceOf<int>()); /* fail message: Expected: all items instance of <System.Int32>
754+
But was: < 1, 2, "3" >
755+
First non-matching item at index [2]: "3"
756+
*/
737757

738758
// new assertion:
739759
collection.Should().AllBeOfType<int>(); /* fail message: Expected type to be "System.Int32", but found "[System.Int32, System.Int32, System.String]". */
@@ -748,6 +768,8 @@ var type = typeof(int);
748768

749769
// old assertion:
750770
CollectionAssert.AllItemsAreInstancesOfType(collection, type);
771+
Assert.That(collection, Is.All.InstanceOf(type));
772+
Assert.That(collection, Has.All.InstanceOf(type));
751773

752774
// new assertion:
753775
collection.Should().AllBeOfType(type);
@@ -764,6 +786,14 @@ CollectionAssert.AllItemsAreInstancesOfType(collection, type); /* fail message:
764786
But was: < 1, 2, "3" >
765787
First non-matching item at index [2]: "3"
766788
*/
789+
Assert.That(collection, Is.All.InstanceOf(type)); /* fail message: Expected: all items instance of <System.Int32>
790+
But was: < 1, 2, "3" >
791+
First non-matching item at index [2]: "3"
792+
*/
793+
Assert.That(collection, Has.All.InstanceOf(type)); /* fail message: Expected: all items instance of <System.Int32>
794+
But was: < 1, 2, "3" >
795+
First non-matching item at index [2]: "3"
796+
*/
767797

768798
// new assertion:
769799
collection.Should().AllBeOfType(type); /* fail message: Expected type to be "System.Int32", but found "[System.Int32, System.Int32, System.String]". */

‎docs/Nunit4Analyzer.md‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -796,6 +796,10 @@ var collection = new object[] { 1, 2, 3 };
796796

797797
// old assertion:
798798
CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int));
799+
Assert.That(collection, Is.All.InstanceOf(typeof(int)));
800+
Assert.That(collection, Is.All.InstanceOf<int>());
801+
Assert.That(collection, Has.All.InstanceOf(typeof(int)));
802+
Assert.That(collection, Has.All.InstanceOf<int>());
799803

800804
// new assertion:
801805
collection.Should().AllBeOfType<int>();
@@ -812,6 +816,26 @@ CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int)); /* fail me
812816
But was: < 1, 2, "3" >
813817
First non-matching item at index [2]: "3"
814818
*/
819+
Assert.That(collection, Is.All.InstanceOf(typeof(int))); /* fail message: Assert.That(collection, Is.All.InstanceOf(typeof(int)))
820+
Expected: all items instance of <System.Int32>
821+
But was: < 1, 2, "3" >
822+
First non-matching item at index [2]: "3"
823+
*/
824+
Assert.That(collection, Is.All.InstanceOf<int>()); /* fail message: Assert.That(collection, Is.All.InstanceOf<int>())
825+
Expected: all items instance of <System.Int32>
826+
But was: < 1, 2, "3" >
827+
First non-matching item at index [2]: "3"
828+
*/
829+
Assert.That(collection, Has.All.InstanceOf(typeof(int))); /* fail message: Assert.That(collection, Has.All.InstanceOf(typeof(int)))
830+
Expected: all items instance of <System.Int32>
831+
But was: < 1, 2, "3" >
832+
First non-matching item at index [2]: "3"
833+
*/
834+
Assert.That(collection, Has.All.InstanceOf<int>()); /* fail message: Assert.That(collection, Has.All.InstanceOf<int>())
835+
Expected: all items instance of <System.Int32>
836+
But was: < 1, 2, "3" >
837+
First non-matching item at index [2]: "3"
838+
*/
815839

816840
// new assertion:
817841
collection.Should().AllBeOfType<int>(); /* fail message: Expected type to be "System.Int32", but found "[System.Int32, System.Int32, System.String]". */
@@ -826,6 +850,8 @@ var type = typeof(int);
826850

827851
// old assertion:
828852
CollectionAssert.AllItemsAreInstancesOfType(collection, type);
853+
Assert.That(collection, Is.All.InstanceOf(type));
854+
Assert.That(collection, Has.All.InstanceOf(type));
829855

830856
// new assertion:
831857
collection.Should().AllBeOfType(type);
@@ -843,6 +869,16 @@ CollectionAssert.AllItemsAreInstancesOfType(collection, type); /* fail message:
843869
But was: < 1, 2, "3" >
844870
First non-matching item at index [2]: "3"
845871
*/
872+
Assert.That(collection, Is.All.InstanceOf(type)); /* fail message: Assert.That(collection, Is.All.InstanceOf(type))
873+
Expected: all items instance of <System.Int32>
874+
But was: < 1, 2, "3" >
875+
First non-matching item at index [2]: "3"
876+
*/
877+
Assert.That(collection, Has.All.InstanceOf(type)); /* fail message: Assert.That(collection, Has.All.InstanceOf(type))
878+
Expected: all items instance of <System.Int32>
879+
But was: < 1, 2, "3" >
880+
First non-matching item at index [2]: "3"
881+
*/
846882

847883
// new assertion:
848884
collection.Should().AllBeOfType(type); /* fail message: Expected type to be "System.Int32", but found "[System.Int32, System.Int32, System.String]". */

‎src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs.Nunit3/Nunit3AnalyzerTests.cs‎

Lines changed: 70 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1087,13 +1087,17 @@ public void CollectionAssertAllItemsAreInstancesOfType()
10871087

10881088
// old assertion:
10891089
CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int));
1090+
Assert.That(collection, Is.All.InstanceOf(typeof(int)));
1091+
Assert.That(collection, Is.All.InstanceOf<int>());
1092+
Assert.That(collection, Has.All.InstanceOf(typeof(int)));
1093+
Assert.That(collection, Has.All.InstanceOf<int>());
10901094

10911095
// new assertion:
10921096
collection.Should().AllBeOfType<int>();
10931097
}
10941098

10951099
[Test, ExpectedAssertionException]
1096-
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion()
1100+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_0()
10971101
{
10981102
// arrange
10991103
var collection = new object[] { 1, 2, "3" };
@@ -1102,6 +1106,46 @@ public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion()
11021106
CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int));
11031107
}
11041108

1109+
[Test, ExpectedAssertionException]
1110+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_1()
1111+
{
1112+
// arrange
1113+
var collection = new object[] { 1, 2, "3" };
1114+
1115+
// old assertion:
1116+
Assert.That(collection, Is.All.InstanceOf(typeof(int)));
1117+
}
1118+
1119+
[Test, ExpectedAssertionException]
1120+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_2()
1121+
{
1122+
// arrange
1123+
var collection = new object[] { 1, 2, "3" };
1124+
1125+
// old assertion:
1126+
Assert.That(collection, Is.All.InstanceOf<int>());
1127+
}
1128+
1129+
[Test, ExpectedAssertionException]
1130+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_3()
1131+
{
1132+
// arrange
1133+
var collection = new object[] { 1, 2, "3" };
1134+
1135+
// old assertion:
1136+
Assert.That(collection, Has.All.InstanceOf(typeof(int)));
1137+
}
1138+
1139+
[Test, ExpectedAssertionException]
1140+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_4()
1141+
{
1142+
// arrange
1143+
var collection = new object[] { 1, 2, "3" };
1144+
1145+
// old assertion:
1146+
Assert.That(collection, Has.All.InstanceOf<int>());
1147+
}
1148+
11051149
[Test, ExpectedAssertionException]
11061150
public void CollectionAssertAllItemsAreInstancesOfType_Failure_NewAssertion()
11071151
{
@@ -1121,13 +1165,15 @@ public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument()
11211165

11221166
// old assertion:
11231167
CollectionAssert.AllItemsAreInstancesOfType(collection, type);
1168+
Assert.That(collection, Is.All.InstanceOf(type));
1169+
Assert.That(collection, Has.All.InstanceOf(type));
11241170

11251171
// new assertion:
11261172
collection.Should().AllBeOfType(type);
11271173
}
11281174

11291175
[Test, ExpectedAssertionException]
1130-
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion()
1176+
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion_0()
11311177
{
11321178
// arrange
11331179
var collection = new object[] { 1, 2, "3" };
@@ -1137,6 +1183,28 @@ public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_
11371183
CollectionAssert.AllItemsAreInstancesOfType(collection, type);
11381184
}
11391185

1186+
[Test, ExpectedAssertionException]
1187+
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion_1()
1188+
{
1189+
// arrange
1190+
var collection = new object[] { 1, 2, "3" };
1191+
var type = typeof(int);
1192+
1193+
// old assertion:
1194+
Assert.That(collection, Is.All.InstanceOf(type));
1195+
}
1196+
1197+
[Test, ExpectedAssertionException]
1198+
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion_2()
1199+
{
1200+
// arrange
1201+
var collection = new object[] { 1, 2, "3" };
1202+
var type = typeof(int);
1203+
1204+
// old assertion:
1205+
Assert.That(collection, Has.All.InstanceOf(type));
1206+
}
1207+
11401208
[Test, ExpectedAssertionException]
11411209
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_NewAssertion()
11421210
{

‎src/FluentAssertions.Analyzers.FluentAssertionAnalyzerDocs.Nunit4/Nunit4AnalyzerTests.cs‎

Lines changed: 71 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1099,6 +1099,7 @@ public void CollectionAssertDoesNotContain_WithCasting_Failure_NewAssertion()
10991099
collection.Should().NotContain((int)item);
11001100
}
11011101

1102+
11021103
[Test]
11031104
public void CollectionAssertAllItemsAreInstancesOfType()
11041105
{
@@ -1107,13 +1108,17 @@ public void CollectionAssertAllItemsAreInstancesOfType()
11071108

11081109
// old assertion:
11091110
CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int));
1111+
Assert.That(collection, Is.All.InstanceOf(typeof(int)));
1112+
Assert.That(collection, Is.All.InstanceOf<int>());
1113+
Assert.That(collection, Has.All.InstanceOf(typeof(int)));
1114+
Assert.That(collection, Has.All.InstanceOf<int>());
11101115

11111116
// new assertion:
11121117
collection.Should().AllBeOfType<int>();
11131118
}
11141119

11151120
[Test, ExpectedAssertionException]
1116-
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion()
1121+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_0()
11171122
{
11181123
// arrange
11191124
var collection = new object[] { 1, 2, "3" };
@@ -1122,6 +1127,46 @@ public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion()
11221127
CollectionAssert.AllItemsAreInstancesOfType(collection, typeof(int));
11231128
}
11241129

1130+
[Test, ExpectedAssertionException]
1131+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_1()
1132+
{
1133+
// arrange
1134+
var collection = new object[] { 1, 2, "3" };
1135+
1136+
// old assertion:
1137+
Assert.That(collection, Is.All.InstanceOf(typeof(int)));
1138+
}
1139+
1140+
[Test, ExpectedAssertionException]
1141+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_2()
1142+
{
1143+
// arrange
1144+
var collection = new object[] { 1, 2, "3" };
1145+
1146+
// old assertion:
1147+
Assert.That(collection, Is.All.InstanceOf<int>());
1148+
}
1149+
1150+
[Test, ExpectedAssertionException]
1151+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_3()
1152+
{
1153+
// arrange
1154+
var collection = new object[] { 1, 2, "3" };
1155+
1156+
// old assertion:
1157+
Assert.That(collection, Has.All.InstanceOf(typeof(int)));
1158+
}
1159+
1160+
[Test, ExpectedAssertionException]
1161+
public void CollectionAssertAllItemsAreInstancesOfType_Failure_OldAssertion_4()
1162+
{
1163+
// arrange
1164+
var collection = new object[] { 1, 2, "3" };
1165+
1166+
// old assertion:
1167+
Assert.That(collection, Has.All.InstanceOf<int>());
1168+
}
1169+
11251170
[Test, ExpectedAssertionException]
11261171
public void CollectionAssertAllItemsAreInstancesOfType_Failure_NewAssertion()
11271172
{
@@ -1141,13 +1186,15 @@ public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument()
11411186

11421187
// old assertion:
11431188
CollectionAssert.AllItemsAreInstancesOfType(collection, type);
1189+
Assert.That(collection, Is.All.InstanceOf(type));
1190+
Assert.That(collection, Has.All.InstanceOf(type));
11441191

11451192
// new assertion:
11461193
collection.Should().AllBeOfType(type);
11471194
}
11481195

11491196
[Test, ExpectedAssertionException]
1150-
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion()
1197+
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion_0()
11511198
{
11521199
// arrange
11531200
var collection = new object[] { 1, 2, "3" };
@@ -1157,6 +1204,28 @@ public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_
11571204
CollectionAssert.AllItemsAreInstancesOfType(collection, type);
11581205
}
11591206

1207+
[Test, ExpectedAssertionException]
1208+
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion_1()
1209+
{
1210+
// arrange
1211+
var collection = new object[] { 1, 2, "3" };
1212+
var type = typeof(int);
1213+
1214+
// old assertion:
1215+
Assert.That(collection, Is.All.InstanceOf(type));
1216+
}
1217+
1218+
[Test, ExpectedAssertionException]
1219+
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_OldAssertion_2()
1220+
{
1221+
// arrange
1222+
var collection = new object[] { 1, 2, "3" };
1223+
var type = typeof(int);
1224+
1225+
// old assertion:
1226+
Assert.That(collection, Has.All.InstanceOf(type));
1227+
}
1228+
11601229
[Test, ExpectedAssertionException]
11611230
public void CollectionAssertAllItemsAreInstancesOfType_WithTypeArgument_Failure_NewAssertion()
11621231
{

0 commit comments

Comments
 (0)