lduchosal / ipnetwork / 960

Committed 15 May 2026 07:18AM UTC coverage: 0.0% (-94.1%) from 94.053%

Build # 960

Build Type

Pull #411

appveyor

Committed by

web-flow

Commit Message

Merge ef6b054ce into 4cec191ae

Pull Request Pull Request #411: Bump MSTest.TestFramework from 4.2.2 to 4.2.3

Coverage Stats

0 of 2438 relevant lines covered (0.0%)

0.0 hits per line

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

0.0

/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	{	×
22	return Equals(left, right);	×
23	}	×
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	{	×
33	return !Equals(left, right);	×
34	}	×
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	{	×
44	return Compare(left, right) < 0;	×
45	}	×
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	{	×
55	return Compare(left, right) <= 0;	×
56	}	×
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	{	×
66	return Compare(left, right) > 0;	×
67	}	×
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	{	×
77	return Compare(left, right) >= 0;	×
78	}	×
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	{	×
88	return left.Subtract(right);	×
89	}	×
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	{	×
99	if (left.TrySupernet(right, out var result))	×
100	{	×
101	return [result];	×
102	}
103	return [left, right];	×
104	}	×
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	{	×
119	if (add < 0)	×
120	{	×
121	return left - (add * -1);	×
122	}
123	if (add == 0)	×
124	{	×
125	return [left];	×
126	}
127	var start = ToBigInteger(left.First);	×
128	var last = ToBigInteger(left.Last);	×
129	var end = last+ add;	×
130
131	if (end < start)	×
132	{	×
133	return [];	×
134	}
135
136	var startIp = ToIPAddress(start, left.AddressFamily);	×
137	var endIp = ToIPAddress(end, left.AddressFamily);	×
138
139	var uintStart = ToBigInteger(startIp);	×
140	var uintEnd = ToBigInteger(endIp);	×
141
142	if (uintEnd <= uintStart)	×
143	{	×
144	throw new OverflowException("IPNetwork overflow");	×
145	}
146	InternalParseRange(true, startIp, endIp, out IEnumerable<IPNetwork2>? networks);	×
147	return networks ?? [];	×
148	}	×
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	{	×
158	if (subtract < 0)	×
159	{	×
160	return left + (subtract * -1);	×
161	}
162	if (subtract == 0)	×
163	{	×
164	return [left];	×
165	}
166	var start = ToBigInteger(left.First);	×
167	var last = ToBigInteger(left.Last);	×
168	var end = last- subtract;	×
169
170	if (end < start)	×
171	{	×
172	return [];	×
173	}
174
175	var startIp = ToIPAddress(start, left.AddressFamily);	×
176	var endIp = ToIPAddress(end, left.AddressFamily);	×
177
178	InternalParseRange(true, startIp, endIp, out IEnumerable<IPNetwork2>? networks);	×
179	return networks ?? [];	×
180	}	×
181	}

lduchosal / ipnetwork / 960

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