function bundleCasesFrom(i: number) {
	if (i >= cases.length) return;
	const b = browserify();
	b.ignore("tape");
	b.add(`${__dirname}/${cases[i]}.js`);
	b.transform(path.normalize(__dirname + "/../cwise.js"));
	tape(cases[i], (t) => { // Without nested tests, the asynchronous nature of bundle causes issues with tape...
		b.bundle((err, src) => {
			if (err) {
				throw new Error("failed to bundle!");
			}
			vm.runInNewContext(src.toString(), {
				test: t.test.bind(t),
				Buffer,
				Int8Array,
				Int16Array,
				Int32Array,
				Float32Array,
				Float64Array,
				Uint8Array,
				Uint16Array,
				Uint32Array,
				Uint8ClampedArray,
				console: { log: console.log.bind(console) }
			});
			t.end();
		});
	});
	bundleCasesFrom(i + 1);
}

import * as Ix from '../Ix';
import * as test from 'tape';
const { elementAt } = Ix.iterable;

test('Iterable#elementAt empty returns undefined', t => {
  const res = elementAt<number>([], 0);
  t.equal(res, undefined);
  t.end();
});

test('Iterable#elementAt single value first index', t => {
  const res = elementAt([42], 0);
  t.equal(res, 42);
  t.end();
});

test('Iterable#elementAt single value invalid index', t => {
  const res = elementAt([42], 1);
  t.equal(res, undefined);
  t.end();
});

test('Iterable#elementAt multiple values valid index', t => {
  const res = elementAt([1, 42, 3], 1);
  t.equal(res, 42);
  t.end();
});

