public void ChannelEventReceived_ArmLost_XDirectionOnArmIsUnknown()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.ArmLost,
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));
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
// Execute
channelListener.Raise(
x => x.EventReceived += null,
routeEventArgs);
// Assert
Assert.Equal(XDirection.Unknown, myo.XDirectionOnArm);
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
}
public void ChannelEventReceived_Orientation_TriggersOrientationDataAcquiredEvent()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.Orientation,
DateTime.UtcNow);
var orientation = new QuaternionF(10, 20, 30, 40);
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.GetEventOrientation(routeEventArgs.Event))
.Returns(orientation);
myoDeviceDriver
.Setup(x => x.GetEventAccelerometer(routeEventArgs.Event))
.Returns(new Vector3F());
myoDeviceDriver
.Setup(x => x.GetGyroscope(routeEventArgs.Event))
.Returns(new Vector3F());
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
OrientationDataEventArgs actualEventArgs = null;
object actualSender = null;
myo.OrientationDataAcquired += (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(orientation, actualEventArgs.Orientation);
Assert.InRange(actualEventArgs.Roll, 2.03404385580104d, 2.03404385580106d);
Assert.Equal(double.NaN, actualEventArgs.Pitch);
Assert.InRange(actualEventArgs.Yaw, 2.31898255934001d, 2.31898255934003d);
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
myoDeviceDriver.Verify(x => x.GetEventOrientation(routeEventArgs.Event), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventAccelerometer(routeEventArgs.Event), Times.Once);
myoDeviceDriver.Verify(x => x.GetGyroscope(routeEventArgs.Event), Times.Once);
}
public void ChannelEventReceived_Disconnected_IsConnectedFalse()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.Disconnected,
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));
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
// Execute
channelListener.Raise(
x => x.EventReceived += null,
routeEventArgs);
// Assert
Assert.False(
myo.IsConnected,
"Expecting the Myo to be disconnected.");
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
}
public void EventReceived_Paired_TriggersPairedEvent()
{
// Setup
var channel = new Mock <IChannelListener>();
var deviceListener = DeviceListener.Create(channel.Object);
PairedEventArgs actualEventArgs = null;
deviceListener.Paired += (_, args) => actualEventArgs = args;
var myoHandle = new IntPtr(12345);
var timestamp = DateTime.UtcNow;
var routeEventArgs = new RouteMyoEventArgs(
myoHandle,
new IntPtr(123),
MyoEventType.Paired,
timestamp);
// Execute
channel.Raise(x => x.EventReceived += null, routeEventArgs);
// Assert
Assert.NotNull(actualEventArgs);
Assert.Equal(myoHandle, actualEventArgs.MyoHandle);
Assert.Equal(timestamp, actualEventArgs.Timestamp);
}
public void EventReceived_EmgData_DoesNotTriggerPairedEvent()
{
// Setup
var channel = new Mock <IChannelListener>();
var deviceListener = DeviceListener.Create(channel.Object);
var gotPairedEvent = false;
deviceListener.Paired += (_, __) => gotPairedEvent = true;
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(123),
MyoEventType.Emg,
DateTime.UtcNow);
// Execute
channel.Raise(x => x.EventReceived += null, routeEventArgs);
// Assert
Assert.False(
gotPairedEvent,
"Not expecting to get the paired event.");
}
private void Channel_EventReceived(object sender, RouteMyoEventArgs e)
{
if (e.EventType == MyoEventType.Paired)
{
OnPaired(e.MyoHandle);
}
}
public void ChannelEventReceived_Orientation_TriggersGyroscopeDataAcquiredEvent()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.Orientation,
DateTime.UtcNow);
var gyroscope = new Vector3F(10, 20, 30);
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.GetEventOrientation(routeEventArgs.Event))
.Returns(new QuaternionF());
myoDeviceDriver
.Setup(x => x.GetEventAccelerometer(routeEventArgs.Event))
.Returns(new Vector3F());
myoDeviceDriver
.Setup(x => x.GetGyroscope(routeEventArgs.Event))
.Returns(gyroscope);
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
GyroscopeDataEventArgs actualEventArgs = null;
object actualSender = null;
myo.GyroscopeDataAcquired += (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(gyroscope, actualEventArgs.Gyroscope);;
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
myoDeviceDriver.Verify(x => x.GetEventOrientation(routeEventArgs.Event), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventAccelerometer(routeEventArgs.Event), Times.Once);
myoDeviceDriver.Verify(x => x.GetGyroscope(routeEventArgs.Event), Times.Once);
}
private void Channel_EventReceived(object sender, RouteMyoEventArgs e)
{
// check if this event is for us
if (e.MyoHandle != _handle)
{
return;
}
HandleEvent(e.EventType, e.Timestamp, e.Event);
}
public void ChannelEventReceived_Emg_EmgDataIsSet()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.Emg,
DateTime.UtcNow);
var gyroscope = new Vector3F(10, 20, 30);
var channelListener = new Mock <IChannelListener>(MockBehavior.Strict);
var myoDeviceDriver = new Mock <IMyoDeviceDriver>(MockBehavior.Strict);
myoDeviceDriver
.SetupGet(x => x.Handle)
.Returns(new IntPtr(123));
for (int i = 0; i < 8; i++)
{
myoDeviceDriver
.Setup(x => x.GetEventEmg(routeEventArgs.Event, i))
.Returns((sbyte)(i * 10));
}
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
// Execute
channelListener.Raise(
x => x.EventReceived += null,
routeEventArgs);
// Assert
Assert.Equal(0, myo.EmgData.GetDataForSensor(0));
Assert.Equal(10, myo.EmgData.GetDataForSensor(1));
Assert.Equal(20, myo.EmgData.GetDataForSensor(2));
Assert.Equal(30, myo.EmgData.GetDataForSensor(3));
Assert.Equal(40, myo.EmgData.GetDataForSensor(4));
Assert.Equal(50, myo.EmgData.GetDataForSensor(5));
Assert.Equal(60, myo.EmgData.GetDataForSensor(6));
Assert.Equal(70, myo.EmgData.GetDataForSensor(7));
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 0), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 1), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 2), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 3), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 4), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 5), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 6), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventEmg(routeEventArgs.Event, 7), Times.Once);
}
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);
}
private void Channel_EventReceived(object sender, RouteMyoEventArgs e)
{
switch (e.EventType)
{
case MyoEventType.Paired:
OnPaired(e.MyoHandle, e.Timestamp);
break;
case MyoEventType.Unpaired:
OnUnpaired(e.MyoHandle, e.Timestamp);
break;
}
}
private void Channel_EventReceived(object sender, RouteMyoEventArgs e)
{
Contract.Requires <ArgumentNullException>(sender != null, "sender");
switch (e.EventType)
{
case MyoEventType.Paired:
OnPaired(e.MyoHandle, e.Timestamp);
break;
case MyoEventType.Unpaired:
OnUnpaired(e.MyoHandle, e.Timestamp);
break;
}
}
public void GetMyoHandle_ValidState_EqualsConstructorParameter()
{
// Setup
var myoHandle = new IntPtr(123);
var args = new RouteMyoEventArgs(
myoHandle,
new IntPtr(789),
MyoEventType.Paired,
DateTime.UtcNow);
// Execute
var result = args.MyoHandle;
// Assert
Assert.Equal(myoHandle, result);
}
public void GetTimestamp_ValidState_EqualsConstructorParameter()
{
// Setup
var timestamp = DateTime.UtcNow;
var args = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(123),
MyoEventType.Paired,
timestamp);
// Execute
var result = args.Timestamp;
// Assert
Assert.Equal(timestamp, result);
}
public void GetEventType_ValidState_EqualsConstructorParameter()
{
// Setup
var eventType = MyoEventType.Emg;
var args = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(123),
eventType,
DateTime.UtcNow);
// Execute
var result = args.EventType;
// Assert
Assert.Equal(eventType, result);
}
public void ChannelEventReceived_Rssi_TriggersRssiEvent()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.Rssi,
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.GetEventRssi(routeEventArgs.Event))
.Returns(123);
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
RssiEventArgs actualEventArgs = null;
object actualSender = null;
myo.Rssi += (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(123, actualEventArgs.Rssi);
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
myoDeviceDriver.Verify(x => x.GetEventRssi(routeEventArgs.Event), Times.Once);
}
public void ChannelEventReceived_Orientation_OrientationIsSet()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(789),
MyoEventType.Orientation,
DateTime.UtcNow);
var orientation = new QuaternionF(10, 20, 30, 40);
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.GetEventOrientation(routeEventArgs.Event))
.Returns(orientation);
myoDeviceDriver
.Setup(x => x.GetEventAccelerometer(routeEventArgs.Event))
.Returns(new Vector3F());
myoDeviceDriver
.Setup(x => x.GetGyroscope(routeEventArgs.Event))
.Returns(new Vector3F());
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
// Execute
channelListener.Raise(
x => x.EventReceived += null,
routeEventArgs);
// Assert
Assert.Equal(orientation, myo.Orientation);
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Once);
myoDeviceDriver.Verify(x => x.GetEventOrientation(routeEventArgs.Event), Times.Once);
myoDeviceDriver.Verify(x => x.GetEventAccelerometer(routeEventArgs.Event), Times.Once);
myoDeviceDriver.Verify(x => x.GetGyroscope(routeEventArgs.Event), Times.Once);
}
public void ChannelEventReceived_Disposed_DoesNotTriggerEvent()
{
// Setup
var routeEventArgs = new RouteMyoEventArgs(
new IntPtr(123),
new IntPtr(123),
MyoEventType.Pose,
DateTime.UtcNow);
var channelListener = new Mock <IChannelListener>(MockBehavior.Strict);
var myoDeviceDriver = new Mock <IMyoDeviceDriver>(MockBehavior.Strict);
myoDeviceDriver
.SetupGet(x => x.Handle)
.Returns(routeEventArgs.MyoHandle);
myoDeviceDriver
.Setup(x => x.GetEventPose(routeEventArgs.Event))
.Returns(Pose.Fist);
var myo = Myo.Create(
channelListener.Object,
myoDeviceDriver.Object);
var gotPoseChangedEvent = false;
myo.PoseChanged += (_, __) => gotPoseChangedEvent = true;
myo.Dispose();
// Execute
channelListener.Raise(
x => x.EventReceived += null,
routeEventArgs);
// Assert
Assert.False(
gotPoseChangedEvent,
"Not expecting to get the pose changed event.");
myoDeviceDriver.VerifyGet(x => x.Handle, Times.Never);
}
public void ChannelEventReceived_ArmRecognized_XDirectionOnArmIsTowardElbow()
{
// 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);
// Execute
channelListener.Raise(
x => x.EventReceived += null,
routeEventArgs);
// Assert
Assert.Equal(XDirection.TowardElbow, myo.XDirectionOnArm);
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 ListenerThread_HandleMyoEvent_TriggersEventReceivedEvent()
{
// Setup
var driver = new Mock <IChannelDriver>();
var timestamp = DateTime.UtcNow;
var eventHandle = new IntPtr(123);
var myoHandle = new IntPtr(12345);
driver
.Setup(x => x.InitializeMyoHub(APPLICATION_IDENTIFIER))
.Returns(myoHandle);
driver
.Setup(x => x.Run(myoHandle, It.IsAny <MyoRunHandler>(), It.IsAny <IntPtr>()))
.Callback <IntPtr, MyoRunHandler, IntPtr>((handle, runHandler, userData) =>
{
runHandler(userData, eventHandle);
});
driver
.Setup(x => x.GetEventType(eventHandle))
.Returns(MyoEventType.Emg);
driver
.Setup(x => x.GetMyoForEvent(eventHandle))
.Returns(myoHandle);
driver
.Setup(x => x.GetEventTimestamp(eventHandle))
.Returns(timestamp);
var channel = Channel.Create(driver.Object, APPLICATION_IDENTIFIER);
var trigger = new ManualResetEventSlim();
object actualSender = null;
RouteMyoEventArgs actualEventArgs = null;
channel.EventReceived += (sender, args) =>
{
actualSender = sender;
actualEventArgs = args;
trigger.Set();
};
// Execute
channel.StartListening();
// Assert
try
{
Assert.True(
trigger.Wait(5000),
"The asycnhronous operation did not finish within a reasonable amount of time.");
Assert.Equal(channel, actualSender);
Assert.NotNull(actualEventArgs);
Assert.Equal(myoHandle, actualEventArgs.MyoHandle);
Assert.Equal(eventHandle, actualEventArgs.Event);
Assert.Equal(MyoEventType.Emg, actualEventArgs.EventType);
Assert.Equal(timestamp, actualEventArgs.Timestamp);
driver.Verify(x => x.InitializeMyoHub(APPLICATION_IDENTIFIER), Times.Once);
driver.Verify(x => x.Run(myoHandle, It.IsAny <MyoRunHandler>(), It.IsAny <IntPtr>()), Times.AtLeastOnce());
driver.Verify(x => x.GetEventType(eventHandle), Times.AtLeastOnce());
driver.Verify(x => x.GetMyoForEvent(eventHandle), Times.AtLeastOnce());
driver.Verify(x => x.GetEventTimestamp(eventHandle), Times.AtLeastOnce());
}
finally
{
channel.Dispose();
}
}
