freelang-editor 11.7.4

package/src/test-phase20-server-db.ts

@@ -0,0 +1,160 @@
+// FreeLang v9: Phase 20 — Server + DB stdlib 테스트
+
+import { createServerModule } from "./stdlib-server";
+import { createDbModule } from "./stdlib-db";
+
+let pass = 0;
+let fail = 0;
+
+function check(label: string, ok: boolean) {
+  if (ok) { console.log(`  ✅ ${label}`); pass++; }
+  else     { console.error(`  ❌ ${label}`); fail++; }
+}
+
+// ── Server 모듈 단위 테스트 ────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log("  Phase 20: stdlib-server 단위 테스트");
+console.log("══════════════════════════════════════════");
+
+// callFn mock
+const mockCallFn = (name: string, args: any[]) => {
+  if (name === "handle_hello") return { msg: "hello" };
+  if (name === "handle_text") return "plain text";
+  if (name === "handle_status") return { __fl_response: true, type: "json", status: 201, body: { created: true } };
+  throw new Error(`Unknown handler: ${name}`);
+};
+
+const S = createServerModule(mockCallFn);
+
+check("server_get 함수 존재", typeof S["server_get"] === "function");
+check("server_post 함수 존재", typeof S["server_post"] === "function");
+check("server_put 함수 존재", typeof S["server_put"] === "function");
+check("server_delete 함수 존재", typeof S["server_delete"] === "function");
+check("server_start 함수 존재", typeof S["server_start"] === "function");
+check("server_stop 함수 존재", typeof S["server_stop"] === "function");
+
+// server_json
+const jsonResp = S["server_json"]({ ok: true });
+check("server_json: __fl_response 마커", jsonResp.__fl_response === true);
+check("server_json: type=json", jsonResp.type === "json");
+check("server_json: status=200", jsonResp.status === 200);
+check("server_json: body 포함", jsonResp.body?.ok === true);
+
+// server_text
+const textResp = S["server_text"]("hello world");
+check("server_text: type=text", textResp.type === "text");
+check("server_text: body 문자열", textResp.body === "hello world");
+
+// server_status
+const errResp = S["server_status"](404, "Not Found");
+check("server_status: code=404", errResp.status === 404);
+check("server_status: type=text", errResp.type === "text");
+
+// server_req_* 파싱 (mock Request 객체)
+const mockReq: any = {
+  body: { name: "김", age: 30 },
+  params: { id: "42", slug: "hello" },
+  query: { q: "search term", page: "2" },
+  headers: { "x-api-key": "secret", "content-type": "application/json" },
+};
+check("server_req_body: body 반환", S["server_req_body"](mockReq)?.name === "김");
+check("server_req_params: params 반환", S["server_req_params"](mockReq)?.id === "42");
+check("server_req_query: query 반환", S["server_req_query"](mockReq)?.q === "search term");
+check("server_req_header: 헤더 반환", S["server_req_header"](mockReq, "x-api-key") === "secret");
+check("server_req_header: 대소문자 무시", S["server_req_header"](mockReq, "X-API-KEY") === "secret");
+check("server_req_header: 없는 헤더 null", S["server_req_header"](mockReq, "authorization") === null);
+
+// server_get 라우트 등록 (오류 없이 실행)
+let routeRegistered = false;
+try { S["server_get"]("/test", "handle_hello"); routeRegistered = true; } catch {}
+check("server_get: 라우트 등록 오류 없음", routeRegistered);
+
+// ── DB 모듈 단위 테스트 ───────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log("  Phase 20: stdlib-db 단위 테스트");
+console.log("══════════════════════════════════════════");
+
+const D = createDbModule();
+
+check("db_get 함수 존재", typeof D["db_get"] === "function");
+check("db_all 함수 존재", typeof D["db_all"] === "function");
+check("db_put 함수 존재", typeof D["db_put"] === "function");
+check("db_delete 함수 존재", typeof D["db_delete"] === "function");
+check("db_project 함수 존재", typeof D["db_project"] === "function");
+check("db_projects 함수 존재", typeof D["db_projects"] === "function");
+check("db_query 함수 존재", typeof D["db_query"] === "function");
+check("db_exec 함수 존재", typeof D["db_exec"] === "function");
+check("db_insert 함수 존재", typeof D["db_insert"] === "function");
+check("db_update 함수 존재", typeof D["db_update"] === "function");
+check("db_count 함수 존재", typeof D["db_count"] === "function");
+check("db_tables 함수 존재", typeof D["db_tables"] === "function");
+check("db_create 함수 존재", typeof D["db_create"] === "function");
+
+// kimdb 연결 테스트 (kimdb가 실행 중이면 통과, 아니면 null 반환)
+const proj = D["db_project"]("freelang-v9") as any;
+check("db_project: 오류 없이 반환 (null or data)", proj === null || typeof proj === "object");
+
+const all = D["db_all"]("projects") as any[];
+check("db_all: 배열 반환", Array.isArray(all));
+
+// SQLite 테스트 (임시 DB)
+import * as os from "os";
+import * as path from "path";
+import * as fs from "fs";
+
+const tmpDb = path.join(os.tmpdir(), `fl_test_${Date.now()}.db`);
+
+try {
+  // 테이블 생성
+  D["db_create"](tmpDb, "CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name TEXT, val INTEGER)");
+  check("db_create: 테이블 생성", true);
+
+  // 행 삽입
+  D["db_insert"](tmpDb, "items", { name: "foo", val: 42 });
+  D["db_insert"](tmpDb, "items", { name: "bar", val: 99 });
+  check("db_insert: 행 삽입 2개", true);
+
+  // 카운트
+  const cnt = D["db_count"](tmpDb, "items") as number;
+  check("db_count: 2행", cnt === 2);
+
+  // 조회
+  const rows = D["db_query"](tmpDb, "SELECT * FROM items ORDER BY val") as any[];
+  check("db_query: 2행 반환", rows.length === 2);
+  check("db_query: 첫 행 name=foo", rows[0]?.name === "foo");
+  check("db_query: 첫 행 val=42", Number(rows[0]?.val) === 42);
+
+  // ? 바인딩
+  const filtered = D["db_query"](tmpDb, "SELECT * FROM items WHERE name=?", ["bar"]) as any[];
+  check("db_query: ? 바인딩", filtered.length === 1 && filtered[0]?.name === "bar");
+
+  // 업데이트
+  D["db_update"](tmpDb, "items", { val: 100 }, "name='foo'");
+  const updated = D["db_query"](tmpDb, "SELECT val FROM items WHERE name='foo'") as any[];
+  check("db_update: val=100", Number(updated[0]?.val) === 100);
+
+  // 테이블 목록
+  const tables = D["db_tables"](tmpDb) as string[];
+  check("db_tables: items 포함", tables.includes("items"));
+
+  // 행 삭제
+  D["db_delete_row"](tmpDb, "items", "name='foo'");
+  const cntAfter = D["db_count"](tmpDb, "items") as number;
+  check("db_delete_row: 1행 남음", cntAfter === 1);
+
+} catch (e: any) {
+  console.error(`  SQLite 테스트 오류: ${e.message}`);
+  fail++;
+} finally {
+  try { fs.unlinkSync(tmpDb); } catch {}
+}
+
+// ── 결과 ─────────────────────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log(`결과: ${pass}/${pass + fail} PASS`);
+console.log("══════════════════════════════════════════");
+
+if (fail > 0) process.exit(1);

