compileprofile-spacetests 0.2.1 → 0.4.0

package/src/__tests__/integration/emotions.test.ts

@@ -1,10 +1,64 @@
-import { emotion_extract_trials, emotion_results, 
+import { emotion_extract_trials, emotion_results,
   emotion_calculate_results } from '../../emotions';
 import { loadTestData } from '../test-utils/testData';
 
 describe('Emotions test module', () => {
   const emotionsData = loadTestData('emotions').emotions;
 
+  // Comprehensive mock data for predictable testing
+  const mockEmotionsData = [
+    {
+      "index": 1,
+      "emotion": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/surprised_3.png",
+      "rt": 1000,
+      "stimulus": "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/surprised_3.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+      "response": 3,
+      "trial_type": "html-button-response",
+      "trial_index": 9,
+      "plugin_version": "2.0.0",
+      "time_elapsed": 45416,
+      "attempted": false
+    },
+    {
+      "index": 2,
+      "emotion": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/sad_1.png",
+      "rt": 1000,
+      "stimulus": "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/sad_1.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+      "response": 1,
+      "trial_type": "html-button-response",
+      "trial_index": 10,
+      "plugin_version": "2.0.0",
+      "time_elapsed": 47656,
+      "attempted": false
+    },
+    {
+      "index": 3,
+      "emotion": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/angry_1.png",
+      "rt": 2000,
+      "stimulus": "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/angry_1.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+      "response": 3,
+      "trial_type": "html-button-response",
+      "trial_index": 11,
+      "plugin_version": "2.0.0",
+      "time_elapsed": 49698,
+      "attempted": false
+    },
+    {
+      "index": 4,
+      "emotion": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/sad_3.png",
+      "rt": 1000,
+      "stimulus": "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/emotions//final/sad_3.png\" class=\"max-w-none rotate_0\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+      "response": 1,
+      "trial_type": "html-button-response",
+      "trial_index": 12,
+      "plugin_version": "2.0.0",
+      "time_elapsed": 52944,
+      "attempted": false
+    },
+    // Non-emotion data that should be filtered out
+    { trial_type: 'browser-check', browser: 'safari' }
+  ];
+
   describe('emotion_extract_trials', () => {
     it('should extract trials from raw data', () => {
       const trials = emotion_extract_trials(emotionsData);
@@ -14,6 +68,8 @@ describe('Emotions test module', () => {
         expect(trial).toHaveProperty('emotion');
         expect(trial).toHaveProperty('emotion_response');
         expect(trial).toHaveProperty('correct');
+        // property correct should be boolean
+        expect(typeof trial.correct).toBe('boolean');
         expect(trial).toHaveProperty('image_number');
         expect(typeof trial.emotion).toBe('string');
       });      
@@ -23,6 +79,25 @@ describe('Emotions test module', () => {
       const trials = emotion_extract_trials([]);
       expect(trials).toEqual([]);
     });
+
+    it('should extract mock data correctly', () => {
+      const trials = emotion_extract_trials(mockEmotionsData);
+      expect(trials.length).toBe(4); // Only trials with valid emotion, rt, and response
+
+      // Check emotion extraction and response mapping
+      expect(trials[0].emotion).toBe('surprised');
+      expect(trials[0].image_number).toBe('3');
+      expect(trials[0].emotion_response).toBe('surprised');
+      expect(trials[0].correct).toBe(true);
+
+      expect(trials[1].emotion).toBe('sad');
+      expect(trials[1].emotion_response).toBe('sad');
+      expect(trials[1].correct).toBe(true);
+
+      expect(trials[2].emotion).toBe('angry');
+      expect(trials[2].emotion_response).toBe('surprised');
+      expect(trials[2].correct).toBe(false);
+    });
   });
 
   describe('emotion_results', () => {
@@ -32,34 +107,67 @@ describe('Emotions test module', () => {
         { rt: 600, correct: true, emotion: 'happy', emotion_response: 'happy' },
         { rt: 1000, correct: true, emotion: 'sad', emotion_response: 'sad' },
         { rt: 800, correct: false, emotion: 'angry', emotion_response: 'happy' },
+        { rt: 400, correct: false, emotion: 'sad', emotion_response: 'happy' },
       ];
       
       const results = emotion_results(sampleTrials);
-      
-      expect(results.n).toBe(3);
-      expect(results.avg_rt).toBe(800); // (1000 + 1500 + 2000) / 3
-      expect(results.avg_acc).toBe(2/3); // (1 + 1 + 0) / 3
-      expect(results.performance).toBeGreaterThan(0);
-      expect(results.performance).toBeLessThanOrEqual(100);
+
+      expect(results).toHaveProperty('common');
+      expect(results.common.n_trials).toBe(4);
+      expect(results.common.avg_rt_total).toBe(700); // (600 + 1000 + 800 + 400) / 4
+      expect(results.common.n_correct_trials / results.common.n_trials).toBe(2/4); // (1 + 1 + 0 + 0) / 4
+      expect(results.common.performance_score).toBeGreaterThanOrEqual(0);
+      expect(results.common.performance_score).toBeLessThanOrEqual(100);
+      expect(results).toHaveProperty('special');
+      expect(results.special).toHaveProperty('by_emotion');
+      expect(results.special).toHaveProperty('confusion_matrix');
     });
 
     it('should handle empty trials array', () => {
       // When given an empty array, it should handle it gracefully
       expect(() => emotion_results([])).toThrow();
     });
+
+    it('should calculate mock data results correctly', () => {
+      const mockTrials = emotion_extract_trials(mockEmotionsData);
+      const mockResults = emotion_results(mockTrials);
+
+      // Expected: 5 trials total, 4 correct, 1 incorrect, 0 missing (missing was filtered out)
+      expect(mockResults.common.n_trials).toBe(4);
+      expect(mockResults.common.n_correct_trials).toBe(3);
+      expect(mockResults.common.n_incorrect_trials).toBe(1);
+
+      expect(mockResults.common.avg_rt_total).toBe(1250);
+      expect(mockResults.common.avg_rt_correct).toBe(1000);
+      expect(mockResults.common.avg_rt_incorrect).toBe(2000);
+
+      // Performance score calculation using RT/(accuracy^5)
+      expect(mockResults.common.performance_score).toBeGreaterThan(0);
+      expect(mockResults.common.performance_score).toBeLessThanOrEqual(100);
+
+      // Check special results structure
+      expect(mockResults.special.by_emotion).toHaveLength(5); // neutral, sad, happy, surprised, angry
+      expect(mockResults.special.confusion_matrix).toHaveProperty('happy');
+      expect(mockResults.special.confusion_matrix).toHaveProperty('sad');
+      expect(mockResults.special.confusion_matrix).toHaveProperty('angry');
+      expect(mockResults.special.confusion_matrix).toHaveProperty('neutral');
+      expect(mockResults.special.confusion_matrix).toHaveProperty('surprised');
+    });
   });
 
   describe('emotion_calculate_results', () => {
     it('should process raw data and return valid results', () => {
       const results = emotion_calculate_results(emotionsData);
       console.log(results);
-      expect(results).toHaveProperty('n');
-      expect(results).toHaveProperty('avg_rt');
-      expect(results).toHaveProperty('avg_acc');
-      expect(results).toHaveProperty('performance');
-      
-      expect(results.performance).toBeGreaterThan(0);
-      expect(results.performance).toBeLessThanOrEqual(100);
+      expect(results).toHaveProperty('common');
+      expect(results).toHaveProperty('special');
+      expect(results.common).toHaveProperty('n_trials');
+      expect(results.common).toHaveProperty('n_correct_trials');
+      expect(results.common).toHaveProperty('avg_rt_total');
+      expect(results.common).toHaveProperty('performance_score');
+
+      expect(results.common.performance_score).toBeGreaterThan(0);
+      expect(results.common.performance_score).toBeLessThanOrEqual(100);
     });
   });
 });

package/src/__tests__/integration/gonogo.test.ts

@@ -4,28 +4,78 @@ import { loadTestData } from '../test-utils/testData';
 describe('Gonogo test module', () => {
   // If gonogo data is available in your test data, load it
   // const gonogoData = loadTestData('gonogo').gonogo;
-  
+
   const gonogoData = loadTestData('gonogo').gonogo;
 
-  const mockTrials = [
+  // Comprehensive mock data for predictable testing
+  const mockGonogoData = [
+    {
+      "trial_index": 8,
+      "block_number": 1,
+      "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
+      "rt": 1000,
+      "stimulus": "",
+      "response": 0,
+      "trial_type": "html-button-response",
+      "plugin_version": "2.0.0",
+      "time_elapsed": 15801,
+      "attempted": false
+    },
+    {
+      "rt": null,
+      "stimulus": "<img src=\"https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/fixation_cross.png\" class=\"max-w-none\" style=\"display:none\" width=\"512\" height=\"512\" alt=\"Mapa\">",
+      "response": null,
+      "trial_type": "html-button-response",
+      "trial_index": 9,
+      "plugin_version": "2.0.0",
+      "time_elapsed": 16335,
+      "attempted": false
+    },
+    {
+      "trial_index": 16,
+      "block_number": 1,
+      "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/alien_trans_1.png",
+      "rt": null,
+      "stimulus": "",
+      "response": null,
+      "trial_type": "html-button-response",
+      "plugin_version": "2.0.0",
+      "time_elapsed": 20290,
+      "attempted": false
+    },
     {
-      image: "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
-      rt: 846,
-      response: 0,
-      block_number:1
+      "trial_index": 10,
+      "block_number": 1,
+      "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
+      "rt": null,
+      "stimulus": "",
+      "response": null,
+      "trial_type": "html-button-response",
+      "plugin_version": "2.0.0",
+      "time_elapsed": 16752,
+      "attempted": false
     },
     {
-      image: "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/alien_trans_1.png",
-      rt: null,
-      response: null,
-      block_number: 1
+      "trial_index": 16,
+      "block_number": 1,
+      "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/alien_trans_1.png",
+      "rt": 2000,
+      "stimulus": "",
+      "response": 0,
+      "trial_type": "html-button-response",
+      "plugin_version": "2.0.0",
+      "time_elapsed": 20290,
+      "attempted": false
     },
+    // Non-gonogo data that should be filtered out
+    { trial_type: 'instructions', text: 'Press space when...' },
+    { trial_type: 'browser-check', browser: 'chrome' }
   ];
 
+
   describe('gonogo_extract_trials', () => {
     it('should extract trials from raw data', () => {
       const trials = gonogo_extract_trials(gonogoData);
-      // consolo log trials which have block number 3
       expect(trials.length).toBeLessThan(gonogoData.length);
       
       trials.forEach(trial => {
@@ -41,41 +91,204 @@ describe('Gonogo test module', () => {
       const trials = gonogo_extract_trials([]);
       expect(trials).toEqual([]);
     });
+
+    it('should extract mock data correctly', () => {
+      const trials = gonogo_extract_trials(mockGonogoData);
+      expect(trials.length).toBe(4); // Only trials with image field
+
+      // Check stimulus extraction and correctness logic
+      expect(trials[0].stimulus).toBe('astronaut_trans_1.png');
+      expect(trials[0].should_go).toBe(true); // astronaut in block 1
+      expect(trials[0].did_go).toBe(true); // response: 1
+      expect(trials[0].correct).toBe(true);
+
+      expect(trials[1].stimulus).toBe('alien_trans_1.png');
+      expect(trials[1].should_go).toBe(false); // alien in block 1
+      expect(trials[1].did_go).toBe(false); // response: null
+      expect(trials[1].correct).toBe(true);
+
+      expect(trials[2].stimulus).toBe('astronaut_trans_1.png');
+      expect(trials[2].should_go).toBe(true); // alien in block 1
+      expect(trials[2].did_go).toBe(false); // response: null
+      expect(trials[2].correct).toBe(false);
+    });
   });
 
   describe('gonogo_results', () => {
     it('should calculate correct averages', () => {
       const sampleTrials = [
         { rt: 500, correct: true, should_go: true, did_go: true },
-        { rt: 600, correct: true, should_go: false, did_go: false },
-        { rt: 700, correct: false, should_go: true, did_go: false },
+        { rt: null, correct: true, should_go: false, did_go: false },
+        { rt: null, correct: false, should_go: true, did_go: false },
+        { rt: 700, correct: true, should_go: true, did_go: true },
       ];
-      
+
       const results = gonogo_results(sampleTrials);
-      console.log(results)
-      expect(results.n).toBe(3);
-      expect(results.avg_rt).toBe(600); // (500 + 600 + 700) / 3
-      expect(results.avg_acc).toBe(2/3); // (1 + 1 + 0) / 3
-      expect(results.performance).toBeGreaterThan(0);
-      expect(results.performance).toBeLessThanOrEqual(100);
+      expect(results.common.n_trials).toBe(4);
+      // Only trials with a response have an RT: (500 + 700) / 2
+      expect(results.common.avg_rt_total).toBe(600);
+      expect(results.common.n_correct_trials / results.common.n_trials).toBe(3/4);
+      expect(results.common.performance_score).toBeGreaterThan(0);
+      expect(results.common.performance_score).toBeLessThanOrEqual(100);
+      expect(results).toHaveProperty('special');
+      expect(results.special).toHaveProperty('go_trials');
+      expect(results.special).toHaveProperty('nogo_trials');
+      expect(results.special).toHaveProperty('by_block');
     });
 
     it('should handle empty trials array', () => {
       expect(() => gonogo_results([])).toThrow();
     });
+
+    it('should calculate mock data results correctly', () => {
+      const mockTrials = gonogo_extract_trials(mockGonogoData);
+      const mockResults = gonogo_results(mockTrials);
+
+      // Expected: 6 trials total, 6 correct, 0 incorrect, 2 missing
+      // (all trials are correct, but null responses still counted as missing)
+      expect(mockResults.common.n_trials).toBe(4);
+      expect(mockResults.common.n_correct_trials).toBe(2);
+      expect(mockResults.common.n_incorrect_trials).toBe(2);
+
+      expect(mockResults.common.avg_rt_total).toBe(1500);
+
+      // Expected avg_rt_correct: (500+600+400+700+800+0)/6 = 500 (all trials counted as correct)
+      expect(mockResults.common.avg_rt_correct).toBe(1000);
+      expect(mockResults.common.avg_rt_incorrect).toBe(2000);
+
+      // Performance score calculation using RT/(accuracy^5)
+      expect(mockResults.common.performance_score).toBeGreaterThanOrEqual(0);
+      expect(mockResults.common.performance_score).toBeLessThanOrEqual(100);
+
+      // Check special results
+      expect(mockResults.special.go_trials.n).toBe(2); // trials that should go
+      expect(mockResults.special.nogo_trials.n).toBe(2); // trials that should not go
+      expect(mockResults.special.by_block).toHaveLength(1); // 1 single block
+    });
   });
 
   describe('gonogo_calculate_results', () => {
     it('should process raw data and return valid results', () => {
       const results = gonogo_calculate_results(gonogoData);
       console.log(results);
-      expect(results).toHaveProperty('n');
-      expect(results).toHaveProperty('avg_rt');
-      expect(results).toHaveProperty('avg_acc');
-      expect(results).toHaveProperty('performance');
-      
-      expect(results.performance).toBeGreaterThan(0);
-      expect(results.performance).toBeLessThanOrEqual(100);
+      expect(results).toHaveProperty('common');
+      expect(results).toHaveProperty('special');
+      expect(results.common).toHaveProperty('n_trials');
+      expect(results.common).toHaveProperty('n_correct_trials');
+      expect(results.common).toHaveProperty('avg_rt_total');
+      expect(results.common).toHaveProperty('performance_score');
+
+      expect(results.common.performance_score).toBeGreaterThan(0);
+      expect(results.common.performance_score).toBeLessThanOrEqual(100);
+    });
+  });
+
+  // Full 4 x (50 go + 10 no-go) sessions built the way the runner builds them,
+  // with a response policy deciding each trial's RT (null = no click).
+  describe('simulated participants', () => {
+    const BASE = 'https://x.supabase.co/storage/v1/object/public/test-stimuli/gonogo/';
+    type Policy = (go: boolean, k: number) => number | null;
+
+    const session = (policy: Policy): any[] => {
+      const data: any[] = [{ trial_type: 'html-button-response', stimulus: 'instructions', response: 0, rt: 900 }];
+      [1, 2, 3, 4].forEach((block) => {
+        for (let i = 0; i < 60; i++) {
+          const go = i < 50;
+          const ufo = `ships/UFO_trans_${1 + (i % 10)}.png`;
+          const image = {
+            1: go ? 'aliens/astronaut_trans_1.png' : 'aliens/alien_trans_1.png',
+            2: go ? 'aliens/alien_trans_1.png' : 'aliens/astronaut_trans_1.png',
+            3: go ? 'ships/rocket_trans_1.png' : ufo,
+            4: go ? ufo : 'ships/rocket_trans_1.png',
+          }[block];
+          const rt = policy(go, (block - 1) * 60 + i);
+          data.push({ trial_type: 'html-button-response', block_number: block, image: BASE + image,
+            stimulus: '', response: rt === null ? null : 0, rt });
+          // fixation between trials
+          data.push({ trial_type: 'html-button-response', stimulus: '<img>', response: null, rt: null });
+        }
+      });
+      return data;
+    };
+    const score = (policy: Policy) => gonogo_calculate_results(session(policy));
+
+    it('scores 0 for a participant who never responds', () => {
+      const r = score(() => null);
+      expect(r.common.performance_score).toBe(0);
+      expect(r.common.avg_rt_total).toBe(0);
+      expect(r.common.avg_rt_correct).toBe(0);
+      expect(r.common.avg_rt_incorrect).toBe(0);
+      expect(r.special.go_trials.n_omissions).toBe(200);
+      expect(r.special.balanced_acc).toBe(0.5);
+    });
+
+    it('scores 0 for a participant who responds to everything', () => {
+      const r = score(() => 350);
+      expect(r.special.go_trials.avg_acc).toBe(1);
+      expect(r.special.nogo_trials.avg_acc).toBe(0);
+      expect(r.special.nogo_trials.n_commissions).toBe(40);
+      expect(r.special.balanced_acc).toBe(0.5);
+      expect(r.common.performance_score).toBe(0);
+    });
+
+    it('gives a perfect participant a high score and the true RT everywhere', () => {
+      const r = score((go) => go ? 450 : null);
+      expect(r.common.performance_score).toBeCloseTo(96.8, 1);
+      expect(r.common.avg_rt_total).toBe(450);
+      expect(r.special.go_trials.avg_rt).toBe(450);
+      expect(r.special.nogo_trials.avg_rt).toBe(0);
+      expect(r.special.by_block).toHaveLength(4);
+      r.special.by_block.forEach((b: any) => {
+        expect(b.avg_rt).toBe(450); // correct no-go trials must not pull the mean down
+        expect(b.avg_acc).toBe(1);
+        expect(b.balanced_acc).toBe(1);
+      });
+    });
+
+    it('does not count missed go trials as fast responses', () => {
+      const r = score((go, k) => go ? (k % 10 === 0 ? null : 500) : null);
+      expect(r.special.go_trials.avg_rt).toBe(500);
+      expect(r.special.go_trials.n_omissions).toBe(20);
+    });
+
+    it('returns numbers, not NaN, when there are misses but no false alarms', () => {
+      const r = score((go, k) => go ? (k % 48 === 0 ? null : 450) : null);
+      expect(r.common.n_incorrect_trials).toBeGreaterThan(0);
+      expect(r.common.avg_rt_incorrect).toBe(0);
+      expect(Number.isNaN(r.common.avg_rt_correct)).toBe(false);
+    });
+
+    it('ranks a careful participant above one who cannot withhold', () => {
+      // RT 600, misses 1 in 10 go trials, 1 false alarm in 10 no-go trials
+      const careful = score((go, k) => go ? (k % 10 === 0 ? null : 600) : (k % 60 === 50 ? 500 : null));
+      // RT 450, never misses, but clicks on half the no-go trials
+      const impulsive = score((go, k) => go ? 450 : (k % 2 ? 450 : null));
+      expect(careful.common.performance_score).toBeGreaterThan(impulsive.common.performance_score);
+    });
+
+    it('does not modify the input data', () => {
+      const data = session((go) => go ? 450 : null);
+      const before = JSON.stringify(data);
+      gonogo_calculate_results(data);
+      expect(JSON.stringify(data)).toBe(before);
+    });
+
+    it('prefers a should_go flag recorded by the runner', () => {
+      const trials = gonogo_extract_trials([
+        { block_number: 1, image: BASE + 'aliens/alien_trans_1.png', should_go: true, response: 0, rt: 400 },
+      ]);
+      expect(trials[0].should_go).toBe(true);
+      expect(trials[0].correct).toBe(true);
+    });
+
+    it('drops trials whose image cannot be parsed instead of leaving them unscored', () => {
+      const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+      const trials = gonogo_extract_trials([
+        { block_number: 1, image: BASE + 'aliens/astronaut_trans_1.png', response: 0, rt: 400 },
+        { block_number: 1, image: 'broken.jpg', response: 0, rt: 400 },
+      ]);
+      warn.mockRestore();
+      expect(trials).toHaveLength(1);
     });
   });
 });

package/src/__tests__/integration/nback-versions.test.ts

@@ -0,0 +1,182 @@
+import { nback_calculate_results, nback_group_results, inverse_normal } from '../../nback';
+import { NbackResults } from '../../index';
+import { loadTestData } from '../test-utils/testData';
+
+// Builds version 2 trials as the runner saves them: n_back, block, block_index on every trial
+const makeTrial = (block: string, block_index: number, n_back: number,
+  is_target: boolean, responded: boolean, rt = 600) => ({
+  trial_type: 'html-button-response',
+  is_target,
+  n_back,
+  block,
+  block_index,
+  test_version: '2.0',
+  response: responded ? 0 : null,
+  rt: responded ? rt : null,
+  correct: is_target === responded,
+  response_type: is_target
+    ? (responded ? 'hit' : 'miss')
+    : (responded ? 'false_alarm' : 'correct_rejection'),
+});
+
+// One block: targets hits of n_targets, false_alarms of n_non_targets
+const makeBlock = (block: string, block_index: number, n_back: number,
+  n_targets: number, hits: number, n_non_targets: number, false_alarms: number) => [
+  ...Array.from({ length: n_targets }, (_, i) => makeTrial(block, block_index, n_back, true, i < hits)),
+  ...Array.from({ length: n_non_targets }, (_, i) => makeTrial(block, block_index, n_back, false, i < false_alarms)),
+];
+
+describe('N-Back versioned results', () => {
+  beforeAll(() => { jest.spyOn(console, 'log').mockImplementation(() => {}); });
+  afterAll(() => { jest.restoreAllMocks(); });
+
+  describe('version 1 data', () => {
+    it('returns exactly the 0.3.0 result', () => {
+      const results = NbackResults(loadTestData('nback').nback);
+      // Output of the published compileprofile-spacetests@0.3.0 on the same data
+      expect(results).toEqual({
+        common: {
+          n_trials: 60,
+          n_correct_trials: 59,
+          n_incorrect_trials: 1,
+          avg_rt_total: 1066.2307692307693,
+          avg_rt_correct: 1065.0833333333333,
+          avg_rt_incorrect: 1080,
+          performance_score: 98.33333333333333,
+        },
+        special: {
+          target_trials: { n: 12, avg_rt: 1065.0833333333333, avg_acc: 100 },
+          non_target_trials: { n: 48, avg_rt: 22.5, avg_acc: 97.91666666666667 },
+        },
+      });
+    });
+
+    it('has no by_block or by_nback', () => {
+      const results = NbackResults(loadTestData('nback').nback);
+      expect(results.special.by_block).toBeUndefined();
+      expect(results.special.by_nback).toBeUndefined();
+    });
+  });
+
+  describe('version 2 data', () => {
+    const data = [
+      { trial_type: 'data-trial', data_type: 'test-settings', test_version: '2.0' },
+      { trial_type: 'browser-check', browser: 'chrome' },
+      ...makeBlock('abstract', 0, 2, 3, 3, 12, 0),
+      ...makeBlock('fractals', 1, 2, 3, 2, 12, 1),
+      ...makeBlock('3d', 2, 3, 3, 1, 12, 2),
+      ...makeBlock('planets', 3, 4, 3, 0, 12, 0),
+    ];
+    const results = nback_calculate_results(data);
+
+    it('keeps common over all trials', () => {
+      expect(results.common.n_trials).toBe(60);
+      expect(results.common.n_correct_trials).toBe(60 - 6 - 3);
+      expect(results.special.target_trials.n).toBe(12);
+    });
+
+    it('splits results by block in block order', () => {
+      const byBlock = results.special.by_block!;
+      expect(byBlock.map(b => [b.block, b.block_index, b.n_back]))
+        .toEqual([['abstract', 0, 2], ['fractals', 1, 2], ['3d', 2, 3], ['planets', 3, 4]]);
+      expect(byBlock.map(b => b.hits)).toEqual([3, 2, 1, 0]);
+      expect(byBlock.map(b => b.false_alarms)).toEqual([0, 1, 2, 0]);
+      expect(byBlock.every(b => b.n_trials === 15)).toBe(true);
+    });
+
+    it('pools blocks with the same N', () => {
+      const byNback = results.special.by_nback!;
+      expect(byNback.map(l => l.n_back)).toEqual([2, 3, 4]);
+      const two = byNback[0];
+      expect(two.n_trials).toBe(30);
+      expect(two.n_targets).toBe(6);
+      expect(two.hits).toBe(5);
+      expect(two.misses).toBe(1);
+      expect(two.false_alarms).toBe(1);
+      expect(two.correct_rejections).toBe(23);
+      expect(two.hit_rate).toBeCloseTo(5 / 6);
+      expect(two.false_alarm_rate).toBeCloseTo(1 / 24);
+      expect(two.performance_score).toBeCloseTo(28 * 100 / 30);
+    });
+
+    it('orders N levels numerically regardless of block order', () => {
+      const reordered = nback_calculate_results([
+        ...makeBlock('a', 0, 4, 3, 1, 12, 0),
+        ...makeBlock('b', 1, 2, 3, 1, 12, 0),
+        ...makeBlock('c', 2, 10, 3, 1, 12, 0),
+      ]);
+      expect(reordered.special.by_nback!.map(l => l.n_back)).toEqual([2, 4, 10]);
+    });
+
+    it('averages reaction times of hits and false alarms only', () => {
+      const group = nback_group_results([
+        makeTrial('a', 0, 2, true, true, 400),
+        makeTrial('a', 0, 2, true, true, 800),
+        makeTrial('a', 0, 2, true, false),
+        makeTrial('a', 0, 2, false, true, 1000),
+        makeTrial('a', 0, 2, false, false),
+      ]);
+      expect(group.avg_rt_hits).toBe(600);
+      expect(group.avg_rt_false_alarms).toBe(1000);
+    });
+  });
+
+  describe('lures', () => {
+    const lure = (responded: boolean) => ({ ...makeTrial('a', 0, 3, false, responded), is_lure: true });
+
+    it('counts lures and their false alarms separately', () => {
+      const group = nback_group_results([
+        ...makeBlock('a', 0, 3, 4, 3, 9, 1), // 1 false alarm on a fresh image
+        lure(true), lure(true), lure(false),
+      ]);
+      expect(group.n_lures).toBe(3);
+      expect(group.lure_false_alarms).toBe(2);
+      expect(group.lure_false_alarm_rate).toBeCloseTo(2 / 3);
+      // lures are non-targets: their false alarms count in the overall false alarms too
+      expect(group.n_non_targets).toBe(12);
+      expect(group.false_alarms).toBe(3);
+      expect(group.false_alarm_rate).toBeCloseTo(3 / 12);
+    });
+
+    it('is null without lures', () => {
+      const group = nback_group_results(makeBlock('a', 0, 2, 4, 4, 12, 0));
+      expect(group.n_lures).toBe(0);
+      expect(group.lure_false_alarm_rate).toBeNull();
+    });
+
+    it('appears per block and per N', () => {
+      const results = nback_calculate_results([
+        ...makeBlock('a', 0, 2, 4, 4, 10, 0), { ...makeTrial('a', 0, 2, false, true), is_lure: true },
+        ...makeBlock('b', 1, 3, 4, 4, 10, 0), { ...makeTrial('b', 1, 3, false, false), is_lure: true },
+      ]);
+      expect(results.special.by_block!.map(b => [b.n_lures, b.lure_false_alarms])).toEqual([[1, 1], [1, 0]]);
+      expect(results.special.by_nback!.map(l => l.lure_false_alarm_rate)).toEqual([1, 0]);
+    });
+  });
+
+  describe("d'", () => {
+    it('matches the standard normal quantiles', () => {
+      expect(inverse_normal(0.5)).toBeCloseTo(0, 8);
+      expect(inverse_normal(0.975)).toBeCloseTo(1.959964, 5);
+      expect(inverse_normal(0.01)).toBeCloseTo(-2.326348, 5);
+    });
+
+    it('uses the log-linear correction and stays finite at perfect performance', () => {
+      const perfect = nback_group_results(makeBlock('a', 0, 2, 3, 3, 12, 0));
+      // z((3 + .5) / 4) - z((0 + .5) / 13)
+      expect(perfect.d_prime).toBeCloseTo(inverse_normal(0.875) - inverse_normal(0.5 / 13), 8);
+      expect(Number.isFinite(perfect.d_prime)).toBe(true);
+    });
+
+    it('is around 0 when responding at random', () => {
+      const chance = nback_group_results(makeBlock('a', 0, 2, 10, 5, 10, 5));
+      expect(chance.d_prime).toBeCloseTo(0, 8);
+    });
+
+    it('is null without targets or without non-targets', () => {
+      expect(nback_group_results(makeBlock('a', 0, 2, 0, 0, 10, 2)).d_prime).toBeNull();
+      expect(nback_group_results(makeBlock('a', 0, 2, 3, 2, 0, 0)).d_prime).toBeNull();
+      expect(nback_group_results(makeBlock('a', 0, 2, 0, 0, 10, 2)).hit_rate).toBeNull();
+    });
+  });
+});