Skip to content

Commit 5a9db52

Browse files
rheoneahsteele
rheone
authored and
ahsteele
committed
Address CA1036 for IPAddressRange and Subnet
CA1036 states that IPAddressRange and Subnet should override the comparison operators, specifically op_Equality, op_Inequality, op_LessThan and op_GreaterThan. Added less than or equal to and greater than or equal to so as not to disappoint. Issue #31
1 parent 3d6f1e1 commit 5a9db52

File tree

4 files changed

+491
-66
lines changed

4 files changed

+491
-66
lines changed

‎src/Arcus.Tests/IPAddressRangeTests.cs‎

Lines changed: 129 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
using System;
1+
using System;
22
using System.Collections.Generic;
33
using System.Globalization;
44
using System.Linq;
@@ -94,10 +94,138 @@ public void Implementation_Test()
9494
Assert.True(typeof(IIPAddressRange).IsAssignableFrom(ipAddressRangeType));
9595
Assert.True(typeof(IComparable<IPAddressRange>).IsAssignableFrom(ipAddressRangeType));
9696
Assert.True(typeof(IEquatable<IPAddressRange>).IsAssignableFrom(ipAddressRangeType));
97+
Assert.True(typeof(IComparable).IsAssignableFrom(ipAddressRangeType));
9798
}
9899

99100
#endregion //end: Class
100101

102+
#region CompareTo / Operators
103+
104+
public static IEnumerable<object[]> Comparison_Values()
105+
{
106+
var ipv4Slash16 = Subnet.Parse("192.168.0.0/16");
107+
var ipv6Slash64 = Subnet.Parse("ab:cd::/64");
108+
var ipv4Slash20 = Subnet.Parse("192.168.0.0/20");
109+
var ipv6Slash96 = Subnet.Parse("ab:cd::/96");
110+
var ipv4All = Subnet.Parse("0.0.0.0/0");
111+
var ipv6All = Subnet.Parse("::/0");
112+
var ipv4Single = Subnet.Parse("0.0.0.0/32");
113+
var ipv6Single = Subnet.Parse("::/128");
114+
115+
yield return new object[] {0, new IPAddressRange(ipv4Slash16.Head, ipv4Slash16.Tail), new IPAddressRange(ipv4Slash16.Head, ipv4Slash16.Tail)};
116+
yield return new object[] {0, new IPAddressRange(ipv6Slash64.Head, ipv6Slash64.Tail), new IPAddressRange(ipv6Slash64.Head, ipv6Slash64.Tail)};
117+
yield return new object[] {1, new IPAddressRange(ipv4Slash16.Head, ipv4Slash16.Tail), null};
118+
yield return new object[] {1, new IPAddressRange(ipv6Slash64.Head, ipv6Slash64.Tail), null};
119+
yield return new object[] {1, new IPAddressRange(ipv4Slash16.Head, ipv4Slash16.Tail), new IPAddressRange(ipv4Slash20.Head, ipv4Slash20.Tail)};
120+
yield return new object[] {-1, new IPAddressRange(ipv4Slash20.Head, ipv4Slash20.Tail), new IPAddressRange(ipv4Slash16.Head, ipv4Slash16.Tail)};
121+
yield return new object[] {1, new IPAddressRange(ipv6Slash64.Head, ipv6Slash64.Tail), new IPAddressRange(ipv6Slash96.Head, ipv6Slash96.Tail)};
122+
yield return new object[] {-1, new IPAddressRange(ipv6Slash96.Head, ipv6Slash96.Tail), new IPAddressRange(ipv6Slash64.Head, ipv6Slash64.Tail)};
123+
yield return new object[] {-1, new IPAddressRange(ipv4All.Head, ipv4All.Tail), new IPAddressRange(ipv6All.Head, ipv6All.Tail)};
124+
yield return new object[] {1, new IPAddressRange(ipv6All.Head, ipv6All.Tail), new IPAddressRange(ipv4All.Head, ipv4All.Tail)};
125+
yield return new object[] {-1, new IPAddressRange(ipv4Single.Head, ipv4Single.Tail), new IPAddressRange(ipv6Single.Head, ipv6Single.Tail)};
126+
yield return new object[] {1, new IPAddressRange(ipv6Single.Head, ipv6Single.Tail), new IPAddressRange(ipv4Single.Head, ipv4Single.Tail)};
127+
}
128+
129+
[Theory]
130+
[MemberData(nameof(Comparison_Values))]
131+
public void CompareTo_Test(int expected,
132+
IPAddressRange left,
133+
IPAddressRange right)
134+
{
135+
// Arrange
136+
// Act
137+
var result = left.CompareTo(right);
138+
139+
// Assert
140+
Assert.Equal(expected, result);
141+
}
142+
143+
[Theory]
144+
[MemberData(nameof(Comparison_Values))]
145+
public void Operator_Equals_Test(int expected,
146+
IPAddressRange left,
147+
IPAddressRange right)
148+
{
149+
// Arrange
150+
// Act
151+
var result = left == right;
152+
153+
// Assert
154+
Assert.Equal(expected == 0, result);
155+
}
156+
157+
[Theory]
158+
[MemberData(nameof(Comparison_Values))]
159+
public void Operator_NotEquals_Test(int expected,
160+
IPAddressRange left,
161+
IPAddressRange right)
162+
{
163+
// Arrange
164+
// Act
165+
var result = left != right;
166+
167+
// Assert
168+
Assert.Equal(expected != 0, result);
169+
}
170+
171+
[Theory]
172+
[MemberData(nameof(Comparison_Values))]
173+
public void Operator_GreaterThan_Test(int expected,
174+
IPAddressRange left,
175+
IPAddressRange right)
176+
{
177+
// Arrange
178+
// Act
179+
var result = left > right;
180+
181+
// Assert
182+
Assert.Equal(expected > 0, result);
183+
}
184+
185+
[Theory]
186+
[MemberData(nameof(Comparison_Values))]
187+
public void Operator_GreaterThanOrEqual_Test(int expected,
188+
IPAddressRange left,
189+
IPAddressRange right)
190+
{
191+
// Arrange
192+
// Act
193+
var result = left >= right;
194+
195+
// Assert
196+
Assert.Equal(expected >= 0, result);
197+
}
198+
199+
[Theory]
200+
[MemberData(nameof(Comparison_Values))]
201+
public void Operator_LessThan_Test(int expected,
202+
IPAddressRange left,
203+
IPAddressRange right)
204+
{
205+
// Arrange
206+
// Act
207+
var result = left < right;
208+
209+
// Assert
210+
Assert.Equal(expected < 0, result);
211+
}
212+
213+
[Theory]
214+
[MemberData(nameof(Comparison_Values))]
215+
public void Operator_LessThanOrEqual_Test(int expected,
216+
IPAddressRange left,
217+
IPAddressRange right)
218+
{
219+
// Arrange
220+
// Act
221+
var result = left <= right;
222+
223+
// Assert
224+
Assert.Equal(expected <= 0, result);
225+
}
226+
227+
#endregion end CompareTo / Operators
228+
101229
#region TailOverlappedBy
102230

