Esempio n. 1
0
        public void GetEtwEventsTest()
        {
            TestHelpers.MockHttpResponder.AddMockResponse(DevicePortal.RealtimeEtwSessionApi, HttpMethods.WebSocket);

            ManualResetEvent etwEventsReceived = new ManualResetEvent(false);
            EtwEvents        etwEvents         = null;

            WindowsDevicePortal.WebSocketMessageReceivedEventHandler <EtwEvents> etwEventsReceivedHandler =
                delegate(DevicePortal sender, WebSocketMessageReceivedEventArgs <EtwEvents> args)
            {
                if (args.Message != null)
                {
                    etwEvents = args.Message;
                    etwEventsReceived.Set();
                }
            };

            TestHelpers.Portal.RealtimeEventsMessageReceived += etwEventsReceivedHandler;

            Task startListeningForEtwEventsTask = TestHelpers.Portal.StartListeningForEtwEventsAsync();

            startListeningForEtwEventsTask.Wait();
            Assert.AreEqual(TaskStatus.RanToCompletion, startListeningForEtwEventsTask.Status);

            etwEventsReceived.WaitOne();

            Task stopListeningForEtwEventsTask = TestHelpers.Portal.StopListeningForEtwEventsAsync();

            stopListeningForEtwEventsTask.Wait();
            Assert.AreEqual(TaskStatus.RanToCompletion, stopListeningForEtwEventsTask.Status);

            TestHelpers.Portal.RealtimeEventsMessageReceived -= etwEventsReceivedHandler;

            ValidateEtwEvents(etwEvents);
        }
Esempio n. 2
0
        public void GetSystemPerfWebSocketTest_XboxOne_1608()
        {
            TestHelpers.MockHttpResponder.AddMockResponse(DevicePortal.SystemPerfApi, this.PlatformType, this.FriendlyOperatingSystemVersion, HttpMethods.WebSocket);

            ManualResetEvent             systemPerfReceived = new ManualResetEvent(false);
            SystemPerformanceInformation systemPerfInfo     = null;

            WindowsDevicePortal.WebSocketMessageReceivedEventHandler <SystemPerformanceInformation> systemPerfReceivedHandler = delegate(DevicePortal sender,
                                                                                                                                         WebSocketMessageReceivedEventArgs <SystemPerformanceInformation> args)
            {
                if (args.Message != null)
                {
                    systemPerfInfo = args.Message;
                    systemPerfReceived.Set();
                }
            };

            TestHelpers.Portal.SystemPerfMessageReceived += systemPerfReceivedHandler;

            Task startListeningForSystemPerfTask = TestHelpers.Portal.StartListeningForSystemPerfAsync();

            startListeningForSystemPerfTask.Wait();
            Assert.AreEqual(TaskStatus.RanToCompletion, startListeningForSystemPerfTask.Status);

            systemPerfReceived.WaitOne();

            Task stopListeningForSystemPerf = TestHelpers.Portal.StopListeningForSystemPerfAsync();

            stopListeningForSystemPerf.Wait();
            Assert.AreEqual(TaskStatus.RanToCompletion, stopListeningForSystemPerf.Status);

            TestHelpers.Portal.SystemPerfMessageReceived -= systemPerfReceivedHandler;

            ValidateSystemPerm(systemPerfInfo);
        }
Esempio n. 3
0
        public void GetRunningProcessesWebSocketTest_XboxOne_1608()
        {
            TestHelpers.MockHttpResponder.AddMockResponse(DevicePortal.RunningProcessApi, this.PlatformType, this.FriendlyOperatingSystemVersion, HttpMethods.WebSocket);

            ManualResetEvent runningProcessesReceived = new ManualResetEvent(false);
            RunningProcesses runningProcesses         = null;

            WindowsDevicePortal.WebSocketMessageReceivedEventHandler <RunningProcesses> runningProcessesReceivedHandler = delegate(DevicePortal sender,
                                                                                                                                   WebSocketMessageReceivedEventArgs <RunningProcesses> args)
            {
                if (args.Message != null)
                {
                    runningProcesses = args.Message;
                    runningProcessesReceived.Set();
                }
            };

            TestHelpers.Portal.RunningProcessesMessageReceived += runningProcessesReceivedHandler;

            Task startListeningForProcessesTask = TestHelpers.Portal.StartListeningForRunningProcessesAsync();

            startListeningForProcessesTask.Wait();
            Assert.AreEqual(TaskStatus.RanToCompletion, startListeningForProcessesTask.Status);

            runningProcessesReceived.WaitOne();

            Task stopListeningForProcessesTask = TestHelpers.Portal.StopListeningForRunningProcessesAsync();

            stopListeningForProcessesTask.Wait();
            Assert.AreEqual(TaskStatus.RanToCompletion, stopListeningForProcessesTask.Status);

            TestHelpers.Portal.RunningProcessesMessageReceived -= runningProcessesReceivedHandler;

            ValidateRunningProcessesAsync(runningProcesses);
        }