extensions/cxx_debugging/tests/DevToolsPlugin_test.ts - devtools/devtools-frontend - Git at Google

 // Copyright 2023 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 import {WorkerPlugin} from '../src/DevToolsPluginHost.js';
 import {createPlugin} from '../src/DWARFSymbols.js';
 import {ResourceLoader} from '../src/MEMFSResourceLoader.js';
 import {DEFAULT_MODULE_CONFIGURATIONS} from '../src/ModuleConfiguration.js';
 import type {WasmValue} from '../src/WasmTypes.js';
 import {type AsyncHostInterface, WorkerRPC} from '../src/WorkerRPC.js';

 import type {TestWorkerInterface} from './DevToolsPluginTestWorker.js';
 import {makeURL, TestHostInterface} from './TestUtils.js';

 describe('DevToolsPlugin', () => {
   describe('addRawModule', () => {
     const expectedSources = [makeURL('/build/tests/inputs/hello.c'), makeURL('/build/tests/inputs/printf.h')];
     it('does not race with removeRawModule', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const sources1Promise = plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});

       const sources1 = await sources1Promise;
       expect(sources1).to.deep.equal(expectedSources);

       const remove1Promise = plugin.removeRawModule('0');
       const sources2Promise = plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});

       const [, sources2] = await Promise.all([remove1Promise, sources2Promise]);
       expect(sources2).to.deep.equal(expectedSources);
     });

     it('does not try to create module file names that contain /', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const sources = await plugin.addRawModule('?ü', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});
       expect(sources).to.deep.equal(expectedSources);
     });

     it('reports missing module', async () => {
       const hostInterface = new TestHostInterface();
       const spy = sinon.spy(hostInterface, 'reportResourceLoad');

       const url = makeURL('/build/tests/inputs/notExistent.s.wasm');
       const plugin = await createPlugin(hostInterface, new ResourceLoader());
       try {
         await plugin.addRawModule('0', '', {url});
       } catch {
       }
       assert.isTrue(spy.calledOnceWithExactly(
           url,
           {success: false, errorMessage: `NotFoundError: Unable to load debug symbols from \'${url}\' (Not Found)`}));
     });

     it('reports loaded module and potentially missing dwp', async () => {
       const hostInterface = new TestHostInterface();
       const spy = sinon.spy(hostInterface, 'reportResourceLoad');

       const url = makeURL('/build/tests/inputs/hello.s.wasm');
       const plugin = await createPlugin(hostInterface, new ResourceLoader());
       await plugin.addRawModule('0', '', {url});

       const dwpUrl = makeURL('/build/tests/inputs/hello.s.wasm.dwp');
       assert.isTrue(spy.calledTwice);
       assert.isTrue(spy.calledWith(url, {success: true, size: 401}));
       assert.isTrue(spy.calledWith(dwpUrl, {success: false, errorMessage: 'Failed to fetch dwp file: Not Found'}));
     });

     it('reports loaded dwos', async () => {
       const url = makeURL('/build/tests/inputs/hello-split.wasm');
       const defaultConfig = {
         moduleConfigurations: DEFAULT_MODULE_CONFIGURATIONS,
         logPluginApiCalls: false,
       };

       const plugin = await WorkerPlugin.create(defaultConfig.moduleConfigurations, defaultConfig.logPluginApiCalls);
       const spy = sinon.spy(plugin, 'reportResourceLoad');

       const rawModuleId = 'hello-split.wasm@123456';
       const helloFileURL = makeURL('/build/tests/inputs/hello-split.c');
       const helperFileURL = makeURL('/build/tests/inputs/helper.c');

       const sources = await plugin.addRawModule(rawModuleId, '', {url});
       expect(sources).to.deep.equal([helloFileURL, helperFileURL]);

       // Request raw location to trigger access to DWO files.
       await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x9, inlineFrameIndex: 0});
       await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x5, inlineFrameIndex: 0});

       const helloDwoURL = makeURL('/build/tests/inputs/hello-split.dwo');
       const helperDwoURL = makeURL('/build/tests/inputs/helper.dwo');

       // Loaded .wasm, missing .dwp, 2x missing .dwo.
       assert.lengthOf(spy.args, 4);
       assert.isTrue(spy.calledWith(helloDwoURL, {success: true, size: 217}));
       assert.isTrue(spy.calledWith(helperDwoURL, {success: true, size: 207}));
     });

     it('reports missing dwos', async () => {
       const url = makeURL('/build/tests/inputs/hello-split-missing-dwo.wasm');
       const defaultConfig = {
         moduleConfigurations: DEFAULT_MODULE_CONFIGURATIONS,
         logPluginApiCalls: false,
       };

       const plugin = await WorkerPlugin.create(defaultConfig.moduleConfigurations, defaultConfig.logPluginApiCalls);
       const spy = sinon.spy(plugin, 'reportResourceLoad');

       const rawModuleId = 'hello-split-missing-dwo.wasm@123456';
       const helloFileURL = makeURL('/build/tests/inputs/hello-split-missing-dwo.c');

       const sources = await plugin.addRawModule(rawModuleId, '', {url});
       expect(sources).to.deep.equal([helloFileURL]);

       // Request raw location to trigger access to DWO files.
       await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x5, inlineFrameIndex: 0});

       const helloDwoURL = makeURL('/build/tests/inputs/hello-split-missing-dwo.dwo');

       // Loaded .wasm, missing .dwp, missing .dwo is reported twice, since we try to load
       // the .dwo twice.
       assert.lengthOf(spy.args, 4);
       assert.isTrue(
           spy.calledWith(helloDwoURL, {success: false, errorMessage: `Couldn't load ${helloDwoURL}. Status: 404`}));
     });
   });

   describe('rawLocationToSourceLocation', () => {
     it('maps bytecode addresses correctly', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const rawModuleId = 'hello.wasm@123456';
       const sourceFileURL = makeURL('/build/tests/inputs/hello.c');
       const header = makeURL('/build/tests/inputs/printf.h');
       const sources = await plugin.addRawModule(rawModuleId, '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});
       expect(sources).to.deep.equal([sourceFileURL, header]);
       expect(await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x02, inlineFrameIndex: 0}))
           .to.deep.equal([{sourceFileURL, rawModuleId, lineNumber: 2, columnNumber: -1}]);
       expect(await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x5, inlineFrameIndex: 0}))
           .to.deep.equal([{sourceFileURL: header, rawModuleId, lineNumber: 0, columnNumber: -1}]);
     });
   });

   describe('sourceLocationToRawLocation', () => {
     it('maps source locations to ranges correctly in the presence of inlining', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const rawModuleId = 'inline.s.wasm@123456';
       const sourceFileURL = makeURL('/build/tests/inputs/inline.c');
       const sources = await plugin.addRawModule(rawModuleId, '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
       expect(sources).to.deep.equal([sourceFileURL]);
       expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 0, columnNumber: -1}))
           .to.deep.equal([{rawModuleId, startOffset: 0x2, endOffset: 0x5}]);
       expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 9, columnNumber: -1}))
           .to.deep.equal([{rawModuleId, startOffset: 0x5, endOffset: 0x6}]);
     });

     it('returns only raw locations for the same line', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const rawModuleId = 'hello.wasm@123456';
       const sourceFileURL = makeURL('/build/tests/inputs/hello.c');
       const header = makeURL('/build/tests/inputs/printf.h');
       const sources = await plugin.addRawModule(rawModuleId, '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});
       expect(sources).to.deep.equal([sourceFileURL, header]);
       expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 5, columnNumber: -1}))
           .to.deep.equal([]);
       expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 10, columnNumber: -1}))
           .to.deep.equal([]);
       expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 16, columnNumber: -1}))
           .to.deep.equal([]);
     });
   });

   describe('getScopeInfo', () => {
     it('handles globals, locals, and parameters', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       expect(await plugin.getScopeInfo('GLOBAL')).to.include({type: 'GLOBAL', typeName: 'Global'});
       expect(await plugin.getScopeInfo('LOCAL')).to.include({type: 'LOCAL', typeName: 'Local'});
       expect(await plugin.getScopeInfo('PARAMETER')).to.include({type: 'PARAMETER', typeName: 'Parameter'});
     });
   });

   describe('getInlinedCalleeRanges', () => {
     it('gets inlined callee PC ranges correctly', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const sources = await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
       expect(sources).to.deep.equal([makeURL('/build/tests/inputs/inline.c')]);

       const ranges = await plugin.getInlinedCalleesRanges({rawModuleId: '0', codeOffset: 0x2, inlineFrameIndex: 0});
       expect(ranges).to.deep.equal([{rawModuleId: '0', startOffset: 0x5, endOffset: 0x6}]);
     });
   });

   describe('getInlinedFunctionRanges', () => {
     it('gets inlined function PC ranges correctly', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const sources = await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
       expect(sources).to.deep.equal([makeURL('/build/tests/inputs/inline.c')]);

       const ranges = await plugin.getInlinedFunctionRanges({rawModuleId: '0', codeOffset: 0x5, inlineFrameIndex: 0});
       expect(ranges).to.deep.equal([{rawModuleId: '0', startOffset: 0x5, endOffset: 0x6}]);
     });
   });

   describe('getFunctionInfo', () => {
     it('gets inlined function infos correctly', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       const sources = await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
       expect(sources).to.eql([makeURL('/build/tests/inputs/inline.c')]);

       const functions = await plugin.getFunctionInfo({rawModuleId: '0', codeOffset: 0x5, inlineFrameIndex: 0});
       expect(functions).to.deep.equal({frames: [{name: 'callee'}, {name: 'caller'}], missingSymbolFiles: []});
     });
   });

   describe('listVariablesInScope', () => {
     it('lists parameter variables correctly', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());

       await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/shadowing.s.wasm')});

       {
         const variables = await plugin.listVariablesInScope({rawModuleId: '0', codeOffset: 0x2, inlineFrameIndex: 0});
         expect(variables.map(v => v.scope)).to.eql(['PARAMETER']);
       }
       {
         const variables = await plugin.listVariablesInScope({rawModuleId: '0', codeOffset: 0x3, inlineFrameIndex: 0});
         expect(variables.map(v => v.scope)).to.eql(['LOCAL']);
       }
     });

     it('lists global variables correctly', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());

       await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/globals.s.wasm')});

       const variables = await plugin.listVariablesInScope({rawModuleId: '0', codeOffset: 0x6, inlineFrameIndex: 0});
       expect(variables.map(v => v.name)).to.deep.equal(['::var_separate_cu']);
     });
   });

   describe('getMappedLines', () => {
     it('computes mapped lines correctly.', async () => {
       const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
       await plugin.addRawModule('hello', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});

       const mappedLines = await plugin.getMappedLines('hello', makeURL('/build/tests/inputs/hello.c'));
       expect(mappedLines).to.eql([2]);
     });
   });

   describe('HostInterface', () => {
     it('provides access to wasm state', async () => {
       class TestAsyncHostInterface implements AsyncHostInterface {
         readonly memory = {offset: 1026, length: 5, stopId: 9, result: new Uint8Array([5, 6, 7, 8, 9]).buffer};
         readonly local = {local: 9, stopId: 10, result: {type: 'i32', value: 5} as const};
         readonly global = {global: 10, stopId: 11, result: {type: 'i32', value: 6} as const};
         readonly op = {op: 11, stopId: 12, result: {type: 'i32', value: 7} as const};
         async getWasmLinearMemory(offset: number, length: number, stopId: unknown): Promise<ArrayBuffer> {
           if (offset === this.memory.offset && length === this.memory.length && stopId === this.memory.stopId) {
             return this.memory.result;
           }
           throw new Error('Unexpected arguments to call');
         }
         async getWasmLocal(local: number, stopId: unknown): Promise<WasmValue> {
           if (local === this.local.local && stopId === this.local.stopId) {
             return this.local.result;
           }
           throw new Error('Unexpected arguments to call');
         }
         async getWasmGlobal(global: number, stopId: unknown): Promise<WasmValue> {
           if (global === this.global.global && stopId === this.global.stopId) {
             return this.global.result;
           }
           throw new Error('Unexpected arguments to call');
         }
         async getWasmOp(op: number, stopId: unknown): Promise<WasmValue> {
           if (op === this.op.op && stopId === this.op.stopId) {
             return this.op.result;
           }
           throw new Error('Unexpected arguments to call');
         }
         reportResourceLoad(_resourceUrl: string, _status: {success: boolean, errorMessage?: string, size?: number}):
             Promise<void> {
           throw new Error('Method not implemented.');
         }
       }

       // To be able to test the synchronous API calls we need a worker. In order to test the wasm state APIs explicitely
       // we wrap real RPCInterface that's running on the plugin worker in a test-specific interface that just
       // round-trips the wasm state access calls to here:
       const hostInterface = new TestAsyncHostInterface();
       const worker = new Worker('/build/tests/DevToolsPluginTestWorker.js', {type: 'module'});
       const rpc = new WorkerRPC<AsyncHostInterface, TestWorkerInterface>(worker, hostInterface);

       {
         const {offset, length, stopId, result} = hostInterface.memory;
         const callResult = await rpc.sendMessage('getWasmMemoryForTest', offset, length, stopId);
         expect(callResult).to.deep.equal(result);
       }
       {
         const {local, stopId, result} = hostInterface.local;
         const callResult = await rpc.sendMessage('getWasmLocalForTest', local, stopId);
         expect(callResult).to.deep.equal(result);
       }
       {
         const {global, stopId, result} = hostInterface.global;
         const callResult = await rpc.sendMessage('getWasmGlobalForTest', global, stopId);
         expect(callResult).to.deep.equal(result);
       }
       {
         const {op, stopId, result} = hostInterface.op;
         const callResult = await rpc.sendMessage('getWasmOpForTest', op, stopId);
         expect(callResult).to.deep.equal(result);
       }
     });
   });

   it('provides a method to report resource loads', async () => {
     class TestAsyncHostInterface implements AsyncHostInterface {
       async getWasmLinearMemory(_offset: number, _length: number, _stopId: unknown): Promise<ArrayBuffer> {
         throw new Error('Method not implemented.');
       }
       async getWasmLocal(_local: number, _stopId: unknown): Promise<WasmValue> {
         throw new Error('Method not implemented.');
       }
       async getWasmGlobal(_global: number, _stopId: unknown): Promise<WasmValue> {
         throw new Error('Method not implemented.');
       }
       async getWasmOp(_op: number, _stopId: unknown): Promise<WasmValue> {
         throw new Error('Method not implemented.');
       }
       reportResourceLoad(_resourceUrl: string, _status: {success: boolean, errorMessage?: string, size?: number}):
           Promise<void> {
         return Promise.resolve();
       }
     }

     const hostInterface = new TestAsyncHostInterface();
     const worker = new Worker('/build/tests/DevToolsPluginTestWorker.js', {type: 'module'});
     const rpc = new WorkerRPC<AsyncHostInterface, TestWorkerInterface>(worker, hostInterface);

     const resourceUrl = 'test.dwo';
     const status = {success: true};
     const spy = sinon.spy(hostInterface, 'reportResourceLoad');
     await rpc.sendMessage('reportResourceLoadForTest', resourceUrl, status);
     assert.isTrue(spy.calledOnceWithExactly(resourceUrl, status));
   });
 });
	// Copyright 2023 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	import {WorkerPlugin} from '../src/DevToolsPluginHost.js';
	import {createPlugin} from '../src/DWARFSymbols.js';
	import {ResourceLoader} from '../src/MEMFSResourceLoader.js';
	import {DEFAULT_MODULE_CONFIGURATIONS} from '../src/ModuleConfiguration.js';
	import type {WasmValue} from '../src/WasmTypes.js';
	import {type AsyncHostInterface, WorkerRPC} from '../src/WorkerRPC.js';

	import type {TestWorkerInterface} from './DevToolsPluginTestWorker.js';
	import {makeURL, TestHostInterface} from './TestUtils.js';

	describe('DevToolsPlugin', () => {
	describe('addRawModule', () => {
	const expectedSources = [makeURL('/build/tests/inputs/hello.c'), makeURL('/build/tests/inputs/printf.h')];
	it('does not race with removeRawModule', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const sources1Promise = plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});

	const sources1 = await sources1Promise;
	expect(sources1).to.deep.equal(expectedSources);

	const remove1Promise = plugin.removeRawModule('0');
	const sources2Promise = plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});

	const [, sources2] = await Promise.all([remove1Promise, sources2Promise]);
	expect(sources2).to.deep.equal(expectedSources);
	});

	it('does not try to create module file names that contain /', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const sources = await plugin.addRawModule('?ü', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});
	expect(sources).to.deep.equal(expectedSources);
	});

	it('reports missing module', async () => {
	const hostInterface = new TestHostInterface();
	const spy = sinon.spy(hostInterface, 'reportResourceLoad');

	const url = makeURL('/build/tests/inputs/notExistent.s.wasm');
	const plugin = await createPlugin(hostInterface, new ResourceLoader());
	try {
	await plugin.addRawModule('0', '', {url});
	} catch {
	}
	assert.isTrue(spy.calledOnceWithExactly(
	url,
	{success: false, errorMessage: `NotFoundError: Unable to load debug symbols from \'${url}\' (Not Found)`}));
	});

	it('reports loaded module and potentially missing dwp', async () => {
	const hostInterface = new TestHostInterface();
	const spy = sinon.spy(hostInterface, 'reportResourceLoad');

	const url = makeURL('/build/tests/inputs/hello.s.wasm');
	const plugin = await createPlugin(hostInterface, new ResourceLoader());
	await plugin.addRawModule('0', '', {url});

	const dwpUrl = makeURL('/build/tests/inputs/hello.s.wasm.dwp');
	assert.isTrue(spy.calledTwice);
	assert.isTrue(spy.calledWith(url, {success: true, size: 401}));
	assert.isTrue(spy.calledWith(dwpUrl, {success: false, errorMessage: 'Failed to fetch dwp file: Not Found'}));
	});

	it('reports loaded dwos', async () => {
	const url = makeURL('/build/tests/inputs/hello-split.wasm');
	const defaultConfig = {
	moduleConfigurations: DEFAULT_MODULE_CONFIGURATIONS,
	logPluginApiCalls: false,
	};

	const plugin = await WorkerPlugin.create(defaultConfig.moduleConfigurations, defaultConfig.logPluginApiCalls);
	const spy = sinon.spy(plugin, 'reportResourceLoad');

	const rawModuleId = 'hello-split.wasm@123456';
	const helloFileURL = makeURL('/build/tests/inputs/hello-split.c');
	const helperFileURL = makeURL('/build/tests/inputs/helper.c');

	const sources = await plugin.addRawModule(rawModuleId, '', {url});
	expect(sources).to.deep.equal([helloFileURL, helperFileURL]);

	// Request raw location to trigger access to DWO files.
	await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x9, inlineFrameIndex: 0});
	await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x5, inlineFrameIndex: 0});

	const helloDwoURL = makeURL('/build/tests/inputs/hello-split.dwo');
	const helperDwoURL = makeURL('/build/tests/inputs/helper.dwo');

	// Loaded .wasm, missing .dwp, 2x missing .dwo.
	assert.lengthOf(spy.args, 4);
	assert.isTrue(spy.calledWith(helloDwoURL, {success: true, size: 217}));
	assert.isTrue(spy.calledWith(helperDwoURL, {success: true, size: 207}));
	});

	it('reports missing dwos', async () => {
	const url = makeURL('/build/tests/inputs/hello-split-missing-dwo.wasm');
	const defaultConfig = {
	moduleConfigurations: DEFAULT_MODULE_CONFIGURATIONS,
	logPluginApiCalls: false,
	};

	const plugin = await WorkerPlugin.create(defaultConfig.moduleConfigurations, defaultConfig.logPluginApiCalls);
	const spy = sinon.spy(plugin, 'reportResourceLoad');

	const rawModuleId = 'hello-split-missing-dwo.wasm@123456';
	const helloFileURL = makeURL('/build/tests/inputs/hello-split-missing-dwo.c');

	const sources = await plugin.addRawModule(rawModuleId, '', {url});
	expect(sources).to.deep.equal([helloFileURL]);

	// Request raw location to trigger access to DWO files.
	await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x5, inlineFrameIndex: 0});

	const helloDwoURL = makeURL('/build/tests/inputs/hello-split-missing-dwo.dwo');

	// Loaded .wasm, missing .dwp, missing .dwo is reported twice, since we try to load
	// the .dwo twice.
	assert.lengthOf(spy.args, 4);
	assert.isTrue(
	spy.calledWith(helloDwoURL, {success: false, errorMessage: `Couldn't load ${helloDwoURL}. Status: 404`}));
	});
	});

	describe('rawLocationToSourceLocation', () => {
	it('maps bytecode addresses correctly', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const rawModuleId = 'hello.wasm@123456';
	const sourceFileURL = makeURL('/build/tests/inputs/hello.c');
	const header = makeURL('/build/tests/inputs/printf.h');
	const sources = await plugin.addRawModule(rawModuleId, '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});
	expect(sources).to.deep.equal([sourceFileURL, header]);
	expect(await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x02, inlineFrameIndex: 0}))
	.to.deep.equal([{sourceFileURL, rawModuleId, lineNumber: 2, columnNumber: -1}]);
	expect(await plugin.rawLocationToSourceLocation({rawModuleId, codeOffset: 0x5, inlineFrameIndex: 0}))
	.to.deep.equal([{sourceFileURL: header, rawModuleId, lineNumber: 0, columnNumber: -1}]);
	});
	});

	describe('sourceLocationToRawLocation', () => {
	it('maps source locations to ranges correctly in the presence of inlining', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const rawModuleId = 'inline.s.wasm@123456';
	const sourceFileURL = makeURL('/build/tests/inputs/inline.c');
	const sources = await plugin.addRawModule(rawModuleId, '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
	expect(sources).to.deep.equal([sourceFileURL]);
	expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 0, columnNumber: -1}))
	.to.deep.equal([{rawModuleId, startOffset: 0x2, endOffset: 0x5}]);
	expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 9, columnNumber: -1}))
	.to.deep.equal([{rawModuleId, startOffset: 0x5, endOffset: 0x6}]);
	});

	it('returns only raw locations for the same line', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const rawModuleId = 'hello.wasm@123456';
	const sourceFileURL = makeURL('/build/tests/inputs/hello.c');
	const header = makeURL('/build/tests/inputs/printf.h');
	const sources = await plugin.addRawModule(rawModuleId, '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});
	expect(sources).to.deep.equal([sourceFileURL, header]);
	expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 5, columnNumber: -1}))
	.to.deep.equal([]);
	expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 10, columnNumber: -1}))
	.to.deep.equal([]);
	expect(await plugin.sourceLocationToRawLocation({rawModuleId, sourceFileURL, lineNumber: 16, columnNumber: -1}))
	.to.deep.equal([]);
	});
	});

	describe('getScopeInfo', () => {
	it('handles globals, locals, and parameters', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	expect(await plugin.getScopeInfo('GLOBAL')).to.include({type: 'GLOBAL', typeName: 'Global'});
	expect(await plugin.getScopeInfo('LOCAL')).to.include({type: 'LOCAL', typeName: 'Local'});
	expect(await plugin.getScopeInfo('PARAMETER')).to.include({type: 'PARAMETER', typeName: 'Parameter'});
	});
	});

	describe('getInlinedCalleeRanges', () => {
	it('gets inlined callee PC ranges correctly', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const sources = await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
	expect(sources).to.deep.equal([makeURL('/build/tests/inputs/inline.c')]);

	const ranges = await plugin.getInlinedCalleesRanges({rawModuleId: '0', codeOffset: 0x2, inlineFrameIndex: 0});
	expect(ranges).to.deep.equal([{rawModuleId: '0', startOffset: 0x5, endOffset: 0x6}]);
	});
	});

	describe('getInlinedFunctionRanges', () => {
	it('gets inlined function PC ranges correctly', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const sources = await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
	expect(sources).to.deep.equal([makeURL('/build/tests/inputs/inline.c')]);

	const ranges = await plugin.getInlinedFunctionRanges({rawModuleId: '0', codeOffset: 0x5, inlineFrameIndex: 0});
	expect(ranges).to.deep.equal([{rawModuleId: '0', startOffset: 0x5, endOffset: 0x6}]);
	});
	});

	describe('getFunctionInfo', () => {
	it('gets inlined function infos correctly', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	const sources = await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/inline.s.wasm')});
	expect(sources).to.eql([makeURL('/build/tests/inputs/inline.c')]);

	const functions = await plugin.getFunctionInfo({rawModuleId: '0', codeOffset: 0x5, inlineFrameIndex: 0});
	expect(functions).to.deep.equal({frames: [{name: 'callee'}, {name: 'caller'}], missingSymbolFiles: []});
	});
	});

	describe('listVariablesInScope', () => {
	it('lists parameter variables correctly', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());

	await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/shadowing.s.wasm')});

	{
	const variables = await plugin.listVariablesInScope({rawModuleId: '0', codeOffset: 0x2, inlineFrameIndex: 0});
	expect(variables.map(v => v.scope)).to.eql(['PARAMETER']);
	}
	{
	const variables = await plugin.listVariablesInScope({rawModuleId: '0', codeOffset: 0x3, inlineFrameIndex: 0});
	expect(variables.map(v => v.scope)).to.eql(['LOCAL']);
	}
	});

	it('lists global variables correctly', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());

	await plugin.addRawModule('0', '', {url: makeURL('/build/tests/inputs/globals.s.wasm')});

	const variables = await plugin.listVariablesInScope({rawModuleId: '0', codeOffset: 0x6, inlineFrameIndex: 0});
	expect(variables.map(v => v.name)).to.deep.equal(['::var_separate_cu']);
	});
	});

	describe('getMappedLines', () => {
	it('computes mapped lines correctly.', async () => {
	const plugin = await createPlugin(new TestHostInterface(), new ResourceLoader());
	await plugin.addRawModule('hello', '', {url: makeURL('/build/tests/inputs/hello.s.wasm')});

	const mappedLines = await plugin.getMappedLines('hello', makeURL('/build/tests/inputs/hello.c'));
	expect(mappedLines).to.eql([2]);
	});
	});

	describe('HostInterface', () => {
	it('provides access to wasm state', async () => {
	class TestAsyncHostInterface implements AsyncHostInterface {
	readonly memory = {offset: 1026, length: 5, stopId: 9, result: new Uint8Array([5, 6, 7, 8, 9]).buffer};
	readonly local = {local: 9, stopId: 10, result: {type: 'i32', value: 5} as const};
	readonly global = {global: 10, stopId: 11, result: {type: 'i32', value: 6} as const};
	readonly op = {op: 11, stopId: 12, result: {type: 'i32', value: 7} as const};
	async getWasmLinearMemory(offset: number, length: number, stopId: unknown): Promise<ArrayBuffer> {
	if (offset === this.memory.offset && length === this.memory.length && stopId === this.memory.stopId) {
	return this.memory.result;
	}
	throw new Error('Unexpected arguments to call');
	}
	async getWasmLocal(local: number, stopId: unknown): Promise<WasmValue> {
	if (local === this.local.local && stopId === this.local.stopId) {
	return this.local.result;
	}
	throw new Error('Unexpected arguments to call');
	}
	async getWasmGlobal(global: number, stopId: unknown): Promise<WasmValue> {
	if (global === this.global.global && stopId === this.global.stopId) {
	return this.global.result;
	}
	throw new Error('Unexpected arguments to call');
	}
	async getWasmOp(op: number, stopId: unknown): Promise<WasmValue> {
	if (op === this.op.op && stopId === this.op.stopId) {
	return this.op.result;
	}
	throw new Error('Unexpected arguments to call');
	}
	reportResourceLoad(_resourceUrl: string, _status: {success: boolean, errorMessage?: string, size?: number}):
	Promise<void> {
	throw new Error('Method not implemented.');
	}
	}

	// To be able to test the synchronous API calls we need a worker. In order to test the wasm state APIs explicitely
	// we wrap real RPCInterface that's running on the plugin worker in a test-specific interface that just
	// round-trips the wasm state access calls to here:
	const hostInterface = new TestAsyncHostInterface();
	const worker = new Worker('/build/tests/DevToolsPluginTestWorker.js', {type: 'module'});
	const rpc = new WorkerRPC<AsyncHostInterface, TestWorkerInterface>(worker, hostInterface);

	{
	const {offset, length, stopId, result} = hostInterface.memory;
	const callResult = await rpc.sendMessage('getWasmMemoryForTest', offset, length, stopId);
	expect(callResult).to.deep.equal(result);
	}
	{
	const {local, stopId, result} = hostInterface.local;
	const callResult = await rpc.sendMessage('getWasmLocalForTest', local, stopId);
	expect(callResult).to.deep.equal(result);
	}
	{
	const {global, stopId, result} = hostInterface.global;
	const callResult = await rpc.sendMessage('getWasmGlobalForTest', global, stopId);
	expect(callResult).to.deep.equal(result);
	}
	{
	const {op, stopId, result} = hostInterface.op;
	const callResult = await rpc.sendMessage('getWasmOpForTest', op, stopId);
	expect(callResult).to.deep.equal(result);
	}
	});
	});

	it('provides a method to report resource loads', async () => {
	class TestAsyncHostInterface implements AsyncHostInterface {
	async getWasmLinearMemory(_offset: number, _length: number, _stopId: unknown): Promise<ArrayBuffer> {
	throw new Error('Method not implemented.');
	}
	async getWasmLocal(_local: number, _stopId: unknown): Promise<WasmValue> {
	throw new Error('Method not implemented.');
	}
	async getWasmGlobal(_global: number, _stopId: unknown): Promise<WasmValue> {
	throw new Error('Method not implemented.');
	}
	async getWasmOp(_op: number, _stopId: unknown): Promise<WasmValue> {
	throw new Error('Method not implemented.');
	}
	reportResourceLoad(_resourceUrl: string, _status: {success: boolean, errorMessage?: string, size?: number}):
	Promise<void> {
	return Promise.resolve();
	}
	}

	const hostInterface = new TestAsyncHostInterface();
	const worker = new Worker('/build/tests/DevToolsPluginTestWorker.js', {type: 'module'});
	const rpc = new WorkerRPC<AsyncHostInterface, TestWorkerInterface>(worker, hostInterface);

	const resourceUrl = 'test.dwo';
	const status = {success: true};
	const spy = sinon.spy(hostInterface, 'reportResourceLoad');
	await rpc.sendMessage('reportResourceLoadForTest', resourceUrl, status);
	assert.isTrue(spy.calledOnceWithExactly(resourceUrl, status));
	});
	});