mutant 0.3.0.rc1 → 0.3.0.rc2

data/spec/unit/mutant/{cli/class_methods/new_spec.rb → cli_new_spec.rb}

@@ -13,7 +13,6 @@ end
 shared_examples_for 'a cli parser' do
   subject { cli.config }
 
-  its(:filter)   { should eql(expected_filter)   }
   its(:strategy) { should eql(expected_strategy) }
   its(:reporter) { should eql(expected_reporter) }
   its(:matcher)  { should eql(expected_matcher)  }
@@ -24,16 +23,16 @@ describe Mutant::CLI, '.new' do
   let(:time)   { Time.now        }
 
   before do
-    Time.stub(:now => time)
+    Time.stub(now: time)
   end
 
   # Defaults
-  let(:expected_filter)   { Mutant::Mutation::Filter::ALL      }
-  let(:expected_strategy) { Mutant::Strategy::Rspec.new        }
+  let(:expected_filter)   { Mutant::Predicate::TAUTOLOGY       }
+  let(:expected_strategy) { Mutant::Strategy::Rspec.new(0)     }
   let(:expected_reporter) { Mutant::Reporter::CLI.new($stdout) }
 
-  let(:ns)    { Mutant::CLI::Classifier }
-  let(:cache) { Mutant::Cache.new       }
+  let(:ns)    { Mutant::Matcher   }
+  let(:cache) { Mutant::Cache.new }
 
   let(:cli) { object.new(arguments) }
 
@@ -56,8 +55,8 @@ describe Mutant::CLI, '.new' do
   end
 
   context 'with many strategy flags' do
