tone 15.2.0 → 15.2.2

package/Tone/source/buffer/ToneBufferSource.test.ts

@@ -115,97 +115,88 @@ describe("ToneBufferSource", () => {
 			player.dispose();
 		});
 
-		it("loops the audio", () => {
-			return Offline(() => {
+		it("loops the audio", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.loop = true;
 				player.toDestination();
 				player.start(0);
-			}, buffer.duration * 2).then((buff) => {
-				expect(buff.getRmsAtTime(0)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration * 0.5)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration * 1.5)).to.be.above(0);
-			});
+			}, buffer.duration * 2);
+			expect(buff.getRmsAtTime(0)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration * 0.5)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration * 1.5)).to.be.above(0);
 		});
 
-		it("loops the audio when loop is set after 'start'", () => {
-			return Offline(() => {
+		it("loops the audio when loop is set after 'start'", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.start(0);
 				player.loop = true;
 				player.toDestination();
-			}, buffer.duration * 2).then((buff) => {
-				expect(buff.getRmsAtTime(0)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration * 0.5)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration * 1.5)).to.be.above(0);
-			});
+			}, buffer.duration * 2);
+			expect(buff.getRmsAtTime(0)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration * 0.5)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration * 1.5)).to.be.above(0);
 		});
 
-		it("unloops the audio when loop is set after 'start'", () => {
-			return Offline(() => {
+		it("unloops the audio when loop is set after 'start'", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.loop = true;
 				player.start(0);
 				player.loop = false;
 				player.toDestination();
-			}, buffer.duration * 2).then((buff) => {
-				expect(buff.getRmsAtTime(0)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration * 0.5)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration)).to.be.closeTo(
-					0,
-					0.001
-				);
-				expect(buff.getRmsAtTime(buffer.duration * 1.5)).to.be.closeTo(
-					0,
-					0.001
-				);
-			});
+			}, buffer.duration * 2);
+			expect(buff.getRmsAtTime(0)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration * 0.5)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration)).to.be.closeTo(0, 0.001);
+			expect(buff.getRmsAtTime(buffer.duration * 1.5)).to.be.closeTo(
+				0,
+				0.001
+			);
 		});
 
-		it("loops the audio for the specific duration", () => {
+		it("loops the audio for the specific duration", async () => {
 			const playDur = buffer.duration * 1.5;
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.loop = true;
 				player.toDestination();
 				player.start(0, 0, playDur);
-			}, buffer.duration * 2).then((buff) => {
-				expect(buff.getRmsAtTime(0)).to.be.above(0);
-				expect(buff.getRmsAtTime(buffer.duration)).to.be.above(0);
-				expect(buff.getRmsAtTime(playDur - 0.01)).to.be.above(0);
-				expect(buff.getRmsAtTime(playDur + 0.01)).to.equal(0);
-			});
+			}, buffer.duration * 2);
+			expect(buff.getRmsAtTime(0)).to.be.above(0);
+			expect(buff.getRmsAtTime(buffer.duration)).to.be.above(0);
+			expect(buff.getRmsAtTime(playDur - 0.01)).to.be.above(0);
+			expect(buff.getRmsAtTime(playDur + 0.01)).to.equal(0);
 		});
 
-		it("starts at the loop start offset if looping", () => {
+		it("starts at the loop start offset if looping", async () => {
 			const offsetTime = 0.05;
 			const offsetSample =
 				buffer.toArray()[Math.floor(offsetTime * sampleRate)];
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.loop = true;
 				player.loopStart = offsetTime;
 				player.start(0);
-			}, 0.1).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.equal(offsetSample);
-			});
+			}, 0.1);
+			expect(buff.getValueAtTime(0)).to.equal(offsetSample);
 		});
 
-		it("the offset is modulo the loopDuration", () => {
+		it("the offset is modulo the loopDuration", async () => {
 			const testSample = buffer.toArray()[
 				Math.floor(0.051 * sampleRate)
 			] as number;
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.loop = true;
 				player.loopStart = 0;
 				player.loopEnd = 0.1;
 				player.start(0, 0.351);
-			}, 0.1).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.be.closeTo(testSample, 1e-4);
-			});
+			}, 0.1);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(testSample, 1e-4);
 		});
 	});
 
