// Copyright (c) Microsoft Corporation. All rights reserved.

// Licensed under the MIT License.

// tslint:disable:no-suspicious-comment max-func-body-length no-invalid-this no-var-requires no-require-imports no-any

import { expect } from 'chai';

import * as path from 'path';

import { ThreadEvent } from 'vscode-debugadapter';

import { DebugClient } from 'vscode-debugadapter-testsupport';

import { DebugProtocol } from 'vscode-debugprotocol';

import { EXTENSION_ROOT_DIR } from '../../client/common/constants';

import { noop } from '../../client/common/core.utils';

import { IS_WINDOWS } from '../../client/common/platform/constants';

import { FileSystem } from '../../client/common/platform/fileSystem';

import { PlatformService } from '../../client/common/platform/platformService';

import { PTVSD_PATH } from '../../client/debugger/Common/constants';

import { DebugOptions, LaunchRequestArguments } from '../../client/debugger/Common/Contracts';

import { PYTHON_PATH, sleep } from '../common';

import { IS_MULTI_ROOT_TEST, TEST_DEBUGGER } from '../initialize';

import { DEBUGGER_TIMEOUT } from './common/constants';

import { DebugClientEx } from './debugClient';

import { continueDebugging } from './utils';

const isProcessRunning = require('is-running') as (number) => boolean;

const debugFilesPath = path.join(__dirname, '..', '..', '..', 'src', 'test', 'pythonFiles', 'debugging');

const DEBUG_ADAPTER = path.join(__dirname, '..', '..', 'client', 'debugger', 'Main.js');

const MAX_SIGNED_INT32 = Math.pow(2, 31) - 1;

const EXPERIMENTAL_DEBUG_ADAPTER = path.join(__dirname, '..', '..', 'client', 'debugger', 'mainV2.js');

let testCounter = 0;

[DEBUG_ADAPTER, EXPERIMENTAL_DEBUG_ADAPTER].forEach(testAdapterFilePath => {

const debugAdapterFileName = path.basename(testAdapterFilePath);

const debuggerType = debugAdapterFileName === 'Main.js' ? 'python' : 'pythonExperimental';

suite(`Standard Debugging - Misc tests: ${debuggerType}`, () => {

let debugClient: DebugClient;

setup(async function () {

if (!IS_MULTI_ROOT_TEST || !TEST_DEBUGGER) {

this.skip();

}

await new Promise(resolve => setTimeout(resolve, 1000));

debugClient = createDebugAdapter();

debugClient.defaultTimeout = DEBUGGER_TIMEOUT;

await debugClient.start();

});

teardown(async () => {

// Wait for a second before starting another test (sometimes, sockets take a while to get closed).

await sleep(1000);

try {

await debugClient.stop().catch(noop);

// tslint:disable-next-line:no-empty

} catch (ex) { }

await sleep(1000);

});

/**

* Creates the debug adapter.

* We do not need to support code coverage on AppVeyor, lets use the standard test adapter.

* @returns {DebugClient}

*/

function createDebugAdapter(): DebugClient {

if (IS_WINDOWS) {

return new DebugClient('node', testAdapterFilePath, debuggerType);

} else {

const coverageDirectory = path.join(EXTENSION_ROOT_DIR, `debug_coverage${testCounter += 1}`);

return new DebugClientEx(testAdapterFilePath, debuggerType, coverageDirectory, { cwd: EXTENSION_ROOT_DIR });

}

}

function buildLaunchArgs(pythonFile: string, stopOnEntry: boolean = false): LaunchRequestArguments {

const env = debuggerType === 'pythonExperimental' ? { PYTHONPATH: PTVSD_PATH } : {};

// tslint:disable-next-line:no-unnecessary-local-variable

const options: LaunchRequestArguments = {

program: path.join(debugFilesPath, pythonFile),

cwd: debugFilesPath,

stopOnEntry,

debugOptions: [DebugOptions.RedirectOutput],

pythonPath: PYTHON_PATH,

args: [],

env,

envFile: '',

logToFile: false,

type: debuggerType

};

return options;

}

test('Should run program to the end', async () => {

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('simplePrint.py', false)),

debugClient.waitForEvent('initialized'),

debugClient.waitForEvent('terminated')

]);

});

test('Should stop on entry', async function () {

if (debuggerType !== 'python') {

return this.skip();

}

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('simplePrint.py', true)),

debugClient.waitForEvent('initialized'),

debugClient.waitForEvent('stopped')

]);

});

