public async void StartTest(TestMethod test)
        {
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
            {
                _currentTest = new TestDescription {
                    Name = test.Name
                };
                _currentGroup.Add(_currentTest);

                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    lstTests.ScrollIntoView(_currentTest);
                });
            });
        }
Пример #2
0
        public void StartTest(TestMethod test)
        {
            Dispatcher.BeginInvoke(() =>
            {
                TestDescription testDescription = new TestDescription {
                    Name = test.Name
                };
                _currentTest = testDescription;
                _currentGroup.Add(_currentTest);

                Dispatcher.BeginInvoke(() =>
                {
                    unitTests.ScrollTo(testDescription);
                });
            });
        }
Пример #3
0
        public async void StartTest(TestMethod test)
        {
            await Dispatcher.InvokeAsync(async() =>
            {
                _currentTest = new TestDescription {
                    Name = test.Name
                };
                _currentGroup.Add(_currentTest);
                _tests.Add(_currentTest);

                await Dispatcher.InvokeAsync(() =>
                {
                    lstTests.ScrollIntoView(_currentTest);
                });
            });
        }
Пример #4
0
 public void EndTest(TestMethod method)
 {
     Dispatcher.BeginInvoke(() =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = SkippedColor;
         }
         else if (!method.Passed)
         {
             _currentTest.Color = FailedColor;
         }
         else
         {
             _currentTest.Color = PassedColor;
         }
         _currentTest = null;
     });
 }
Пример #5
0
 public void EndTest(TestMethod method)
 {
     Dispatcher.BeginInvoke(() =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x66, 0x66, 0x66);
         }
         else if (!method.Passed)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0xFF, 0x00, 0x6E);
         }
         else
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x2A, 0x9E, 0x39);
         }
         _currentTest = null;
     });
 }
 public async void EndTest(TestMethod method)
 {
     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x66, 0x66, 0x66);
         }
         else if (!method.Passed)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0xFF, 0x00, 0x6E);
         }
         else
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x2A, 0x9E, 0x39);
         }
         _currentTest = null;
     });
 }
 public async void EndTest(TestMethod method)
 {
     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = SkippedColor;
         }
         else if (!method.Passed)
         {
             _currentTest.Color = FailedColor;
         }
         else
         {
             _currentTest.Color = PassedColor;
         }
         _currentTest = null;
     });
 }
Пример #8
0
 public async void EndTest(TestMethod method)
 {
     await Dispatcher.InvokeAsync(() =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = SkippedColor;
             ConsoleHelper.WriteLine("Skipped");
         }
         else if (!method.Passed)
         {
             _currentTest.Color = FailedColor;
             ConsoleHelper.WriteLine("Failed: " + method.ErrorInfo);
         }
         else
         {
             _currentTest.Color = PassedColor;
             ConsoleHelper.WriteLine("Passed");
         }
         _currentTest = null;
     });
 }
 public async void EndTest(TestMethod method)
 {
     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x66, 0x66, 0x66);
         }
         else if (!method.Passed)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0xFF, 0x00, 0x6E);
         }
         else
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x2A, 0x9E, 0x39);
         }
         _currentTest = null;
     });
 }
        public async void EndTest(TestMethod test)
        {
            long bytesEnd = this.traffic.GetBytesSent() + this.traffic.GetBytesReceived() - bytesStart;
            this.stopwatch.Stop();
            TimeSpan time = this.stopwatch.Elapsed;

            await Dispatcher.InvokeAsync(() =>
            {
                currentTest.Duration = time;
                currentTest.Bytes = bytesEnd;
                if (test.Excluded)
                {
                    currentTest.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x66, 0x66, 0x66));
                }
                else if (!test.Passed)
                {
                    currentTest.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0xFF, 0x00, 0x6E));
                }
                else
                {
                    currentTest.Brush = new SolidColorBrush(Color.FromArgb(0xFF, 0x2A, 0x9E, 0x39));
                }
                currentTest = null;
            });
        }
        public async void StartTest(TestMethod test)
        {

            this.bytesStart = this.traffic.GetBytesSent() + this.traffic.GetBytesReceived();
            this.stopwatch.Reset();
            this.stopwatch.Start();

            await Dispatcher.InvokeAsync(async () =>
            {
                currentTest = new TestDescription { Name = test.Name };
                currentGroup.Add(currentTest);
                tests.Add(currentTest);

                await Dispatcher.InvokeAsync(() =>
                {
                    lstTests.ScrollIntoView(currentTest);
                });
            });
        }
 public async void EndTest(TestMethod method)
 {
     await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = SkippedColor;
         }
         else if (!method.Passed)
         {
             _currentTest.Color = FailedColor;
         }
         else
         {
             _currentTest.Color = PassedColor;
         }
         _currentTest = null;
     });
 }
        public async void StartTest(TestMethod test)
        {
            await Dispatcher.InvokeAsync(async () =>
            {
                _currentTest = new TestDescription { Name = test.Name };
                _currentGroup.Add(_currentTest);
                _tests.Add(_currentTest);

                await Dispatcher.InvokeAsync(() =>
                {
                    lstTests.ScrollIntoView(_currentTest);
                });
            });
        }
 public void EndTest(TestMethod method)
 {
     Dispatcher.BeginInvoke(() =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = SkippedColor;
         }
         else if (!method.Passed)
         {
             _currentTest.Color = FailedColor;
         }
         else
         {
             _currentTest.Color = PassedColor;
         }
         _currentTest = null;
     });
 }
 public async void EndTest(TestMethod method)
 {
     await Dispatcher.InvokeAsync(() =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = SkippedColor;
             ConsoleHelper.WriteLine("Skipped");
         }
         else if (!method.Passed)
         {
             _currentTest.Color = FailedColor;
             ConsoleHelper.WriteLine("Failed: " + method.ErrorInfo);
         }
         else
         {
             _currentTest.Color = PassedColor;
             ConsoleHelper.WriteLine("Passed");
         }
         _currentTest = null;
     });
 }
        public void StartTest(TestMethod test)
        {
            Dispatcher.BeginInvoke(() =>
            {
                TestDescription testDescription = new TestDescription { Name = test.Name };
                _currentTest = testDescription;
                _currentGroup.Add(_currentTest);

                Dispatcher.BeginInvoke(() =>
                {
                    unitTests.ScrollTo(testDescription);
                });
            });
        }
 public void EndTest(TestMethod method)
 {
     Dispatcher.BeginInvoke(() =>
     {
         if (method.Excluded)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x66, 0x66, 0x66);
         }
         else if (!method.Passed)
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0xFF, 0x00, 0x6E);
         }
         else
         {
             _currentTest.Color = Color.FromArgb(0xFF, 0x2A, 0x9E, 0x39);
         }
         _currentTest = null;
     });
 }
        public async void StartTest(TestMethod test)
        {
            await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
            {
                _currentTest = new TestDescription { Name = test.Name };
                _currentGroup.Add(_currentTest);

                await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
                {
                    lstTests.ScrollIntoView(_currentTest);
                });
            });
        }