Program.spec.ts

import { assert, expect } from './chai-config.spec';
import * as path from 'path';
import * as pick from 'object.pick';
import * as sinonImport from 'sinon';
import { CancellationTokenSource, CompletionItemKind, Position, Range } from 'vscode-languageserver';
import * as fsExtra from 'fs-extra';
import { DiagnosticMessages } from './DiagnosticMessages';
import { DEFAULT_MIN_FIRMWARE_VERSION } from './RokuConstants';
import type { BrsFile } from './files/BrsFile';
import type { XmlFile } from './files/XmlFile';
import type { BsConfig } from './BsConfig';
import type { TranspileObj } from './Program';
import { Program } from './Program';
import { standardizePath as s, util } from './util';
import { URI } from 'vscode-uri';
import PluginInterface from './PluginInterface';
import type { FunctionStatement, PrintStatement } from './parser/Statement';
import { EmptyStatement } from './parser/Statement';
import { expectCompletionsExcludes, expectCompletionsIncludes, expectDiagnostics, expectHasDiagnostics, expectThrows, expectThrowsAsync, expectZeroDiagnostics, trim, trimMap } from './testHelpers.spec';
import { doesNotThrow } from 'assert';
import { createVisitor, WalkMode } from './astUtils/visitors';
import { isBrsFile } from './astUtils/reflection';
import type { LiteralExpression } from './parser/Expression';
import type { AstEditor } from './astUtils/AstEditor';
import { tempDir, rootDir, stagingDir } from './testHelpers.spec';
import type { BsDiagnostic, Plugin } from './interfaces';
import { createLogger } from './logging';
import { Scope } from './Scope';
import undent from 'undent';
import { SourceMapConsumer } from 'source-map';

let sinon = sinonImport.createSandbox();