test('test stderr output for Python', async () => {

const output = debuggerType === 'python' ? 'stdout' : 'stderr';

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('stdErrOutput.py', false)),

debugClient.waitForEvent('initialized'),

//TODO: ptvsd does not differentiate.

debugClient.assertOutput(output, 'error output'),

debugClient.waitForEvent('terminated')

]);

});

test('Test stdout output', async () => {

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('stdOutOutput.py', false)),

debugClient.waitForEvent('initialized'),

debugClient.assertOutput('stdout', 'normal output'),

debugClient.waitForEvent('terminated')

]);

});

test('Should run program to the end (with stopOnEntry=true and continue)', async function () {

if (debuggerType !== 'python') {

return this.skip();

}

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('simplePrint.py', true)),

debugClient.waitForEvent('initialized'),

debugClient.waitForEvent('stopped')

]);

const threadId = ((await threadIdPromise) as ThreadEvent).body.threadId;

await Promise.all([

debugClient.continueRequest({ threadId }),

debugClient.waitForEvent('terminated')

]);

});

test('Ensure threadid is int32', async function () {

if (debuggerType !== 'python') {

return this.skip();

}

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('simplePrint.py', true)),

debugClient.waitForEvent('initialized'),

debugClient.waitForEvent('stopped')

]);

const threadId = ((await threadIdPromise) as ThreadEvent).body.threadId;

expect(threadId).to.be.lessThan(MAX_SIGNED_INT32 + 1, 'ThreadId is not an integer');

await Promise.all([

debugClient.continueRequest({ threadId }),

debugClient.waitForEvent('terminated')

]);

});

test('Should break at print statement (line 3)', async () => {

const launchArgs = buildLaunchArgs('sample2.py', false);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

await debugClient.hitBreakpoint(launchArgs, breakpointLocation);

});

test('Should kill python process when ending debug session', async function () {

if (debuggerType === 'python') {

return this.skip();

}

const launchArgs = buildLaunchArgs('sample2.py', false);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

const processPromise = debugClient.waitForEvent('process') as Promise<DebugProtocol.ProcessEvent>;

await debugClient.hitBreakpoint(launchArgs, breakpointLocation);

const processInfo = await processPromise;

const processId = processInfo.body.systemProcessId;

expect(processId).to.be.greaterThan(0, 'Invalid process id');

await debugClient.stop();

await sleep(1000);

// Confirm the process is dead

expect(isProcessRunning(processId)).to.be.equal(false, 'Python (debugee) Process is still alive');

});

test('Test conditional breakpoints', async () => {

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('forever.py', false)),

debugClient.waitForEvent('initialized')

]);

const breakpointLocation = { path: path.join(debugFilesPath, 'forever.py'), column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column, condition: 'i == 3' }],

source: { path: breakpointLocation.path }

});

await sleep(1);

await threadIdPromise;

const frames = await debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

// Wait for breakpoint to hit

const frameId = frames.body.stackFrames[0].id;

const scopes = await debugClient.scopesRequest({ frameId });

expect(scopes.body.scopes).of.length(1, 'Incorrect number of scopes');

const variablesReference = scopes.body.scopes[0].variablesReference;

const variables = await debugClient.variablesRequest({ variablesReference });

const vari = variables.body.variables.find(item => item.name === 'i')!;

expect(vari).to.be.not.equal('undefined', 'variable \'i\' is undefined');

expect(vari.value).to.be.equal('3');

});

test('Test variables', async () => {

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('sample2.py', false)),

debugClient.waitForEvent('initialized')

]);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

await threadIdPromise;

const stackFramesPromise = debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

// Wait for breakpoint to hit

const frameId = (await stackFramesPromise).body.stackFrames[0].id;

const scopes = await debugClient.scopesRequest({ frameId });

expect(scopes.body.scopes).of.length(1, 'Incorrect number of scopes');

const variablesReference = scopes.body.scopes[0].variablesReference;

const variables = await debugClient.variablesRequest({ variablesReference });

const vara = variables.body.variables.find(item => item.name === 'a')!;

const varb = variables.body.variables.find(item => item.name === 'b')!;

const varfile = variables.body.variables.find(item => item.name === '__file__')!;

const vardoc = variables.body.variables.find(item => item.name === '__doc__')!;

expect(vara).to.be.not.equal('undefined', 'variable \'a\' is undefined');

expect(vara.value).to.be.equal('1');

expect(varb).to.be.not.equal('undefined', 'variable \'b\' is undefined');

expect(varb.value).to.be.equal('2');

expect(varfile).to.be.not.equal('undefined', 'variable \'__file__\' is undefined');

