Tone.js/test/event/Loop.js

define(["helper/Basic", "Tone/event/Loop", "Tone/core/Tone", "Tone/core/Transport", "helper/Offline", "Test"], 
	function (Basic, Loop, Tone, Transport, Offline, Test) {

	describe("Loop", function(){

		Basic(Loop);

		context("Constructor", function(){

			it ("takes a callback and an interval", function(){
				return Offline(function(){
					var callback = function(){};
					var loop = new Loop(callback, "8n");
					expect(loop.callback).to.equal(callback);
					expect(loop.interval).to.equal("8n");
					loop.dispose();
				});
			});

			it ("can be constructed with no arguments", function(){
				return Offline(function(){
					var loop = new Loop();
					expect(loop.iterations).to.equal(Infinity);
					loop.dispose();
				});
			});

			it ("can pass in arguments in options object", function(){
				return Offline(function(){
					var callback = function(){};
					var loop = new Loop({
						"callback" : callback,
						"iterations" : 4,
						"probability" : 0.3,
						"interval" : "8t"
					});
					expect(loop.callback).to.equal(callback);
					expect(loop.interval).to.equal("8t");
					expect(loop.iterations).to.equal(4);
					expect(loop.probability).to.equal(0.3);
					loop.dispose();
				});
			});
		});

		context("Get/Set", function(){

			it ("can set values with object", function(){
				return Offline(function(){
					var callback = function(){};
					var loop = new Loop();
					loop.set({
						"callback" : callback,
						"iterations" : 8
					});
					expect(loop.callback).to.equal(callback);
					expect(loop.iterations).to.equal(8);
					loop.dispose();
				});
			});

			it ("can get/set the humanize values", function(){
				return Offline(function(){
					var callback = function(){};
					var loop = new Loop();
					loop.humanize = true;
					expect(loop.humanize).to.be.true;
					loop.dispose();
				});
			});

			it ("can set get a the values as an object", function(){
				return Offline(function(){
					var callback = function(){};
					var loop = new Loop({
						"callback" : callback,
						"iterations" : 4,
						"probability" : 0.3
					});
					var values = loop.get();
					expect(values.iterations).to.equal(4);
					expect(values.probability).to.equal(0.3);
					loop.dispose();
				});
			});
		});


		context("Callback", function(){

			it ("does not invoke get invoked until started", function(){
				return Offline(function(Transport){
					new Loop(function(){
						throw new Error("shouldn't call this callback");
					}, "8n");
					Transport.start();
				}, 0.3);
			});

			it ("is invoked after it's started", function(){
				var invoked = false;
				return Offline(function(Transport){
					var loop = new Loop(function(){
						loop.dispose();
						invoked = true;
					}, 0.05).start(0);
					Transport.start();
				}).then(function(){
					expect(invoked).to.be.true;
				});
			});

			it ("passes in the scheduled time to the callback", function(){
				var invoked = false;
				return Offline(function(Transport){
					var now = Transport.now() + 0.1;
					var loop = new Loop(function(time){
						expect(time).to.be.a.number;
						expect(time - now).to.be.closeTo(0.3, 0.01);
						loop.dispose();
						invoked = true;
					});
					Transport.start(now);
					loop.start(0.3);
				}, 0.5).then(function(){
					expect(invoked).to.be.true;
				});
			});

			it ("can mute the callback", function(){
				return Offline(function(){
					var loop = new Loop(function(){
						throw new Error("shouldn't call this callback");
					}, "4n").start();
					loop.mute = true;
					expect(loop.mute).to.be.true;
					Transport.start();
				}, 0.4);
			});

			it ("can trigger with some probability", function(){
				return Offline(function(Transport){
					var loop = new Loop(function(){
						throw new Error("shouldn't call this callback");
					}, "4n").start();
					loop.probability = 0;
					expect(loop.probability).to.equal(0);
					Transport.start();
				}, 0.4);
			});
		});

		context("Scheduling", function(){

			it ("can be started and stopped multiple times", function(){
				return Offline(function(Transport){
					var loop = new Loop().start().stop(0.2).start(0.4);
					Transport.start(0);
					return function(time){
						Test.whenBetween(time, 0, 0.19, function(){
							expect(loop.state).to.equal("started");	
						});
						Test.whenBetween(time, 0.2, 0.39, function(){
							expect(loop.state).to.equal("stopped");	
						});
						Test.whenBetween(time, 0.4, Infinity, function(){
							expect(loop.state).to.equal("started");	
						});
					};
				}, 0.6);
			});

			it ("restarts when transport is restarted", function(){
				return Offline(function(Transport){
					var note = new Loop().start(0).stop(0.4);
					Transport.start(0).stop(0.5).start(0.55);
					return function(sample, time){
						Test.whenBetween(time, 0, 0.39, function(){
							expect(note.state).to.equal("started");
						});
						Test.whenBetween(time, 0.4, 0.5, function(){
							expect(note.state).to.equal("stopped");	
						});
						Test.whenBetween(time, 0.55, 0.8, function(){
							expect(note.state).to.equal("started");
						});
					};
				}, 1);
			});


			it ("can be cancelled", function(){
				return Offline(function(Transport){
					var note = new Loop().start(0);
					expect(note.state).to.equal("started");
					Transport.start();

					var firstStop = false;
					var restarted = false;
					var tested = false;
					return function(time){
						//stop the transport
						if (time > 0.2 && !firstStop){
							firstStop = true;
							Transport.stop();
							note.cancel();
						}
						if (time > 0.3 && !restarted){
							restarted = true;
							Transport.start();
						}
						if (time > 0.4 && !tested){
							restarted = true;
							Transport.start();
							expect(note.state).to.equal("stopped");
						}
					};
				}, 0.5);
			});

		});

		context("Looping", function(){

			it ("loops", function(){
				var callCount = 0;
				return Offline(function(Transport){
					new Loop({
						"interval" : 0.1,
						"callback" : function(){
							callCount++;
						}
					}).start(0);
					Transport.start();
				}, 0.8).then(function(){
					expect(callCount).to.equal(9);
				});
			});

			it ("loops for the specified interval", function(){
				var invoked = false;
				return Offline(function(Transport){
					var lastCall;
					new Loop({
						"interval" : "8n",
						"callback" : function(time){
							if (lastCall){
								invoked = true;
								expect(time - lastCall).to.be.closeTo(0.25, 0.01);
							}
							lastCall = time;
						}
					}).start(0);
					Transport.start();
				}, 1).then(function(){
					expect(invoked).to.be.true;
				});
			});

			it ("can loop a specific number of iterations", function(){
				var callCount = 0;
				return Offline(function(Transport){
					new Loop({
						"interval" : 0.1,
						"iterations" : 2,
						"callback" : function(){
							callCount++;
						}
					}).start(0);
					Transport.start();
				}, 0.4).then(function(){
					expect(callCount).to.equal(2);
				});
			});

			it ("reports the progress of the loop", function(){
				return Offline(function(Transport){
					var loop = new Loop({
						"interval" : 1,
					}).start(0);
					Transport.start();
					return function(time){
						expect(loop.progress).to.be.closeTo(time, 0.05);
					};
				}, 0.8);
			});
		});

		context("playbackRate", function(){

			it ("can adjust the playbackRate", function(){
				var invoked = false;
				return Offline(function(Transport){
					var lastCall;
					var loop = new Loop({
						"playbackRate" : 2,
						"interval" : 0.5,
						"callback" : function(time){
							if (lastCall){
								invoked = true;
								expect(time - lastCall).to.be.closeTo(0.25, 0.01);
							}
							lastCall = time;
						}
					}).start(0);
					expect(loop.playbackRate).to.equal(2);
					Transport.start();
				}, 0.7).then(function(){
					expect(invoked).to.be.true;
				});
				
			});

			it ("can playback at a faster rate", function(){
				var callCount = 0;
				return Offline(function(Transport){
					var loop = new Loop({
						"interval" : 0.1,
						"callback" : function(){
							callCount++;
						}
					}).start(0);
					loop.playbackRate = 1.5;
					expect(loop.playbackRate).to.equal(1.5);
					Transport.start();
				}, 0.8).then(function(){
					expect(callCount).to.equal(13);
				});
			});

		});

	});
});