mutant 0.2.20 → 0.3.0.beta2

data/spec/unit/mutant/matcher/namespace/each_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Mutant::Matcher::Namespace, '#each' do
+  subject { object.each { |item| yields << item } }
+
+  let(:yields) { []                                    }
+  let(:object) { described_class.new(TestApp::Literal) }
+
+  let(:singleton_a) { mock('SingletonA', :name => 'TestApp::Literal') }
+  let(:singleton_b) { mock('SingletonB', :name => 'TestApp::Foo')     }
+  let(:subject_a)   { mock('SubjectA')                                }
+  let(:subject_b)   { mock('SubjectB')                                }
+
+  before do
+    Mutant::Matcher::Methods::Singleton.stub(:each).with(singleton_a).and_yield(subject_a)
+    Mutant::Matcher::Methods::Instance.stub(:each).with(singleton_a).and_yield(subject_b)
+    ObjectSpace.stub(:each_object => [singleton_a, singleton_b])
+  end
+
+  context 'with no block' do
+    subject { object.each }
+
+    it { should be_instance_of(to_enum.class) }
+
+    if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+      pending 'FIX RBX rspec? BUG HERE'
+    else
+      it 'yields the expected values' do
+        subject.to_a.should eql(object.to_a)
+      end
+    end
+  end
+
+  it 'should yield subjects' do
+    expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
+  end
+end

data/spec/unit/mutant/mutator/node/begin/mutation_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'begin' do
+
+  # This mutation and only this mutation can result in
+  # and empty emit that is parsed into nil, unparser cannot
+  # handle this so we guard this here!
+  def generate(node)
+    return '' if node.nil?
+    super
+  end
+
+  let(:source) { "true\nfalse" }
+
+  let(:mutations) do
+    mutations = []
+
+    # Mutation of each statement in block
+    mutations << "true\ntrue"
+    mutations << "false\nfalse"
+    mutations << "nil\nfalse"
+    mutations << "true\nnil"
+
+    # Remove statement in block
+    mutations << 'true'
+    mutations << 'false'
+
+    # Replace block with empty
+    mutations << ''
+  end
+
+  it_should_behave_like 'a mutator'
+end

data/spec/unit/mutant/mutator/node/block/mutation_spec.rb

@@ -1,35 +1,63 @@
 require 'spec_helper'
 
 describe Mutant::Mutator, 'block' do
-
-  context 'with more than one statement' do
-    let(:source) { "self.foo\nself.bar" }
+  context 'with block' do
+    let(:source) { 'foo() { a; b }' }
 
     let(:mutations) do
       mutations = []
+      mutations << 'foo { a }'
+      mutations << 'foo { b }'
+      mutations << 'foo {}'
+      mutations << 'foo'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'with block args' do
 
-      # Mutation of each statement in block
-      mutations << "foo\nself.bar".to_ast
-      mutations << "self.foo\nbar".to_ast
+    let(:source) { 'foo { |a, b| }' }
 
-      # Remove statement in block
-      mutations << Rubinius::AST::Block.new(1, ['self.foo'.to_ast])
-      mutations << Rubinius::AST::Block.new(1, ['self.bar'.to_ast])
-      mutations << Rubinius::AST::Block.new(1, ['nil'.to_ast])
+    before do
+      Mutant::Random.stub(:hex_string => :random)
+    end
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'foo'
+      mutations << 'foo { |a, b| ::Object.new }'
+      mutations << 'foo { |a, srandom| }'
+      mutations << 'foo { |srandom, b| }'
+      mutations << 'foo { |a| }'
+      mutations << 'foo { |b| }'
+      mutations << 'foo { || }'
     end
 
     it_should_behave_like 'a mutator'
   end
 
+  context 'with block pattern args' do
 
+    before do
+      Mutant::Random.stub(:hex_string => :random)
+    end
 
-  context 'with one statement' do
-    let(:node) { Rubinius::AST::Block.new(1, ['self.foo'.to_ast]) }
+    let(:source) { 'foo { |(a, b), c| }' }
 
     let(:mutations) do
       mutations = []
-      mutations << Rubinius::AST::Block.new(1, ['foo'.to_ast])
-      mutations << Rubinius::AST::Block.new(1, ['nil'.to_ast])
+      mutations << 'foo { || }'
+      mutations << 'foo { |a, b, c| }'
+      mutations << 'foo { |(a, b), c| ::Object.new }'
+      mutations << 'foo { |(a), c| }'
+      mutations << 'foo { |(b), c| }'
+      mutations << 'foo { |(a, b)| }'
+      mutations << 'foo { |c| }'
+      mutations << 'foo { |(srandom, b), c| }'
+      mutations << 'foo { |(a, srandom), c| }'
+      mutations << 'foo { |(a, b), srandom| }'
+      mutations << 'foo'
     end
 
     it_should_behave_like 'a mutator'

data/spec/unit/mutant/mutator/node/case/mutation_spec.rb

