mutant 0.5.17 → 0.5.18

data/spec/unit/mutant/mutator/node/named_value/variable_assignment_spec.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::NamedValue::VariableAssignment, 'mutations' do
-  context 'global variable' do
-    let(:source) { '$a = true' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << '$a__mutant__ = true'
-      mutations << '$a = false'
-      mutations << '$a = nil'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'class variable' do
-    let(:source) { '@@a = true' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << '@@a__mutant__ = true'
-      mutations << '@@a = false'
-      mutations << '@@a = nil'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'instance variable' do
-    let(:source) { '@a = true' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << '@a__mutant__ = true'
-      mutations << '@a = false'
-      mutations << '@a = nil'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'local variable' do
-    let(:source) { 'a = true' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'a__mutant__ = true'
-      mutations << 'a = false'
-      mutations << 'a = nil'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

data/spec/unit/mutant/mutator/node/nthref_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, 'nthref' do
-  context '$1' do
-    let(:source)    { '$1'   }
-    let(:mutations) { ['$2'] }
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context '$2' do
-    let(:source)    { '$2' }
-    let(:mutations) { ['$3', '$1']   }
-
-    it_should_behave_like 'a mutator'
-  end
-end

data/spec/unit/mutant/mutator/node/op_assgn_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Generic, 'op_asgn' do
-  let(:source) { '@a.b += 1' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << '@a.b += -1'
-    mutations << '@a.b += 2'
-    mutations << '@a.b += 0'
-    mutations << '@a.b += nil'
-    mutations << 'nil.b += 1'
-    mutations << 'nil'
-    # TODO: fix invalid AST
-    #   This should not get emitted as invalid AST with valid unparsed source
-    mutations << s(:op_asgn, s(:ivar, :@a), :+, s(:int, 1))
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/or_asgn_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::OpAsgn, 'or_asgn' do
-  let(:source)  { 'a ||= 1' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << 'a__mutant__ ||= 1'
-    mutations << 'a ||= nil'
-    mutations << 'a ||= 0'
-    mutations << 'a ||= -1'
-    mutations << 'a ||= 2'
-    mutations << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/redo_spec.rb

@@ -1,10 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Generic, 'redo' do
-  let(:source)    { 'redo' }
-  let(:mutations) { []     }
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/rescue_spec.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Generic, 'rescue' do
-
-  context 'multiple exception selectors and assignment' do
-    let(:source) { 'begin; rescue ExceptionA, ExceptionB => error; true; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'begin; rescue ExceptionA, ExceptionB; true; end'
-      mutations << 'begin; rescue ExceptionA, ExceptionB => error; false; end'
-      mutations << 'begin; rescue ExceptionA, ExceptionB => error; nil; end'
-      mutations << 'begin; rescue ExceptionA => error; true; end'
-      mutations << 'begin; rescue ExceptionB => error; true; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'single exception selector and assignment' do
-    let(:source) { 'begin; rescue SomeException => error; true; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'begin; rescue SomeException; true; end'
-      mutations << 'begin; rescue SomeException => error; false; end'
-      mutations << 'begin; rescue SomeException => error; nil; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'no exection selector and assignment' do
-    let(:source) { 'begin; rescue => error; true end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'begin; rescue => error; false; end'
-      mutations << 'begin; rescue => error; nil; end'
-      mutations << 'begin; rescue; true; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'no exection selector and no assignment' do
-    let(:source) { 'begin; rescue; true end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'begin; rescue; false; end'
-      mutations << 'begin; rescue; nil; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

data/spec/unit/mutant/mutator/node/restarg_spec.rb

@@ -1,18 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Restarg, 'restarg' do
-  let(:source) { 'foo(*bar)' }
-
-  let(:mutations) do
-    mutants = []
-    mutants << 'foo'
-    mutants << 'foo(nil)'
-    mutants << 'foo(bar)'
-    mutants << 'foo(*nil)'
-    mutants << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/mutator/node/return_spec.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, 'return' do
-
-  context 'return without value' do
-    let(:source) { 'return' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'return with value' do
-    let(:source) { 'return foo' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'return nil'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-end

data/spec/unit/mutant/mutator/node/send_spec.rb

@@ -1,382 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-# FIXME: This spec needs to be structured better!
-describe Mutant::Mutator, 'send' do
-
-  context 'when using #reverse_each' do
-    let(:source) { 'reverse_each' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'each'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'when using #reverse_map' do
-    let(:source) { 'reverse_map' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'map'
-      mutations << 'each'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'when using #map' do
-    let(:source) { 'map' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'each'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'when using #==' do
-    let(:source) { 'foo == bar' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'bar'
-      mutations << 'nil == bar'
-      mutations << 'foo == nil'
-      mutations << 'nil'
-      mutations << 'foo.eql?(bar)'
-      mutations << 'foo.equal?(bar)'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'when using #gsub' do
-    let(:source) { 'foo.gsub(a, b)' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'foo.gsub(a)'
-      mutations << 'foo.gsub(b)'
-      mutations << 'foo.gsub'
-      mutations << 'foo.sub(a, b)'
-      mutations << 'foo.gsub(a, nil)'
-      mutations << 'foo.gsub(nil, b)'
-      mutations << 'nil.gsub(a, b)'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'when using Kernel#send' do
-    let(:source) { 'foo.send(bar)' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo.send'
-      mutations << 'foo.public_send(bar)'
-      mutations << 'bar'
-      mutations << 'foo'
-      mutations << 'foo.send(nil)'
-      mutations << 'nil.send(bar)'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'inside op assign' do
-    let(:source) { 'self.foo ||= expression' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'self.foo ||= nil'
-      mutations << 'nil.foo ||= expression'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'attribute assign' do
-
-    context 'to self' do
-      let(:source) { 'self.bar=baz' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'nil'
-        mutations << 'self.bar=nil'
-        mutations << 'self'
-        mutations << 'self.bar'
-        mutations << 'baz'
-        # This one could probably be removed
-        mutations << 'nil.bar=baz'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'to other object' do
-      let(:source) { 'foo.bar=baz' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'foo'
-        mutations << 'nil'
-        mutations << 'foo.bar=nil'
-        mutations << 'foo.bar'
-        mutations << 'baz'
-        # This one could probably be removed
-        mutations << 'nil.bar=baz'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-  end
-
-  context 'index assign' do
-    let(:source) { 'foo[bar]=baz' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with only a splat arg' do
-    let(:source) { 'foo(*bar)' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'foo(nil)'
-      mutations << 'foo(bar)'
-      mutations << 'foo(*nil)'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with only a block arg' do
-    let(:source) { 'foo(&bar)' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'single splat arg splat' do
-    let(:source) { 'foo[*bar]' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'foo'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with self as' do
-    context 'implicit' do
-      let(:source) { 'foo' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'nil'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'explict receiver' do
-      let(:source) { 'self.foo' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'foo'
-        mutations << 'self'
-        mutations << 'nil.foo'
-        mutations << 'nil'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'explicit receiver with keyword message name' do
-      Unparser::Constants::KEYWORDS.each do |keyword|
-        context "with keyword: #{keyword}" do
-          let(:source) { "self.#{keyword}" }
-          let(:mutations) do
-            ['self']
-          end
-        end
-      end
-    end
-  end
-
-  context 'without arguments' do
-
-    context 'to some object' do
-      let(:source) { 'foo.bar' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'foo'
-        mutations << 'nil.bar'
-        mutations << 'nil'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'to self.class.foo' do
-      let(:source) { 'self.class.foo' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'self.class'
-        mutations << 'self.foo'
-        mutations << 'nil.class.foo'
-        mutations << 'nil.foo'
-        mutations << 'nil'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-  end
-
-  context 'with arguments' do
-
-    context 'one argument' do
-      let(:source) { 'foo(nil)' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'foo'
-        mutations << 'nil'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'with explicit self as receiver' do
-      let(:source) { 'self.foo(nil)' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'self'
-        mutations << 'self.foo'
-        mutations << 'foo(nil)'
-        mutations << 'nil'
-        mutations << 'nil.foo(nil)'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'to some object with keyword in method name' do
-      Unparser::Constants::KEYWORDS.each do |keyword|
-        context "with keyword #{keyword}" do
-          let(:source) { "foo.#{keyword}(nil)" }
-
-          let(:mutations) do
-            mutations = []
-            mutations << "foo.#{keyword}"
-            mutations << 'foo'
-            mutations << "nil.#{keyword}(nil)"
-            mutations << 'nil'
-          end
-
-          it_should_behave_like 'a mutator'
-        end
-      end
-    end
-
-    context 'two arguments' do
-      let(:source) { 'foo(nil, nil)' }
-
-      let(:mutations) do
-        mutations = []
-        mutations << 'foo()'
-        mutations << 'foo(nil)'
-        mutations << 'nil'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'binary operator methods' do
-      context 'nested' do
-        let(:source) { '(left - right) / foo' }
-
-        let(:mutations) do
-          mutations = []
-          mutations << 'foo'
-          mutations << '(left - right)'
-          mutations << 'left / foo'
-          mutations << 'right / foo'
-          mutations << '(left - right) / nil'
-          mutations << '(left - nil) / foo'
-          mutations << '(nil - right) / foo'
-          mutations << 'nil / foo'
-          mutations << 'nil'
-        end
-
-        it_should_behave_like 'a mutator'
-      end
-
-      (Mutant::BINARY_METHOD_OPERATORS - [:==, :eql?]).each do |operator|
-        context 'on literal scalar arguments' do
-          let(:source) { "true #{operator} false" }
-
-          let(:mutations) do
-            mutations = []
-            mutations << "false #{operator} false"
-            mutations << "nil   #{operator} false"
-            mutations << "true  #{operator} true"
-            mutations << "true  #{operator} nil"
-            mutations << 'true'
-            mutations << 'false'
-            mutations << 'nil'
-          end
-
-          it_should_behave_like 'a mutator'
-        end
-
-        context 'on non literal scalar arguments' do
-          let(:source) { "left #{operator} right" }
-          let(:mutations) do
-            mutations = []
-            mutations << 'left'
-            mutations << 'right'
-            mutations << "left #{operator} nil"
-            mutations << "nil #{operator} right"
-            mutations << 'nil'
-          end
-
-          it_should_behave_like 'a mutator'
-        end
-      end
-    end
-  end
-end