@boyingliu01/xp-gate 0.8.8 → 0.8.10

package/principles/__tests__/types.test.ts

@@ -0,0 +1,101 @@
+/**
+ * @test types.ts - Core type definitions
+ * @intent Verify Rule and Violation interfaces match design spec
+ * @covers clean-code-solid-checker-design Section 6-7
+ */
+
+import { describe, it, expect } from 'vitest';
+
+// These imports will fail until implementation exists - that's the RED phase!
+import type { Rule, Violation, Severity, Adapter } from '../types';
+
+describe('types.ts - Core Interfaces', () => {
+  describe('Rule interface', () => {
+    it('should have required fields: id, name, threshold, severity, check', () => {
+      // This test will fail until types.ts exists
+      const rule: Rule = {
+        id: 'clean-code.long-function',
+        name: 'Long Function',
+        threshold: 50,
+        severity: 'warning',
+        check: () => [],
+      };
+
+      expect(rule.id).toBeDefined();
+      expect(rule.name).toBeDefined();
+      expect(rule.threshold).toBeDefined();
+      expect(rule.severity).toBeDefined();
+      expect(rule.check).toBeDefined();
+    });
+
+    it('should support all severity levels', () => {
+      const severities: Severity[] = ['error', 'warning', 'info'];
+      
+      expect(severities).toContain('error');
+      expect(severities).toContain('warning');
+      expect(severities).toContain('info');
+    });
+
+    it('should have correct rule ID format', () => {
+      // Rule IDs should follow pattern: category.rule-name
+      const validIds = [
+        'clean-code.long-function',
+        'clean-code.magic-numbers',
+        'solid.srp',
+        'solid.dip',
+      ];
+
+      validIds.forEach(id => {
+        expect(id).toMatch(/^[a-z-]+\.[a-z-]+$/);
+      });
+    });
+  });
+
+  describe('Violation interface', () => {
+    it('should have required fields: file, line, ruleId, message, severity', () => {
+      const violation: Violation = {
+        file: 'src/test.ts',
+        line: 42,
+        ruleId: 'clean-code.long-function',
+        message: 'Function exceeds 50 lines',
+        severity: 'warning',
+      };
+
+      expect(violation.file).toBeDefined();
+      expect(violation.line).toBeDefined();
+      expect(violation.ruleId).toBeDefined();
+      expect(violation.message).toBeDefined();
+      expect(violation.severity).toBeDefined();
+    });
+
+    it('should support optional column field', () => {
+      const violationWithColumn: Violation = {
+        file: 'src/test.ts',
+        line: 42,
+        column: 10,
+        ruleId: 'clean-code.magic-numbers',
+        message: 'Magic number 47 detected',
+        severity: 'info',
+      };
+
+      expect(violationWithColumn.column).toBe(10);
+    });
+  });
+
+  describe('Adapter interface', () => {
+    it('should have required methods: detectLanguage, parseAST, extractFunctions', () => {
+      // This will fail until Adapter interface is defined
+      const adapter: Adapter = {
+        detectLanguage: () => 'typescript',
+        parseAST: () => null,
+        extractFunctions: () => [],
+        extractClasses: () => [],
+        countLines: () => 0,
+      };
+
+      expect(adapter.detectLanguage).toBeDefined();
+      expect(adapter.parseAST).toBeDefined();
+      expect(adapter.extractFunctions).toBeDefined();
+    });
+  });
+});

