return xhrRequest('/__echo/default', options).then(function (response: any) {
					const data = JSON.parse(response.data);
					assert.strictEqual(data.headers['x-requested-with'], 'XMLHttpRequest');
					if (has('formdata')) {
						assert.include(data.headers['content-type'], 'application/x-www-form-urlencoded');
					}
				});

		}));
	},

	'contextual load'(this: any) {
		const def = this.async(5000);

		load(require, './load/a', './load/b').then(def.callback(function ([ a, b ]: [ any, any ]) {
			assert.deepEqual(a, { one: 1, two: 2 });
			assert.deepEqual(b, { three: 3, four: 4 });
		}));
	}

	// TODO: once AMD error handling is figured out, add tests for the failure case
};

if (has('host-node')) {
	const nodeRequire: any = global.require.nodeRequire;
	const path: any = nodeRequire('path');
	const buildDir: string = path.join(process.cwd(), '_build');

	suite.node = {
		'different than AMD load'() {
			const nodeLoad: typeof load = nodeRequire(path.join(buildDir, 'src', 'load')).default;
			assert.notStrictEqual(nodeLoad, load);
		},

		'global load succeeds'(this: any) {
			const def = this.async(5000);

			const result: Promise<any[]> = nodeRequire(path.join(buildDir, 'tests', 'unit', 'load', 'node')).globalSucceed;
			result.then(def.callback(function ([ fs, path ]: [ any, any ]) {

const basePath = (function() {
	if (has('host-browser')) {
		return '../../_build/tests/support/data/';
	}
	else if (has('host-node')) {
		return '_build/tests/support/data/';
	}
})();

	'.queueAnimationTask()': function () {
		if (!has('host-browser')) {
			this.skip('browser required.');
		}

		const dfd = this.async(5000);
		const parts: string[] = [];

		function a() {
			queueAnimationTask(function () {
				parts.push('queueAnimationTask 1');
			});
			parts.push('start');
			queueAnimationTask(function () {
				parts.push('queueAnimationTask 2');
			});
		}
		function b() {
			parts.push('end');
		}
		function c() {
			a();
			b();
		}

		c();
		setTimeout(dfd.callback(function () {
			assert.equal(parts.join(','), 'start,end,queueAnimationTask 1,queueAnimationTask 2',
				'queueAnimationTasks should be executed to the beginning of the next loop.');
		}), 300);
	},

	'.queueAnimationTask() => handle.destroy()': function () {
		if (!has('host-browser')) {
			this.skip('browser required.');
		}

		const dfd = this.async(5000);
		let parts: string[];

		function test() {
			parts = [];

			parts.push('start');
			queueAnimationTask(function () {
				parts.push('queueAnimationTask');
			}).destroy();
			parts.push('end');
		}

		test();
		setTimeout(dfd.callback(function () {
			assert.equal(parts.join(','), 'start,end');
		}), 100);
	},

import * as assert from 'intern/chai!assert';
import * as registerSuite from 'intern!object';
import has from 'src/has';
import ByteLengthQueuingStrategy from 'src/streams/ByteLengthQueuingStrategy';
import WritableStream, { State } from 'src/streams/WritableStream';
import ManualSink from './helpers/ManualSink';

const ASYNC_TIMEOUT = 1000;

registerSuite({
	name: 'ByteLengthQueuingStrategy',

	size() {
		if (!has('arraybuffer')) {
			this.skip('ArrayBuffer doesn\'t exist in this environment');
		}
		let dfd = this.async(ASYNC_TIMEOUT);
		let sink = new ManualSink<ArrayBuffer>();

		let stream = new WritableStream<ArrayBuffer>(sink, new ByteLengthQueuingStrategy<ArrayBuffer>({
			highWaterMark: 2 * 1024
		}));

		let promise = stream.write(new ArrayBuffer(1024));
		assert.strictEqual(stream.state, State.Writable);

		stream.write(new ArrayBuffer(1024));
		assert.strictEqual(stream.state, State.Writable);

		stream.write(new ArrayBuffer(1));
		assert.strictEqual(stream.state, State.Waiting);

		'has cache': {

			teardown() {
				delete hasCache['abc'];
				delete hasCache['def'];
				delete hasCache['deferred-cache'];
			},

			'basic true/false tests'() {
				hasAdd('abc', true);
				assert.isTrue(hasCache['abc']);
				hasAdd('def', false);
				assert.isFalse(hasCache['def']);

				delete hasCache['abc'];
				assert.isUndefined(has('abc'), 'Feature should be undefined after being removed from cache');
			},

			'deferred feature test should not populate cache until evaluated'() {
				hasAdd('deferred-cache', function () {
					return true;
				});
				assert.notProperty(hasCache, 'deferred-cache');
				has('deferred-cache');
				assert.property(hasCache, 'deferred-cache');
			}
		},

		'adding feature detections': {
			setup() {
				Object.keys(hasCache).forEach(function (key) {