[Fact] public void Add()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_j1 = hg.newJoints();
var dat_j2 = hg.newJoints();
var exp_j = hg.newJoints();
var mock_vh = new Mock <IVectorHelper>();
mock_vh.Setup(m => m.addList(dat_j1.pinky, dat_j2.pinky)).Returns(exp_j.pinky);
mock_vh.Setup(m => m.addList(dat_j1.ring, dat_j2.ring)).Returns(exp_j.ring);
mock_vh.Setup(m => m.addList(dat_j1.middle, dat_j2.middle)).Returns(exp_j.middle);
mock_vh.Setup(m => m.addList(dat_j1.index, dat_j2.index)).Returns(exp_j.index);
mock_vh.Setup(m => m.addList(dat_j1.thumb, dat_j2.thumb)).Returns(exp_j.thumb);
mock_vh.Setup(m => m.add(dat_j1.palm, dat_j2.palm)).Returns(exp_j.palm);
JointsHelper jh = new JointsHelper(mock_vh.Object);
var act_j = jh.add(dat_j1, dat_j2);
mock_vh.Verify(m => m.addList(dat_j1.pinky, dat_j2.pinky), Times.Once());
mock_vh.Verify(m => m.addList(dat_j1.ring, dat_j2.ring), Times.Once());
mock_vh.Verify(m => m.addList(dat_j1.middle, dat_j2.middle), Times.Once());
mock_vh.Verify(m => m.addList(dat_j1.index, dat_j2.index), Times.Once());
mock_vh.Verify(m => m.addList(dat_j1.thumb, dat_j2.thumb), Times.Once());
mock_vh.Verify(m => m.add(dat_j1.palm, dat_j2.palm), Times.Once());
test.jointsEqual(exp_j, act_j);
}
[Fact] public void Range()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
int dat_len = dg.newInt(100);
List <Joints> dat_jL = hg.newJointsList(dat_len);
Joints exp_range = hg.newJoints();
Joints exp_min = hg.newJoints();
Joints exp_max = hg.newJoints();
Mock <IJointsHelper> mock_jh = new Mock <IJointsHelper>();
foreach (var j in dat_jL)
{
mock_jh.Setup(m => m.minMax(It.IsAny <Joints>(), It.IsAny <Joints>(), j)).Returns((exp_min, exp_max));
}
mock_jh.Setup(m => m.sub(exp_max, exp_min)).Returns(exp_range);
Stats s = new Stats(mock_jh.Object);
Joints act_range = s.range(dat_jL);
foreach (var j in dat_jL)
{
mock_jh.Verify(m => m.minMax(It.IsAny <Joints>(), It.IsAny <Joints>(), j), Times.Once());
}
mock_jh.Verify(m => m.sub(exp_max, exp_min), Times.Once());
test.jointsEqual(exp_range, act_range);
}
[Fact] public void Load_Once()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_hnd = hg.newHand(hg.newFingerList());
var dat_fps = dg.newFloat(100);
var exp_hnd = dat_hnd;
var exp_pos = hg.newJoints();
var mock_jh = new Mock <IJointsHelper>();
mock_jh.Setup(m => m.handToJoints(dat_hnd)).Returns(exp_pos);
var org_N_SAMPLES = GBL.N_SAMPLES;
GBL.N_SAMPLES = dg.newInt(100);
var q = new Queues(mock_jh.Object);
q.LoadSample(dat_hnd, dat_fps);
var act_hnd = q.GetSamples();
var act_pos = q.GetPositions();
var act_vel = q.GetVelocities();
GBL.N_SAMPLES = org_N_SAMPLES;
mock_jh.Verify(m => m.handToJoints(dat_hnd), Times.Once());
mock_jh.Verify(m => m.sub(It.IsAny <Joints>(), It.IsAny <Joints>()), Times.Never());
mock_jh.Verify(m => m.div(It.IsAny <Joints>(), It.IsAny <float>()), Times.Never());
test.handEqual(exp_hnd, act_hnd[0]);
test.jointsEqual(exp_pos, act_pos[0]);
Assert.Single <Hand>(act_hnd);
Assert.Single <Joints>(act_pos);
Assert.Single <Joints>(act_vel);
}
[Fact] public void Pow()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_j1 = hg.newJoints();
var exp_j = hg.newJoints();
var mock_vh = new Mock <IVectorHelper>();
mock_vh.Setup(m => m.powList(dat_j1.pinky, 2)).Returns(exp_j.pinky);
mock_vh.Setup(m => m.powList(dat_j1.ring, 2)).Returns(exp_j.ring);
mock_vh.Setup(m => m.powList(dat_j1.middle, 2)).Returns(exp_j.middle);
mock_vh.Setup(m => m.powList(dat_j1.index, 2)).Returns(exp_j.index);
mock_vh.Setup(m => m.powList(dat_j1.thumb, 2)).Returns(exp_j.thumb);
mock_vh.Setup(m => m.pow(dat_j1.palm, 2)).Returns(exp_j.palm);
JointsHelper jh = new JointsHelper(mock_vh.Object);
var act_j = jh.pow(dat_j1, 2);
mock_vh.Verify(m => m.powList(dat_j1.pinky, 2), Times.Once());
mock_vh.Verify(m => m.powList(dat_j1.ring, 2), Times.Once());
mock_vh.Verify(m => m.powList(dat_j1.middle, 2), Times.Once());
mock_vh.Verify(m => m.powList(dat_j1.index, 2), Times.Once());
mock_vh.Verify(m => m.powList(dat_j1.thumb, 2), Times.Once());
mock_vh.Verify(m => m.pow(dat_j1.palm, 2), Times.Once());
test.jointsEqual(act_j, exp_j);
}
[Fact] public void Average()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
int dat_len = dg.newInt(100);
List <Joints> dat_jL = hg.newJointsList(dat_len);
Joints exp_ave = hg.newJoints();
Mock <IJointsHelper> mock_jh = new Mock <IJointsHelper>();
for (int i = 0; i < dat_len; i++)
{
mock_jh.Setup(m => m
.add(It.IsAny <Joints>(), dat_jL[i]))
.Returns(exp_ave);
}
mock_jh.Setup(m => m
.div(exp_ave, dat_len))
.Returns(exp_ave);
Stats s = new Stats(mock_jh.Object);
Joints act_ave = s.average(dat_jL);
mock_jh.Verify(m => m.add(It.IsAny <Joints>(), It.IsAny <Joints>()), Times.Exactly(dat_len));
mock_jh.Verify(m => m.div(exp_ave, dat_len), Times.Once());
test.jointsEqual(exp_ave, act_ave);
}
[Fact] public void HandToJoints()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
List <Vector[]> dat_vL = new List <Vector[]>()
{
dg.newVectors(5),
dg.newVectors(5),
dg.newVectors(5),
dg.newVectors(5),
dg.newVectors(5),
};
List <Finger> dat_fL = hg.newFingerList(dat_vL);
Hand dat_hand = hg.newHand(dat_fL);
Joints exp_joints = new Joints {
pinky = dat_vL[0],
ring = dat_vL[1],
middle = dat_vL[2],
index = dat_vL[3],
thumb = dat_vL[4],
palm = dat_hand.PalmPosition
};
VectorHelper vh = new VectorHelper();
JointsHelper jh = new JointsHelper(vh);
Joints act_joints = jh.handToJoints(dat_hand);
test.jointsEqual(exp_joints, act_joints);
}
[Fact] public void Extract_Multiple()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_f1 = hg.newFrame();
var dat_f2 = hg.newFrame();
dat_f1.Hands[0].IsLeft = false;
dat_f1.Hands[1].IsLeft = true;
dat_f2.Hands[0].IsLeft = false;
dat_f2.Hands[1].IsLeft = true;
var mock_l = new Mock <IQueues>();
var mock_2 = new Mock <IQueues>();
mock_l.Setup(m => m.LoadSample(dat_f1.Hands[1], dat_f1.CurrentFramesPerSecond));
mock_2.Setup(m => m.LoadSample(dat_f2.Hands[1], dat_f2.CurrentFramesPerSecond));
var dm1 = new DataManager(mock_l.Object, true);
var dm2 = new DataManager(mock_2.Object, true);
dm1.Extract(dat_f1);
dm2.Extract(dat_f2);
mock_l.Verify(m => m.LoadSample(dat_f1.Hands[1], dat_f1.CurrentFramesPerSecond), Times.Once());
mock_2.Verify(m => m.LoadSample(dat_f2.Hands[1], dat_f2.CurrentFramesPerSecond), Times.Once());
}
[Fact] public void GreaterEqual()
{
Data_Generator dg = new Data_Generator();
Vector v1 = dg.newVector();
Vector v2 = dg.newVector();
(bool exp_x, bool exp_y, bool exp_z) = dg.newBoolTuple();
if (v1.x >= v2.x)
{
exp_x = true;
}
if (v1.y >= v2.y)
{
exp_y = true;
}
if (v1.z >= v2.z)
{
exp_z = true;
}
VectorHelper v = new VectorHelper();
(bool act_x, bool act_y, bool act_z) = v.greaterEqual(v1, v2);
test.Equals(exp_x, act_x);
test.Equals(exp_y, act_y);
test.Equals(exp_z, act_z);
}
[Fact] public void Extract_ClearsQueues()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_f = hg.newFrame();
dat_f.Hands[0].IsLeft = false;
dat_f.Hands[1].IsLeft = true;
var mock_l = new Mock <IQueues>();
mock_l.Setup(m => m.LoadSample(dat_f.Hands[1], dat_f.CurrentFramesPerSecond));
var dm = new DataManager(mock_l.Object, true);
dm.Extract(dat_f);
var dataCount = dm.GetData();
(List <Joints> position, List <Joints> velocity)exp;
exp.position = null;
exp.velocity = null;
test.Equals(dataCount, exp);
}
[Fact] public void Div_Int()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_j1 = hg.newJoints();
var dat_f = dg.newInt(100);
var exp_j = hg.newJoints();
var mock_vh = new Mock <IVectorHelper>();
mock_vh.Setup(m => m.divList(dat_j1.pinky, dat_f)).Returns(exp_j.pinky);
mock_vh.Setup(m => m.divList(dat_j1.ring, dat_f)).Returns(exp_j.ring);
mock_vh.Setup(m => m.divList(dat_j1.middle, dat_f)).Returns(exp_j.middle);
mock_vh.Setup(m => m.divList(dat_j1.index, dat_f)).Returns(exp_j.index);
mock_vh.Setup(m => m.divList(dat_j1.thumb, dat_f)).Returns(exp_j.thumb);
mock_vh.Setup(m => m.div(dat_j1.palm, dat_f)).Returns(exp_j.palm);
JointsHelper jh = new JointsHelper(mock_vh.Object);
var act_j = jh.div(dat_j1, dat_f);
mock_vh.Verify(m => m.divList(dat_j1.pinky, dat_f), Times.Once());
mock_vh.Verify(m => m.divList(dat_j1.ring, dat_f), Times.Once());
mock_vh.Verify(m => m.divList(dat_j1.middle, dat_f), Times.Once());
mock_vh.Verify(m => m.divList(dat_j1.index, dat_f), Times.Once());
mock_vh.Verify(m => m.divList(dat_j1.thumb, dat_f), Times.Once());
mock_vh.Verify(m => m.div(dat_j1.palm, dat_f), Times.Once());
test.jointsEqual(exp_j, act_j);
}
[Fact] public void greaterEqualListOneToOne()
{
Data_Generator dg = new Data_Generator();
int length = dg.newInt(100);
Vector[] v1 = dg.newVectors(length);
Vector[] v2 = dg.newVectors(length);
var exp_tupleList = new (bool exp_x, bool exp_y, bool exp_z)[length];
[Fact] public void greaterEqual()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_j1 = hg.newJoints();
var dat_f = dg.newFloat(100);
var exp_j = hg.newJoints();
var mock_vh = new Mock <IVectorHelper>();
Assert.True(false);
}
[Fact] public void LowestJoint()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
Hand dat_hand = hg.newHand(hg.newFingerList());
Vector exp_joint = new Vector(-1, -1, -1);
dat_hand.Fingers[4].bones[3].NextJoint = exp_joint;
VectorHelper vh = new VectorHelper();
JointsHelper jh = new JointsHelper(vh);
Vector act_joint = jh.lowestJoint(dat_hand);
}
[Fact] public void Variance()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
int dat_len = dg.newInt(100);
List <Joints> dat_jL = hg.newJointsList(dat_len);
var mock_vh = new Mock <IVectorHelper>();
Joints exp_sum = hg.newJoints();
Joints exp_avg = hg.newJoints();
Joints exp = hg.newJoints();
Joints exp_error = hg.newJoints();
Joints exp_sq_error = hg.newJoints();
Joints exp_sum_sq_error = hg.newJoints();
Joints exp_Variance = hg.newJoints();
Mock <IJointsHelper> mock_jh = new Mock <IJointsHelper>();
foreach (var j in dat_jL)
{
mock_jh.Setup(m => m.add(It.IsAny <Joints>(), j)).Returns(exp_sum);
}
mock_jh.Setup(m => m.div(exp_sum, dat_len)).Returns(exp_avg);
foreach (var j in dat_jL)
{
mock_jh.Setup(m => m.sub(j, exp_avg)).Returns(exp_error);
mock_jh.Setup(m => m.pow(exp_error, 2)).Returns(exp_sq_error);
mock_jh.Setup(m => m.add(It.IsAny <Joints>(), exp_sq_error)).Returns(exp_sum_sq_error);
}
mock_jh.Setup(m => m.div(exp_sum_sq_error, dat_len - 1)).Returns(exp_Variance);
Stats s = new Stats(mock_jh.Object);
var act_Variance = s.variance(dat_jL);
foreach (var j in dat_jL)
{
mock_jh.Verify(m => m.add(It.IsAny <Joints>(), j), Times.Once());
}
mock_jh.Verify(m => m.div(exp_sum, dat_len), Times.Once());
foreach (var j in dat_jL)
{
mock_jh.Verify(m => m.sub(j, exp_avg), Times.Once());
mock_jh.Verify(m => m.pow(exp_error, 2), Times.Exactly(dat_len));
mock_jh.Verify(m => m.add(It.IsAny <Joints>(), exp_sq_error), Times.Exactly(dat_len));
}
test.jointsEqual(exp_Variance, act_Variance);
}
[Fact] public void Lowest()
{
Data_Generator dg = new Data_Generator();
int len = dg.newInt(100);
Vector[] input = dg.newVectors(len);
input[0] = new Vector(-1, -1, -1);
Vector exp = input[0];
VectorHelper vh = new VectorHelper();
Vector act = vh.lowest(input);
test.vectorEqual(exp, act);
}
[Fact] public void Add()
{
Data_Generator dg = new Data_Generator();
Vector v1 = dg.newVector();
Vector v2 = dg.newVector();
Vector exp = new Vector {
x = v1.x + v2.x,
y = v1.y + v2.y,
z = v1.z + v2.z
};
VectorHelper v = new VectorHelper();
Vector act = v.add(v1, v2);
test.vectorEqual(exp, act);
}
[Fact] public void Pow()
{
Data_Generator dg = new Data_Generator();
Vector v1 = dg.newVector();
float f = dg.newFloat(100);
Vector exp = new Vector {
x = (float)Math.Pow(v1.x, f),
y = (float)Math.Pow(v1.y, f),
z = (float)Math.Pow(v1.z, f)
};
VectorHelper v = new VectorHelper();
Vector act = v.pow(v1, f);
test.vectorEqual(act, exp);
}
[Fact] public void Div()
{
Data_Generator dg = new Data_Generator();
Vector v1 = dg.newVector();
float v2 = dg.newFloat(100);
Vector exp = new Vector {
x = v1.x / v2,
y = v1.y / v2,
z = v1.z / v2
};
VectorHelper v = new VectorHelper();
Vector act = v.div(v1, v2);
test.vectorEqual(exp, act);
}
[Fact] public void PowList()
{
Data_Generator dg = new Data_Generator();
int length = dg.newInt(100);
float f = dg.newFloat(100);
Vector[] v1 = dg.newVectors(length);
Vector[] exp = dg.newZeroVectors(length);
for (int i = 0; i < length; i++)
{
exp[i].x = (float)Math.Pow(v1[i].x, f);
exp[i].y = (float)Math.Pow(v1[i].y, f);
exp[i].z = (float)Math.Pow(v1[i].z, f);
}
VectorHelper v = new VectorHelper();
Vector[] act = v.powList(v1, f);
test.vectorsEqual(act, exp);
}
[Fact] public void MinMax()
{
Data_Generator dg = new Data_Generator();
(Vector min, Vector max, Vector v)dat;
dat.v = dg.newVector();
dat.min = new Vector(float.MinValue, float.MinValue, float.MinValue);
dat.max = dg.newZeroVector();
(Vector min, Vector max)exp;
exp.min = dat.min;
exp.max = dat.v;
var v = new VectorHelper();
var act = v.minMax(dat.min, dat.max, dat.v);
test.vectorEqual(exp.min, act.min);
test.vectorEqual(exp.max, act.max);
}
[Fact] public void ToArray()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_j = hg.newJoints();
var datPinky = dat_j.pinky;
var datRing = dat_j.ring;
var datMiddle = dat_j.middle;
var datIndex = dat_j.index;
var datThumb = dat_j.thumb;
var datPalm = dat_j.palm;
Vector[] jVecArr = dat_j.ToArray();
int k = 0;
for (int i = 0; i < 5; i++)
{
test.Equals(jVecArr[k], datPinky[i]);
k++;
}
for (int i = 0; i < 5; i++)
{
test.Equals(jVecArr[k], datRing[i]);
k++;
}
for (int i = 0; i < 5; i++)
{
test.Equals(jVecArr[k], datMiddle[i]);
k++;
}
for (int i = 0; i < 5; i++)
{
test.Equals(jVecArr[k], datIndex[i]);
k++;
}
for (int i = 0; i < 5; i++)
{
test.Equals(jVecArr[k], datThumb[i]);
k++;
}
test.Equals(jVecArr[25], datPalm);
}
[Fact] public void AddList()
{
Data_Generator dg = new Data_Generator();
int length = dg.newInt(100);
Vector[] v1 = dg.newVectors(length);
Vector[] v2 = dg.newVectors(length);
Vector[] exp = dg.newZeroVectors(length);
for (int i = 0; i < length; i++)
{
exp[i].x = v1[i].x + v2[i].x;
exp[i].y = v1[i].y + v2[i].y;
exp[i].z = v1[i].z + v2[i].z;
}
VectorHelper v = new VectorHelper();
Vector[] act = v.addList(v1, v2);
test.vectorsEqual(exp, act);
}
[Fact] public void MinMaxList()
{
var dg = new Data_Generator();
//var dat_i = 0;
var dat_len = dg.newInt(100);
var dat_vA = dg.newVectors(dat_len);
var dat_min = dg.newMinVectors(dat_len);
var dat_max = dg.newZeroVectors(dat_len);
(Vector[] min, Vector[] max)exp = (new Vector[dat_len], new Vector[dat_len]);
exp.min = dat_min;
exp.max = dat_vA;
var vh = new VectorHelper();
(Vector[] min, Vector[] max)act = vh.minMaxList(dat_min, dat_max, dat_vA);
test.vectorsEqual(exp.min, act.min);
test.vectorsEqual(exp.max, act.max);
}
[Fact] public void DivList()
{
Data_Generator dg = new Data_Generator();
int length = dg.newInt(100);
Vector[] v1 = dg.newVectors(length);
float v2 = dg.newFloat(100);
Vector[] exp = dg.newZeroVectors(length);
for (int i = 0; i < length; i++)
{
exp[i].x = v1[i].x / v2;
exp[i].y = v1[i].y / v2;
exp[i].z = v1[i].z / v2;
}
VectorHelper v = new VectorHelper();
Vector[] act = v.divList(v1, v2);
test.vectorsEqual(exp, act);
}
[Fact] public void FingerToVectors()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
Finger inp_finger = hg.newFinger(dg.newVectors(5));
Vector[] exp_vL = new Vector[] {
inp_finger.bones[0].PrevJoint,
inp_finger.bones[1].PrevJoint,
inp_finger.bones[2].PrevJoint,
inp_finger.bones[3].PrevJoint,
inp_finger.bones[3].NextJoint,
};
VectorHelper vh = new VectorHelper();
JointsHelper jh = new JointsHelper(vh);
Vector[] act_vL = jh.fingerToVectors(inp_finger);
test.vectorsEqual(exp_vL, act_vL);
}
[Fact] public void Emit()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
VectorHelper vh = new VectorHelper();
JointsHelper jh = new JointsHelper(vh);
AmplitudeModulationEmitter mock_emitter = new AmplitudeModulationEmitter("MockDevice:U5;logfile=log.txt");
var j = hg.newJoints();
bool exp = false;
bool act = false;
var haptic = new Haptic(jh, mock_emitter);
var point = haptic.AquireTarget(j);
var points = new List <AmplitudeModulationControlPoint>();
points.Add(point);
exp = mock_emitter.update(points);
act = haptic.Emit(points);
Assert.Equal(exp, act);
}
[Fact] public void Load_Multiple()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
var dat_hnd1 = hg.newHand(hg.newFingerList());
var dat_fps1 = dg.newFloat(100);
var dat_hnd2 = hg.newHand(hg.newFingerList());
var dat_fps2 = dg.newFloat(100);
var exp_hnd1 = dat_hnd1;
var exp_pos1 = hg.newJoints();
var exp_hnd2 = dat_hnd2;
var exp_pos2 = hg.newJoints();
var mock_jh = new Mock <IJointsHelper>();
mock_jh.Setup(m => m.handToJoints(dat_hnd1)).Returns(exp_pos1);
mock_jh.Setup(m => m.handToJoints(dat_hnd2)).Returns(exp_pos2);
var org_N_SAMPLES = GBL.N_SAMPLES;
GBL.N_SAMPLES = dg.newInt(100);
var q = new Queues(mock_jh.Object);
q.LoadSample(dat_hnd1, dat_fps1);
q.LoadSample(dat_hnd2, dat_fps2);
var act_hnds = q.GetSamples();
var act_poss = q.GetPositions();
var act_vels = q.GetVelocities();
GBL.N_SAMPLES = org_N_SAMPLES;
mock_jh.Verify(m => m.handToJoints(dat_hnd1), Times.Once());
mock_jh.Verify(m => m.handToJoints(dat_hnd2), Times.Once());
test.handEqual(exp_hnd1, act_hnds[0]);
test.handEqual(exp_hnd2, act_hnds[1]);
test.jointsEqual(exp_pos1, act_poss[0]);
test.jointsEqual(exp_pos2, act_poss[1]);
}
[Fact] public void Average()
{
Data_Generator dg = new Data_Generator();
int len = dg.newInt(100);
Vector[] vL = dg.newVectors(len);
Vector exp = new Vector(0, 0, 0);
for (int i = 0; i < len; i++)
{
exp.x += vL[i].x;
exp.y += vL[i].y;
exp.z += vL[i].z;
}
exp.x /= (float)len;
exp.y /= (float)len;
exp.z /= (float)len;
VectorHelper vh = new VectorHelper();
Vector act = vh.average(vL);
test.vectorEqual(exp, act);
}
[Fact] public void AquireTarget()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
Joints inp_joint = hg.newJoints();
float org_UH_INTENSITY = GBL.UH_INTENSITY;
float org_UH_FREQUENCY = GBL.UH_FREQUENCY;
float exp_UH_INTENSITY = dg.newFloat(100);
float exp_UH_FREQUENCY = dg.newFloat(200);
AmplitudeModulationControlPoint exp = new AmplitudeModulationControlPoint(
inp_joint.palm.x,
inp_joint.palm.z * -1,
inp_joint.palm.y,
exp_UH_INTENSITY,
exp_UH_FREQUENCY
);
Haptic h = new Haptic(new JointsHelper(new VectorHelper()), new AmplitudeModulationEmitter());
var act = h.AquireTarget(inp_joint);
Assert.Equal(exp.getPosition().x, act.getPosition().x);
Assert.Equal(exp.getPosition().y, act.getPosition().y);
Assert.Equal(exp.getPosition().z, act.getPosition().z);
}
[Fact] public void MinMax()
{
Data_Generator dg = new Data_Generator();
Hand_Generator hg = new Hand_Generator(dg);
(Joints min, Joints max, Joints j)dat;
dat.j = hg.newJoints();
dat.min = new Joints(dg.newMinVectors(5), dg.newMinVectors(5), dg.newMinVectors(5), dg.newMinVectors(5),
dg.newMinVectors(5), dg.newMinVector(), dg.newFloat(100));
dat.max = new Joints(dg.newZeroVectors(5), dg.newZeroVectors(5), dg.newZeroVectors(5), dg.newZeroVectors(5),
dg.newZeroVectors(5), dg.newZeroVector(), dg.newFloat(100));
(Joints min, Joints max)exp;
exp.min = dat.min;
exp.max = dat.j;
var vH = new VectorHelper();
var jH = new JointsHelper(vH);
var act = jH.minMax(dat.min, dat.max, dat.j);
test.jointsEqual(exp.min, act.min);
test.jointsEqual(exp.max, act.max);
}
