How to use the assert.strict function in assert

credential = await this.fetch(fqdn);
			}
		} else {
			assert(allowRemote, `Credential ${fqdn} was not found locally and allowRemote is false`);
			credential = await this.fetch(fqdn);
		}
		assert(credential, `Credential ${fqdn} was not found!`);

		// check validity if allowed
		if(!allowExpired) {
			credential.checkValidity();
		}

		// check ocsp status if allowed
		if(!allowRevoked) {
			assert(await credential.checkOcspStatus(credential) !== config.OcspStatus.Revoked,
				`Credential ${fqdn} is revoked and allowRevoked is false`);
		}

		return credential;
	}

it('bad function that turns good without wait', async () => {
		const retries = 10;
		const errorMessage = "error on retry func";

		let fncalled = 0;
		const fn = simple.stub().callFn(function() {
			if(fncalled < 7) {
				fncalled++;
				throw new Error(errorMessage);
			}
			return true;
		});

		const result = await commonUtils.retry(fn, retries,(() => 0));
		assert.equal(fn.callCount, fncalled+1);
		assert(result);
	});
});

it('double stopping fails second time', () => {
		beameUtils.startBackgroundJob(name,() => {}, 2000);
		beameUtils.stopBackgroundJob(name);
		try {
			beameUtils.stopBackgroundJob(name);
			assert.fail("Should have failed");
		}
		catch (e) {
			assert(e && e.message, "error shouldn't be empty");
		}
	});

it('should match leading slashes', () => {
    assert(!isMatch('ef', '/*'));
    assert(isMatch('/ef', '/*'));
    assert(isMatch('/foo/bar.txt', '/foo/*'));
    assert(isMatch('/foo/bar.txt', '/foo/**'));
    assert(isMatch('/foo/bar.txt', '/foo/**/**/*.txt'));
    assert(isMatch('/foo/bar.txt', '/foo/**/**/bar.txt'));
    assert(isMatch('/foo/bar.txt', '/foo/**/*.txt'));
    assert(isMatch('/foo/bar.txt', '/foo/**/bar.txt'));
    assert(!isMatch('/foo/bar.txt', '/foo/*/bar.txt'));
    assert(!isMatch('/foo/bar/baz.txt', '/foo/*'));
    assert(isMatch('/foo/bar/baz.txt', '/foo/**'));
    assert(isMatch('/foo/bar/baz.txt', '/foo/**'));
    assert(isMatch('/foo/bar/baz.txt', '/foo/**/*.txt'));
    assert(isMatch('/foo/bar/baz.txt', '/foo/**/*/*.txt'));
    assert(isMatch('/foo/bar/baz.txt', '/foo/**/*/baz.txt'));
    assert(!isMatch('/foo/bar/baz.txt', '/foo/*.txt'));
    assert(isMatch('/foo/bar/baz.txt', '/foo/*/*.txt'));
    assert(!isMatch('/foo/bar/baz.txt', '/foo/*/*/baz.txt'));
    assert(!isMatch('/foo/bar/baz.txt', '/foo/bar**'));
    assert(isMatch('/foo/bar/baz/qux.txt', '**/*.txt'));
    assert(!isMatch('/foo/bar/baz/qux.txt', '**/.txt'));

(function hidden() {
    const err = new assert.AssertionError({
      actual: 'foo',
      operator: 'strictEqual',
      stackStartFunction: hidden
    });
    const err2 = new assert.AssertionError({
      actual: 'foo',
      operator: 'strictEqual',
      stackStartFn: hidden
    });
    assert(!err.stack.includes('hidden'));
    assert(!err2.stack.includes('hidden'));
  })();
}

let txCount = 0;
	let blCount = 0;

	for(let bl in res['block']) {
		txCount += res['block'][bl].transactions.length;
		blCount++;
	}

	let traceCount = res['trace'].length;

	console.log("The resulting package contains "+txCount+" transactions, "+res['log'].length+" logs and "+traceCount+" traces.");
	
	//check if there have been too many traces, but only if we actually had enough transactions
	if(txCount > blCount && traceCount > txCount * 5) {
		console.error("Too many traces compared to transactions! Breaking, take a look.");
		assert(false);
	}

	let blockchain = structureBlockchainData(res['block'], res['log'], res['trace']);
	
	if(filename == null){
		filename = datadir+"blocks "+blockchain['block'][0].number+"-"+blockchain['block'][blockchain['block'].length-1].number+".json";
	}

	jsonUtil.save(blockchain, filename);
}

static _checkAccess(access) {
    assert(typeof access === 'object' && !(access instanceof Array),
      'access.yml should define an object');
    Object.keys(access).forEach(serviceName => {
      const serviceAccess = access[serviceName];
      assert(typeof serviceAccess === 'object' && !(serviceAccess instanceof Array),
        'each service in access.yml should define an object');
      assert.deepEqual(Object.keys(serviceAccess).sort(), ['tables'],
        'each service in access.yml should only have a `tables` property');
    });
  }

if (typeof payload.nbf !== 'undefined' && !ignoreNotBefore) {
      assert.equal(typeof payload.nbf, 'number', 'invalid nbf value');
      assert(payload.nbf <= timestamp + clockTolerance, 'jwt not active yet');
    }

    if (typeof payload.iat !== 'undefined' && !ignoreIssued) {
      assert.equal(typeof payload.iat, 'number', 'invalid iat value');
      if (typeof payload.exp === 'undefined') {
        assert(payload.iat <= timestamp + clockTolerance, 'jwt issued in the future');
      }
    }

    if (typeof payload.exp !== 'undefined' && !ignoreExpiration) {
      assert.equal(typeof payload.exp, 'number', 'invalid exp value');
      assert(timestamp - clockTolerance < payload.exp, 'jwt expired');
    }

    if (typeof payload.jti !== 'undefined') {
      assert.equal(typeof payload.jti, 'string', 'invalid jti value');
    }

    if (typeof payload.iss !== 'undefined') {
      assert.equal(typeof payload.iss, 'string', 'invalid iss value');
    }

    if (jti) {
      assert.equal(payload.jti, jti, 'jwt jti invalid');
    }

    if (audience) {
      verifyAudience(