package/src/test-phase21-ws-auth-cache-pubsub.ts

@@ -0,0 +1,212 @@
+// FreeLang v9: Phase 21 — WS + Auth + Cache + PubSub 테스트
+
+import { createWsModule } from "./stdlib-ws";
+import { createAuthModule } from "./stdlib-auth";
+import { createCacheModule } from "./stdlib-cache";
+import { createPubSubModule } from "./stdlib-pubsub";
+
+let pass = 0;
+let fail = 0;
+
+function check(label: string, ok: boolean) {
+  if (ok) { console.log(`  ✅ ${label}`); pass++; }
+  else     { console.error(`  ❌ ${label}`); fail++; }
+}
+
+// ── Auth ──────────────────────────────────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log("  Phase 21: stdlib-auth 테스트");
+console.log("══════════════════════════════════════════");
+
+const A = createAuthModule();
+
+// JWT sign + verify
+const payload = { userId: "42", role: "admin" };
+const secret  = "my_secret_key";
+const token   = A["auth_jwt_sign"](payload, secret, 3600);
+check("auth_jwt_sign: 토큰 생성", typeof token === "string" && token.split(".").length === 3);
+
+const verified = A["auth_jwt_verify"](token, secret);
+check("auth_jwt_verify: 검증 성공", verified !== null);
+check("auth_jwt_verify: payload.userId 일치", verified?.userId === "42");
+check("auth_jwt_verify: payload.role 일치", verified?.role === "admin");
+
+const badToken = A["auth_jwt_verify"](token, "wrong_secret");
+check("auth_jwt_verify: 잘못된 시크릿 → null", badToken === null);
+
+const decoded = A["auth_jwt_decode"](token);
+check("auth_jwt_decode: userId 포함", decoded?.userId === "42");
+
+check("auth_jwt_expired: 유효 토큰 false", A["auth_jwt_expired"](token) === false);
+// 만료된 토큰 생성 (expiry=-1)
+const expiredToken = A["auth_jwt_sign"]({ x: 1 }, secret, -100);
+check("auth_jwt_expired: 만료 토큰 true", A["auth_jwt_expired"](expiredToken) === true);
+check("auth_jwt_verify: 만료 토큰 → null", A["auth_jwt_verify"](expiredToken, secret) === null);
+
+// Bearer extraction
+const mockReq = { headers: { authorization: `Bearer ${token}` } };
+check("auth_bearer_extract: 토큰 추출", A["auth_bearer_extract"](mockReq) === token);
+check("auth_bearer_extract: 없으면 null", A["auth_bearer_extract"]({ headers: {} }) === null);
+
+// API key
+const apiReq = { headers: { "x-api-key": "secret123" }, query: {}, body: {} };
+check("auth_apikey_valid: 유효 키", A["auth_apikey_valid"](apiReq, ["secret123", "other"]) === true);
+check("auth_apikey_valid: 잘못된 키", A["auth_apikey_valid"](apiReq, ["wrong"]) === false);
+check("auth_apikey_get: 키 추출", A["auth_apikey_get"](apiReq) === "secret123");
+
+// Password hashing
+const hash = A["auth_hash_password"]("mypassword123");
+check("auth_hash_password: salt:hash 형식", typeof hash === "string" && hash.includes(":"));
+check("auth_verify_password: 올바른 비밀번호", A["auth_verify_password"]("mypassword123", hash) === true);
+check("auth_verify_password: 틀린 비밀번호", A["auth_verify_password"]("wrong", hash) === false);
+
+// Tokens
+const token32 = A["auth_random_token"](32);
+check("auth_random_token: 64자 hex", typeof token32 === "string" && token32.length === 64);
+
+const hmac = A["auth_hmac"]("data", "secret");
+check("auth_hmac: hex 출력", typeof hmac === "string" && hmac.length === 64);
+
+const sha = A["auth_sha256"]("hello");
+check("auth_sha256: hex 출력", typeof sha === "string" && sha.length === 64);
+
+const b64 = A["auth_base64"]("hello world");
+check("auth_base64: 인코딩", b64 === "aGVsbG8gd29ybGQ=");
+check("auth_base64_decode: 디코딩", A["auth_base64_decode"](b64) === "hello world");
+
+// ── Cache ──────────────────────────────────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log("  Phase 21: stdlib-cache 테스트");
+console.log("══════════════════════════════════════════");
+
+const C = createCacheModule();
+
+// 기본 set/get
+C["cache_set"]("key1", "value1");
+check("cache_set/get: 기본 동작", C["cache_get"]("key1") === "value1");
+check("cache_has: 존재 확인", C["cache_has"]("key1") === true);
+check("cache_has: 미존재 false", C["cache_has"]("nonexistent") === false);
+
+// 객체 저장
+C["cache_set"]("obj1", { name: "test", count: 42 });
+const obj = C["cache_get"]("obj1") as any;
+check("cache_set/get: 객체 저장", obj?.name === "test" && obj?.count === 42);
+
+// TTL
+C["cache_set"]("ttl1", "expires_soon", 50); // 50ms TTL
+check("cache_get: TTL 만료 전", C["cache_get"]("ttl1") === "expires_soon");
+check("cache_ttl: 남은 시간 양수", (C["cache_ttl"]("ttl1") as number) > 0);
+check("cache_ttl: 영구 키 -1", C["cache_ttl"]("key1") === -1);
+check("cache_ttl: 미존재 null", C["cache_ttl"]("xxx") === null);
+
+// 삭제
+C["cache_del"]("key1");
+check("cache_del: 삭제 후 null", C["cache_get"]("key1") === null);
+
+// incr
+C["cache_set"]("counter", 0);
+C["cache_incr"]("counter", 5);
+check("cache_incr: +5", C["cache_get"]("counter") === 5);
+C["cache_incr"]("counter");
+check("cache_incr: +1 (기본)", C["cache_get"]("counter") === 6);
+
+// mset/mget
+C["cache_mset"]({ "a": 1, "b": 2, "c": 3 });
+const multi = C["cache_mget"](["a", "b", "c", "d"]) as any;
+check("cache_mset/mget: 3개 저장, d=null", multi["a"] === 1 && multi["b"] === 2 && multi["d"] === null);
+
+// keys
+const keys = C["cache_keys"]() as string[];
+check("cache_keys: 존재 키 포함", keys.includes("a") && keys.includes("b"));
+
+// clear by prefix
+C["cache_set"]("prefix:1", "x"); C["cache_set"]("prefix:2", "y"); C["cache_set"]("other", "z");
+const cleared = C["cache_clear"]("prefix:");
+check("cache_clear: prefix로 2개 삭제", cleared === 2);
+check("cache_clear: 다른 키 유지", C["cache_has"]("other") === true);
+
+// ── PubSub ─────────────────────────────────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log("  Phase 21: stdlib-pubsub 테스트");
+console.log("══════════════════════════════════════════");
+
+const received: any[] = [];
+const mockCallFn = (name: string, args: any[]) => {
+  received.push({ name, topic: args[0], data: args[1] });
+};
+
+const PS = createPubSubModule(mockCallFn);
+
+const subId = PS["pubsub_subscribe"]("user.login", "on_login") as string;
+check("pubsub_subscribe: ID 반환", typeof subId === "string");
+
+PS["pubsub_subscribe"]("user.login", "on_login_2");
+PS["pubsub_subscribe"]("order.created", "on_order");
+
+check("pubsub_topics: 2개 토픽", (PS["pubsub_topics"]() as string[]).length === 2);
+check("pubsub_subscribers: user.login 2개", PS["pubsub_subscribers"]("user.login") === 2);
+
+// publish
+const delivered = PS["pubsub_publish"]("user.login", { userId: "42" }) as number;
+check("pubsub_publish: 2개 전달", delivered === 2);
+check("pubsub_publish: 핸들러 호출", received.some(r => r.name === "on_login" && r.data?.userId === "42"));
+check("pubsub_publish: 두 번째 핸들러 호출", received.some(r => r.name === "on_login_2"));
+
+// 없는 토픽
+check("pubsub_publish: 구독자 없으면 0", PS["pubsub_publish"]("no.topic", {}) === 0);
+
+// once
+received.length = 0;
+PS["pubsub_once"]("temp.event", "on_temp");
+PS["pubsub_publish"]("temp.event", "first");
+PS["pubsub_publish"]("temp.event", "second");
+check("pubsub_once: 첫 발행 호출", received.length === 1);
+check("pubsub_once: 두 번째 발행 무시", received.length === 1);
+
+// unsubscribe
+received.length = 0;
+PS["pubsub_unsubscribe"](subId);
+PS["pubsub_publish"]("user.login", { userId: "99" });
+check("pubsub_unsubscribe: 해제 후 1개만 호출", received.length === 1);
+check("pubsub_unsubscribe: on_login_2만 호출", received[0]?.name === "on_login_2");
+
+// ── WS 모듈 구조 테스트 ────────────────────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log("  Phase 21: stdlib-ws 구조 테스트");
+console.log("══════════════════════════════════════════");
+
+const WS = createWsModule(mockCallFn);
+check("ws_start 함수 존재", typeof WS["ws_start"] === "function");
+check("ws_stop 함수 존재", typeof WS["ws_stop"] === "function");
+check("ws_send 함수 존재", typeof WS["ws_send"] === "function");
+check("ws_send_json 함수 존재", typeof WS["ws_send_json"] === "function");
+check("ws_broadcast 함수 존재", typeof WS["ws_broadcast"] === "function");
+check("ws_broadcast_json 함수 존재", typeof WS["ws_broadcast_json"] === "function");
+check("ws_close 함수 존재", typeof WS["ws_close"] === "function");
+check("ws_clients 함수 존재", typeof WS["ws_clients"] === "function");
+check("ws_count 함수 존재", typeof WS["ws_count"] === "function");
+check("ws_on_connect_fn 함수 존재", typeof WS["ws_on_connect_fn"] === "function");
+check("ws_on_message_fn 함수 존재", typeof WS["ws_on_message_fn"] === "function");
+
+// 연결 없는 상태
+check("ws_clients: 초기 빈 배열", (WS["ws_clients"]() as string[]).length === 0);
+check("ws_count: 초기 0", WS["ws_count"]() === 0);
+check("ws_send: 없는 연결 false", WS["ws_send"]("nonexistent", "hi") === false);
+check("ws_broadcast: 연결 없을 때 0", WS["ws_broadcast"]("hello") === 0);
+
+// 핸들러 이름 설정
+WS["ws_on_connect_fn"]("my_connect_handler");
+WS["ws_on_message_fn"]("my_message_handler");
+check("ws_on_connect_fn: 오류 없음", true);
+
+// ── 결과 ─────────────────────────────────────────────────────────────────────
+
+console.log("\n══════════════════════════════════════════");
+console.log(`결과: ${pass}/${pass + fail} PASS`);
+console.log("══════════════════════════════════════════");
+
+if (fail > 0) process.exit(1);