expect(path.normalize(varfile.value)).to.be.equal(`'${path.normalize(path.join(debugFilesPath, 'sample2.py'))}'`);

expect(vardoc).to.be.not.equal('undefined', 'variable \'__doc__\' is undefined');

});

test('Test editing variables', async () => {

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('sample2.py', false)),

debugClient.waitForEvent('initialized')

]);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

// const threadId = ((await threadIdPromise) as ThreadEvent).body.threadId;

const stackFramesPromise = debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

// Wait for breakpoint to hit

const frameId = (await stackFramesPromise).body.stackFrames[0].id;

const scopes = await debugClient.scopesRequest({ frameId });

expect(scopes.body.scopes).of.length(1, 'Incorrect number of scopes');

const variablesReference = scopes.body.scopes[0].variablesReference;

const variables = await debugClient.variablesRequest({ variablesReference });

const vara = variables.body.variables.find(item => item.name === 'a')!;

expect(vara).to.be.not.equal('undefined', 'variable \'a\' is undefined');

expect(vara.value).to.be.equal('1');

const response = await debugClient.setVariableRequest({ variablesReference, name: 'a', value: '1234' });

expect(response.success).to.be.equal(true, 'settting variable failed');

expect(response.body.value).to.be.equal('1234');

});

test('Test evaluating expressions', async () => {

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('sample2.py', false)),

debugClient.waitForEvent('initialized')

]);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

await threadIdPromise;

const stackFramesPromise = debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

// Wait for breakpoint to hit

const frameId = (await stackFramesPromise).body.stackFrames[0].id;

const response = await debugClient.evaluateRequest({ frameId, expression: '(a+b)*2' });

expect(response.success).to.be.equal(true, 'variable evaluation failed');

expect(response.body.result).to.be.equal('6', 'expression value is incorrect');

});

test('Test stepover', async () => {

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('sample2.py', false)),

debugClient.waitForEvent('initialized')

]);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

// hit breakpoint.

const threadId = ((await threadIdPromise) as ThreadEvent).body.threadId;

await debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

const functionLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 7 };

await Promise.all([

debugClient.nextRequest({ threadId }),

debugClient.assertStoppedLocation('step', functionLocation)

]);

const functionInvocationLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 11 };

await Promise.all([

debugClient.nextRequest({ threadId }),

debugClient.assertStoppedLocation('step', functionInvocationLocation)

]);

const printLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 13 };

await Promise.all([

debugClient.nextRequest({ threadId }),

debugClient.assertStoppedLocation('step', printLocation)

]);

});

test('Test stepin and stepout', async () => {

const threadIdPromise = debugClient.waitForEvent('thread');

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('sample2.py', false)),

debugClient.waitForEvent('initialized')

]);

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

// hit breakpoint.

await debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

const threadId = ((await threadIdPromise) as ThreadEvent).body.threadId;

const functionLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 7 };

await Promise.all([

debugClient.nextRequest({ threadId }),

debugClient.assertStoppedLocation('step', functionLocation)

]);

const functionInvocationLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 11 };

await Promise.all([

debugClient.nextRequest({ threadId }),

debugClient.assertStoppedLocation('step', functionInvocationLocation)

]);

const loopPrintLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 8 };

await Promise.all([

debugClient.stepInRequest({ threadId }),

debugClient.assertStoppedLocation('step', loopPrintLocation)

]);

await Promise.all([

debugClient.stepOutRequest({ threadId }),

debugClient.assertStoppedLocation('step', functionInvocationLocation)

]);

const printLocation = { path: path.join(debugFilesPath, 'sample2.py'), column: 1, line: 13 };

await Promise.all([

debugClient.nextRequest({ threadId }),

debugClient.assertStoppedLocation('step', printLocation)

]);

});

test('Test pausing', async function () {

if (debuggerType !== 'pythonExperimental') {

return this.skip();

}

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('forever.py', false)),

debugClient.waitForEvent('initialized'),

debugClient.waitForEvent('process')

]);

await sleep(3);

const pauseLocation = { path: path.join(debugFilesPath, 'forever.py'), line: 5 };

const pausePromise = debugClient.assertStoppedLocation('pause', pauseLocation);

const threads = await debugClient.threadsRequest();

expect(threads).to.be.not.equal(undefined, 'no threads response');

expect(threads.body.threads).to.be.lengthOf(1);

await debugClient.pauseRequest({ threadId: threads.body.threads[0].id });

await pausePromise;

});

test('Test pausing on exceptions', async function () {

if (debuggerType !== 'python') {

return this.skip();

}

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('sample3WithEx.py', false)),

debugClient.waitForEvent('initialized')

]);

