From bf3aa9b07f6dfb7700634fbcf706c913c9d8c571 Mon Sep 17 00:00:00 2001
From: w3lld1 <42353747+w3lld1@users.noreply.github.com>
Date: Fri, 10 Jul 2026 13:33:42 +0000
Subject: [PATCH] test: cover flag utilities

---
 src/flags.test.ts | 88 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 src/flags.test.ts

diff --git a/src/flags.test.ts b/src/flags.test.ts
new file mode 100644
index 00000000..4ac10a43
--- /dev/null
+++ b/src/flags.test.ts
@@ -0,0 +1,88 @@
+import * as ts from "typescript";
+import { describe, expect, it } from "vitest";
+
+import {
+	isModifierFlagSet,
+	isNodeFlagSet,
+	isObjectFlagSet,
+	isSymbolFlagSet,
+	isTransientSymbolLinksFlagSet,
+	isTypeFlagSet,
+} from "./flags";
+
+describe("isModifierFlagSet", () => {
+	it("checks declaration modifier flags", () => {
+		const declaration = ts.factory.createClassDeclaration(
+			[
+				ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
+				ts.factory.createModifier(ts.SyntaxKind.AbstractKeyword),
+			],
+			"Example",
+			undefined,
+			undefined,
+			[],
+		);
+
+		expect(isModifierFlagSet(declaration, ts.ModifierFlags.Abstract)).toBe(
+			true,
+		);
+		expect(isModifierFlagSet(declaration, ts.ModifierFlags.Export)).toBe(true);
+		expect(isModifierFlagSet(declaration, ts.ModifierFlags.Async)).toBe(false);
+	});
+});
+
+describe("isNodeFlagSet", () => {
+	it("checks node flags", () => {
+		const node = { flags: ts.NodeFlags.AwaitContext } as ts.Node;
+
+		expect(isNodeFlagSet(node, ts.NodeFlags.AwaitContext)).toBe(true);
+		expect(isNodeFlagSet(node, ts.NodeFlags.JavaScriptFile)).toBe(false);
+	});
+});
+
+describe("isObjectFlagSet", () => {
+	it("checks object type flags", () => {
+		const objectType = {
+			objectFlags: ts.ObjectFlags.Anonymous,
+		} as ts.ObjectType;
+
+		expect(isObjectFlagSet(objectType, ts.ObjectFlags.Anonymous)).toBe(true);
+		expect(isObjectFlagSet(objectType, ts.ObjectFlags.Mapped)).toBe(false);
+	});
+});
+
+describe("isSymbolFlagSet", () => {
+	it("checks symbol flags", () => {
+		const symbol = { flags: ts.SymbolFlags.Function } as ts.Symbol;
+
+		expect(isSymbolFlagSet(symbol, ts.SymbolFlags.Function)).toBe(true);
+		expect(isSymbolFlagSet(symbol, ts.SymbolFlags.Class)).toBe(false);
+	});
+});
+
+describe("isTransientSymbolLinksFlagSet", () => {
+	it("checks transient symbol link flags", () => {
+		const links = {
+			checkFlags: ts.CheckFlags.Readonly,
+		} as ts.TransientSymbolLinks;
+		const linksWithoutFlags = {
+			checkFlags: 0 as ts.CheckFlags,
+		} as ts.TransientSymbolLinks;
+
+		expect(isTransientSymbolLinksFlagSet(links, ts.CheckFlags.Readonly)).toBe(
+			true,
+		);
+		expect(
+			isTransientSymbolLinksFlagSet(linksWithoutFlags, ts.CheckFlags.Readonly),
+		).toBe(false);
+	});
+});
+
+describe("isTypeFlagSet", () => {
+	it("checks type flags", () => {
+		const type = { flags: ts.TypeFlags.String } as ts.Type;
+
+		expect(isTypeFlagSet(type, ts.TypeFlags.String)).toBe(true);
+		expect(isTypeFlagSet(type, ts.TypeFlags.Number)).toBe(false);
+	});
+});