@goast/kotlin 0.4.2-beta1 → 0.4.3

package/esm/src/ast/nodes/enum-value.test.js

@@ -0,0 +1,115 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktAnnotation } from './annotation.js';
+import { ktDoc } from './doc.js';
+import { ktEnumValue } from './enum-value.js';
+describe('ktEnumValue', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    it('should write enum value', () => {
+        builder.append(ktEnumValue('FOO'));
+        expect(builder.toString(false)).toBe('FOO');
+    });
+    it('should write enum value with arguments', () => {
+        builder.append(ktEnumValue('FOO', { arguments: ['x', 'y'] }));
+        expect(builder.toString(false)).toBe('FOO(x, y)');
+    });
+    it('should write enum value with documenation', () => {
+        builder.append(ktEnumValue('FOO', { doc: ktDoc('This is a foo') }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}FOO`);
+    });
+    it('should write enum value with annotations', () => {
+        builder.append(ktEnumValue('FOO', { annotations: [ktAnnotation('Deprecated')] }));
+        expect(builder.toString(false)).toBe(`@Deprecated${EOL}FOO`);
+    });
+    it('should write enum value with members', () => {
+        builder.append(ktEnumValue('FOO', {
+            members: ['// Comment 1', '// Comment 2'],
+        }));
+        expect(builder.toString(false)).toBe(`FOO {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}`);
+    });
+    it('should write enum value with all options', () => {
+        builder.append(ktEnumValue('FOO', {
+            doc: ktDoc('This is a foo'),
+            annotations: [ktAnnotation('Deprecated')],
+            arguments: ['x', 'y'],
+            members: ['// Comment 1', '// Comment 2'],
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
+         * This is a foo
+         */
+        @Deprecated
+        FOO(x, y) {
+            // Comment 1
+            // Comment 2
+        }`));
+    });
+    it('should render injections', () => {
+        builder.append(ktEnumValue('FOO', {
+            doc: ktDoc('This is a foo'),
+            annotations: [ktAnnotation('Deprecated')],
+            arguments: ['x', 'y'],
+            members: ['// Comment 1', '// Comment 2'],
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+                beforeAnnotations: '║ba║',
+                afterAnnotations: '║aa║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeArguments: '║ba║',
+                afterArguments: '║aa║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+                beforeMembers: '║bm║',
+                afterMembers: '║am║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
+        /**
+         * This is a foo
+         */
+        ║ad║║ba║@Deprecated
+        ║aa║║bn║FOO║an║║ba║(x, y)║aa║ ║bb║{
+            ║bm║// Comment 1
+            // Comment 2
+            ║am║
+        }║ab║║a║`));
+    });
+});
+describe('writeKtEnumValues', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    it('should write enum values in single line', () => {
+        ktEnumValue.write(builder, [ktEnumValue('FOO'), ktEnumValue('BAR')]);
+        expect(builder.toString(false)).toBe('FOO, BAR');
+    });
+    it('should write enum values in multiline', () => {
+        ktEnumValue.write(builder, [
+            ktEnumValue('FOO'),
+            ktEnumValue('BAR'),
+            ktEnumValue('BAZ'),
+            ktEnumValue('QUX'),
+            ktEnumValue('QUUX'),
+        ]);
+        expect(builder.toString(false)).toBe(`FOO,${EOL}BAR,${EOL}BAZ,${EOL}QUX,${EOL}QUUX`);
+    });
+    it('should write enum values with space between', () => {
+        ktEnumValue.write(builder, [
+            ktEnumValue('FOO'),
+            ktEnumValue('BAR', { annotations: [ktAnnotation('Deprecated')] }),
+            ktEnumValue('BAZ'),
+        ]);
+        expect(builder.toString(false)).toBe(`FOO,${EOL}${EOL}@Deprecated${EOL}BAR,${EOL}${EOL}BAZ`);
+    });
+});

package/esm/src/ast/nodes/enum.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=enum.test.d.ts.map

package/esm/src/ast/nodes/enum.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/enum.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/enum.test.js

@@ -0,0 +1,129 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktAnnotation } from './annotation.js';
+import { ktConstructor } from './constructor.js';
+import { ktDoc } from './doc.js';
+import { ktEnumValue } from './enum-value.js';
+import { ktEnum } from './enum.js';
+import { ktObject } from './object.js';
+import { ktParameter } from './parameter.js';
+describe('ktEnum', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    it('should write enum', () => {
+        builder.append(ktEnum('Foo'));
+        expect(builder.toString(false)).toBe(`enum class Foo${EOL}`);
+    });
+    it('should write enum with values', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR'), ktEnumValue('BAZ')]));
+        expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR, BAZ${EOL}}${EOL}`);
+    });
+    it('should write documenation', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { doc: ktDoc('This is a foo') }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
+    });
+    it('should write annotations', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { annotations: [ktAnnotation('Deprecated')] }));
+        expect(builder.toString(false)).toBe(`@Deprecated${EOL}enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
+    });
+    it('should write access modifiers', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { accessModifier: 'private' }));
+        expect(builder.toString(false)).toBe(`private enum class Foo {${EOL}    BAR${EOL}}${EOL}`);
+    });
+    it('should write primary constructor', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
+            primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
+        }));
+        expect(builder.toString(false)).toBe(`enum class Foo(x: Int, y: Int) {${EOL}    BAR(0, 1)${EOL}}${EOL}`);
+    });
+    it('should write members', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR'), ktEnumValue('BAZ')], { members: ['// Comment 1', '// Comment 2'] }));
+        expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR, BAZ;${EOL}${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`);
+    });
+    it('should write implemented interfaces', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { implements: ['Bar', 'Baz'] }));
+        expect(builder.toString(false)).toBe(`enum class Foo : Bar, Baz {${EOL}    BAR${EOL}}${EOL}`);
+    });
+    it('should write companion object', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR')], { companionObject: ktObject() }));
+        expect(builder.toString(false)).toBe(`enum class Foo {${EOL}    BAR;${EOL}${EOL}    companion object {}${EOL}}${EOL}`);
+    });
+    it('should write all options', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
+            doc: ktDoc('This is a foo'),
+            annotations: [ktAnnotation('Deprecated')],
+            accessModifier: 'private',
+            primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
+            implements: ['Bar', 'Baz'],
+            members: ['// Comment 1', '// Comment 2'],
+            companionObject: ktObject(),
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
+         * This is a foo
+         */
+        @Deprecated
+        private enum class Foo(x: Int, y: Int) : Bar, Baz {
+            BAR(0, 1);
+
+            companion object {}
+
+            // Comment 1
+            // Comment 2
+        }
+        `));
+    });
+    it('should render injections', () => {
+        builder.append(ktEnum('Foo', [ktEnumValue('BAR', { arguments: ['0', '1'] })], {
+            doc: ktDoc('This is a foo'),
+            annotations: [ktAnnotation('Deprecated')],
+            accessModifier: 'private',
+            primaryConstructor: ktConstructor([ktParameter('x', 'Int'), ktParameter('y', 'Int')]),
+            implements: ['Bar', 'Baz'],
+            members: ['// Comment 1', '// Comment 2'],
+            companionObject: ktObject(),
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+                beforeAnnotations: '║ba║',
+                afterAnnotations: '║aa║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforePrimaryConstructor: '║bpc║',
+                afterPrimaryConstructor: '║apc║',
+                beforeImplements: '║bi║',
+                afterImplements: '║ai║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+                beforeValues: '║bv║',
+                afterValues: '║av║',
+                beforeMembers: '║bm║',
+                afterMembers: '║am║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
+        /**
+         * This is a foo
+         */
+        ║ad║║ba║@Deprecated
+        ║aa║║bm║private ║am║enum class ║bn║Foo║an║║bpc║(x: Int, y: Int)║apc║ : ║bi║Bar, Baz║ai║ ║bb║{
+            ║bv║BAR(0, 1);
+
+            ║av║║bm║companion object {}
+
+            // Comment 1
+            // Comment 2
+            ║am║
+        }║ab║
+        ║a║`));
+    });
+});

