it('should work', function (done) {
   assert.doesNotThrow(function () { 
     tableService.doesTableExist('$MetricsMinutePrimaryTransactionsBlob', function () { 
       assert.doesNotThrow(function () { 
         tableService.doesTableExist('$MetricsTransactionsTable', function () { 
           done();
         }); 
       });     
     }); 
   });      
 });

 next: (root: Element) => {
   const myElement = root.querySelector(
     '.myelementclass'
   ) as HTMLElement;
   assert.notStrictEqual(myElement, null);
   assert.notStrictEqual(typeof myElement, 'undefined');
   assert.strictEqual(myElement.tagName, 'H3');
   assert.doesNotThrow(function() {
     setTimeout(() => myElement.click());
   });
 },

 it('should return error on bad .p12 in callback', done => {
   assert.doesNotThrow(() => {
     getPem(BADP12FILE, (err, pem) => {
       assert(err);
       if (err) {
         assert(err.message.indexOf('Too few bytes to read') > -1);
         done();
       }
     });
   });
 });

 test('checkConsistency accepts isolated vertices', function() {
   var f1, mesh, v0, v1, v2, v3;
   mesh = new HalfEdgeMesh;
   v0 = mesh.createVertex([0, 0, 0]);
   v1 = mesh.createVertex([1, 0, 0]);
   v2 = mesh.createVertex([1, 1, 0]);
   v3 = mesh.createVertex([0, 0, 1]);
   f1 = mesh.newFace([v0, v1, v2]);
   assert.doesNotThrow(function() {
     mesh.checkConsistency();
   });
 });

 next: (root: Element) => {
   const firstElem = root.querySelector('.first') as HTMLElement;
   const secondElem = root.querySelector('.second') as HTMLElement;
   assert.notStrictEqual(firstElem, null);
   assert.notStrictEqual(typeof firstElem, 'undefined');
   assert.notStrictEqual(secondElem, null);
   assert.notStrictEqual(typeof secondElem, 'undefined');
   assert.doesNotThrow(function() {
     setTimeout(() => firstElem.click());
     setTimeout(() => secondElem.click(), 5);
   });
 },

    it('should throw if addNode() is invoked with already existing node', () => {
        const nodes = new Map<number, any>();
        const sortOp = new TopologicalSort<number, any>(nodes);

        assert.doesNotThrow(() => {
            sortOp.addNode(1, {});
        }, 'addNode() should not throw if nodes list is empty');

        assert.throws(() => {
            sortOp.addNode(1, {});
        }, 'addNode() should throw an error if node with this key already exists');
    });

 it('should not error if only refresh token is set', () => {
   const oauth2client = new googleapis.auth.OAuth2(
     CLIENT_ID,
     CLIENT_SECRET,
     REDIRECT_URI
   );
   oauth2client.credentials = {refresh_token: 'refresh_token'};
   assert.doesNotThrow(() => {
     const options = {auth: oauth2client, shortUrl: '...'};
     localUrlshortener.url.get(options, Utils.noop);
     remoteUrlshortener.url.get(options, Utils.noop);
   });
 });

	it("should assert if node detached", ()=>
	{
		const list = new LinkedList<number>();
		list.add(1).add(2);
		assert.equal(list.count, 2);

		assert.equal(list.findLast(1)!.value,1);
		assert.equal(list.firstValue,1);
		assert.equal(list.find(2)!.value,2);
		assert.equal(list.lastValue,2);
		list.last!.value = 3;
		assert.equal(list.find(3)!.value,3);
		assert.equal(list.lastValue,3);

		list.addAfter(list.first!,5)
			.addFirst(0)
			.addLast(10);

		assert.equal(list.first!.value,0);
		assert.equal(list.getNodeAt(0)!.value,0);
		assert.equal(list.getValueAt(0),0);
		assert.equal(list!.getNodeAt(2)!.value,5);
		assert.equal(list.getValueAt(2),5);
		assert.equal(list!.getNodeAt(4)!.value,10);
		assert.equal(list.getValueAt(4),10);
		assert.ok(list.removeLast());
		assert.ok(list.removeFirst());
		const n = list.getNodeAt(1)!;
		assert.ok(list.removeAt(1));
		assert.throws(()=>n.value);

		const last = list.last!;
		assert.equal(last.previous!.value,1);
		assert.equal(last.previous!.next,last);
		last.remove();
		assert.ok(!last.list);
		assert.equal(list.count, 1);

		assert.doesNotThrow(()=>last.remove());
		assert.throws(()=>last.value);
		assert.throws(()=>last.next);
		assert.throws(()=>last.previous);

		const first = list.first!;
		list.dispose();
		assert.ok(!first.list);
		assert.throws(()=>first.value);

	})