lduchosal / ipnetwork / 809

Committed 17 Aug 2025 08:25AM UTC coverage: 93.223% (-1.0%) from 94.226%

Build # 809

Build Type

push

appveyor

Committed by

web-flow

Commit Message

Chore: cleanup, breaking changes, enum, tryparse, exception, static ListIPAddress (#363)

* Chore: huge cleanup, enum, tryparse, exception, static ListIPAddress, important changes : IPNetwork comparison and sort order have change to reflect expected behavoir
* Fix: obsolete enums
* Fix: network sorting and member comparison
* Chore: upgrade version number 3.3

Run Details

1802 of 1933 relevant lines covered (93.22%)

726934.37 hits per line

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

97.12

/src/System.Net.IPNetwork/IPNetwork2InternalParse.cs

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

namespace System.Net;

using System.Text.RegularExpressions;

/// <summary>
/// The InternalParse methodes.
/// </summary>
public partial class IPNetwork2
{
    /// <summary>
    /// 192.168.168.100 - 255.255.255.0
    ///
    /// Network   : 192.168.168.0
    /// Netmask   : 255.255.255.0
    /// Cidr      : 24
    /// Start     : 192.168.168.1
    /// End       : 192.168.168.254
    /// Broadcast : 192.168.168.255.
    /// </summary>
    /// <param name="tryParse">Whether to throw exception or not during conversion.</param>
    /// <param name="ipaddress">A string containing an ip address to convert.</param>
    /// <param name="netmask">A string containing a netmask to convert (255.255.255.0).</param>
    /// <param name="ipnetwork">The resulting IPNetwork.</param>
    private static bool InternalParse(bool tryParse, string ipaddress, string netmask, out IPNetwork2 ipnetwork)
    {
        if (string.IsNullOrEmpty(ipaddress))
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(ipaddress));
            }

            ipnetwork = null;
            return false;
        }

        if (string.IsNullOrEmpty(netmask))
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(netmask));
            }

            ipnetwork = null;
            return false;
        }

        bool ipaddressParsed = IPAddress.TryParse(ipaddress, out IPAddress ip);
        if (!ipaddressParsed)
        {
            if (!tryParse)
            {
                throw new ArgumentException("ipaddress");
            }

            ipnetwork = null;
            return false;
        }

        bool netmaskParsed = IPAddress.TryParse(netmask, out IPAddress mask);
        if (!netmaskParsed)
        {
            if (!tryParse)
            {
                throw new ArgumentException("netmask");
            }

            ipnetwork = null;
            return false;
        }

        bool parsed = InternalParse(tryParse, ip, mask, out ipnetwork);
        return parsed;
    }

    /// <summary>
    /// Internal parse an IPNetwork2.
    /// </summary>
    /// <param name="tryParse">Prevent exception.</param>
    /// <param name="network">The network to parse.</param>
    /// <param name="cidrGuess">The way to guess CIDR.</param>
    /// <param name="sanitize">If true, removes invalid characters and normalizes whitespace from the network string, keeping only valid network address characters (0-9, a-f, A-F, ., /, :, and spaces).</param>
    /// <param name="ipnetwork">The resulting IPNetwork.</param>
    /// <exception cref="ArgumentNullException">When network is null.</exception>
    /// <exception cref="ArgumentException">When network is not valid.</exception>
    /// <returns>true if parsed, otherwise false</returns>
    private static bool InternalParse(bool tryParse, string network, ICidrGuess cidrGuess, bool sanitize, out IPNetwork2 ipnetwork)
    {
        if (string.IsNullOrEmpty(network))
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(network));
            }

            ipnetwork = null;
            return false;
        }

        if (sanitize)
        {
            network = Regex.Replace(network, @"[^0-9a-fA-F\.\/\s\:]+", string.Empty, RegexOptions.None, TimeSpan.FromMilliseconds(100));
            network = Regex.Replace(network, @"\s{2,}", " ", RegexOptions.None, TimeSpan.FromMilliseconds(100));
            network = network.Trim();
        }

        StringSplitOptions splitOptions = sanitize ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None;
        string[] args = network.Split([' ', '/'], splitOptions);

        if (args.Length == 0)
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(network));
            }

            ipnetwork = null;
            return false;
        }
        
        if (args.Length == 1)
        {
            string cidrlessNetwork = args[0];
            if (cidrGuess.TryGuessCidr(cidrlessNetwork, out byte cidr))
            {
                bool parsed = InternalParse(tryParse, cidrlessNetwork, cidr, out ipnetwork);
                return parsed;
            }

            if (!tryParse)
            {
                throw new ArgumentException("network");
            }

            ipnetwork = null;
            return false;
        }
        
        if (args.Length == 2)
        {
            if (byte.TryParse(args[1], out byte cidr1))
            {
                bool parsed2 = InternalParse(tryParse, args[0], cidr1, out ipnetwork);
                return parsed2;
            }

            bool parsed3 = InternalParse(tryParse, args[0], args[1], out ipnetwork);
            return parsed3;
        }
        else
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(network));
            }
            ipnetwork = null;
            return false;
        }
    }

    /// <summary>
    /// 192.168.168.100 255.255.255.0
    ///
    /// Network   : 192.168.168.0
    /// Netmask   : 255.255.255.0
    /// Cidr      : 24
    /// Start     : 192.168.168.1
    /// End       : 192.168.168.254
    /// Broadcast : 192.168.168.255.
    /// </summary>
    /// <param name="tryParse">Whether to throw exception or not during conversion.</param>
    /// <param name="ipaddress">An ip address to convert.</param>
    /// <param name="netmask">A netmask to convert (255.255.255.0).</param>
    /// <param name="ipnetwork">The resulting IPNetwork.</param>
    private static bool InternalParse(bool tryParse, IPAddress ipaddress, IPAddress netmask, out IPNetwork2 ipnetwork)
    {
        if (ipaddress == null)
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(ipaddress));
            }

            ipnetwork = null;
            return false;
        }

        if (netmask == null)
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(netmask));
            }

            ipnetwork = null;
            return false;
        }

        var uintIpAddress = ToBigInteger(ipaddress);
        bool parsed = TryToCidr(netmask, out byte cidr2);
        if (!parsed)
        {
            if (!tryParse)
            {
                throw new ArgumentException("netmask");
            }

            ipnetwork = null;
            return false;
        }

        var ipnet = new IPNetwork2(uintIpAddress, ipaddress.AddressFamily, cidr2);
        ipnetwork = ipnet;
        return true;
    }

    /// <summary>
    /// 192.168.168.100/24
    ///
    /// Network   : 192.168.168.0
    /// Netmask   : 255.255.255.0
    /// Cidr      : 24
    /// Start     : 192.168.168.1
    /// End       : 192.168.168.254
    /// Broadcast : 192.168.168.255.
    /// </summary>
    /// <param name="tryParse">Whether to throw exception or not during conversion.</param>
    /// <param name="ipaddress">A string containing an ip address to convert.</param>
    /// <param name="cidr">A byte representing the CIDR to be used in conversion (/24).</param>
    /// <param name="ipnetwork">The resulting IPNetwork.</param>
    private static bool InternalParse(bool tryParse, string ipaddress, byte cidr, out IPNetwork2 ipnetwork)
    {
        if (string.IsNullOrEmpty(ipaddress))
        {
            if (!tryParse)
            {
                throw new ArgumentNullException(nameof(ipaddress));
            }

            ipnetwork = null;
            return false;
        }

        bool ipaddressParsed = IPAddress.TryParse(ipaddress, out IPAddress ip);
        if (!ipaddressParsed)
        {
            if (!tryParse)
            {
                throw new ArgumentException("ipaddress");
            }

            ipnetwork = null;
            return false;
        }

        bool parsedNetmask = TryToNetmask(cidr, ip.AddressFamily, out IPAddress mask);
        if (!parsedNetmask)
        {
            if (!tryParse)
            {
                throw new ArgumentException("cidr");
            }

            ipnetwork = null;
            return false;
        }

        bool parsed = InternalParse(tryParse, ip, mask, out ipnetwork);
        return parsed;
    }
}