@@ -247,42 +238,39 @@ describe("ToneBufferSource", () => {
 			};
 		});
 
-		it("schedules the onended callback when offline", () => {
+		it("schedules the onended callback when offline", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0.2).stop(0.4);
 				player.onended = () => (wasInvoked = true);
-			}, 0.5).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.5);
+			expect(wasInvoked).to.equal(true);
 		});
 
-		it("invokes the onended callback when a looped buffer is scheduled to stop", () => {
+		it("invokes the onended callback when a looped buffer is scheduled to stop", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.loop = true;
 				player.start().stop(0.4);
 				player.onended = () => {
 					wasInvoked = true;
 				};
-			}, 0.5).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.5);
+			expect(wasInvoked).to.equal(true);
 		});
 
-		it("schedules the onended callback when the buffer is done without scheduling stop", () => {
+		it("schedules the onended callback when the buffer is done without scheduling stop", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0);
 				player.onended = () => {
 					wasInvoked = true;
 				};
-			}, buffer.duration * 1.1).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, buffer.duration * 1.1);
+			expect(wasInvoked).to.equal(true);
 		});
 	});
 
@@ -291,8 +279,8 @@ describe("ToneBufferSource", () => {
 			return buffer.load("./test/audio/sine.wav");
 		});
 
-		it("reports the right state when scheduled to stop", () => {
-			return Offline(() => {
+		it("reports the right state when scheduled to stop", async () => {
+			await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0.2).stop(0.4);
 
@@ -306,8 +294,8 @@ describe("ToneBufferSource", () => {
 			}, 0.5);
 		});
 
-		it("reports the right state when duration is passed into start method", () => {
-			return Offline(() => {
+		it("reports the right state when duration is passed into start method", async () => {
+			await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0, 0, 0.1);
 
@@ -327,8 +315,8 @@ describe("ToneBufferSource", () => {
 			return buffer.load("./test/audio/sine.wav");
 		});
 
-		it("can play for a specific duration", () => {
-			return Offline(() => {
+		it("can play for a specific duration", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0).stop(0.1);
 
@@ -337,158 +325,141 @@ describe("ToneBufferSource", () => {
 						expect(player.state).to.equal("stopped");
 					}
 				};
-			}, 0.4).then((rms) => {
-				expect(rms.getRmsAtTime(0)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.09)).to.be.gt(0);
-				// after stop is scheduled
-				expect(rms.getRmsAtTime(0.11)).to.equal(0);
-				expect(rms.getRmsAtTime(0.3)).to.equal(0);
-			});
+			}, 0.4);
+			expect(rms.getRmsAtTime(0)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.09)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.11)).to.equal(0);
+			expect(rms.getRmsAtTime(0.3)).to.equal(0);
 		});
 
-		it("can be scheduled to stop", () => {
-			return Offline(() => {
+		it("can be scheduled to stop", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0).stop(0.1);
-			}, 0.6).then((rms) => {
-				expect(rms.getRmsAtTime(0.01)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.08)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.11)).to.equal(0);
-			});
+			}, 0.6);
+			expect(rms.getRmsAtTime(0.01)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.08)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.11)).to.equal(0);
 		});
 
-		it("plays correctly when playbackRate is < 1", () => {
-			return Offline(() => {
+		it("plays correctly when playbackRate is < 1", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0);
 				player.playbackRate.value = 0.75;
-			}, buffer.duration * 1.3).then((rms) => {
-				expect(rms.getRmsAtTime(0.01)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.1)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.2)).to.be.gt(0);
-				expect(rms.getRmsAtTime(buffer.duration)).to.be.gt(0);
-			});
+			}, buffer.duration * 1.3);
+			expect(rms.getRmsAtTime(0.01)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.1)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.2)).to.be.gt(0);
+			expect(rms.getRmsAtTime(buffer.duration)).to.be.gt(0);
 		});
 
