Use expect.js instead of expect in browser tests
https://bugs.webkit.org/show_bug.cgi?id=168492

Reviewed by Joseph Pecoraro.

Use expect.js (https://github.com/Automattic/expect.js) instead of expect (https://github.com/mjackson/expect).

* browser-tests/close-button-tests.js:
* browser-tests/component-base-tests.js:
* browser-tests/editable-text-tests.js:
* browser-tests/index.html:


git-svn-id: http://svn.webkit.org/repository/webkit/trunk@212533 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Websites/perf.webkit.org/ChangeLog b/Websites/perf.webkit.org/ChangeLog
index d3bd771..3b44552 100644
--- a/Websites/perf.webkit.org/ChangeLog
+++ b/Websites/perf.webkit.org/ChangeLog
@@ -1,5 +1,19 @@
 2017-02-16  Ryosuke Niwa  <rniwa@webkit.org>
 
+        Use expect.js instead of expect in browser tests
+        https://bugs.webkit.org/show_bug.cgi?id=168492
+
+        Reviewed by Joseph Pecoraro.
+
+        Use expect.js (https://github.com/Automattic/expect.js) instead of expect (https://github.com/mjackson/expect).
+
+        * browser-tests/close-button-tests.js:
+        * browser-tests/component-base-tests.js:
+        * browser-tests/editable-text-tests.js:
+        * browser-tests/index.html:
+
+2017-02-16  Ryosuke Niwa  <rniwa@webkit.org>
+
         Modernize and fix measurement-set tests
         https://bugs.webkit.org/show_bug.cgi?id=168484
 
diff --git a/Websites/perf.webkit.org/browser-tests/close-button-tests.js b/Websites/perf.webkit.org/browser-tests/close-button-tests.js
index 5793579..fda3ce9 100644
--- a/Websites/perf.webkit.org/browser-tests/close-button-tests.js
+++ b/Websites/perf.webkit.org/browser-tests/close-button-tests.js
@@ -14,11 +14,11 @@
             closeButton.listenToAction('activate', () => {
                 activateCount++;
             });
-            expect(activateCount).toBe(0);
+            expect(activateCount).to.be(0);
             closeButton.content().querySelector('a').click();
-            expect(activateCount).toBe(1);
+            expect(activateCount).to.be(1);
             closeButton.content().querySelector('a').click();
-            expect(activateCount).toBe(2);
+            expect(activateCount).to.be(2);
         });
     });
 
diff --git a/Websites/perf.webkit.org/browser-tests/component-base-tests.js b/Websites/perf.webkit.org/browser-tests/component-base-tests.js
index acc1f2b..86c03e2 100644
--- a/Websites/perf.webkit.org/browser-tests/component-base-tests.js
+++ b/Websites/perf.webkit.org/browser-tests/component-base-tests.js
@@ -21,7 +21,7 @@
     describe('constructor', () => {
         it('is a function', () => {
             return new BrowsingContext().importScript('components/base.js', 'ComponentBase').then((ComponentBase) => {
-                expect(ComponentBase).toBeA('function');
+                expect(ComponentBase).to.be.a('function');
             });
         });
 
@@ -35,15 +35,15 @@
                     }
                 }
                 let instance = new SomeComponent;
-                expect(instance).toBeA(ComponentBase);
-                expect(instance).toBeA(SomeComponent);
-                expect(callCount).toBe(1);
+                expect(instance).to.be.a(ComponentBase);
+                expect(instance).to.be.a(SomeComponent);
+                expect(callCount).to.be(1);
             });
         });
 
         it('must not create shadow tree eagerly', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
-                expect(hasShadowTree()).toBe(false);
+                expect(hasShadowTree()).to.be(false);
             });
         });
     });
@@ -54,7 +54,7 @@
             return context.importScript('components/base.js', 'ComponentBase').then((ComponentBase) => {
                 class SomeComponent extends ComponentBase { }
                 let instance = new SomeComponent('some-component');
-                expect(instance.element()).toBeA(context.global.HTMLElement);
+                expect(instance.element()).to.be.a(context.global.HTMLElement);
             });
         });
 