-    let(:arguments) { %w(--static-fail --rspec TestApp) }
-    let(:expected_matcher) { Mutant::CLI::Classifier::Namespace::Flat.new(Mutant::Cache.new, 'TestApp') }
+    let(:arguments) { %w(--rspec --rspec TestApp) }
+    let(:expected_matcher) { Mutant::Matcher::Scope.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
   end
@@ -65,7 +64,7 @@ describe Mutant::CLI, '.new' do
   context 'without arguments' do
     let(:arguments) { [] }
 
-    let(:expected_message) { 'No strategy was set!' }
+    let(:expected_message) { 'No matchers given' }
 
     it_should_behave_like 'an invalid cli run'
   end
@@ -79,15 +78,15 @@ describe Mutant::CLI, '.new' do
 
   context 'with explicit method matcher' do
     let(:arguments)        { %w(--rspec TestApp::Literal#float) }
-    let(:expected_matcher) { ns::Method.new(cache, 'TestApp::Literal#float') }
+    let(:expected_matcher) { ns::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:float)) }
 
     it_should_behave_like 'a cli parser'
   end
 
   context 'with debug flag' do
-    let(:matcher)          { '::TestApp*'                                 }
-    let(:arguments)        { %W(--debug --rspec #{matcher})               }
-    let(:expected_matcher) { ns::Namespace::Recursive.new(cache, matcher) }
+    let(:matcher)          { '::TestApp*'                      }
+    let(:arguments)        { %W(--debug --rspec #{matcher})    }
+    let(:expected_matcher) { ns::Namespace.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
 
@@ -97,9 +96,9 @@ describe Mutant::CLI, '.new' do
   end
 
   context 'with zombie flag' do
-    let(:matcher)          { '::TestApp*'                                 }
-    let(:arguments)        { %W(--zombie --rspec #{matcher})              }
-    let(:expected_matcher) { ns::Namespace::Recursive.new(cache, matcher) }
+    let(:matcher)          { '::TestApp*'                      }
+    let(:arguments)        { %W(--zombie --rspec #{matcher})   }
+    let(:expected_matcher) { ns::Namespace.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
 
@@ -109,9 +108,9 @@ describe Mutant::CLI, '.new' do
   end
 
   context 'with namespace matcher' do
-    let(:matcher)          { '::TestApp*'                                 }
-    let(:arguments)        { %W(--rspec #{matcher})                       }
-    let(:expected_matcher) { ns::Namespace::Recursive.new(cache, matcher) }
+    let(:matcher)          { '::TestApp*'                      }
+    let(:arguments)        { %W(--rspec #{matcher})            }
+    let(:expected_matcher) { ns::Namespace.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
   end
@@ -122,13 +121,13 @@ describe Mutant::CLI, '.new' do
 
     let(:filters) do
       [
-        Mutant::Mutation::Filter::Code.new('faa'),
-        Mutant::Mutation::Filter::Code.new('bbb'),
+        Mutant::Predicate::Attribute.new(:code, 'faa'),
+        Mutant::Predicate::Attribute.new(:code, 'bbb'),
       ]
     end
 
-    let(:expected_matcher) { ns::Method.new(cache, 'TestApp::Literal#float')  }
-    let(:expected_filter)  { Mutant::Mutation::Filter::Whitelist.new(filters) }
+    let(:expected_matcher) { ns::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:float))  }
+    let(:expected_filter)  { Mutant::Predicate::Whitelist.new(filters) }
 
     it_should_behave_like 'a cli parser'
   end

data/spec/unit/mutant/{cli/class_methods/run_spec.rb → cli_run_spec.rb}

@@ -5,16 +5,16 @@ require 'spec_helper'
 describe Mutant::CLI, '.run' do
   subject { object.run(argv) }
 
-  let(:object)     { described_class                                 }
-  let(:argv)       { double('ARGV')                                  }
-  let(:attributes) { double('Options')                               }
-  let(:runner)     { double('Runner', :success? => success)          }
-  let(:config)     { double('Config')                                }
-  let(:instance)   { double(described_class.name, :config => config) }
+  let(:object)     { described_class                              }
+  let(:argv)       { double('ARGV')                               }
+  let(:attributes) { double('Options')                            }
+  let(:runner)     { double('Runner', success?: success)          }
+  let(:config)     { double('Config')                             }
+  let(:instance)   { double(described_class.name, config: config) }
 
   before do
-    described_class.stub(:new => instance)
-    Mutant::Runner::Config.stub(:run => runner)
+    described_class.stub(new: instance)
+    Mutant::Runner::Config.stub(run: runner)
   end
 
   context 'when runner is successful' do

data/spec/unit/mutant/killer/rspec/class_methods/new_spec.rb

@@ -18,24 +18,24 @@ describe Mutant::Killer::Rspec, '.new' do
   let(:mutation) do
     double(
       'Mutation',
-      :subject => mutation_subject,
-      :should_survive? => false
+      subject: mutation_subject,
+      should_survive?: false
     )
   end
 
   let(:strategy) do
     double(
       'Strategy',
-      :spec_files => ['foo'],
-      :error_stream => $stderr,
-      :output_stream => $stdout
+      spec_files: ['foo'],
+      error_stream: $stderr,
+      output_stream: $stdout
     )
   end
 
   before do
     mutation.stub(:insert)
     mutation.stub(:reset)
-    RSpec::Core::Runner.stub(:run => exit_status)
+    RSpec::Core::Runner.stub(run: exit_status)
   end
 
   context 'when run exits zero' do

data/spec/unit/mutant/killer/success_predicate_spec.rb

@@ -5,13 +5,13 @@ require 'spec_helper'
 describe Mutant::Killer, '#success?' do
   subject { object.success? }
 
-  let(:object)           { class_under_test.new(strategy, mutation)    }
-  let(:strategy)         { double('Strategy')                          }
-  let(:mutation)         { double('Mutation', :success? => kill_state) }
-  let(:kill_state)       { double('Kill State')                        }
+  let(:object)           { class_under_test.new(strategy, mutation) }
+  let(:strategy)         { double('Strategy')                       }
+  let(:mutation)         { double('Mutation', success?: kill_state) }
+  let(:kill_state)       { double('Kill State')                     }
 
   before do
-    kill_state.stub(:freeze => kill_state, :dup => kill_state)
+    kill_state.stub(freeze: kill_state, dup: kill_state)
   end
 
   let(:class_under_test) do

data/spec/unit/mutant/loader/eval/class_methods/run_spec.rb

@@ -11,7 +11,7 @@ describe Mutant::Loader::Eval, '.run' do
   let(:line)   { 1               }
 
   let(:mutation_subject) do
-    double('Subject', :source_path => path, :source_line => line)
+    double('Subject', source_path: path, source_line: line)
   end
 
   let(:source) do

data/spec/unit/mutant/matcher/filter_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mutant::Matcher::Filter do
+  let(:object)    { described_class.new(matcher, predicate) }
+  let(:matcher)   { [:foo, :bar] }
+
+  let(:predicate) { Mutant::Predicate::Attribute::Equality.new(:to_s, 'foo') }
+
+  describe '#each' do
+    subject { object.each { |item| yields << item } }
+
+    let(:yields) { []                 }
+    its(:to_a)   { should eql([:bar]) }
+
+    it_should_behave_like 'an #each method'
+  end
+end

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

@@ -10,10 +10,10 @@ describe Mutant::Matcher::Namespace, '#each' do
 
   let(:cache) { Mutant::Cache.new }
 
-  let(:singleton_a) { double('SingletonA', :name => 'TestApp::Literal') }
-  let(:singleton_b) { double('SingletonB', :name => 'TestApp::Foo')     }
-  let(:subject_a)   { double('SubjectA')                                }
-  let(:subject_b)   { double('SubjectB')                                }
+  let(:singleton_a) { double('SingletonA', name: 'TestApp::Literal') }
+  let(:singleton_b) { double('SingletonB', name: 'TestApp::Foo')     }
+  let(:subject_a)   { double('SubjectA')                             }
+  let(:subject_b)   { double('SubjectB')                             }
 
   before do
     Mutant::Matcher::Methods::Singleton.stub(:each)
@@ -22,7 +22,7 @@ describe Mutant::Matcher::Namespace, '#each' do
     Mutant::Matcher::Methods::Instance.stub(:each)
       .with(cache, singleton_a)
       .and_yield(subject_b)
-    ObjectSpace.stub(:each_object => [singleton_a, singleton_b])
+    ObjectSpace.stub(each_object: [singleton_a, singleton_b])
   end
 
   context 'with no block' do

data/spec/unit/mutant/mutation_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Mutant::Mutation do
+
+  let(:class_under_test) { Class.new(described_class)                                         }
+  let(:object)           { class_under_test.new(mutation_subject, Mutant::NodeHelpers::N_NIL) }
+  let(:mutation_subject) { double('Subject', identification: 'subject', source: 'original')   }
+  let(:node)             { double('Node')                                                     }
+
+  describe '#code' do
+    subject { object.code }
+
+    it { should eql('8771a') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#original_source' do
+    subject { object.original_source }
+
+    it { should eql('original') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#source' do
+    subject { object.source }
+
+    it { should eql('nil') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#identification' do
+
+    subject { object.identification }
+
+    it { should eql('subject:8771a') }
+
+    it_should_behave_like 'an idempotent method'
+  end
+end

data/spec/unit/mutant/mutator/each_spec.rb

@@ -19,7 +19,7 @@ describe Mutant::Mutator, '.each' do
     end
 
     before do
-      Mutant::Random.stub(:hex_string => random_string)
+      Mutant::Random.stub(hex_string: random_string)
     end
 
     it_should_behave_like 'a mutator'

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

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Mutant::Mutator::Node::Generic, 'and_asgn' do
+describe Mutant::Mutator::Node::OpAsgn, 'and_asgn' do
   let(:random_fixnum) { 5        }
   let(:random_string) { 'random' }
 
@@ -16,10 +16,11 @@ describe Mutant::Mutator::Node::Generic, 'and_asgn' do
     mutations << 'a &&= -1'
     mutations << 'a &&= 2'
     mutations << 'a &&= 5'
+    mutations << 'nil'
   end
 
   before do
-    Mutant::Random.stub(:fixnum => random_fixnum, :hex_string => random_string)
+    Mutant::Random.stub(fixnum: random_fixnum, hex_string: random_string)
   end
 
   it_should_behave_like 'a mutator'

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

@@ -12,7 +12,10 @@ describe Mutant::Mutator, 'block' do
       mutations << 'foo { b }'
       mutations << 'foo {}'
       mutations << 'foo { raise }'
+      mutations << 'foo { a; nil }'
+      mutations << 'foo { nil; b }'
       mutations << 'foo'
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'
@@ -23,7 +26,7 @@ describe Mutant::Mutator, 'block' do
     let(:source) { 'foo { |a, b| }' }
 
     before do
-      Mutant::Random.stub(:hex_string => 'random')
+      Mutant::Random.stub(hex_string: 'random')
     end
 
     let(:mutations) do
@@ -35,6 +38,7 @@ describe Mutant::Mutator, 'block' do
       mutations << 'foo { |a| }'
       mutations << 'foo { |b| }'
       mutations << 'foo { || }'
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'
@@ -43,7 +47,7 @@ describe Mutant::Mutator, 'block' do
   context 'with block pattern args' do
 
     before do
-      Mutant::Random.stub(:hex_string => 'random')
+      Mutant::Random.stub(hex_string: 'random')
     end
 
     let(:source) { 'foo { |(a, b), c| }' }
@@ -61,6 +65,7 @@ describe Mutant::Mutator, 'block' do
       mutations << 'foo { |(a, srandom), c| }'
       mutations << 'foo { |(a, b), srandom| }'
       mutations << 'foo'
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'

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

@@ -8,6 +8,7 @@ describe Mutant::Mutator::Node::NamedValue::Access, 'block_pass' do
   let(:mutations) do
     mutants = []
     mutants << 'foo'
+    mutants << 'nil'
   end
 
   it_should_behave_like 'a mutator'

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

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

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

@@ -6,7 +6,7 @@ describe Mutant::Mutator::Node::Case do
   let(:random_string) { 'random' }
 
   before do
-    Mutant::Random.stub(:hex_string => random_string)
+    Mutant::Random.stub(hex_string: random_string)
   end
 
   context 'with multiple when branches' do
@@ -217,6 +217,8 @@ describe Mutant::Mutator::Node::Case do
           :else
         end
       RUBY
+
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'
@@ -314,6 +316,8 @@ describe Mutant::Mutator::Node::Case do
           :else
         end
       RUBY
+
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'

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

@@ -8,6 +8,7 @@ describe Mutant::Mutator::Node::Noop, 'cbase' do
   let(:mutations) do
     mutants = []
     mutants << 'nil'
+    mutants << 'A'
   end
 
   it_should_behave_like 'a mutator'

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

@@ -3,12 +3,13 @@
 require 'spec_helper'
 
 describe Mutant::Mutator::Node::Const, 'const' do
-  let(:source) { 'A::B' }
+  let(:source) { 'A::B::C' }
 
   let(:mutations) do
     mutants = []
     mutants << 'nil'
-    mutants << 'nil::B'
+    mutants << 'B::C'
+    mutants << 'C'
   end
 
   it_should_behave_like 'a mutator'

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

@@ -43,7 +43,7 @@ describe Mutant::Mutator, 'def' do
     let(:source) { 'def foo(a, b); end' }
 
     before do
-      Mutant::Random.stub(:hex_string => 'random')
+      Mutant::Random.stub(hex_string: 'random')
     end
 
     let(:mutations) do
@@ -83,7 +83,7 @@ describe Mutant::Mutator, 'def' do
     let(:source) { 'def foo(a = true); end' }
 
     before do
-      Mutant::Random.stub(:hex_string => 'random')
+      Mutant::Random.stub(hex_string: 'random')
     end
 
     let(:mutations) do
@@ -127,7 +127,7 @@ describe Mutant::Mutator, 'def' do
   context 'define on singleton with argument' do
 
     before do
-      Mutant::Random.stub(:hex_string => 'random')
+      Mutant::Random.stub(hex_string: 'random')
     end
 
     let(:source) { 'def self.foo(a, b); end' }

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

@@ -3,8 +3,12 @@
 require 'spec_helper'
 
 describe Mutant::Mutator::Node::Generic, 'defined?' do
-  let(:source)    { 'defined?(foo)' }
-  let(:mutations) { []              }
+  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/mutation_spec.rb

@@ -2,9 +2,9 @@
 
 require 'spec_helper'
 
-describe Mutant::Mutator::Node::Generic, 'dstr' do
+describe Mutant::Mutator::Node::Dstr, 'dstr' do
   before do
-    Mutant::Random.stub(:hex_string => 'random')
+    Mutant::Random.stub(hex_string: 'random')
   end
 
   let(:source)  { '"foo#{bar}baz"' }
@@ -15,6 +15,8 @@ describe Mutant::Mutator::Node::Generic, 'dstr' do
     mutations << '"#{nil}#{bar}baz"'
     mutations << '"foo#{bar}random"'
     mutations << '"foo#{bar}#{nil}"'
+    mutations << '"foo#{nil}baz"'
+    mutations << 'nil'
   end
 
   it_should_behave_like 'a mutator'

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

@@ -2,9 +2,9 @@
 
 require 'spec_helper'
 
-describe Mutant::Mutator::Node::Generic, 'dsum' do
+describe Mutant::Mutator::Node::Dsym, 'dsym' do
   before do
-    Mutant::Random.stub(:hex_string => 'random')
+    Mutant::Random.stub(hex_string: 'random')
   end
 
   let(:source)  { ':"foo#{bar}baz"' }
@@ -15,6 +15,8 @@ describe Mutant::Mutator::Node::Generic, 'dsum' do
     mutations << ':"#{nil}#{bar}baz"'
     mutations << ':"foo#{bar}random"'
     mutations << ':"foo#{bar}#{nil}"'
+    mutations << ':"foo#{nil}baz"'
+    mutations << 'nil'
   end
 
   it_should_behave_like 'a mutator'

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Mutant::Mutator, 'if' do
   before do
-    Mutant::Random.stub(:hex_string => 'random')
+    Mutant::Random.stub(hex_string: 'random')
   end
 
   context 'with if and else branches' do
@@ -36,6 +36,8 @@ describe Mutant::Mutator, 'if' do
       # 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'
@@ -51,6 +53,8 @@ describe Mutant::Mutator, 'if' do
       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'
@@ -69,6 +73,7 @@ describe Mutant::Mutator, 'if' do
       mutants << 'unless true;        true;  end'
       mutants << 'unless false;       true;  end'
       mutants << 'if     :condition;  true;  end'
+      mutants << 'nil'
     end
 
     it_should_behave_like 'a mutator'

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

@@ -12,7 +12,7 @@ describe Mutant::Mutator::Node::Literal, 'fixnum' do
   end
 
   before do
-    Mutant::Random.stub(:fixnum => random_fixnum)
+    Mutant::Random.stub(fixnum: random_fixnum)
   end
 
   it_should_behave_like 'a mutator'

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

@@ -20,7 +20,7 @@ describe Mutant::Mutator::Node::Literal, 'float' do
   let(:random_float) { 7.123 }
 
   before do
-    Mutant::Random.stub(:float => random_float)
+    Mutant::Random.stub(float: random_float)
   end
 
   it_should_behave_like 'a mutator'

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

@@ -3,6 +3,13 @@
 require 'spec_helper'
 
 describe Mutant::Mutator::Node::Literal, 'range' do
+
+  before :each do
+    Mutant::Random.stub(fixnum: random_fixnum)
+  end
+
+  let(:random_fixnum) { 5 }
+
   context 'inclusive range literal' do
     let(:source) { '1..100' }
 
@@ -13,6 +20,18 @@ describe Mutant::Mutator::Node::Literal, 'range' do
       mutations << '(0.0 / 0.0)..100'
       mutations << '1..(1.0 / 0.0)'
       mutations << '1..(0.0 / 0.0)'
+      mutations << '-1..100'
+      mutations << '5..100'
+      mutations << '0..100'
+      mutations << '2..100'
+      mutations << 'nil..100'
+      mutations << '1..nil'
+      mutations << '1..0'
+      mutations << '1..1'
+      mutations << '1..99'
+      mutations << '1..101'
+      mutations << '1..-100'
+      mutations << '1..5'
     end
 
     it_should_behave_like 'a mutator'
@@ -28,6 +47,18 @@ describe Mutant::Mutator::Node::Literal, 'range' do
       mutations << '(0.0 / 0.0)...100'
       mutations << '1...(1.0 / 0.0)'
       mutations << '1...(0.0 / 0.0)'
+      mutations << '-1...100'
+      mutations << '5...100'
+      mutations << '0...100'
+      mutations << '2...100'
+      mutations << 'nil...100'
+      mutations << '1...nil'
+      mutations << '1...0'
+      mutations << '1...1'
+      mutations << '1...99'
+      mutations << '1...101'
+      mutations << '1...-100'
+      mutations << '1...5'
     end
 
     it_should_behave_like 'a mutator'

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

@@ -9,9 +9,9 @@ describe Mutant::Mutator::Node::Literal, 'regex' do
 
     let(:mutations) do
       mutations = []
-      mutations << 'nil'
       mutations << '//' # match all
       mutations << '/a\A/' # match nothing
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'
@@ -22,10 +22,12 @@ describe Mutant::Mutator::Node::Literal, 'regex' do
 
     let(:mutations) do
       mutations = []
-      mutations << 'nil'
       mutations << '//' # match all
       mutations << '/#{foo}n/' # match all
       mutations << '/a\A/' # match nothing
+      mutations << '/#{nil.bar}n/'
+      mutations << '/#{nil}n/'
+      mutations << 'nil'
     end
 
     it_should_behave_like 'a mutator'