-		it("plays correctly when playbackRate is > 1", () => {
-			return Offline(() => {
+		it("plays correctly when playbackRate is > 1", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0);
 				player.playbackRate.value = 2;
-			}, buffer.duration).then((rms) => {
-				expect(rms.getRmsAtTime(0.03)).to.be.gt(0);
-				expect(rms.getRmsAtTime(buffer.duration * 0.45)).to.be.gt(0);
-				expect(rms.getRmsAtTime(buffer.duration * 0.5)).to.closeTo(
-					0,
-					0.01
-				);
-				expect(rms.getRmsAtTime(buffer.duration * 0.7)).to.closeTo(
-					0,
-					0.01
-				);
-			});
+			}, buffer.duration);
+			expect(rms.getRmsAtTime(0.03)).to.be.gt(0);
+			expect(rms.getRmsAtTime(buffer.duration * 0.45)).to.be.gt(0);
+			expect(rms.getRmsAtTime(buffer.duration * 0.5)).to.closeTo(0, 0.01);
+			expect(rms.getRmsAtTime(buffer.duration * 0.7)).to.closeTo(0, 0.01);
 		});
 
-		it("can play for a specific duration passed in the 'start' method", () => {
-			return Offline(() => {
+		it("can play for a specific duration passed in the 'start' method", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0, 0, 0.1);
 
-				return (time) => {
-					if (time > 0.1) {
+				return (time_1) => {
+					if (time_1 > 0.1) {
 						expect(player.state).to.equal("stopped");
 					}
 				};
-			}, 0.4).then((rms) => {
-				expect(rms.getRmsAtTime(0)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.09)).to.be.gt(0);
-				// after stop is scheduled
-				expect(rms.getRmsAtTime(0.11)).to.equal(0);
-				expect(rms.getRmsAtTime(0.3)).to.equal(0);
-			});
+			}, 0.4);
+			expect(rms.getRmsAtTime(0)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.09)).to.be.gt(0);
+			// after stop is scheduled
+			expect(rms.getRmsAtTime(0.11)).to.equal(0);
+			expect(rms.getRmsAtTime(0.3)).to.equal(0);
 		});
 
-		it("can start at an offset", () => {
+		it("can start at an offset", async () => {
 			const offsetTime = 0.1;
 			const offsetSample =
 				buffer.toArray()[Math.floor(offsetTime * sampleRate)];
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0, offsetTime);
-			}, 0.05).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.equal(offsetSample);
-			});
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.equal(offsetSample);
 		});
 
-		it("can end start ramp early", () => {
-			return Offline(() => {
+		it("can end start ramp early", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.fadeIn = 0.2;
 				player.toDestination();
 				player.start(0).stop(0.1);
-			}, 0.2).then((rms) => {
-				expect(rms.getRmsAtTime(0.0)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.05)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.09)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.1)).to.equal(0);
-				expect(rms.getRmsAtTime(0.15)).to.equal(0);
-			});
+			}, 0.2);
+			expect(rms.getRmsAtTime(0.0)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.05)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.09)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.1)).to.equal(0);
+			expect(rms.getRmsAtTime(0.15)).to.equal(0);
 		});
 
