scruby 0.2.7

data/spec/integration_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper"
+
+require "scruby"
+
+include Scruby
+include Ugens
+
+describe "synthdef examples" do
+
+  before :all do
+    @sdef = SynthDef.new :hola do |a, b| SinOsc.kr( a ) + SinOsc.kr( b ) end
+    @expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 4, 104, 111, 108, 97, 0, 1, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 97, 0, 0, 1, 98, 0, 1, 0, 4, 7, 67, 111, 110, 116, 114, 111, 108, 1, 0, 0, 0, 2, 0, 0, 1, 1, 6, 83, 105, 110, 79, 115, 99, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, -1, -1, 0, 0, 1, 6, 83, 105, 110, 79, 115, 99, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, -1, -1, 0, 0, 1, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 1, 0, 2, 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 1, 0, 0 ].pack('C*')
+  end
+
+  it "should have correct children" do
+    @sdef.children[0].should be_instance_of( Control )
+    @sdef.children[1].should be_instance_of( SinOsc )
+    @sdef.children[2].should be_instance_of( SinOsc )
+    @sdef.children[3].should be_instance_of( BinaryOpUGen )
+  end
+
+  it "should encode with control" do
+    @sdef.encode.should == @expected
+  end
+
+  it "should encode with ops" do
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 4, 104, 101, 108, 112, 0, 2, 67, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 0, 0, 3, 0, 0, 2, 0, 0 ].pack('C*')
+    SynthDef.new(:help){ (SinOsc.ar() + SinOsc.ar()) * SinOsc.ar() }.encode.should == expected
+  end
+
+  it "should encode with out" do
+    sdef = SynthDef.new(:out){ Out.ar(0, SinOsc.ar) }
+    sdef.children.should have(2).children
+    
+    sdef.children[0].should be_instance_of( SinOsc )
+    sdef.children[1].should be_instance_of( Out ) 
+    
+    sdef.constants.should == [ 440, 0 ]
+    sdef.children[1].channels.should == []
+    
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 3, 111, 117, 116, 0, 2, 67, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 3, 79, 117, 116, 2, 0, 2, 0, 0, 0, 0, -1, -1, 0, 1, 0, 0, 0, 0, 0, 0 ].pack('C*')
+    sdef.encode.should == expected
+  end
+
+  it "should encode another with out" do
+    sdef = SynthDef.new(:out){ sig = SinOsc.ar(100, 200) * SinOsc.ar(200); Out.ar(0, sig) }
+    sdef.encode.should == [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 3, 111, 117, 116, 0, 3, 66, -56, 0, 0, 67, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 1, -1, -1, 0, 2, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 3, 79, 117, 116, 2, 0, 2, 0, 0, 0, 0, -1, -1, 0, 2, 0, 2, 0, 0, 0, 0 ].pack('C*')
+  end
+  
+  it "should encode out with two channels" do
+    sdef = SynthDef.new( :out ){ sig = SinOsc.ar(100, [200, 200]) * SinOsc.ar(200); Out.ar(0, sig) }
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 3, 111, 117, 116, 0, 3, 66, -56, 0, 0, 67, 72, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 1, -1, -1, 0, 2, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 0, 0, 0, 0, 2, 0, 0, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 1, 0, 0, 0, 2, 0, 0, 2, 3, 79, 117, 116, 2, 0, 3, 0, 0, 0, 0, -1, -1, 0, 2, 0, 3, 0, 0, 0, 4, 0, 0, 0, 0 ].pack('C*')
+    sdef.encode.should == expected
+  end
+  
+  it "should instantiate and encode" do
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 4, 104, 101, 108, 112, 0, 2, 67, -36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, -1, -1, 0, 0, -1, -1, 0, 1, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 2, 0, 0, 0, 3, 0, 0, 2, 0, 0 ].pack('C*')
+    SynthDef.new( :help ){ (SinOsc.ar() + SinOsc.ar()) * SinOsc.ar() }.encode.should == expected
+  end
+  
+  it "should encode out with multidimensional array" do
+    sdef  = SynthDef.new( :out ){ sig = SinOsc.ar(100, [200,[100, 100]]) * SinOsc.ar(200); Out.ar(0, sig) }
+    children = sdef.children
+    children[0..3].map { |u| u.should be_instance_of(SinOsc) }
+    children[4].should be_instance_of(BinaryOpUGen)
+    children[5].should be_instance_of(BinaryOpUGen)
+    children[6].should be_instance_of(BinaryOpUGen)
+    children[7].should be_instance_of(Out)
+    children[8].should be_instance_of(Out)
+    #the order of the elements is different than in supercollider, but at least has the encoded string is the same size so i guess its fine
+    sdef.encode.should have(261).chars
+  end
+  
+  it "should encode 'complex' sdef" do
+    sdef  = SynthDef.new :am do |gate, portadora, moduladora, amp|
+      mod = SinOsc.kr moduladora, 0, 0.5, 0.5
+      sig = SinOsc.ar portadora, 0, mod
+      env = EnvGen.kr Env.asr(2, 1, 2), gate, :doneAction => 2
+      Out.ar 0, sig*env
+    end
+
+    sdef.children.should have(8).children
+    sdef.constants.should == [0, 0.5, 1, 2, -99, 5, -4]
+    expected = [ 83, 67, 103, 102, 0, 0, 0, 1, 0, 1, 2, 97, 109, 0, 7, 0, 0, 0, 0, 63, 0, 0, 0, 63, -128, 0, 0, 64, 0, 0, 0, -62, -58, 0, 0, 64, -96, 0, 0, -64, -128, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 4, 103, 97, 116, 101, 0, 0, 9, 112, 111, 114, 116, 97, 100, 111, 114, 97, 0, 1, 10, 109, 111, 100, 117, 108, 97, 100, 111, 114, 97, 0, 2, 3, 97, 109, 112, 0, 3, 0, 8, 7, 67, 111, 110, 116, 114, 111, 108, 1, 0, 0, 0, 4, 0, 0, 1, 1, 1, 1, 6, 83, 105, 110, 79, 115, 99, 1, 0, 2, 0, 1, 0, 0, 0, 0, 0, 2, -1, -1, 0, 0, 1, 6, 77, 117, 108, 65, 100, 100, 1, 0, 3, 0, 1, 0, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, -1, 0, 1, 1, 6, 83, 105, 110, 79, 115, 99, 2, 0, 2, 0, 1, 0, 0, 0, 0, 0, 1, -1, -1, 0, 0, 2, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 3, 0, 0, 0, 2, 0, 0, 2, 6, 69, 110, 118, 71, 101, 110, 1, 0, 17, 0, 1, 0, 0, 0, 0, 0, 0, -1, -1, 0, 2, -1, -1, 0, 0, -1, -1, 0, 2, -1, -1, 0, 3, -1, -1, 0, 0, -1, -1, 0, 3, -1, -1, 0, 2, -1, -1, 0, 4, -1, -1, 0, 2, -1, -1, 0, 3, -1, -1, 0, 5, -1, -1, 0, 6, -1, -1, 0, 0, -1, -1, 0, 3, -1, -1, 0, 5, -1, -1, 0, 6, 1, 12, 66, 105, 110, 97, 114, 121, 79, 112, 85, 71, 101, 110, 2, 0, 2, 0, 1, 0, 2, 0, 4, 0, 0, 0, 5, 0, 0, 2, 3, 79, 117, 116, 2, 0, 2, 0, 0, 0, 0, -1, -1, 0, 0, 0, 6, 0, 0, 0, 0 ].pack('c*')
+    sdef.encode.should == expected
+  end
+end
+

