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/ConsoleApplication/TextFormatter.cs

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

namespace System.Net;

using System.Collections.Generic;
using System.IO;
using System.Numerics;

/// <summary>
/// Renders action results as human-readable text.
/// </summary>
public class TextFormatter : IFormatter
{
    private readonly TextWriter _writer;

    /// <summary>
    /// Initializes a new instance of the <see cref="TextFormatter"/> class.
    /// </summary>
    public TextFormatter(TextWriter writer)
    {
        _writer = writer;
    }

    /// <inheritdoc/>
    public void Write(ActionOutput output, ProgramContext ac)
    {
        output.WriteTo(this, ac);
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.Networks output, ProgramContext ac)
    {
        WriteNetworkList(output.Items, ac);
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.NetworkGroups output, ProgramContext ac)
    {
        for (int i = 0; i < output.Groups.Count; i++)
        {
            var group = output.Groups[i];
            if (group.Count == 0)
            {
                _writer.WriteLine("Unable to subnet ipnetwork {0} into cidr {1}", output.InputNetworks[i], output.SubnetCidr);
            }
            else
            {
                WriteNetworkList(group, ac);
            }

            WriteSeparator(output.Groups.Count, i + 1);
        }
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.SubtractResults output, ProgramContext ac)
    {
        foreach (var ipn in output.Items)
        {
            _writer.WriteLine("{0}", ipn);
        }
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.ContainResults output, ProgramContext ac)
    {
        foreach (var r in output.Items)
        {
            _writer.WriteLine("{0} contains {1} : {2}", r.Network, r.Test, r.Contains);
        }
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.OverlapResults output, ProgramContext ac)
    {
        foreach (var r in output.Items)
        {
            _writer.WriteLine("{0} overlaps {1} : {2}", r.Network, r.Test, r.Overlaps);
        }
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.IpAddresses output, ProgramContext ac)
    {
        foreach (var ipnetwork in output.InputNetworks)
        {
            if (ipnetwork.Cidr < 16)
            {
                Console.Error.WriteLine(
                    "WARNING: listing all IP addresses in {0} ({1} addresses). This may take a very long time.",
                    ipnetwork,
                    ipnetwork.Total);
            }
        }

        foreach (string addr in output.Items)
        {
            _writer.WriteLine("{0}", addr);
        }
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.Error output, ProgramContext ac)
    {
        _writer.WriteLine(output.Message);
    }

    /// <inheritdoc/>
    public void Write(ActionOutput.UsageInfo output, ProgramContext ac)
    {
        if (output.Errors.Count > 0)
        {
            foreach (string error in output.Errors)
            {
                _writer.WriteLine(error);
            }

            return;
        }

        WriteUsageHelp(output);
    }

    private void WriteUsageHelp(ActionOutput.UsageInfo output)
    {
        _writer.WriteLine("Usage: {0}", output.Synopsis);
        _writer.WriteLine("Version: {0}", output.Version);

        foreach (var group in output.OptionGroups)
        {
            _writer.WriteLine();
            _writer.WriteLine(group.Name);

            int maxWidth = ComputeMaxFlagWidth(group.Options);

            foreach (var opt in group.Options)
            {
                string flagPart = opt.ArgName is not null
                    ? $"-{opt.Flag} {opt.ArgName}"
                    : $"-{opt.Flag}";
                _writer.WriteLine("\t{0} : {1}", flagPart.PadRight(maxWidth), opt.Description);
                if (opt.Example is not null)
                {
                    _writer.WriteLine("\t{0}   {1}", new string(' ', maxWidth), opt.Example);
                }
            }
        }

        _writer.WriteLine();
        _writer.WriteLine("networks  : {0} ", output.NetworksDescription);
        _writer.WriteLine("            ({0} )", string.Join(" ", output.NetworksExamples));
    }

    private static int ComputeMaxFlagWidth(List<UsageOption> options)
    {
        int maxWidth = 0;
        foreach (var opt in options)
        {
            int width = 1 + opt.Flag.Length;
            if (opt.ArgName is not null)
            {
                width += 1 + opt.ArgName.Length;
            }

            if (width > maxWidth)
            {
                maxWidth = width;
            }
        }

        return maxWidth;
    }

    private void WriteNetworkList(List<IPNetwork2> networks, ProgramContext ac)
    {
        for (int i = 0; i < networks.Count; i++)
        {
            WriteNetwork(networks[i], ac);
            WriteSeparator(networks.Count, i + 1);
        }
    }

