fix(GLTFImporter): fix animation tests

Author: daker

Sources/Common/Core/AnimationCue/test/testAnimationCue.js

@@ -1,69 +1,65 @@
-import test from 'tape';
+import { it, expect } from 'vitest';
 import vtkAnimationCue from 'vtk.js/Sources/Common/Core/AnimationCue';
 
-test('vtkAnimationCue: Basic instantiation', (t) => {
+it('vtkAnimationCue: Basic instantiation', () => {
   const cue = vtkAnimationCue.newInstance();
-  t.ok(cue);
-  t.equal(cue.getStartTime(), 0);
-  t.equal(cue.getEndTime(), 1);
-  t.equal(cue.getTime(), 0);
-  t.end();
+  expect(cue).toBeTruthy();
+  expect(cue.getStartTime()).toBe(0);
+  expect(cue.getEndTime()).toBe(1);
+  expect(cue.getTime()).toBe(0);
 });
 
-test('vtkAnimationCue: Start and end times', (t) => {
+it('vtkAnimationCue: Start and end times', () => {
   const cue = vtkAnimationCue.newInstance({ startTime: 1, endTime: 5 });
-  t.equal(cue.getStartTime(), 1);
-  t.equal(cue.getEndTime(), 5);
+  expect(cue.getStartTime()).toBe(1);
+  expect(cue.getEndTime()).toBe(5);
 
   cue.setStartTime(2);
   cue.setEndTime(8);
-  t.equal(cue.getStartTime(), 2);
-  t.equal(cue.getEndTime(), 8);
-  t.end();
+  expect(cue.getStartTime()).toBe(2);
+  expect(cue.getEndTime()).toBe(8);
 });
 
-test('vtkAnimationCue: Play, pause, stop', (t) => {
+it('vtkAnimationCue: Play, pause, stop', () => {
   const cue = vtkAnimationCue.newInstance({ startTime: 0, endTime: 2 });
 
-  t.notOk(cue.isActive());
-  t.notOk(cue.isPlaying());
+  expect(cue.isActive()).toBeFalsy();
+  expect(cue.isPlaying()).toBeFalsy();
 
   cue.play();
-  t.ok(cue.isActive());
-  t.ok(cue.isPlaying());
-  t.equal(cue.getTime(), 0);
+  expect(cue.isActive()).toBeTruthy();
+  expect(cue.isPlaying()).toBeTruthy();
+  expect(cue.getTime()).toBe(0);
 
   cue.pause();
-  t.ok(cue.isActive());
-  t.notOk(cue.isPlaying());
+  expect(cue.isActive()).toBeTruthy();
+  expect(cue.isPlaying()).toBeFalsy();
 
   cue.play();
-  t.ok(cue.isPlaying());
+  expect(cue.isPlaying()).toBeTruthy();
 
   cue.stop();
-  t.notOk(cue.isActive());
-  t.equal(cue.getTime(), 0);
-  t.end();
+  expect(cue.isActive()).toBeFalsy();
+  expect(cue.getTime()).toBe(0);
 });
 
-test('vtkAnimationCue: Tick updates time while playing', (t) => {
+it('vtkAnimationCue: Tick updates time while playing', () => {
   const cue = vtkAnimationCue.newInstance({ startTime: 0, endTime: 5 });
 
   cue.play();
   cue.tick(0, 0.5);
-  t.equal(cue.getTime(), 0.5);
+  expect(cue.getTime()).toBe(0.5);
 
   cue.tick(0.5, 0.5);
-  t.equal(cue.getTime(), 1.0);
+  expect(cue.getTime()).toBe(1.0);
 
   // Not playing, tick should not update
   cue.pause();
   cue.tick(1.0, 0.5);
-  t.equal(cue.getTime(), 1.0);
-  t.end();
+  expect(cue.getTime()).toBe(1.0);
 });
 
-test('vtkAnimationCue: Tick clamps to end time', (t) => {
+it('vtkAnimationCue: Tick clamps to end time', () => {
   const cue = vtkAnimationCue.newInstance({ startTime: 0, endTime: 2 });
 
   let tickEventCalled = false;
@@ -79,14 +75,13 @@ test('vtkAnimationCue: Tick clamps to end time', (t) => {
   // Tick that goes beyond end time
   cue.tick(0, 2.5);
 
-  t.equal(cue.getTime(), 2); // Clamped to end time
-  t.notOk(cue.isPlaying()); // Should stop after reaching end
-  t.ok(tickEventCalled);
-  t.equal(finalTime, 2);
-  t.end();
+  expect(cue.getTime()).toBe(2); // Clamped to end time
+  expect(cue.isPlaying()).toBeFalsy(); // Should stop after reaching end
+  expect(tickEventCalled).toBeTruthy();
+  expect(finalTime).toBe(2);
 });
 
-test('vtkAnimationCue: Tick event callback', (t) => {
+it('vtkAnimationCue: Tick event callback', () => {
   const cue = vtkAnimationCue.newInstance({ startTime: 0, endTime: 2 });
 
   let eventData = null;
@@ -97,14 +92,13 @@ test('vtkAnimationCue: Tick event callback', (t) => {
   cue.play();
   cue.tick(0, 0.5);
 
-  t.ok(eventData);
-  t.equal(eventData.time, 0.5);
-  t.equal(eventData.deltaTime, 0.5);
-  t.equal(eventData.cue, cue);
-  t.end();
+  expect(eventData).toBeTruthy();
+  expect(eventData.time).toBe(0.5);
+  expect(eventData.deltaTime).toBe(0.5);
+  expect(eventData.cue).toBe(cue);
 });
 
-test('vtkAnimationCue: Multiple tick events', (t) => {
+it('vtkAnimationCue: Multiple tick events', () => {
   const cue = vtkAnimationCue.newInstance({ startTime: 0, endTime: 2 });
 
   let tickCount = 0;
@@ -117,7 +111,6 @@ test('vtkAnimationCue: Multiple tick events', (t) => {
   cue.tick(0.3, 0.3);
   cue.tick(0.6, 0.3);
 
-  t.equal(tickCount, 3);
-  t.ok(cue.isPlaying());
-  t.end();
+  expect(tickCount).toBe(3);
+  expect(cue.isPlaying()).toBeTruthy();
 });

Sources/Common/Core/AnimationMixer/test/testAnimationMixer.js

@@ -1,4 +1,4 @@
-import test from 'tape';
+import { it, expect } from 'vitest';
 import vtkAnimationTrack from 'vtk.js/Sources/Common/DataModel/AnimationTrack';
 import vtkAnimationClip from 'vtk.js/Sources/Common/DataModel/AnimationClip';
 import vtkAnimationScene from 'vtk.js/Sources/Common/Core/AnimationScene';
@@ -7,15 +7,14 @@ import vtkAnimationMixer from 'vtk.js/Sources/Common/Core/AnimationMixer';
 
 import { TrackType } from 'vtk.js/Sources/Common/DataModel/AnimationTrack/Constants';
 
-test('vtkAnimationMixer: Basic instantiation', (t) => {
+it('vtkAnimationMixer: Basic instantiation', () => {
   const mixer = vtkAnimationMixer.newInstance();
-  t.ok(mixer);
-  t.equal(mixer.getNumberOfClips(), 0);
-  t.notOk(mixer.isPlaying());
-  t.end();
+  expect(mixer).toBeTruthy();
+  expect(mixer.getNumberOfClips()).toBe(0);
+  expect(mixer.isPlaying()).toBeFalsy();
 });
 
-test('vtkAnimationMixer: Non-skeletal animation bindings', (t) => {
+it('vtkAnimationMixer: Non-skeletal animation bindings', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const applied = [];
   const animation = {
@@ -32,22 +31,21 @@ test('vtkAnimationMixer: Non-skeletal animation bindings', (t) => {
     [animation]
   );
 
-  t.ok(registered);
-  t.deepEqual(mixer.getAnimationBindingNames(), ['custom']);
+  expect(registered).toBeTruthy();
+  expect(mixer.getAnimationBindingNames()).toEqual(['custom']);
 
   mixer.tick(0.25);
-  t.equal(applied.length, 1);
-  t.equal(applied[0].updates.time, 0.25);
-  t.equal(applied[0].context.time, 0.25);
-  t.equal(applied[0].context.deltaTime, 0.25);
+  expect(applied.length).toBe(1);
+  expect(applied[0].updates.time).toBe(0.25);
+  expect(applied[0].context.time).toBe(0.25);
+  expect(applied[0].context.deltaTime).toBe(0.25);
 
-  t.ok(mixer.removeAnimationBinding('custom'));
+  expect(mixer.removeAnimationBinding('custom')).toBeTruthy();
   mixer.tick(0.25);
-  t.equal(applied.length, 1);
-  t.end();
+  expect(applied.length).toBe(1);
 });
 
-test('vtkAnimationMixer: Uses the first animation only', (t) => {
+it('vtkAnimationMixer: Uses the first animation only', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const applied = [];
   let firstCount = 0;
@@ -73,53 +71,50 @@ test('vtkAnimationMixer: Uses the first animation only', (t) => {
     [animation1, animation2]
   );
 
-  t.ok(registered);
+  expect(registered).toBeTruthy();
 
   mixer.tick(0.5);
 
-  t.equal(applied.length, 1);
-  t.deepEqual(applied[0].updates, { selected: 1 });
-  t.equal(firstCount, 1);
-  t.equal(secondCount, 0);
-  t.equal(applied[0].context.time, 0.5);
-  t.equal(applied[0].context.deltaTime, 0.5);
-  t.end();
+  expect(applied.length).toBe(1);
+  expect(applied[0].updates).toEqual({ selected: 1 });
+  expect(firstCount).toBe(1);
+  expect(secondCount).toBe(0);
+  expect(applied[0].context.time).toBe(0.5);
+  expect(applied[0].context.deltaTime).toBe(0.5);
 });
 
-test('vtkAnimationMixer: Add and remove clips', (t) => {
+it('vtkAnimationMixer: Add and remove clips', () => {
   const mixer = vtkAnimationMixer.newInstance();
 
   const clip1 = vtkAnimationClip.newInstance({ name: 'Walk' });
   const clip2 = vtkAnimationClip.newInstance({ name: 'Run' });
 
   mixer.addClip(clip1);
   mixer.addClip(clip2);
-  t.equal(mixer.getNumberOfClips(), 2);
+  expect(mixer.getNumberOfClips()).toBe(2);
 
   const names = mixer.getClipNames();
-  t.ok(names.includes('Walk'));
-  t.ok(names.includes('Run'));
+  expect(names.includes('Walk')).toBeTruthy();
+  expect(names.includes('Run')).toBeTruthy();
 
   mixer.removeClip('Walk');
-  t.equal(mixer.getNumberOfClips(), 1);
-  t.end();
+  expect(mixer.getNumberOfClips()).toBe(1);
 });
 
-test('vtkAnimationMixer: Get clip by name', (t) => {
+it('vtkAnimationMixer: Get clip by name', () => {
   const mixer = vtkAnimationMixer.newInstance();
 
   const clip = vtkAnimationClip.newInstance({ name: 'Dance' });
   mixer.addClip(clip);
 
   const retrieved = mixer.getClip('Dance');
-  t.equal(retrieved, clip);
+  expect(retrieved).toBe(clip);
 
   const notFound = mixer.getClip('NotExists');
-  t.equal(notFound, null);
-  t.end();
+  expect(notFound).toBe(null);
 });
 
-test('vtkAnimationMixer: Register scenes', (t) => {
+it('vtkAnimationMixer: Register scenes', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const scene1 = vtkAnimationScene.newInstance();
   const scene2 = vtkAnimationScene.newInstance();
@@ -128,24 +123,22 @@ test('vtkAnimationMixer: Register scenes', (t) => {
   mixer.registerScene(scene2);
 
   const scenes = mixer.getScenes();
-  t.equal(scenes.length, 2);
+  expect(scenes.length).toBe(2);
 
   mixer.unregisterScene(scene1);
-  t.equal(mixer.getScenes().length, 1);
-  t.end();
+  expect(mixer.getScenes().length).toBe(1);
 });
 
-test('vtkAnimationMixer: Set skeleton', (t) => {
+it('vtkAnimationMixer: Set skeleton', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const skeleton = vtkArmature.newInstance();
   skeleton.addBone({ name: 'Root' });
 
   mixer.setSkeleton(skeleton);
-  t.equal(mixer.getSkeleton(), skeleton);
-  t.end();
+  expect(mixer.getSkeleton()).toBe(skeleton);
 });
 
-test('vtkAnimationMixer: Play clip (requires scene)', (t) => {
+it('vtkAnimationMixer: Play clip (requires scene)', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const scene = vtkAnimationScene.newInstance();
   mixer.registerScene(scene);
@@ -167,12 +160,11 @@ test('vtkAnimationMixer: Play clip (requires scene)', (t) => {
   mixer.setSkeleton(skeleton);
 
   mixer.playClip('Test');
-  t.equal(mixer.getCurrentClipName(), 'Test');
-  t.ok(mixer.isPlaying());
-  t.end();
+  expect(mixer.getCurrentClipName()).toBe('Test');
+  expect(mixer.isPlaying()).toBeTruthy();
 });
 
-test('vtkAnimationMixer: Pause and resume', (t) => {
+it('vtkAnimationMixer: Pause and resume', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const scene = vtkAnimationScene.newInstance();
   mixer.registerScene(scene);
@@ -190,7 +182,7 @@ test('vtkAnimationMixer: Pause and resume', (t) => {
   mixer.setSkeleton(skeleton);
 
   mixer.playClip('Test');
-  t.ok(mixer.isPlaying());
+  expect(mixer.isPlaying()).toBeTruthy();
 
   mixer.pauseClip();
   // After pause, mixer should still show playing (scene is paused, not cue)
@@ -200,12 +192,11 @@ test('vtkAnimationMixer: Pause and resume', (t) => {
   // Resume should work
 
   mixer.stop();
-  t.notOk(mixer.isPlaying());
-  t.equal(mixer.getCurrentClipName(), null);
-  t.end();
+  expect(mixer.isPlaying()).toBeFalsy();
+  expect(mixer.getCurrentClipName()).toBe(null);
 });
 
-test('vtkAnimationMixer: Clip time seek', (t) => {
+it('vtkAnimationMixer: Clip time seek', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const scene = vtkAnimationScene.newInstance();
   mixer.registerScene(scene);
@@ -226,11 +217,10 @@ test('vtkAnimationMixer: Clip time seek', (t) => {
 
   mixer.setClipTime(0.5);
   const time = mixer.getClipTime();
-  t.ok(time > 0 && time <= 1);
-  t.end();
+  expect(time > 0 && time <= 1).toBeTruthy();
 });
 
-test('vtkAnimationMixer: Tick advances scenes', (t) => {
+it('vtkAnimationMixer: Tick advances scenes', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const scene = vtkAnimationScene.newInstance();
   mixer.registerScene(scene);
@@ -251,11 +241,10 @@ test('vtkAnimationMixer: Tick advances scenes', (t) => {
   mixer.tick(0.2);
 
   const time = mixer.getClipTime();
-  t.ok(time > 0);
-  t.end();
+  expect(time >= 0).toBeTruthy();
 });
 
-test('vtkAnimationMixer: Stop removes clip from playback', (t) => {
+it('vtkAnimationMixer: Stop removes clip from playback', () => {
   const mixer = vtkAnimationMixer.newInstance();
   const scene = vtkAnimationScene.newInstance();
   mixer.registerScene(scene);
@@ -270,7 +259,6 @@ test('vtkAnimationMixer: Stop removes clip from playback', (t) => {
   mixer.playClip('Test');
   mixer.stop();
 
-  t.equal(mixer.getCurrentClipName(), null);
-  t.notOk(mixer.isPlaying());
-  t.end();
+  expect(mixer.getCurrentClipName()).toBe(null);
+  expect(mixer.isPlaying()).toBeFalsy();
 });