test('Iterable#elementAt multiple values invalid index', t => {
  const res = elementAt([1, 42, 3], 7);
  t.equal(res, undefined);

import * as test from 'tape';
import {exec} from '../src/index';

test('fake command should error', t => {
    t.plan(1);
    exec('fake-command', null)
        .then(out => t.error(out))
        .catch(err => t.ok(true, err.message));
});

test('fake path should error', t => {
    t.plan(1);
    exec('mkdir foo', '/fake/path')
        .then(out => t.error(out))
        .catch(err => t.ok(true, err.message));
});

test('git version should return version', t => {
    t.plan(1);
    exec('git --version', null)
        .then(out => t.ok(out.includes('git version'), out))
        .catch(err => t.fail(err.message));
});

test('git status should return status', t => {
    t.plan(1);
    exec('git status', null)
        .then(out => t.ok(true, out))
        .catch(err => t.fail(err.message));
});

import * as Ix from '../Ix';
import * as test from 'tape';
const { toMap } = Ix.iterable;

test('Iterable#toMap stores values', t => {
  const res = toMap([1, 4], x => x % 2);
  t.equal(res.get(0), 4);
  t.equal(res.get(1), 1);
  t.end();
});

test('Iterable#toMap overwrites duplicates', t => {
  const res = toMap([1, 4, 2], x => x % 2);
  t.equal(res.get(0), 2);
  t.equal(res.get(1), 1);
  t.end();
});

test('Iterable#toMap with element selector', t => {
  const res = toMap([1, 4], x => x % 2, x => x + 1);
  t.equal(res.get(0), 5);
  t.equal(res.get(1), 2);
  t.end();
});

test('Iterable#toMap with element selector overwrites duplicates', t => {
  const res = toMap([1, 4, 2], x => x % 2, x => x + 1);
  t.equal(res.get(0), 3);
  t.equal(res.get(1), 2);
  t.end();
});

import * as test from 'tape';
const { throttle } = Ix.asynciterable;
import { hasNext, noNext } from '../asynciterablehelpers';

function delayItem<T>(item: T, delay: number) {
  return new Promise<T>(res => setTimeout(() => res(item), delay));
}

test('AsyncIterable#throttle drops none', async t => {
  const xs = async function*() {
    yield await delayItem(1, 100);
    yield await delayItem(2, 100);
    yield await delayItem(3, 100);
  };
  const ys = throttle(xs(), 50);

  const it = ys[Symbol.asyncIterator]();
  await hasNext(t, it, 1);
  await hasNext(t, it, 2);
  await hasNext(t, it, 3);
  await noNext(t, it);
  t.end();
});

test('AsyncIterable#throttle drops some', async t => {
  const xs = async function*() {
    yield await delayItem(1, 100);
    yield await delayItem(2, 100);
    yield await delayItem(3, 100);
    yield await delayItem(4, 100);
  };

import * as test from 'tape';

import {compare} from './patch';

test('utils/patch: JSON patch should deal gracefully with undefined values', t => {
  t.plan(3);

  const obj1 = {a: 'foo', b: undefined};
  const obj2 = {a: 'foo', b: undefined};

  const changes = compare(obj1, obj2);

  t.ok(changes, 'changes is not null');
  t.ok(Array.isArray(changes), 'changes is an array');
  t.notOk(changes.length, 'objects should compare as identical');

  t.end();
});

test('utils/patch: JSON patch can generate a changeset for simple objects', t => {
  t.plan(5);

  const obj1 = {a: 'foo', b: 'bar'};
  const obj2 = {a: 'foo', b: 'foo'};

  const changes = compare(obj1, obj2);

  t.ok(changes, 'changes is not null');
  t.ok(Array.isArray(changes), 'changes is an array');
  t.equals(1, changes.length, 'changes should contain one change');
  t.equals('replace', changes[0].op, 'operation should be a "replace" op');

export function kaktest(
  name: string,
  cb: (kak: Kak<Splice>, t: test.Test, end: () => void) => void | Promise<any>
): void {
  test(name, (t: test.Test) => {
    t.timeoutAfter(1000)
    t.plan(1)
    const proc = libkak.Headless()
    const session = proc.pid
    const kak = Kak.Init(Splice, {session, client: 'unnamed0', debug})
    const end = () => (proc.kill(), kak.teardown(), t.end())
    cb(kak, t, end)
  })
}

        await delay(5);
        ctx.body = "ok";
        ctx.status = 200;
    });

test('public:200', { skip: false }, async (t) => {
    let store = await getStore(false);
    let app = new Koa();
    //public
    app.use(publicRoute);
    //Auth   
    app.use(authentication);
    //Secured
    app.use(secretRoute);    

    let request = supertest.agent(listen(app));
    request
        .get('/public')
        .expect(200)
        .end(async (err, res) => {
            await delay(5);
            t.assert(!err);
            if (err) debug(err.message);
            t.end();
        });
});

const authentication = auth(users.service.fromCredentials);

const secretRoute = router.get('/secret',
        async function (args, next) {

const { elementAt } = Ix.iterable;
const { first } = Ix.iterable;
const { isEmpty } = Ix.iterable;
const { last } = Ix.iterable;
const { range } = Ix.iterable;
const { sequenceEqual } = Ix.iterable;
const { skip } = Ix.iterable;
const { take } = Ix.iterable;
const { toArray } = Ix.iterable;

test('Iterable#range produces correct sequence', t => {
  const rangeSequence = range(1, 100);
  let expected = 0;

  for (let item of rangeSequence) {
    expected++;
    t.equal(expected, item);
  }

  t.equal(100, expected);
  t.end();
});

test('Iterable#range toArray produce correct result', t => {
  const arr = toArray(range(1, 100));

  for (let i = 0; i < arr.length; i++) {
    t.equal(i + 1, arr[i]);
  }
  t.end();
});

import { skipDirectories, skipMeta } from '../../src/transforms/skip-items';
import ContentItemBuilder from '../../src/content-item-builder';

test('skipItems', (t) => {

    t.test('skipDirectories', (st) => {
        {
            const item = new ContentItemBuilder(true, '/').build();
            st.ok(skipDirectories(item), 'is directory');
        }
        {
            const item = new ContentItemBuilder(false, '/').build();
            st.notOk(skipDirectories(item), 'isn\'t directory');
        }
        st.end();
    });

    t.test('skipMeta', (st) => {
        {
            const item = new ContentItemBuilder(false, '/meta.yaml').build();
            st.ok(skipMeta(item), 'is meta');
        }
        {
            const item = new ContentItemBuilder(false, '/whatever').build();
            st.notOk(skipMeta(item), 'isn\'t meta');
        }
        st.end();
    });

});