public void SendTest(string macAddress, int port, int count, int interval)
        {
            // ARRANGE
            var expected = count == 0 ? 0 : MagicPacketTests.GetNumberOfNetworkInterfaces();

            // ACT: Send Magic Packet
            var sent = (port < 0 && count < 0 && interval < 0) ?
                       MagicPacket.Send(macAddress) :
                       MagicPacket.Send(macAddress, port, count, interval);

            // OUTPUT
            for (int i = 0; i < sent?.Length; i++)
            {
                Debug.WriteLine($"Source IP Address[{i}] = {sent[i]}");
            }

            // ASSERT
            Assert.AreEqual(expected, sent.Length);
        }
        public void SendSyncTest(bool async)
        {
            // ARRANGE
            var this_MethodName = $"{nameof(MagicPacketTests)}.{nameof(MagicPacketTests.SendSyncTest)}";
            var act_MethodName  = async ?
                                  $"{nameof(MagicPacketTests)}.{nameof(MagicPacketTests.SendSyncTestAsync)}" :
                                  $"{nameof(MagicPacket)}.{nameof(MagicPacket.Send)}";

            var macAddress = "01:23:45:AB:CD:EF";
            var port       = 9;
            var count      = 2;
            var interval   = 1000;
            var error      = 100;

            var expected_count    = MagicPacketTests.GetNumberOfNetworkInterfaces();
            var expected_timespan = TimeSpan.FromMilliseconds(interval * (count - 1) * MagicPacketTests.GetNumberOfNetworkInterfaces());

            string[]        sent = null;
            Task <string[]> task = null;


            // OUTPUT: START
            Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {this_MethodName}: START");

            // OUTPUT: Before Call
            Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {this_MethodName}() --> {act_MethodName}()");
            Console.WriteLine();


            // GET Start Time
            var start_time = DateTime.Now;

            // ACT
            if (!async)
            {
                // NOT Async
                sent = MagicPacket.Send(macAddress, port, count, interval);
            }
            else
            {
                // Async
                task = async ? SendSyncTestAsync(macAddress, port, count, interval) : null;
            }

            // GET Timespan
            var time = DateTime.Now - start_time;


            // OUTPUT: Returned
            Console.WriteLine();
            Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {this_MethodName}() <-- {act_MethodName}()");


            // Wait for complete (Async)
            if (async)
            {
                // OUTPUT: Before Wait for Complete
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {this_MethodName}: Wait for Complete {act_MethodName}()");
                Console.WriteLine("-----");
                Console.WriteLine();

                // Wait for complete (Async)
                task.Wait();

                // OUTPUT: After Wait for Complete
                Console.WriteLine();
                Console.WriteLine("-----");
                Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {this_MethodName}: {act_MethodName}() is completed.");
            }


            // OUTPUT: END (before Assertion)
            Console.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] {this_MethodName}: END (Count = {expected_count}, Timespan = {time.TotalMilliseconds})");


            // ASSERT (Count)
            Assert.AreEqual(expected_count, !async ? sent.Length : task.Result.Length);

            // ASSERT (Timespan)
            if (!async)
            {
                // NOT Async
                Assert.IsTrue((time > (expected_timespan - TimeSpan.FromMilliseconds(error))) && (time < (expected_timespan + TimeSpan.FromMilliseconds(error))));
            }
            else
            {
                // Async
                Assert.IsTrue(time < TimeSpan.FromMilliseconds(error));
            }
        }