package/principles/adapters/__tests__/base.test.ts

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { Adapter } from '../../types';
+import { BaseAdapter } from '../base';
+
+class MockAdapter extends BaseAdapter {
+  parseAST(): unknown {
+    return { content: this.fileContent, astType: 'mock' };
+  }
+  extractFunctions(): unknown[] {
+    return [];
+  }
+  extractClasses(): unknown[] {
+    return [];
+  }
+}
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('BaseAdapter - Default Implementation', () => {
+
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('mock file content\ntest line 2');
+    const adapter = new MockAdapter('./test.ts');
+    const implemented: Adapter = adapter as unknown as Adapter;
+    
+    expect(implemented).toBeDefined();
+    expect(implemented.detectLanguage).toBeDefined();
+    expect(implemented.parseAST).toBeDefined();
+    expect(implemented.extractFunctions).toBeDefined();
+    expect(implemented.extractClasses).toBeDefined();
+    expect(implemented.countLines).toBeDefined();
+  });
+
+  it('should detect language based on file extension', () => {
+    (readFileSync as vi.Mock).mockReturnValue('file content');
+    
+    const adapterTs = new MockAdapter('./test.ts');
+    expect(adapterTs.detectLanguage()).toBe('typescript');
+    
+    const adapterTsx = new MockAdapter('./test.tsx');
+    expect(adapterTsx.detectLanguage()).toBe('typescript');  
+    
+    const adapterJs = new MockAdapter('./test.js');
+    expect(adapterJs.detectLanguage()).toBe('javascript');
+    
+    const adapterPy = new MockAdapter('./test.py');
+    expect(adapterPy.detectLanguage()).toBe('python');
+    
+    const adapterUnknown = new MockAdapter('./test.unknown');
+    expect(adapterUnknown.detectLanguage()).toBe('unknown');
+  });
+
+  it('should parse file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('mock file content\ntest line 2');
+    const adapter = new MockAdapter('./test.ts');
+    const ast = adapter.parseAST();
+    expect(ast).toEqual({ content: 'mock file content\ntest line 2', astType: 'mock' });
+  });
+
+  it('should extract functions from AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('');
+    const adapter = new MockAdapter('./test.ts');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+  });
+
+  it('should extract classes from AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('');
+    const adapter = new MockAdapter('./test.ts');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+  });
+
+  it('should count physical lines correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('line 1\nline 2\nline 3');
+    const adapter = new MockAdapter('./test.ts');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(3);
+  });
+
+  it('should throw error for unsupported file operations', () => {
+    (readFileSync as vi.Mock).mockImplementation(() => {
+      throw new Error('Could not read file');
+    });
+    
+    expect(() => {
+      new MockAdapter('./nonexistent-file.txt');
+    }).toThrow('Could not read file:');
+  });
+});

package/principles/adapters/__tests__/cpp.test.ts

