tone 14.8.27

package/Tone/core/clock/TickSource.test.ts

@@ -0,0 +1,655 @@
+import { expect } from "chai";
+import { BasicTests } from "test/helper/Basic";
+import { Offline } from "test/helper/Offline";
+import { TickSource } from "./TickSource";
+
+describe("TickSource", () => {
+
+	BasicTests(TickSource);
+
+	context("Constructor", () => {
+
+		it("can pass in the frequency", () => {
+			const source = new TickSource(2);
+			expect(source.frequency.value).to.equal(2);
+			source.dispose();
+		});
+
+		it("initially returns stop", () => {
+			const source = new TickSource(2);
+			expect(source.state).to.equal("stopped");
+			source.dispose();
+		});
+	});
+
+	context("Ticks", () => {
+
+		it("ticks are 0 before started", () => {
+			const source = new TickSource();
+			expect(source.ticks).to.equal(0);
+			source.dispose();
+		});
+
+		it("can set ticks", () => {
+			const source = new TickSource();
+			expect(source.ticks).to.equal(0);
+			source.ticks = 10;
+			expect(source.ticks).to.equal(10);
+			source.dispose();
+		});
+
+		it("ticks increment at the rate of the frequency after started", () => {
+			return Offline(() => {
+				const source = new TickSource();
+				source.start(0);
+				return time => {
+					expect(source.ticks).to.be.closeTo(time, 0.1);
+				};
+			}, 0.5);
+		});
+
+		it("ticks return to 0 after stopped", () => {
+			return Offline(() => {
+				const source = new TickSource(2);
+				source.start(0).stop(0.4);
+				return time => {
+					if (time < 0.399) {
+						expect(source.ticks).to.be.closeTo(2 * time, 0.01);
+					} else if (time > 0.4) {
+						expect(source.ticks).to.be.equal(0);
+					}
+				};
+			}, 0.5);
+		});
+
+		it("returns the paused ticks when paused", () => {
+			return Offline(() => {
+				const source = new TickSource(2);
+				source.start(0).pause(0.4);
+				let pausedTicks = -1;
+				return time => {
+					if (time < 0.4) {
+						pausedTicks = source.ticks;
+						expect(source.ticks).to.be.closeTo(2 * time, 0.01);
+					} else {
+						expect(source.ticks).to.be.closeTo(pausedTicks, 0.01);
+					}
+				};
+			}, 0.5);
+		});
+
+		it("ticks restart at 0 when started after stop", () => {
+			const source = new TickSource(3);
+			source.start(0).stop(1).start(2);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(1.5, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(3, 0.01);
+			source.dispose();
+		});
+
+		it("ticks remain the same after paused", () => {
+			const source = new TickSource(3);
+			source.start(0).pause(1);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(1.5, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(3, 0.01);
+			source.dispose();
+		});
+
+		it("ticks resume where they were paused", () => {
+			const source = new TickSource(2);
+			source.start(0).pause(1).start(2);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(6, 0.01);
+			source.dispose();
+		});
+
+		it("ticks return to 0 after pause then stopped", () => {
+			const source = new TickSource(2);
+			source.start(0).pause(1).start(2).stop(3);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(0, 0.01);
+			source.dispose();
+		});
+
+		it("handles multiple starts/stops", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(0.3).start(0.4).stop(0.5).start(0.6);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.1)).to.be.closeTo(0.1, 0.01);
+			expect(source.getTicksAtTime(0.2)).to.be.closeTo(0.2, 0.01);
+			expect(source.getTicksAtTime(0.3)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.4)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.6)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.7)).to.be.closeTo(0.1, 0.01);
+			expect(source.getTicksAtTime(0.8)).to.be.closeTo(0.2, 0.01);
+			source.dispose();
+		});
+
+		it("can get ticks when started with an offset", () => {
+			const source = new TickSource(1);
+			source.start(0, 2).stop(3).start(5, 1);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(6)).to.be.closeTo(2, 0.01);
+			source.dispose();
+		});
+
+		it("can invoke stop multiple times, takes the last invokation", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(3).stop(2).stop(4);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(6)).to.be.closeTo(0, 0.01);
+			source.dispose();
+		});
+
+		it("can set multiple setTicksAtTime", () => {
+			const source = new TickSource(1);
+			source.start(0, 1).pause(3);
+			source.setTicksAtTime(1, 4);
+			source.stop(5).start(6);
+			source.setTicksAtTime(2, 7);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(3.5)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(6)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(6.5)).to.be.closeTo(0.5, 0.01);
+			expect(source.getTicksAtTime(7)).to.be.closeTo(2, 0.01);
+			source.dispose();
+		});
+
+		it("can pass start offset", () => {
+			const source = new TickSource(2);
+			source.start(0, 2).pause(1).start(2, 1);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(5, 0.01);
+			source.dispose();
+		});
+
+		it("can set ticks at any point", () => {
+			const source = new TickSource(2);
+			source.start(0, 2).pause(1).start(2);
+			source.setTicksAtTime(10, 1.5);
+			source.setTicksAtTime(2, 3.5);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(10, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(12, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(5, 0.01);
+			source.dispose();
+		});
+
+		it("get the time of the ticks", () => {
+			const source = new TickSource(2);
+			source.start(0, 2).pause(1).start(2);
+			source.setTicksAtTime(10, 1.5);
+			source.setTicksAtTime(2, 3.5);
+			expect(source.getTimeOfTick(2, 0.9)).to.be.closeTo(0, 0.01);
+			expect(source.getTimeOfTick(4, 0.9)).to.be.closeTo(1, 0.01);
+			expect(source.getTimeOfTick(10, 3)).to.be.closeTo(2, 0.01);
+			expect(source.getTimeOfTick(12, 3)).to.be.closeTo(3, 0.01);
+			expect(source.getTimeOfTick(3, 4)).to.be.closeTo(4, 0.01);
+			expect(source.getTimeOfTick(5, 4)).to.be.closeTo(5, 0.01);
+			source.dispose();
+		});
+
+		it("can cancel scheduled events", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(3);
+			source.setTicksAtTime(10, 2);
+			source.cancel(1);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(1, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(2, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(3, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(5, 0.01);
+			expect(source.getTicksAtTime(6)).to.be.closeTo(6, 0.01);
+			source.dispose();
+		});
+	});
+
+	context("forEachTickBetween", () => {
+
+		it("invokes a callback function when started", () => {
+			const source = new TickSource(1);
+			source.start(0);
+			let wasCalled = false;
+			source.forEachTickBetween(0, 2, () => {
+				wasCalled = true;
+			});
+			expect(wasCalled).to.equal(true);
+			source.dispose();
+		});
+
+		it("does not invoke callback when not overlapping with tick", () => {
+			const source = new TickSource(1);
+			source.start(0);
+			let wasCalled = false;
+			source.forEachTickBetween(1.1, 2, () => {
+				wasCalled = true;
+			});
+			expect(wasCalled).to.equal(false);
+			source.dispose();
+		});
+
+		it("iterates only at times when the state is 'started'", () => {
+			const source = new TickSource(4);
+			source.start(0.2).pause(2).start(3.5).stop(5);
+			let iterations = 0;
+			const expectedTimes = [1.2, 1.45, 1.7, 1.95, 3.5, 3.75, 4, 4.25, 4.5, 4.75];
+			const expectedTicks = [4, 5, 6, 7, 7, 8, 9, 10, 11, 12];
+			source.forEachTickBetween(1, 7, (time, ticks) => {
+				expect(time).to.be.closeTo(expectedTimes[iterations], 0.001);
+				expect(ticks).to.equal(expectedTicks[iterations]);
+				iterations++;
+			});
+			expect(iterations).to.equal(expectedTimes.length);
+			source.dispose();
+		});
+
+		it("can start at time = 0", () => {
+			const source = new TickSource(1);
+			source.start(0);
+			let iterations = 0;
+			source.forEachTickBetween(0, 0.1, () => {
+				iterations++;
+			});
+			expect(iterations).to.equal(1);
+			source.dispose();
+		});
+
+		it("can throw an error in the callback but still invokes all loops", () => {
+			const source = new TickSource(1);
+			source.start(0);
+			expect(() => {
+				source.forEachTickBetween(0, 3, () => {
+					throw new Error("should throw");
+				});
+			}).throws(Error);
+			source.dispose();
+		});
+
+		it("iterates once per tick", () => {
+			const source = new TickSource(1);
+			source.start(0.5);
+			let iterations = 0;
+			source.forEachTickBetween(0, 2, () => {
+				iterations++;
+			});
+			expect(iterations).to.equal(2);
+			source.dispose();
+		});
+
+		it("passes time and tick into the callback", () => {
+			const source = new TickSource(2);
+			source.start(0.5);
+			let iterations = 0;
+			const times = [0.5, 1.0, 1.5];
+			source.forEachTickBetween(0, 2, (time, ticks) => {
+				expect(times[ticks]).to.be.closeTo(time, 0.001);
+				iterations++;
+			});
+			expect(iterations).to.equal(3);
+			source.dispose();
+		});
+
+		it("ticks = 0 when restarted", () => {
+			const source = new TickSource(1);
+			source.start(0.5).stop(1).start(2);
+			let iterations = 0;
+			const expectedTicks = [0, 0, 1];
+			const expectedTimes = [0.5, 2, 3];
+			source.forEachTickBetween(0, 3.1, (time, ticks) => {
+				expect(time).to.be.closeTo(expectedTimes[iterations], 0.001);
+				expect(ticks).to.equal(expectedTicks[iterations]);
+				iterations++;
+			});
+			expect(iterations).to.equal(expectedTicks.length);
+			source.dispose();
+		});
+
+		it("ticks resume after pause when restarted", () => {
+			const source = new TickSource(1);
+			source.start(0.5).pause(2).start(3);
+			let iterations = 0;
+			const expectedTicks = [0, 1, 2];
+			const expectedTimes = [0.5, 1.5, 3];
+			source.forEachTickBetween(0, 3.1, (time, ticks) => {
+				expect(time).to.be.closeTo(expectedTimes[iterations], 0.001);
+				expect(ticks).to.equal(expectedTicks[iterations]);
+				iterations++;
+			});
+			expect(iterations).to.equal(expectedTicks.length);
+			source.dispose();
+		});
+
+		it("handles start and stop", () => {
+			const source = new TickSource(2);
+			source.start(0.5).stop(2);
+			let iterations = 0;
+			const times = [0.5, 1.0, 1.5];
+			source.forEachTickBetween(0, 3, (time, ticks) => {
+				expect(times[ticks]).to.be.closeTo(time, 0.001);
+				iterations++;
+			});
+			expect(iterations).to.equal(3);
+			source.dispose();
+		});
+
+		it("handles multiple start and stop", () => {
+			const source = new TickSource(2);
+			source.start(0.5).stop(2).start(2.5).stop(4.1);
+			let iterations = 0;
+			const times = [0.5, 1.0, 1.5, 2.5, 3, 3.5, 4];
+			source.forEachTickBetween(0, 10, time => {
+				expect(times[iterations]).to.be.closeTo(time, 0.001);
+				iterations++;
+			});
+			expect(iterations).to.equal(times.length);
+			source.dispose();
+		});
+
+		it("works with a frequency ramp", () => {
+			const source = new TickSource(1);
+			source.frequency.setValueAtTime(1, 0);
+			source.frequency.linearRampToValueAtTime(4, 1);
+			source.start(0.5);
+			let iterations = 0;
+			const times = [0.500, 0.833, 1.094, 1.344, 1.594, 1.844];
+			source.forEachTickBetween(0, 2, (time, ticks) => {
+				expect(time).to.be.closeTo(times[ticks], 0.001);
+				iterations++;
+			});
+			expect(iterations).to.equal(times.length);
+			source.dispose();
+		});
+
+		it("can start with a tick offset", () => {
+			const source = new TickSource(10);
+			source.start(0.5, 5);
+			let iterations = 0;
+			source.forEachTickBetween(0, 2, (time, ticks) => {
+				expect(ticks).to.be.gte(5);
+				iterations++;
+			});
+			expect(iterations).to.equal(15);
+			source.dispose();
+		});
+
+		it("can handle multiple starts with tick offsets", () => {
+			const source = new TickSource(1);
+			source.start(0.5, 10).stop(2).start(3, 1);
+			let iterations = 0;
+			const expectedTimes = [0.5, 1.5, 3];
+			const expectedTicks = [10, 11, 1];
+			source.forEachTickBetween(0, 4, (time, ticks) => {
+				expect(time).to.be.closeTo(expectedTimes[iterations], 0.001);
+				expect(ticks).to.equal(expectedTicks[iterations]);
+				iterations++;
+			});
+			expect(iterations).to.equal(expectedTicks.length);
+			source.dispose();
+		});
+
+		it("can set ticks after start", () => {
+			const source = new TickSource(1);
+			source.start(0.4, 3);
+			source.setTicksAtTime(1, 1.4);
+			source.setTicksAtTime(10, 3);
+			let iterations = 0;
+			const expectedTicks = [3, 1, 2, 10];
+			source.forEachTickBetween(0, 4, (time, ticks) => {
+				expect(ticks).to.equal(expectedTicks[iterations]);
+				iterations++;
+			});
+			expect(iterations).to.equal(expectedTicks.length);
+			source.dispose();
+		});
+
+		it("can pass in the frequency", () => {
+			const source = new TickSource(20);
+			source.start(0.5);
+			let iterations = 0;
+			let lastTime = 0.5;
+			source.forEachTickBetween(0.51, 2.01, time => {
+				expect(time - lastTime).to.be.closeTo(0.05, 0.001);
+				lastTime = time;
+				iterations++;
+			});
+			expect(iterations).to.equal(30);
+			source.dispose();
+		});
+
+		it("can iterate from later in the timeline", () => {
+			const source = new TickSource(1);
+			source.start(0.2);
+			let iterations = 0;
+			source.forEachTickBetween(100, 101, (time, ticks) => {
+				expect(ticks).to.equal(100);
+				expect(time).to.be.closeTo(100.2, 0.001);
+				iterations++;
+			});
+			expect(iterations).to.equal(1);
+			source.dispose();
+		});
+
+		it("always increments by 1 at a fixed rate", () => {
+			const source = new TickSource(960);
+			source.start(0);
+			let previousTick = -1;
+			let previousTime = -1;
+			source.forEachTickBetween(1000, 1010, (time, ticks) => {
+				expect(time).to.be.gt(previousTime);
+				if (previousTick !== -1) {
+					expect(ticks - previousTick).to.equal(1);
+				}
+				previousTick = ticks;
+				previousTime = time;
+			});
+			source.dispose();
+		});
+
+		it("always increments by 1 when linearly changing rate", () => {
+			const source = new TickSource(200);
+			source.frequency.setValueAtTime(200, 0);
+			source.frequency.linearRampToValueAtTime(1000, 100);
+			source.start(10);
+			let previousTick = -1;
+			let previousTime = -1;
+			source.forEachTickBetween(10, 30, (time, ticks) => {
+				expect(time).to.be.gt(previousTime);
+				expect(ticks - previousTick).to.equal(1);
+				previousTick = ticks;
+				previousTime = time;
+			});
+			source.dispose();
+		});
+
+		it("always increments by 1 when setting values", () => {
+			const source = new TickSource(200);
+			source.frequency.setValueAtTime(300, 0);
+			source.frequency.setValueAtTime(3, 0.1);
+			source.frequency.setValueAtTime(100, 0.2);
+			source.frequency.setValueAtTime(10, 0.3);
+			source.frequency.setValueAtTime(1000, 0.4);
+			source.frequency.setValueAtTime(1, 0.5);
+			source.frequency.setValueAtTime(50, 0.6);
+			source.start(0);
+			let previousTick = -1;
+			let previousTime = -1;
+			source.forEachTickBetween(0, 10, (time, ticks) => {
+				expect(time).to.be.gt(previousTime);
+				expect(ticks - previousTick).to.equal(1);
+				previousTick = ticks;
+				previousTime = time;
+			});
+			source.dispose();
+		});
+
+	});
+
+	context("Seconds", () => {
+
+		it("get the elapsed time in seconds", () => {
+			return Offline(() => {
+				const source = new TickSource(1).start(0);
+				return time => {
+					expect(source.seconds).to.be.closeTo(time, 0.01);
+				};
+			}, 2);
+		});
+
+		it("seconds is 0 before starting", () => {
+			const source = new TickSource(1);
+			expect(source.seconds).to.be.closeTo(0, 0.001);
+			source.dispose();
+
+		});
+
+		it("can set the seconds", () => {
+			const source = new TickSource(1);
+			expect(source.seconds).to.be.closeTo(0, 0.001);
+			source.dispose();
+
+		});
+
+		it("seconds pauses at last second count", () => {
+			const source = new TickSource(1);
+			source.start(0).pause(1);
+			expect(source.getSecondsAtTime(0)).to.be.closeTo(0, 0.001);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(1, 0.001);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(1, 0.001);
+			source.dispose();
+		});
+
+		it("can handle multiple pauses", () => {
+			const source = new TickSource(1);
+			source.start(0).pause(1).start(2).pause(3).start(4).stop(6);
+			expect(source.getSecondsAtTime(0)).to.be.closeTo(0, 0.001);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(1, 0.001);
+			expect(source.getSecondsAtTime(2)).to.be.closeTo(1, 0.001);
+			expect(source.getSecondsAtTime(2.5)).to.be.closeTo(1.5, 0.001);
+			expect(source.getSecondsAtTime(3)).to.be.closeTo(2, 0.001);
+			expect(source.getSecondsAtTime(4.5)).to.be.closeTo(2.5, 0.001);
+			expect(source.getSecondsAtTime(5)).to.be.closeTo(3, 0.001);
+			expect(source.getSecondsAtTime(6)).to.be.closeTo(0, 0.001);
+			source.dispose();
+		});
+
+		it("get the elapsed time in seconds when starting in the future", () => {
+			return Offline(() => {
+				const source = new TickSource(1).start(0.1);
+				return time => {
+					if (time < 0.1) {
+						expect(source.seconds).to.be.closeTo(0, 0.001);
+					} else {
+						expect(source.seconds).to.be.closeTo(time - 0.1, 0.01);
+					}
+				};
+			}, 2);
+		});
+
+		it("handles multiple starts and stops", () => {
+			const source = new TickSource(1).start(0).stop(0.5).start(1).stop(1.5);
+			expect(source.getSecondsAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(0.4)).to.be.closeTo(0.4, 0.01);
+			expect(source.getSecondsAtTime(0.5)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(0.9)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getSecondsAtTime(1.4)).to.be.closeTo(0.4, 0.01);
+			expect(source.getSecondsAtTime(1.5)).to.be.closeTo(0, 0.01);
+			source.dispose();
+		});
+	});
+
+	context("Frequency", () => {
+
+		it("can automate frequency with setValueAtTime", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(0.3).start(0.4).stop(0.5).start(0.6);
+			source.frequency.setValueAtTime(2, 0.3);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.1)).to.be.closeTo(0.1, 0.01);
+			expect(source.getTicksAtTime(0.2)).to.be.closeTo(0.2, 0.01);
+			expect(source.getTicksAtTime(0.3)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.4)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.45)).to.be.closeTo(0.1, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.6)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.7)).to.be.closeTo(0.2, 0.01);
+			expect(source.getTicksAtTime(0.8)).to.be.closeTo(0.4, 0.01);
+			source.dispose();
+		});
+
+		it("can automate frequency with linearRampToValueAtTime", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(1).start(2);
+			source.frequency.linearRampToValueAtTime(2, 2);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(0.56, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(2, 0.01);
+			source.dispose();
+		});
+
+		it("can automate frequency with exponentialRampToValueAtTime", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(1).start(2).stop(5);
+			source.frequency.exponentialRampToValueAtTime(4, 2);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(0.6, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(4, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(8, 0.01);
+			source.dispose();
+		});
+
+		it("can automate frequency with setTargetAtTime", () => {
+			const source = new TickSource(1);
+			source.start(0).stop(1).start(2).stop(5);
+			source.frequency.setTargetAtTime(2, 1, 0.5);
+			expect(source.getTicksAtTime(0)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(0.5)).to.be.closeTo(0.5, 0.01);
+			expect(source.getTicksAtTime(1)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(2)).to.be.closeTo(0, 0.01);
+			expect(source.getTicksAtTime(3)).to.be.closeTo(1.86, 0.01);
+			expect(source.getTicksAtTime(4)).to.be.closeTo(3.73, 0.01);
+			expect(source.getTicksAtTime(5)).to.be.closeTo(0, 0.01);
+			source.dispose();
+		});
+	});
+
+});