103231
[Theory]

‎src/Arcus.Tests/SubnetTests.cs‎

Lines changed: 106 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
using System;
1+
using System;
22
using System.Collections.Generic;
33
using System.Globalization;
44
using System.Linq;
@@ -59,42 +59,125 @@ public void Class_Implementation_Test()
5959
Assert.True(typeof(IIPAddressRange).IsAssignableFrom(subnetType));
6060
Assert.True(typeof(IComparable<Subnet>).IsAssignableFrom(subnetType));
6161
Assert.True(typeof(IEquatable<Subnet>).IsAssignableFrom(subnetType));
62+
Assert.True(typeof(IComparable).IsAssignableFrom(subnetType));
6263
}
6364

6465
#endregion // end: Class
6566

66-
#region CompareTo
67+
#region CompareTo / Operators
68+
69+
public static IEnumerable<object[]> Comparison_Values()
70+
{
71+
yield return new object[] {0, Subnet.Parse("192.168.0.0/16"), Subnet.Parse("192.168.0.0/16")};
72+
yield return new object[] {0, Subnet.Parse("ab:cd::/64"), Subnet.Parse("ab:cd::/64")};
73+
yield return new object[] {1, Subnet.Parse("192.168.0.0/16"), null};
74+
yield return new object[] {1, Subnet.Parse("ab:cd::/64"), null};
75+
yield return new object[] {1, Subnet.Parse("192.168.0.0/16"), Subnet.Parse("192.168.0.0/20")};
76+
yield return new object[] {-1, Subnet.Parse("192.168.0.0/20"), Subnet.Parse("192.168.0.0/16")};
77+
yield return new object[] {1, Subnet.Parse("ab:cd::/64"), Subnet.Parse("ab:cd::/96")};
78+
yield return new object[] {-1, Subnet.Parse("ab:cd::/96"), Subnet.Parse("ab:cd::/64")};
79+
yield return new object[] {-1, Subnet.Parse("0.0.0.0/0"), Subnet.Parse("::/0")};
80+
yield return new object[] {1, Subnet.Parse("::/0"), Subnet.Parse("0.0.0.0/0")};
81+
yield return new object[] {-1, Subnet.Parse("0.0.0.0/32"), Subnet.Parse("::/128")};
82+
yield return new object[] {1, Subnet.Parse("::/128"), Subnet.Parse("0.0.0.0/32")};
83+
}
6784

