Merge from vscode 05fc61ffb1aee9fd19173c32113daed079f9b7bd (#5074)

* Merge from vscode 05fc61ffb1aee9fd19173c32113daed079f9b7bd

* fix tests

src/vs/base/test/common/buffer.test.ts

@@ -3,18 +3,365 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-
 import * as assert from 'assert';
-import { hasBuffer, VSBuffer } from 'vs/base/common/buffer';
+import { VSBuffer, bufferToReadable, readableToBuffer, bufferToStream, streamToBuffer, writeableBufferStream } from 'vs/base/common/buffer';
+import { timeout } from 'vs/base/common/async';
 
 suite('Buffer', () => {
 
-	if (hasBuffer) {
-		test('issue #71993 - VSBuffer#toString returns numbers', () => {
-			const data = new Uint8Array([1, 2, 3, 'h'.charCodeAt(0), 'i'.charCodeAt(0), 4, 5]).buffer;
-			const buffer = VSBuffer.wrap(new Uint8Array(data, 3, 2));
-			assert.deepEqual(buffer.toString(), 'hi');
-		});
-	}
+	test('issue #71993 - VSBuffer#toString returns numbers', () => {
+		const data = new Uint8Array([1, 2, 3, 'h'.charCodeAt(0), 'i'.charCodeAt(0), 4, 5]).buffer;
+		const buffer = VSBuffer.wrap(new Uint8Array(data, 3, 2));
+		assert.deepEqual(buffer.toString(), 'hi');
+	});
 
+	test('bufferToReadable / readableToBuffer', () => {
+		const content = 'Hello World';
+		const readable = bufferToReadable(VSBuffer.fromString(content));
+
+		assert.equal(readableToBuffer(readable).toString(), content);
+	});
+
+	test('bufferToStream / streamToBuffer', async () => {
+		const content = 'Hello World';
+		const stream = bufferToStream(VSBuffer.fromString(content));
+
+		assert.equal((await streamToBuffer(stream)).toString(), content);
+	});
+
+	test('bufferWriteableStream - basics (no error)', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 2);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(chunks[1].toString(), 'World');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - basics (error)', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(new Error());
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 1);
+	});
+
+	test('bufferWriteableStream - buffers data when no listener', async () => {
+		const stream = writeableBufferStream();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'HelloWorld');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - buffers errors when no listener', async () => {
+		const stream = writeableBufferStream();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.error(new Error());
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		stream.end();
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 1);
+	});
+
+	test('bufferWriteableStream - buffers end when no listener', async () => {
+		const stream = writeableBufferStream();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'HelloWorld');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - nothing happens after end()', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		let dataCalledAfterEnd = false;
+		stream.on('data', data => {
+			dataCalledAfterEnd = true;
+		});
+
+		let errorCalledAfterEnd = false;
+		stream.on('error', error => {
+			errorCalledAfterEnd = true;
+		});
+
+		let endCalledAfterEnd = false;
+		stream.on('end', () => {
+			endCalledAfterEnd = true;
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.error(new Error());
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(dataCalledAfterEnd, false);
+		assert.equal(errorCalledAfterEnd, false);
+		assert.equal(endCalledAfterEnd, false);
+
+		assert.equal(chunks.length, 2);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(chunks[1].toString(), 'World');
+	});
+
+	test('bufferWriteableStream - pause/resume (simple)', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		stream.pause();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 0);
+		assert.equal(errors.length, 0);
+		assert.equal(ended, false);
+
+		stream.resume();
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'HelloWorld');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - pause/resume (pause after first write)', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+
+		stream.pause();
+
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(errors.length, 0);
+		assert.equal(ended, false);
+
+		stream.resume();
+
+		assert.equal(chunks.length, 2);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(chunks[1].toString(), 'World');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 0);
+	});
+
+	test('bufferWriteableStream - pause/resume (error)', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		stream.pause();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(new Error());
+
+		assert.equal(chunks.length, 0);
+		assert.equal(ended, false);
+		assert.equal(errors.length, 0);
+
+		stream.resume();
+
+		assert.equal(chunks.length, 1);
+		assert.equal(chunks[0].toString(), 'Hello');
+		assert.equal(ended, true);
+		assert.equal(errors.length, 1);
+	});
+
+	test('bufferWriteableStream - destroy', async () => {
+		const stream = writeableBufferStream();
+
+		let chunks: VSBuffer[] = [];
+		stream.on('data', data => {
+			chunks.push(data);
+		});
+
+		let ended = false;
+		stream.on('end', () => {
+			ended = true;
+		});
+
+		let errors: Error[] = [];
+		stream.on('error', error => {
+			errors.push(error);
+		});
+
+		stream.destroy();
+
+		await timeout(0);
+		stream.write(VSBuffer.fromString('Hello'));
+		await timeout(0);
+		stream.end(VSBuffer.fromString('World'));
+
+		assert.equal(chunks.length, 0);
+		assert.equal(ended, false);
+		assert.equal(errors.length, 0);
+	});
 });

src/vs/base/test/node/encoding/encoding.test.ts

@@ -6,51 +6,114 @@
 import * as assert from 'assert';
 import * as fs from 'fs';
 import * as encoding from 'vs/base/node/encoding';