-		it("can end start ramp with a ramp", () => {
-			return Offline(() => {
+		it("can end start ramp with a ramp", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(onesBuffer);
 				player.fadeIn = 0.2;
 				player.fadeOut = 0.1;
 				player.loop = true;
 				player.toDestination();
 				player.start(0).stop(0.1);
-			}, 0.3).then((buff) => {
-				// fade in
-				expect(buff.getRmsAtTime(0.01)).to.be.gt(0);
-				expect(buff.getRmsAtTime(0.05)).to.be.gt(0);
-				// fade out
-				expect(buff.getRmsAtTime(0.1)).to.be.gt(0);
-				expect(buff.getRmsAtTime(0.15)).to.be.gt(0);
-				expect(buff.getRmsAtTime(0.19)).to.be.gt(0);
-				// end of ramp
-				expect(buff.getRmsAtTime(0.21)).to.equal(0);
-			});
-		});
-
-		it("can be scheduled to stop with a ramp", () => {
-			return Offline(() => {
+			}, 0.3);
+			// fade in
+			expect(buff.getRmsAtTime(0.01)).to.be.gt(0);
+			expect(buff.getRmsAtTime(0.05)).to.be.gt(0);
+			// fade out
+			expect(buff.getRmsAtTime(0.1)).to.be.gt(0);
+			expect(buff.getRmsAtTime(0.15)).to.be.gt(0);
+			expect(buff.getRmsAtTime(0.19)).to.be.gt(0);
+			// end of ramp
+			expect(buff.getRmsAtTime(0.21)).to.equal(0);
+		});
+
+		it("can be scheduled to stop with a ramp", async () => {
+			const rms = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.fadeOut = 0.05;
 				player.start(0).stop(0.1);
-			}, 0.6).then((rms) => {
-				expect(rms.getRmsAtTime(0.01)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.05)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.08)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.1)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.14)).to.be.gt(0);
-				expect(rms.getRmsAtTime(0.16)).to.equal(0);
-				expect(rms.getRmsAtTime(0.2)).to.equal(0);
-				expect(rms.getRmsAtTime(0.3)).to.equal(0);
-				expect(rms.getRmsAtTime(0.4)).to.equal(0);
-				expect(rms.getRmsAtTime(0.5)).to.equal(0);
-			});
-		});
-
-		it("fade is applied after the stop time", () => {
-			return Offline(() => {
+			}, 0.6);
+			expect(rms.getRmsAtTime(0.01)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.05)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.08)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.1)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.14)).to.be.gt(0);
+			expect(rms.getRmsAtTime(0.16)).to.equal(0);
+			expect(rms.getRmsAtTime(0.2)).to.equal(0);
+			expect(rms.getRmsAtTime(0.3)).to.equal(0);
+			expect(rms.getRmsAtTime(0.4)).to.equal(0);
+			expect(rms.getRmsAtTime(0.5)).to.equal(0);
+		});
+
+		it("fade is applied after the stop time", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(onesBuffer).toDestination();
 				player.fadeOut = 0.1;
 				player.start(0).stop(0.2);
-			}, 0.32).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.equal(1);
-				expect(buff.getValueAtTime(0.1)).to.equal(1);
-				expect(buff.getValueAtTime(0.2)).to.equal(1);
-				expect(buff.getValueAtTime(0.25)).to.be.closeTo(0.5, 0.01);
-				expect(buff.getValueAtTime(0.29)).to.be.closeTo(0.1, 0.01);
-				expect(buff.getValueAtTime(0.3)).to.be.closeTo(0, 0.01);
-				expect(buff.getValueAtTime(0.31)).to.equal(0);
-			});
+			}, 0.32);
+			expect(buff.getValueAtTime(0)).to.equal(1);
+			expect(buff.getValueAtTime(0.1)).to.equal(1);
+			expect(buff.getValueAtTime(0.2)).to.equal(1);
+			expect(buff.getValueAtTime(0.25)).to.be.closeTo(0.5, 0.01);
+			expect(buff.getValueAtTime(0.29)).to.be.closeTo(0.1, 0.01);
+			expect(buff.getValueAtTime(0.3)).to.be.closeTo(0, 0.01);
+			expect(buff.getValueAtTime(0.31)).to.equal(0);
 		});
 
 		it("can fade with an exponential curve", () => {
@@ -498,34 +469,32 @@ describe("ToneBufferSource", () => {
 			player.dispose();
 		});
 
-		it("fades in and out exponentially", () => {
-			return Offline(() => {
+		it("fades in and out exponentially", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(onesBuffer).toDestination();
 				player.curve = "exponential";
 				player.fadeIn = 0.1;
 				player.fadeOut = 0.1;
 				player.start(0).stop(0.4);
-			}, 0.51).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.equal(0);
-				expect(buff.getValueAtTime(0.05)).to.be.closeTo(0.93, 0.01);
-				expect(buff.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
-				expect(buff.getValueAtTime(0.4)).to.be.closeTo(1, 0.01);
-				expect(buff.getValueAtTime(0.45)).to.be.closeTo(0.06, 0.01);
-				expect(buff.getValueAtTime(0.5)).to.closeTo(0, 0.01);
-			});
+			}, 0.51);
+			expect(buff.getValueAtTime(0)).to.equal(0);
+			expect(buff.getValueAtTime(0.05)).to.be.closeTo(0.93, 0.01);
+			expect(buff.getValueAtTime(0.1)).to.be.closeTo(1, 0.01);
+			expect(buff.getValueAtTime(0.4)).to.be.closeTo(1, 0.01);
+			expect(buff.getValueAtTime(0.45)).to.be.closeTo(0.06, 0.01);
+			expect(buff.getValueAtTime(0.5)).to.closeTo(0, 0.01);
 		});
 