@@ -62,14 +62,14 @@
             return new BrowsingContext().importScript('components/base.js', 'ComponentBase').then((ComponentBase) => {
                 class SomeComponent extends ComponentBase { }
                 let instance = new SomeComponent('some-component');
-                expect(instance.element().component()).toBe(instance);
+                expect(instance.element().component()).to.be(instance);
             });
         });
 
         it('must not create shadow tree eagerly', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.element();
-                expect(hasShadowTree()).toBe(false);
+                expect(hasShadowTree()).to.be(false);
             });
         });
     });
@@ -78,13 +78,13 @@
         it('must create shadow tree', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.content();
-                expect(hasShadowTree()).toBe(true);
+                expect(hasShadowTree()).to.be(true);
             });
         });
 
         it('must return the same shadow tree each time it is called', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
-                expect(instance.content()).toBe(instance.content());
+                expect(instance.content()).to.be(instance.content());
             });
         });
 
@@ -97,9 +97,9 @@
 
                 const instance = new SomeComponent;
                 const part1 = instance.content('part1');
-                expect(part1.localName).toBe('div');
-                expect(part1.title).toBe('foo');
-                expect(instance.content('part2')).toBe(null);
+                expect(part1.localName).to.be('div');
+                expect(part1.title).to.be('foo');
+                expect(instance.content('part2')).to.be(null);
             });
         });
     });
@@ -108,7 +108,7 @@
         it('must create shadow tree', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.part('foo');
-                expect(hasShadowTree()).toBe(true);
+                expect(hasShadowTree()).to.be(true);
             });
         });
 
@@ -124,10 +124,10 @@
 
                 const otherComponent = new OtherComponent;
                 const someComponent = otherComponent.part('foo');
-                expect(someComponent).toBeA(SomeComponent);
-                expect(someComponent.element().id).toBe('foo');
-                expect(otherComponent.part('foo')).toBe(someComponent);
-                expect(otherComponent.part('bar')).toBe(null);
+                expect(someComponent).to.be.a(SomeComponent);
+                expect(someComponent.element().id).to.be('foo');
+                expect(otherComponent.part('foo')).to.be(someComponent);
+                expect(otherComponent.part('bar')).to.be(null);
             });
         });
     });
@@ -147,10 +147,10 @@
                 const object = {'foo': 1};
                 instance.dispatchAction('action', 'bar', object, 5);
 
-                expect(calls.length).toBe(1);
-                expect(calls[0][0]).toBe('bar');
-                expect(calls[0][1]).toBe(object);
-                expect(calls[0][2]).toBe(5);
+                expect(calls.length).to.be(1);
+                expect(calls[0][0]).to.be('bar');
+                expect(calls[0][1]).to.be(object);
+                expect(calls[0][2]).to.be(5);
             });
         });
 
@@ -178,10 +178,10 @@
                 ComponentBase.defineElement('some-component', SomeComponent);
 
                 (new SomeComponent).enqueueToRender();
-                expect(renderCallCount).toBe(0);
+                expect(renderCallCount).to.be(0);
 
                 (new SomeComponent).enqueueToRender();
-                expect(renderCallCount).toBe(0);
+                expect(renderCallCount).to.be(0);
             });
         });
 
@@ -194,21 +194,21 @@
                 const SomeComponent = class extends ComponentBase { }
                 ComponentBase.defineElement('some-component', SomeComponent);
 
-                expect(requestAnimationFrameCount).toBe(0);
+                expect(requestAnimationFrameCount).to.be(0);
                 let instance = new SomeComponent;
                 instance.enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
 
                 instance.enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
 
                 (new SomeComponent).enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
 
                 const AnotherComponent = class extends ComponentBase { }
                 ComponentBase.defineElement('another-component', AnotherComponent);
                 (new AnotherComponent).enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
             });
         });
 
@@ -217,8 +217,8 @@
             return context.importScripts(['instrumentation.js', 'components/base.js'], 'ComponentBase').then((ComponentBase) => {
                 let callback = null;
                 context.global.requestAnimationFrame = (newCallback) => {
-                    expect(callback).toBe(null);
-                    expect(newCallback).toNotBe(null);
+                    expect(callback).to.be(null);
+                    expect(newCallback).to.not.be(null);
                     callback = newCallback;
                 }
 
@@ -230,20 +230,20 @@
                 }
                 ComponentBase.defineElement('some-component', SomeComponent);
 
-                expect(renderCalls.length).toBe(0);
+                expect(renderCalls.length).to.be(0);
                 const instance = new SomeComponent;
                 instance.enqueueToRender();
                 instance.enqueueToRender();
 
                 const anotherInstance = new SomeComponent;
                 anotherInstance.enqueueToRender();
-                expect(renderCalls.length).toBe(0);
+                expect(renderCalls.length).to.be(0);
 
                 callback();
 
-                expect(renderCalls.length).toBe(2);
-                expect(renderCalls[0]).toBe(instance);
-                expect(renderCalls[1]).toBe(anotherInstance);
+                expect(renderCalls.length).to.be(2);
+                expect(renderCalls[0]).to.be(instance);
+                expect(renderCalls[1]).to.be(anotherInstance);
             });
         });
 