describe('Program', () => {
    let program: Program;

    beforeEach(() => {
        fsExtra.ensureDirSync(tempDir);
        fsExtra.emptyDirSync(tempDir);
        program = new Program({
            rootDir: rootDir,
            stagingDir: stagingDir
        });
        program.createSourceScope(); //ensure source scope is created
    });
    afterEach(() => {
        sinon.restore();
        fsExtra.ensureDirSync(tempDir);
        fsExtra.emptyDirSync(tempDir);
        program.dispose();
    });

    it('does not throw exception after calling validate() after dispose()', () => {
        program.setFile('source/themes/alpha.bs', `
            sub main()
            end sub
        `);
        program.dispose();
        program.validate();
    });

    it('Does not crash for file not referenced by any other scope', async () => {
        program.setFile('tests/testFile.spec.bs', `
            function main(args as object) as object
                return roca(args).describe("test suite", sub()
                    m.pass()
                end sub)
            end function
        `);
        program.validate();
        //test passes if this line does not throw
        await program.getTranspiledFileContents('tests/testFile.spec.bs');
    });

    describe('global scope', () => {
        it('returns all callables when asked', () => {
            expect(program.globalScope.getAllCallables().length).to.be.greaterThan(0);
        });
        it('validate gets called and does nothing', () => {
            expect(program.globalScope.validate()).to.eql(undefined);
        });
    });

    describe('addFile', () => {
        it('adds various files to `pkgMap`', () => {
            program.setFile('source/main.brs', '');
            expect(program['pkgMap']).to.have.property(s`source/main.brs`);

            program.setFile('source/main.bs', '');
            expect(program['pkgMap']).to.have.property(s`source/main.bs`);

            program.setFile('components/comp1.xml', '');
            expect(program['pkgMap']).to.have.property(s`components/comp1.xml`);
        });

        it('does not crash when given a totally bogus file', () => {
            program.setFile('source/main.brs', `class Animalpublic name as stringpublic function walk()end functionend class`);
            //if the program didn't get stuck in an infinite loop, this test passes
        });

        it('flags unsupported statements at root of file', () => {
            program.setFile('source/main.brs', `
                result = true
                print true
                createObject("roSGNode", "Rectangle")
            `);
            program.validate();
            expectDiagnostics(program, [{
                ...DiagnosticMessages.unexpectedStatementOutsideFunction()
            }, {
                ...DiagnosticMessages.unexpectedStatementOutsideFunction()
            }, {
                ...DiagnosticMessages.unexpectedStatementOutsideFunction()
            }]);
        });

        it('only parses xml files as components when file is found within the "components" folder', () => {
            expect(Object.keys(program.files).length).to.equal(0);

            program.setFile('components/comp1.xml', '');
            expect(Object.keys(program.files).length).to.equal(1);

            program.setFile('notComponents/comp1.xml', '');
            expect(Object.keys(program.files).length).to.equal(1);

            program.setFile('componentsExtra/comp1.xml', '');
            expect(Object.keys(program.files).length).to.equal(1);
        });

        it('supports empty statements for transpile', async () => {
            const file = program.setFile<BrsFile>('source/main.bs', `
                sub main()
                    m.logError()
                    'some comment
                end sub
            `);
            (file.parser.ast.statements[0] as FunctionStatement).func.body.statements[0] = new EmptyStatement();
            await program.transpile([{ src: file.srcPath, dest: file.pkgPath }], tempDir);
        });

        it('works with different cwd', () => {
            let projectDir = s`${tempDir}/project2`;
            fsExtra.ensureDirSync(projectDir);
            program = new Program({ cwd: projectDir });
            program.setFile('source/lib.brs', 'function main()\n    print "hello world"\nend function');
            // await program.reloadFile('source/lib.brs', `'this is a comment`);
            //if we made it to here, nothing exploded, so the test passes
        });

        it(`adds files in the source folder to the 'source' scope`, () => {
            expect(program.getScopeByName('source')).to.exist;
            //no files in source scope
            expect(program.getScopeByName('source').getOwnFiles().length).to.equal(0);

            //add a new source file
            program.setFile('source/main.brs', '');
            //file should be in source scope now
            expect(program.getScopeByName('source').getFile('source/main.brs')).to.exist;

            //add an unreferenced file from the components folder
            program.setFile('components/component1/component1.brs', '');

            //source scope should have the same number of files
            expect(program.getScopeByName('source').getFile('source/main.brs')).to.exist;
            expect(program.getScopeByName('source').getFile(`${rootDir}/components/component1/component1.brs`)).not.to.exist;
        });

        it('normalizes file paths', () => {
            program.setFile('source/main.brs', '');

            expect(program.getScopeByName('source').getFile('source/main.brs')).to.exist;

            //shouldn't throw an exception because it will find the correct path after normalizing the above path and remove it
            try {
                program.removeFile('source/main.brs');
                //no error
            } catch (e) {
                assert.fail(null, null, 'Should not have thrown exception');
            }
        });

        it('creates a scope for every component xml file', () => {
            // let componentPath = path.resolve(`${rootDir}/components/component1.xml`);
            // await program.loadOrReloadFile('components', '')
        });

        it(`emits events for scope and file creation`, () => {
            const beforeProgramValidate = sinon.spy();
            const afterProgramValidate = sinon.spy();
            const afterScopeCreate = sinon.spy();
            const beforeScopeValidate = sinon.spy();
            const afterScopeValidate = sinon.spy();
            const beforeFileParse = sinon.spy();
            const afterFileParse = sinon.spy();
            const afterFileValidate = sinon.spy();
            program.plugins = new PluginInterface([{
                name: 'emits events for scope and file creation',
                beforeProgramValidate: beforeProgramValidate,
                afterProgramValidate: afterProgramValidate,
                afterScopeCreate: afterScopeCreate,
                beforeScopeValidate: beforeScopeValidate,
                afterScopeValidate: afterScopeValidate,
                beforeFileParse: beforeFileParse,
                afterFileParse: afterFileParse,
                afterFileValidate: afterFileValidate
            }], { logger: createLogger() });

            //add a new source file
            program.setFile('source/main.brs', '');
            //add a component file
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/lib.brs" />
                </component>`);
            program.validate();

            //program events
            expect(beforeProgramValidate.callCount).to.equal(1);
            expect(afterProgramValidate.callCount).to.equal(1);
            //scope events
            //(we get component scope event only because source is created in beforeEach)
            expect(afterScopeCreate.callCount).to.equal(1);
            expect(beforeScopeValidate.callCount).to.equal(2);
            expect(afterScopeValidate.callCount).to.equal(2);
            //file events
            expect(beforeFileParse.callCount).to.equal(2);
            expect(afterFileParse.callCount).to.equal(2);
            expect(afterFileValidate.callCount).to.equal(2);
        });
    });

    describe('validate', () => {
        it('does not lose scope diagnostics in second validation after cancelling the previous validation', async () => {
            program.setFile('source/Direction.bs', `
                enum Direction
                    up = "up"
                end enum
            `);
            program.setFile('source/test.bs', `
                import "Direction.bs"
                sub test()
                    print Direction.down
                end sub
            `);

            //add several scopes so we have time to cancel the validation
            for (let i = 0; i < 3; i++) {
                program.setFile(`components/Component${i}.xml`, undent`
                    <component name="Component${i}" extends="Group">
                        <script uri="pkg:/source/test.bs" />
                    </component>
                `);
            }
            program.validate();
            //ensure the diagnostic is there during normal run
            expectDiagnostics(program, [
                DiagnosticMessages.unknownEnumValue('down', 'Direction').message
            ]);

            const cancel = new CancellationTokenSource();

            let count = 0;
            const plugin = {
                name: 'cancel validation',
                beforeProgramValidate: () => {
                    count++;
                    //if this is the second validate, remove the plugin and change the file to invalidate the scopes again
                    if (count === 2) {
                        program.plugins.remove(plugin);
                        program.setFile('source/test.bs', program.getFile('source/test.bs').fileContents + `'comment`);
                    }
                },
                afterScopeValidate: () => {
                    //if the diagnostic is avaiable, we know it's safe to cancel
                    if (program.getDiagnostics().find(x => x.code === DiagnosticMessages.unknownEnumValue('down', 'Direction').code)) {
                        cancel.cancel();
                    }
                }
            } as Plugin;
            //add a plugin that monitors where we are in the process, so we can cancel the validate at the correct time
            program.plugins.add(plugin);

            //change the file so it forces a reload
            program.setFile('source/test.bs', program.getFile('source/test.bs').fileContents + `'comment`);

            //now trigger two validations, the first one will be cancelled, the second one will run to completion
            await Promise.all([
                program.validate({
                    async: true,
                    cancellationToken: cancel.token
                }),
                program.validate({
                    async: true
                })
            ]);

            //ensure the diagnostic is there after a cancelled run (with a subsequent completed run)
            expectDiagnostics(program, [
                DiagnosticMessages.unknownEnumValue('down', 'Direction').message
            ]);
        });

        it('validate (sync) passes along inner exception', () => {
            program.setFile('source/main.brs', ``);
            sinon.stub(Scope.prototype, 'validate').callsFake(() => {
                throw new Error('Scope crash');
            });
            expectThrows(() => {
                program.validate();
            }, 'Scope crash');
        });

        it('validate (async) passes along inner exception', async () => {
            program.setFile('source/main.brs', ``);
            sinon.stub(Scope.prototype, 'validate').callsFake(() => {
                throw new Error('Scope crash');
            });
            await expectThrowsAsync(async () => {
                await program.validate({
                    async: true
                });
            }, 'Scope crash');
        });

        it('retains expressions after validate', () => {
            const file = program.setFile<BrsFile>('source/main.bs', `
                sub test()
                    print a.b.c
                end sub
            `);
            //disable the plugins
            expect(file.parser.references.expressions).to.be.lengthOf(1);
            program.validate();
            expect(file.parser.references.expressions).to.be.lengthOf(1);
        });
        it('catches duplicate XML component names', () => {
            //add 2 components which both reference the same errored file
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                </component>
            `);
            program.setFile('components/component2.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                </component>
            `);
            program.validate();
            expectDiagnostics(program, [{
                ...DiagnosticMessages.duplicateComponentName('Component1'),
                range: Range.create(1, 17, 1, 27),
                relatedInformation: [{
                    location: util.createLocation(
                        URI.file(s`${rootDir}/components/component2.xml`).toString(),
                        Range.create(1, 17, 1, 27)
                    ),
                    message: 'Also defined here'
                }]
            }, {
                ...DiagnosticMessages.duplicateComponentName('Component1'),
                range: Range.create(1, 17, 1, 27),
                relatedInformation: [{
                    location: util.createLocation(
                        URI.file(s`${rootDir}/components/component1.xml`).toString(),
                        Range.create(1, 17, 1, 27)
                    ),
                    message: 'Also defined here'
                }]
            }]);
        });

        it('allows adding diagnostics', () => {
            const expected = [{
                message: 'message',
                file: undefined,
                range: undefined
            }] as any as BsDiagnostic[];
            program.addDiagnostics(expected);
            const actual = (program as any).diagnostics;
            expect(actual).to.deep.equal(expected);
        });

        it('does not produce duplicate parse errors for different component scopes', () => {
            //add a file with a parse error
            program.setFile('components/lib.brs', `
                sub DoSomething()
                    'random out-of-place open paren, definitely causes parse error
                    (
                end sub
            `);

            //add 2 components which both reference the same errored file
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/lib.brs" />
                </component>
            `);
            program.setFile('components/component2.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component2" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/lib.brs" />
                </component>
            `);

            program.validate();
            expectHasDiagnostics(program, 1);
        });

        it('detects scripts not loaded by any file', () => {
            //add a main file for sanity check
            program.setFile('source/main.brs', '');
            program.validate();
            expectZeroDiagnostics(program);

            //add the orphaned file
            program.setFile('components/lib.brs', '');
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.fileNotReferencedByAnyOtherFile()
            ]);
        });

        it('does not throw errors on shadowed init functions in components', () => {
            program.setFile('lib.brs', `
                function DoSomething()
                    return true
                end function
            `);

            program.setFile('components/Parent.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Parent" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/lib.brs" />
                </component>
            `);

            program.setFile('components/Child.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Child" extends="Parent">
                </component>
            `);

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('recognizes global function calls', () => {
            expectZeroDiagnostics(program);
            program.setFile('source/file.brs', `
                function DoB()
                    sleep(100)
                end function
            `);
            //validate the scope
            program.validate();
            expectZeroDiagnostics(program);
        });

        it('shows warning when a child component imports the same script as its parent', () => {
            program.setFile('components/parent.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/lib.brs" />
                </component>
            `);

            program.setFile('components/child.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ChildScene" extends="ParentScene">
                    <script type="text/brightscript" uri="pkg:/lib.brs" />
                </component>
            `);

            program.setFile('lib.brs', `'comment`);
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.unnecessaryScriptImportInChildFromParent('ParentScene')
            ]);
        });

        it('adds info diag when child component method shadows parent component method', () => {
            program.setFile('components/parent.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/parent.brs" />
                </component>
            `);

            program.setFile('components/child.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ChildScene" extends="ParentScene">
                    <script type="text/brightscript" uri="pkg:/child.brs" />
                </component>
            `);

            program.setFile('parent.brs', `sub DoSomething()\nend sub`);
            program.setFile('child.brs', `sub DoSomething()\nend sub`);
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.overridesAncestorFunction('', '', '', '').code
            ]);
        });

        it('does not add info diagnostic on shadowed "init" functions', () => {
            program.setFile('components/parent.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                    <script type="text/brightscript" uri="parent.brs" />
                </component>
                `);
            program.setFile(`components/parent.brs`, `sub Init()\nend sub`);
            program.setFile(`components/child.brs`, `sub Init()\nend sub`);

            program.setFile('components/child.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ChildScene" extends="ParentScene">
                    <script type="text/brightscript" uri="child.brs" />
                </component>
            `);
            //run this validate separately so we can have an easier time debugging just the child component
            program.validate();
            expectZeroDiagnostics(program);
        });

        it('catches duplicate methods in single file', () => {
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
                sub DoSomething()
                end sub
            `);
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.duplicateFunctionImplementation('DoSomething', 'source'),
                DiagnosticMessages.duplicateFunctionImplementation('DoSomething', 'source')
            ]);
        });

        it('catches duplicate methods across multiple files', () => {
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
            `);
            program.setFile('source/lib.brs', `
                sub DoSomething()
                end sub
            `);
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.duplicateFunctionImplementation('DoSomething', 'source'),
                DiagnosticMessages.duplicateFunctionImplementation('DoSomething', 'source')
            ]);
        });

        it('maintains correct callables list', () => {
            let initialCallableCount = program.getScopeByName('source').getAllCallables().length;
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
                sub DoSomething()
                end sub
            `);
            expect(program.getScopeByName('source').getAllCallables().length).equals(initialCallableCount + 2);
            //set the file contents again (resetting the wasProcessed flag)
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
                sub DoSomething()
                end sub
                `);
            expect(program.getScopeByName('source').getAllCallables().length).equals(initialCallableCount + 2);
            program.removeFile(`${rootDir}/source/main.brs`);
            expect(program.getScopeByName('source').getAllCallables().length).equals(initialCallableCount);
        });

        it('resets errors on revalidate', () => {
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
                sub DoSomething()
                end sub
            `);
            program.validate();
            expectHasDiagnostics(program, 2);
            //set the file contents again (resetting the wasProcessed flag)
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
                sub DoSomething()
                end sub
            `);
            program.validate();
            expectHasDiagnostics(program, 2);

            //load in a valid file, the errors should go to zero
            program.setFile('source/main.brs', `
                sub DoSomething()
                end sub
            `);
            program.validate();
            expectZeroDiagnostics(program);
        });

        it('identifies invocation of unknown function', () => {
            //call a function that doesn't exist
            program.setFile('source/main.brs', `
                sub Main()
                    name = "Hello"
                    DoSomething(name)
                end sub
            `);

            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.cannotFindFunction('DoSomething')
            ]);
        });

        it('supports using vars defined in nested if statements', () => {
            //call a function that doesn't exist
            program.setFile({ src: `${rootDir}/source/main.brs`, dest: 'source/main.brs' }, `
                sub Main()
                    if true
                        name = "bob"
                    end if
                    print name
                end sub
            `);

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('supports using `m` vars in parameter default values', () => {
            //call a function that doesn't exist
            program.setFile({ src: `${rootDir}/source/main.brs`, dest: 'source/main.brs' }, `
                function findNode(nodeId as string, parentNode = m.top as object)
                    return parentNode.findNode(nodeId)
                end function
            `);

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('detects methods from another file in a subdirectory', () => {
            program.setFile('source/main.brs', `
                sub Main()
                    DoSomething()
                end sub
            `);
            program.setFile('source/ui/lib.brs', `
                function DoSomething()
                    print "hello world"
                end function
            `);
            program.validate();
            expectZeroDiagnostics(program);
        });

        it('properly handles errors in async mode', async () => {
            const file = program.setFile<BrsFile>('source/main.brs', ``);
            file.validate = () => {
                throw new Error('Crash for test');
            };
            let error: Error;
            try {
                await program.validate({ async: true });
            } catch (e) {
                error = e as any;
            }
            expect(error?.message).to.eql('Crash for test');
        });

        it('includes files added during beforeProgramValidate in validation', () => {
            program.setFile('source/a.brs', `
                sub a()
                    b()
                end sub
            `);

            program.plugins.add({
                name: 'add file in beforeProgramValidate',
                beforeProgramValidate: () => {
                    program.setFile('source/b.brs', `
                        sub b()
                        end sub
                    `);
                }
            });

            program.validate();
            expectZeroDiagnostics(program);
        });
    });

    describe('hasFile', () => {
        it('recognizes when it has a file loaded', () => {
            expect(program.hasFile('file1.brs')).to.be.false;
            program.setFile('file1.brs', `'comment`);
            expect(program.hasFile('file1.brs')).to.be.true;
        });
    });

    describe('getPaths', () => {
        function getPaths(...args: any[]) {
            return (program as any).getPaths(...args);
        }
        it('works for dest', () => {
            expect(
                getPaths('source/main.brs', rootDir)
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });

        it('works for absolute src', () => {
            expect(
                getPaths(`${rootDir}/source\\main.brs`, rootDir)
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });

        it('works for missing src', () => {
            expect(
                getPaths({ dest: 'source/main.brs' }, rootDir)
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });

        it('works for missing dest', () => {
            expect(
                getPaths({ src: `${rootDir}/source/main.brs` }, rootDir)
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });

        it('works for pkg string', () => {
            expect(
                getPaths('pkg:/source/main.brs', rootDir)
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });

        it('favors pkgPath over destPath', () => {
            expect(
                getPaths({ srcPath: `${rootDir}/source/main.brs`, destPath: 'source/DontUse.brs', pkgPath: `pkg:/source/main.brs` })
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });

        it('works when given a file', () => {
            expect(
                getPaths({ srcPath: `${rootDir}/source/main.brs`, pkgPath: `source/main.brs` })
            ).to.eql({
                srcPath: s`${rootDir}/source/main.brs`,
                pkgPath: s`source/main.brs`
            });
        });
    });

    describe('setFile', () => {
        it('links xml scopes based on xml parent-child relationships', () => {
            program.setFile('components/ParentScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                </component>
            `);

            //create child component
            program.setFile('components/ChildScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ChildScene" extends="ParentScene">
                </component>
            `);

            expect(program.getScopeByName('components/ChildScene.xml').getParentScope().name).to.equal(s`components/ParentScene.xml`);

            //change the parent's name.
            program.setFile('components/ParentScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="NotParentScene" extends="Scene">
                </component>
            `);

            //The child scope should no longer have the link to the parent scope, and should instead point back to global
            expect(program.getScopeByName('components/ChildScene.xml').getParentScope().name).to.equal('global');
        });

        it('creates a new scope for every added component xml', () => {
            //we have global callables, so get that initial number
            program.setFile('components/component1.xml', '');
            expect(program.getScopeByName(`components/component1.xml`)).to.exist;

            program.setFile('components/component1.xml', '');
            program.setFile('components/component2.xml', '');
            expect(program.getScopeByName(`components/component1.xml`)).to.exist;
            expect(program.getScopeByName(`components/component2.xml`)).to.exist;
        });

        it('includes referenced files in xml scopes', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/component1.brs" />
                </component>
            `);
            program.setFile('components/component1.brs', '');

            let scope = program.getScopeByName(`components/component1.xml`);
            expect(scope.getFile('components/component1.xml').pkgPath).to.equal(s`components/component1.xml`);
            expect(scope.getFile('components/component1.brs').pkgPath).to.equal(s`components/component1.brs`);
        });

        it('adds xml file to files map', () => {
            program.setFile('components/component1.xml', '');
            expect(program.getFile('components/component1.xml')).to.exist;
        });

        it('detects missing script reference', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/component1.brs" />
                </component>
            `);
            program.validate();
            expectDiagnostics(program, [{
                ...DiagnosticMessages.referencedFileDoesNotExist(),
                range: Range.create(2, 42, 2, 72)
            }]);
        });

        it('accepts libpkg .brs script reference', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="libpkg:/components/component1.brs" />
                </component>
            `);
            program.setFile('components/component1.brs', '');

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('accepts libpkg .bs script reference', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="libpkg:/components/component1.bs" />
                </component>
            `);
            program.setFile('components/component1.bs', '');

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('does not set function not found diagnostic for function in libpkg referenced script reference', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="libpkg:/components/component1.brs" />
                    <interface>
                        <function name="isFound"/>
                    </interface>
                </component>
            `);
            program.setFile('components/component1.brs', `
                function isFound()
                end function`
            );

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('does not set function not found diagnostic for function in libpkg referenced .bs script reference', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="libpkg:/components/component1.bs" />
                    <interface>
                        <function name="isFound"/>
                    </interface>
                </component>
            `);
            program.setFile('components/component1.bs', `
                function isFound()
                end function`
            );

            program.validate();
            expectZeroDiagnostics(program);
        });

        it('sets function not found diagnostic for missing function in libpkg referenced script reference', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="libpkg:/components/component1.brs" />
                    <interface>
                        <function name="isNotFound"/>
                    </interface>
                </component>
            `);
            program.setFile('components/component1.brs', `
                function isFound()
                end function`
            );

            program.validate();

            expectDiagnostics(program, [
                DiagnosticMessages.xmlFunctionNotFound('isNotFound')
            ]);
        });

        it('adds warning instead of error on mismatched upper/lower case script import', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="component1.brs" />
                </component>
            `);
            program.setFile('components/COMPONENT1.brs', '');

            //validate
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.scriptImportCaseMismatch(s`components\\COMPONENT1.brs`, 'COMPONENT1.brs')
            ]);
        });

        it('includes a correctly-cased relative path in the diagnostic data for a relative import', () => {
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="component1.brs" />
                </component>
            `);
            program.setFile('components/COMPONENT1.brs', '');

            program.validate();
            const diagnostics = program.getDiagnostics();
            const mismatch = diagnostics.find(d => d.code === DiagnosticMessages.scriptImportCaseMismatch('').code);
            expect((mismatch?.data as any)?.correctFilePath).to.equal('COMPONENT1.brs');
        });

        it('includes a correctly-cased relative path for imports across directories', () => {
            program.setFile('components/sub/comp.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="comp" extends="Scene">
                    <script type="text/brightscript" uri="../utils/helper.brs" />
                </component>
            `);
            program.setFile('components/utils/HELPER.brs', '');

            program.validate();
            const diagnostics = program.getDiagnostics();
            const mismatch = diagnostics.find(d => d.code === DiagnosticMessages.scriptImportCaseMismatch('').code);
            expect((mismatch?.data as any)?.correctFilePath).to.equal('../utils/HELPER.brs');
        });
    });

    describe('reloadFile', () => {
        it('picks up new files in a scope when an xml file is loaded', () => {
            program.options.ignoreErrorCodes!.push(1013);
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/component1.brs" />
                </component>
            `);
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.referencedFileDoesNotExist()
            ]);

            //add the file, the error should go away
            program.setFile('components/component1.brs', '');
            program.validate();
            expectZeroDiagnostics(program);

            //add the xml file back in, but change the component brs file name. Should have an error again
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/component2.brs" />
                </component>
            `);
            program.validate();
            expectDiagnostics(program, [
                DiagnosticMessages.referencedFileDoesNotExist()
            ]);
        });

        it('handles when the brs file is added before the component', () => {
            let brsPath = s`${rootDir}/components/component1.brs`;
            program.setFile('components/component1.brs', '');

            let xmlFile = program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/component1.brs" />
                </component>
            `);
            program.validate();
            expectZeroDiagnostics(program);
            expect(program.getScopeByName(xmlFile.pkgPath).getFile(brsPath)).to.exist;
        });

        it('reloads referenced fles when xml file changes', () => {
            program.options.ignoreErrorCodes!.push(1013);
            program.setFile('components/component1.brs', '');

            let xmlFile = program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">

                </component>
            `);
            program.validate();
            expectZeroDiagnostics(program);
            expect(program.getScopeByName(xmlFile.pkgPath).getFile('components/component1.brs')).not.to.exist;

            //reload the xml file contents, adding a new script reference.
            xmlFile = program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/components/component1.brs" />
                </component>
            `);

            expect(program.getScopeByName(xmlFile.pkgPath).getFile('components/component1.brs')).to.exist;
        });
    });

    describe('getCodeActions', () => {
        it('does not fail when file is missing from program', () => {
            doesNotThrow(() => {
                program.getCodeActions('not/real/file', util.createRange(1, 2, 3, 4));
            });
        });
    });

    describe('getCompletions', () => {
        it('includes `for each` variable', () => {
            program.setFile('source/main.brs', `
                sub main()
                    items = [1, 2, 3]
                    for each thing in items
                        t =
                    end for
                    end for
                end sub
            `);
            program.validate();
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(4, 28)).map(x => x.label);
            expect(completions).to.include('thing');
        });

        it('finds enum member after dot', () => {
            program.setFile('source/main.bs', `
                sub test()
                    thing = alpha.Direction.
                end sub
                namespace alpha
                    enum Direction
                        up
                    end enum
                end namespace
            `);
            program.validate();
            const completions = program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 44));
            expect(completions.map(x => ({ kind: x.kind, label: x.label }))).to.eql([{
                label: 'up',
                kind: CompletionItemKind.EnumMember
            }]);
        });

        it('finds enum member after dot in if statement', () => {
            program.setFile('source/main.bs', `
                sub test()
                    if alpha.beta. then
                    end if
                end sub
                namespace alpha.beta
                    const isEnabled = true
                end namespace
            `);
            program.validate();
            const completions = program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 34));
            expect(completions.map(x => ({ kind: x.kind, label: x.label }))).to.eql([{
                label: 'isEnabled',
                kind: CompletionItemKind.Constant
            }]);
        });

        it('includes `for` variable', () => {
            program.setFile('source/main.brs', `
                sub main()
                    for i = 0 to 10
                        t =
                    end for
                end sub
            `);
            program.validate();
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(3, 28)).map(x => x.label);
            expect(completions).to.include('i');
        });

        it('should include first-level namespace names for brighterscript files', () => {
            program.setFile('source/main.bs', `
                namespace NameA.NameB.NameC
                    sub DoSomething()
                    end sub
                end namespace
                sub main()
                    print
                end sub
            `);
            expectCompletionsIncludes(program.getCompletions(`${rootDir}/source/main.bs`, Position.create(6, 25)), [{
                label: 'NameA',
                kind: CompletionItemKind.Module
            }]);
            expectCompletionsExcludes(program.getCompletions(`${rootDir}/source/main.bs`, Position.create(6, 25)), [{
                label: 'NameB',
                kind: CompletionItemKind.Module
            }, {
                label: 'NameA.NameB',
                kind: CompletionItemKind.Module
            }, {
                label: 'NameA.NameB.NameC',
                kind: CompletionItemKind.Module
            }, {
                label: 'NameA.NameB.NameC.DoSomething',
                kind: CompletionItemKind.Module
            }]);
        });

        it('resolves completions for namespaces with next namespace part for brighterscript file', () => {
            program.setFile('source/main.bs', `
                namespace NameA.NameB.NameC
                    sub DoSomething()
                    end sub
                end namespace
                sub main()
                    NameA.
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.bs`, Position.create(6, 26)).map(x => x.label);
            expect(completions).to.include('NameB');
            expect(completions).not.to.include('NameA');
            expect(completions).not.to.include('NameA.NameB');
            expect(completions).not.to.include('NameA.NameB.NameC');
            expect(completions).not.to.include('NameA.NameB.NameC.DoSomething');
        });

        it('finds namespace members for brighterscript file', () => {
            program.setFile('source/main.bs', `
                sub main()
                    NameA.
                    NameA.NameB.
                    NameA.NameB.NameC.
                end sub
                namespace NameA
                    sub alertA()
                    end sub
                end namespace
                namespace NameA
                    sub info()
                    end sub
                end namespace
                namespace NameA.NameB
                    sub alertB()
                    end sub
                end namespace
                namespace NameA.NameB.NameC
                    sub alertC()
                    end sub
                end namespace
            `);
            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 26)).map(x => x.label).sort()
            ).to.eql(['NameB', 'alertA', 'info']);

            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(3, 32)).map(x => x.label).sort()
            ).to.eql(['NameC', 'alertB']);

            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(4, 38)).map(x => x.label).sort()
            ).to.eql(['alertC']);
        });

        it('finds namespace members for classes', () => {
            program.setFile('source/main.bs', `
                sub main()
                    NameA.
                    NameA.NameB.
                    NameA.NameB.NameC.
                end sub
                namespace NameA
                    sub alertA()
                    end sub
                end namespace
                namespace NameA
                    sub info()
                    end sub
                    class MyClassA
                    end class
                end namespace
                namespace NameA.NameB
                    sub alertB()
                    end sub
                    class MyClassB
                    end class
                end namespace
                namespace NameA.NameB.NameC
                    sub alertC()
                    end sub
                end namespace
            `);
            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 26)).map(x => x.label).sort()
            ).to.eql(['MyClassA', 'NameB', 'alertA', 'info']);

            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(3, 32)).map(x => x.label).sort()
            ).to.eql(['MyClassB', 'NameC', 'alertB']);

            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(4, 38)).map(x => x.label).sort()
            ).to.eql(['alertC']);
        });

        it('finds only namespaces that have classes, when new keyword is used', () => {
            program.setFile('source/main.bs', `
                sub main()
                    a = new NameA.
                    b = new NameA.NameB.
                    c = new NameA.NameB.NameC.
                end sub
                namespace NameA
                    sub alertA()
                    end sub
                end namespace
                namespace NameA
                    sub info()
                    end sub
                    class MyClassA
                    end class
                end namespace
                namespace NameA.NoClassA
                end namespace
                namespace NameA.NoClassB
                end namespace
                namespace NameA.NameB
                    sub alertB()
                    end sub
                    class MyClassB
                    end class
                end namespace
                namespace NameA.NameB.NoClass
                end namespace
                namespace NameA.NameB.NameC
                    sub alertC()
                    end sub
                end namespace
            `);
            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 34)).map(x => x.label).sort()
            ).to.eql(['MyClassA', 'NameB']);

            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(3, 40)).map(x => x.label).sort()
            ).to.eql(['MyClassB']);

            expect(
                program.getCompletions(`${rootDir}/source/main.bs`, Position.create(4, 46)).map(x => x.label).sort()
            ).to.be.empty;
        });

        //Bron.. pain to get this working.. do we realy need this? seems moot with ropm..
        it.skip('should include translated namespace function names for brightscript files', () => {
            program.setFile('source/main.bs', `
                namespace NameA.NameB.NameC
                    sub DoSomething()
                    end sub
                end namespace
            `);
            program.setFile('source/lib.brs', `
                sub test()

                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/lib.brs`, Position.create(2, 23));
            expect(completions.map(x => x.label)).to.include('NameA_NameB_NameC_DoSomething');
        });

        it('inlcudes global completions for file with no scope', () => {
            program.setFile('main.brs', `
                function Main()
                    age = 1
                end function
            `);
            let completions = program.getCompletions('main.brs', Position.create(2, 10));
            expect(completions.filter(x => x.label.toLowerCase() === 'abs')).to.be.lengthOf(1);
        });

        it('filters out text results for top-level function statements', () => {
            program.setFile('source/main.brs', `
                function Main()
                    age = 1
                end function
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 10));
            expect(completions.filter(x => x.label === 'Main')).to.be.lengthOf(1);
        });

        it('does not filter text results for object properties used in conditional statements', () => {
            program.setFile('source/main.brs', `
                sub Main()
                    p.
                end sub
                sub SayHello()
                    person = {}
                    if person.isAlive then
                        print "Hello"
                    end if
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 22));
            expect(completions.filter(x => x.label === 'isAlive')).to.be.lengthOf(1);
        });

        it('does not filter text results for object properties used in assignments', () => {
            program.setFile('source/main.brs', `
                sub Main()
                    p.
                end sub
                sub SayHello()
                   person = {}
                   localVar = person.name
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 22));
            expect(completions.filter(x => x.label === 'name')).to.be.lengthOf(1);
        });

        it('does not filter text results for object properties', () => {
            program.setFile('source/main.brs', `
                sub Main()
                    p.
                end sub
                sub SayHello()
                   person = {}
                   person.name = "bob"
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 22));
            expect(completions.filter(x => x.label === 'name')).to.be.lengthOf(1);
        });

        it('filters out text results for local vars used in conditional statements', () => {
            program.setFile('source/main.brs', `
                sub Main()

                end sub
                sub SayHello()
                    isTrue = true
                    if isTrue then
                        print "is true"
                    end if
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 10));
            expect(completions.filter(x => x.label === 'isTrue')).to.be.lengthOf(0);
        });

        it('filters out text results for local variable assignments', () => {
            program.setFile('source/main.brs', `
                sub Main()

                end sub
                sub SayHello()
                    message = "Hello"
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 10));
            expect(completions.filter(x => x.label === 'message')).to.be.lengthOf(0);
        });

        it('filters out text results for local variables used in assignments', () => {
            program.setFile('source/main.brs', `
                sub Main()

                end sub
                sub SayHello()
                    message = "Hello"
                    otherVar = message
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 10));
            expect(completions.filter(x => x.label === 'message')).to.be.lengthOf(0);
        });

        it('does not suggest local variables when initiated to the right of a period', () => {
            program.setFile('source/main.brs', `
                function Main()
                    helloMessage = "jack"
                    person.hello
                end function
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(3, 32));
            expect(completions.filter(x => x.kind === CompletionItemKind.Variable).map(x => x.label)).not.to.contain('helloMessage');
        });

        it('finds all file paths when initiated on xml uri', () => {
            let xmlPath = s`${rootDir}/components/component1.xml`;
            program.setFile('components/component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="HeroScene" extends="Scene">
                    <script type="text/brightscript" uri="" />
                </component>
            `);
            program.setFile('components/component1.brs', '');
            let completions = program.getCompletions(xmlPath, Position.create(2, 42));
            expect(completions[0]).to.include({
                kind: CompletionItemKind.File,
                label: 'component1.brs'
            });
            expect(completions[1]).to.include({
                kind: CompletionItemKind.File,
                label: 'pkg:/components/component1.brs'
            });
            //it should NOT include the global methods
            expect(completions).to.be.lengthOf(2);
        });

        it('get all functions and properties in scope when doing any dotted get on non m ', () => {
            program.setFile('source/main.bs', `
                sub main()
                    thing.anonPropA = "foo"
                    thing.anonPropB = "bar"
                    thing.person
                end sub
                class MyClassA
                    personName = "rafa"
                    personAName = "rafaA"
                    function personAMethodA()
                    end function
                    function personAMethodB()
                    end function
                end class
                namespace NameA
                    sub alertA()
                    end sub
                end namespace
                namespace NameA.NameB
                    sub alertB()
                    end sub
                    class MyClassB
                        personName = "roger"
                        personBName = "rogerB"
                        function personAMethodC()
                        end function
                        function personBMethodA()
                        end function
                        function personBMethodB()
                        end function
                    end class
                end namespace
                namespace NameA.NameB.NameC
                    sub alertC()
                    end sub
                end namespace
            `);
            //note - we let the vscode extension do the filtering, so we still return everything; otherwise it exhibits strange behaviour in the IDE
            expect(
                (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(4, 32))).map(x => x.label).sort()
            ).to.eql(['anonPropA', 'anonPropB', 'person', 'personAMethodA', 'personAMethodB', 'personAMethodC', 'personAName', 'personBMethodA', 'personBMethodB', 'personBName', 'personName']);
        });

        it('get all functions and properties relevant for m ', () => {
            program.setFile('source/main.bs', `
                class MyClassA
                    function new()
                        m.
                    end function
                    personName = "rafa"
                    personAName = "rafaA"
                    function personAMethodA()
                    end function
                    function personAMethodB()
                    end function
                end class
                class MyClassB
                    personName = "roger"
                    personBName = "rogerB"
                    function personAMethodC()
                    end function
                    function personBMethodA()
                    end function
                    function personBMethodB()
                    end function
                end class
                class MyClassC extends MyClassA
                    function new()
                        m.
                    end function
                    personCName = "rogerC"
                    function personCMethodC()
                    end function
                    function personCMethodA()
                    end function
                    function personCMethodB()
                    end function
                end class
                sub alertC()
                end sub
            `);
            expect(
                (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(3, 26))).map(x => x.label).sort()
            ).to.eql(['personAMethodA', 'personAMethodB', 'personAName', 'personName']);
            expect(
                (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(24, 26))).map(x => x.label).sort()
            ).to.eql(['personAMethodA', 'personAMethodB', 'personAName', 'personCMethodA', 'personCMethodB', 'personCMethodC', 'personCName', 'personName']);
        });

    });

    it('include non-namespaced classes in the list of general output', () => {
        program.setFile('source/main.bs', `
                function regularFunc()
                    MyClass
                end function
                sub alertC()
                end sub
                class MyClassA
                end class
                class MyClassB
                end class
                class MyClassC extends MyClassA
                end class
            `);
        expect(
            (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(3, 26))).map(x => x.label).sort()
        ).to.include.members(['MyClassA', 'MyClassB', 'MyClassC']);
    });

    it('only include classes when using new keyword', () => {
        program.setFile('source/main.bs', `
                class MyClassA
                end class
                class MyClassB
                end class
                class MyClassC extends MyClassA
                end class
                function regularFunc()
                    new MyClass
                end function
                sub alertC()
                end sub
            `);
        expect(
            (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(8, 29))).map(x => x.label).sort()
        ).to.eql(['MyClassA', 'MyClassB', 'MyClassC']);
    });

    it('gets completions when using callfunc inovation', () => {
        program.setFile('source/main.bs', `
            function main()
                myNode@.sayHello(arg1)
            end function
        `);
        program.setFile('components/MyNode.bs', `
            function sayHello(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/MyNode.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="Component1" extends="Scene">
                <script type="text/brightscript" uri="pkg:/components/MyNode.bs" />
                <interface>
                    <function name="sayHello"/>
                </interface>
            </component>`);
        program.validate();

        expect(
            (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 30))).map(x => x.label).sort()
        ).to.eql(['sayHello']);
    });

    it('gets completions for callfunc invocation with multiple nodes', () => {
        program.setFile('source/main.bs', `
            function main()
                myNode@.sayHello(arg1)
            end function
        `);
        program.setFile('components/MyNode.bs', `
            function sayHello(text, text2)
            end function
            function sayHello2(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/MyNode.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="Component1" extends="Scene">
                <script type="text/brightscript" uri="pkg:/components/MyNode.bs" />
                <interface>
                    <function name="sayHello"/>
                    <function name="sayHello2"/>
                </interface>
            </component>`);
        program.setFile('components/MyNode2.bs', `
            function sayHello3(text, text2)
            end function
            function sayHello4(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/MyNode2.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="Component2" extends="Scene">
                <script type="text/brightscript" uri="pkg:/components/MyNode2.bs" />
                <interface>
                    <function name="sayHello3"/>
                    <function name="sayHello4"/>
                </interface>
            </component>`);
        program.validate();

        expect(
            (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 30))).map(x => x.label).sort()
        ).to.eql(['sayHello', 'sayHello2', 'sayHello3', 'sayHello4']);
    });

    it('gets completions for callfunc invocation with multiple nodes and validates single code completion results', () => {
        program.setFile('source/main.bs', `
            function main()
                ParentNode@.sayHello(arg1)
            end function
        `);
        program.setFile('components/ParentNode.bs', `
            function sayHello(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/ParentNode.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="ParentNode" extends="Scene">
                <script type="text/brightscript" uri="pkg:/components/ParentNode.bs" />
                <interface>
                    <function name="sayHello"/>
                </interface>
            </component>`);
        program.setFile('components/ChildNode.bs', `
            function sayHello(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/ChildNode.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="ChildNode" extends="ParentNode">
                <script type="text/brightscript" uri="pkg:/components/ChildNode.bs" />
            </component>`);
        program.validate();

        expect(
            (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 30))).map(x => x.label).sort()
        ).to.eql(['sayHello']);
    });

    it('gets completions for extended nodes with callfunc invocation - ensure overridden methods included', () => {
        program.setFile('source/main.bs', `
            function main()
                myNode@.sayHello(arg1)
            end function
        `);
        program.setFile('components/MyNode.bs', `
            function sayHello(text, text2)
            end function
            function sayHello2(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/MyNode.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="Component1" extends="Scene">
                <script type="text/brightscript" uri="pkg:/components/MyNode.bs" />
                <interface>
                    <function name="sayHello"/>
                    <function name="sayHello2"/>
                </interface>
            </component>`);
        program.setFile('components/MyNode2.bs', `
            function sayHello3(text, text2)
            end function
            function sayHello2(text, text2)
            end function
            function sayHello4(text, text2)
            end function
        `);
        program.setFile<XmlFile>('components/MyNode2.xml',
            trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="Component2" extends="Component1">
                <script type="text/brightscript" uri="pkg:/components/MyNode2.bs" />
                <interface>
                    <function name="sayHello3"/>
                    <function name="sayHello4"/>
                </interface>
            </component>`);
        program.validate();

        expect(
            (program.getCompletions(`${rootDir}/source/main.bs`, Position.create(2, 30))).map(x => x.label).sort()
        ).to.eql(['sayHello', 'sayHello2', 'sayHello3', 'sayHello4']);
    });

    describe('xml inheritance', () => {
        it('handles parent-child attach and detach', () => {
            //create parent component
            let parentFile = program.setFile('components/ParentScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                </component>
            `);

            //create child component
            let childFile = program.setFile('components/ChildScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ChildScene" extends="ParentScene">
                </component>
            `);

            //the child should have been attached to the parent
            expect((childFile as XmlFile).parentComponent).to.equal(parentFile);

            //change the name of the parent
            parentFile = program.setFile('components/ParentScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="NotParentScene" extends="Scene">
                </component>
            `);

            //the child should no longer have a parent
            expect((childFile as XmlFile).parentComponent).not.to.exist;
        });

        it('provides child components with parent functions', () => {
            //create parent component
            program.setFile('components/ParentScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                </component>
            `);

            //create child component
            program.setFile('components/ChildScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ChildScene" extends="ParentScene">
                    <script type="text/brightscript" uri="ChildScene.brs" />
                </component>
            `);
            program.setFile('components/ChildScene.brs', `
                sub Init()
                    DoParentThing()
                end sub
            `);

            program.validate();

            //there should be an error when calling DoParentThing, since it doesn't exist on child or parent
            expectDiagnostics(program, [
                DiagnosticMessages.cannotFindFunction('DoParentThing')
            ]);

            //add the script into the parent
            program.setFile('components/ParentScene.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="ParentScene" extends="Scene">
                    <script type="text/brightscript" uri="ParentScene.brs" />
                </component>
            `);

            program.setFile('components/ParentScene.brs', `
                sub DoParentThing()

                end sub
            `);

            program.validate();
            //the error should be gone because the child now has access to the parent script
            expectZeroDiagnostics(program);
        });
    });

    describe('xml scope', () => {
        it('does not fail on base components with many children', () => {
            program.setFile('source/lib.brs', `
                sub DoSomething()
                end sub
            `);

            //add a brs file with invalid syntax
            program.setFile('components/base.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="BaseScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/source/lib.brs" />
                </component>
            `);
            let childCount = 20;
            //add many children, we should never encounter an error
            for (let i = 0; i < childCount; i++) {
                program.setFile(`components/child${i}.xml`, trim`
                    <?xml version="1.0" encoding="utf-8" ?>
                    <component name="Child${i}" extends="BaseScene">
                        <script type="text/brightscript" uri="pkg:/source/lib.brs" />
                    </component>
                `);
            }
            program.validate();

            //the children shouldn't have diagnostics about shadowing their parent lib.brs file.
            expectZeroDiagnostics(
                program.getDiagnostics().filter((x) => x.code === DiagnosticMessages.overridesAncestorFunction('', '', '', '').code)
            );

            //the children all include a redundant import of lib.brs file which is imported by the parent.
            expect(
                program.getDiagnostics().filter((x) => x.code === DiagnosticMessages.unnecessaryScriptImportInChildFromParent('').code)
            ).to.be.lengthOf(childCount);
        });

        it('detects script import changes', () => {
            //create the xml file without script imports
            let xmlFile = program.setFile('components/component.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="MyScene" extends="Scene">
                </component>
            `);

            //the component scope should only have the xml file
            expect(program.getScopeByName(xmlFile.pkgPath).getOwnFiles().length).to.equal(1);

            //create the lib file
            let libFile = program.setFile('source/lib.brs', `'comment`);

            //change the xml file to have a script import
            xmlFile = program.setFile('components/component.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="MyScene" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/source/lib.brs" />
                </component>
            `);
            let scope = program.getScopeByName(xmlFile.pkgPath);
            //the component scope should have the xml file AND the lib file
            expect(scope.getOwnFiles().length).to.equal(2);
            expect(scope.getFile(xmlFile.srcPath)).to.exist;
            expect(scope.getFile(libFile.srcPath)).to.exist;

            //reload the xml file again, removing the script import.
            xmlFile = program.setFile('components/component.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="MyScene" extends="Scene">
                </component>
            `);

            //the scope should again only have the xml file loaded
            expect(program.getScopeByName(xmlFile.pkgPath).getOwnFiles().length).to.equal(1);
            expect(program.getScopeByName(xmlFile.pkgPath)).to.exist;
        });
    });

    describe('getFileByPkgPath', () => {
        it('finds file in source folder', () => {
            expect(program.getFileByPkgPath(s`source/main.brs`)).not.to.exist;
            expect(program.getFileByPkgPath(s`source/main2.brs`)).not.to.exist;
            program.setFile('source/main2.brs', '');
            program.setFile('source/main.brs', '');
            expect(program.getFileByPkgPath(s`source/main.brs`)).to.exist;
            expect(program.getFileByPkgPath(s`source/main2.brs`)).to.exist;
        });
    });

    describe('removeFiles', () => {
        it('removes files by absolute paths', () => {
            program.setFile('source/main.brs', '');
            expect(program.getFileByPkgPath(s`source/main.brs`)).to.exist;
            program.removeFiles([`${rootDir}/source/main.brs`]);
            expect(program.getFileByPkgPath(s`source/main.brs`)).not.to.exist;
        });
    });

    describe('getDiagnostics', () => {
        it('includes diagnostics from files not included in any scope', () => {
            program.setFile('components/a/b/c/main.brs', `
                sub A()
                    "this string is not terminated
                end sub
            `);
            //the file should be included in the program
            expect(program.getFile('components/a/b/c/main.brs')).to.exist;
            let diagnostics = program.getDiagnostics();
            expectHasDiagnostics(diagnostics);
            let parseError = diagnostics.filter(x => x.message === 'Unterminated string at end of line')[0];
            expect(parseError).to.exist;
        });

        it('it excludes specified error codes', () => {
            //declare file with two different syntax errors
            program.setFile('source/main.brs', `
                sub A()
                    'call with wrong param count
                    B(1,2,3)

                    'call unknown function
                    C()
                end sub

                sub B(name as string)
                end sub
            `);

            program.validate();
            expectHasDiagnostics(program, 2);

            program.options.diagnosticFilters = [
                DiagnosticMessages.mismatchArgumentCount(0, 0).code
            ];

            expectDiagnostics(program, [
                DiagnosticMessages.cannotFindFunction('C')
            ]);
        });
    });

    describe('getCompletions', () => {
        it('returns all functions in scope', () => {
            program.setFile('source/main.brs', `
                sub Main()

                end sub

                sub ActionA()
                end sub
            `);
            program.setFile('source/lib.brs', `
                sub ActionB()
                end sub
            `);

            program.validate();

            let completions = program
                //get completions
                .getCompletions(`${rootDir}/source/main.brs`, util.createPosition(2, 10))
                //only keep the label property for this test
                .map(x => pick(x, 'label'));

            expect(completions).to.deep.include({ label: 'Main' });
            expect(completions).to.deep.include({ label: 'ActionA' });
            expect(completions).to.deep.include({ label: 'ActionB' });
        });

        it('returns all variables in scope', () => {
            program.setFile('source/main.brs', `
                sub Main()
                    name = "bob"
                    age = 20
                    shoeSize = 12.5
                end sub
                sub ActionA()
                end sub
            `);
            program.setFile('source/lib.brs', `
                sub ActionB()
                end sub
            `);

            program.validate();

            let completions = program.getCompletions(`${rootDir}/source/main.brs`, util.createPosition(2, 10));
            let labels = completions.map(x => pick(x, 'label'));

            expect(labels).to.deep.include({ label: 'Main' });
            expect(labels).to.deep.include({ label: 'ActionA' });
            expect(labels).to.deep.include({ label: 'ActionB' });
            expect(labels).to.deep.include({ label: 'name' });
            expect(labels).to.deep.include({ label: 'age' });
            expect(labels).to.deep.include({ label: 'shoeSize' });
        });

        it('returns empty set when out of range', () => {
            const position = util.createPosition(99, 99);
            program.setFile('source/main.brs', '');
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, position);
            //get the name of all global completions
            const globalCompletions = program.globalScope.getAllFiles().flatMap(x => x.getCompletions(position)).map(x => x.label);
            //filter out completions from global scope
            completions = completions.filter(x => !globalCompletions.includes(x.label));
            expect(completions).to.be.empty;
        });

        it('finds parameters', () => {
            program.setFile('source/main.brs', `
                sub Main(count = 1)
                    firstName = "bob"
                    age = 21
                    shoeSize = 10
                end sub
            `);
            let completions = program.getCompletions(`${rootDir}/source/main.brs`, Position.create(2, 10));
            let labels = completions.map(x => pick(x, 'label'));

            expect(labels).to.deep.include({ label: 'count' });
        });
    });

    it('does not create map by default', async () => {
        fsExtra.ensureDirSync(program.options.stagingDir!);
        program.setFile('source/main.brs', `
            sub main()
            end sub
        `);
        program.validate();
        await program.transpile([], program.options.stagingDir!);
        expect(fsExtra.pathExistsSync(s`${stagingDir}/source/main.brs`)).is.true;
        expect(fsExtra.pathExistsSync(s`${stagingDir}/source/main.brs.map`)).is.false;
    });

    it('creates sourcemap for brs and xml files', async () => {
        fsExtra.ensureDirSync(program.options.stagingDir!);
        program.setFile('source/main.brs', `
            sub main()
            end sub
        `);
        program.setFile('components/comp1.xml', trim`
            <?xml version="1.0" encoding="utf-8" ?>
            <component name="SimpleScene" extends="Scene">
            </component>
        `);
        program.validate();

        expect(fsExtra.pathExistsSync(s`${stagingDir}/source/main.brs.map`)).is.false;
        expect(fsExtra.pathExistsSync(s`${stagingDir}/components/comp1.xml.map`)).is.false;

        let filePaths = [{
            src: s`${rootDir}/source/main.brs`,
            dest: s`source/main.brs`
        }, {
            src: s`${rootDir}/components/comp1.xml`,
            dest: s`components/comp1.xml`
        }];
        program.options.sourceMap = true;
        await program.transpile(filePaths, program.options.stagingDir!);

        expect(fsExtra.pathExistsSync(s`${stagingDir}/source/main.brs.map`)).is.true;
        expect(fsExtra.pathExistsSync(s`${stagingDir}/components/comp1.xml.map`)).is.true;
    });

    describe('sourcemap source paths', () => {
        async function transpileFile(options: BsConfig, pkgPath = 'source/main.bs') {
            fsExtra.ensureDirSync(program.options.stagingDir!);
            program = new Program({
                rootDir: rootDir,
                stagingDir: stagingDir,
                sourceMap: true,
                ...options
            });
            program.setFile(pkgPath, `
                sub main()
                end sub
            `);
            program.validate();
            const src = s`${rootDir}/${pkgPath}`;
            const dest = pkgPath.replace(/\.bs$/, '.brs');
            await program.transpile([{ src: src, dest: dest }], stagingDir);
            const mapPath = s`${stagingDir}/${dest}.map`;
            return JSON.parse(fsExtra.readFileSync(mapPath, 'utf8'));
        }

        it('sources[] contains an absolute path by default', async () => {
            const map = await transpileFile({});
            expect(map.sources).to.have.lengthOf(1);
            expect(path.isAbsolute(map.sources[0])).to.be.true;
            expect(s`${map.sources[0]}`).to.eql(s`${rootDir}/source/main.bs`);
        });

        it('does not write a sourceRoot field to the map by default', async () => {
            const map = await transpileFile({});
            expect(map.sourceRoot).to.be.undefined;
        });

        describe('relativeSourceMaps: true', () => {
            it('sources[] contains a path relative to the map file', async () => {
                const map = await transpileFile({ relativeSourceMaps: true });
                expect(map.sources).to.have.lengthOf(1);
                expect(path.isAbsolute(map.sources[0])).to.be.false;
            });

            it('sources[] relative path resolves back to the original source file', async () => {
                const map = await transpileFile({ relativeSourceMaps: true });
                // map is written to stagingDir/source/main.brs.map
                const mapDir = s`${stagingDir}/source`;
                const resolved = s`${path.resolve(mapDir, map.sources[0])}`;
                expect(resolved).to.eql(s`${rootDir}/source/main.bs`);
            });

            it('does not write a sourceRoot field to the map when sourceRoot is not set', async () => {
                const map = await transpileFile({ relativeSourceMaps: true });
                expect(map.sourceRoot).to.be.undefined;
            });

            it('works for deeply nested files — relative path still resolves correctly', async () => {
                const map = await transpileFile({ relativeSourceMaps: true }, 'source/deeply/nested/main.bs');
                expect(path.isAbsolute(map.sources[0])).to.be.false;
                const mapDir = s`${stagingDir}/source/deeply/nested`;
                const resolved = s`${path.resolve(mapDir, map.sources[0])}`;
                expect(resolved).to.eql(s`${rootDir}/source/deeply/nested/main.bs`);
            });

            describe('with sourceRoot', () => {
                it('writes sourceRoot field to the map', async () => {
                    const customRoot = s`${rootDir}/../customRoot`;
                    const map = await transpileFile({ relativeSourceMaps: true, sourceRoot: customRoot });
                    expect(s`${map.sourceRoot}`).to.eql(customRoot);
                });

                it('sources[] entries are not absolute', async () => {
                    const customRoot = s`${rootDir}/../customRoot`;
                    const map = await transpileFile({ relativeSourceMaps: true, sourceRoot: customRoot });
                    expect(path.isAbsolute(map.sources[0])).to.be.false;
                });

                it('sources[] entry is the path of the source file relative to sourceRoot', async () => {
                    const customRoot = s`${rootDir}/../customRoot`;
                    const map = await transpileFile({ relativeSourceMaps: true, sourceRoot: customRoot });
                    // TranspileState swaps rootDir→sourceRoot, so the embedded srcPath is
                    // customRoot/source/main.bs. Relative to customRoot that is 'source/main.bs'.
                    expect(s`${map.sources[0]}`).to.eql(s`source/main.bs`);
                });

                it('sourceRoot + sources[0] reconstructs the source file path (the consumer contract)', async () => {
                    const customRoot = s`${rootDir}/../customRoot`;
                    const map = await transpileFile({ relativeSourceMaps: true, sourceRoot: customRoot });
                    // A sourcemap consumer resolves: path.resolve(sourceRoot, sources[0])
                    const reconstructed = s`${path.resolve(map.sourceRoot, map.sources[0])}`;
                    expect(reconstructed).to.eql(s`${customRoot}/source/main.bs`);
                });
            });
        });

        describe('relativeSourceMaps: false (legacy)', () => {
            it('sources[] contains an absolute path even when sourceRoot is set', async () => {
                const sourceRoot = s`${rootDir}/../sourceRootFolder`;
                const map = await transpileFile({ sourceRoot: sourceRoot });
                expect(path.isAbsolute(map.sources[0])).to.be.true;
            });

            it('sources[] path has rootDir replaced with sourceRoot', async () => {
                const sourceRoot = s`${rootDir}/../sourceRootFolder`;
                const map = await transpileFile({ sourceRoot: sourceRoot });
                // rootDir portion is swapped for sourceRoot; rest of the path is preserved
                expect(s`${map.sources[0]}`).to.eql(s`${sourceRoot}/source/main.bs`);
            });

            it('does not write a sourceRoot field to the map even when sourceRoot is set', async () => {
                const sourceRoot = s`${rootDir}/../sourceRootFolder`;
                const map = await transpileFile({ sourceRoot: sourceRoot });
                expect(map.sourceRoot).to.be.undefined;
            });

            it('sources[] is unaffected for files outside rootDir', async () => {
                // a file whose srcPath doesn't start with rootDir should not be rewritten
                fsExtra.ensureDirSync(stagingDir);
                program = new Program({
                    rootDir: rootDir,
                    stagingDir: stagingDir,
                    sourceMap: true,
                    sourceRoot: s`${rootDir}/../sourceRootFolder`
                });
                const outsidePath = s`${rootDir}/../outside/main.brs`;
                fsExtra.outputFileSync(outsidePath, 'sub main()\nend sub\n');
                program.setFile({ src: outsidePath, dest: 'source/main.brs' }, fsExtra.readFileSync(outsidePath, 'utf8'));
                program.validate();
                await program.transpile([{
                    src: outsidePath,
                    dest: 'source/main.brs'
                }], stagingDir);
                const map = JSON.parse(fsExtra.readFileSync(s`${stagingDir}/source/main.brs.map`, 'utf8'));
                // path outside rootDir is left as-is (absolute, under its real location)
                expect(s`${map.sources[0]}`).to.eql(outsidePath);
            });
        });
    });

    describe('prebuild sourcemap chaining', () => {
        // A prebuild step produced an intermediate file with a map pointing back to original source.
        // BrighterScript must apply that incoming map so the final output traces all the
        // way to the original source — not just to the intermediate file.

        let prebuildBrsMapJson: string;
        let prebuildXmlMapJson: string;
        const brsSource = 'sub main()\n    print "hello"\nend sub';
        const xmlSource = trim`
            <?xml version="1.0" encoding="utf-8" ?>
            <component name="Comp1" extends="Scene">
            </component>
        `;
        const originalBrsSrc = s`${rootDir}/source/original.bs`;
        const originalXmlSrc = s`${rootDir}/components/original.bxml`;

        beforeEach(async () => {
            const { SourceMapGenerator } = await import('source-map');
            const brsGen = new SourceMapGenerator({ file: 'main.brs' });
            brsGen.addMapping({ generated: { line: 1, column: 0 }, original: { line: 1, column: 0 }, source: originalBrsSrc });
            brsGen.addMapping({ generated: { line: 2, column: 0 }, original: { line: 2, column: 0 }, source: originalBrsSrc });
            brsGen.addMapping({ generated: { line: 3, column: 0 }, original: { line: 3, column: 0 }, source: originalBrsSrc });
            prebuildBrsMapJson = brsGen.toString();

            const xmlGen = new SourceMapGenerator({ file: 'comp1.xml' });
            xmlGen.addMapping({ generated: { line: 1, column: 0 }, original: { line: 1, column: 0 }, source: originalXmlSrc });
            xmlGen.addMapping({ generated: { line: 2, column: 0 }, original: { line: 2, column: 0 }, source: originalXmlSrc });
            xmlGen.addMapping({ generated: { line: 3, column: 0 }, original: { line: 3, column: 0 }, source: originalXmlSrc });
            prebuildXmlMapJson = xmlGen.toString();

            program.options.sourceMap = true;
            fsExtra.ensureDirSync(s`${rootDir}/source`);
            fsExtra.ensureDirSync(s`${rootDir}/components`);
            fsExtra.ensureDirSync(stagingDir);
        });

        async function assertBrsOutputMapChainsToOriginal() {
            program.validate();
            await program.transpile([{ src: s`${rootDir}/source/main.brs`, dest: s`source/main.brs` }], stagingDir);

            const outputMapPath = s`${stagingDir}/source/main.brs.map`;
            expect(fsExtra.pathExistsSync(outputMapPath)).is.true;
            const outputMapJson = JSON.parse(fsExtra.readFileSync(outputMapPath, 'utf8'));

            // Program._getTranspiledFileContents chains the input map via applySourceMap.
            await SourceMapConsumer.with(outputMapJson, null, (consumer) => {
                const pos = consumer.originalPositionFor({ line: 2, column: 4 });
                expect(pos.source, 'output map should chain back to original.bs').to.include('original.bs');
                expect(pos.line).to.eql(2);
            });
        }

        async function assertXmlOutputMapChainsToOriginal() {
            program.validate();
            await program.transpile([{ src: s`${rootDir}/components/comp1.xml`, dest: s`components/comp1.xml` }], stagingDir);

            const outputMapPath = s`${stagingDir}/components/comp1.xml.map`;
            expect(fsExtra.pathExistsSync(outputMapPath)).is.true;
            const outputMapJson = JSON.parse(fsExtra.readFileSync(outputMapPath, 'utf8'));

            // Verify the output map sources include the original pre-prebuild XML source.
            // XML transpile generates character-level mappings, so use LEAST_UPPER_BOUND to
            // find the first mapping at or after column 0 on a given line.
            const originatesFromOriginal = outputMapJson.sources?.some((src: string) => src.includes('original.bxml'));
            expect(originatesFromOriginal, 'output map should chain back to original.bxml').to.be.true;

            await SourceMapConsumer.with(outputMapJson, null, (consumer) => {
                // Use LEAST_UPPER_BOUND to find the first mapping >= (n, 0) since XML maps
                // are character-level and may not start at column 0.
                const pos1 = consumer.originalPositionFor({ line: 1, column: 0, bias: SourceMapConsumer.LEAST_UPPER_BOUND });
                expect(pos1.source, 'line 1 output map should chain back to original.bxml').to.include('original.bxml');
                expect(pos1.line).to.eql(1);

                const pos2 = consumer.originalPositionFor({ line: 2, column: 0, bias: SourceMapConsumer.LEAST_UPPER_BOUND });
                expect(pos2.source, 'line 2 output map should chain back to original.bxml').to.include('original.bxml');
                expect(pos2.line).to.eql(2);
            });
        }

        it('reads co-located .brs.map file', async () => {
            fsExtra.writeFileSync(s`${rootDir}/source/main.brs`, brsSource);
            fsExtra.writeFileSync(s`${rootDir}/source/main.brs.map`, prebuildBrsMapJson);

            program.setFile({ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }, brsSource);
            await assertBrsOutputMapChainsToOriginal();
        });

        it('follows relative sourceMappingURL comment in the .brs file', async () => {
            // The map lives at a custom relative path referenced via sourceMappingURL.
            const mapRelPath = './maps/main.brs.map';
            const sourceWithComment = `${brsSource}\n'//# sourceMappingURL=${mapRelPath}`;

            fsExtra.ensureDirSync(s`${rootDir}/source/maps`);
            fsExtra.writeFileSync(s`${rootDir}/source/main.brs`, sourceWithComment);
            fsExtra.writeFileSync(s`${rootDir}/source/maps/main.brs.map`, prebuildBrsMapJson);

            program.setFile({ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }, sourceWithComment);
            await assertBrsOutputMapChainsToOriginal();
        });

        it('follows absolute sourceMappingURL comment in the .brs file', async () => {
            const absoluteMapPath = s`${rootDir}/maps/main.brs.map`;
            const sourceWithComment = `${brsSource}\n'//# sourceMappingURL=${absoluteMapPath}`;

            fsExtra.ensureDirSync(s`${rootDir}/maps`);
            fsExtra.writeFileSync(s`${rootDir}/source/main.brs`, sourceWithComment);
            fsExtra.writeFileSync(absoluteMapPath, prebuildBrsMapJson);

            program.setFile({ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }, sourceWithComment);
            await assertBrsOutputMapChainsToOriginal();
        });

        it('decodes inline base64 sourceMappingURL in the .brs file', async () => {
            // The map is embedded as a data URI — no external file needed.
            const base64Map = Buffer.from(prebuildBrsMapJson).toString('base64');
            const sourceWithInlineMap = `${brsSource}\n'//# sourceMappingURL=data:application/json;base64,${base64Map}`;

            fsExtra.writeFileSync(s`${rootDir}/source/main.brs`, sourceWithInlineMap);

            program.setFile({ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }, sourceWithInlineMap);
            await assertBrsOutputMapChainsToOriginal();
        });

        it('gracefully ignores a missing sourceMappingURL target file', async () => {
            // sourceMappingURL points to a file that does not exist — should not throw and
            // should produce an output map that still points to the intermediate .brs file.
            const sourceWithBadRef = `${brsSource}\n'//# sourceMappingURL=./does-not-exist.map`;

            fsExtra.writeFileSync(s`${rootDir}/source/main.brs`, sourceWithBadRef);

            program.setFile({ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }, sourceWithBadRef);
            program.validate();
            expectZeroDiagnostics(program);
            // Should complete without throwing
            await program.transpile([{ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }], stagingDir);

            const outputMapPath = s`${stagingDir}/source/main.brs.map`;
            expect(fsExtra.pathExistsSync(outputMapPath)).is.true;
            const outputMapJson = JSON.parse(fsExtra.readFileSync(outputMapPath, 'utf8'));
            // Without chaining the map still points to the intermediate .brs file (not original.bs)
            await SourceMapConsumer.with(outputMapJson, null, (consumer) => {
                const pos = consumer.originalPositionFor({ line: 2, column: 4 });
                expect(pos.source).to.include('main.brs');
            });
        });

        it('does not chain maps when sourceMap option is false', async () => {
            // When sourceMap output is disabled no output .map file should be created,
            // regardless of whether an input map exists.
            program.options.sourceMap = false;

            fsExtra.writeFileSync(s`${rootDir}/source/main.brs`, brsSource);
            fsExtra.writeFileSync(s`${rootDir}/source/main.brs.map`, prebuildBrsMapJson);

            program.setFile({ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }, brsSource);
            program.validate();
            await program.transpile([{ src: s`${rootDir}/source/main.brs`, dest: 'source/main.brs' }], stagingDir);

            expect(fsExtra.pathExistsSync(s`${stagingDir}/source/main.brs.map`)).is.false;
        });

        describe('xml files', () => {
            it('reads co-located .xml.map file', async () => {
                fsExtra.writeFileSync(s`${rootDir}/components/comp1.xml`, xmlSource);
                fsExtra.writeFileSync(s`${rootDir}/components/comp1.xml.map`, prebuildXmlMapJson);

                program.setFile({ src: s`${rootDir}/components/comp1.xml`, dest: 'components/comp1.xml' }, xmlSource);
                await assertXmlOutputMapChainsToOriginal();
            });

            it('follows relative sourceMappingURL comment in the .xml file (XML comment format)', async () => {
                const mapRelPath = './maps/comp1.xml.map';
                const xmlWithComment = `${xmlSource}\n<!--//# sourceMappingURL=${mapRelPath} -->`;

                fsExtra.ensureDirSync(s`${rootDir}/components/maps`);
                fsExtra.writeFileSync(s`${rootDir}/components/comp1.xml`, xmlWithComment);
                fsExtra.writeFileSync(s`${rootDir}/components/maps/comp1.xml.map`, prebuildXmlMapJson);

                program.setFile({ src: s`${rootDir}/components/comp1.xml`, dest: 'components/comp1.xml' }, xmlWithComment);
                await assertXmlOutputMapChainsToOriginal();
            });

            it('follows absolute sourceMappingURL comment in the .xml file', async () => {
                const absoluteMapPath = s`${rootDir}/maps/comp1.xml.map`;
                const xmlWithComment = `${xmlSource}\n<!--//# sourceMappingURL=${absoluteMapPath} -->`;

                fsExtra.ensureDirSync(s`${rootDir}/maps`);
                fsExtra.writeFileSync(s`${rootDir}/components/comp1.xml`, xmlWithComment);
                fsExtra.writeFileSync(absoluteMapPath, prebuildXmlMapJson);

                program.setFile({ src: s`${rootDir}/components/comp1.xml`, dest: 'components/comp1.xml' }, xmlWithComment);
                await assertXmlOutputMapChainsToOriginal();
            });

            it('decodes inline base64 sourceMappingURL in the .xml file', async () => {
                const base64Map = Buffer.from(prebuildXmlMapJson).toString('base64');
                const xmlWithInlineMap = `${xmlSource}\n<!--//# sourceMappingURL=data:application/json;base64,${base64Map} -->`;

                fsExtra.writeFileSync(s`${rootDir}/components/comp1.xml`, xmlWithInlineMap);

                program.setFile({ src: s`${rootDir}/components/comp1.xml`, dest: 'components/comp1.xml' }, xmlWithInlineMap);
                await assertXmlOutputMapChainsToOriginal();
            });
        });
    });

    it('copies the bslib.brs file', async () => {
        fsExtra.ensureDirSync(program.options.stagingDir!);
        program.validate();

        await program.transpile([], program.options.stagingDir!);

        expect(fsExtra.pathExistsSync(s`${stagingDir}/source/bslib.brs`)).is.true;
    });

    it('copies the bslib.brs file to optionally specified directory', async () => {
        fsExtra.ensureDirSync(program.options.stagingDir!);
        program.options.bslibDestinationDir = 'source/opt';
        program.validate();

        await program.transpile([], program.options.stagingDir!);

        expect(fsExtra.pathExistsSync(s`${stagingDir}/source/opt/bslib.brs`)).is.true;
    });

    describe('getTranspiledFileContents', () => {
        it('fires plugin events', async () => {
            const file = program.setFile('source/main.brs', trim`
                sub main()
                    print "hello world"
                end sub
            `);
            const plugin = program.plugins.add({
                name: 'TestPlugin',
                beforeFileTranspile: (event) => {
                    const stmt = ((event.file as BrsFile).ast.statements[0] as FunctionStatement).func.body.statements[0] as PrintStatement;
                    event.editor.setProperty((stmt.expressions[0] as LiteralExpression).token, 'text', '"hello there"');
                },
                afterFileTranspile: sinon.spy()
            });
            expect(
                (await program.getTranspiledFileContents(file.srcPath)).code
            ).to.eql(trim`
                sub main()
                    print "hello there"
                end sub`
            );
            expect(plugin.afterFileTranspile.callCount).to.be.greaterThan(0);
        });

        it('allows events to modify the file contents', async () => {
            program.options.emitDefinitions = true;
            program.plugins.add({
                name: 'TestPlugin',
                afterFileTranspile: (event) => {
                    event.code = `'code comment\n${event.code}`;
                    event.typedef = `'typedef comment\n${event.typedef}`;
                }
            });
            program.setFile('source/lib.bs', `
                sub log(message)
                    print message
                end sub
            `);
            await program.transpile([], stagingDir);
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/lib.brs`).toString().trimEnd()
            ).to.eql(trim`
                'code comment
                sub log(message)
                    print message
                end sub`
            );
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/lib.d.bs`).toString().trimEnd()
            ).to.eql(trim`
                'typedef comment
                sub log(message)
                end sub
            `);
        });
    });

    it('beforeProgramTranspile sends entries in alphabetical order', () => {
        program.setFile('source/main.bs', trim`
            sub main()
                print "hello world"
            end sub
        `);

        program.setFile('source/common.bs', trim`
            sub getString()
                return "test"
            end sub
        `);

        //send the files out of order
        const result = program['beforeProgramTranspile']([{
            src: s`${rootDir}/source/main.bs`,
            dest: 'source/main.bs'
        }, {
            src: s`${rootDir}/source/common.bs`,
            dest: 'source/common.bs'
        }], program.options.stagingDir);

        //entries should now be in alphabetic order
        expect(
            result.entries.map(x => x.outputPath)
        ).to.eql([
            s`${stagingDir}/source/common.brs`,
            s`${stagingDir}/source/main.brs`
        ]);
    });

    describe('transpile', () => {
        it('detects and transpiles files added between beforeProgramTranspile and afterProgramTranspile', async () => {
            program.setFile('source/main.bs', trim`
                sub main()
                    print "hello world"
                end sub
            `);
            program.plugins.add({
                name: 'TestPlugin',
                beforeFileTranspile: (event) => {
                    if (isBrsFile(event.file)) {
                        //add lib1
                        if (event.outputPath.endsWith('main.brs')) {
                            event.program.setFile('source/lib1.bs', `
                                sub lib1()
                                end sub
                            `);
                        }
                        //add lib2 (this should happen during the next cycle of "catch missing files" cycle
                        if (event.outputPath.endsWith('main.brs')) {
                            //add another file
                            event.program.setFile('source/lib2.bs', `
                                sub lib2()
                                end sub
                            `);
                        }
                    }
                }
            });
            await program.transpile([], stagingDir);
            //our new files should exist
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/lib1.brs`).toString()
            ).to.eql(trim`
                sub lib1()
                end sub
            `);
            //our changes should be there
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/lib2.brs`).toString()
            ).to.eql(trim`
                sub lib2()
                end sub
            `);
        });

        it('sets needsTranspiled=true when there is at least one edit', async () => {
            program.setFile('source/main.brs', trim`
                sub main()
                    print "hello world"
                end sub
            `);
            program.plugins.add({
                name: 'TestPlugin',
                beforeFileTranspile: (event) => {
                    const stmt = ((event.file as BrsFile).ast.statements[0] as FunctionStatement).func.body.statements[0] as PrintStatement;
                    event.editor.setProperty((stmt.expressions[0] as LiteralExpression).token, 'text', '"hello there"');
                }
            });
            await program.transpile([], stagingDir);
            //our changes should be there
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/main.brs`).toString()
            ).to.eql(trim`
                sub main()
                    print "hello there"
                end sub`
            );
        });

        it('handles AstEditor flow properly', async () => {
            program.setFile('source/main.bs', `
                sub main()
                    print "hello world"
                end sub
            `);
            let literalExpression: LiteralExpression | undefined;
            //replace all strings with "goodbye world"
            program.plugins.add({
                name: 'TestPlugin',
                beforeFileTranspile: (event) => {
                    if (isBrsFile(event.file)) {
                        event.file.ast.walk(createVisitor({
                            LiteralExpression: (literal) => {
                                literalExpression = literal;
                                event.editor.setProperty(literal.token, 'text', '"goodbye world"');
                            }
                        }), {
                            walkMode: WalkMode.visitExpressionsRecursive
                        });
                    }
                }
            });
            //transpile the file
            await program.transpile([], stagingDir);
            //our changes should be there
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/main.brs`).toString()
            ).to.eql(trim`
                sub main()
                    print "goodbye world"
                end sub`
            );

            //our literalExpression should have been restored to its original value
            expect(literalExpression!.token.text).to.eql('"hello world"');
        });

        it('handles AstEditor for beforeProgramTranspile', async () => {
            const file = program.setFile<BrsFile>('source/main.bs', `
                sub main()
                    print "hello world"
                end sub
            `);
            let literalExpression: LiteralExpression | undefined;
            //replace all strings with "goodbye world"
            program.plugins.add({
                name: 'TestPlugin',
                beforeProgramTranspile: (program: Program, entries: TranspileObj[], editor: AstEditor) => {
                    file.ast.walk(createVisitor({
                        LiteralExpression: (literal) => {
                            literalExpression = literal;
                            editor.setProperty(literal.token, 'text', '"goodbye world"');
                        }
                    }), {
                        walkMode: WalkMode.visitExpressionsRecursive
                    });
                }
            });
            //transpile the file
            await program.transpile([], stagingDir);
            //our changes should be there
            expect(
                fsExtra.readFileSync(`${stagingDir}/source/main.brs`).toString()
            ).to.eql(trim`
                sub main()
                    print "goodbye world"
                end sub`
            );

            //our literalExpression should have been restored to its original value
            expect(literalExpression!.token.text).to.eql('"hello world"');
        });

        it('copies bslib.brs when no ropm version was found', async () => {
            await program.transpile([], stagingDir);
            expect(fsExtra.pathExistsSync(`${stagingDir}/source/bslib.brs`)).to.be.true;
        });

        it('does not copy bslib.brs when found in roku_modules', async () => {
            program.setFile('source/roku_modules/bslib/bslib.brs', '');
            await program.transpile([], stagingDir);
            expect(fsExtra.pathExistsSync(`${stagingDir}/source/bslib.brs`)).to.be.false;
            expect(fsExtra.pathExistsSync(`${stagingDir}/source/roku_modules/bslib/bslib.brs`)).to.be.true;
        });

        it('transpiles in-memory-only files', async () => {
            program.setFile('source/logger.bs', trim`
                sub logInfo()
                    print SOURCE_LINE_NUM
                end sub
            `);
            await program.transpile([], program.options.stagingDir!);
            expect(trimMap(
                fsExtra.readFileSync(s`${stagingDir}/source/logger.brs`).toString()
            )).to.eql(trim`
                sub logInfo()
                    print 2
                end sub
            `);
        });

        it('copies in-memory-only .brs files to stagingDir', async () => {
            program.setFile('source/logger.brs', trim`
                sub logInfo()
                    print "logInfo"
                end sub
            `);
            await program.transpile([], program.options.stagingDir!);
            expect(trimMap(
                fsExtra.readFileSync(s`${stagingDir}/source/logger.brs`).toString()
            )).to.eql(trim`
                sub logInfo()
                    print "logInfo"
                end sub
            `);
        });

        it('copies in-memory .xml file', async () => {
            program.setFile('components/Component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                </component>
            `);
            await program.transpile([], program.options.stagingDir!);
            expect(trimMap(
                fsExtra.readFileSync(s`${stagingDir}/components/Component1.xml`).toString()
            )).to.eql(trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/source/bslib.brs" />
                </component>
            `);
        });

        it('uses custom bslib path when specified in .xml file', async () => {
            program.options.bslibDestinationDir = 'source/opt';
            program.setFile('components/Component1.xml', trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                </component>
            `);
            await program.transpile([], program.options.stagingDir!);
            expect(trimMap(
                fsExtra.readFileSync(s`${stagingDir}/components/Component1.xml`).toString()
            )).to.eql(trim`
                <?xml version="1.0" encoding="utf-8" ?>
                <component name="Component1" extends="Scene">
                    <script type="text/brightscript" uri="pkg:/source/opt/bslib.brs" />
                </component>
            `);
        });

        it('uses sourceRoot when provided for brs files', async () => {
            let sourceRoot = s`${tempDir}/sourceRootFolder`;
            program = new Program({
                rootDir: rootDir,
                stagingDir: stagingDir,
                sourceRoot: sourceRoot,
                sourceMap: true
            });
            program.setFile('source/main.brs', `
                sub main()
                end sub
            `);
            await program.transpile([{
                src: s`${rootDir}/source/main.brs`,
                dest: s`source/main.brs`
            }], stagingDir);

            let contents = fsExtra.readFileSync(s`${stagingDir}/source/main.brs.map`).toString();
            let map = JSON.parse(contents);
            // legacy behavior: sources[] contains the absolute path with rootDir swapped for sourceRoot
            expect(s`${map.sources[0]}`).to.eql(s`${sourceRoot}/source/main.brs`);
            expect(map.sourceRoot).to.be.undefined;
        });

        it('uses sourceRoot when provided for bs files', async () => {
            let sourceRoot = s`${tempDir}/sourceRootFolder`;
            program = new Program({
                rootDir: rootDir,
                stagingDir: stagingDir,
                sourceRoot: sourceRoot,
                sourceMap: true
            });
            program.setFile('source/main.bs', `
                sub main()
                end sub
            `);
            await program.transpile([{
                src: s`${rootDir}/source/main.bs`,
                dest: s`source/main.bs`
            }], stagingDir);

            let contents = fsExtra.readFileSync(s`${stagingDir}/source/main.brs.map`).toString();
            let map = JSON.parse(contents);
            // legacy behavior: sources[] contains the absolute path with rootDir swapped for sourceRoot
            expect(s`${map.sources[0]}`).to.eql(s`${sourceRoot}/source/main.bs`);
            expect(map.sourceRoot).to.be.undefined;
        });

        it('does not publish files that are empty', async () => {
            let sourceRoot = s`${tempDir}/sourceRootFolder`;
            program = new Program({
                rootDir: rootDir,
                stagingDir: stagingDir,
                sourceRoot: sourceRoot,
                sourceMap: true,
                pruneEmptyCodeFiles: true
            });
            program.setFile('source/types.bs', `
                enum mainstyle
                    dark = "dark"
                    light = "light"
                end enum
            `);
            program.setFile('source/main.bs', `
                import "pkg:/source/types.bs"

                sub main()
                    ? "The night is " + mainstyle.dark + " and full of terror"
                end sub
            `);
            await program.transpile([
                {
                    src: s`${rootDir}/source/main.bs`,
                    dest: s`source/main.bs`
                },
                {
                    src: s`${rootDir}/source/types.bs`,
                    dest: s`source/types.bs`
                }
            ], stagingDir);

            expect(trimMap(
                fsExtra.readFileSync(s`${stagingDir}/source/main.brs`).toString()
            )).to.eql(trim`
                'import "pkg:/source/types.bs"

                sub main()
                    ? "The night is " + "dark" + " and full of terror"
                end sub
            `);
            expect(fsExtra.pathExistsSync(s`${stagingDir}/source/types.brs`)).to.be.false;
        });
    });

    describe('typedef', () => {
        describe('emitDefinitions', () => {
            it('generates typedef for .bs files', async () => {
                program.setFile<BrsFile>('source/Duck.bs', `
                    class Duck
                    end class
                `);
                program.options.emitDefinitions = true;
                program.validate();
                await program.transpile([], stagingDir);

                expect(fsExtra.pathExistsSync(s`${stagingDir}/source/Duck.brs`)).to.be.true;
                expect(fsExtra.pathExistsSync(s`${stagingDir}/source/Duck.d.bs`)).to.be.true;
                expect(fsExtra.pathExistsSync(s`${stagingDir}/source/Duck.d.brs`)).to.be.false;
            });

            it('does not generate typedef for typedef file', async () => {
                program.setFile<BrsFile>('source/Duck.d.bs', `
                    class Duck
                    end class
                `);
                program.options.emitDefinitions = true;
                program.validate();
                await program.transpile([], stagingDir);

                expect(fsExtra.pathExistsSync(s`${stagingDir}/source/Duck.d.brs`)).to.be.false;
                expect(fsExtra.pathExistsSync(s`${stagingDir}/source/Duck.brs`)).to.be.false;
            });
        });

        it('ignores bs1018 for d.bs files', () => {
            program.setFile<BrsFile>('source/main.d.bs', `
                class Duck
                    sub new(name as string)
                    end sub
                    name as string
                end class

                class BabyDuck extends Duck
                    sub new(name as string, age as integer)
                    end sub
                    age as integer
                end class
            `);
            program.validate();
            expectZeroDiagnostics(program);
        });
    });

    describe('getSignatureHelp', () => {
        function getSignatureHelp(line: number, column: number) {
            return program.getSignatureHelp(
                'source/main.bs',
                util.createPosition(line, column)
            );
        }

        function assertSignatureHelp(line: number, col: number, text: string, index: number) {
            let signatureHelp = getSignatureHelp(line, col);
            expect(signatureHelp?.[0]?.signature?.label, `wrong label for ${line},${col} - got: "${signatureHelp?.[0]?.signature?.label}" expected "${text}"`).to.equal(text);
            expect(signatureHelp?.[0]?.index, `wrong index for ${line},${col} - got ${signatureHelp?.[0]?.index} expected ${index}`).to.equal(index);
        }

        it('does not crash when there is no file', () => {
            let signatureHelp = getSignatureHelp(1, 9);
            expectZeroDiagnostics(program);
            expect(signatureHelp[0]?.signature).to.not.exist;
        });

        it('does not crash when there is no expression at location', () => {
            program.validate();
            let signatureHelp = getSignatureHelp(1, 9);

            expectZeroDiagnostics(program);
            expect(signatureHelp[0]?.signature).to.not.exist;
        });

        it('does not crash when parts is undefined', () => {
            program.setFile('source/main.bs', `
                sub main()
                    print m.b["c"].hello?(12345)
                end sub
            `);
            program.validate();
            expectZeroDiagnostics(program);
            // 123|45
            let signatureHelp = getSignatureHelp(2, 45);
            expect(signatureHelp).is.empty;
        });

        describe('gets signature info for regular function call', () => {
            it('does not get help when on method name', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello("name", 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                for (let i = 24; i < 33; i++) {
                    let signatureHelp = getSignatureHelp(2, i);
                    expect(signatureHelp).is.empty;
                }
            });

            it('gets help when on first param', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello("name", 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                for (let i = 33; i < 40; i++) {
                    assertSignatureHelp(2, i, 'sub sayHello(name as string, age as integer)', 0);
                }
            });

            it('gets help when on second param', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello("name", 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                for (let i = 41; i < 44; i++) {
                    assertSignatureHelp(2, i, 'sub sayHello(name as string, age as integer)', 1);
                }
            });
        });

        describe('does not crash for unknown function info for regular function call', () => {
            it('gets help when on method name', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        cryHello("name", 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub
                `);
                program.validate();
                let signatureHelp = getSignatureHelp(2, 26);
                expect(signatureHelp).to.be.empty;
                signatureHelp = getSignatureHelp(2, 34);
                expect(signatureHelp).to.be.empty;
                signatureHelp = getSignatureHelp(2, 43);
                expect(signatureHelp).to.be.empty;
            });
        });

        describe('gets signature info for class function call', () => {
            it('gets help when on method name', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        william = new Greeter()
                        william.sayHello("name", 12)
                    end sub
                    class Greeter
                        sub sayHello(name as string, age as integer)
                        end sub
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 42, 'sub sayHello(name as string, age as integer)', 0);
            });

            it('gets help when on first param', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        william = new Greeter()
                        william.sayHello("name", 12)
                    end sub
                    class Greeter
                        sub sayHello(name as string, age as integer)
                        end sub
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 51, 'sub sayHello(name as string, age as integer)', 1);
            });
        });

        describe('gets signature info for class function call on this class', () => {
            it('gets help when on method name', () => {
                program.setFile('source/main.bs', `
                    class Greeter
                        sub greet()
                            m.sayHello("name", 12)
                        end sub
                        sub sayHello(name as string, age as integer)
                        end sub
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 42, 'sub sayHello(name as string, age as integer)', 0);
            });

            it('gets help when on second param', () => {
                program.setFile('source/main.bs', `
                    class Greeter
                        sub greet()
                            m.sayHello("name", 12)
                        end sub
                        sub sayHello(name as string, age as integer)
                        end sub
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 49, 'sub sayHello(name as string, age as integer)', 1);
            });

        });
        describe('gets signature info for overridden class function call', () => {
            it('gets help when on first param', () => {
                program.setFile('source/main.bs', `
                    class Greeter extends Person
                        sub greet()
                            m.sayHello("name", 12)
                        end sub
                        override sub sayHello(name as string, age as integer)
                        end sub

                        end class
                        class Person
                            sub sayHello(name as string, age as integer)
                            end sub
                        end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 43, 'sub sayHello(name as string, age as integer)', 0);
            });

            it('gets help when on second param', () => {
                program.setFile('source/main.bs', `
                    class Greeter extends Person
                        sub greet()
                            m.sayHello("name", 12)
                        end sub
                        override sub sayHello(name as string, age as integer)
                        end sub

                        end class
                        class Person
                            sub sayHello(name as string, age as integer)
                            end sub
                        end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 49, 'sub sayHello(name as string, age as integer)', 1);
            });
        });

        describe('gets signature info for overridden super method function call', () => {
            it('gets help when on first param', () => {
                program.setFile('source/main.bs', `
                    class Greeter extends Person
                        sub greet()
                            m.sayHello("name", 12)
                        end sub
                        override sub sayHello(name as string, age as integer)
                        end sub

                        end class
                        class Person
                            sub sayHello(name as string, age as integer)
                            end sub
                        end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 43, 'sub sayHello(name as string, age as integer)', 0);
            });

            it('gets help when on first param', () => {
                program.setFile('source/main.bs', `
                    class Greeter extends Person
                        sub greet()
                            m.sayHello("name", 12)
                        end sub
                        override sub sayHello(name as string, age as integer)
                        end sub

                        end class
                        class Person
                            sub sayHello(name as string, age as integer)
                            end sub
                        end class
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 49, 'sub sayHello(name as string, age as integer)', 1);
            });
        });

        describe('gets signature info for nested function call', () => {
            it('gets signature info for the outer function - index 0', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        outer([inner(["apple"], 100)], 12)
                    end sub

                    sub outer(name as string, age as integer)
                    end sub

                    sub inner(fruits as object, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 36, 'sub outer(name as string, age as integer)', 0);
            });

            it('gets signature info for the outer function - index 1', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        outer([inner(["apple"], 100)], 12)
                    end sub

                    sub outer(name as string, age as integer)
                    end sub

                    sub inner(fruits as object, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 57, 'sub outer(name as string, age as integer)', 1);
            });

            it('gets signature info for the inner function - name', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        outer([inner(["apple"], 100)], 12)
                    end sub

                    sub outer(name as string, age as integer)
                    end sub

                    sub inner(fruits as object, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 43, 'sub inner(fruits as object, age as integer)', 0);
            });

            it('gets signature info for the inner function - param 0', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        outer([inner(["apple"], 100)], 12)
                    end sub

                    sub outer(name as string, age as integer)
                    end sub

                    sub inner(fruits as object, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 51, 'sub inner(fruits as object, age as integer)', 1);
            });

            it('gets signature info for the inner function - param 1', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        outer([inner(["apple"], 100)], 12)
                    end sub

                    sub outer(name as string, age as integer)
                    end sub

                    sub inner(fruits as object, age as integer)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 48, 'sub inner(fruits as object, age as integer)', 1);
            });
        });

        describe('classes', () => {
            it('gives signature help in constructors', () => {
                program.setFile('source/main.bs', `
                    sub test()
                        p = new Person("george", 20, "text")
                    end sub
                    class Person
                        function new(name as string, age as integer, n2 as string)
                        end function
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);

                for (let i = 40; i < 48; i++) {
                    assertSignatureHelp(2, i, 'Person(name as string, age as integer, n2 as string)', 0);
                }
                for (let i = 48; i < 52; i++) {
                    assertSignatureHelp(2, i, 'Person(name as string, age as integer, n2 as string)', 1);
                }
                for (let i = 52; i < 60; i++) {
                    assertSignatureHelp(2, i, 'Person(name as string, age as integer, n2 as string)', 2);
                }
            });

            it('gives signature help for class with no constructor', () => {
                program.setFile('source/main.bs', `
                    sub test()
                        p = new Person()
                    end sub
                    class Person
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);

                assertSignatureHelp(2, 40, 'Person()', 0);
            });

            it('gives signature help for base constructor', () => {
                program.setFile('source/main.bs', `
                    sub test()
                        p = new Person("george", 20, "text")
                    end sub
                    class Person extends Being
                    end class
                    class Being
                        function new(name as string, age as integer, n2 as string)
                        end function
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);

                for (let i = 40; i < 48; i++) {
                    assertSignatureHelp(2, i, 'Person(name as string, age as integer, n2 as string)', 0);
                }
                for (let i = 48; i < 52; i++) {
                    assertSignatureHelp(2, i, 'Person(name as string, age as integer, n2 as string)', 1);
                }
                for (let i = 52; i < 60; i++) {
                    assertSignatureHelp(2, i, 'Person(name as string, age as integer, n2 as string)', 2);
                }
            });

            it('gives signature help in constructors in namespaced class', () => {
                program.setFile('source/main.bs', `
                    sub test()
                        p = new being.human.Person("george", 20, "text")
                    end sub
                    namespace being.human
                        class Person
                            function new(name as string, age as integer, n2 as string)
                            end function
                        end class
                    end namespace
                `);
                program.validate();
                expectZeroDiagnostics(program);

                for (let i = 52; i < 60; i++) {
                    assertSignatureHelp(2, i, 'being.human.Person(name as string, age as integer, n2 as string)', 0);
                }
                for (let i = 60; i < 64; i++) {
                    assertSignatureHelp(2, i, 'being.human.Person(name as string, age as integer, n2 as string)', 1);
                }
                for (let i = 64; i < 72; i++) {
                    assertSignatureHelp(2, i, 'being.human.Person(name as string, age as integer, n2 as string)', 2);
                }
            });
        });

        describe('edge cases', () => {
            it('still gives signature help on commas', () => {
                program.setFile('source/main.bs', `
                    class Person
                        function sayHello(name as string, age as integer, n2 as string)
                        end function

                        function yes(a as string)
                            m.sayHello("george",m.yes("a"),
                            m.yes(""))
                        end function
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);

                for (let i = 42; i < 48; i++) {
                    assertSignatureHelp(6, i, 'function sayHello(name as string, age as integer, n2 as string)', 0);
                }
                for (let i = 48; i < 54; i++) {
                    assertSignatureHelp(6, i, 'function sayHello(name as string, age as integer, n2 as string)', 1);
                }
                for (let i = 54; i < 58; i++) {
                    assertSignatureHelp(6, i, 'function yes(a as string)', 0);
                }
            });

            it('still gives signature help on spaces', () => {
                program.setFile('source/main.bs', `
                    class Person
                        function sayHello(name as string, age as integer, n2 as string)
                        end function

                        function yes(a as string)
                            m.sayHello("george", m.yes("a"),
                            m.yes(""))
                        end function
                    end class
                `);
                program.validate();
                expectZeroDiagnostics(program);

                for (let i = 42; i < 48; i++) {
                    assertSignatureHelp(6, i, 'function sayHello(name as string, age as integer, n2 as string)', 0);
                }
                for (let i = 48; i < 55; i++) {
                    assertSignatureHelp(6, i, 'function sayHello(name as string, age as integer, n2 as string)', 1);
                }
                for (let i = 55; i < 58; i++) {
                    assertSignatureHelp(6, i, 'function yes(a as string)', 0);
                }
                for (let i = 0; i < 33; i++) {
                    assertSignatureHelp(7, i, 'function sayHello(name as string, age as integer, n2 as string)', 2);
                }
            });
        });

        describe('gets signature info for function calls that go over a line', () => {
            it('gets signature info for the outer function - index 0', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello([getName([
                            "apple"
                            "pear"
                        ], function()
                            return 10
                        end function
                        )], 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub

                    sub getName(fruits as object, age as function)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                for (let i = 34; i < 42; i++) {
                    assertSignatureHelp(2, i, 'sub sayHello(name as string, age as integer)', 0);
                }
            });

            it('gets signature info for the outer function - end of index 0', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello([getName([
                            "apple"
                            "pear"
                        ], function()
                            return 10
                        end function
                        )], 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub

                    sub getName(fruits as object, age as function)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(8, 25, 'sub sayHello(name as string, age as integer)', 0);
            });

            it('gets signature info for the outer function - index 1', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello([getName([
                            "apple"
                            "pear"
                        ], function()
                            return 10
                        end function
                        )], 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub

                    sub getName(fruits as object, age as function)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(8, 30, 'sub sayHello(name as string, age as integer)', 1);
            });

            it('gets signature info for the inner function - param 0', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello([getName([
                            "apple"
                            "pear"
                        ], function()
                            return 10
                        end function
                        )], 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub

                    sub getName(fruits as object, age as function)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(3, 31, 'sub getName(fruits as object, age as function)', 0);
                assertSignatureHelp(4, 31, 'sub getName(fruits as object, age as function)', 0);
            });

            it('gets signature info for the inner function - param 1 - function declartion', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello([getName([
                            "apple"
                            "pear"
                        ], function()
                            return 10
                        end function
                        )], 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub

                    sub getName(fruits as object, age as function)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(5, 31, 'sub getName(fruits as object, age as function)', 1);
            });

            it('gets signature info for the inner function - param 1 - in anon function', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        sayHello([getName([
                            "apple"
                            "pear"
                        ], function()
                            return 10
                        end function
                        )], 12)
                    end sub

                    sub sayHello(name as string, age as integer)
                    end sub

                    sub getName(fruits as object, age as function)
                    end sub
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(6, 31, 'sub getName(fruits as object, age as function)', 1);
            });
        });

        describe('gets signature info for namespace function call', () => {
            it('gets signature info function - index 0', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        person.greeter.sayHello("hey", 12)
                    end sub
                    sub sayHello(notThisOne = true)
                    end sub
                    namespace person.greeter
                        sub sayHello(name as string, age as integer)
                        end sub
                    end namespace
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 49, 'sub person.greeter.sayHello(name as string, age as integer)', 0);
            });

            it('gets signature info for the outer function - index 1', () => {
                program.setFile('source/main.bs', `
                    sub main()
                        person.greeter.sayHello("hey", 12)
                    end sub
                    sub sayHello(notThisOne = true)
                    end sub
                    namespace person.greeter
                        sub sayHello(name as string, age as integer)
                        end sub
                    end namespace
                `);
                program.validate();
                expectZeroDiagnostics(program);
                assertSignatureHelp(2, 57, 'sub person.greeter.sayHello(name as string, age as integer)', 1);
            });
        });

        it('gets signature help for partially typed line', () => {
            program.setFile('source/main.bs', `
                function main()
                    thing@.test(a1
                end function
                function test(arg1, arg2, arg3)
                end function
                `);
            program.setFile('components/MyNode.bs', `
                function test(arg1, arg2, arg3)
                end function
                `);
            program.setFile<XmlFile>('components/MyNode.xml',
                trim`<?xml version="1.0" encoding="utf-8" ?>
            <component name="Component1" extends="Scene">
                <script type="text/brightscript" uri="pkg:/components/MyNode.bs" />
                <interface>
                    <function name="test"/>
                </interface>
            </component>`);
            program.validate();

            for (let col = 32; col < 33; col++) {
                let signatureHelp = (program.getSignatureHelp(`${rootDir}/source/main.bs`, Position.create(2, col)));
                expect(signatureHelp, `failed on col ${col}`).to.have.lengthOf(1);
                expect(signatureHelp[0].index, `failed on col ${col}`).to.equal(0);
            }
        });

        it('does not crash on malformed function declaration with trailing comma', () => {
            program.setFile('source/main.bs', `
                sub test(p1 = invalid,
                    result = 1
                end sub
            `);
            program.validate();

            // Try to get signature help at the position after the comma
            // This should not crash even though the function declaration is malformed
            const signatureHelp = program.getSignatureHelp(`${rootDir}/source/main.bs`, Position.create(1, 34));

            // We don't necessarily expect specific results, just that it doesn't crash
            expect(signatureHelp).to.be.an('array');
        });

        it('does not crash on incomplete function call', () => {
            program.setFile('source/main.bs', `
                function main()
                    someFunction(
                end function
                function someFunction(param1 as string)
                end function
            `);
            program.validate();

            // Try to get signature help after the opening parenthesis
            const signatureHelp = program.getSignatureHelp(`${rootDir}/source/main.bs`, Position.create(2, 32));

            // We don't necessarily expect specific results, just that it doesn't crash
            expect(signatureHelp).to.be.an('array');
        });

        it('does not crash on malformed function declaration with missing closing paren', () => {
            program.setFile('source/main.bs', `
                sub test(p1 = invalid
                    result = 1
                end sub
            `);
            program.validate();

            // Try to get signature help at the position where closing paren should be
            const signatureHelp = program.getSignatureHelp(`${rootDir}/source/main.bs`, Position.create(1, 33));

            // We don't necessarily expect specific results, just that it doesn't crash
            expect(signatureHelp).to.be.an('array');
        });
    });

    describe('plugins', () => {
        it('emits file validation events', () => {
            const plugin = {
                name: 'test',
                beforeFileValidate: sinon.spy(),
                onFileValidate: sinon.spy(),
                afterFileValidate: sinon.spy()
            };
            program.plugins.add(plugin);
            program.setFile('source/main.brs', '');
            program.validate();
            expect(plugin.beforeFileValidate.callCount).to.equal(1);
            expect(plugin.onFileValidate.callCount).to.equal(1);
            expect(plugin.afterFileValidate.callCount).to.equal(1);
        });

        it('emits file validation events', () => {
            const plugin = {
                name: 'test',
                beforeFileValidate: sinon.spy(),
                onFileValidate: sinon.spy(),
                afterFileValidate: sinon.spy()
            };
            program.plugins.add(plugin);
            program.setFile('components/main.xml', '');
            program.validate();
            expect(plugin.beforeFileValidate.callCount).to.equal(1);
            expect(plugin.onFileValidate.callCount).to.equal(1);
            expect(plugin.afterFileValidate.callCount).to.equal(1);
        });

        it('emits program dispose event', () => {
            const plugin = {
                name: 'test',
                beforeProgramDispose: sinon.spy()
            };
            program.plugins.add(plugin);
            program.dispose();
            expect(plugin.beforeProgramDispose.callCount).to.equal(1);
        });
    });

    describe('getScopesForFile', () => {
        it('returns empty array when no scopes were found', () => {
            expect(program.getScopesForFile('does/not/exist')).to.eql([]);
        });
    });

    describe('findFilesForEnum', () => {
        it('finds files', () => {
            const file = program.setFile('source/main.bs', `
                enum Direction
                    up
                    down
                end enum
            `);
            expect(
                program.findFilesForEnum('Direction').map(x => x.srcPath)
            ).to.eql([
                file.srcPath
            ]);
        });
    });

    describe('manifest', () => {
        beforeEach(() => {
            fsExtra.emptyDirSync(tempDir);
            fsExtra.writeFileSync(`${tempDir}/manifest`, trim`
                # Channel Details
                title=sample manifest
                major_version=2
                minor_version=0
                build_version=0
                supports_input_launch=1
                bs_const=DEBUG=false
            `);
            program.options = util.normalizeConfig({
                rootDir: tempDir
            });
        });

        afterEach(() => {
            fsExtra.emptyDirSync(tempDir);
            program.dispose();
        });

        it('loads the manifest from project root', () => {
            let manifest = program.getManifest();
            testCommonManifestValues(manifest);
            expect(manifest.get('bs_const')).to.equal('DEBUG=false');
        });

        it('loads the manifest from a FileObj', () => {
            fsExtra.emptyDirSync(tempDir);
            fsExtra.ensureDirSync(`${tempDir}/someDeepDir`);
            fsExtra.writeFileSync(`${tempDir}/someDeepDir/manifest`, trim`
                # Channel Details
                title=sample manifest
                major_version=2
                minor_version=0
                build_version=0
                supports_input_launch=1
                bs_const=DEBUG=false
            `);
            program.loadManifest({
                src: `${tempDir}/someDeepDir/manifest`,
                dest: 'manifest'
            });
            let manifest = program.getManifest();
            testCommonManifestValues(manifest);
            expect(manifest.get('bs_const')).to.equal('DEBUG=false');
        });

        it('adds a const to the manifest', () => {
            program.options.manifest = {
                // eslint-disable-next-line camelcase
                bs_const: {
                    NEW_VALUE: false
                }
            };
            let manifest = program.getManifest();
            testCommonManifestValues(manifest);
            expect(manifest.get('bs_const')).to.equal('DEBUG=false;NEW_VALUE=false');
        });

        it('changes a const in the manifest', () => {
            program.options.manifest = {
                // eslint-disable-next-line camelcase
                bs_const: {
                    DEBUG: true
                }
            };
            let manifest = program.getManifest();
            testCommonManifestValues(manifest);
            expect(manifest.get('bs_const')).to.equal('DEBUG=true');
        });

        it('removes a const in the manifest', () => {
            program.options.manifest = {
                // eslint-disable-next-line camelcase
                bs_const: {
                    DEBUG: null
                }
            };
            let manifest = program.getManifest();
            testCommonManifestValues(manifest);
            expect(manifest.get('bs_const')).to.equal('');
        });

        it('handles no consts in the manifest', () => {
            fsExtra.emptyDirSync(tempDir);
            fsExtra.writeFileSync(`${tempDir}/manifest`, trim`
                # Channel Details
                title=sample manifest
                major_version=2
                minor_version=0
                build_version=0
                supports_input_launch=1
            `);
            let manifest = program.getManifest();
            testCommonManifestValues(manifest);
            expect(manifest.get('bs_const')).to.equal('');
        });

        function testCommonManifestValues(manifest: Map<string, string>) {
            expect(manifest.get('title')).to.equal('sample manifest');
            expect(manifest.get('major_version')).to.equal('2');
            expect(manifest.get('minor_version')).to.equal('0');
            expect(manifest.get('build_version')).to.equal('0');
            expect(manifest.get('supports_input_launch')).to.equal('1');
        }
    });

    describe('getMinFirmwareVersion', () => {
        it(`returns DEFAULT_MIN_FIRMWARE_VERSION when minFirmwareVersion is unset`, () => {
            program.dispose();
            program = new Program({});
            expect(program.getMinFirmwareVersion()).to.equal(DEFAULT_MIN_FIRMWARE_VERSION);
        });

        it(`returns the user's value when minFirmwareVersion is set`, () => {
            program.dispose();
            program = new Program({ minFirmwareVersion: '11.5.0' });
            expect(program.getMinFirmwareVersion()).to.equal('11.5.0');
        });

        it('returns DEFAULT when minFirmwareVersion is set to garbage', () => {
            program.dispose();
            program = new Program({ minFirmwareVersion: 'banana' });
            expect(program.getMinFirmwareVersion()).to.equal(DEFAULT_MIN_FIRMWARE_VERSION);
        });

        it('returns DEFAULT when minFirmwareVersion is an empty string', () => {
            program.dispose();
            program = new Program({ minFirmwareVersion: '' });
            expect(program.getMinFirmwareVersion()).to.equal(DEFAULT_MIN_FIRMWARE_VERSION);
        });

        it(`returns the canonical coerced semver form when the user's value parses but is non-strict`, () => {
            program.dispose();
            program = new Program({ minFirmwareVersion: '11.5' });
            expect(program.getMinFirmwareVersion()).to.equal('11.5.0');
        });
    });

    describe('getRsgVersion', () => {
        function setupWith(manifestContents: string | undefined, minFirmwareVersion?: string) {
            if (manifestContents !== undefined) {
                fsExtra.writeFileSync(`${tempDir}/manifest`, manifestContents);
            }
            program.dispose();
            program = new Program({
                rootDir: tempDir,
                minFirmwareVersion: minFirmwareVersion
            });
        }

        it(`returns the manifest's explicit value coerced to canonical semver`, () => {
            setupWith(trim`
                title=t
                rsg_version=1.1
            `);
            expect(program.getRsgVersion()).to.equal('1.1.0');
        });

        it(`returns '1.2.0' when manifest is silent and effective firmware >= 9.3.0 (the default)`, () => {
            setupWith(trim`title=t`);
            expect(program.getRsgVersion()).to.equal('1.2.0');
        });

        it(`returns '1.1.0' when manifest is silent and minFirmwareVersion is between 7.5.0 and 9.3.0`, () => {
            setupWith(trim`title=t`, '8.0.0');
            expect(program.getRsgVersion()).to.equal('1.1.0');
        });

        it(`returns '1.0.0' when manifest is silent and minFirmwareVersion is below 7.5.0 (pre-1.1 firmware)`, () => {
            setupWith(trim`title=t`, '7.0.0');
            expect(program.getRsgVersion()).to.equal('1.0.0');
        });

        it(`returns '1.3.0' when manifest is silent and minFirmwareVersion is >= 15.1.0`, () => {
            //1.3.becameDefaultAt is 15.1.0 (Roku's cert-policy "expected default" for new development at this firmware)
            setupWith(trim`title=t`, '15.1.0');
            expect(program.getRsgVersion()).to.equal('1.3.0');
        });

        it(`is data-driven: a forward-compat unknown rsg_version from the manifest is coerced and returned`, () => {
            //we don't know about 1.5 in RSG_VERSIONS, but the manifest's explicit value still wins
            setupWith(trim`
                title=t
                rsg_version=1.5
            `);
            expect(program.getRsgVersion()).to.equal('1.5.0');
        });

        it(`falls back to the default firmware (and its rsg_version) when minFirmwareVersion is unparseable garbage`, () => {
            //getMinFirmwareVersion sanitizes garbage input → DEFAULT (15.0.0)
            //→ getRsgVersion picks the highest matching default → '1.2.0'
            setupWith(trim`title=t`, 'not-a-version');
            expect(program.getRsgVersion()).to.equal('1.2.0');
        });
    });

    describe('getManifestEntries', () => {
        it('returns line-aware entries for each manifest line', () => {
            fsExtra.writeFileSync(`${tempDir}/manifest`, trim`
                title=t
                rsg_version=1.2
            `);
            program.dispose();
            program = new Program({ rootDir: tempDir });
            //getManifestEntries is protected; use bracket access for tests
            // eslint-disable-next-line @typescript-eslint/dot-notation
            const entries = program['getManifestEntries']();
            expect(entries).to.have.lengthOf(2);
            expect(entries[1]).to.deep.include({ key: 'rsg_version', value: '1.2' });
            expect(entries[1].range.start.line).to.equal(1);
        });

        it('returns an empty array when no manifest exists', () => {
            program.dispose();
            program = new Program({ rootDir: tempDir });
            // eslint-disable-next-line @typescript-eslint/dot-notation
            expect(program['getManifestEntries']()).to.eql([]);
        });
    });
});