test('Migrate Data', async () => {
		const storageDir = uniqueStorageDir();
		await mkdirp(storageDir);

		const storage = new StorageService(join(storageDir, 'storage.db'), false, false, new NullLogService(), TestEnvironmentService);
		await storage.init();

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

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

		await storage.migrate(newStorageDir);

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

		await storage.close();
		await del(newStorageDir, tmpdir());
		await del(storageDir, tmpdir());
	});

	test('basics (corrupt DB falls back to empty DB)', async () => {
		const storageDir = uniqueStorageDir();

		await mkdirp(storageDir);

		const corruptDBPath = join(storageDir, 'broken.db');
		await writeFile(corruptDBPath, 'This is a broken DB');

		let expectedError: any;
		await testDBBasics(corruptDBPath, error => {
			expectedError = error;
		});

		ok(expectedError);

		await del(storageDir, tmpdir());
	});

	test('conflicting updates', async () => {
		const storageDir = uniqueStorageDir();
		await mkdirp(storageDir);

		let storage = new Storage({ path: join(storageDir, 'storage.db') });
		await storage.init();

		let changes = new Set<string>();
		storage.onDidChangeStorage(key => {
			changes.add(key);
		});

		const set1Promise = storage.set('foo', 'bar1');
		const set2Promise = storage.set('foo', 'bar2');
		const set3Promise = storage.set('foo', 'bar3');

		equal(storage.get('foo'), 'bar3');
		equal(changes.size, 1);
		ok(changes.has('foo'));

		let setPromiseResolved = false;
		await Promise.all([set1Promise, set2Promise, set3Promise]).then(() => setPromiseResolved = true);
		ok(setPromiseResolved);

		changes = new Set<string>();

		const set4Promise = storage.set('bar', 'foo');
		const delete1Promise = storage.delete('bar');

		ok(!storage.get('bar'));

		equal(changes.size, 1);
		ok(changes.has('bar'));

		let setAndDeletePromiseResolved = false;
		await Promise.all([set4Promise, delete1Promise]).then(() => setAndDeletePromiseResolved = true);
		ok(setAndDeletePromiseResolved);

		await storage.close();
		await del(storageDir, tmpdir());
	});

	teardown(() => {
		return pfs.del(backupHome, os.tmpdir());
	});

	suiteTeardown(async () => {
		await pfs.del(testDir);
		await service.stop();
	});

			]).then(() => {
				assert.equal(fs.readFileSync(testFile), 'Hello World 5');

				return pfs.del(parentDir, os.tmpdir());
			});

			return pfs.writeFile(testFile, 'Hello World', null!).then(() => {
				assert.equal(fs.readFileSync(testFile), 'Hello World');

				return pfs.del(parentDir, os.tmpdir());
			});

	teardown(() => {
		service.dispose();
		return pfs.del(parentDir, os.tmpdir());
	});