@@ -252,8 +252,8 @@
             return context.importScripts(['instrumentation.js', 'components/base.js'], 'ComponentBase').then((ComponentBase) => {
                 let callback = null;
                 context.global.requestAnimationFrame = (newCallback) => {
-                    expect(callback).toBe(null);
-                    expect(newCallback).toNotBe(null);
+                    expect(callback).to.be(null);
+                    expect(newCallback).to.not.be(null);
                     callback = newCallback;
                 }
 
@@ -269,26 +269,26 @@
                 }
                 ComponentBase.defineElement('some-component', SomeComponent);
 
-                expect(renderCalls.length).toBe(0);
+                expect(renderCalls.length).to.be(0);
                 const instance = new SomeComponent;
                 const anotherInstance = new SomeComponent;
                 instance.enqueueToRender();
                 instanceToEnqueue = anotherInstance;
                 callback();
                 callback = null;
-                expect(renderCalls.length).toBe(2);
-                expect(renderCalls[0]).toBe(instance);
-                expect(renderCalls[1]).toBe(anotherInstance);
+                expect(renderCalls.length).to.be(2);
+                expect(renderCalls[0]).to.be(instance);
+                expect(renderCalls[1]).to.be(anotherInstance);
                 renderCalls = [];
 
                 instance.enqueueToRender();
                 anotherInstance.enqueueToRender();
                 instanceToEnqueue = instance;
                 callback();
-                expect(renderCalls.length).toBe(3);
-                expect(renderCalls[0]).toBe(instance);
-                expect(renderCalls[1]).toBe(anotherInstance);
-                expect(renderCalls[2]).toBe(instance);
+                expect(renderCalls.length).to.be(3);
+                expect(renderCalls[0]).to.be(instance);
+                expect(renderCalls[1]).to.be(anotherInstance);
+                expect(renderCalls[2]).to.be(instance);
             });
         });
 
@@ -298,8 +298,8 @@
                 let requestAnimationFrameCount = 0;
                 let callback = null;
                 context.global.requestAnimationFrame = (newCallback) => {
-                    expect(callback).toBe(null);
-                    expect(newCallback).toNotBe(null);
+                    expect(callback).to.be(null);
+                    expect(newCallback).to.not.be(null);
                     callback = newCallback;
                     requestAnimationFrameCount++;
                 }
@@ -312,35 +312,35 @@
 
                 const instance = new SomeComponent;
                 const anotherInstance = new SomeComponent;
-                expect(requestAnimationFrameCount).toBe(0);
+                expect(requestAnimationFrameCount).to.be(0);
 
                 instance.enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
                 anotherInstance.enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
 
-                expect(renderCalls.length).toBe(0);
+                expect(renderCalls.length).to.be(0);
                 callback();
                 callback = null;
-                expect(renderCalls.length).toBe(2);
-                expect(renderCalls[0]).toBe(instance);
-                expect(renderCalls[1]).toBe(anotherInstance);
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(renderCalls.length).to.be(2);
+                expect(renderCalls[0]).to.be(instance);
+                expect(renderCalls[1]).to.be(anotherInstance);
+                expect(requestAnimationFrameCount).to.be(1);
 
                 anotherInstance.enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(2);
+                expect(requestAnimationFrameCount).to.be(2);
                 instance.enqueueToRender();
-                expect(requestAnimationFrameCount).toBe(2);
+                expect(requestAnimationFrameCount).to.be(2);
 
-                expect(renderCalls.length).toBe(2);
+                expect(renderCalls.length).to.be(2);
                 callback();
                 callback = null;
