Esempio n. 1
0
        public void Start_WhenTestMessageSent_ThenWatchedDeviceIsNotObserved()
        {
            // ARRANGE
            IUsbDeviceNotification deviceArrived = null;
            var testScheduler             = new TestScheduler();
            var mockedHandle              = new Mock <IHandle>();
            var mockedProcessHandleResult = new Mock <IProcessHandleResult>();
            var guid        = Guid.NewGuid();
            var testMessage = new Message {
                Msg = 1
            };
            var usbDeviceWatcher = SetupTestDeviceWatcherWithHandleCreated(
                testScheduler,
                mockedHandle,
                guid,
                testMessage);

            mockedHandle.Setup(x => x.ProcessFor(usbDeviceWatcher)).Returns(mockedProcessHandleResult.Object);

            // ACT
            usbDeviceWatcher.AllDeviceNotifications().Subscribe(next => deviceArrived = next);
            testScheduler.Start();
            usbDeviceWatcher.SimulateMessage(testMessage);

            // ASSERT
            Assert.Null(deviceArrived);
        }
Esempio n. 2
0
        public void Start_WhenObserver_ThenThreadIdShouldBeDifferentToSubscriptionThread()
        {
            // ARRANGE
            IUsbDeviceNotification deviceArrived = null;
            var testScheduler             = new TestScheduler();
            var mockedHandle              = new Mock <IHandle>();
            var mockedProcessHandleResult = new Mock <IProcessHandleResult>();
            var guid = Guid.NewGuid();
            var deviceChangeMessage = new Message {
                Msg = 0x219
            };
            var usbDeviceWatcher     = SetupTestDeviceWatcherWithHandleCreated(testScheduler, mockedHandle, guid, deviceChangeMessage);
            var currentThreadId      = Thread.CurrentThread.ManagedThreadId;
            var observerdThreadId    = -1;
            var manualResetEventSlim = new ManualResetEventSlim(false);

            mockedHandle.Setup(x => x.ProcessFor(usbDeviceWatcher)).Returns(mockedProcessHandleResult.Object);

            // ACT
            usbDeviceWatcher.AllDeviceNotifications().Subscribe(next =>
            {
                observerdThreadId = Thread.CurrentThread.ManagedThreadId;
                deviceArrived     = next;
                manualResetEventSlim.Set();
            });
            testScheduler.Start();
            usbDeviceWatcher.SimulateMessage(deviceChangeMessage);
            manualResetEventSlim.Wait();

            // ASSERT
            Assert.NotEqual(currentThreadId, observerdThreadId);
            Assert.NotNull(deviceArrived);
        }
Esempio n. 3
0
        public void Start_WhenDeviceChangedMessageSentAndExceptionOccurs_ThenDeviceIsNotObserved()
        {
            // ARRANGE
            IUsbDeviceNotification deviceArrived = null;
            var testScheduler             = new TestScheduler();
            var mockedHandle              = new Mock <IHandle>();
            var mockedProcessHandleResult = new Mock <IProcessHandleResult>();
            var guid    = Guid.NewGuid();
            var message = new Message {
                Msg = 0x219
            };
            const bool mockedMarshalWrapperThrowsException = true;
            var        usbDeviceWatcher     = SetupTestDeviceWatcherWithHandleCreated(testScheduler, mockedHandle, guid, message, null, mockedMarshalWrapperThrowsException);
            var        manualResetEventSlim = new ManualResetEventSlim(false);

            mockedHandle.Setup(x => x.ProcessFor(usbDeviceWatcher)).Returns(mockedProcessHandleResult.Object);

            // ACT
            usbDeviceWatcher.AllDeviceNotifications()
            .Subscribe(
                next =>
            {
                deviceArrived = next;
                manualResetEventSlim.Set();
            },
                error => manualResetEventSlim.Set());
            testScheduler.Start();
            usbDeviceWatcher.SimulateMessage(message);
            manualResetEventSlim.Wait();

            // ASSERT
            Assert.Null(deviceArrived);
        }
Esempio n. 4
0
        public void StartAndAttachedDevices_WhenStartDisposed_ThenAttachedDevicesStillReceivesNotification()
        {
            // ARRANGE
            var manualResetEventSlim      = new ManualResetEventSlim(false);
            var testScheduler             = new TestScheduler();
            var mockedHandle              = new Mock <IHandle>();
            var mockedProcessHandleResult = new Mock <IProcessHandleResult>();
            var guid    = Guid.NewGuid();
            var message = new Message {
                Msg = 0x219, WParam = new IntPtr(0x8000)
            };
            var usbDeviceWatcher = SetupTestDeviceWatcherWithHandleCreated(testScheduler, mockedHandle, guid, message);
            IUsbDeviceNotification nextObservedFromStart           = null;
            IUsbDeviceNotification nextObservedFromAttachedDevices = null;

            mockedHandle.Setup(x => x.ProcessFor(usbDeviceWatcher))
            .Returns(mockedProcessHandleResult.Object)
            .Verifiable();

            // ACT
            var disposable = usbDeviceWatcher.AllDeviceNotifications().Subscribe(next =>
            {
                nextObservedFromStart = next;
            });

            disposable.Dispose();
            usbDeviceWatcher.ArrivedDeviceNotificationsOnly().Subscribe(next =>
            {
                nextObservedFromAttachedDevices = next;
                manualResetEventSlim.Set();
            });
            testScheduler.Start();

            // ASSERT
            manualResetEventSlim.Wait();
            Assert.Null(nextObservedFromStart);
            Assert.NotNull(nextObservedFromAttachedDevices);
        }