const pauseLocation = { path: path.join(debugFilesPath, 'sample3WithEx.py'), line: 5 };

await debugClient.assertStoppedLocation('exception', pauseLocation);

});

test('Test pausing on assert failures', async () => {

const pauseLocation = { path: path.join(debugFilesPath, 'sampleWithAssertEx.py'), line: 1 };

function waitToStopDueToException() {

return new Promise((resolve, reject) => {

debugClient.once('stopped', (event: DebugProtocol.StoppedEvent) => {

if (event.body.reason === 'exception' &&

event.body.text && event.body.text!.startsWith('AssertionError')) {

resolve();

} else {

reject(new Error('Stopped for some other reason'));

}

});

setTimeout(() => {

reject(new Error(`waitToStopDueToException not received after ${debugClient.defaultTimeout} ms`));

}, debugClient.defaultTimeout);

});

}

function setBreakpointFilter(): Promise<any> {

if (debuggerType === 'python') {

return Promise.resolve();

} else {

return debugClient.waitForEvent('initialized')

.then(() => debugClient.setExceptionBreakpointsRequest({ filters: ['uncaught'] }))

.then(() => debugClient.configurationDoneRequest());

}

}

await Promise.all([

debugClient.configurationSequence(),

setBreakpointFilter(),

debugClient.launch(buildLaunchArgs('sampleWithAssertEx.py', false)),

waitToStopDueToException(),

debugClient.assertStoppedLocation('exception', pauseLocation)

]);

});

test('Test multi-threaded debugging', async function () {

if (debuggerType !== 'python') {

// See GitHub issue #1250

this.skip();

return;

}

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('multiThread.py', false)),

debugClient.waitForEvent('initialized')

]);

// Add a delay for debugger to start (sometimes it takes a long time for new debugger to break).

await sleep(3000);

const pythonFile = path.join(debugFilesPath, 'multiThread.py');

const breakpointLocation = { path: pythonFile, column: 1, line: 11 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

await debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

const threads = await debugClient.threadsRequest();

expect(threads.body.threads).of.lengthOf(2, 'incorrect number of threads');

for (const thread of threads.body.threads) {

expect(thread.id).to.be.lessThan(MAX_SIGNED_INT32 + 1, 'ThreadId is not an integer');

}

});

test('Test multi-threaded debugging', async function () {

this.timeout(30000);

await Promise.all([

debugClient.launch(buildLaunchArgs('multiThread.py', false)),

debugClient.waitForEvent('initialized')

]);

const pythonFile = path.join(debugFilesPath, 'multiThread.py');

const breakpointLocation = { path: pythonFile, column: 1, line: 11 };

const breakpointRequestArgs = {

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

};

function waitForStoppedEventFromTwoThreads() {

return new Promise((resolve, reject) => {

let numberOfStops = 0;

debugClient.addListener('stopped', (event: DebugProtocol.StoppedEvent) => {

numberOfStops += 1;

if (numberOfStops < 2) {

return;

}

resolve(event);

});

setTimeout(() => reject(new Error('Timeout waiting for two threads to stop at breakpoint')), DEBUGGER_TIMEOUT);

});

}

await Promise.all([

debugClient.setBreakpointsRequest(breakpointRequestArgs),

debugClient.setExceptionBreakpointsRequest({ filters: [] }),

debugClient.configurationDoneRequest(),

waitForStoppedEventFromTwoThreads(),

debugClient.assertStoppedLocation('breakpoint', breakpointLocation)

]);

const threads = await debugClient.threadsRequest();

expect(threads.body.threads).of.lengthOf(2, 'incorrect number of threads');

for (const thread of threads.body.threads) {

expect(thread.id).to.be.lessThan(MAX_SIGNED_INT32 + 1, 'ThreadId is not an integer');

}

});

test('Test stack frames', async () => {

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(buildLaunchArgs('stackFrame.py', false)),

debugClient.waitForEvent('initialized')

]);

const pythonFile = path.join(debugFilesPath, 'stackFrame.py');

const breakpointLocation = { path: pythonFile, column: 1, line: 5 };

await debugClient.setBreakpointsRequest({

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

});

// hit breakpoint.

const stackframes = await debugClient.assertStoppedLocation('breakpoint', breakpointLocation);

const fileSystem = new FileSystem(new PlatformService());

expect(stackframes.body.stackFrames[0].line).to.be.equal(5);

expect(fileSystem.arePathsSame(stackframes.body.stackFrames[0].source!.path!, pythonFile)).to.be.equal(true, 'paths do not match');

