refactor

Author: trivalik

PcapDotNet/src/PcapDotNet.Core.Test/LivePacketDeviceTests.cs

@@ -32,7 +32,7 @@ public LivePacketDeviceTests()
 #endif
 
         [Fact]
-        public void SendAndReceievePacketTest()
+        public void SendAndReceivePacketTest()
         {
             const string SourceMac = "11:22:33:44:55:66";
             const string DestinationMac = "77:88:99:AA:BB:CC";

PcapDotNet/src/PcapDotNet.Core.Test/OfflinePacketDeviceTests.cs

@@ -310,7 +310,7 @@ public void SetSamplingMethodOneEveryNTest()
         public void SetSamplingMethodFirstAfterIntervalTest()
         {
             const int NumPackets = 10;
-            
+
             Packet expectedPacket = _random.NextEthernetPacket(100);
             using (PacketCommunicator communicator = OpenOfflineDevice(NumPackets, expectedPacket, TimeSpan.FromSeconds(1)))
             {
@@ -338,7 +338,7 @@ public void DumpToBadFileTest()
         {
             Assert.Throws<InvalidOperationException>(() => OpenOfflineDevice(10, _random.NextEthernetPacket(100), TimeSpan.Zero, "??"));
         }
-        
+
         [Fact]
         public void EmptyNameTest()
         {
@@ -404,7 +404,6 @@ public void ReadUnicodeFilenameTest()
             Assert.True(File.Exists(ReadUnicodeFilename), string.Format("File {0} doesn't exist", ReadUnicodeFilename));
         }
 
-
         [Fact]
         public void ReadNonExistingUnicodeFilenameTest()
         {

PcapDotNet/src/PcapDotNet.Core.Test/WiresharkCompareTests.cs

@@ -452,7 +452,7 @@ private static void ComparePacketsToWireshark(IEnumerable<Packet> packets)
                     {
                     // Wireshark's preferences file is %APPDATA%\Wireshark\preferences
                         FileName = Path.Combine(wiresharkDirectory, WiresharkTshark),
-                        Arguments = "-o ip.check_checksum:TRUE " + 
+                        Arguments = "-o ip.check_checksum:TRUE " +
                                     "-o ipv6.use_geoip:FALSE " +
                                     "-o udp.check_checksum:TRUE " +
                                     "-o tcp.relative_sequence_numbers:FALSE " +

PcapDotNet/src/PcapDotNet.Core/BerkeleyPacketFilter.cs

@@ -72,7 +72,7 @@ public void Dispose()
 
         /// <summary>
         /// Returns if a given filter applies to an offline packet.
-        /// This method is used to apply a filter to a packet that is currently in memory. 
+        /// This method is used to apply a filter to a packet that is currently in memory.
         /// This process does not need to open an adapter; we need just to create the proper filter (by settings parameters like the snapshot length, or the link-layer type) by means of the Pcap.
         /// The current API of libpcap does not allow to receive a packet and to filter the packet after it has been received. However, this can be useful in case you want to filter packets in the application, instead of into the receiving process. This function allows you to do the job.
         /// </summary>

PcapDotNet/src/PcapDotNet.Core/Native/PcapUnixPal.cs

@@ -699,7 +699,7 @@ internal extern static int pcap_getnonblock(
             internal extern static int pcap_minor_version(PcapHandle /* pcap_t* */ p);
 
             /// <summary>
-            /// pcap_activate() is used to activate a packet capture handle to look at packets on the network, with the options that were set on the handle being in effect.  
+            /// pcap_activate() is used to activate a packet capture handle to look at packets on the network, with the options that were set on the handle being in effect.
             /// </summary>
             /// <returns>Returns 0 on success without warnings, a non-zero positive value on success with warnings, and a negative value on error. A non-zero return value indicates what warning or error condition occurred.</returns>
             [DllImport(PCAP_DLL, CallingConvention = CallingConvention.Cdecl)]

PcapDotNet/src/PcapDotNet.Core/PacketCommunicator/PacketCommunicator.cs

@@ -20,7 +20,7 @@ namespace PcapDotNet.Core
     public delegate void HandleStatistics(PacketSampleStatistics statistics);
 
     /// <summary>
-    /// Used to receive and send packets accross the network or to read and write packets to a pcap file.
+    /// Used to receive and send packets across the network or to read and write packets to a pcap file.
     /// </summary>
     public abstract class PacketCommunicator : IDisposable
     {
@@ -34,13 +34,13 @@ protected PacketCommunicator(SocketAddress netmask)
         }
 
         /// <summary>
-        /// Close the files associated with the capture and deallocates resources. 
+        /// Close the files associated with the capture and deallocates resources.
         /// </summary>
         protected virtual void Dispose(bool disposing)
         {
             PcapDescriptor.Dispose();
         }
-        
+
         /// <inheritdoc/>
         public void Dispose()
         {
@@ -110,7 +110,7 @@ public ReadOnlyCollection<PcapDataLink> SupportedDataLinks
         }
 
         /// <summary>
-        /// The dimension of the packet portion (in bytes) that is delivered to the application. 
+        /// The dimension of the packet portion (in bytes) that is delivered to the application.
         /// </summary>
         public int SnapshotLength { get => Interop.Pcap.pcap_snapshot(PcapDescriptor); }
 
@@ -230,12 +230,12 @@ public void SetKernelMinimumBytesToCopy(int size)
 
         /// <summary>
         /// Define a sampling method for packet capture.
-        /// This function allows applying a sampling method to the packet capture process. 
+        /// This function allows applying a sampling method to the packet capture process.
         /// The method will be applied as soon as the capture starts.
         /// </summary>
         /// <remarks>
         /// Warning: Sampling parameters cannot be changed when a capture is active. These parameters must be applied before starting the capture. If they are applied when the capture is in progress, the new settings are ignored.
-        /// Warning: Sampling works only when capturing data on Win32 or reading from a file. It has not been implemented on other platforms. Sampling works on remote machines provided that the probe (i.e. the capturing device) is a Win32 workstation. 
+        /// Warning: Sampling works only when capturing data on Win32 or reading from a file. It has not been implemented on other platforms. Sampling works on remote machines provided that the probe (i.e. the capturing device) is a Win32 workstation.
         /// </remarks>
         /// <param name="method">The sampling method to be applied</param>
         public void SetSamplingMethod(SamplingMethod method)
@@ -290,7 +290,7 @@ public PacketCommunicatorReceiveResult ReceivePacket(out Packet packet)
 
         /// <summary>
         /// Collect a group of packets.
-        /// Used to collect and process packets. 
+        /// Used to collect and process packets.
         /// <seealso cref="ReceivePacket"/>
         /// <seealso cref="ReceivePackets"/>
         /// <seealso cref="Break"/>

PcapDotNet/src/PcapDotNet.Core/PacketCommunicator/SamplingMethod.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace PcapDotNet.Core
 {
@@ -31,7 +31,7 @@ public abstract class SamplingMethod
         public const int PCAP_SAMP_FIRST_AFTER_N_MS = 2;
 
         internal abstract int Method { get; }
-        
+
         internal abstract int Value { get; }
     }
 
@@ -40,7 +40,7 @@ public abstract class SamplingMethod
     /// In other words, if the interval is set to 10 milliseconds, the first packet is returned to the caller; the next returned one will be the first packet that arrives when 10ms have elapsed.
     /// </summary>
     public sealed class SamplingMethodFirstAfterInterval : SamplingMethod
-    {    
+    {
         private readonly int _intervalInMilliseconds;
 
         /// <summary>
@@ -82,7 +82,7 @@ public SamplingMethodFirstAfterInterval(TimeSpan interval)
 
     /// <summary>
     /// No sampling has to be done on the current capture.
-    /// In this case, no sampling algorithms are applied to the current capture. 
+    /// In this case, no sampling algorithms are applied to the current capture.
     /// </summary>
     public sealed class SamplingMethodNone : SamplingMethod
     {

PcapDotNet/src/PcapDotNet.Core/PacketDevice/LivePacketDevice.cs

@@ -22,7 +22,7 @@ public sealed class LivePacketDevice : PacketDevice
         /// </returns>
         /// <exception cref="InvalidOperationException">
         /// Thrown if some errors occurred. 
-        /// An error could be due to several reasons: 
+        /// An error could be due to several reasons:
         ///   <list type="bullet">
         ///     <item>libpcap/WinPcap was not installed on the local/remote host.</item>
         ///     <item>The user does not have enough privileges to list the devices.</item>

PcapDotNet/src/PcapDotNet.Core/PacketDevice/OfflinePacketDevice.cs

@@ -11,7 +11,7 @@ namespace PcapDotNet.Core
     public sealed class OfflinePacketDevice : PacketDevice
     {
         private readonly string _fileName;
- 
+
         /// <summary>
         /// Creates a device object from a pcap file.
         /// The device can opened to read packets from.
@@ -39,7 +39,7 @@ public override string Description
         }
 
         /// <summary>
-        /// Interface flags. Currently the only possible flag is Loopback, that is set if the interface is a loopback interface. 
+        /// Interface flags. Currently the only possible flag is Loopback, that is set if the interface is a loopback interface.
         /// </summary>
         public override DeviceAttributes Attributes
         {
@@ -55,7 +55,7 @@ public override ReadOnlyCollection<DeviceAddress> Addresses
         }
 
         /// <summary>
-        /// Open a generic source in order to capture / send (WinPcap only) traffic. 
+        /// Open a generic source in order to capture / send (WinPcap only) traffic.
         /// </summary>
         /// <param name="snapshotLength">length of the packet that has to be retained. For each packet received by the filter, only the first 'snapshotLength' bytes are stored in the buffer and passed to the user application. For instance, snaplen equal to 100 means that only the first 100 bytes of each packet are stored.</param>
         /// <param name="attributes">Keeps several flags that can be needed for capturing packets.</param>
@@ -65,5 +65,5 @@ public override PacketCommunicator Open(int snapshotLength, PacketDeviceOpenAttr
         {
             return new OfflinePacketCommunicator(_fileName);
         }
-    };
+    }
 }

PcapDotNet/src/PcapDotNet.Core/PacketDevice/PacketDevice.cs

@@ -13,7 +13,7 @@ protected PacketDevice() { }
 #pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
 
         /// <summary>
-        /// This snapshort length value should be sufficient, on most if not all networks, to capture all the data available from the packet.
+        /// This snapshot length value should be sufficient, on most if not all networks, to capture all the data available from the packet.
         /// </summary>
         public const int DefaultSnapshotLength = 65536;
 
@@ -28,7 +28,7 @@ protected PacketDevice() { }
         public abstract string Description { get; }
 
         /// <summary>
-        /// Interface flags. Currently the only possible flag is Loopback, that is set if the interface is a loopback interface. 
+        /// Interface flags. Currently the only possible flag is Loopback, that is set if the interface is a loopback interface.
         /// </summary>
         public abstract DeviceAttributes Attributes { get; }
 
@@ -47,8 +47,8 @@ protected PacketDevice() { }
         public abstract PacketCommunicator Open(int snapshotLength, PacketDeviceOpenAttributes attributes, int readTimeout);
 
         /// <summary>
-        /// Open a generic source in order to capture / send (WinPcap only) traffic. 
-        /// Uses maxmimum snapshotLength (65536), promiscuous mode and 1 second read timeout.
+        /// Open a generic source in order to capture / send (WinPcap only) traffic.
+        /// Uses maximum snapshotLength (65536), promiscuous mode and 1 second read timeout.
         /// </summary>
         public virtual PacketCommunicator Open()
         {