-		it("can be scheduled to start at a lower gain", () => {
-			return Offline(() => {
+		it("can be scheduled to start at a lower gain", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer).toDestination();
 				player.start(0, 0, undefined, 0.5);
-			}, 0.5).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.be.lte(0.5);
-				expect(buff.getValueAtTime(0.1)).to.be.lte(0.5);
-				expect(buff.getValueAtTime(0.2)).to.be.lte(0.5);
-				expect(buff.getValueAtTime(0.3)).to.be.lte(0.5);
-				expect(buff.getValueAtTime(0.4)).to.be.lte(0.5);
-			});
+			}, 0.5);
+			expect(buff.getValueAtTime(0)).to.be.lte(0.5);
+			expect(buff.getValueAtTime(0.1)).to.be.lte(0.5);
+			expect(buff.getValueAtTime(0.2)).to.be.lte(0.5);
+			expect(buff.getValueAtTime(0.3)).to.be.lte(0.5);
+			expect(buff.getValueAtTime(0.4)).to.be.lte(0.5);
 		});
 
 		it("cannot be started more than once", () => {
@@ -537,44 +506,40 @@ describe("ToneBufferSource", () => {
 			player.dispose();
 		});
 
-		it("stops playing if invoked with 'stop' at a sooner time", () => {
-			return Offline(() => {
+		it("stops playing if invoked with 'stop' at a sooner time", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.toDestination();
 				player.start(0).stop(0.1).stop(0.05);
-			}, 0.3).then((buff) => {
-				expect(buff.getTimeOfLastSound()).to.be.closeTo(0.05, 0.02);
-			});
+			}, 0.3);
+			expect(buff.getTimeOfLastSound()).to.be.closeTo(0.05, 0.02);
 		});
 
-		it("does not play if the stop time is at the start time", () => {
-			return Offline(() => {
+		it("does not play if the stop time is at the start time", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.toDestination();
 				player.start(0).stop(0);
-			}, 0.3).then((buff) => {
-				expect(buff.isSilent()).is.equal(true);
-			});
+			}, 0.3);
+			expect(buff.isSilent()).is.equal(true);
 		});
 
-		it("does not play if the stop time is at before start time", () => {
-			return Offline(() => {
+		it("does not play if the stop time is at before start time", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.toDestination();
 				player.start(0.1).stop(0);
-			}, 0.3).then((buff) => {
-				expect(buff.isSilent()).is.equal(true);
-			});
+			}, 0.3);
+			expect(buff.isSilent()).is.equal(true);
 		});
 
-		it("stops playing at the last scheduled stop time", () => {
-			return Offline(() => {
+		it("stops playing at the last scheduled stop time", async () => {
+			const buff = await Offline(() => {
 				const player = new ToneBufferSource(buffer);
 				player.toDestination();
 				player.start(0).stop(0.1).stop(0.2);
-			}, 0.3).then((buff) => {
-				expect(buff.getTimeOfLastSound()).to.be.closeTo(0.2, 0.02);
-			});
+			}, 0.3);
+			expect(buff.getTimeOfLastSound()).to.be.closeTo(0.2, 0.02);
 		});
 	});
 });