    private void WriteNetwork(IPNetwork2 ipn, ProgramContext ac)
    {
        if (ac.IPNetwork) { _writer.WriteLine("IPNetwork   : {0}", ipn); }
        if (ac.Network) { _writer.WriteLine("Network     : {0}", ipn.Network); }
        if (ac.Netmask) { _writer.WriteLine("Netmask     : {0}", ipn.Netmask); }
        if (ac.Cidr) { _writer.WriteLine("Cidr        : {0}", ipn.Cidr); }
        if (ac.Broadcast) { _writer.WriteLine("Broadcast   : {0}", ipn.Broadcast); }
        if (ac.FirstUsable) { _writer.WriteLine("FirstUsable : {0}", ipn.FirstUsable); }
        if (ac.LastUsable) { _writer.WriteLine("LastUsable  : {0}", ipn.LastUsable); }
        if (ac.Usable) { _writer.WriteLine("Usable      : {0}", ipn.Usable); }
        if (ac.Total) { _writer.WriteLine("Total       : {0}", ipn.Total); }
    }

    private void WriteSeparator(BigInteger max, BigInteger index)
    {
        if (max > 1 && index != max)
        {
            _writer.WriteLine("--");
        }
    }
}

1	// <copyright file="TextFormatter.cs" company="IPNetwork">
2	// Copyright (c) IPNetwork. All rights reserved.
3	// </copyright>
4
5	namespace System.Net;
6
7	using System.Collections.Generic;
8	using System.IO;
9	using System.Numerics;
10
11	/// <summary>
12	/// Renders action results as human-readable text.
13	/// </summary>
14	public class TextFormatter : IFormatter
15	{
16	private readonly TextWriter _writer;
17
18	/// <summary>
19	/// Initializes a new instance of the <see cref="TextFormatter"/> class.
20	/// </summary>
21	public TextFormatter(TextWriter writer)	×
22	{	×
23	_writer = writer;	×
24	}	×
25
26	/// <inheritdoc/>
27	public void Write(ActionOutput output, ProgramContext ac)
28	{	×
29	output.WriteTo(this, ac);	×
30	}	×
31
32	/// <inheritdoc/>
33	public void Write(ActionOutput.Networks output, ProgramContext ac)
34	{	×
35	WriteNetworkList(output.Items, ac);	×
36	}	×
37
38	/// <inheritdoc/>
39	public void Write(ActionOutput.NetworkGroups output, ProgramContext ac)
40	{	×
41	for (int i = 0; i < output.Groups.Count; i++)	×
42	{	×
43	var group = output.Groups[i];	×
44	if (group.Count == 0)	×
45	{	×
46	_writer.WriteLine("Unable to subnet ipnetwork {0} into cidr {1}", output.InputNetworks[i], output.SubnetCidr);	×
47	}	×
48	else
49	{	×
50	WriteNetworkList(group, ac);	×
51	}	×
52
53	WriteSeparator(output.Groups.Count, i + 1);	×
54	}	×
55	}	×
56
57	/// <inheritdoc/>
58	public void Write(ActionOutput.SubtractResults output, ProgramContext ac)
59	{	×
60	foreach (var ipn in output.Items)	×
61	{	×
62	_writer.WriteLine("{0}", ipn);	×
63	}	×
64	}	×
65
66	/// <inheritdoc/>
67	public void Write(ActionOutput.ContainResults output, ProgramContext ac)
68	{	×
69	foreach (var r in output.Items)	×
70	{	×
71	_writer.WriteLine("{0} contains {1} : {2}", r.Network, r.Test, r.Contains);	×
72	}	×
73	}	×
74
75	/// <inheritdoc/>
76	public void Write(ActionOutput.OverlapResults output, ProgramContext ac)
77	{	×
78	foreach (var r in output.Items)	×
79	{	×
80	_writer.WriteLine("{0} overlaps {1} : {2}", r.Network, r.Test, r.Overlaps);	×
81	}	×
82	}	×
83
84	/// <inheritdoc/>
85	public void Write(ActionOutput.IpAddresses output, ProgramContext ac)
86	{	×
87	foreach (var ipnetwork in output.InputNetworks)	×
88	{	×
89	if (ipnetwork.Cidr < 16)	×
90	{	×
91	Console.Error.WriteLine(	×
92	"WARNING: listing all IP addresses in {0} ({1} addresses). This may take a very long time.",	×
93	ipnetwork,	×
94	ipnetwork.Total);	×
95	}	×
96	}	×
97
98	foreach (string addr in output.Items)	×
99	{	×
100	_writer.WriteLine("{0}", addr);	×
101	}	×
102	}	×
103
104	/// <inheritdoc/>
105	public void Write(ActionOutput.Error output, ProgramContext ac)
106	{	×
107	_writer.WriteLine(output.Message);	×
108	}	×
109
110	/// <inheritdoc/>
111	public void Write(ActionOutput.UsageInfo output, ProgramContext ac)
112	{	×
113	if (output.Errors.Count > 0)	×
114	{	×
115	foreach (string error in output.Errors)	×
116	{	×
117	_writer.WriteLine(error);	×
118	}	×
119
120	return;	×
121	}
122
123	WriteUsageHelp(output);	×
124	}	×
125
126	private void WriteUsageHelp(ActionOutput.UsageInfo output)
127	{	×
128	_writer.WriteLine("Usage: {0}", output.Synopsis);	×
129	_writer.WriteLine("Version: {0}", output.Version);	×
130
131	foreach (var group in output.OptionGroups)	×
132	{	×
133	_writer.WriteLine();	×
134	_writer.WriteLine(group.Name);	×
135
136	int maxWidth = ComputeMaxFlagWidth(group.Options);	×
137
138	foreach (var opt in group.Options)	×
139	{	×
140	string flagPart = opt.ArgName is not null	×
141	? $"-{opt.Flag} {opt.ArgName}"	×
142	: $"-{opt.Flag}";	×
143	_writer.WriteLine("\t{0} : {1}", flagPart.PadRight(maxWidth), opt.Description);	×
144	if (opt.Example is not null)	×
145	{	×
146	_writer.WriteLine("\t{0} {1}", new string(' ', maxWidth), opt.Example);	×
147	}	×
148	}	×
149	}	×
150
151	_writer.WriteLine();	×
152	_writer.WriteLine("networks : {0} ", output.NetworksDescription);	×
153	_writer.WriteLine(" ({0} )", string.Join(" ", output.NetworksExamples));	×
154	}	×
155
156	private static int ComputeMaxFlagWidth(List<UsageOption> options)
157	{	×
158	int maxWidth = 0;	×
159	foreach (var opt in options)	×
160	{	×
161	int width = 1 + opt.Flag.Length;	×
162	if (opt.ArgName is not null)	×
163	{	×
164	width += 1 + opt.ArgName.Length;	×
165	}	×
166
167	if (width > maxWidth)	×
168	{	×
169	maxWidth = width;	×
170	}	×
171	}	×
172
173	return maxWidth;	×
174	}	×
175
176	private void WriteNetworkList(List<IPNetwork2> networks, ProgramContext ac)
177	{	×
178	for (int i = 0; i < networks.Count; i++)	×
179	{	×
180	WriteNetwork(networks[i], ac);	×
181	WriteSeparator(networks.Count, i + 1);	×
182	}	×
183	}	×
184
185	private void WriteNetwork(IPNetwork2 ipn, ProgramContext ac)
186	{	×
187	if (ac.IPNetwork) { _writer.WriteLine("IPNetwork : {0}", ipn); }	×
188	if (ac.Network) { _writer.WriteLine("Network : {0}", ipn.Network); }	×
189	if (ac.Netmask) { _writer.WriteLine("Netmask : {0}", ipn.Netmask); }	×
190	if (ac.Cidr) { _writer.WriteLine("Cidr : {0}", ipn.Cidr); }	×
191	if (ac.Broadcast) { _writer.WriteLine("Broadcast : {0}", ipn.Broadcast); }	×
192	if (ac.FirstUsable) { _writer.WriteLine("FirstUsable : {0}", ipn.FirstUsable); }	×
193	if (ac.LastUsable) { _writer.WriteLine("LastUsable : {0}", ipn.LastUsable); }	×
194	if (ac.Usable) { _writer.WriteLine("Usable : {0}", ipn.Usable); }	×
195	if (ac.Total) { _writer.WriteLine("Total : {0}", ipn.Total); }	×
196	}	×
197
198	private void WriteSeparator(BigInteger max, BigInteger index)
199	{	×
200	if (max > 1 && index != max)	×
201	{	×
202	_writer.WriteLine("--");	×
203	}	×
204	}	×
205	}

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