data/spec/multiout_ugen_spec.rb

@@ -0,0 +1,86 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper"
+
+require "scruby/core_ext/delegator_array"
+require "scruby/control_name"
+require "scruby/env"
+require "scruby/ugens/ugen" 
+require "scruby/ugens/ugen_operations" 
+require "scruby/ugens/multi_out"
+
+include Scruby
+include Ugens
+
+class Control
+  class << self
+    public :new
+  end
+end
+
+describe Control do
+  before do
+    sdef = mock( 'SynthDef', :children => [] )
+    Ugen.stub!( :synthdef ).and_return( sdef )
+
+    @proxy = mock(OutputProxy, :instance_of_proxy? => true)
+    OutputProxy.stub!( :new ).and_return( @proxy )
+
+    @names = Array.new( rand(7) + 3 ) do |i|
+      ControlName.new "control_#{i}", 1, :control, i
+    end
+    
+    @proxies = Control.new( :audio, *@names )
+    @control = sdef.children.first
+  end
+
+  it "should return an array of proxies" do
+    @proxies.should be_a( DelegatorArray )
+    @proxies.should have( @names.size ).proxies
+  end
+
+  it "should set channels" do
+    @control.should be_instance_of( Control )
+    @control.channels.should == @names.map{ @proxy }
+  end
+
+  it "should be added to synthdef" do
+    Ugen.should_receive( :synthdef )
+    Control.new( :audio, [])
+  end
+  
+  it "should instantiate with #and_proxies_from" do
+    Control.should_receive(:new).with( :control, *@names )
+    Control.and_proxies_from( @names )
+  end
+  
+  it "should have index" do
+    @control.index.should == 0
+  end
+  
+end
+
+describe OutputProxy do
+  
+  before do
+    @sdef = mock( 'sdef', :children => [] )
+    Ugen.stub!( :synthdef ).and_return( @sdef )
+    @name  = ControlName.new( "control", 1, :control, 0)
+    @names = [@name]
+    @output_index = 1
+  end
+  
+  it "should receive index from control" do
+    Control.and_proxies_from( @names ).first.index.should == 0
+    @sdef.children.first.index.should == 0
+  end
+  
+  it "should have empty inputs" do
+    OutputProxy.new( :audio, @name, @output_index, @name ).inputs.should == []
+  end
+  
+  it "should not be added to synthdef" do
+    Ugen.should_not_receive( :synthdef )
+    OutputProxy.new( :audio, @name, @output_index, @name )
+  end
+end
+
+