package/esm/src/ast/nodes/function.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=function.test.d.ts.map

package/esm/src/ast/nodes/function.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"function.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/function.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/function.test.js

@@ -0,0 +1,160 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktAnnotation } from './annotation.js';
+import { ktDoc } from './doc.js';
+import { ktFunction } from './function.js';
+import { ktGenericParameter } from './generic-parameter.js';
+import { ktParameter } from './parameter.js';
+describe('ktFunction', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    it('should write an empty function', () => {
+        builder.append(ktFunction('foo'));
+        expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
+    });
+    it('should write a function with generics', () => {
+        builder.append(ktFunction('foo', { generics: [ktGenericParameter('T')] }));
+        expect(builder.toString(false)).toBe(`fun <T> foo() {}${EOL}`);
+    });
+    it('should write a function with a single parameter', () => {
+        builder.append(ktFunction('foo', { parameters: [ktParameter('x', 'Int')] }));
+        expect(builder.toString(false)).toBe(`fun foo(x: Int) {}${EOL}`);
+    });
+    it('should write a function with a return type', () => {
+        builder.append(ktFunction('foo', { returnType: 'Int' }));
+        expect(builder.toString(false)).toBe(`fun foo(): Int {}${EOL}`);
+    });
+    it('should write a function with a body', () => {
+        builder.append(ktFunction('foo', { body: 'println("Hello")' }));
+        expect(builder.toString(false)).toBe(`fun foo() {${EOL}    println("Hello")${EOL}}${EOL}`);
+    });
+    it('should write access modifiers if they exist', () => {
+        builder.append(ktFunction('foo', { accessModifier: 'private' }));
+        expect(builder.toString(false)).toBe(`private fun foo() {}${EOL}`);
+    });
+    it('should write all annotations', () => {
+        builder.append(ktFunction('foo', { annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')] }));
+        expect(builder.toString(false)).toBe(`@Inject${EOL}@Optional${EOL}fun foo() {}${EOL}`);
+    });
+    it('should write receiver type if it exists', () => {
+        builder.append(ktFunction('foo', { receiverType: 'String' }));
+        expect(builder.toString(false)).toBe(`fun String.foo() {}${EOL}`);
+    });
+    it('should write receiver annotations if they exist and a receiver type exists', () => {
+        builder.append(ktFunction('foo', { receiverType: 'String', receiverAnnotations: [ktAnnotation('Fancy')] }));
+        expect(builder.toString(false)).toBe(`fun @Fancy String.foo() {}${EOL}`);
+    });
+    it('shoudl not write receiver annotations if they exist and a receiver type does not exist', () => {
+        builder.append(ktFunction('foo', { receiverAnnotations: [ktAnnotation('Fancy')] }));
+        expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
+    });
+    it('should write single expression if configured and body exists', () => {
+        builder.append(ktFunction('foo', { body: '42', singleExpression: true }));
+        expect(builder.toString(false)).toBe(`fun foo() = 42${EOL}`);
+    });
+    it('should not write single expression if configured and body does not exist', () => {
+        builder.append(ktFunction('foo', { singleExpression: true }));
+        expect(builder.toString(false)).toBe(`fun foo() {}${EOL}`);
+    });
+    it('should write open keyword if configured', () => {
+        builder.append(ktFunction('foo', { open: true }));
+        expect(builder.toString(false)).toBe(`open fun foo() {}${EOL}`);
+    });
+    it('should write inline keyword if configured', () => {
+        builder.append(ktFunction('foo', { inline: true }));
+        expect(builder.toString(false)).toBe(`inline fun foo() {}${EOL}`);
+    });
+    it('should write infix keyword if configured', () => {
+        builder.append(ktFunction('foo', { infix: true }));
+        expect(builder.toString(false)).toBe(`infix fun foo() {}${EOL}`);
+    });
+    it('should write tailrec keyword if configured', () => {
+        builder.append(ktFunction('foo', { tailrec: true }));
+        expect(builder.toString(false)).toBe(`tailrec fun foo() {}${EOL}`);
+    });
+    it('should write operator keyword if configured', () => {
+        builder.append(ktFunction('foo', { operator: true }));
+        expect(builder.toString(false)).toBe(`operator fun foo() {}${EOL}`);
+    });
+    it('should write override keyword if configured', () => {
+        builder.append(ktFunction('foo', { override: true }));
+        expect(builder.toString(false)).toBe(`override fun foo() {}${EOL}`);
+    });
+    it('should write abstract keyword if configured', () => {
+        builder.append(ktFunction('foo', { abstract: true }));
+        expect(builder.toString(false)).toBe(`abstract fun foo()${EOL}`);
+    });
+    it('should write documenation if it exists', () => {
+        builder.append(ktFunction('foo', { doc: ktDoc('This is a function') }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * This is a function${EOL} */${EOL}fun foo() {}${EOL}`);
+    });
+    it('should write all the parts of the function', () => {
+        builder.append(ktFunction('foo', {
+            generics: [ktGenericParameter('T')],
+            parameters: [ktParameter('x', 'Int')],
+            returnType: 'Int',
+            doc: ktDoc('This is a function'),
+            body: 'println("Hello")',
+            accessModifier: 'private',
+            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+            receiverType: 'String',
+            receiverAnnotations: [ktAnnotation('Fancy')],
+            singleExpression: true,
+            open: true,
+            inline: true,
+            infix: true,
+            tailrec: true,
+            operator: true,
+            override: true,
+        }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * This is a function${EOL} */${EOL}@Inject${EOL}@Optional${EOL}private inline infix tailrec open override operator fun <T> @Fancy String.foo(x: Int): Int = println("Hello")${EOL}`);
+    });
+    it('should render injections', () => {
+        builder.append(ktFunction('foo', {
+            generics: [ktGenericParameter('T')],
+            parameters: [ktParameter('x', 'Int')],
+            doc: ktDoc('This is a function'),
+            returnType: 'Int',
+            body: 'println("Hello")',
+            accessModifier: 'private',
+            annotations: [ktAnnotation('Inject'), ktAnnotation('Optional')],
+            receiverType: 'String',
+            receiverAnnotations: [ktAnnotation('Fancy')],
+            singleExpression: true,
+            open: true,
+            inline: true,
+            infix: true,
+            tailrec: true,
+            operator: true,
+            override: true,
+            inject: {
+                before: '║bg║',
+                after: '║ag║',
+                beforeGenerics: '║bgg║',
+                afterGenerics: '║agg║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeParameters: '║bp║',
+                afterParameters: '║ap║',
+                beforeReturnType: '║br║',
+                afterReturnType: '║ar║',
+                beforeReceiverType: '║brt║',
+                afterReceiverType: '║art║',
+                beforeReceiverAnnotations: '║bra║',
+                afterReceiverAnnotations: '║ara║',
+                beforeAnnotations: '║ba║',
+                afterAnnotations: '║aa║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(`║bg║║bd║${EOL}/**${EOL} * This is a function${EOL} */${EOL}║ad║║ba║@Inject${EOL}@Optional${EOL}║aa║║bm║private inline infix tailrec open override operator ║am║fun ║bgg║<T>║agg║ ║bra║@Fancy ║ara║║brt║String║art║.║bn║foo║an║║bp║(x: Int)║ap║: ║br║Int║ar║ = println("Hello")${EOL}║ag║`);
+    });
+});

package/esm/src/ast/nodes/generic-parameter.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=generic-parameter.test.d.ts.map

package/esm/src/ast/nodes/generic-parameter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic-parameter.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/generic-parameter.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/generic-parameter.test.js

@@ -0,0 +1,49 @@
+import "../../../_dnt.test_polyfills.js";
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktGenericParameter } from './generic-parameter.js';
+describe('ktGenericParameter', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    describe('single', () => {
+        it('should write the name of the parameter', () => {
+            builder.append(ktGenericParameter('T'));
+            expect(builder.toString(false)).toBe('T');
+        });
+        it('should write the constraint if it exists', () => {
+            builder.append(ktGenericParameter('T', { constraint: 'number' }));
+            expect(builder.toString(false)).toBe('T : number');
+        });
+        it('should render injections', () => {
+            builder.append(ktGenericParameter('T', {
+                constraint: 'number',
+                inject: {
+                    before: '║b║',
+                    after: '║a║',
+                    beforeName: '║bn║',
+                    afterName: '║an║',
+                    beforeConstraint: '║bc║',
+                    afterConstraint: '║ac║',
+                },
+            }));
+            expect(builder.toString(false)).toBe('║b║║bn║T║an║ : ║bc║number║ac║║a║');
+        });
+    });
+    describe('multiple', () => {
+        it('should not write anything if the node is empty', () => {
+            ktGenericParameter.write(builder, []);
+            expect(builder.toString(false)).toBe('');
+        });
+        it('should write a single parameter', () => {
+            ktGenericParameter.write(builder, [ktGenericParameter('T')]);
+            expect(builder.toString(false)).toBe('<T>');
+        });
+        it('should write all the parameters', () => {
+            ktGenericParameter.write(builder, [ktGenericParameter('T'), ktGenericParameter('U')]);
+            expect(builder.toString(false)).toBe('<T, U>');
+        });
+    });
+});

package/esm/src/ast/nodes/init-block.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=init-block.test.d.ts.map

package/esm/src/ast/nodes/init-block.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-block.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/init-block.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/init-block.test.js

@@ -0,0 +1,28 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktInitBlock } from './init-block.js';
+describe('ktInitBlock', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    it('should write an empty init block', () => {
+        builder.append(ktInitBlock(''));
+        expect(builder.toString(false)).toBe(`init {}${EOL}`);
+    });
+    it('should write an init block with a single statement', () => {
+        builder.append(ktInitBlock('println("Hello")'));
+        expect(builder.toString(false)).toBe(`init {${EOL}    println("Hello")${EOL}}${EOL}`);
+    });
+    it('should write an init block with multiple statements', () => {
+        builder.append(ktInitBlock((b) => b.appendLine('println("Hello")').appendLine('println("World")')));
+        expect(builder.toString(false)).toBe(`init {${EOL}    println("Hello")${EOL}    println("World")${EOL}}${EOL}`);
+    });
+    it('should render injections', () => {
+        builder.append(ktInitBlock('println("Hello")', { inject: { before: ['before'], after: ['after'] } }));
+        expect(builder.toString(false)).toBe(`beforeinit {${EOL}    println("Hello")${EOL}}${EOL}after`);
+    });
+});

package/esm/src/ast/nodes/interface.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=interface.test.d.ts.map

package/esm/src/ast/nodes/interface.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/interface.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}

package/esm/src/ast/nodes/interface.test.js

@@ -0,0 +1,121 @@
+import "../../../_dnt.test_polyfills.js";
+import { EOL } from 'node:os';
+import { expect } from '../../../deps/jsr.io/@std/expect/1.0.7/expect.js';
+import { beforeEach, describe, it } from '../../../deps/jsr.io/@std/testing/1.0.4/bdd.js';
+import { normalizeEOL } from '@goast/test-utils';
+import { KotlinFileBuilder } from '../../file-builder.js';
+import { ktAnnotation } from './annotation.js';
+import { ktDoc } from './doc.js';
+import { ktGenericParameter } from './generic-parameter.js';
+import { ktInterface } from './interface.js';
+import { ktObject } from './object.js';
+describe('ktInterface', () => {
+    let builder;
+    beforeEach(() => {
+        builder = new KotlinFileBuilder();
+    });
+    it('should write interface', () => {
+        builder.append(ktInterface('Foo'));
+        expect(builder.toString(false)).toBe(`interface Foo${EOL}`);
+    });
+    it('should write generics', () => {
+        builder.append(ktInterface('Foo', { generics: [ktGenericParameter('T'), ktGenericParameter('U')] }));
+        expect(builder.toString(false)).toBe(`interface Foo<T, U>${EOL}`);
+    });
+    it('should write members', () => {
+        builder.append(ktInterface('Foo', {
+            members: ['// Comment 1', '// Comment 2'],
+        }));
+        expect(builder.toString(false)).toBe(`interface Foo {${EOL}    // Comment 1${EOL}    // Comment 2${EOL}}${EOL}`);
+    });
+    it('should write extended interfaces', () => {
+        builder.append(ktInterface('Foo', { extends: ['Bar', 'Baz'] }));
+        expect(builder.toString(false)).toBe(`interface Foo : Bar, Baz${EOL}`);
+    });
+    it('should write annotations', () => {
+        builder.append(ktInterface('Foo', { annotations: [ktAnnotation('Deprecated')] }));
+        expect(builder.toString(false)).toBe(`@Deprecated${EOL}interface Foo${EOL}`);
+    });
+    it('should write access modifiers', () => {
+        builder.append(ktInterface('Foo', { accessModifier: 'private' }));
+        expect(builder.toString(false)).toBe(`private interface Foo${EOL}`);
+    });
+    it('should write documenation', () => {
+        builder.append(ktInterface('Foo', { doc: ktDoc('This is a foo') }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * This is a foo${EOL} */${EOL}interface Foo${EOL}`);
+    });
+    it('should write generic parameter description', () => {
+        builder.append(ktInterface('Foo', { generics: [ktGenericParameter('T', { description: 'The type' })] }));
+        expect(builder.toString(false)).toBe(`/**${EOL} * @param T The type${EOL} */${EOL}interface Foo<T>${EOL}`);
+    });
+    it('should write companion object', () => {
+        builder.append(ktInterface('Foo', { companionObject: ktObject() }));
+        expect(builder.toString(false)).toBe(`interface Foo {${EOL}    companion object {}${EOL}}${EOL}`);
+    });
+    it('should write all options', () => {
+        builder.append(ktInterface('Foo', {
+            doc: ktDoc('This is a foo'),
+            annotations: [ktAnnotation('Deprecated')],
+            accessModifier: 'private',
+            extends: ['Bar', 'Baz'],
+            generics: [ktGenericParameter('T')],
+            members: ['// Comment 1', '// Comment 2'],
+            companionObject: ktObject(),
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`/**
+         * This is a foo
+         */
+        @Deprecated
+        private interface Foo<T> : Bar, Baz {
+            companion object {}
+
+            // Comment 1
+            // Comment 2
+        }
+        `));
+    });
+    it('should render injections', () => {
+        builder.append(ktInterface('Foo', {
+            doc: ktDoc('This is a foo'),
+            annotations: [ktAnnotation('Deprecated')],
+            accessModifier: 'private',
+            extends: ['Bar', 'Baz'],
+            generics: [ktGenericParameter('T')],
+            members: ['// Comment 1', '// Comment 2'],
+            companionObject: ktObject(),
+            inject: {
+                before: '║b║',
+                after: '║a║',
+                beforeDoc: '║bd║',
+                afterDoc: '║ad║',
+                beforeAnnotations: '║ba║',
+                afterAnnotations: '║aa║',
+                beforeModifiers: '║bm║',
+                afterModifiers: '║am║',
+                beforeName: '║bn║',
+                afterName: '║an║',
+                beforeGenerics: '║bg║',
+                afterGenerics: '║ag║',
+                beforeExtends: '║be║',
+                afterExtends: '║ae║',
+                beforeBody: '║bb║',
+                afterBody: '║ab║',
+                beforeMembers: '║bm║',
+                afterMembers: '║am║',
+            },
+        }));
+        expect(builder.toString(false)).toBe(normalizeEOL(8)(`║b║║bd║
+        /**
+         * This is a foo
+         */
+        ║ad║║ba║@Deprecated
+        ║aa║║bm║private ║am║interface ║bn║Foo║an║║bg║<T>║ag║ : ║be║Bar, Baz║ae║ ║bb║{
+            ║bm║companion object {}
+
+            // Comment 1
+            // Comment 2
+            ║am║
+        }║ab║
+        ║a║`));
+    });
+});

package/esm/src/ast/nodes/object.test.d.ts

@@ -0,0 +1,2 @@
+import "../../../_dnt.test_polyfills.js";
+//# sourceMappingURL=object.test.d.ts.map

package/esm/src/ast/nodes/object.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.test.d.ts","sourceRoot":"","sources":["../../../../src/src/ast/nodes/object.test.ts"],"names":[],"mappings":"AAAA,OAAO,iCAAiC,CAAC"}