> find-word@0.1.0 test > vitest run tests/content.test.ts tests/game.test.ts RUN v5.0.4 /home/hermes/worktrees/find-word-v0.1 ❯ tests/game.test.ts (7 tests | 1 failed) 21ms ❯ 출제와 정답 판정 (4) × 실제 보기에 있는 경쟁 단어를 문장에 넣고 청취 연산별 순서를 유지한다 10ms ❯ tests/content.test.ts (15 tests | 11 failed) 98ms ❯ 저장된 문제·환경 데이터 (15) × 열 패턴은 서로 다른 청취 연산 mechanic을 하나씩 가진다 11ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 14ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 9ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 8ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 9ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 7ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 6ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 6ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 7ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 8ms × undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 6ms ⎯⎯⎯⎯⎯⎯ Failed Tests 12 ⎯⎯⎯⎯⎯⎯⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > 열 패턴은 서로 다른 청취 연산 mechanic을 하나씩 가진다 AssertionError: expected Set{ undefined } to deeply equal Set{ 'direct-target', …(9) } - Expected + Received Set { - "conditional-cue", - "correction", - "direct-target", - "distractor-password", - "first", - "ignore-then-remember", - "last", - "middle", - "repetition", - "spatial-right-cue", + undefined, } ❯ tests/content.test.ts:15:54 13| it("열 패턴은 서로 다른 청취 연산 mechanic을 하나씩 가진다", () => { 14| expect(PATTERNS).toHaveLength(10); 15| expect(new Set(PATTERNS.map((p) => p.mechanic))).toEqual(new Set([ | ^ 16| "direct-target", "distractor-password", "ignore-then-remember", … 17| "last", "middle", "repetition", "correction", "conditional-cue",… ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'direct-target' // Object.is equality - Expected: "direct-target" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사과' ] - Expected + Received - [ - "사과", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to have a length of 1 but got +0 - Expected + Received - 1 + 0 ❯ tests/content.test.ts:47:66 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. 47| expect.soft(heard.filter((word) => word === entry.answer)).toHav… | ^ 48| } 49| }); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[4/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '바다' ] - Expected + Received - [ - "바다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[5/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나무' ] - Expected + Received - [ - "나무", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[6/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '모자' ] - Expected + Received - [ - "모자", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[7/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '우산' ] - Expected + Received - [ - "우산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[8/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '시장' ] - Expected + Received - [ - "시장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[9/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '기름' ] - Expected + Received - [ - "기름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[10/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '소리' ] - Expected + Received - [ - "소리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[11/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '고기' ] - Expected + Received - [ - "고기", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[12/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '가구' ] - Expected + Received - [ - "가구", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[13/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'distractor-password' // Object.is equality - Expected: "distractor-password" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[14/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '들은 비밀 암호는 무엇인가요?' to match /진짜 암호/ - Expected: /진짜 암호/ + Received: "들은 비밀 암호는 무엇인가요?" ❯ tests/content.test.ts:36:35 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); | ^ 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); 38| for (const entry of WORDS) { ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[15/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '비밀 암호는 {word}입니다.' to match /연습 암호/ - Expected: /연습 암호/ + Received: "비밀 암호는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[16/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '비밀 암호는 {word}입니다.' to match /진짜 암호/ - Expected: /진짜 암호/ + Received: "비밀 암호는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[17/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '다과', '사과' ] - Expected + Received - [ - "다과", - "사과", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[18/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사다', '바다' ] - Expected + Received - [ - "사다", - "바다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[19/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나루', '나무' ] - Expected + Received - [ - "나루", - "나무", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[20/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '포자', '모자' ] - Expected + Received - [ - "포자", - "모자", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[21/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '부산', '우산' ] - Expected + Received - [ - "부산", - "우산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[22/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '지장', '시장' ] - Expected + Received - [ - "지장", - "시장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[23/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '이름', '기름' ] - Expected + Received - [ - "이름", - "기름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[24/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '오리', '소리' ] - Expected + Received - [ - "오리", - "소리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[25/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '보기', '고기' ] - Expected + Received - [ - "보기", - "고기", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[26/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '하구', '가구' ] - Expected + Received - [ - "하구", - "가구", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[27/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'ignore-then-remember' // Object.is equality - Expected: "ignore-then-remember" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[28/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '꼭 기억할 단어는 {word}입니다.' to match /잊으세요.*이제.*기억하세요/ - Expected: /잊으세요.*이제.*기억하세요/ + Received: "꼭 기억할 단어는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[29/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'first' // Object.is equality - Expected: "first" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[30/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '첫 번째는 {word}, 두 번째는 달입니다.' to match /세 단어.*첫/ - Expected: /세 단어.*첫/ + Received: "첫 번째는 {word}, 두 번째는 달입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[31/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사과', '다과', '사고' ] - Expected + Received - [ - "사과", - "다과", - "사고", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[32/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '바다', '사다', '보다' ] - Expected + Received - [ - "바다", - "사다", - "보다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[33/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나무', '나루', '너무' ] - Expected + Received - [ - "나무", - "나루", - "너무", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[34/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '모자', '포자', '모조' ] - Expected + Received - [ - "모자", - "포자", - "모조", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[35/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '우산', '부산', '오산' ] - Expected + Received - [ - "우산", - "부산", - "오산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[36/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '시장', '지장', '사장' ] - Expected + Received - [ - "시장", - "지장", - "사장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[37/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '기름', '이름', '거름' ] - Expected + Received - [ - "기름", - "이름", - "거름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[38/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '소리', '오리', '수리' ] - Expected + Received - [ - "소리", - "오리", - "수리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[39/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '고기', '보기', '고개' ] - Expected + Received - [ - "고기", - "보기", - "고개", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[40/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '가구', '하구', '가교' ] - Expected + Received - [ - "가구", - "하구", - "가교", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[41/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'last' // Object.is equality - Expected: "last" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[42/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '처음 단어는 별, 마지막 단어는 {word}입니다.' to match /세 단어.*마지막/ - Expected: /세 단어.*마지막/ + Received: "처음 단어는 별, 마지막 단어는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[43/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '다과', '사고', '사과' ] - Expected + Received - [ - "다과", - "사고", - "사과", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[44/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사다', '보다', '바다' ] - Expected + Received - [ - "사다", - "보다", - "바다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[45/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나루', '너무', '나무' ] - Expected + Received - [ - "나루", - "너무", - "나무", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[46/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '포자', '모조', '모자' ] - Expected + Received - [ - "포자", - "모조", - "모자", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[47/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '부산', '오산', '우산' ] - Expected + Received - [ - "부산", - "오산", - "우산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[48/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '지장', '사장', '시장' ] - Expected + Received - [ - "지장", - "사장", - "시장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[49/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '이름', '거름', '기름' ] - Expected + Received - [ - "이름", - "거름", - "기름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[50/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '오리', '수리', '소리' ] - Expected + Received - [ - "오리", - "수리", - "소리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[51/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '보기', '고개', '고기' ] - Expected + Received - [ - "보기", - "고개", - "고기", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[52/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '하구', '가교', '가구' ] - Expected + Received - [ - "하구", - "가교", - "가구", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[53/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'middle' // Object.is equality - Expected: "middle" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[54/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '별, {word}, 달. 가운데 단어를 기억하세요.' to match /세 단어.*가운데/ - Expected: /세 단어.*가운데/ + Received: "별, {word}, 달. 가운데 단어를 기억하세요." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[55/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '다과', '사과', '사고' ] - Expected + Received - [ - "다과", - "사과", - "사고", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[56/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사다', '바다', '보다' ] - Expected + Received - [ - "사다", - "바다", - "보다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[57/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나루', '나무', '너무' ] - Expected + Received - [ - "나루", - "나무", - "너무", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[58/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '포자', '모자', '모조' ] - Expected + Received - [ - "포자", - "모자", - "모조", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[59/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '부산', '우산', '오산' ] - Expected + Received - [ - "부산", - "우산", - "오산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[60/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '지장', '시장', '사장' ] - Expected + Received - [ - "지장", - "시장", - "사장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[61/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '이름', '기름', '거름' ] - Expected + Received - [ - "이름", - "기름", - "거름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[62/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '오리', '소리', '수리' ] - Expected + Received - [ - "오리", - "소리", - "수리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[63/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '보기', '고기', '고개' ] - Expected + Received - [ - "보기", - "고기", - "고개", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[64/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '하구', '가구', '가교' ] - Expected + Received - [ - "하구", - "가구", - "가교", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[65/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'repetition' // Object.is equality - Expected: "repetition" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[66/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '{word}. 다시 한번, {word}.' to match /두 번/ - Expected: /두 번/ + Received: "{word}. 다시 한번, {word}." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[67/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사과', '다과', '사과', '사고' ] - Expected + Received - [ - "사과", - "다과", - "사과", - "사고", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[68/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to have a length of 2 but got +0 - Expected + Received - 2 + 0 ❯ tests/content.test.ts:47:66 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. 47| expect.soft(heard.filter((word) => word === entry.answer)).toHav… | ^ 48| } 49| }); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[69/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '바다', '사다', '바다', '보다' ] - Expected + Received - [ - "바다", - "사다", - "바다", - "보다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[70/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나무', '나루', '나무', '너무' ] - Expected + Received - [ - "나무", - "나루", - "나무", - "너무", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[71/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '모자', '포자', '모자', '모조' ] - Expected + Received - [ - "모자", - "포자", - "모자", - "모조", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[72/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '우산', '부산', '우산', '오산' ] - Expected + Received - [ - "우산", - "부산", - "우산", - "오산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[73/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '시장', '지장', '시장', '사장' ] - Expected + Received - [ - "시장", - "지장", - "시장", - "사장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[74/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '기름', '이름', '기름', '거름' ] - Expected + Received - [ - "기름", - "이름", - "기름", - "거름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[75/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '소리', '오리', '소리', '수리' ] - Expected + Received - [ - "소리", - "오리", - "소리", - "수리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[76/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '고기', '보기', '고기', '고개' ] - Expected + Received - [ - "고기", - "보기", - "고기", - "고개", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[77/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '가구', '하구', '가구', '가교' ] - Expected + Received - [ - "가구", - "하구", - "가구", - "가교", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[78/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'correction' // Object.is equality - Expected: "correction" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[79/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '말을 바로잡아 알려준 단어는 무엇인가요?' to match /정정/ - Expected: /정정/ + Received: "말을 바로잡아 알려준 단어는 무엇인가요?" ❯ tests/content.test.ts:36:35 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); | ^ 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); 38| for (const entry of WORDS) { ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[80/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '달이 아니라 {word}입니다.' to match /아니.*잘못.*정정/ - Expected: /아니.*잘못.*정정/ + Received: "달이 아니라 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[81/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'conditional-cue' // Object.is equality - Expected: "conditional-cue" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[82/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '에스가 메시지로 남긴 단어는 무엇인가요?' to match /신호/ - Expected: /신호/ + Received: "에스가 메시지로 남긴 단어는 무엇인가요?" ❯ tests/content.test.ts:36:35 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); | ^ 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); 38| for (const entry of WORDS) { ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[83/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '에스가 남긴 메시지는 {word}입니다.' to match /초록 불이면 앞 단어/ - Expected: /초록 불이면 앞 단어/ + Received: "에스가 남긴 메시지는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[84/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '에스가 남긴 메시지는 {word}입니다.' to match /빨간 불이면 뒤 단어/ - Expected: /빨간 불이면 뒤 단어/ + Received: "에스가 남긴 메시지는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[85/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '에스가 남긴 메시지는 {word}입니다.' to match /지금은 빨간 불/ - Expected: /지금은 빨간 불/ + Received: "에스가 남긴 메시지는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[86/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected undefined to be 'spatial-right-cue' // Object.is equality - Expected: "spatial-right-cue" + Received: undefined ❯ tests/content.test.ts:35:35 33| ])("$mechanic의 열 문장은 해당 청취 의도로만 답을 고를 수 있다", ({ id, mechanic, order,… 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); | ^ 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[87/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '이번 임무의 단서는 무엇인가요?' to match /오른쪽/ - Expected: /오른쪽/ + Received: "이번 임무의 단서는 무엇인가요?" ❯ tests/content.test.ts:36:35 34| const pattern = PATTERNS.find((p) => p.id === id)!; 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); | ^ 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); 38| for (const entry of WORDS) { ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[88/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected '이번 임무의 단서는 {word}입니다.' to match /오른쪽 표지.*왼쪽 표지/ - Expected: /오른쪽 표지.*왼쪽 표지/ + Received: "이번 임무의 단서는 {word}입니다." ❯ tests/content.test.ts:37:57 35| expect.soft(pattern.mechanic).toBe(mechanic); 36| expect.soft(pattern.question).toMatch(question); 37| cues.forEach((cue) => expect.soft(pattern.sentence).toMatch(cue)); | ^ 38| for (const entry of WORDS) { 39| const choices = [entry.answer, ...entry.distractors.map((d) => d… ❯ tests/content.test.ts:37:10 ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[89/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '사과', '다과' ] - Expected + Received - [ - "사과", - "다과", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[90/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '바다', '사다' ] - Expected + Received - [ - "바다", - "사다", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[91/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '나무', '나루' ] - Expected + Received - [ - "나무", - "나루", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[92/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '모자', '포자' ] - Expected + Received - [ - "모자", - "포자", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[93/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '우산', '부산' ] - Expected + Received - [ - "우산", - "부산", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[94/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '시장', '지장' ] - Expected + Received - [ - "시장", - "지장", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[95/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '기름', '이름' ] - Expected + Received - [ - "기름", - "이름", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[96/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '소리', '오리' ] - Expected + Received - [ - "소리", - "오리", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[97/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '고기', '보기' ] - Expected + Received - [ - "고기", - "보기", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[98/228]⎯ FAIL tests/content.test.ts > 저장된 문제·환경 데이터 > undefined 열 문장은 해당 청취 의도로만 답을 고를 수 있다 AssertionError: expected [] to deeply equal [ '가구', '하구' ] - Expected + Received - [ - "가구", - "하구", - ] + [] ❯ tests/content.test.ts:44:26 42| .replaceAll("{distractor2}", choices[2]!); 43| const heard = [...sentence.matchAll(/‘([^’]+)’/g)].map((match) =… 44| expect.soft(heard).toEqual(order.map((index) => choices[index])); | ^ 45| expect(sentence).not.toMatch(/[{}]/); 46| // 인용 단어 목록 안에서 반복 목표는 정확히 두 번, 나머지는 한 번이다. ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[99/228]⎯ FAIL tests/game.test.ts > 출제와 정답 판정 > 실제 보기에 있는 경쟁 단어를 문장에 넣고 청취 연산별 순서를 유지한다 AssertionError: expected '비밀 암호는 사과입니다.' to contain '‘사과’' Expected: "‘사과’" Received: "비밀 암호는 사과입니다." ❯ tests/game.test.ts:18:28 16| for (const q of createQuestions(seed, "choice")) { 17| expect(q.sentence).not.toMatch(/[{}]/); 18| expect(q.sentence).toContain(`‘${q.word.answer}’`); | ^ 19| if (q.pattern.id !== "luck") { 20| expect(q.sentence).toContain(`‘${q.word.distractors[0]!.word… ⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[100/228]⎯ Test Files 2 failed (2) Tests 12 failed | 10 passed (22) Start at 05:53:17 Duration 1.83s (environment 75%, setup 13%, tests 6%, transform 4%, import 1%, worker 1%)