Example #1
0
        public void ChannelEventReceived_ArmRecognized_TriggersArmRecognizedEvent()
        {
            // Setup
            var routeEventArgs = new RouteMyoEventArgs(
                new IntPtr(123),
                new IntPtr(789),
                MyoEventType.ArmRecognized,
                DateTime.UtcNow);

            var channelListener = new Mock <IChannelListener>(MockBehavior.Strict);

            var myoDeviceDriver = new Mock <IMyoDeviceDriver>(MockBehavior.Strict);

            myoDeviceDriver
            .SetupGet(x => x.Handle)
            .Returns(new IntPtr(123));
            myoDeviceDriver
            .Setup(x => x.GetArm(routeEventArgs.Event))
            .Returns(Arm.Left);
            myoDeviceDriver
            .Setup(x => x.GetEventDirectionX(routeEventArgs.Event))
            .Returns(XDirection.TowardElbow);

            var myo = Myo.Create(
                channelListener.Object,
                myoDeviceDriver.Object);

            ArmRecognizedEventArgs actualEventArgs = null;
            object actualSender = null;

            myo.ArmRecognized += (sender, args) =>
            {
                actualSender    = sender;
                actualEventArgs = args;
            };

            // Execute
            channelListener.Raise(
                x => x.EventReceived += null,
                routeEventArgs);

            // Assert
            Assert.Equal(myo, actualSender);
            Assert.Equal(myo, actualEventArgs.Myo);
            Assert.Equal(routeEventArgs.Timestamp, actualEventArgs.Timestamp);
            Assert.Equal(Arm.Left, actualEventArgs.Arm);
            Assert.Equal(XDirection.TowardElbow, actualEventArgs.XDirection);

            myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
            myoDeviceDriver.Verify(x => x.GetArm(routeEventArgs.Event), Times.Once);
            myoDeviceDriver.Verify(x => x.GetEventDirectionX(routeEventArgs.Event), Times.Once);
        }
        public void GetArm_ValidState_EqualsConstructorParameter()
        {
            // Setup
            var arm = Arm.Left;

            var args = new ArmRecognizedEventArgs(
                new Mock <IMyo>().Object,
                DateTime.UtcNow,
                arm,
                XDirection.Unknown);

            // Execute
            var result = args.Arm;

            // Assert
            Assert.Equal(arm, result);
        }
        public void GetMyo_ValidState_EqualsConstructorParameter()
        {
            // Setup
            var myo = new Mock <IMyo>();

            var args = new ArmRecognizedEventArgs(
                myo.Object,
                DateTime.UtcNow,
                Arm.Unknown,
                XDirection.Unknown);

            // Execute
            var result = args.Myo;

            // Assert
            Assert.Equal(myo.Object, result);
        }
        public void GetTimestamp_ValidState_EqualsConstructorParameter()
        {
            // Setup
            var timestamp = DateTime.UtcNow;

            var args = new ArmRecognizedEventArgs(
                new Mock <IMyo>().Object,
                timestamp,
                Arm.Unknown,
                XDirection.Unknown);

            // Execute
            var result = args.Timestamp;

            // Assert
            Assert.Equal(timestamp, result);
        }
        public void GetXDirection_ValidState_EqualsConstructorParameter()
        {
            // Setup
            var directionX = XDirection.TowardElbow;

            var args = new ArmRecognizedEventArgs(
                new Mock <IMyo>().Object,
                DateTime.UtcNow,
                Arm.Unknown,
                directionX);

            // Execute
            var result = args.XDirection;

            // Assert
            Assert.Equal(directionX, result);
        }