test('simple file operations, single root, no ignore', async () => {
		let request: IWatcherRequest = { path: testDir, excludes: [] };
		service.setRoots([request]);
		await wait(300);

		assert.equal(service.wacherCount, 1);

		// create a file
		let testFilePath = path.join(testDir, 'file.txt');
		await pfs.writeFile(testFilePath, '');
		await assertFileEvents(result, [{ path: testFilePath, type: FileChangeType.ADDED }]);

		// modify a file
		await pfs.writeFile(testFilePath, 'Hello');
		await assertFileEvents(result, [{ path: testFilePath, type: FileChangeType.UPDATED }]);

		// create a folder
		let testFolderPath = path.join(testDir, 'newFolder');
		await pfs.mkdirp(testFolderPath);
		// copy a file
		let copiedFilePath = path.join(testFolderPath, 'file2.txt');
		await pfs.copy(testFilePath, copiedFilePath);
		await assertFileEvents(result, [{ path: copiedFilePath, type: FileChangeType.ADDED }, { path: testFolderPath, type: FileChangeType.ADDED }]);

		// delete a file
		await pfs.rimraf(copiedFilePath, pfs.RimRafMode.MOVE);
		let renamedFilePath = path.join(testFolderPath, 'file3.txt');
		// move a file
		await pfs.rename(testFilePath, renamedFilePath);
		await assertFileEvents(result, [{ path: copiedFilePath, type: FileChangeType.DELETED }, { path: testFilePath, type: FileChangeType.DELETED }, { path: renamedFilePath, type: FileChangeType.ADDED }]);

		// delete a folder
		await pfs.rimraf(testFolderPath, pfs.RimRafMode.MOVE);
		await assertFileEvents(result, [{ path: testFolderPath, type: FileChangeType.DELETED }, { path: renamedFilePath, type: FileChangeType.DELETED }]);
	});

	test('Migrate Data', async () => {
		class StorageTestEnvironmentService extends EnvironmentService {

			constructor(private workspaceStorageFolderPath: string, private _extensionsPath: string) {
				super(parseArgs(process.argv), process.execPath);
			}

			get workspaceStorageHome(): string {
				return this.workspaceStorageFolderPath;
			}

			get extensionsPath(): string {
				return this._extensionsPath;
			}
		}

		const storageDir = uniqueStorageDir();
		await mkdirp(storageDir);

		const storage = new StorageService(new InMemoryStorageDatabase(), new NullLogService(), new StorageTestEnvironmentService(storageDir, storageDir));
		await storage.initialize({ id: String(Date.now()) });

		storage.store('bar', 'foo', StorageScope.WORKSPACE);
		storage.store('barNumber', 55, StorageScope.WORKSPACE);
		storage.store('barBoolean', true, StorageScope.GLOBAL);

		await storage.migrate({ id: String(Date.now() + 100) });

		equal(storage.get('bar', StorageScope.WORKSPACE), 'foo');
		equal(storage.getNumber('barNumber', StorageScope.WORKSPACE), 55);
		equal(storage.getBoolean('barBoolean', StorageScope.GLOBAL), true);

		await storage.close();
		await rimraf(storageDir, RimRafMode.MOVE);
	});

	test('realcase', async () => {
		const id = uuid.generateUuid();
		const parentDir = path.join(os.tmpdir(), 'vsctests', id);
		const newDir = path.join(parentDir, 'extpath', id);

		await pfs.mkdirp(newDir, 493);

		// assume case insensitive file system
		if (process.platform === 'win32' || process.platform === 'darwin') {
			const upper = newDir.toUpperCase();
			const real = realcaseSync(upper);

			if (real) { // can be null in case of permission errors
				assert.notEqual(real, upper);
				assert.equal(real.toUpperCase(), upper);
				assert.equal(real, newDir);
			}
		}

		// linux, unix, etc. -> assume case sensitive file system
		else {
			const real = realcaseSync(newDir);
			assert.equal(real, newDir);
		}

		await pfs.rimraf(parentDir, pfs.RimRafMode.MOVE);
	});

		return pfs.mkdirp(newDir, 493).then(() => {
			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
			fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');

			return pfs.rimraf(newDir).then(() => {
				assert.ok(!fs.existsSync(newDir));
			});
		});

	setup(async () => {
		service = new TestBackupFileService(workspaceResource, backupHome, workspacesJsonPath);

		// Delete any existing backups completely and then re-create it.
		await pfs.rimraf(backupHome, pfs.RimRafMode.MOVE);
		await pfs.mkdirp(backupHome);

		return pfs.writeFile(workspacesJsonPath, '');
	});

	setup(done => {

		// Delete any existing backups completely and then re-create it.
		rimraf(marketplaceHome, RimRafMode.MOVE).then(() => {
			mkdirp(marketplaceHome).then(() => {
				done();
			}, error => done(error));
		}, error => done(error));
	});

		const onMkdirp = error => {
			if (error) {
				return onError(error, done);
			}

			fs.writeFileSync(path.join(newDir, 'somefile.txt'), 'Contents');
			fs.writeFileSync(path.join(newDir, 'someOtherFile.txt'), 'Contents');

			pfs.rimraf(newDir).then(() => {
				assert.ok(!fs.existsSync(newDir));
				done();
			}, error => onError(error, done));
		};