-                expect(renderCalls.length).toBe(4);
-                expect(renderCalls[0]).toBe(instance);
-                expect(renderCalls[1]).toBe(anotherInstance);
-                expect(renderCalls[2]).toBe(anotherInstance);
-                expect(renderCalls[3]).toBe(instance);
-                expect(requestAnimationFrameCount).toBe(2);
+                expect(renderCalls.length).to.be(4);
+                expect(renderCalls[0]).to.be(instance);
+                expect(renderCalls[1]).to.be(anotherInstance);
+                expect(renderCalls[2]).to.be(anotherInstance);
+                expect(renderCalls[3]).to.be(instance);
+                expect(requestAnimationFrameCount).to.be(2);
             });
         });
 
@@ -350,28 +350,28 @@
         it('must create shadow tree', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.render();
-                expect(hasShadowTree()).toBe(true);
+                expect(hasShadowTree()).to.be(true);
             });
         });
 
         it('must not create shadow tree when neither htmlTemplate nor cssTemplate are present', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.render();
-                expect(hasShadowTree()).toBe(false);
+                expect(hasShadowTree()).to.be(false);
             }, {htmlTemplate: false, cssTemplate: false});
         });
 
         it('must create shadow tree when htmlTemplate is present and cssTemplate is not', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.render();
-                expect(hasShadowTree()).toBe(true);
+                expect(hasShadowTree()).to.be(true);
             }, {htmlTemplate: true, cssTemplate: false});
         });
 
         it('must create shadow tree when cssTemplate is present and htmlTemplate is not', () => {
             return createTestToCheckExistenceOfShadowTree((instance, hasShadowTree) => {
                 instance.render();
-                expect(hasShadowTree()).toBe(true);
+                expect(hasShadowTree()).to.be(true);
             }, {htmlTemplate: false, cssTemplate: true});
         });
 
@@ -384,7 +384,7 @@
                 class SomeComponent extends ComponentBase {
                     didConstructShadowTree()
                     {
-                        expect(this.content()).toBeA(context.global.ShadowRoot);
+                        expect(this.content()).to.be.a(context.global.ShadowRoot);
                         didConstructShadowTreeCount++;
                     }
 
@@ -397,11 +397,11 @@
                 ComponentBase.defineElement('some-component', SomeComponent);
 
                 const instance = new SomeComponent;
-                expect(didConstructShadowTreeCount).toBe(0);
-                expect(htmlTemplateCount).toBe(0);
+                expect(didConstructShadowTreeCount).to.be(0);
+                expect(htmlTemplateCount).to.be(0);
                 instance.render();
-                expect(didConstructShadowTreeCount).toBe(1);
-                expect(htmlTemplateCount).toBe(1);
+                expect(didConstructShadowTreeCount).to.be(1);
+                expect(htmlTemplateCount).to.be(1);
             });
         });
     });
@@ -415,8 +415,8 @@
                 ComponentBase.defineElement('some-component', SomeComponent);
 
                 let elementClass = context.global.customElements.get('some-component');
-                expect(elementClass).toBeA('function');
-                expect(elementClass.name).toBe('SomeComponentElement');
+                expect(elementClass).to.be.a('function');
+                expect(elementClass.name).to.be('SomeComponentElement');
             });
         });
 
@@ -432,14 +432,14 @@
                 }
                 ComponentBase.defineElement('some-component', SomeComponent);
 
-                expect(instances.length).toBe(0);
+                expect(instances.length).to.be(0);
                 let element = context.document.createElement('some-component');
-                expect(instances.length).toBe(1);
+                expect(instances.length).to.be(1);
 
-                expect(element).toBeA(context.global.HTMLElement);
-                expect(element.component()).toBe(instances[0]);
-                expect(instances[0].element()).toBe(element);
-                expect(instances.length).toBe(1);
+                expect(element).to.be.a(context.global.HTMLElement);
+                expect(element.component()).to.be(instances[0]);
+                expect(instances[0].element()).to.be(element);
+                expect(instances.length).to.be(1);
             });
         });
 
@@ -455,14 +455,14 @@
                 }
                 ComponentBase.defineElement('some-component', SomeComponent);
 
-                expect(instances.length).toBe(0);
+                expect(instances.length).to.be(0);
                 let component = new SomeComponent;
-                expect(instances.length).toBe(1);
+                expect(instances.length).to.be(1);
 