@@ -0,0 +1,319 @@
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::Case do
+  let(:random_string) { 'random' }
+
+  before do
+    Mutant::Random.stub(:hex_string => random_string)
+  end
+
+  context 'with multiple when branches' do
+    let(:source) do
+      <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+    end
+
+    let(:mutations) do
+      mutations = []
+
+      # Presence of branches
+      mutations << <<-RUBY
+        case :condition
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :baz
+          :barbaz
+        end
+      RUBY
+
+      # Mutations of condition
+      mutations << <<-RUBY
+        case nil
+        when :foo
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :srandom
+        when :foo
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+
+      # Mutations of branch bodies
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          nil
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :srandom
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :baz
+          :srandom
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :baz
+          nil
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          :srandom
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          nil
+        end
+      RUBY
+
+      # Mutations of when conditions
+      mutations << <<-RUBY
+        case :condition
+        when :srandom
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when nil
+          :foo
+        when :bar, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :srandom, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when nil, :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, nil
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar, :srandom
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :baz
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        when :bar
+          :barbaz
+        else
+          :else
+        end
+      RUBY
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'with one when branch' do
+    let(:source) do
+      <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        else
+          :else
+        end
+      RUBY
+    end
+
+    let(:mutations) do
+      mutations = []
+
+      # Presence of branches
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        end
+      RUBY
+
+      # Mutations of condition
+      mutations << <<-RUBY
+        case nil
+        when :foo
+          :foo
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :srandom
+        when :foo
+          :foo
+        else
+          :else
+        end
+      RUBY
+
+      # Mutations of branch bodies
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          nil
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :srandom
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        else
+          :srandom
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when :foo
+          :foo
+        else
+          nil
+        end
+      RUBY
+
+      # Mutations of when conditions
+      mutations << <<-RUBY
+        case :condition
+        when :srandom
+          :foo
+        else
+          :else
+        end
+      RUBY
+      mutations << <<-RUBY
+        case :condition
+        when nil
+          :foo
+        else
+          :else
+        end
+      RUBY
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end

data/spec/unit/mutant/mutator/node/define/mutation_spec.rb

@@ -1,20 +1,22 @@
 require 'spec_helper'
 
-describe Mutant::Mutator, 'define' do
+describe Mutant::Mutator, 'def' do
 
   context 'with no arguments' do
-    let(:source) { 'def foo; self.bar; self.baz; end' }
+    let(:source) { 'def foo; true; false; end' }
 
     let(:mutations) do
       mutations = []
 
       # Mutation of each statement in block
-      mutations << 'def foo; bar; self.baz; end'
-      mutations << 'def foo; self.bar; baz; end'
+      mutations << 'def foo; true; true; end'
+      mutations << 'def foo; false; false; end'
+      mutations << 'def foo; true; nil; end'
+      mutations << 'def foo; nil; false; end'
 
       # Remove statement in block
-      mutations << 'def foo; self.baz; end'
-      mutations << 'def foo; self.bar; end'
+      mutations << 'def foo; true; end'
+      mutations << 'def foo; false; end'
 
       # Remove all statements
       mutations << 'def foo; end'
@@ -24,7 +26,7 @@ describe Mutant::Mutator, 'define' do
   end
 
   context 'with arguments' do
-    let(:source) { 'def foo(a, b); nil; end' }
+    let(:source) { 'def foo(a, b); end' }
 
     before do
       Mutant::Random.stub(:hex_string => 'random')
@@ -34,29 +36,29 @@ describe Mutant::Mutator, 'define' do
       mutations = []
 
       # Deletion of each argument
-      mutations << 'def foo(a); nil; end'
-      mutations << 'def foo(b); nil; end'
+      mutations << 'def foo(a); end'
+      mutations << 'def foo(b); end'
 
       # Deletion of all arguments
-      mutations << 'def foo; nil; end'
+      mutations << 'def foo; end'
 
       # Rename each argument
-      mutations << 'def foo(srandom, b); nil; end'
-      mutations << 'def foo(a, srandom); nil; end'
+      mutations << 'def foo(srandom, b); end'
+      mutations << 'def foo(a, srandom); end'
 
       # Mutation of body
-      mutations << 'def foo(a, b); Object.new; end'
+      mutations << 'def foo(a, b); ::Object.new; end'
     end
 
     it_should_behave_like 'a mutator'
   end
 
-  context 'with arguments beginning with an underscore' do
+  context 'with argument beginning in an underscore' do
     let(:source) { 'def foo(_unused); end' }
 
     let(:mutations) do
       mutations = []
-      mutations << 'def foo(_unused); Object.new; end'
+      mutations << 'def foo(_unused); ::Object.new; end'
       mutations << 'def foo; end'
     end
 
@@ -64,38 +66,40 @@ describe Mutant::Mutator, 'define' do
   end
 
   context 'default argument' do
-    let(:source) { 'def foo(a = "literal"); end' }
+    let(:source) { 'def foo(a = true); end' }
 
     before do
       Mutant::Random.stub(:hex_string => 'random')
     end
 