-import { readExactlyByFile } from 'vs/base/node/stream';
 import { Readable } from 'stream';
 import { getPathFromAmdModule } from 'vs/base/common/amd';
 
+export async function detectEncodingByBOM(file: string): Promise<string | null> {
+	try {
+		const { buffer, bytesRead } = await readExactlyByFile(file, 3);
+
+		return encoding.detectEncodingByBOMFromBuffer(buffer, bytesRead);
+	} catch (error) {
+		return null; // ignore errors (like file not found)
+	}
+}
+
+interface ReadResult {
+	buffer: Buffer | null;
+	bytesRead: number;
+}
+
+function readExactlyByFile(file: string, totalBytes: number): Promise<ReadResult> {
+	return new Promise<ReadResult>((resolve, reject) => {
+		fs.open(file, 'r', null, (err, fd) => {
+			if (err) {
+				return reject(err);
+			}
+
+			function end(err: Error | null, resultBuffer: Buffer | null, bytesRead: number): void {
+				fs.close(fd, closeError => {
+					if (closeError) {
+						return reject(closeError);
+					}
+
+					if (err && (<any>err).code === 'EISDIR') {
+						return reject(err); // we want to bubble this error up (file is actually a folder)
+					}
+
+					return resolve({ buffer: resultBuffer, bytesRead });
+				});
+			}
+
+			const buffer = Buffer.allocUnsafe(totalBytes);
+			let offset = 0;
+
+			function readChunk(): void {
+				fs.read(fd, buffer, offset, totalBytes - offset, null, (err, bytesRead) => {
+					if (err) {
+						return end(err, null, 0);
+					}
+
+					if (bytesRead === 0) {
+						return end(null, buffer, offset);
+					}
+
+					offset += bytesRead;
+
+					if (offset === totalBytes) {
+						return end(null, buffer, offset);
+					}
+
+					return readChunk();
+				});
+			}
+
+			readChunk();
+		});
+	});
+}
+
 suite('Encoding', () => {
 
 	test('detectBOM does not return error for non existing file', async () => {
 		const file = getPathFromAmdModule(require, './fixtures/not-exist.css');
 
-		const detectedEncoding = await encoding.detectEncodingByBOM(file);
+		const detectedEncoding = await detectEncodingByBOM(file);
 		assert.equal(detectedEncoding, null);
 	});
 
 	test('detectBOM UTF-8', async () => {
 		const file = getPathFromAmdModule(require, './fixtures/some_utf8.css');
 
-		const detectedEncoding = await encoding.detectEncodingByBOM(file);
+		const detectedEncoding = await detectEncodingByBOM(file);
 		assert.equal(detectedEncoding, 'utf8');
 	});
 
 	test('detectBOM UTF-16 LE', async () => {
 		const file = getPathFromAmdModule(require, './fixtures/some_utf16le.css');
 
-		const detectedEncoding = await encoding.detectEncodingByBOM(file);
+		const detectedEncoding = await detectEncodingByBOM(file);
 		assert.equal(detectedEncoding, 'utf16le');
 	});
 
 	test('detectBOM UTF-16 BE', async () => {
 		const file = getPathFromAmdModule(require, './fixtures/some_utf16be.css');
 
-		const detectedEncoding = await encoding.detectEncodingByBOM(file);
+		const detectedEncoding = await detectEncodingByBOM(file);
 		assert.equal(detectedEncoding, 'utf16be');
 	});
 
 	test('detectBOM ANSI', async function () {
 		const file = getPathFromAmdModule(require, './fixtures/some_ansi.css');
 
-		const detectedEncoding = await encoding.detectEncodingByBOM(file);
+		const detectedEncoding = await detectEncodingByBOM(file);
 		assert.equal(detectedEncoding, null);
 	});
 
 	test('detectBOM ANSI', async function () {
 		const file = getPathFromAmdModule(require, './fixtures/empty.txt');
 
-		const detectedEncoding = await encoding.detectEncodingByBOM(file);
+		const detectedEncoding = await detectEncodingByBOM(file);
 		assert.equal(detectedEncoding, null);
 	});
 

src/vs/base/test/node/stream/stream.test.ts

@@ -9,23 +9,6 @@ import * as stream from 'vs/base/node/stream';
 import { getPathFromAmdModule } from 'vs/base/common/amd';
 
 suite('Stream', () => {
-	test('readExactlyByFile - ANSI', function () {
-		const file = getPathFromAmdModule(require, './fixtures/file.css');
-
-		return stream.readExactlyByFile(file, 10).then(({ buffer, bytesRead }) => {
-			assert.equal(bytesRead, 10);
-			assert.equal(buffer!.toString(), '/*--------');
-		});
-	});
-
-	test('readExactlyByFile - empty', function () {
-		const file = getPathFromAmdModule(require, './fixtures/empty.txt');
-
-		return stream.readExactlyByFile(file, 10).then(({ bytesRead }) => {
-			assert.equal(bytesRead, 0);
-		});
-	});
-
 	test('readToMatchingString - ANSI', function () {
 		const file = getPathFromAmdModule(require, './fixtures/file.css');