-                expect(component).toBe(instances[0]);
-                expect(component.element()).toBeA(context.global.HTMLElement);
-                expect(component.element().component()).toBe(component);
-                expect(instances.length).toBe(1);
+                expect(component).to.be(instances[0]);
+                expect(component.element()).to.be.a(context.global.HTMLElement);
+                expect(component.element().component()).to.be(component);
+                expect(instances.length).to.be(1);
             });
         });
 
@@ -481,12 +481,12 @@
                     requestAnimationFrameCount++;
                 }
 
-                expect(requestAnimationFrameCount).toBe(0);
+                expect(requestAnimationFrameCount).to.be(0);
                 const instance = new SomeComponent;
                 context.global.dispatchEvent(new Event('resize'));
                 context.document.body.appendChild(instance.element());
                 context.global.dispatchEvent(new Event('resize'));
-                expect(requestAnimationFrameCount).toBe(1);
+                expect(requestAnimationFrameCount).to.be(1);
             });
         });
 
@@ -506,9 +506,9 @@
                 }
 
                 const instance = new SomeComponent;
-                expect(requestAnimationFrameCount).toBe(0);
+                expect(requestAnimationFrameCount).to.be(0);
                 context.global.dispatchEvent(new Event('resize'));
-                expect(requestAnimationFrameCount).toBe(0);
+                expect(requestAnimationFrameCount).to.be(0);
             });
         });
 
diff --git a/Websites/perf.webkit.org/browser-tests/editable-text-tests.js b/Websites/perf.webkit.org/browser-tests/editable-text-tests.js
index 0cdf8f8..98c0588 100644
--- a/Websites/perf.webkit.org/browser-tests/editable-text-tests.js
+++ b/Websites/perf.webkit.org/browser-tests/editable-text-tests.js
@@ -31,14 +31,14 @@
             editableText = new EditableText;
             context.document.body.appendChild(editableText.element());
             editableText.enqueueToRender();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content().textContent).toNotInclude('hello');
+            expect(editableText.content().textContent).to.not.contain('hello');
             editableText.setText('hello');
             editableText.enqueueToRender();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content().textContent).toInclude('hello');
+            expect(editableText.content().textContent).to.contain('hello');
         });
     });
 
@@ -51,18 +51,18 @@
             context.document.body.appendChild(editableText.element());
             editableText.setText('hello');
             editableText.enqueueToRender();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content().querySelector('input').offsetHeight).toBe(0);
-            expect(editableText.content().textContent).toInclude('hello');
-            expect(editableText.content().querySelector('a').textContent).toInclude('Edit');
-            expect(editableText.content().querySelector('a').textContent).toNotInclude('Save');
+            expect(editableText.content().querySelector('input').offsetHeight).to.be(0);
+            expect(editableText.content().textContent).to.contain('hello');
+            expect(editableText.content().querySelector('a').textContent).to.contain('Edit');
+            expect(editableText.content().querySelector('a').textContent).to.not.contain('Save');
             editableText.content().querySelector('a').click();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content().querySelector('input').offsetHeight).toNotBe(0);
-            expect(editableText.content().querySelector('a').textContent).toNotInclude('Edit');
-            expect(editableText.content().querySelector('a').textContent).toInclude('Save');
+            expect(editableText.content().querySelector('input').offsetHeight).to.not.be(0);
+            expect(editableText.content().querySelector('a').textContent).to.not.contain('Edit');
+            expect(editableText.content().querySelector('a').textContent).to.contain('Save');
         });
     });
 
@@ -77,21 +77,21 @@
             editableText.setText('hello');
             editableText.enqueueToRender();
             editableText.listenToAction('update', () => updateCount++);
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             editableText.content().querySelector('a').click();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             const input = editableText.content().querySelector('input');
-            expect(input.offsetHeight).toNotBe(0);
-            expect(editableText.editedText()).toBe('hello');
+            expect(input.offsetHeight).to.not.be(0);
+            expect(editableText.editedText()).to.be('hello');
             input.value = 'world';
-            expect(editableText.editedText()).toBe('world');
-            expect(updateCount).toBe(0);
+            expect(editableText.editedText()).to.be('world');
+            expect(updateCount).to.be(0);
             editableText.content().querySelector('a').click();
-            expect(updateCount).toBe(1);
-            expect(editableText.editedText()).toBe('world');
-            expect(editableText.text()).toBe('hello');
+            expect(updateCount).to.be(1);
+            expect(editableText.editedText()).to.be('world');
+            expect(editableText.text()).to.be('hello');
         });
     });
 