-    let(:mutations) do 
+    let(:mutations) do
       mutations = []
       mutations << 'def foo(a); end'
       mutations << 'def foo(); end'
-      mutations << 'def foo(a = "random"); end'
+      mutations << 'def foo(a = false); end'
       mutations << 'def foo(a = nil); end'
-      mutations << 'def foo(a = "literal"); Object.new; end'
-      mutations << 'def foo(srandom = "literal"); nil; end'
+      mutations << 'def foo(srandom = true); end'
+      mutations << 'def foo(a = true); ::Object.new; end'
     end
 
     it_should_behave_like 'a mutator'
   end
 
   context 'define on singleton' do
-    let(:source) { 'def self.foo; self.bar; self.baz; end' }
+    let(:source) { 'def self.foo; true; false; end' }
 
     let(:mutations) do
       mutations = []
 
       # Body presence mutations
-      mutations << 'def self.foo; bar; self.baz; end' 
-      mutations << 'def self.foo; self.bar; baz; end' 
-     
+      mutations << 'def self.foo; false; false; end'
+      mutations << 'def self.foo; true; true; end'
+      mutations << 'def self.foo; true; nil; end'
+      mutations << 'def self.foo; nil; false; end'
+
       # Body presence mutations
-      mutations << 'def self.foo; self.bar; end'
-      mutations << 'def self.foo; self.baz; end'
+      mutations << 'def self.foo; true; end'
+      mutations << 'def self.foo; false; end'
 
       # Remove all statements
       mutations << 'def self.foo; end'
@@ -127,7 +131,7 @@ describe Mutant::Mutator, 'define' do
       mutations << 'def self.foo(a, srandom); nil; end'
 
       # Mutation of body
-      mutations << 'def self.foo(a, b); Object.new; end'
+      mutations << 'def self.foo(a, b); ::Object.new; end'
     end
 
     it_should_behave_like 'a mutator'

data/spec/unit/mutant/mutator/node/if/mutation_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Mutant::Mutator, 'if' do
+
+  before do
+    Mutant::Random.stub(:hex_string => 'random')
+  end
+
+  context 'with if and else branches' do
+    let(:source) { 'if :condition; true; else false; end' }
+
+    let(:mutations) do
+      mutants = []
+
+      # mutations of condition
+      mutants << 'if :srandom;    true; else false; end'
+      mutants << 'if !:condition; true; else false; end'
+      mutants << 'if nil;         true; else false; end'
+      mutants << 'if true;        true; else false; end'
+      mutants << 'if false;       true; else false; end'
+
+      # Deleted else branch
+      mutants << 'if :condition; true end'
+
+      # Deleted if branch resuting in unless rendering
+      mutants << 'unless :condition; false; end'
+
+      # Deleted if branch with promoting else branch to if branch
+      mutants << 'if :condition; false end'
+
+      # mutations of if body
+      mutants << 'if :condition; false; else false; end'
+      mutants << 'if :condition; nil;   else false; end'
+
+      # mutations of else body
+      mutants << 'if :condition; true;  else true;  end'
+      mutants << 'if :condition; true;  else nil;   end'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'if with one branch' do
+    let(:source) { 'if condition; true; end' }
+
+    let(:mutations) do
+      mutants = []
+      mutants << 'if !condition; true;  end'
+      mutants << 'if condition;  false; end'
+      mutants << 'if condition;  nil;   end'
+      mutants << 'if true;       true;  end'
+      mutants << 'if false;      true;  end'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'unless with one branch' do
+    let(:source) { 'unless :condition; true; end' }
+
+    let(:mutations) do
+      mutants = []
+      mutants << 'unless !:condition; true;  end'
+      mutants << 'unless :srandom;    true;  end'
+      mutants << 'unless nil;         true;  end'
+      mutants << 'unless :condition;  false; end'
+      mutants << 'unless :condition;  nil;   end'
+      mutants << 'unless true;        true;  end'
+      mutants << 'unless false;       true;  end'
+      mutants << 'if     :condition;  true;  end'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end

data/spec/unit/mutant/mutator/node/literal/fixnum_spec.rb

@@ -6,7 +6,7 @@ describe Mutant::Mutator::Node::Literal, 'fixnum' do
   let(:source) { '10' }
 
   let(:mutations) do
-    %W(nil 0 1 #{random_fixnum} -10)
+    %W(nil 0 1 #{random_fixnum} -10 9 11)
   end
 
   before do

data/spec/unit/mutant/mutator/node/literal/hash_spec.rb

@@ -20,8 +20,8 @@ describe Mutant::Mutator::Node::Literal, 'hash' do
     mutations << '{ true  => true  ,  false => nil   }'
 
     # Remove each key once
-    mutations << '{ true => true }' 
-    mutations << '{ false => false }' 
+    mutations << '{ true => true }'
+    mutations << '{ false => false }'
 
     # Empty hash
     mutations << '{}'