data/spec/node_spec.rb

@@ -0,0 +1,112 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper"
+
+require "scruby/core_ext/typed_array" 
+require "scruby/node"
+require "scruby/bus"
+
+require 'scruby/server'
+require File.join( File.expand_path(File.dirname(__FILE__)), "server")
+
+include Scruby
+
+describe Node do  
+  before :all do
+    @server  = Server.new
+  end
+  
+  before do
+    Node.reset!
+    Server.stub!(:all).and_return([@server])
+  end
+  
+  it "should have incremental uniq id" do
+    10.times do |i|
+      Node.new.id.should  == 2001 + i
+    end    
+  end
+  
+  it "should reset" do
+    Node.new.id.should == 2001
+  end
+  
+  describe 'instantiation' do
+    it "should not accept non servers" do
+      lambda{ Node.new(1,2) }.should   raise_error(TypeError)
+      lambda{ Node.new([1,2]) }.should raise_error(TypeError)
+    end
+    
+    it "should accept a server and have a TypedArray of Servers" do
+      n = Node.new @server
+      n.servers.should == [@server]
+    end
+    
+    it "should have default servers if no server is passed" do
+      n = Node.new
+      n.servers.should == [@server]
+    end
+  end
+  
+  describe 'Server interaction' do
+    before :all do
+      @server = Server.new
+      @server.boot
+      @server.send "/dumpOSC", 3
+      sleep 0.05
+    end
+    
+    after :all do
+      @server.quit
+    end
+    
+    before do
+      @node = Node.new @server
+    end
+    
+    it "should send free" do
+      @node.free
+      @node.should_not   be_running
+      @node.group.should be_nil
+      @node.should_not   be_playing
+      sleep 0.05
+      @server.output.should =~ %r{\[ "/n_free", #{ @node.id } \]}
+    end
+    
+    it "should send run" do
+      @node.run
+      sleep 0.05
+      @server.output.should =~ %r{\[ "/n_run", #{ @node.id }, 1 \]}
+      @node.run false
+      sleep 0.05
+      @server.output.should =~ %r{\[ "/n_run", #{ @node.id }, 0 \]}
+    end
+    
+    it "should send run" do
+      @node.run
+      sleep 0.05
+      @server.output.should =~ %r{\[ "/n_run", #{ @node.id }, 1 \]}
+      @node.run false
+      sleep 0.05
+      @server.output.should =~ %r{\[ "/n_run", #{ @node.id }, 0 \]}
+    end
+    
+    describe 'map' do
+      it "should just accept instances of Bus" do
+         b1 = mock 'Bus', :index => 1, :channels => 1, :rate => :audio
+         b1.should_receive(:kind_of?).and_return(false)
+         lambda { @node.map :freq1 => b1 }.should raise_error(ArgumentError)
+      end
+      
+      it "should send map" do
+        b1 = mock 'Bus', :index => 1, :channels => 1, :rate => :control
+        b1.should_receive(:kind_of?).and_return(true)
+        b2 = mock 'Bus', :index => 2, :channels => 2, :rate => :audio
+        b2.should_receive(:kind_of?).and_return(true)
+        @node.map( :freq1 => b1, :freq2 => b2 ).should be_instance_of(Node)
+        sleep 0.05
+        @server.output.should =~ %r{\[ \"#bundle\", 1, \n    \[ \"/n_mapn\", #{ @node.id }, \"freq1\", #{ b1.index }, 1 \],\n    \[ \"/n_mapan\", #{ @node.id }, \"freq2\", #{ b2.index }, 2 \]\n\]}
+      end
+    end
+  
+  end
+  
+end

data/spec/operation_ugens_spec.rb

@@ -0,0 +1,196 @@
+require File.expand_path(File.dirname(__FILE__)) + "/helper"
+
+
+require "scruby/control_name"
+require "scruby/env"
+require "scruby/ugens/ugen"
+require "scruby/ugens/ugen_operations" 
+require "scruby/ugens/operation_ugens"
+require "scruby/core_ext/delegator_array"
+
+include Scruby
+include Ugens
+
+class MockUgen < Ugen
+  class << self; public :new; end
+end
+
+describe UnaryOpUGen do
+  ::RATES = :scalar, :demand, :control, :audio
+  
+  before do
+    @scalar  = MockUgen.new :scalar
+    @demand  = MockUgen.new :demand
+    @control = MockUgen.new :control
+    @audio   = MockUgen.new :audio
+  end
+  
+  describe UnaryOpUGen do
+    
+    before do
+      @op = UnaryOpUGen.new( :neg, @audio )
+    end
+    
+    it "should return special index" do
+      UnaryOpUGen.new( :neg, @audio ).special_index.should     == 0
+      UnaryOpUGen.new( :bitNot, @audio ).special_index.should  == 4
+      UnaryOpUGen.new( :abs, @audio ).special_index.should     == 5
+      UnaryOpUGen.new( :asFloat, @audio ).special_index.should == 6
+    end
+  
+    it "should accept just one input" do
+      lambda{ UnaryOpUGen.new(:neg, @audio, @demand) }.should raise_error( ArgumentError )
+    end
+  
+    it "should just accept defined operators" # do
+     #    lambda{ UnaryOpUGen.new(:not_operator, @audio) }.should raise_error( ArgumentError )
+     #  end
+  
+    it "should get max rate" do
+      UnaryOpUGen.send(:get_rate, @scalar, @demand ).should                       == :demand
+      UnaryOpUGen.send(:get_rate, @scalar, @demand, @audio ).should               == :audio
+      UnaryOpUGen.send(:get_rate, @scalar, [@demand, [@control, @audio]] ).should == :audio
+    end
+  
+    it do
+      UnaryOpUGen.new(:neg, @audio).should be_instance_of(UnaryOpUGen)
+    end
+  
+    it "should set rate" do
+      UnaryOpUGen.new(:neg, @audio).rate.should  == :audio
+      UnaryOpUGen.new(:neg, @scalar).rate.should == :scalar
+    end
+  
+    it "should set operator" do
+      UnaryOpUGen.new(:neg, @audio).operator.should == :neg
+    end    
+  end
+  
+  describe BinaryOpUGen do
+    
+    before do
+      @arg_array = [@audio, [@scalar, @audio, [@demand, [@control, @demand]]] ]
+      @op_arr = BinaryOpUGen.new(:+, @audio, @arg_array )
+    end
+    
+    it "should return special index" do
+      BinaryOpUGen.new( :+, @audio, @audio ).special_index.should == 0
+      BinaryOpUGen.new( :-, @audio, @audio ).special_index.should == 1
+      BinaryOpUGen.new( :*, @audio, @audio ).special_index.should == 2
+      BinaryOpUGen.new( :/, @audio, @audio ).special_index.should == 4
+    end
+  
+    it "should accept exactly two inputs" do
+      lambda{ BinaryOpUGen.new(:+, @audio) }.should raise_error( ArgumentError )
+      lambda{ BinaryOpUGen.new(:+, @audio, @demand, @demand) }.should raise_error( ArgumentError )
+    end
+
+    it "should have correct inputs and operator when two inputs" do
+      arr = BinaryOpUGen.new( :+, @audio, @demand )
+      arr.inputs.should   == [@audio, @demand]
+      arr.operator.should == :+
+      arr.rate.should     == :audio
+    end
+  
+    it "should accept array as input" do
+      BinaryOpUGen.new(:+, @audio, [@audio, @scalar] ).should be_instance_of(DelegatorArray)
+    end
+  
+    it "should return an array of UnaryOpUGens" do
+      @op_arr.flatten.map { |op| op.should be_instance_of(BinaryOpUGen)  }
+    end
+  
+    it "should set rate for all operations" do
+      @op_arr.flatten.map { |op| op.rate.should eql(:audio)  }
+    end
+  
+    it "should set operator for all operations" do
+      @op_arr.flatten.map { |op| op.operator.should eql(:+)  }
+    end
+  
+    it "should set correct inputs when provided an array" do
+      arr = BinaryOpUGen.new(:+, @control, [@audio, @scalar] )
+      arr.first.inputs.should == [@control, @audio]
+      arr.last.inputs.should  == [@control, @scalar]
+    end
+    
+    it "should create the correct number of operations" do
+      @op_arr.flatten.size.should eql( @arg_array.flatten.size )
+    end
+  
+    it "should replicate the array passed" do
+      last = lambda do |i| 
+        if i.instance_of?( BinaryOpUGen) 
+          i.inputs.first.should == @audio
+          i.inputs.last 
+        else 
+          i.map{ |e| last.call(e) } 
+        end
+      end
+      last.call(@op_arr).should == @arg_array
+    end
+    
+    it "should accept numbers as inputs" do
+      arr = BinaryOpUGen.new(:+, @control, [100, 200.0] )
+      arr.first.inputs.should == [@control, 100]
+      arr.last.inputs.should  == [@control, 200.0]
+      BinaryOpUGen.new(:+, 100, @control ).inputs.should == [100, @control]
+    end
+    
+    it "should accept array as input" do
+      arr = BinaryOpUGen.new(:+, [@audio, @scalar], @control  )
+      arr.first.inputs.should == [@audio, @control]
+      arr.last.inputs.should  == [@scalar, @control]
+    end
+    
+    it "should accept numeric arg as first arg" do
+      arr = BinaryOpUGen.new(:+, 1, @control  )
+      arr.inputs.should == [1, @control]
+    end
+  end
+  
+  describe MulAdd do
+    it do
+      MulAdd.new( @audio, 0.5, 0.5 ).should be_instance_of(MulAdd)
+    end
+
+    it do
+      MulAdd.new( @audio, 0.5, 0.5 ).rate.should   == :audio
+    end
+    
+    it do
+      MulAdd.new( @audio, 0.5, 0.5 ).inputs.should == [@audio, 0.5, 0.5]
+    end
+ 
+    it "should not be instance of MulAdd" do
+      unary_op = mock 'neg'
+      mult     = mock 'mult'
+      minus    = mock 'minus'
+      plus     = mock 'plus'
+      
+      @audio.should_receive( :neg ).and_return( unary_op )
+      @audio.should_receive( :* ).and_return( mult )
+      add = mock( '0.5', :- => minus, :zero? => false )
+      @audio.should_receive( :+ ).and_return( plus )
+      
+      MulAdd.new( @audio, 0, 0.5 ).should be_instance_of( Float )
+      MulAdd.new( @audio, 1, 0 ).should   == @audio
+      MulAdd.new( @audio, -1, 0 ).should  == unary_op
+      MulAdd.new( @audio, 0.5, 0 ).should == mult
+      MulAdd.new( @audio, -1, add ).should == minus
+      MulAdd.new( @audio, 1, 0.5 ).should == plus
+    end
+    
+    it "should accept ugens" do
+      MulAdd.new( @audio, @audio, 1 ).should be_instance_of(MulAdd)
+      MulAdd.new( @audio, @audio, @scalar ).should be_instance_of(MulAdd)
+      
+      bin_op_ugen = mock 'binary op ugen'
+      @audio.stub!( :* ).and_return bin_op_ugen
+      MulAdd.new( @audio, @audio, 0 ).should == bin_op_ugen
+    end
+        
+  end
+  
+end
+