6885
[Theory]
69-
[InlineData(0, "192.168.0.0/16", "192.168.0.0/16")]
70-
[InlineData(0, "ab:cd::/64", "ab:cd::/64")]
71-
[InlineData(1, "192.168.0.0/16", null)]
72-
[InlineData(1, "ab:cd::/64", null)]
73-
[InlineData(1, "192.168.0.0/16", "192.168.0.0/20")]
74-
[InlineData(-1, "192.168.0.0/20", "192.168.0.0/16")]
75-
[InlineData(1, "ab:cd::/64", "ab:cd::/96")]
76-
[InlineData(-1, "ab:cd::/96", "ab:cd::/64")]
77-
[InlineData(-1, "0.0.0.0/0", "::/0")]
78-
[InlineData(1, "::/0", "0.0.0.0/0")]
79-
[InlineData(-1, "0.0.0.0/32", "::/128")]
80-
[InlineData(1, "::/128", "0.0.0.0/32")]
86+
[MemberData(nameof(Comparison_Values))]
8187
public void CompareTo_Test(int expected,
82-
string x,
83-
string y)
88+
Subnet left,
89+
Subnet right)
8490
{
8591
// Arrange
86-
var thisSubnet = Subnet.Parse(x);
92+
// Act
93+
var result = left.CompareTo(right);
8794

88-
if (!Subnet.TryParse(y, out var other))
89-
{
90-
other = null;
91-
}
95+
// Assert
96+
Assert.Equal(expected, result);
97+
}
9298

99+
[Theory]
100+
[MemberData(nameof(Comparison_Values))]
101+
public void Operator_Equals_Test(int expected,
102+
Subnet left,
103+
Subnet right)
104+
{
105+
// Arrange
93106
// Act
94-
var result = thisSubnet.CompareTo(other);
107+
var result = left == right;
95108

96109
// Assert
97-
Assert.Equal(expected, result);
110+
Assert.Equal(expected == 0, result);
111+
}
112+
113+
[Theory]
114+
[MemberData(nameof(Comparison_Values))]
115+
public void Operator_NotEquals_Test(int expected,
116+
Subnet left,
117+
Subnet right)
118+
{
119+
// Arrange
120+
// Act
121+
var result = left != right;
122+
123+
// Assert
124+
Assert.Equal(expected != 0, result);
125+
}
126+
127+
[Theory]
128+
[MemberData(nameof(Comparison_Values))]
129+
public void Operator_GreaterThan_Test(int expected,
130+
Subnet left,
131+
Subnet right)
132+
{
133+
// Arrange
134+
// Act
135+
var result = left > right;
136+
137+
// Assert
138+
Assert.Equal(expected > 0, result);
139+
}
140+
141+
[Theory]
142+
[MemberData(nameof(Comparison_Values))]
143+
public void Operator_GreaterThanOrEqual_Test(int expected,
144+
Subnet left,
145+
Subnet right)
146+
{
147+
// Arrange
148+
// Act
149+
var result = left >= right;
150+
151+
// Assert
152+
Assert.Equal(expected >= 0, result);
153+
}
154+
155+
[Theory]
156+
[MemberData(nameof(Comparison_Values))]
157+
public void Operator_LessThan_Test(int expected,
158+
Subnet left,
159+
Subnet right)
160+
{
161+
// Arrange
162+
// Act
163+
var result = left < right;
164+
165+
// Assert
166+
Assert.Equal(expected < 0, result);
167+
}
168+
169+
[Theory]
170+
[MemberData(nameof(Comparison_Values))]
171+
public void Operator_LessThanOrEqual_Test(int expected,
172+
Subnet left,
173+
Subnet right)
174+
{
175+
// Arrange
176+
// Act
177+
var result = left <= right;
178+
179+
// Assert
180+
Assert.Equal(expected <= 0, result);
98181
}
99182

100183
#endregion

0 commit comments

Comments
 (0)