lduchosal / ipnetwork / 881

Committed 07 Mar 2026 04:55PM UTC coverage: 92.371% (-1.0%) from 93.419%

Build # 881

Build Type

Pull #383

appveyor

Committed by

web-flow

Commit Message

Merge 72bf930e1 into 4178c9692

Pull Request Pull Request #383: feat/v4-nullable

Run Details

1901 of 2058 relevant lines covered (92.37%)

580908.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.06

/src/System.Net.IPNetwork/IPNetwork2Operators.cs

// <copyright file="IPNetwork2Operators.cs" company="IPNetwork">
// Copyright (c) IPNetwork. All rights reserved.
// </copyright>

using System.Collections.Generic;

namespace System.Net;

/// <summary>
/// Opertors.
/// </summary>
public sealed partial class IPNetwork2
{
    /// <summary>
    /// Compares two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>true if left equals right; otherwise, false.</returns>
    public static bool operator ==(IPNetwork2? left, IPNetwork2? right)
    {
        return Equals(left, right);
    }

    /// <summary>
    /// Compares two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>true if left does not equals right; otherwise, false.</returns>
    public static bool operator !=(IPNetwork2? left, IPNetwork2? right)
    {
        return !Equals(left, right);
    }

    /// <summary>
    /// Compares two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>true if left is less than right; otherwise, false.</returns>
    public static bool operator <(IPNetwork2? left, IPNetwork2? right)
    {
        return Compare(left, right) < 0;
    }

    /// <summary>
    /// Compares two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>true if left is less than right; otherwise, false.</returns>
    public static bool operator <=(IPNetwork2? left, IPNetwork2? right)
    {
        return Compare(left, right) <= 0;
    }

    /// <summary>
    /// Compares two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>true if left is greater than right; otherwise, false.</returns>
    public static bool operator >(IPNetwork2? left, IPNetwork2? right)
    {
        return Compare(left, right) > 0;
    }

    /// <summary>
    /// Compares two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>true if left is greater than right; otherwise, false.</returns>
    public static bool operator >=(IPNetwork2? left, IPNetwork2? right)
    {
        return Compare(left, right) >= 0;
    }
    
    /// <summary>
    /// Subtract two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>The symmetric difference (subtraction) of two networks.</returns>
    public static List<IPNetwork2> operator -(IPNetwork2 left, IPNetwork2 right)
    {
        return left.Subtract(right);
    }
    
    /// <summary>
    /// Add two IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="right">Right instance.</param>
    /// <returns>Try to supernet two consecutive cidr equal subnet into a single one, otherwise return both netowkrs.</returns>
    public static List<IPNetwork2> operator +(IPNetwork2 left, IPNetwork2 right)
    {
        if (left.TrySupernet(right, out var result))
        {
            return [result];
        }
        return [left, right];
    }
    
    /// <summary>
    /// Behavior
    ///  The addition operator (+) performs the following operations:
    ///  Network Expansion: Adds the specified number of IP addresses to the network range
    ///  Optimal Grouping: Attempts to create the most efficient network representation
    ///  Multiple Networks: When a single contiguous network cannot represent the result, returns multiple networks
    ///  CIDR Optimization: Automatically calculates the appropriate subnet mask for the expanded range
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="add">number.</param>
    /// <returns>Adds the specified number of IP addresses to the network range.</returns>
    public static IEnumerable<IPNetwork2> operator +(IPNetwork2 left, int add)
    {
        if (add < 0)
        {
            return left - (add * -1);
        }
        if (add == 0)
        {
            return [left];
        }
        var start = ToBigInteger(left.First);
        var last = ToBigInteger(left.Last);
        var end = last+ add;

        if (end < start)
        {
            return [];
        }

        var startIp = ToIPAddress(start, left.AddressFamily);
        var endIp = ToIPAddress(end, left.AddressFamily);
        
        var uintStart = ToBigInteger(startIp);
        var uintEnd = ToBigInteger(endIp);

        if (uintEnd <= uintStart)
        {
            throw new OverflowException("IPNetwork overflow");
        }
        InternalParseRange(true, startIp, endIp, out IEnumerable<IPNetwork2>? networks);
        return networks ?? [];
    }
    
