diff --git a/functions/helloworld/index.js b/functions/helloworld/index.js
index 496798897c..f8eb85a3f3 100644
--- a/functions/helloworld/index.js
+++ b/functions/helloworld/index.js
@@ -49,7 +49,13 @@ exports.helloGET = (req, res) => {
  */
 // [START functions_tips_terminate]
 exports.helloHttp = (req, res) => {
-  res.send(`Hello ${escapeHtml(req.query.name || req.body.name || 'World')}!`);
+  const name =
+    req.query && req.query.name
+      ? req.query.name
+      : req.body && req.body.name
+      ? req.body.name
+      : 'World';
+  res.send(`Hello ${escapeHtml(name)}!`);
 };
 // [END functions_helloworld_http]
 
diff --git a/functions/helloworld/package.json b/functions/helloworld/package.json
index 4b6c438d36..3d1d066575 100644
--- a/functions/helloworld/package.json
+++ b/functions/helloworld/package.json
@@ -12,9 +12,9 @@
     "node": ">=8"
   },
   "scripts": {
-    "e2e-test": "export FUNCTIONS_CMD='gcloud functions' && sh test/updateFunctions.sh && BASE_URL=\"https://$GCP_REGION-$GCLOUD_PROJECT.cloudfunctions.net/\" ava -T 20s --verbose test/*.test.js",
-    "test": "export FUNCTIONS_CMD='functions-emulator' && sh test/updateFunctions.sh && export BASE_URL=\"http://localhost:8010/$GCLOUD_PROJECT/$GCF_REGION\" && ava -T 20s --verbose -c 1 test/index.test.js",
-    "system-test": "export FUNCTIONS_CMD='functions-emulator' && sh test/updateFunctions.sh && export BASE_URL=\"http://localhost:8010/$GCLOUD_PROJECT/$GCF_REGION\" && ava -T 20s --verbose test/*.test.js"
+    "e2e-test": "export FUNCTIONS_CMD='gcloud functions' && sh test/updateFunctions.sh && BASE_URL=\"https://$GCP_REGION-$GCLOUD_PROJECT.cloudfunctions.net/\" mocha test/*.test.js --timeout=60000 --exit",
+    "test": "export FUNCTIONS_CMD='functions-emulator' && sh test/updateFunctions.sh && export BASE_URL=\"http://localhost:8010/$GCLOUD_PROJECT/$GCF_REGION\" && mocha test/*.test.js --timeout=60000 --exit",
+    "system-test": "export FUNCTIONS_CMD='functions-emulator' && sh test/updateFunctions.sh && export BASE_URL=\"http://localhost:8010/$GCLOUD_PROJECT/$GCF_REGION\" && mocha test/*.test.js --timeout=60000 --exit"
   },
   "dependencies": {
     "@google-cloud/debug-agent": "^3.0.0",
@@ -26,7 +26,7 @@
     "@google-cloud/nodejs-repo-tools": "^3.0.0",
     "@google-cloud/pubsub": "^0.22.0",
     "@google-cloud/storage": "^2.0.0",
-    "ava": "^0.25.0",
+    "mocha": "^6.0.0",
     "express": "^4.16.3",
     "proxyquire": "^2.1.0",
     "sinon": "^7.0.0",
diff --git a/functions/helloworld/shim.js b/functions/helloworld/shim.js
index e5f5d2ebda..bd510180f0 100644
--- a/functions/helloworld/shim.js
+++ b/functions/helloworld/shim.js
@@ -73,9 +73,9 @@ const pubsubShim = (gcfFn, topicName, subscriptionName) => {
 const storageShim = (gcfFn, bucketName, topicName, subscriptionName) => {
   // [START functions_testing_shim_storage]
   // Import dependencies
-  const Pubsub = require('@google-cloud/pubsub');
+  const {PubSub} = require('@google-cloud/pubsub');
   const {Storage} = require(`@google-cloud/storage`);
-  const pubsub = Pubsub();
+  const pubsub = new PubSub();
   const storage = new Storage();
 
   // TODO(developer): specify a function to test
diff --git a/functions/helloworld/test/index.test.js b/functions/helloworld/test/index.test.js
index f05f979872..3c60c77ba7 100644
--- a/functions/helloworld/test/index.test.js
+++ b/functions/helloworld/test/index.test.js
@@ -15,20 +15,20 @@
 
 const Buffer = require('safe-buffer').Buffer;
 const path = require('path');
-const test = require(`ava`);
-const tools = require(`@google-cloud/nodejs-repo-tools`);
-const supertest = require(`supertest`);
-const uuid = require(`uuid`);
+const assert = require('assert');
+const tools = require('@google-cloud/nodejs-repo-tools');
+const supertest = require('supertest');
+const uuid = require('uuid');
 
-const {PubSub} = require(`@google-cloud/pubsub`);
+const {PubSub} = require('@google-cloud/pubsub');
 const pubsub = new PubSub();
-const {Storage} = require(`@google-cloud/storage`);
+const {Storage} = require('@google-cloud/storage');
 const storage = new Storage();
 
 const baseCmd = process.env.FUNCTIONS_CMD;
 const topicName = process.env.FUNCTIONS_TOPIC;
 
-const localFileName = `test.txt`;
+const localFileName = 'test.txt';
 const fileName = `test-${uuid.v4()}.txt`;
 
 const BASE_URL = process.env.BASE_URL;
@@ -36,83 +36,76 @@ const BASE_URL = process.env.BASE_URL;
 const bucketName = process.env.FUNCTIONS_BUCKET;
 const bucket = storage.bucket(bucketName);
 
-test.before(`Must specify BASE_URL`, t => {
-  t.truthy(BASE_URL);
+before('Must specify BASE_URL', () => {
+  assert.ok(BASE_URL);
+  tools.checkCredentials();
 });
 
-test.before(tools.checkCredentials);
-
-test.cb(`helloGET: should print hello world`, t => {
-  supertest(BASE_URL)
-    .get(`/helloGET`)
+it('helloGET: should print hello world', async () => {
+  await supertest(BASE_URL)
+    .get('/helloGET')
     .expect(200)
     .expect(response => {
-      t.is(response.text, `Hello World!`);
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello World!');
+    });
 });
 
-test.cb(`helloHttp: should print a name via GET`, t => {
-  supertest(BASE_URL)
-    .get(`/helloHttp?name=John`)
+it('helloHttp: should print a name via GET', async () => {
+  await supertest(BASE_URL)
+    .get('/helloHttp?name=John')
     .expect(200)
     .expect(response => {
-      t.is(response.text, 'Hello John!');
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello John!');
+    });
 });
 
-test.cb(`helloHttp: should print a name via POST`, t => {
-  supertest(BASE_URL)
-    .post(`/helloHttp`)
+it('helloHttp: should print a name via POST', async () => {
+  await supertest(BASE_URL)
+    .post('/helloHttp')
     .send({name: 'John'})
     .expect(200)
     .expect(response => {
-      t.is(response.text, 'Hello John!');
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello John!');
+    });
 });
 
-test.cb(`helloHttp: should print hello world`, t => {
-  supertest(BASE_URL)
-    .get(`/helloHttp`)
+it('helloHttp: should print hello world', async () => {
+  await supertest(BASE_URL)
+    .get('/helloHttp')
     .expect(200)
     .expect(response => {
-      t.is(response.text, `Hello World!`);
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello World!');
+    });
 });
 
-test.cb.serial(`helloHttp: should escape XSS`, t => {
-  supertest(BASE_URL)
-    .post(`/helloHttp`)
+it('helloHttp: should escape XSS', async () => {
+  await supertest(BASE_URL)
+    .post('/helloHttp')
     .send({name: '<script>alert(1)</script>'})
     .expect(200)
     .expect(response => {
-      t.false(response.text.includes('<script>'));
-    })
-    .end(t.end);
+      assert.strictEqual(response.text.includes('<script>'), false);
+    });
 });
 
-test(`helloBackground: should print a name`, async t => {
+it.only('helloBackground: should print a name', async () => {
   const data = JSON.stringify({name: 'John'});
   const output = await tools.runAsync(
     `${baseCmd} call helloBackground --data '${data}'`
   );
 
-  t.true(output.includes('Hello John!'));
+  assert.strictEqual(output.includes('Hello John!'), true);
 });
 
-test(`helloBackground: should print hello world`, async t => {
+it('helloBackground: should print hello world', async () => {
   const output = await tools.runAsync(
     `${baseCmd} call helloBackground --data '{}'`
   );
 
-  t.true(output.includes('Hello World!'));
+  assert.strictEqual(output.includes('Hello World!'), true);
 });
 
-test(`helloPubSub: should print a name`, async t => {
-  t.plan(0);
+it('helloPubSub: should print a name', async () => {
   const startTime = new Date(Date.now()).toISOString();
   const name = uuid.v4();
 
@@ -126,12 +119,11 @@ test(`helloPubSub: should print a name`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloPubSub --start-time ${startTime}`
     );
-    assert(logs.includes(`Hello, ${name}!`));
+    assert.strictEqual(logs.includes(`Hello, ${name}!`), true);
   });
 });
 
-test(`helloPubSub: should print hello world`, async t => {
-  t.plan(0);
+it('helloPubSub: should print hello world', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Publish to pub/sub topic
@@ -144,12 +136,11 @@ test(`helloPubSub: should print hello world`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloPubSub --start-time ${startTime}`
     );
-    assert(logs.includes('Hello, World!'));
+    assert.strictEqual(logs.includes('Hello, World!'), true);
   });
 });
 
-test.serial(`helloGCS: should print uploaded message`, async t => {
-  t.plan(0);
+it('helloGCS: should print uploaded message', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Upload file
@@ -163,46 +154,49 @@ test.serial(`helloGCS: should print uploaded message`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloGCS --start-time ${startTime}`
     );
-    assert(logs.includes(`File ${fileName} uploaded`));
+    assert.strictEqual(logs.includes(`File ${fileName} uploaded`), true);
   });
 });
 
-test.serial(`helloGCS: should print metadata updated message`, async t => {
-  t.plan(0);
+it('helloGCS: should print metadata updated message', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Update file metadata
-  await bucket.setMetadata(fileName, {foo: `bar`});
+  await bucket.setMetadata(fileName, {foo: 'bar'});
 
   // Check logs
   await tools.tryTest(async assert => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloGCS --start-time ${startTime}`
     );
-    assert(logs.includes(`File ${fileName} metadata updated`));
+    assert.strictEqual(
+      logs.includes(`File ${fileName} metadata updated`),
+      true
+    );
   });
 });
 
-test.serial(`helloGCSGeneric: should print event details`, async t => {
-  t.plan(0);
+it('helloGCSGeneric: should print event details', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Update file metadata
-  await bucket.setMetadata(fileName, {foo: `baz`});
+  await bucket.setMetadata(fileName, {foo: 'baz'});
 
   // Check logs
   await tools.tryTest(async assert => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloGCSGeneric --start-time ${startTime}`
     );
-    assert(logs.includes(`Bucket: ${bucketName}`));
-    assert(logs.includes(`File: ${fileName}`));
-    assert(logs.includes(`Event type: google.storage.object.metadataUpdate`));
+    assert.strictEqual(logs.includes(`Bucket: ${bucketName}`), true);
+    assert.strictEqual(logs.includes(`File: ${fileName}`), true);
+    assert.strictEqual(
+      logs.includes('Event type: google.storage.object.metadataUpdate'),
+      true
+    );
   });
 });
 
-test.serial(`helloGCS: should print deleted message`, async t => {
-  t.plan(0);
+it('helloGCS: should print deleted message', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Delete file
@@ -213,12 +207,11 @@ test.serial(`helloGCS: should print deleted message`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloGCS --start-time ${startTime}`
     );
-    assert(logs.includes(`File ${fileName} deleted`));
+    assert.strictEqual(logs.includes(`File ${fileName} deleted`), true);
   });
 });
 
-test(`helloError: should throw an error`, async t => {
-  t.plan(0);
+it('helloError: should throw an error', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Publish to pub/sub topic
@@ -231,12 +224,11 @@ test(`helloError: should throw an error`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloError --start-time ${startTime}`
     );
-    assert(logs.includes('Error: I failed you'));
+    assert.strictEqual(logs.includes('Error: I failed you'), true);
   });
 });
 
-test(`helloError2: should throw a value`, async t => {
-  t.plan(0);
+it('helloError2: should throw a value', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Publish to pub/sub topic
@@ -249,12 +241,11 @@ test(`helloError2: should throw a value`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloError2 --start-time ${startTime}`
     );
-    assert(logs.includes(' 1\n'));
+    assert.strictEqual(logs.includes(' 1\n'), true);
   });
 });
 
-test(`helloError3: callback should return an errback value`, async t => {
-  t.plan(0);
+it('helloError3: callback should return an errback value', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Publish to pub/sub topic
@@ -267,16 +258,20 @@ test(`helloError3: callback should return an errback value`, async t => {
     const logs = await tools.runAsync(
       `${baseCmd} logs read helloError3 --start-time ${startTime}`
     );
-    assert(logs.includes(' I failed you\n'));
+    assert.strictEqual(logs.includes(' I failed you\n'), true);
   });
 });
 
-test.cb(`helloTemplate: should render the html`, t => {
-  supertest(BASE_URL)
-    .get(`/helloTemplate`)
+it('helloTemplate: should render the html', async () => {
+  await supertest(BASE_URL)
+    .get('/helloTemplate')
     .expect(200)
     .expect(response => {
-      t.regex(response.text, /<h1>Cloud Functions Template Sample<\/h1>/);
-    })
-    .end(t.end);
+      assert.strictEqual(
+        new RegExp(/<h1>Cloud Functions Template Sample<\/h1>/).test(
+          response.text
+        ),
+        true
+      );
+    });
 });
diff --git a/functions/helloworld/test/sample.integration.http.test.js b/functions/helloworld/test/sample.integration.http.test.js
index acddc9749f..f8168bf24b 100644
--- a/functions/helloworld/test/sample.integration.http.test.js
+++ b/functions/helloworld/test/sample.integration.http.test.js
@@ -14,28 +14,26 @@
  */
 
 // [START functions_http_integration_test]
-const test = require(`ava`);
-const Supertest = require(`supertest`);
+const assert = require('assert');
+const Supertest = require('supertest');
 const supertest = Supertest(process.env.BASE_URL);
 
-test.cb(`helloHttp: should print a name`, t => {
-  supertest
-    .post(`/helloHttp`)
+it('helloHttp: should print a name', async () => {
+  await supertest
+    .post('/helloHttp')
     .send({name: 'John'})
     .expect(200)
     .expect(response => {
-      t.is(response.text, 'Hello John!');
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello John!');
+    });
 });
 
-test.cb(`helloHttp: should print hello world`, t => {
-  supertest
-    .get(`/helloHttp`)
+it('helloHttp: should print hello world', async () => {
+  await supertest
+    .get('/helloHttp')
     .expect(200)
     .expect(response => {
-      t.is(response.text, `Hello World!`);
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello World!');
+    });
 });
 // [END functions_http_integration_test]
diff --git a/functions/helloworld/test/sample.integration.pubsub.test.js b/functions/helloworld/test/sample.integration.pubsub.test.js
index 0ca6e2413b..a59df42639 100644
--- a/functions/helloworld/test/sample.integration.pubsub.test.js
+++ b/functions/helloworld/test/sample.integration.pubsub.test.js
@@ -14,38 +14,38 @@
  */
 
 // [START functions_pubsub_integration_test]
-const childProcess = require(`child_process`);
-const test = require(`ava`);
-const uuid = require(`uuid`);
+const childProcess = require('child_process');
+const assert = require('assert');
+const uuid = require('uuid');
 
-test.serial(`helloPubSub: should print a name`, async t => {
-  t.plan(1);
+it('helloPubSub: should print a name', done => {
   const startTime = new Date(Date.now()).toISOString();
   const name = uuid.v4();
 
   // Mock Pub/Sub call, as the emulator doesn't listen to Pub/Sub topics
-  const encodedName = Buffer.from(name).toString(`base64`);
+  const encodedName = Buffer.from(name).toString('base64');
   const data = JSON.stringify({data: encodedName});
-  childProcess.execSync(`functions call helloPubSub --data '${data}'`);
+  childProcess.execSync(`functions call helloPubSub --data ${data}`);
 
   // Check the emulator's logs
   const logs = childProcess
     .execSync(`functions logs read helloPubSub --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`Hello, ${name}!`));
+  assert.strictEqual(logs.includes(`Hello, ${name}!`), true);
+  done();
 });
 
-test.serial(`helloPubSub: should print hello world`, async t => {
-  t.plan(1);
+it('helloPubSub: should print hello world', done => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Mock Pub/Sub call, as the emulator doesn't listen to Pub/Sub topics
-  childProcess.execSync(`functions call helloPubSub --data {}`);
+  childProcess.execSync('functions call helloPubSub --data {}');
 
   // Check the emulator's logs
   const logs = childProcess
     .execSync(`functions logs read helloPubSub --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`Hello, World!`));
+  assert.strictEqual(logs.includes('Hello, World!'), true);
+  done();
 });
 // [END functions_pubsub_integration_test]
diff --git a/functions/helloworld/test/sample.integration.storage.test.js b/functions/helloworld/test/sample.integration.storage.test.js
index df27ee4d92..3daf38c4b8 100644
--- a/functions/helloworld/test/sample.integration.storage.test.js
+++ b/functions/helloworld/test/sample.integration.storage.test.js
@@ -14,12 +14,11 @@
  */
 
 // [START functions_storage_integration_test]
-const childProcess = require(`child_process`);
-const test = require(`ava`);
-const uuid = require(`uuid`);
+const childProcess = require('child_process');
+const assert = require('assert');
+const uuid = require('uuid');
 
-test.serial(`helloGCS: should print uploaded message`, async t => {
-  t.plan(1);
+it('helloGCS: should print uploaded message', done => {
   const startTime = new Date(Date.now()).toISOString();
   const filename = uuid.v4(); // Use a unique filename to avoid conflicts
 
@@ -36,11 +35,11 @@ test.serial(`helloGCS: should print uploaded message`, async t => {
   const logs = childProcess
     .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`File ${filename} uploaded.`));
+  assert.ok(logs.includes(`File ${filename} uploaded.`));
+  done();
 });
 
-test.serial(`helloGCS: should print metadata updated message`, async t => {
-  t.plan(1);
+it('helloGCS: should print metadata updated message', done => {
   const startTime = new Date(Date.now()).toISOString();
   const filename = uuid.v4(); // Use a unique filename to avoid conflicts
 
@@ -57,11 +56,11 @@ test.serial(`helloGCS: should print metadata updated message`, async t => {
   const logs = childProcess
     .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`File ${filename} metadata updated.`));
+  assert.ok(logs.includes(`File ${filename} metadata updated.`));
+  done();
 });
 
-test.serial(`helloGCS: should print deleted message`, async t => {
-  t.plan(1);
+it('helloGCS: should print deleted message', done => {
   const startTime = new Date(Date.now()).toISOString();
   const filename = uuid.v4(); // Use a unique filename to avoid conflicts
 
@@ -78,6 +77,6 @@ test.serial(`helloGCS: should print deleted message`, async t => {
   const logs = childProcess
     .execSync(`functions-emulator logs read helloGCS --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`File ${filename} deleted.`));
+  assert.ok(logs.includes(`File ${filename} deleted.`));
 });
 // [END functions_storage_integration_test]
diff --git a/functions/helloworld/test/sample.system.http.test.js b/functions/helloworld/test/sample.system.http.test.js
index 51bb9c94b3..966fec7a8b 100644
--- a/functions/helloworld/test/sample.system.http.test.js
+++ b/functions/helloworld/test/sample.system.http.test.js
@@ -14,28 +14,26 @@
  */
 
 // [START functions_http_system_test]
-const test = require(`ava`);
-const Supertest = require(`supertest`);
+const assert = require('assert');
+const Supertest = require('supertest');
 const supertest = Supertest(process.env.BASE_URL);
 
-test.cb(`helloHttp: should print a name`, t => {
-  supertest
-    .post(`/helloHttp`)
+it('helloHttp: should print a name', async () => {
+  await supertest
+    .post('/helloHttp')
     .send({name: 'John'})
     .expect(200)
     .expect(response => {
-      t.is(response.text, 'Hello John!');
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello John!');
+    });
 });
 
-test.cb(`helloHttp: should print hello world`, t => {
-  supertest
-    .get(`/helloHttp`)
+it('helloHttp: should print hello world', async () => {
+  await supertest
+    .get('/helloHttp')
     .expect(200)
     .expect(response => {
-      t.is(response.text, `Hello World!`);
-    })
-    .end(t.end);
+      assert.strictEqual(response.text, 'Hello World!');
+    });
 });
 // [END functions_http_system_test]
diff --git a/functions/helloworld/test/sample.system.pubsub.test.js b/functions/helloworld/test/sample.system.pubsub.test.js
index 0cf511f0cf..2aa48087bb 100644
--- a/functions/helloworld/test/sample.system.pubsub.test.js
+++ b/functions/helloworld/test/sample.system.pubsub.test.js
@@ -14,17 +14,18 @@
  */
 
 // [START functions_pubsub_system_test]
-const childProcess = require(`child_process`);
-const test = require(`ava`);
-const uuid = require(`uuid`);
-const {PubSub} = require(`@google-cloud/pubsub`);
+const childProcess = require('child_process');
+const assert = require('assert');
+const uuid = require('uuid');
+const {PubSub} = require('@google-cloud/pubsub');
 const pubsub = new PubSub();
 
+process.env.FUNCTIONS_TOPIC =
+  'projects/grass-clump-479/topics/gcloud-logging-test0165b071-1325-11e9-bc58-d3b6d1def78e';
 const topicName = process.env.FUNCTIONS_TOPIC;
-const baseCmd = `gcloud functions`;
+const baseCmd = 'gcloud functions';
 
-test(`helloPubSub: should print a name`, async t => {
-  t.plan(1);
+it('helloPubSub: should print a name', async () => {
   const startTime = new Date(Date.now()).toISOString();
   const name = uuid.v4();
 
@@ -40,11 +41,10 @@ test(`helloPubSub: should print a name`, async t => {
   const logs = childProcess
     .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`Hello, ${name}!`));
+  assert.ok(logs.includes(`Hello, ${name}!`));
 });
 
-test(`helloPubSub: should print hello world`, async t => {
-  t.plan(1);
+it('helloPubSub: should print hello world', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Publish to pub/sub topic
@@ -59,6 +59,6 @@ test(`helloPubSub: should print hello world`, async t => {
   const logs = childProcess
     .execSync(`${baseCmd} logs read helloPubSub --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes('Hello, World!'));
+  assert.ok(logs.includes('Hello, World!'));
 });
 // [END functions_pubsub_system_test]
diff --git a/functions/helloworld/test/sample.system.storage.test.js b/functions/helloworld/test/sample.system.storage.test.js
index 180470fc75..484cf48ec4 100644
--- a/functions/helloworld/test/sample.system.storage.test.js
+++ b/functions/helloworld/test/sample.system.storage.test.js
@@ -14,23 +14,22 @@
  */
 
 // [START functions_storage_system_test]
-const {Storage} = require(`@google-cloud/storage`);
+const {Storage} = require('@google-cloud/storage');
 const storage = new Storage();
-const uuid = require(`uuid`);
-const test = require(`ava`);
-const path = require(`path`);
-const childProcess = require(`child_process`);
-const localFileName = `test.txt`;
+const uuid = require('uuid');
+const assert = require('assert');
+const path = require('path');
+const childProcess = require('child_process');
+const localFileName = 'test.txt';
 
 // Use unique GCS filename to avoid conflicts between concurrent test runs
 const gcsFileName = `test-${uuid.v4()}.txt`;
 
 const bucketName = process.env.FUNCTIONS_BUCKET;
 const bucket = storage.bucket(bucketName);
-const baseCmd = `gcloud functions`;
+const baseCmd = 'gcloud functions';
 
-test.serial(`helloGCS: should print uploaded message`, async t => {
-  t.plan(1);
+it('helloGCS: should print uploaded message', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Upload file
@@ -46,16 +45,15 @@ test.serial(`helloGCS: should print uploaded message`, async t => {
   const logs = childProcess
     .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`File ${gcsFileName} uploaded`));
+  assert.ok(logs.includes(`File ${gcsFileName} uploaded`));
 });
 
-test.serial(`helloGCS: should print metadata updated message`, async t => {
-  t.plan(1);
+it('helloGCS: should print metadata updated message', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Update file metadata
   const file = bucket.file(gcsFileName);
-  await file.setMetadata(gcsFileName, {foo: `bar`});
+  await file.setMetadata(gcsFileName, {foo: 'bar'});
 
   // Wait for consistency
   await new Promise(resolve => setTimeout(resolve, 15000));
@@ -64,11 +62,10 @@ test.serial(`helloGCS: should print metadata updated message`, async t => {
   const logs = childProcess
     .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`File ${gcsFileName} metadata updated`));
+  assert.strictEqual(logs.ok(`File ${gcsFileName} metadata updated`));
 });
 
-test.serial(`helloGCS: should print deleted message`, async t => {
-  t.plan(1);
+it('helloGCS: should print deleted message', async () => {
   const startTime = new Date(Date.now()).toISOString();
 
   // Delete file
@@ -81,6 +78,6 @@ test.serial(`helloGCS: should print deleted message`, async t => {
   const logs = childProcess
     .execSync(`${baseCmd} logs read helloGCS --start-time ${startTime}`)
     .toString();
-  t.true(logs.includes(`File ${gcsFileName} deleted`));
+  assert.ok(logs.includes(`File ${gcsFileName} deleted`));
 });
 // [END functions_storage_system_test]
diff --git a/functions/helloworld/test/sample.unit.http.test.js b/functions/helloworld/test/sample.unit.http.test.js
index 7727a6a208..845c907704 100644
--- a/functions/helloworld/test/sample.unit.http.test.js
+++ b/functions/helloworld/test/sample.unit.http.test.js
@@ -14,13 +14,13 @@
  */
 
 // [START functions_http_unit_test]
-const test = require(`ava`);
-const sinon = require(`sinon`);
-const uuid = require(`uuid`);
+const assert = require('assert');
+const sinon = require('sinon');
+const uuid = require('uuid');
 
-const helloHttp = require(`..`).helloHttp;
+const helloHttp = require('..').helloHttp;
 
-test(`helloHttp: should print a name`, t => {
+it('helloHttp: should print a name', () => {
   // Mock ExpressJS 'req' and 'res' parameters
   const name = uuid.v4();
   const req = {
@@ -34,11 +34,11 @@ test(`helloHttp: should print a name`, t => {
   helloHttp(req, res);
 
   // Verify behavior of tested function
-  t.true(res.send.calledOnce);
-  t.deepEqual(res.send.firstCall.args, [`Hello ${name}!`]);
+  assert.ok(res.send.calledOnce);
+  assert.deepStrictEqual(res.send.firstCall.args, [`Hello ${name}!`]);
 });
 
-test(`helloHttp: should print hello world`, t => {
+it('helloHttp: should print hello world', () => {
   // Mock ExpressJS 'req' and 'res' parameters
   const req = {
     body: {},
@@ -49,7 +49,7 @@ test(`helloHttp: should print hello world`, t => {
   helloHttp(req, res);
 
   // Verify behavior of tested function
-  t.true(res.send.calledOnce);
-  t.deepEqual(res.send.firstCall.args, [`Hello World!`]);
+  assert.ok(res.send.calledOnce);
+  assert.deepStrictEqual(res.send.firstCall.args, ['Hello World!']);
 });
 // [END functions_http_unit_test]
diff --git a/functions/helloworld/test/sample.unit.pubsub.test.js b/functions/helloworld/test/sample.unit.pubsub.test.js
index 14e06d2617..e412bbb933 100644
--- a/functions/helloworld/test/sample.unit.pubsub.test.js
+++ b/functions/helloworld/test/sample.unit.pubsub.test.js
@@ -14,34 +14,32 @@
  */
 
 // [START functions_pubsub_unit_test]
-const test = require(`ava`);
-const uuid = require(`uuid`);
-const sinon = require(`sinon`);
+const assert = require('assert');
+const uuid = require('uuid');
+const utils = require('@google-cloud/nodejs-repo-tools');
 
-const helloPubSub = require(`..`).helloPubSub;
-const consoleLog = sinon.stub(console, 'log');
+const helloPubSub = require('..').helloPubSub;
 
-test.cb(`helloPubSub: should print a name`, t => {
-  t.plan(1);
+beforeEach(utils.stubConsole);
+afterEach(utils.restoreConsole);
 
+it('helloPubSub: should print a name', done => {
   // Initialize mocks
   const name = uuid.v4();
   const event = {
     data: {
-      data: Buffer.from(name).toString(`base64`),
+      data: Buffer.from(name).toString('base64'),
     },
   };
 
   // Call tested function and verify its behavior
   helloPubSub(event, () => {
-    t.true(consoleLog.calledWith(`Hello, ${name}!`));
-    t.end();
+    assert.ok(console.log.calledWith(`Hello, ${name}!`));
+    done();
   });
 });
 
-test.cb(`helloPubSub: should print hello world`, t => {
-  t.plan(1);
-
+it('helloPubSub: should print hello world', done => {
   // Initialize mocks
   const event = {
     data: {},
@@ -49,8 +47,8 @@ test.cb(`helloPubSub: should print hello world`, t => {
 
   // Call tested function and verify its behavior
   helloPubSub(event, () => {
-    t.true(consoleLog.calledWith(`Hello, World!`));
-    t.end();
+    assert.ok(console.log.calledWith('Hello, World!'));
+    done();
   });
 });
 // [END functions_pubsub_unit_test]
diff --git a/functions/helloworld/test/sample.unit.storage.test.js b/functions/helloworld/test/sample.unit.storage.test.js
index 555937fc48..83c7f14467 100644
--- a/functions/helloworld/test/sample.unit.storage.test.js
+++ b/functions/helloworld/test/sample.unit.storage.test.js
@@ -14,16 +14,16 @@
  */
 
 // [START functions_storage_unit_test]
-const test = require(`ava`);
-const uuid = require(`uuid`);
-const sinon = require(`sinon`);
+const assert = require('assert');
+const uuid = require('uuid');
+const utils = require('@google-cloud/nodejs-repo-tools');
 
-const helloGCS = require(`..`).helloGCS;
-const consoleLog = sinon.stub(console, 'log');
+const helloGCS = require('..').helloGCS;
 
-test.cb(`helloGCS: should print uploaded message`, t => {
-  t.plan(1);
+beforeEach(utils.stubConsole);
+afterEach(utils.restoreConsole);
 
+it('helloGCS: should print uploaded message', done => {
   // Initialize mocks
   const filename = uuid.v4();
   const event = {
@@ -36,14 +36,12 @@ test.cb(`helloGCS: should print uploaded message`, t => {
 
   // Call tested function and verify its behavior
   helloGCS(event, () => {
-    t.true(consoleLog.calledWith(`File ${filename} uploaded.`));
-    t.end();
+    assert.ok(console.log.calledWith(`File ${filename} uploaded.`));
+    done();
   });
 });
 
-test.cb(`helloGCS: should print metadata updated message`, t => {
-  t.plan(1);
-
+it('helloGCS: should print metadata updated message', done => {
   // Initialize mocks
   const filename = uuid.v4();
   const event = {
@@ -56,14 +54,12 @@ test.cb(`helloGCS: should print metadata updated message`, t => {
 
   // Call tested function and verify its behavior
   helloGCS(event, () => {
-    t.true(consoleLog.calledWith(`File ${filename} metadata updated.`));
-    t.end();
+    assert.ok(console.log.calledWith(`File ${filename} metadata updated.`));
+    done();
   });
 });
 
-test.cb(`helloGCS: should print deleted message`, t => {
-  t.plan(1);
-
+it('helloGCS: should print deleted message', done => {
   // Initialize mocks
   const filename = uuid.v4();
   const event = {
@@ -76,8 +72,8 @@ test.cb(`helloGCS: should print deleted message`, t => {
 
   // Call tested function and verify its behavior
   helloGCS(event, () => {
-    t.true(consoleLog.calledWith(`File ${filename} deleted.`));
-    t.end();
+    assert.ok(console.log.calledWith(`File ${filename} deleted.`));
+    done();
   });
 });
 // [END functions_storage_unit_test]
diff --git a/functions/helloworld/test/shim.test.js b/functions/helloworld/test/shim.test.js
index c62d1d217d..4a671a4d07 100644
--- a/functions/helloworld/test/shim.test.js
+++ b/functions/helloworld/test/shim.test.js
@@ -13,15 +13,15 @@
  * limitations under the License.
  */
 
-const test = require(`ava`);
-const Supertest = require(`supertest`);
-const tools = require(`@google-cloud/nodejs-repo-tools`);
-const {PubSub} = require(`@google-cloud/pubsub`);
+const assert = require('assert');
+const Supertest = require('supertest');
+const tools = require('@google-cloud/nodejs-repo-tools');
+const {PubSub} = require('@google-cloud/pubsub');
 const pubsub = new PubSub();
-const {Storage} = require(`@google-cloud/storage`);
+const {Storage} = require('@google-cloud/storage');
 const storage = new Storage();
-const uuid = require(`uuid`);
-const path = require(`path`);
+const uuid = require('uuid');
+const path = require('path');
 
 const PORT = process.env.PORT || 3000;
 const supertest = Supertest(`http://localhost:${PORT}`);
@@ -29,8 +29,8 @@ const topicName = `gcf-shim-topic-${uuid.v4()}`;
 const subscriptionName = `gcf-shim-sub-${uuid.v4()}`;
 const bucketName = `gcf-shim-bucket-${uuid.v4()}`;
 
-const cmd = `node shim.js`;
-const cwd = path.join(__dirname, `..`);
+const cmd = 'node shim.js';
+const cwd = path.join(__dirname, '..');
 
 const bucket = storage.bucket(bucketName);
 let topic;
@@ -40,7 +40,7 @@ let subscription;
 const delay = ms => new Promise(resolve => setTimeout(resolve, ms));
 
 // Create test resources
-test.before(() => {
+before(() => {
   return bucket
     .create()
     .then(() => {
@@ -58,7 +58,7 @@ test.before(() => {
 });
 
 // Tear down test resources
-test.after.always(() => {
+after(() => {
   return bucket
     .deleteFiles({force: true})
     .then(subscription.delete())
@@ -73,16 +73,16 @@ test.after.always(() => {
     .catch(console.error);
 });
 
-test(`shim: should handle HTTP`, async t => {
+it('shim: should handle HTTP', async () => {
   const shim = tools.runAsync(`${cmd} http ${PORT}`, cwd);
   await delay(1000)
     .then(() => {
       // Send HTTP request
       return supertest
-        .get(`/helloGET`)
+        .get('/helloGET')
         .expect(200)
         .expect(response => {
-          t.is(response.text, 'Hello World!');
+          assert.strictEqual(response.text, 'Hello World!');
         });
     })
     .then(() => {
@@ -90,7 +90,7 @@ test(`shim: should handle HTTP`, async t => {
     }); // Stop shim
 });
 
-test(`shim: should handle PubSub`, async t => {
+it('shim: should handle PubSub', async () => {
   const name = uuid.v4();
   const publisher = topic.publisher();
   const shim = tools.runAsync(
@@ -106,11 +106,11 @@ test(`shim: should handle PubSub`, async t => {
       return shim;
     })
     .then(output => {
-      t.true(output.includes(`Hello, ${name}!`));
+      assert.ok(output.includes(`Hello, ${name}!`));
     });
 });
 
-test(`shim: should handle GCS`, async t => {
+it('shim: should handle GCS', async () => {
   const shim = tools.runAsync(
     `${cmd} storage helloGCS "${bucketName}" "${topicName}" "${subscriptionName}"`,
     cwd
@@ -119,12 +119,12 @@ test(`shim: should handle GCS`, async t => {
   // Upload file to bucket
   await delay(10000)
     .then(() => {
-      return bucket.upload(path.join(cwd, `test/test.txt`));
+      return bucket.upload(path.join(cwd, 'test/test.txt'));
     })
     .then(() => {
       return shim;
     })
     .then(output => {
-      t.true(output.includes(`File test.txt uploaded.`));
+      assert.ok(output.includes('File test.txt uploaded.'));
     });
 });