2330 lines
101 KiB
Plaintext
2330 lines
101 KiB
Plaintext
|
||
> 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%)
|