expect(stackframes.body.stackFrames[0].name).to.be.equal('foo');

expect(stackframes.body.stackFrames[1].line).to.be.equal(8);

expect(fileSystem.arePathsSame(stackframes.body.stackFrames[1].source!.path!, pythonFile)).to.be.equal(true, 'paths do not match');

expect(stackframes.body.stackFrames[1].name).to.be.equal('bar');

expect(stackframes.body.stackFrames[2].line).to.be.equal(10);

expect(fileSystem.arePathsSame(stackframes.body.stackFrames[2].source!.path!, pythonFile)).to.be.equal(true, 'paths do not match');

});

test('Test Evaluation of Expressions', async function () {

if (debuggerType !== 'pythonExperimental') {

return this.skip();

}

const breakpointLocation = { path: path.join(debugFilesPath, 'sample2WithoutSleep.py'), column: 1, line: 5 };

const breakpointArgs = {

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],

source: { path: breakpointLocation.path }

};

await Promise.all([

debugClient.launch(buildLaunchArgs('sample2WithoutSleep.py', false)),

debugClient.waitForEvent('initialized')

.then(() => debugClient.setBreakpointsRequest(breakpointArgs))

.then(() => debugClient.configurationDoneRequest())

.then(() => debugClient.threadsRequest()),

debugClient.waitForEvent('thread'),

debugClient.assertStoppedLocation('breakpoint', breakpointLocation)

]);

//Do not remove this, this is required to ensure PTVSD is ready to accept other requests.

await debugClient.threadsRequest();

const evaluateResponse = await debugClient.evaluateRequest({ context: 'repl', expression: 'a+b+2', frameId: 1 });

expect(evaluateResponse.body.type).to.equal('int');

expect(evaluateResponse.body.result).to.equal('5');

await continueDebugging(debugClient);

});

test('Test Passing custom args to python file', async function () {

if (debuggerType !== 'pythonExperimental') {

return this.skip();

}

const options = buildLaunchArgs('printSysArgv.py', false);

options.args = ['1', '2', '3'];

await Promise.all([

debugClient.configurationSequence(),

debugClient.launch(options),

debugClient.assertOutput('stdout', options.args.join(',')),

debugClient.waitForEvent('terminated')

]);

});

test('Test Logpoints', async function () {

if (debuggerType !== 'pythonExperimental') {

return this.skip();

}

const breakpointLocation = { path: path.join(debugFilesPath, 'logMessage.py'), line: 4 };

const breakpointArgs: DebugProtocol.SetBreakpointsArguments = {

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, logMessage: 'Sum of {a} and {b} is 3' }],

source: { path: breakpointLocation.path }

};

await Promise.all([

debugClient.launch(buildLaunchArgs('logMessage.py', false)),

debugClient.waitForEvent('initialized')

.then(() => debugClient.setBreakpointsRequest(breakpointArgs))

.then(() => debugClient.configurationDoneRequest())

.then(() => debugClient.threadsRequest()),

debugClient.waitForEvent('thread')

.then(() => debugClient.threadsRequest()),

debugClient.assertOutput('stdout', 'Sum of 1 and 2 is 3'),

debugClient.waitForEvent('terminated')

]);

});

test('Test Hit Count Breakpoints', async function () {

if (debuggerType !== 'pythonExperimental') {

return this.skip();

}

const breakpointLocation = { path: path.join(debugFilesPath, 'loopyTest.py'), column: 1, line: 2 };

const breakpointArgs: DebugProtocol.SetBreakpointsArguments = {

lines: [breakpointLocation.line],

breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column, hitCondition: '5' }],

source: { path: breakpointLocation.path }

};

await Promise.all([

debugClient.launch(buildLaunchArgs('loopyTest.py', false)),

debugClient.waitForEvent('initialized')

.then(() => debugClient.setBreakpointsRequest(breakpointArgs))

.then(() => debugClient.configurationDoneRequest())

.then(() => debugClient.threadsRequest()),

debugClient.waitForEvent('thread'),

debugClient.assertStoppedLocation('breakpoint', breakpointLocation)

]);

//Do not remove this, this is required to ensure PTVSD is ready to accept other requests.

await debugClient.threadsRequest();

const evaluateResponse = await debugClient.evaluateRequest({ context: 'repl', expression: 'i', frameId: 1 });

expect(evaluateResponse.body.type).to.equal('int');

expect(evaluateResponse.body.result).to.equal('4');

await continueDebugging(debugClient);

});

});

});