@@ -106,27 +106,27 @@
             editableText.setText('hello');
             editableText.enqueueToRender();
             editableText.listenToAction('update', () => updateCount++);
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             editableText.content().querySelector('a').click();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             const input = editableText.content().querySelector('input');
-            expect(input.offsetHeight).toNotBe(0);
-            expect(editableText.editedText()).toBe('hello');
+            expect(input.offsetHeight).to.not.be(0);
+            expect(editableText.editedText()).to.be('hello');
             input.value = 'world';
-            expect(updateCount).toBe(0);
+            expect(updateCount).to.be(0);
 
             const focusableElement = document.createElement('div');
             focusableElement.setAttribute('tabindex', 0);
             document.body.appendChild(focusableElement);
             focusableElement.focus();
 
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content().querySelector('input').offsetHeight).toBe(0);
-            expect(editableText.text()).toBe('hello');
-            expect(updateCount).toBe(0);
+            expect(editableText.content().querySelector('input').offsetHeight).to.be(0);
+            expect(editableText.text()).to.be('hello');
+            expect(updateCount).to.be(0);
         });
     });
 
@@ -141,23 +141,23 @@
             editableText.setText('hello');
             editableText.enqueueToRender();
             editableText.listenToAction('update', () => updateCount++);
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             editableText.content().querySelector('a').click();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             const input = editableText.content().querySelector('input');
-            expect(input.offsetHeight).toNotBe(0);
-            expect(editableText.editedText()).toBe('hello');
+            expect(input.offsetHeight).to.not.be(0);
+            expect(editableText.editedText()).to.be('hello');
             input.value = 'world';
-            expect(updateCount).toBe(0);
+            expect(updateCount).to.be(0);
             editableText.content().querySelector('a').focus();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content().querySelector('input').offsetHeight).toNotBe(0);
+            expect(editableText.content().querySelector('input').offsetHeight).to.not.be(0);
             editableText.content().querySelector('a').click();
-            expect(editableText.editedText()).toBe('world');
-            expect(updateCount).toBe(1);
+            expect(editableText.editedText()).to.be('world');
+            expect(updateCount).to.be(1);
         });
     });
 
@@ -172,28 +172,28 @@
             editableText.setText('hello');
             editableText.enqueueToRender();
             editableText.listenToAction('update', () => updateCount++);
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             editableText.content('action-button').click();
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
             const input = editableText.content('text-field');
-            expect(input.offsetHeight).toNotBe(0);
-            expect(editableText.editedText()).toBe('hello');
+            expect(input.offsetHeight).to.not.be(0);
+            expect(editableText.editedText()).to.be('hello');
             input.value = 'world';
-            expect(updateCount).toBe(0);
-            return waitToRender(context);
+            expect(updateCount).to.be(0);
+            return waitForComponentsToRender(context);
         }).then(() => {
             editableText.content('action-button').dispatchEvent(new MouseEvent('mousedown'));
             return new Promise((resolve) => setTimeout(resolve, 0));
         }).then(() => {
             editableText.content('text-field').blur();
             editableText.content('action-button').dispatchEvent(new MouseEvent('mouseup'));
-            return waitToRender(context);
+            return waitForComponentsToRender(context);
         }).then(() => {
-            expect(editableText.content('text-field').offsetHeight).toBe(0);
-            expect(updateCount).toBe(1);
-            expect(editableText.editedText()).toBe('world');
+            expect(editableText.content('text-field').offsetHeight).to.be(0);
+            expect(updateCount).to.be(1);
+            expect(editableText.editedText()).to.be('world');
         });
     });
 
diff --git a/Websites/perf.webkit.org/browser-tests/index.html b/Websites/perf.webkit.org/browser-tests/index.html
index c808d46..803ad38 100644
--- a/Websites/perf.webkit.org/browser-tests/index.html
+++ b/Websites/perf.webkit.org/browser-tests/index.html
@@ -4,7 +4,7 @@
 <title>In-Browser Tests for Performance Dashboard</title>
 <link rel="stylesheet" href="https://cdn.rawgit.com/mochajs/mocha/2.2.5/mocha.css">
 <script src="https://cdnjs.cloudflare.com/ajax/libs/mocha/2.2.5/mocha.js"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/expect/1.20.2/expect.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/expect.js/0.2.0/expect.min.js"></script>
 <script>
 
 mocha.setup('bdd');