mutant 0.5.17 → 0.5.18

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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Noop, 'cbase' do
-  let(:source) { '::A' }
-
-  let(:mutations) do
-    mutants = []
-    mutants << 'nil'
-    mutants << 'A'
-  end
-
-  it_should_behave_like 'a mutator'
-end

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

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::ConditionalLoop do
-
-  context 'with empty body' do
-    let(:source) { 'while true; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'while true; raise; end'
-      mutations << 'while false; end'
-      mutations << 'while nil; end'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with while statement' do
-    let(:source) { 'while true; foo; bar; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'while true; bar; end'
-      mutations << 'while true; foo; end'
-      mutations << 'while true; end'
-      mutations << 'while false; foo; bar; end'
-      mutations << 'while nil;   foo; bar; end'
-      mutations << 'while true;  foo; nil; end'
-      mutations << 'while true;  nil; bar; end'
-      mutations << 'while true;  raise; end'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with until statement' do
-    let(:source) { 'until true; foo; bar; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'until true; bar; end'
-      mutations << 'until true; foo; end'
-      mutations << 'until true; end'
-      mutations << 'until false; foo; bar; end'
-      mutations << 'until nil;   foo; bar; end'
-      mutations << 'until true;  foo; nil; end'
-      mutations << 'until true;  nil; bar; end'
-      mutations << 'until true;  raise; end'
-      mutations << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

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

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Const, 'const' do
-  let(:source) { 'A::B::C' }
-
-  let(:mutations) do
-    mutants = []
-    mutants << 'nil'
-    mutants << 'B::C'
-    mutants << 'C'
-  end
-
-  it_should_behave_like 'a mutator'
-end

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

@@ -1,171 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, 'def' do
-  context 'empty' do
-    let(:source) { 'def foo; end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'def foo; raise; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'empty rescue body' do
-    let(:source) { "def foo\nfoo\nrescue\nend" }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'def foo; raise; end'
-      mutations << 'def foo; nil; rescue; end'
-      mutations << 'def foo; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with no arguments' do
-    let(:source) { 'def foo; true; false; end' }
-
-    let(:mutations) do
-      mutations = []
-
-      # Mutation of each statement in block
-      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; true; end'
-      mutations << 'def foo; false; end'
-
-      # Remove all statements
-      mutations << 'def foo; end'
-
-      mutations << 'def foo; raise; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with arguments' do
-    let(:source) { 'def foo(a, b); end' }
-
-    let(:mutations) do
-      mutations = []
-
-      # Deletion of each argument
-      mutations << 'def foo(a); end'
-      mutations << 'def foo(b); end'
-
-      # Deletion of all arguments
-      mutations << 'def foo; end'
-
-      # Rename each argument
-      mutations << 'def foo(a__mutant__, b); end'
-      mutations << 'def foo(a, b__mutant__); end'
-
-      # Mutation of body
-      mutations << 'def foo(a, b); raise; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with argument beginning in an underscore' do
-    let(:source) { 'def foo(_unused); end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'def foo(_unused); raise; end'
-      mutations << 'def foo; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'with optional argument beginning in an underscore' do
-    let(:source) { 'def foo(_unused = true); end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'def foo(_unused = nil); end'
-      mutations << 'def foo(_unused = false); end'
-      mutations << 'def foo(_unused = true); raise; end'
-      mutations << 'def foo(_unused); end'
-      mutations << 'def foo; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'default argument' do
-    let(:source) { 'def foo(a = true); end' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'def foo(a); end'
-      mutations << 'def foo(); end'
-      mutations << 'def foo(a = false); end'
-      mutations << 'def foo(a = nil); end'
-      mutations << 'def foo(a__mutant__ = true); end'
-      mutations << 'def foo(a = true); raise; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'define on singleton' do
-    let(:source) { 'def self.foo; true; false; end' }
-
-    let(:mutations) do
-      mutations = []
-
-      # Body presence mutations
-      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; true; end'
-      mutations << 'def self.foo; false; end'
-
-      # Remove all statements
-      mutations << 'def self.foo; end'
-
-      mutations << 'def self.foo; raise; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'define on singleton with argument' do
-
-    let(:source) { 'def self.foo(a, b); end' }
-
-    let(:mutations) do
-      mutations = []
-
-      # Deletion of each argument
-      mutations << 'def self.foo(a); end'
-      mutations << 'def self.foo(b); end'
-
-      # Deletion of all arguments
-      mutations << 'def self.foo; end'
-
-      # Rename each argument
-      mutations << 'def self.foo(a__mutant__, b); end'
-      mutations << 'def self.foo(a, b__mutant__); end'
-
-      # Mutation of body
-      mutations << 'def self.foo(a, b); raise; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

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

@@ -1,14 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Generic, 'defined?' do
-  let(:source) { 'defined?(foo)' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << 'defined?(nil)'
-  end
-
-  it_should_behave_like 'a mutator'
-end

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

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Dstr, 'dstr' do
-  let(:source)  { '"foo#{bar}baz"' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << '"#{nil}#{bar}baz"'
-    mutations << '"foo#{bar}#{nil}"'
-    mutations << '"foo#{nil}baz"'
-    mutations << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

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

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

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

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Generic, 'ensure' do
-  let(:source) { 'begin; rescue; ensure; true; end' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << 'begin; rescue; ensure; false; end'
-    mutations << 'begin; rescue; ensure; nil; end'
-    mutations << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

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

@@ -1,77 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator, 'if' do
-  context 'with if and else branches' do
-    let(:source) { 'if :condition; true; else false; end' }
-
-    let(:mutations) do
-      mutants = []
-
-      # mutations of condition
-      mutants << 'if :condition__mutant__; 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'
-
-      mutants << 'nil'
-    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'
-      mutants << 'if nil;        true;  end'
-      mutants << 'nil'
-    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 :condition__mutant__; 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'
-      mutants << 'nil'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

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

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Kwbegin, 'kwbegin' do
-  let(:source) { 'begin; true; end' }
-
-  let(:mutations) do
-    mutations = []
-    mutations << 'begin; false; end'
-    mutations << 'begin; nil; end'
-    mutations << 'nil'
-  end
-
-  it_should_behave_like 'a mutator'
-end

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

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::Literal, 'array' do
-
-  context 'on one item' do
-    let(:source) { '[true]' }
-
-    let(:mutations) do
-      mutations = []
-      mutations << 'nil'
-      mutations << 'true'
-      mutations << '[false]'
-      mutations << '[nil]'
-      mutations << '[]'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'on arrays with more than one item' do
-    let(:source) { '[true, false]' }
-
-    let(:mutations) do
-      mutations = []
-
-      # Literal replaced with nil
-      mutations << 'nil'
-
-      # Mutation of each element in array
-      mutations << '[nil, false]'
-      mutations << '[false, false]'
-      mutations << '[true, nil]'
-      mutations << '[true, true]'
-
-      # Remove each element of array once
-      mutations << '[true]'
-      mutations << '[false]'
-
-      # Empty array
-      mutations << '[]'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end