[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); }