package/src/test-phase22-process.ts

@@ -0,0 +1,166 @@
+// FreeLang v9: Phase 22 Process 모듈 테스트
+// env_load, env_get, env_require, on_sigterm, error line numbers
+
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { Interpreter } from "./interpreter";
+import { lex } from "./lexer";
+import { parse } from "./parser";
+
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void) {
+  try {
+    fn();
+    console.log(`  ✅ ${name}`);
+    passed++;
+  } catch (e: any) {
+    console.log(`  ❌ ${name}: ${e.message}`);
+    failed++;
+  }
+}
+
+function run(code: string): any {
+  const interp = new Interpreter();
+  const ast = parse(lex(code));
+  interp.interpret(ast);
+  return interp.context.lastValue;
+}
+
+// ─── 1. env_get ─────────────────────────────────────────────────────────────
+console.log("\n[1] env_get");
+
+test("env_get: 존재하는 변수", () => {
+  process.env["FL_TEST_VAR"] = "hello";
+  const result = run(`(env_get "FL_TEST_VAR")`);
+  if (result !== "hello") throw new Error(`expected "hello", got "${result}"`);
+});
+
+test("env_get: 없는 변수 → 빈 문자열", () => {
+  delete process.env["FL_NONEXISTENT_XYZ"];
+  const result = run(`(env_get "FL_NONEXISTENT_XYZ")`);
+  if (result !== "") throw new Error(`expected "", got "${result}"`);
+});
+
+// ─── 2. env_load ─────────────────────────────────────────────────────────────
+console.log("\n[2] env_load");
+
+test("env_load: .env 파일 읽기", () => {
+  const tmpDir = os.tmpdir();
+  const envFile = path.join(tmpDir, ".env.fl-test");
+  fs.writeFileSync(envFile, `FL_DB_HOST=localhost\nFL_DB_PORT=5432\n# comment\nFL_SECRET="my secret"\n`);
+
+  run(`(env_load "${envFile}")`);
+
+  if (process.env["FL_DB_HOST"] !== "localhost")
+    throw new Error(`FL_DB_HOST should be "localhost", got "${process.env["FL_DB_HOST"]}"`);
+  if (process.env["FL_DB_PORT"] !== "5432")
+    throw new Error(`FL_DB_PORT should be "5432"`);
+  if (process.env["FL_SECRET"] !== "my secret")
+    throw new Error(`FL_SECRET should be "my secret" (quotes stripped), got "${process.env["FL_SECRET"]}"`);
+
+  fs.unlinkSync(envFile);
+});
+
+test("env_load: 없는 파일 → 빈 맵 반환 (no throw)", () => {
+  const result = run(`(env_load "/nonexistent/.env.xyz")`);
+  if (typeof result !== "object" || result === null)
+    throw new Error(`expected object, got ${typeof result}`);
+});
+
+// ─── 3. env_require ──────────────────────────────────────────────────────────
+console.log("\n[3] env_require");
+
+test("env_require: 있는 변수 반환", () => {
+  process.env["FL_REQ_VAR"] = "value123";
+  const result = run(`(env_require "FL_REQ_VAR")`);
+  if (result !== "value123") throw new Error(`expected "value123", got "${result}"`);
+});
+
+test("env_require: 없는 변수 → throw", () => {
+  delete process.env["FL_MISSING_REQ"];
+  let threw = false;
+  try {
+    run(`(env_require "FL_MISSING_REQ")`);
+  } catch (e: any) {
+    threw = true;
+    if (!e.message.includes("FL_MISSING_REQ"))
+      throw new Error(`error should mention var name, got: ${e.message}`);
+  }
+  if (!threw) throw new Error("should have thrown");
+});
+
+// ─── 4. on_sigterm / process helpers ─────────────────────────────────────────
+console.log("\n[4] on_sigterm / process helpers");
+
+test("on_sigterm: 등록 (예외 없이)", () => {
+  run(`(on_sigterm)`); // no callback — just register handlers
+});
+
+test("process_pid: 양수 숫자 반환", () => {
+  const result = run(`(process_pid)`);
+  if (typeof result !== "number" || result <= 0)
+    throw new Error(`expected positive number, got ${result}`);
+});
+
+test("process_argv: 배열 반환", () => {
+  const result = run(`(process_argv)`);
+  if (!Array.isArray(result))
+    throw new Error(`expected array, got ${typeof result}`);
+});
+
+// ─── 5. 에러 라인 번호 ────────────────────────────────────────────────────────
+console.log("\n[5] 에러 라인 번호");
+
+test("에러 메시지에 FreeLang line N 포함", () => {
+  let errorMsg = "";
+  try {
+    run(`(unknown_func_xyz 1 2 3)`);
+  } catch (e: any) {
+    errorMsg = e.message;
+  }
+  if (!errorMsg.includes("FreeLang line"))
+    throw new Error(`에러에 라인 정보 없음: "${errorMsg}"`);
+});
+
+test("멀티라인 코드에서 라인 번호 추적", () => {
+  const code = `
+(+ 1 2)
+(+ 3 4)
+(nonexistent_fn 42)
+`;
+  let errorMsg = "";
+  try {
+    run(code);
+  } catch (e: any) {
+    errorMsg = e.message;
+  }
+  if (!errorMsg.includes("FreeLang line"))
+    throw new Error(`에러에 라인 정보 없음: "${errorMsg}"`);
+  console.log(`     → ${errorMsg.split("\n")[0]}`);
+});
+
+test("라인 번호가 실제 소스 라인과 일치", () => {
+  // 4번째 라인에서 에러
+  const code = `(+ 1 2)\n(+ 3 4)\n(+ 5 6)\n(this_does_not_exist)`;
+  let errorMsg = "";
+  try {
+    run(code);
+  } catch (e: any) {
+    errorMsg = e.message;
+  }
+  if (!errorMsg.includes("FreeLang line 4"))
+    throw new Error(`4번 라인 에러 기대, 실제: "${errorMsg}"`);
+});
+
+// ─── 결과 ──────────────────────────────────────────────────────────────────
+console.log(`\n${"─".repeat(50)}`);
+console.log(`Phase 22 결과: ${passed}/${passed + failed} PASS`);
+if (failed > 0) {
+  console.log(`❌ ${failed}개 실패`);
+  process.exit(1);
+} else {
+  console.log(`✅ 전부 통과`);
+}