redscript-mc 2.6.2 → 3.0.0

package/src/__tests__/compiler/tuple-type.test.ts

@@ -0,0 +1,263 @@
+/**
+ * Tests for tuple types and destructuring.
+ *
+ * RedScript supports:
+ *   - Tuple type annotations:  (int, int)
+ *   - Tuple literal expressions: (a, b)
+ *   - Destructuring let-bindings: let (lo, hi) = expr
+ *   - Functions that return tuples: fn foo(): (int, int) { return (a, b) }
+ */
+
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { lowerToHIR } from '../../hir/lower'
+import { lowerToMIR } from '../../mir/lower'
+import { verifyMIR } from '../../mir/verify'
+import { compile } from '../../emit/compile'
+import type { MIRFunction } from '../../mir/types'
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function parse(source: string) {
+  const tokens = new Lexer(source).tokenize()
+  return new Parser(tokens, source).parse('test')
+}
+
+function lowerFn(source: string, fnName: string): MIRFunction {
+  const ast = parse(source)
+  const hir = lowerToHIR(ast)
+  const mir = lowerToMIR(hir)
+  expect(verifyMIR(mir)).toEqual([])
+  const fn = mir.functions.find(f => f.name === fnName)
+  expect(fn).toBeDefined()
+  return fn!
+}
+
+// ---------------------------------------------------------------------------
+// 1. Parser: tuple type annotation  (int, int)
+// ---------------------------------------------------------------------------
+
+const TUPLE_TYPE_SRC = `
+fn min_max(arr: int[]): (int, int) {
+  let min: int = arr[0]
+  let max: int = arr[0]
+  return (min, max)
+}
+`
+
+describe('tuple type — parser', () => {
+  test('parses function return type as tuple', () => {
+    const ast = parse(TUPLE_TYPE_SRC)
+    const fn = ast.declarations[0]
+    expect(fn.returnType).toMatchObject({ kind: 'tuple', elements: [
+      { kind: 'named', name: 'int' },
+      { kind: 'named', name: 'int' },
+    ] })
+  })
+
+  test('return statement contains a tuple_lit expression', () => {
+    const ast = parse(TUPLE_TYPE_SRC)
+    const fn = ast.declarations[0]
+    const ret = fn.body[fn.body.length - 1]
+    expect(ret.kind).toBe('return')
+    if (ret.kind !== 'return') throw new Error()
+    expect(ret.value).toMatchObject({ kind: 'tuple_lit', elements: [
+      { kind: 'ident', name: 'min' },
+      { kind: 'ident', name: 'max' },
+    ] })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 2. Parser: let destructuring  let (a, b) = expr
+// ---------------------------------------------------------------------------
+
+const DESTRUCT_SRC = `
+fn test() {
+  let (lo, hi) = (1, 2)
+}
+`
+
+describe('tuple destructuring — parser', () => {
+  test('parses let_destruct with two bindings', () => {
+    const ast = parse(DESTRUCT_SRC)
+    const fn = ast.declarations[0]
+    const stmt = fn.body[0]
+    expect(stmt).toMatchObject({
+      kind: 'let_destruct',
+      names: ['lo', 'hi'],
+    })
+  })
+
+  test('initializer is a tuple_lit', () => {
+    const ast = parse(DESTRUCT_SRC)
+    const fn = ast.declarations[0]
+    const stmt = fn.body[0] as any
+    expect(stmt.init).toMatchObject({ kind: 'tuple_lit', elements: [
+      { kind: 'int_lit', value: 1 },
+      { kind: 'int_lit', value: 2 },
+    ] })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 3. Parser: three-element tuple
+// ---------------------------------------------------------------------------
+
+// Note: (1, 2, 3) with three int literals is ambiguous with BlockPos literal in the parser.
+// Use variable names to force tuple interpretation.
+const THREE_TUPLE_SRC = `
+fn triple(): (int, int, int) {
+  let x: int = 1
+  let y: int = 2
+  let z: int = 3
+  return (x, y, z)
+}
+
+fn caller() {
+  let (a, b, c) = triple()
+}
+`
+
+describe('three-element tuple', () => {
+  test('return type has three elements', () => {
+    const ast = parse(THREE_TUPLE_SRC)
+    const fn = ast.declarations[0]
+    expect(fn.returnType).toMatchObject({
+      kind: 'tuple',
+      elements: [
+        { kind: 'named', name: 'int' },
+        { kind: 'named', name: 'int' },
+        { kind: 'named', name: 'int' },
+      ],
+    })
+  })
+
+  test('destructuring binds three names', () => {
+    const ast = parse(THREE_TUPLE_SRC)
+    const caller = ast.declarations[1]
+    const stmt = caller.body[0] as any
+    expect(stmt.kind).toBe('let_destruct')
+    expect(stmt.names).toEqual(['a', 'b', 'c'])
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 4. MIR: tuple return emits __rf_0 / __rf_1 copies
+// ---------------------------------------------------------------------------
+
+describe('tuple return — MIR', () => {
+  test('MIR for return (a, b) emits copies to __rf_0 and __rf_1', () => {
+    const fn = lowerFn(TUPLE_TYPE_SRC, 'min_max')
+
+    const allInstrs = fn.blocks.flatMap(b => b.instrs)
+    const rf0 = allInstrs.find(i => i.kind === 'copy' && (i as any).dst === '__rf_0')
+    const rf1 = allInstrs.find(i => i.kind === 'copy' && (i as any).dst === '__rf_1')
+    expect(rf0).toBeDefined()
+    expect(rf1).toBeDefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 5. MIR: destructuring a tuple call — reads __rf_0, __rf_1
+// ---------------------------------------------------------------------------
+
+const CALLER_SRC = `
+fn min_max(arr: int[]): (int, int) {
+  let min: int = arr[0]
+  let max: int = arr[0]
+  return (min, max)
+}
+
+fn test() {
+  let arr = [3, 1, 4, 1, 5, 9]
+  let (lo, hi) = min_max(arr)
+}
+`
+
+describe('tuple destructuring call — MIR', () => {
+  test('MIR for let (lo, hi) = call() reads __rf_0 and __rf_1', () => {
+    const fn = lowerFn(CALLER_SRC, 'test')
+
+    const allInstrs = fn.blocks.flatMap(b => b.instrs)
+    // There must be copies from __rf_0 and __rf_1 temps
+    const readRf = allInstrs.filter(i =>
+      i.kind === 'copy' && (i as any).src?.name?.startsWith('__rf_')
+    )
+    expect(readRf.length).toBeGreaterThanOrEqual(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 6. MIR: direct tuple literal destructuring  let (a, b) = (10, 20)
+// ---------------------------------------------------------------------------
+
+const DIRECT_DESTRUCT_SRC = `
+fn test() {
+  let (a, b) = (10, 20)
+}
+`
+
+describe('direct tuple literal destructuring — MIR', () => {
+  test('MIR evaluates each element into separate temps', () => {
+    const fn = lowerFn(DIRECT_DESTRUCT_SRC, 'test')
+    const allInstrs = fn.blocks.flatMap(b => b.instrs)
+    // Constants 10 and 20 should appear in the instr stream
+    const constVals = allInstrs
+      .filter(i => i.kind === 'copy' && (i as any).src?.kind === 'const')
+      .map(i => (i as any).src.value as number)
+    expect(constVals).toContain(10)
+    expect(constVals).toContain(20)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Helpers for compile output
+// ---------------------------------------------------------------------------
+
+function compileOutput(source: string): string {
+  const result = compile(source, { namespace: 'test' })
+  // compile() returns { files: Array<{path, content}>, warnings, success }
+  const files = (result as any).files as Array<{ path: string; content: string }>
+  return files.map((f: { path: string; content: string }) => f.content).join('\n')
+}
+
+// ---------------------------------------------------------------------------
+// 7. End-to-end compile: does not throw
+// ---------------------------------------------------------------------------
+
+describe('tuple type — end-to-end compile', () => {
+  test('min_max function compiles without error', () => {
+    expect(() => compile(TUPLE_TYPE_SRC, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('full min_max + caller compiles without error', () => {
+    expect(() => compile(CALLER_SRC, { namespace: 'test' })).not.toThrow()
+  })
+
+  test('three-element tuple compiles without error', () => {
+    expect(() => compile(THREE_TUPLE_SRC, { namespace: 'test' })).not.toThrow()
+  })
+})
+
+// ---------------------------------------------------------------------------
+// 8. Compile output: tuple return generates scoreboard operations
+// ---------------------------------------------------------------------------
+
+describe('tuple return — compiled output', () => {
+  test('compiled output contains scoreboard operations for both return slots', () => {
+    const allOutput = compileOutput(TUPLE_TYPE_SRC)
+    // Tuple return compiles to scoreboard operations for ret_0 and ret_1 slots
+    expect(allOutput).toMatch(/\$ret_0/)
+    expect(allOutput).toMatch(/\$ret_1/)
+  })
+
+  test('compiled caller output references both return slots', () => {
+    const allOutput = compileOutput(CALLER_SRC)
+    // Caller reads from ret_0 / ret_1 (scoreboard-based return convention)
+    expect(allOutput).toMatch(/\$ret_0/)
+    expect(allOutput).toMatch(/\$ret_1/)
+  })
+})

package/src/__tests__/compiler/watch-decorator.test.ts

@@ -0,0 +1,72 @@
+import { compile } from '../../emit/compile'
+import { Lexer } from '../../lexer'
+import { Parser } from '../../parser'
+import { TypeChecker } from '../../typechecker'
+import type { DiagnosticError } from '../../diagnostics'
+
+function getFile(files: Array<{ path: string; content: string }>, path: string): string {
+  const file = files.find(entry => entry.path === path)
+  if (!file) {
+    throw new Error(`Missing file: ${path}\nFiles:\n${files.map(entry => entry.path).join('\n')}`)
+  }
+  return file.content
+}
+
+function parseWatchObjective(source: string): string | undefined {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return ast.declarations[0]?.watchObjective
+}
+
+function typeCheck(source: string): DiagnosticError[] {
+  const tokens = new Lexer(source).tokenize()
+  const ast = new Parser(tokens).parse('test')
+  return new TypeChecker(source).check(ast)
+}
+
+describe('@watch decorator', () => {
+  test('parser records the watched objective on the function', () => {
+    expect(parseWatchObjective(`
+      @watch("rs.kills")
+      fn on_kill() {}
+    `)).toBe('rs.kills')
+  })
+
+  test('typechecker accepts parameterless handlers and rejects parameters', () => {
+    expect(typeCheck(`
+      @watch("rs.kills")
+      fn on_kill() {
+        say("kill");
+      }
+    `)).toHaveLength(0)
+
+    const errors = typeCheck(`
+      @watch("rs.kills")
+      fn on_kill(player: Player) {}
+    `)
+    expect(errors.length).toBeGreaterThan(0)
+    expect(errors[0].message).toContain('cannot declare parameters')
+  })
+
+  test('emits watcher objective, dispatcher, and tick registration', () => {
+    const result = compile(`
+      @watch("rs.kills")
+      fn on_kill() {
+        let k: int = scoreboard_get("@s", "rs.kills");
+        if (k >= 10) {
+          title("@s", "Achievement Unlocked!");
+        }
+      }
+    `, { namespace: 'watch_test' })
+
+    const load = getFile(result.files, 'data/watch_test/function/load.mcfunction')
+    const tick = JSON.parse(getFile(result.files, 'data/minecraft/tags/function/tick.json'))
+    const watch = getFile(result.files, 'data/watch_test/function/__watch_on_kill.mcfunction')
+
+    expect(load).toContain('scoreboard objectives add __watch_on_kill_prev dummy')
+    expect(tick.values).toContain('watch_test:__watch_on_kill')
+    expect(watch).toContain('execute as @a unless score @s __watch_on_kill_prev = @s __watch_on_kill_prev run scoreboard players operation @s __watch_on_kill_prev = @s rs.kills')
+    expect(watch).toContain('execute as @a unless score @s rs.kills = @s __watch_on_kill_prev run function watch_test:on_kill')
+    expect(watch).toContain('execute as @a unless score @s rs.kills = @s __watch_on_kill_prev run scoreboard players operation @s __watch_on_kill_prev = @s rs.kills')
+  })
+})

package/src/__tests__/config/project-config.test.ts

@@ -0,0 +1,181 @@
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { loadProjectConfig, buildTomlTemplate, ProjectConfig } from '../../config/project-config'
+
+// Helper: create a temp directory tree and write files
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'redscript-config-test-'))
+}
+
+function writeToml(dir: string, content: string): void {
+  fs.writeFileSync(path.join(dir, 'redscript.toml'), content, 'utf-8')
+}
+
+afterAll(() => {
+  // Cleanup is handled per-test via individual tmpdir removal
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 1: Returns null when no redscript.toml exists
+// ──────────────────────────────────────────────────────────────────────────────
+test('returns null when no redscript.toml is found', () => {
+  const dir = makeTmpDir()
+  const result = loadProjectConfig(dir)
+  expect(result).toBeNull()
+  fs.rmSync(dir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 2: Parses [project] section correctly
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses [project] section fields correctly', () => {
+  const dir = makeTmpDir()
+  writeToml(dir, `
+[project]
+name = "my-datapack"
+namespace = "my_pack"
+mc-version = "1.21.4"
+description = "My awesome datapack"
+`)
+  const config = loadProjectConfig(dir)
+  expect(config).not.toBeNull()
+  expect(config!.project?.name).toBe('my-datapack')
+  expect(config!.project?.namespace).toBe('my_pack')
+  expect(config!.project?.['mc-version']).toBe('1.21.4')
+  expect(config!.project?.description).toBe('My awesome datapack')
+  fs.rmSync(dir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 3: Parses [compiler] section correctly
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses [compiler] section fields correctly', () => {
+  const dir = makeTmpDir()
+  writeToml(dir, `
+[compiler]
+optimization = 2
+include-dirs = ["src/shared", "src/stdlib"]
+no-dce = false
+`)
+  const config = loadProjectConfig(dir)
+  expect(config).not.toBeNull()
+  expect(config!.compiler?.optimization).toBe(2)
+  expect(config!.compiler?.['include-dirs']).toEqual(['src/shared', 'src/stdlib'])
+  expect(config!.compiler?.['no-dce']).toBe(false)
+  fs.rmSync(dir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 4: Parses [output] section correctly
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses [output] section fields correctly', () => {
+  const dir = makeTmpDir()
+  writeToml(dir, `
+[output]
+dir = "dist/"
+`)
+  const config = loadProjectConfig(dir)
+  expect(config).not.toBeNull()
+  expect(config!.output?.dir).toBe('dist/')
+  fs.rmSync(dir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 5: Full config — all sections together
+// ──────────────────────────────────────────────────────────────────────────────
+test('parses all sections in a full redscript.toml', () => {
+  const dir = makeTmpDir()
+  writeToml(dir, `
+[project]
+name = "my-datapack"
+namespace = "my_pack"
+mc-version = "1.21.4"
+description = "My awesome datapack"
+
+[compiler]
+optimization = 2
+include-dirs = ["src/shared", "src/stdlib"]
+no-dce = false
+
+[output]
+dir = "dist/"
+`)
+  const config = loadProjectConfig(dir)
+  expect(config).not.toBeNull()
+  expect(config!.project?.namespace).toBe('my_pack')
+  expect(config!.compiler?.optimization).toBe(2)
+  expect(config!.output?.dir).toBe('dist/')
+  fs.rmSync(dir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 6: Walks up the directory tree (sub-directory can find parent toml)
+// ──────────────────────────────────────────────────────────────────────────────
+test('finds redscript.toml by walking up the directory tree', () => {
+  const rootDir = makeTmpDir()
+  writeToml(rootDir, `
+[project]
+namespace = "parent_pack"
+`)
+  // Create a nested sub-directory (simulating src/nested)
+  const subDir = path.join(rootDir, 'src', 'nested')
+  fs.mkdirSync(subDir, { recursive: true })
+
+  // loadProjectConfig called from subDir should find the toml in rootDir
+  const config = loadProjectConfig(subDir)
+  expect(config).not.toBeNull()
+  expect(config!.project?.namespace).toBe('parent_pack')
+  fs.rmSync(rootDir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 7: CLI flags take priority over toml values (simulated merge)
+// ──────────────────────────────────────────────────────────────────────────────
+test('CLI flags override toml values when merged', () => {
+  const dir = makeTmpDir()
+  writeToml(dir, `
+[project]
+namespace = "toml_namespace"
+mc-version = "1.21.0"
+description = "From TOML"
+
+[output]
+dir = "dist/"
+`)
+  const tomlConfig = loadProjectConfig(dir)
+  expect(tomlConfig).not.toBeNull()
+
+  // Simulate CLI merge logic: CLI args take priority
+  const cliNamespace = 'cli_namespace'          // provided by CLI
+  const cliMcVersion: string | undefined = undefined  // not provided by CLI
+  const cliOutput: string | undefined = undefined     // not provided by CLI
+
+  const namespace = cliNamespace ?? tomlConfig!.project?.namespace ?? 'default'
+  const mcVersion = cliMcVersion ?? tomlConfig!.project?.['mc-version'] ?? '1.21'
+  const outputDir = cliOutput ?? tomlConfig!.output?.dir ?? './dist'
+
+  expect(namespace).toBe('cli_namespace')   // CLI wins
+  expect(mcVersion).toBe('1.21.0')          // falls back to toml
+  expect(outputDir).toBe('dist/')           // falls back to toml
+
+  fs.rmSync(dir, { recursive: true })
+})
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Test 8: buildTomlTemplate generates valid parseable content
+// ──────────────────────────────────────────────────────────────────────────────
+test('buildTomlTemplate generates a parseable template', () => {
+  const dir = makeTmpDir()
+  const template = buildTomlTemplate('test_pack')
+  fs.writeFileSync(path.join(dir, 'redscript.toml'), template, 'utf-8')
+
+  const config = loadProjectConfig(dir)
+  expect(config).not.toBeNull()
+  expect(config!.project?.name).toBe('test_pack')
+  expect(config!.project?.namespace).toBe('test_pack')
+  expect(config!.project?.['mc-version']).toBe('1.21.4')
+  expect(config!.output?.dir).toBe('dist/')
+
+  fs.rmSync(dir, { recursive: true })
+})

package/src/__tests__/config-decorator.test.ts

@@ -0,0 +1,157 @@
+/**
+ * Tests for the @config decorator — compile-time configuration injection.
+ *
+ * @config("key", default: value) on a global let variable allows values to be
+ * injected at compile time via CompileOptions.config, enabling customizable
+ * build-time constants.
+ */
+
+import { compile } from '../emit/compile'
+
+function getFile(files: { path: string; content: string }[], pathSubstr: string): string | undefined {
+  const f = files.find(f => f.path.includes(pathSubstr))
+  return f?.content
+}
+
+describe('@config decorator — compile-time configuration injection', () => {
+  test('uses default value when no config is provided', () => {
+    const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      fn get_max(): int {
+        return MAX_PLAYERS;
+      }
+    `
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'get_max.mcfunction')
+    expect(fn).toBeDefined()
+    // Default value 20 should be used
+    expect(fn).toContain('20')
+  })
+
+  test('overrides default value with provided config', () => {
+    const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      fn get_max(): int {
+        return MAX_PLAYERS;
+      }
+    `
+    const result = compile(source, { namespace: 'test', config: { max_players: 10 } })
+    const fn = getFile(result.files, 'get_max.mcfunction')
+    expect(fn).toBeDefined()
+    // Config value 10 should be used, not default 20
+    expect(fn).toContain('10')
+  })
+
+  test('different config values produce different outputs', () => {
+    const source = `
+      @config("difficulty", default: 1)
+      let DIFFICULTY: int
+
+      fn get_difficulty(): int {
+        return DIFFICULTY;
+      }
+    `
+
+    const resultEasy = compile(source, { namespace: 'test', config: { difficulty: 1 } })
+    const resultHard = compile(source, { namespace: 'test', config: { difficulty: 5 } })
+
+    const fnEasy = getFile(resultEasy.files, 'get_difficulty.mcfunction')
+    const fnHard = getFile(resultHard.files, 'get_difficulty.mcfunction')
+
+    expect(fnEasy).toBeDefined()
+    expect(fnHard).toBeDefined()
+
+    // Hard difficulty (5) vs easy (1) — outputs differ
+    expect(fnEasy).not.toEqual(fnHard)
+    expect(fnEasy).toContain('1')
+    expect(fnHard).toContain('5')
+  })
+
+  test('multiple @config variables', () => {
+    const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      @config("difficulty", default: 1)
+      let DIFFICULTY: int
+
+      fn get_max(): int {
+        return MAX_PLAYERS;
+      }
+
+      fn get_diff(): int {
+        return DIFFICULTY;
+      }
+    `
+    const result = compile(source, {
+      namespace: 'test',
+      config: { max_players: 10, difficulty: 3 },
+    })
+
+    const maxFn = getFile(result.files, 'get_max.mcfunction')
+    const diffFn = getFile(result.files, 'get_diff.mcfunction')
+
+    expect(maxFn).toBeDefined()
+    expect(diffFn).toBeDefined()
+
+    // max_players=10 used
+    expect(maxFn).toContain('10')
+    // difficulty=3 used
+    expect(diffFn).toContain('3')
+  })
+
+  test('config without default falls back to 0', () => {
+    const source = `
+      @config("some_value")
+      let SOME_VALUE: int
+
+      fn get_val(): int {
+        return SOME_VALUE;
+      }
+    `
+    // No config provided, no default — should fall back to 0
+    const result = compile(source, { namespace: 'test' })
+    const fn = getFile(result.files, 'get_val.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('0')
+  })
+
+  test('config value overrides even when default is provided', () => {
+    const source = `
+      @config("boost", default: 100)
+      let BOOST: int
+
+      fn get_boost(): int {
+        return BOOST;
+      }
+    `
+    const result = compile(source, { namespace: 'test', config: { boost: 999 } })
+    const fn = getFile(result.files, 'get_boost.mcfunction')
+    expect(fn).toBeDefined()
+    expect(fn).toContain('999')
+    // Default 100 should NOT appear
+    expect(fn).not.toContain('100')
+  })
+
+  test('compilation succeeds without errors for @config globals', () => {
+    const source = `
+      @config("max_players", default: 20)
+      let MAX_PLAYERS: int
+
+      @config("difficulty", default: 1)
+      let DIFFICULTY: int
+
+      fn spawn_enemies(): void {
+        let count: int = 3 * DIFFICULTY;
+      }
+    `
+    // Should compile cleanly with config values
+    expect(() =>
+      compile(source, { namespace: 'test', config: { max_players: 10, difficulty: 3 } })
+    ).not.toThrow()
+  })
+})