    /// <summary>
    /// Add IPNetwork.
    /// </summary>
    /// <param name="left">left instance.</param>
    /// <param name="subtract">number.</param>
    /// <returns>Try to supernet two consecutive cidr equal subnet into a single one, otherwise return both netowkrs.</returns>
    public static IEnumerable<IPNetwork2> operator -(IPNetwork2 left, int subtract)
    {
        if (subtract < 0)
        {
            return left + (subtract * -1);
        }
        if (subtract == 0)
        {
            return [left];
        }
        var start = ToBigInteger(left.First);
        var last = ToBigInteger(left.Last);
        var end = last- subtract;

        if (end < start)
        {
            return [];
        }

        var startIp = ToIPAddress(start, left.AddressFamily);
        var endIp = ToIPAddress(end, left.AddressFamily);
        
        InternalParseRange(true, startIp, endIp, out IEnumerable<IPNetwork2>? networks);
        return networks ?? [];
    }
}

1	// <copyright file="IPNetwork2Operators.cs" company="IPNetwork">
2	// Copyright (c) IPNetwork. All rights reserved.
3	// </copyright>
4
5	using System.Collections.Generic;
6
7	namespace System.Net;
8
9	/// <summary>
10	/// Opertors.
11	/// </summary>
12	public sealed partial class IPNetwork2
13	{
14	/// <summary>
15	/// Compares two IPNetwork.
16	/// </summary>
17	/// <param name="left">left instance.</param>
18	/// <param name="right">Right instance.</param>
19	/// <returns>true if left equals right; otherwise, false.</returns>
20	public static bool operator ==(IPNetwork2? left, IPNetwork2? right)
21	{	331,314✔
22	return Equals(left, right);	331,314✔
23	}	331,314✔
24
25	/// <summary>
26	/// Compares two IPNetwork.
27	/// </summary>
28	/// <param name="left">left instance.</param>
29	/// <param name="right">Right instance.</param>
30	/// <returns>true if left does not equals right; otherwise, false.</returns>
31	public static bool operator !=(IPNetwork2? left, IPNetwork2? right)
32	{	117✔
33	return !Equals(left, right);	117✔
34	}	117✔
35
36	/// <summary>
37	/// Compares two IPNetwork.
38	/// </summary>
39	/// <param name="left">left instance.</param>
40	/// <param name="right">Right instance.</param>
41	/// <returns>true if left is less than right; otherwise, false.</returns>
42	public static bool operator <(IPNetwork2? left, IPNetwork2? right)
43	{	3✔
44	return Compare(left, right) < 0;	3✔
45	}	3✔
46
47	/// <summary>
48	/// Compares two IPNetwork.
49	/// </summary>
50	/// <param name="left">left instance.</param>
51	/// <param name="right">Right instance.</param>
52	/// <returns>true if left is less than right; otherwise, false.</returns>
53	public static bool operator <=(IPNetwork2? left, IPNetwork2? right)
54	{	3✔
55	return Compare(left, right) <= 0;	3✔
56	}	3✔
57
58	/// <summary>
59	/// Compares two IPNetwork.
60	/// </summary>
61	/// <param name="left">left instance.</param>
62	/// <param name="right">Right instance.</param>
63	/// <returns>true if left is greater than right; otherwise, false.</returns>
64	public static bool operator >(IPNetwork2? left, IPNetwork2? right)
65	{	4✔
66	return Compare(left, right) > 0;	4✔
67	}	4✔
68
69	/// <summary>
70	/// Compares two IPNetwork.
71	/// </summary>
72	/// <param name="left">left instance.</param>
73	/// <param name="right">Right instance.</param>
74	/// <returns>true if left is greater than right; otherwise, false.</returns>
75	public static bool operator >=(IPNetwork2? left, IPNetwork2? right)
76	{	5✔
77	return Compare(left, right) >= 0;	5✔
78	}	5✔
79
80	/// <summary>
81	/// Subtract two IPNetwork.
82	/// </summary>
83	/// <param name="left">left instance.</param>
84	/// <param name="right">Right instance.</param>
85	/// <returns>The symmetric difference (subtraction) of two networks.</returns>
86	public static List<IPNetwork2> operator -(IPNetwork2 left, IPNetwork2 right)
87	{	10✔
88	return left.Subtract(right);	10✔
89	}	10✔
90
91	/// <summary>
92	/// Add two IPNetwork.
93	/// </summary>
94	/// <param name="left">left instance.</param>
95	/// <param name="right">Right instance.</param>
96	/// <returns>Try to supernet two consecutive cidr equal subnet into a single one, otherwise return both netowkrs.</returns>
97	public static List<IPNetwork2> operator +(IPNetwork2 left, IPNetwork2 right)
98	{	15✔
99	if (left.TrySupernet(right, out var result))	15✔
100	{	12✔
101	return [result];	12✔
102	}
103	return [left, right];	3✔
104	}	15✔
105
106	/// <summary>
107	/// Behavior
108	/// The addition operator (+) performs the following operations:
109	/// Network Expansion: Adds the specified number of IP addresses to the network range
110	/// Optimal Grouping: Attempts to create the most efficient network representation
111	/// Multiple Networks: When a single contiguous network cannot represent the result, returns multiple networks
112	/// CIDR Optimization: Automatically calculates the appropriate subnet mask for the expanded range
113	/// </summary>
114	/// <param name="left">left instance.</param>
115	/// <param name="add">number.</param>
116	/// <returns>Adds the specified number of IP addresses to the network range.</returns>
117	public static IEnumerable<IPNetwork2> operator +(IPNetwork2 left, int add)
118	{	27✔
119	if (add < 0)	27✔
120	{	2✔
121	return left - (add * -1);	2✔
122	}
123	if (add == 0)	25✔
124	{	1✔
125	return [left];	1✔
126	}
127	var start = ToBigInteger(left.First);	24✔
128	var last = ToBigInteger(left.Last);	24✔
129	var end = last+ add;	24✔
130
131	if (end < start)	24✔
132	{	×
133	return [];	×
134	}
135
136	var startIp = ToIPAddress(start, left.AddressFamily);	24✔
137	var endIp = ToIPAddress(end, left.AddressFamily);	24✔
138
139	var uintStart = ToBigInteger(startIp);	24✔
140	var uintEnd = ToBigInteger(endIp);	24✔
141
142	if (uintEnd <= uintStart)	24✔
143	{	4✔
144	throw new OverflowException("IPNetwork overflow");	4✔
145	}
146	InternalParseRange(true, startIp, endIp, out IEnumerable<IPNetwork2>? networks);	20✔
147	return networks ?? [];	20✔
148	}	23✔
149
150	/// <summary>
151	/// Add IPNetwork.
152	/// </summary>
153	/// <param name="left">left instance.</param>
154	/// <param name="subtract">number.</param>
155	/// <returns>Try to supernet two consecutive cidr equal subnet into a single one, otherwise return both netowkrs.</returns>
156	public static IEnumerable<IPNetwork2> operator -(IPNetwork2 left, int subtract)
157	{	19✔
158	if (subtract < 0)	19✔
159	{	4✔
160	return left + (subtract * -1);	4✔
161	}
162	if (subtract == 0)	15✔
163	{	1✔
164	return [left];	1✔
165	}
166	var start = ToBigInteger(left.First);	14✔
167	var last = ToBigInteger(left.Last);	14✔
168	var end = last- subtract;	14✔
169
170	if (end < start)	14✔
171	{	13✔
172	return [];	13✔
173	}
174
175	var startIp = ToIPAddress(start, left.AddressFamily);	1✔
176	var endIp = ToIPAddress(end, left.AddressFamily);	1✔
177
178	InternalParseRange(true, startIp, endIp, out IEnumerable<IPNetwork2>? networks);	1✔
179	return networks ?? [];	1✔
180	}	17✔
181	}

lduchosal / ipnetwork / 881

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous