tone 15.2.0 → 15.2.2

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

@@ -62,9 +62,9 @@ describe("Player", () => {
 	});
 
 	context("onstop", () => {
-		it("invokes the onstop method when the player is explicitly stopped", () => {
+		it("invokes the onstop method when the player is explicitly stopped", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const player = new Player({
 					onstop: () => {
 						wasInvoked = true;
@@ -72,36 +72,33 @@ describe("Player", () => {
 					url: buffer,
 				});
 				player.start(0).stop(0.1);
-			}, 0.2).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, 0.2);
+			expect(wasInvoked).to.equal(true);
 		});
 
-		it("invokes the onstop method when the file is naturally over", () => {
+		it("invokes the onstop method when the file is naturally over", async () => {
 			let wasInvoked = false;
-			return Offline(() => {
+			await Offline(() => {
 				const player = new Player(buffer);
 				player.start(0);
 				player.onstop = () => {
 					wasInvoked = true;
 					expect(player.state).to.equal("stopped");
 				};
-			}, buffer.duration * 1.1).then(() => {
-				expect(wasInvoked).to.equal(true);
-			});
+			}, buffer.duration * 1.1);
+			expect(wasInvoked).to.equal(true);
 		});
 
-		it("invokes the onstop method on restart", () => {
+		it("invokes the onstop method on restart", async () => {
 			let wasInvoked = 0;
-			return Offline(() => {
+			await Offline(() => {
 				const player = new Player(buffer);
 				player.start(0).restart(0.1).stop(0.2);
 				player.onstop = () => {
 					wasInvoked++;
 				};
-			}, 0.3).then(() => {
-				expect(wasInvoked).to.equal(2);
-			});
+			}, 0.3);
+			expect(wasInvoked).to.equal(2);
 		});
 	});
 
@@ -114,11 +111,10 @@ describe("Player", () => {
 			});
 		});
 
-		it("loads a url using the load method", () => {
+		it("loads a url using the load method", async () => {
 			const player = new Player();
-			return player.load("./test/audio/sine.wav").then(() => {
-				expect(player.buffer).to.be.instanceof(ToneAudioBuffer);
-			});
+			await player.load("./test/audio/sine.wav");
+			expect(player.buffer).to.be.instanceof(ToneAudioBuffer);
 		});
 
 		it("can be created with an options object", () => {
@@ -162,23 +158,22 @@ describe("Player", () => {
 			player.dispose();
 		});
 
-		it("can be played in reverse", () => {
+		it("can be played in reverse", async () => {
 			const shorterBuffer = buffer.slice(0, buffer.duration / 2);
 			const audioBuffer = (
 				shorterBuffer.get() as AudioBuffer
 			).getChannelData(0);
 			const lastSample = audioBuffer[audioBuffer.length - 1];
 			expect(lastSample).to.not.equal(0);
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new Player({
 					reverse: true,
 					url: shorterBuffer.get(),
 				}).toDestination();
 				player.start(0);
-			}).then((buff) => {
-				const firstSample = buff.toArray()[0][0];
-				expect(firstSample).to.equal(lastSample);
 			});
+			const firstSample = buff.toArray()[0][0];
+			expect(firstSample).to.equal(lastSample);
 		});
 	});
 
@@ -206,84 +201,79 @@ describe("Player", () => {
 			player.dispose();
 		});
 
-		it("loops the audio", () => {
-			return Offline(() => {
+		it("loops the audio", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.loop = true;
 				player.toDestination();
 				player.start(0);
-			}, buffer.duration * 1.5).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.2)).to.be.above(0);
-			});
+			}, buffer.duration * 1.5);
+			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.2)).to.be.above(0);
 		});
 
-		it("setting the loop multiple times has no affect", () => {
-			return Offline(() => {
+		it("setting the loop multiple times has no affect", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.loop = true;
 				player.loop = true;
 				player.toDestination();
 				player.start(0);
-			}, buffer.duration * 1.5).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.2)).to.be.above(0);
-			});
+			}, buffer.duration * 1.5);
+			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.2)).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 Player(buffer);
 				player.toDestination();
 				player.start(0);
 				player.loop = true;
-			}, buffer.duration * 1.5).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.2)).to.be.above(0);
-			});
+			}, buffer.duration * 1.5);
+			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.2)).to.be.above(0);
 		});
 
-		it("offset is the loopStart when set to loop", () => {
+		it("offset is the loopStart when set to loop", async () => {
 			const testSample =
 				buffer.toArray(0)[Math.floor(0.1 * getContext().sampleRate)];
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.loopStart = 0.1;
 				player.loop = true;
 				player.toDestination();
 				player.start(0);
-			}, 0.05).then((buff) => {
-				expect(buff.toArray()[0][0]).to.equal(testSample);
-			});
+			}, 0.05);
+			expect(buff.toArray()[0][0]).to.equal(testSample);
 		});
 
-		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 Player(buffer);
 				player.loop = true;
 				player.toDestination();
 				player.start(0, 0, playDur);
-			}, buffer.duration * 2).then((buff) => {
-				for (let time = 0; time < buffer.duration * 2; time += 0.1) {
-					const val = buff.getRmsAtTime(time);
-					if (time < playDur - 0.01) {
-						expect(val).to.be.greaterThan(0);
-					} else if (time > playDur) {
-						expect(val).to.equal(0);
-					}
+			}, buffer.duration * 2);
+			for (let time = 0; time < buffer.duration * 2; time += 0.1) {
+				const val = buff.getRmsAtTime(time);
+				if (time < playDur - 0.01) {
+					expect(val).to.be.greaterThan(0);
+				} else if (time > playDur) {
+					expect(val).to.equal(0);
 				}
-			});
+			}
 		});
 
-		it("correctly compensates if the offset is greater than the loopEnd", () => {
-			return Offline(() => {
+		it("correctly compensates if the offset is greater than the loopEnd", async () => {
+			const buff = await Offline(() => {
 				// make a ramp between 0-1
 				const ramp = new Float32Array(
 					Math.floor(getContext().sampleRate * 0.3)
@@ -291,20 +281,19 @@ describe("Player", () => {
 				for (let i = 0; i < ramp.length; i++) {
 					ramp[i] = (i / ramp.length) * 0.3;
 				}
-				const buff = ToneAudioBuffer.fromArray(ramp);
-				const player = new Player(buff).toDestination();
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
 				player.loopStart = 0.1;
 				player.loopEnd = 0.2;
 				player.loop = true;
 				player.start(0, 0.35);
-			}, 0.05).then((buff) => {
-				buff.forEach((sample, time) => {
-					if (time < 0.04) {
-						expect(sample).to.be.within(0.15, 0.2);
-					} else if (time > 0.05 && time < 0.09) {
-						expect(sample).to.be.within(0.1, 0.15);
-					}
-				});
+			}, 0.05);
+			buff.forEach((sample, time) => {
+				if (time < 0.04) {
+					expect(sample).to.be.within(0.15, 0.2);
+				} else if (time > 0.05 && time < 0.09) {
+					expect(sample).to.be.within(0.1, 0.15);
+				}
 			});
 		});
 	});
@@ -401,20 +390,19 @@ describe("Player", () => {
 	});
 
 	context("Start Scheduling", () => {
-		it("can be start with an offset", () => {
+		it("can be start with an offset", async () => {
 			const testSample =
 				buffer.toArray(0)[Math.floor(0.1 * getContext().sampleRate)];
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer.get());
 				player.toDestination();
 				player.start(0, 0.1);
-			}).then((buff) => {
-				expect(buff.toArray()[0][0]).to.equal(testSample);
 			});
+			expect(buff.toArray()[0][0]).to.equal(testSample);
 		});
 
-		it("is stopped and restarted when start is called twice", () => {
-			return Offline(() => {
+		it("is stopped and restarted when start is called twice", async () => {
+			const buff = await Offline(() => {
 				// make a ramp between 0-1
 				const ramp = new Float32Array(
 					Math.floor(getContext().sampleRate * 0.3)
@@ -422,83 +410,78 @@ describe("Player", () => {
 				for (let i = 0; i < ramp.length; i++) {
 					ramp[i] = i / (ramp.length - 1);
 				}
-				const buff = new ToneAudioBuffer().fromArray(ramp);
-				const player = new Player(buff).toDestination();
+				const playerBuff = new ToneAudioBuffer().fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
 				player.start(0);
 				player.start(0.1);
-			}, 0.31).then((buff) => {
-				expect(buff.max()).to.be.lessThan(1);
-			});
+			}, 0.31);
+			expect(buff.max()).to.be.lessThan(1);
 		});
 
-		it("only seeks if player is started", () => {
-			return Offline(() => {
+		it("only seeks if player is started", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer).toDestination();
 				player.seek(0.2, 0.01);
-			}, 0.05).then((buff) => {
-				expect(buff.isSilent()).to.be.true;
-			});
+			}, 0.05);
+			expect(buff.isSilent()).to.be.true;
 		});
 
-		it("can seek to a position at the given time", () => {
-			return Offline(() => {
+		it("can seek to a position at the given time", async () => {
+			const buff = await Offline(() => {
 				const ramp = new Float32Array(
 					Math.floor(getContext().sampleRate * 0.3)
 				);
 				for (let i = 0; i < ramp.length; i++) {
 					ramp[i] = (i / ramp.length) * 0.3;
 				}
-				const buff = new ToneAudioBuffer().fromArray(ramp);
-				const player = new Player(buff).toDestination();
+				const playerBuff = new ToneAudioBuffer().fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
 				player.start(0);
 				player.seek(0.2, 0.1);
-			}, 0.3).then((buff) => {
-				buff.forEach((sample, time) => {
-					if (time < 0.09) {
-						expect(sample).to.be.within(0, 0.1);
-					} else if (time > 0.1 && time < 0.19) {
-						expect(sample).to.be.within(0.2, 0.3);
-					}
-				});
+			}, 0.3);
+			buff.forEach((sample, time) => {
+				if (time < 0.09) {
+					expect(sample).to.be.within(0, 0.1);
+				} else if (time > 0.1 && time < 0.19) {
+					expect(sample).to.be.within(0.2, 0.3);
+				}
 			});
 		});
 
-		it("can be play for a specific duration", () => {
-			return Offline(() => {
+		it("can be play for a specific duration", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.toDestination();
 				player.start(0).stop(0.1);
-				return (time) => {
-					whenBetween(time, 0.1, Infinity, () => {
+				return (time_2) => {
+					whenBetween(time_2, 0.1, Infinity, () => {
 						expect(player.state).to.equal("stopped");
 					});
-					whenBetween(time, 0, 0.1, () => {
+					whenBetween(time_2, 0, 0.1, () => {
 						expect(player.state).to.equal("started");
 					});
 				};
-			}, 0.3).then((buff) => {
-				buff.forEachBetween(
-					(sample) => {
-						expect(sample).to.equal(0);
-					},
-					0.11,
-					0.15
-				);
-			});
+			}, 0.3);
+			buff.forEachBetween(
+				(sample) => {
+					expect(sample).to.equal(0);
+				},
+				0.11,
+				0.15
+			);
 		});
 
-		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 Player(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("stops playing if at the last scheduled 'stop' time", () => {
-			return Offline(() => {
+		it("stops playing if at the last scheduled 'stop' time", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.toDestination();
 				player
@@ -506,24 +489,22 @@ describe("Player", () => {
 					.start(0.1, 0, 0.05)
 					.start(0.2, 0, 0.05);
 				player.stop(0.1);
-			}, 0.3).then((buff) => {
-				expect(buff.getTimeOfLastSound()).to.be.closeTo(0.1, 0.02);
-			});
+			}, 0.3);
+			expect(buff.getTimeOfLastSound()).to.be.closeTo(0.1, 0.02);
 		});
 
-		it("can retrigger multiple sources which all stop at the stop time", () => {
-			return Offline(() => {
+		it("can retrigger multiple sources which all stop at the stop time", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.toDestination();
 				player.loop = true;
 				player.start(0).start(0.1).start(0.2).stop(0.25);
-			}, 0.4).then((buff) => {
-				expect(buff.getTimeOfLastSound()).to.be.closeTo(0.25, 0.02);
-			});
+			}, 0.4);
+			expect(buff.getTimeOfLastSound()).to.be.closeTo(0.25, 0.02);
 		});
 
-		it("can be play for a specific duration passed in the 'start' method", () => {
-			return Offline(() => {
+		it("can be play for a specific duration passed in the 'start' method", async () => {
+			const buff = await Offline(() => {
 				const player = new Player(buffer);
 				player.toDestination();
 				player.start(0, 0, 0.1);
@@ -535,9 +516,8 @@ describe("Player", () => {
 						expect(player.state).to.equal("started");
 					});
 				};
-			}, 0.3).then((buff) => {
-				expect(buff.getTimeOfLastSound()).to.be.closeTo(0.1, 0.02);
-			});
+			}, 0.3);
+			expect(buff.getTimeOfLastSound()).to.be.closeTo(0.1, 0.02);
 		});
 
 		it("reports itself as stopped after a single iterations of the buffer", () => {
@@ -556,16 +536,15 @@ describe("Player", () => {
 			}, buffer.duration * 1.1);
 		});
 
-		it("plays synced to the Transport", () => {
-			return Offline(({ transport }) => {
+		it("plays synced to the Transport", async () => {
+			const buff = await Offline(({ transport }) => {
 				const player = new Player(buffer)
 					.sync()
 					.start(0)
 					.toDestination();
 				transport.start(0);
-			}, 0.05).then((buff) => {
-				expect(buff.isSilent()).to.be.false;
-			});
+			}, 0.05);
+			expect(buff.isSilent()).to.be.false;
 		});
 
 		it("does not play twice when the offset is very small", () => {
@@ -584,24 +563,23 @@ describe("Player", () => {
 			);
 		});
 
-		it("offsets correctly when started by the Transport", () => {
+		it("offsets correctly when started by the Transport", async () => {
 			const testSample =
 				buffer.toArray(0)[
 					Math.floor(0.13125 * getContext().sampleRate)
 				];
-			return Offline(({ transport }) => {
+			const buff = await Offline(({ transport }) => {
 				const player = new Player(buffer)
 					.sync()
 					.start(0, 0.1)
 					.toDestination();
 				transport.start(0, 0.03125);
-			}, 0.05).then((buff) => {
-				expect(buff.toArray()[0][0]).to.equal(testSample);
-			});
+			}, 0.05);
+			expect(buff.toArray()[0][0]).to.equal(testSample);
 		});
 
-		it("starts at the correct position when Transport is offset and playbackRate is not 1", () => {
-			return Offline(({ transport }) => {
+		it("starts at the correct position when Transport is offset and playbackRate is not 1", async () => {
+			const buff = await Offline(({ transport }) => {
 				// make a ramp between 0-1
 				const ramp = new Float32Array(
 					Math.floor(getContext().sampleRate * 0.3)
@@ -609,67 +587,64 @@ describe("Player", () => {
 				for (let i = 0; i < ramp.length; i++) {
 					ramp[i] = i / ramp.length;
 				}
-				const buff = ToneAudioBuffer.fromArray(ramp);
-				const player = new Player(buff).toDestination();
+				const playerBuff = ToneAudioBuffer.fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
 				player.playbackRate = 0.5;
 				player.sync().start(0);
 				// start halfway through
 				transport.start(0, 0.15);
-			}, 0.05).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.be.closeTo(0.5, 0.05);
-			});
+			}, 0.05);
+			expect(buff.getValueAtTime(0)).to.be.closeTo(0.5, 0.05);
 		});
 
-		it("starts with an offset when synced and started after Transport is running", () => {
-			return Offline(({ transport }) => {
+		it("starts with an offset when synced and started after Transport is running", async () => {
+			const buff = await Offline(({ transport }) => {
 				const ramp = new Float32Array(
 					Math.floor(getContext().sampleRate * 0.3)
 				);
 				for (let i = 0; i < ramp.length; i++) {
 					ramp[i] = (i / ramp.length) * 0.3;
 				}
-				const buff = new ToneAudioBuffer().fromArray(ramp);
-				const player = new Player(buff).toDestination();
+				const playerBuff = new ToneAudioBuffer().fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
 				transport.start(0);
 				return atTime(0.1, () => {
 					player.sync().start(0);
 				});
-			}, 0.3).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.equal(0);
-				expect(buff.getValueAtTime(0.05)).to.equal(0);
-				expect(buff.getValueAtTime(0.11)).to.be.closeTo(0.11, 0.01);
-				expect(buff.getValueAtTime(0.2)).to.be.closeTo(0.2, 0.01);
-			});
+			}, 0.3);
+			expect(buff.getValueAtTime(0)).to.equal(0);
+			expect(buff.getValueAtTime(0.05)).to.equal(0);
+			expect(buff.getValueAtTime(0.11)).to.be.closeTo(0.11, 0.01);
+			expect(buff.getValueAtTime(0.2)).to.be.closeTo(0.2, 0.01);
 		});
 
-		it("can pass in an offset when synced and started after Transport is running", () => {
-			return Offline(({ transport }) => {
+		it("can pass in an offset when synced and started after Transport is running", async () => {
+			const buff = await Offline(({ transport }) => {
 				const ramp = new Float32Array(
 					Math.floor(getContext().sampleRate * 0.3)
 				);
 				for (let i = 0; i < ramp.length; i++) {
 					ramp[i] = (i / ramp.length) * 0.3;
 				}
-				const buff = new ToneAudioBuffer().fromArray(ramp);
-				const player = new Player(buff).toDestination();
+				const playerBuff = new ToneAudioBuffer().fromArray(ramp);
+				const player = new Player(playerBuff).toDestination();
 				player.loop = true;
 				transport.start(0);
 				return atTime(0.1, () => {
 					player.sync().start(0, 0.1);
 				});
-			}, 0.3).then((buff) => {
-				expect(buff.getValueAtTime(0)).to.equal(0);
-				expect(buff.getValueAtTime(0.05)).to.equal(0);
-				expect(buff.getValueAtTime(0.11)).to.be.closeTo(0.21, 0.01);
-				expect(buff.getValueAtTime(0.15)).to.be.closeTo(0.25, 0.01);
-				expect(buff.getValueAtTime(0.2)).to.be.closeTo(0.0, 0.01);
-				expect(buff.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
-			});
+			}, 0.3);
+			expect(buff.getValueAtTime(0)).to.equal(0);
+			expect(buff.getValueAtTime(0.05)).to.equal(0);
+			expect(buff.getValueAtTime(0.11)).to.be.closeTo(0.21, 0.01);
+			expect(buff.getValueAtTime(0.15)).to.be.closeTo(0.25, 0.01);
+			expect(buff.getValueAtTime(0.2)).to.be.closeTo(0.0, 0.01);
+			expect(buff.getValueAtTime(0.25)).to.be.closeTo(0.05, 0.01);
 		});
 
-		it("fades in and out correctly", () => {
+		it("fades in and out correctly", async () => {
 			let duration = 0.5;
-			return Offline(() => {
+			const buff = await Offline(() => {
 				const onesArray = new Float32Array(
 					getContext().sampleRate * duration
 				);
@@ -683,18 +658,14 @@ describe("Player", () => {
 					fadeIn: 0.1,
 				}).toDestination();
 				player.start(0);
-			}, 0.6).then((buff) => {
-				expect(buff.getRmsAtTime(0)).to.be.closeTo(0, 0.1);
-				expect(buff.getRmsAtTime(0.05)).to.be.closeTo(0.5, 0.1);
-				expect(buff.getRmsAtTime(0.1)).to.be.closeTo(1, 0.1);
-				duration -= 0.1;
-				expect(buff.getRmsAtTime(duration)).to.be.closeTo(1, 0.1);
-				expect(buff.getRmsAtTime(duration + 0.05)).to.be.closeTo(
-					0.5,
-					0.1
-				);
-				expect(buff.getRmsAtTime(duration + 0.1)).to.be.closeTo(0, 0.1);
-			});
+			}, 0.6);
+			expect(buff.getRmsAtTime(0)).to.be.closeTo(0, 0.1);
+			expect(buff.getRmsAtTime(0.05)).to.be.closeTo(0.5, 0.1);
+			expect(buff.getRmsAtTime(0.1)).to.be.closeTo(1, 0.1);
+			duration -= 0.1;
+			expect(buff.getRmsAtTime(duration)).to.be.closeTo(1, 0.1);
+			expect(buff.getRmsAtTime(duration + 0.05)).to.be.closeTo(0.5, 0.1);
+			expect(buff.getRmsAtTime(duration + 0.1)).to.be.closeTo(0, 0.1);
 		});
 
 		it("stops only last activeSource when restarting at intervals < latencyHint", (done) => {