@@ -0,0 +1,290 @@
+import { describe, it, expect, vi } from 'vitest';
+import { CppAdapter } from '../cpp';
+
+type MockFunction = Record<string, unknown>;
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('CppAdapter', () => {
+  
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    const adapter = new CppAdapter('test.cpp');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+    expect(adapter).toHaveProperty('countLines');
+  });
+
+  it('should detect language as cpp for .cpp files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    const adapter = new CppAdapter('test.cpp');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('cpp');
+  });
+
+  it('should detect language as cpp for .cxx files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    const adapter = new CppAdapter('test.cxx');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('cpp');
+  });
+
+  it('should detect language as cpp for .cc files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    const adapter = new CppAdapter('test.cc');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('cpp');
+  });
+
+  it('should detect language as cpp for .c files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    const adapter = new CppAdapter('test.c');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('cpp');
+  });
+
+  it('should detect language as cpp for .hpp files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('#pragma once');
+    const adapter = new CppAdapter('test.hpp');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('cpp');
+  });
+
+  it('should detect language as cpp for .h files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('#pragma once');
+    const adapter = new CppAdapter('test.h');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('cpp');
+  });
+
+  it('should parse C++ file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('int main() { return 0; }');
+    const adapter = new CppAdapter('test.cpp');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('cpp');
+  });
+
+  it('should extract functions from C++ code', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+int add(int a, int b) {
+  return a + b;
+}
+
+int main() {
+  return add(1, 2);
+}
+`);
+    const adapter = new CppAdapter('test.cpp');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as MockFunction).name === 'main')).toBe(true);
+  });
+
+  it('should handle C++ strings with special characters', () => {
+    (readFileSync as vi.Mock).mockReturnValue(`
+int main() {
+  const char* str = "Hello \\"World\\"";
+  char c = '\\'';
+  return 0;
+}
+`);
+    
+    const adapter = new CppAdapter('test.cpp');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {name: string}).name === 'main')).toBe(true);
+  });
+  
+  it('should throw error when file cannot be read', () => {
+    (readFileSync as vi.Mock).mockImplementation(() => {
+      throw new Error('Could not read file');
+    });
+    
+    expect(() => {
+      new CppAdapter('nonexistent-file.cpp');
+    }).toThrow('Could not read file:');
+  });
+});
+
+/**
+ * @test REQ-COV-004 CppAdapter extractCodeBlock branch coverage
+ * @intent Verify block-comment handling and nested-brace counting inside extractCodeBlock
+ * @covers AC-COV-004
+ */
+describe('CppAdapter - extractCodeBlock edge cases', () => {
+  it('should skip single-line block comment before the opening brace', () => {
+    const src = `int foo() /* inline comment */ { return 1; }`;
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block).toContain('{ return 1; }');
+    expect(block.endsWith('}')).toBe(true);
+  });
+
+  it('should skip multi-line block comment spanning multiple lines', () => {
+    const src = [
+      'int foo()',
+      '/* this is a',
+      '   multi-line block',
+      '   comment */',
+      '{',
+      '  return 42;',
+      '}',
+    ].join('\n');
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block).toContain('return 42;');
+    expect(block.trim().endsWith('}')).toBe(true);
+  });
+
+  it('should ignore braces inside block comments', () => {
+    const src = `int foo() /* fake { brace } here */ { return 7; }`;
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block).toContain('return 7;');
+    expect(block.trim().endsWith('}')).toBe(true);
+  });
+
+  it('should count nested braces correctly via braceCount++ path', () => {
+    const src = `void foo() { if (x) { return; } }`;
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block).toBe('void foo() { if (x) { return; } }');
+  });
+
+  it('should handle deeply nested braces (triple nesting)', () => {
+    const src = `int bar() { if (a) { while (b) { c++; } } return 0; }`;
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block.trim().endsWith('}')).toBe(true);
+    expect(block).toContain('c++;');
+    const opens = (block.match(/\{/g) || []).length;
+    const closes = (block.match(/\}/g) || []).length;
+    expect(opens).toBe(closes);
+  });
+
+  it('should combine block comments and nested braces in same body', () => {
+    const src = [
+      'int compute() {',
+      '  /* outer block comment',
+      '     with text { and } symbols */',
+      '  if (a) {',
+      '    /* nested comment */',
+      '    return 1;',
+      '  }',
+      '  return 0;',
+      '}',
+    ].join('\n');
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block.trim().endsWith('}')).toBe(true);
+    expect(block).toContain('return 1;');
+    expect(block).toContain('return 0;');
+  });
+
+  it('should skip line comments (// ...) before brace', () => {
+    const src = [
+      'int foo() {',
+      '  // line comment with { fake brace }',
+      '  return 5;',
+      '}',
+    ].join('\n');
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const block = adapter.extractCodeBlock(0);
+    expect(block).toContain('return 5;');
+    expect(block.trim().endsWith('}')).toBe(true);
+  });
+
+  it('should extract constructors with member initializer lists', () => {
+    const src = [
+      'class Foo {',
+      'public:',
+      '  Foo(int x) : value_(x) {',
+      '    init();',
+      '  }',
+      'private:',
+      '  int value_;',
+      '};',
+    ].join('\n');
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as { type: string }).type === 'constructor')).toBe(true);
+  });
+
+  it('should extract classes from C++ source', () => {
+    const src = [
+      'class MyClass {',
+      'public:',
+      '  void doStuff() { return; }',
+      '};',
+      'struct MyStruct : public Base {',
+      '  int x;',
+      '};',
+    ].join('\n');
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.length).toBeGreaterThanOrEqual(2);
+    expect(classes.some(c => (c as { name: string }).name === 'MyClass')).toBe(true);
+    expect(classes.some(c => (c as { name: string }).name === 'MyStruct')).toBe(true);
+  });
+
+  it('should count lines correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('line1\nline2\nline3');
+    const adapter = new CppAdapter('test.cpp');
+    expect(adapter.countLines()).toBe(3);
+  });
+
+  it('should fall back to super.detectLanguage for non-cpp extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new CppAdapter('test.txt');
+    expect(adapter.detectLanguage()).toBe('unknown');
+  });
+
+  it('should extract functions correctly when source has block comments and nested braces', () => {
+    const src = [
+      '/* file header comment */',
+      'int outer(int x) {',
+      '  /* explain logic */',
+      '  if (x > 0) {',
+      '    return x;',
+      '  }',
+      '  return -x;',
+      '}',
+    ].join('\n');
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as { name: string }).name === 'outer')).toBe(true);
+  });
+
+  it('should extract functions with scope prefix (e.g. MyClass::method)', () => {
+    const src = 'void MyClass::method() { return; }';
+    (readFileSync as vi.Mock).mockReturnValue(src);
+    const adapter = new CppAdapter('test.cpp');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as { name: string }).name === 'MyClass::method')).toBe(true);
+  });
+});

package/principles/adapters/__tests__/dart.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect, vi } from 'vitest';
+import { DartAdapter } from '../dart';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('DartAdapter', () => {
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    const adapter = new DartAdapter('test.dart');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+    expect(adapter).toHaveProperty('countLines');
+  });
+
+  it('should detect language as dart for .dart files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}');
+    const adapter = new DartAdapter('test.dart');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('dart');
+  });
+
+  it('should parse Dart file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    const adapter = new DartAdapter('test.dart');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('dart');
+  });
+
+  it('should extract functions from Dart AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    const adapter = new DartAdapter('test.dart');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {name: string}).name === 'testFn')).toBe(true);
+  });
+
+  it('should extract classes from Dart AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nclass TestClass {}');
+    const adapter = new DartAdapter('test.dart');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'TestClass')).toBe(true);
+  });
+
+  it('should count Dart file physical lines', () => {
+    (readFileSync as vi.Mock).mockReturnValue('void testFn() {}\nvoid testFn2() {}');
+    const adapter = new DartAdapter('test.dart');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(2);
+  });
+
+  it('should fall back to super.detectLanguage for non-dart extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new DartAdapter('test.py');
+    expect(adapter.detectLanguage()).toBe('python');
+  });
+
+  it('should handle async functions in Dart', () => {
+    (readFileSync as vi.Mock).mockReturnValue('Future<void> fetchData() async {}\nasync void fireAndForget() {}');
+    const adapter = new DartAdapter('test.dart');
+    const functions = adapter.extractFunctions();
+    const asyncFns = functions.filter(fn => (fn as {type: string}).type === 'async_function');
+    expect(asyncFns.length).toBeGreaterThan(0);
+  });
+
+  it('should handle abstract class declarations in Dart', () => {
+    (readFileSync as vi.Mock).mockReturnValue('abstract class Repository {\n  void save();\n}\n');
+    const adapter = new DartAdapter('test.dart');
+    const classes = adapter.extractClasses();
+    const abstractClasses = classes.filter(cls => (cls as {type: string}).type === 'abstract_class');
+    expect(abstractClasses.length).toBeGreaterThan(0);
+  });
+});

package/principles/adapters/__tests__/go.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi } from 'vitest';
+import { GoAdapter } from '../go';
+
+vi.mock('fs', () => ({
+  readFileSync: vi.fn(),
+  existsSync: vi.fn(() => true),
+}));
+
+import { readFileSync } from 'fs';
+
+describe('GoAdapter', () => {
+  it('should implement the Adapter interface', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
+    const adapter = new GoAdapter('test.go');
+    
+    expect(adapter).toHaveProperty('detectLanguage');
+    expect(adapter).toHaveProperty('parseAST');
+    expect(adapter).toHaveProperty('extractFunctions');
+    expect(adapter).toHaveProperty('extractClasses');
+    expect(adapter).toHaveProperty('countLines');
+  });
+
+  it('should detect language as go for .go files', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}');
+    const adapter = new GoAdapter('test.go');
+    const detected = adapter.detectLanguage();
+    expect(detected).toBe('go');
+  });
+
+  it('should parse Go file AST correctly', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
+    const adapter = new GoAdapter('test.go');
+    const ast = adapter.parseAST();
+    expect(ast).toHaveProperty('content');
+    expect(ast).toHaveProperty('language');
+    expect(ast).toHaveProperty('filePath');
+    expect(ast.language).toBe('go');
+  });
+
+  it('should extract functions from Go AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nfunc (t *TestClass) method() {}');
+    const adapter = new GoAdapter('test.go');
+    const functions = adapter.extractFunctions();
+    expect(Array.isArray(functions)).toBe(true);
+    expect(functions.some(fn => (fn as {name: string}).name === 'testFn')).toBe(true);
+  });
+
+  it('should extract structs from Go AST', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\ntype TestClass struct {}');
+    const adapter = new GoAdapter('test.go');
+    const classes = adapter.extractClasses();
+    expect(Array.isArray(classes)).toBe(true);
+    expect(classes.some(cls => (cls as {name: string}).name === 'TestClass')).toBe(true);
+  });
+
+  it('should count Go file physical lines', () => {
+    (readFileSync as vi.Mock).mockReturnValue('func testFn() {}\nfunc testFn2() {}');
+    const adapter = new GoAdapter('test.go');
+    const lineCount = adapter.countLines();
+    expect(lineCount).toBe(2);
+  });
+
+  it('should fall back to super.detectLanguage for non-go extensions', () => {
+    (readFileSync as vi.Mock).mockReturnValue('content');
+    const adapter = new GoAdapter('test.ts');
+    expect(adapter.detectLanguage()).toBe('typescript');
+  });
+});