1	// <copyright file="IPNetwork2InternalParse.cs" company="IPNetwork">
2	// Copyright (c) IPNetwork. All rights reserved.
3	// </copyright>
4
5	namespace System.Net;
6
7	using System.Text.RegularExpressions;
8
9	/// <summary>
10	/// The InternalParse methodes.
11	/// </summary>
12	public partial class IPNetwork2
13	{
14	/// <summary>
15	/// 192.168.168.100 - 255.255.255.0
16	///
17	/// Network : 192.168.168.0
18	/// Netmask : 255.255.255.0
19	/// Cidr : 24
20	/// Start : 192.168.168.1
21	/// End : 192.168.168.254
22	/// Broadcast : 192.168.168.255.
23	/// </summary>
24	/// <param name="tryParse">Whether to throw exception or not during conversion.</param>
25	/// <param name="ipaddress">A string containing an ip address to convert.</param>
26	/// <param name="netmask">A string containing a netmask to convert (255.255.255.0).</param>
27	/// <param name="ipnetwork">The resulting IPNetwork.</param>
28	private static bool InternalParse(bool tryParse, string ipaddress, string netmask, out IPNetwork2 ipnetwork)
29	{	81✔
30	if (string.IsNullOrEmpty(ipaddress))	81✔
31	{	5✔
32	if (!tryParse)	5✔
33	{	3✔
34	throw new ArgumentNullException(nameof(ipaddress));	3✔
35	}
36
37	ipnetwork = null;	2✔
38	return false;	2✔
39	}
40
41	if (string.IsNullOrEmpty(netmask))	76✔
42	{	6✔
43	if (!tryParse)	6✔
44	{	4✔
45	throw new ArgumentNullException(nameof(netmask));	4✔
46	}
47
48	ipnetwork = null;	2✔
49	return false;	2✔
50	}
51
52	bool ipaddressParsed = IPAddress.TryParse(ipaddress, out IPAddress ip);	70✔
53	if (!ipaddressParsed)	70✔
54	{	6✔
55	if (!tryParse)	6✔
56	{	4✔
57	throw new ArgumentException("ipaddress");	4✔
58	}
59
60	ipnetwork = null;	2✔
61	return false;	2✔
62	}
63
64	bool netmaskParsed = IPAddress.TryParse(netmask, out IPAddress mask);	64✔
65	if (!netmaskParsed)	64✔
66	{	4✔
67	if (!tryParse)	4✔
68	{	2✔
69	throw new ArgumentException("netmask");	2✔
70	}
71
72	ipnetwork = null;	2✔
73	return false;	2✔
74	}
75
76	bool parsed = InternalParse(tryParse, ip, mask, out ipnetwork);	60✔
77	return parsed;	58✔
78	}	66✔
79
80	/// <summary>
81	/// Internal parse an IPNetwork2.
82	/// </summary>
83	/// <param name="tryParse">Prevent exception.</param>
84	/// <param name="network">The network to parse.</param>
85	/// <param name="cidrGuess">The way to guess CIDR.</param>
86	/// <param name="sanitize">If true, removes invalid characters and normalizes whitespace from the network string, keeping only valid network address characters (0-9, a-f, A-F, ., /, :, and spaces).</param>
87	/// <param name="ipnetwork">The resulting IPNetwork.</param>
88	/// <exception cref="ArgumentNullException">When network is null.</exception>
89	/// <exception cref="ArgumentException">When network is not valid.</exception>
90	/// <returns>true if parsed, otherwise false</returns>
91	private static bool InternalParse(bool tryParse, string network, ICidrGuess cidrGuess, bool sanitize, out IPNetwork2 ipnetwork)
92	{	4,001,022✔
93	if (string.IsNullOrEmpty(network))	4,001,022✔
94	{	5✔
95	if (!tryParse)	5✔
96	{	3✔
97	throw new ArgumentNullException(nameof(network));	3✔
98	}
99
100	ipnetwork = null;	2✔
101	return false;	2✔
102	}
103
104	if (sanitize)	4,001,017✔
105	{	4,001,010✔
106	network = Regex.Replace(network, @"[^0-9a-fA-F\.\/\s\:]+", string.Empty, RegexOptions.None, TimeSpan.FromMilliseconds(100));	4,001,010✔
107	network = Regex.Replace(network, @"\s{2,}", " ", RegexOptions.None, TimeSpan.FromMilliseconds(100));	4,001,010✔
108	network = network.Trim();	4,001,010✔
109	}	4,001,010✔
110
111	StringSplitOptions splitOptions = sanitize ? StringSplitOptions.RemoveEmptyEntries : StringSplitOptions.None;	4,001,017✔
112	string[] args = network.Split([' ', '/'], splitOptions);	4,001,017✔
113
114	if (args.Length == 0)	4,001,017✔
115	{	1✔
116	if (!tryParse)	1✔
117	{	×
118	throw new ArgumentNullException(nameof(network));	×
119	}
120
121	ipnetwork = null;	1✔
122	return false;	1✔
123	}
124
125	if (args.Length == 1)	4,001,016✔
126	{	54✔
127	string cidrlessNetwork = args[0];	54✔
128	if (cidrGuess.TryGuessCidr(cidrlessNetwork, out byte cidr))	54✔
129	{	49✔
130	bool parsed = InternalParse(tryParse, cidrlessNetwork, cidr, out ipnetwork);	49✔
131	return parsed;	49✔
132	}
133
134	if (!tryParse)	5✔
135	{	2✔
136	throw new ArgumentException("network");	2✔
137	}
138
139	ipnetwork = null;	3✔
140	return false;	3✔
141	}
142
143	if (args.Length == 2)	4,000,962✔
144	{	4,000,959✔
145	if (byte.TryParse(args[1], out byte cidr1))	4,000,959✔
146	{	4,000,914✔
147	bool parsed2 = InternalParse(tryParse, args[0], cidr1, out ipnetwork);	4,000,914✔
148	return parsed2;	4,000,914✔
149	}
150
151	bool parsed3 = InternalParse(tryParse, args[0], args[1], out ipnetwork);	45✔
152	return parsed3;	43✔
153	}
154	else
155	{	3✔
156	if (!tryParse)	3✔
157	{	×
158	throw new ArgumentNullException(nameof(network));	×
159	}
160	ipnetwork = null;	3✔
161	return false;	3✔
162	}
163	}	4,001,015✔
164
165	/// <summary>
166	/// 192.168.168.100 255.255.255.0
167	///
168	/// Network : 192.168.168.0
169	/// Netmask : 255.255.255.0
170	/// Cidr : 24
171	/// Start : 192.168.168.1
172	/// End : 192.168.168.254
173	/// Broadcast : 192.168.168.255.
174	/// </summary>
175	/// <param name="tryParse">Whether to throw exception or not during conversion.</param>
176	/// <param name="ipaddress">An ip address to convert.</param>
177	/// <param name="netmask">A netmask to convert (255.255.255.0).</param>
178	/// <param name="ipnetwork">The resulting IPNetwork.</param>
179	private static bool InternalParse(bool tryParse, IPAddress ipaddress, IPAddress netmask, out IPNetwork2 ipnetwork)
180	{	4,001,085✔
181	if (ipaddress == null)	4,001,085✔
182	{	4✔
183	if (!tryParse)	4✔
184	{	2✔
185	throw new ArgumentNullException(nameof(ipaddress));	2✔
186	}
187
188	ipnetwork = null;	2✔
189	return false;	2✔
190	}
191
192	if (netmask == null)	4,001,081✔
193	{	4✔
194	if (!tryParse)	4✔
195	{	2✔
196	throw new ArgumentNullException(nameof(netmask));	2✔
197	}
198
199	ipnetwork = null;	2✔
200	return false;	2✔
201	}
202
203	var uintIpAddress = ToBigInteger(ipaddress);	4,001,077✔
204	bool parsed = TryToCidr(netmask, out byte cidr2);	4,001,077✔
205	if (!parsed)	4,001,077✔
206	{	4✔
207	if (!tryParse)	4✔
208	{	2✔
209	throw new ArgumentException("netmask");	2✔
210	}
211
212	ipnetwork = null;	2✔
213	return false;	2✔
214	}
215
216	var ipnet = new IPNetwork2(uintIpAddress, ipaddress.AddressFamily, cidr2);	4,001,073✔
217	ipnetwork = ipnet;	4,001,073✔
218	return true;	4,001,073✔
219	}	4,001,079✔
220
221	/// <summary>
222	/// 192.168.168.100/24
223	///
224	/// Network : 192.168.168.0
225	/// Netmask : 255.255.255.0
226	/// Cidr : 24
227	/// Start : 192.168.168.1
228	/// End : 192.168.168.254
229	/// Broadcast : 192.168.168.255.
230	/// </summary>
231	/// <param name="tryParse">Whether to throw exception or not during conversion.</param>
232	/// <param name="ipaddress">A string containing an ip address to convert.</param>
233	/// <param name="cidr">A byte representing the CIDR to be used in conversion (/24).</param>
234	/// <param name="ipnetwork">The resulting IPNetwork.</param>
235	private static bool InternalParse(bool tryParse, string ipaddress, byte cidr, out IPNetwork2 ipnetwork)
236	{	4,001,061✔
237	if (string.IsNullOrEmpty(ipaddress))	4,001,061✔
238	{	6✔
239	if (!tryParse)	6✔
240	{	2✔
241	throw new ArgumentNullException(nameof(ipaddress));	2✔
242	}
243
244	ipnetwork = null;	4✔
245	return false;	4✔
246	}
247
248	bool ipaddressParsed = IPAddress.TryParse(ipaddress, out IPAddress ip);	4,001,055✔
249	if (!ipaddressParsed)	4,001,055✔
250	{	37✔
251	if (!tryParse)	37✔
252	{	1✔
253	throw new ArgumentException("ipaddress");	1✔
254	}
255
256	ipnetwork = null;	36✔
257	return false;	36✔
258	}
259
260	bool parsedNetmask = TryToNetmask(cidr, ip.AddressFamily, out IPAddress mask);	4,001,018✔
261	if (!parsedNetmask)	4,001,018✔
262	{	3✔
263	if (!tryParse)	3✔
264	{	1✔
265	throw new ArgumentException("cidr");	1✔
266	}
267
268	ipnetwork = null;	2✔
269	return false;	2✔
270	}
271
272	bool parsed = InternalParse(tryParse, ip, mask, out ipnetwork);	4,001,015✔
273	return parsed;	4,001,015✔
274	}	4,001,057✔
275	}

lduchosal / ipnetwork / 809

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