mutant 0.5.18 → 0.5.19

data/meta/rescue.rb

@@ -3,27 +3,28 @@
 Mutant::Meta::Example.add do
   source 'begin; rescue ExceptionA, ExceptionB => error; true; end'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'begin; rescue ExceptionA, ExceptionB; true; end'
+  mutation 'begin; rescue self, ExceptionB => error; true; end'
+  mutation 'begin; rescue ExceptionA, self => error; true; end'
   mutation 'begin; rescue ExceptionA, ExceptionB => error; false; end'
   mutation 'begin; rescue ExceptionA, ExceptionB => error; nil; end'
-  mutation 'begin; rescue ExceptionA => error; true; end'
-  mutation 'begin; rescue ExceptionB => error; true; end'
 end
 
 Mutant::Meta::Example.add do
   source 'begin; rescue SomeException => error; true; end'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'begin; rescue SomeException; true; end'
   mutation 'begin; rescue SomeException => error; false; end'
   mutation 'begin; rescue SomeException => error; nil; end'
+  mutation 'begin; rescue self => error; true; end'
 end
 
 Mutant::Meta::Example.add do
   source 'begin; rescue => error; true end'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'begin; rescue => error; false; end'
   mutation 'begin; rescue => error; nil; end'
   mutation 'begin; rescue; true; end'
@@ -32,7 +33,7 @@ end
 Mutant::Meta::Example.add do
   source 'begin; rescue; true end'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'begin; rescue; false; end'
   mutation 'begin; rescue; nil; end'
 end

data/meta/restarg.rb

@@ -3,9 +3,11 @@
 Mutant::Meta::Example.add do
   source 'foo(*bar)'
 
+  singleton_mutations
   mutation 'foo'
   mutation 'foo(nil)'
+  mutation 'foo(self)'
+  mutation 'foo(*self)'
   mutation 'foo(bar)'
   mutation 'foo(*nil)'
-  mutation 'nil'
 end

data/meta/return.rb

@@ -3,13 +3,14 @@
 Mutant::Meta::Example.add do
   source 'return'
 
-  mutation 'nil'
+  singleton_mutations
 end
 
 Mutant::Meta::Example.add do
   source 'return foo'
 
+  singleton_mutations
   mutation 'foo'
   mutation 'return nil'
-  mutation 'nil'
+  mutation 'return self'
 end

data/meta/send.rb

@@ -3,14 +3,14 @@
 Mutant::Meta::Example.add do
   source 'reverse_each'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'each'
 end
 
 Mutant::Meta::Example.add do
   source 'reverse_map'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'map'
   mutation 'each'
 end
@@ -18,18 +18,20 @@ end
 Mutant::Meta::Example.add do
   source 'map'
 
-  mutation 'nil'
+  singleton_mutations
   mutation 'each'
 end
 
 Mutant::Meta::Example.add do
   source 'foo == bar'
 
+  singleton_mutations
   mutation 'foo'
   mutation 'bar'
   mutation 'nil == bar'
+  mutation 'self == bar'
   mutation 'foo == nil'
-  mutation 'nil'
+  mutation 'foo == self'
   mutation 'foo.eql?(bar)'
   mutation 'foo.equal?(bar)'
 end
@@ -37,43 +39,40 @@ end
 Mutant::Meta::Example.add do
   source 'foo.gsub(a, b)'
 
+  singleton_mutations
   mutation 'foo'
   mutation 'foo.gsub(a)'
   mutation 'foo.gsub(b)'
   mutation 'foo.gsub'
   mutation 'foo.sub(a, b)'
   mutation 'foo.gsub(a, nil)'
+  mutation 'foo.gsub(a, self)'
   mutation 'foo.gsub(nil, b)'
+  mutation 'foo.gsub(self, b)'
   mutation 'nil.gsub(a, b)'
-  mutation 'nil'
+  mutation 'self.gsub(a, b)'
 end
 
 Mutant::Meta::Example.add do
   source 'foo.send(bar)'
 
+  singleton_mutations
   mutation 'foo.send'
   mutation 'foo.public_send(bar)'
   mutation 'bar'
   mutation 'foo'
+  mutation 'self.send(bar)'
   mutation 'foo.send(nil)'
+  mutation 'foo.send(self)'
   mutation 'nil.send(bar)'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
-  source 'self.foo ||= expression'
+  source 'self.bar = baz'
 
-  mutation 'self.foo ||= nil'
-  mutation 'nil.foo ||= expression'
-  mutation 'nil'
-end
-
-Mutant::Meta::Example.add do
-  source 'self.bar=baz'
-
-  mutation 'nil'
-  mutation 'self.bar=nil'
-  mutation 'self'
+  singleton_mutations
+  mutation 'self.bar = nil'
+  mutation 'self.bar = self'
   mutation 'self.bar'
   mutation 'baz'
   # This one could probably be removed
@@ -81,105 +80,107 @@ Mutant::Meta::Example.add do
 end
 
 Mutant::Meta::Example.add do
-  source 'foo.bar=baz'
+  source 'foo.bar = baz'
 
+  singleton_mutations
   mutation 'foo'
-  mutation 'nil'
-  mutation 'foo.bar=nil'
+  mutation 'foo.bar = nil'
+  mutation 'foo.bar = self'
+  mutation 'self.bar = baz'
   mutation 'foo.bar'
   mutation 'baz'
   # This one could probably be removed
-  mutation 'nil.bar=baz'
+  mutation 'nil.bar = baz'
 end
 
 Mutant::Meta::Example.add do
   source 'foo[bar]=baz'
 
+  singleton_mutations
   mutation 'foo'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'foo(*bar)'
 
+  singleton_mutations
   mutation 'foo'
   mutation 'foo(nil)'
   mutation 'foo(bar)'
+  mutation 'foo(self)'
   mutation 'foo(*nil)'
-  mutation 'nil'
+  mutation 'foo(*self)'
 end
 
 Mutant::Meta::Example.add do
   source 'foo(&bar)'
 
+  singleton_mutations
   mutation 'foo'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'foo[*bar]'
 
+  singleton_mutations
   mutation 'foo'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'foo'
 
-  mutation 'nil'
+  singleton_mutations
 end
 
 Mutant::Meta::Example.add do
   source 'self.foo'
 
+  singleton_mutations
   mutation 'foo'
-  mutation 'self'
   mutation 'nil.foo'
-  mutation 'nil'
 end
 
 Unparser::Constants::KEYWORDS.each do |keyword|
   Mutant::Meta::Example.add do
     source "self.#{keyword}"
 
+    singleton_mutations
     mutation "nil.#{keyword}"
-    mutation 'nil'
-    mutation 'self'
   end
 end
 
 Mutant::Meta::Example.add do
   source 'foo.bar'
 
+  singleton_mutations
   mutation 'foo'
   mutation 'nil.bar'
-  mutation 'nil'
+  mutation 'self.bar'
 end
 
 Mutant::Meta::Example.add do
   source 'self.class.foo'
 
+  singleton_mutations
   mutation 'self.class'
   mutation 'self.foo'
   mutation 'nil.class.foo'
   mutation 'nil.foo'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'foo(nil)'
 
+  singleton_mutations
   mutation 'foo'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'self.foo(nil)'
 
-  mutation 'self'
+  singleton_mutations
   mutation 'self.foo'
   mutation 'foo(nil)'
-  mutation 'nil'
   mutation 'nil.foo(nil)'
 end
 
@@ -187,54 +188,50 @@ Unparser::Constants::KEYWORDS.each do |keyword|
   Mutant::Meta::Example.add do
     source "foo.#{keyword}(nil)"
 
+    singleton_mutations
+    mutation "self.#{keyword}(nil)"
     mutation "foo.#{keyword}"
     mutation 'foo'
     mutation "nil.#{keyword}(nil)"
-    mutation 'nil'
   end
 end
 
 Mutant::Meta::Example.add do
   source 'foo(nil, nil)'
 
+  singleton_mutations
   mutation 'foo()'
   mutation 'foo(nil)'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source '(left - right) / foo'
 
+  singleton_mutations
   mutation 'foo'
   mutation '(left - right)'
   mutation 'left / foo'
   mutation 'right / foo'
   mutation '(left - right) / nil'
+  mutation '(left - right) / self'
   mutation '(left - nil) / foo'
+  mutation '(left - self) / foo'
   mutation '(nil - right) / foo'
+  mutation '(self - right) / foo'
   mutation 'nil / foo'
-  mutation 'nil'
+  mutation 'self / foo'
 end
 
 (Mutant::BINARY_METHOD_OPERATORS - [:==, :eql?]).each do |operator|
   Mutant::Meta::Example.add do
     source "true #{operator} false"
 
+    singleton_mutations
+    mutation 'true'
+    mutation 'false'
     mutation "false #{operator} false"
     mutation "nil   #{operator} false"
     mutation "true  #{operator} true"
     mutation "true  #{operator} nil"
-    mutation 'true'
-    mutation 'false'
-    mutation 'nil'
-  end
-
-  Mutant::Meta::Example.add do
-    source "left #{operator} right"
-    mutation 'left'
-    mutation 'right'
-    mutation "left #{operator} nil"
-    mutation "nil #{operator} right"
-    mutation 'nil'
   end
 end

data/meta/{string.rb → str.rb}

@@ -3,5 +3,5 @@
 Mutant::Meta::Example.add do
   source '"foo"'
 
-  mutation 'nil'
+  singleton_mutations
 end

data/meta/super.rb

@@ -3,24 +3,27 @@
 Mutant::Meta::Example.add do
   source 'super'
 
-  mutation 'nil'
+  singleton_mutations
 end
 
 Mutant::Meta::Example.add do
   source 'super()'
 
+  singleton_mutations
+  # this is zsuper a totally differend node thant super()
   mutation 'super'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'super(foo, bar)'
 
+  singleton_mutations
   mutation 'super'
   mutation 'super()'
   mutation 'super(foo)'
   mutation 'super(bar)'
   mutation 'super(foo, nil)'
+  mutation 'super(foo, self)'
   mutation 'super(nil, bar)'
-  mutation 'nil'
+  mutation 'super(self, bar)'
 end

data/meta/symbol.rb

@@ -3,6 +3,6 @@
 Mutant::Meta::Example.add do
   source ':foo'
 
-  mutation 'nil'
+  singleton_mutations
   mutation ':foo__mutant__'
 end

data/meta/true.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+Mutant::Meta::Example.add do
+  source 'true'
+
+  mutation 'nil'
+  mutation 'false'
+end

data/meta/until.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+Mutant::Meta::Example.add do
+  source 'until true; foo; bar; end'
+
+  singleton_mutations
+  mutation 'until true; bar; end'
+  mutation 'until true; foo; end'
+  mutation 'until true; end'
+  mutation 'until false; foo; bar; end'
+  mutation 'until nil; foo; bar; end'
+  mutation 'until true; foo; nil; end'
+  mutation 'until true; foo; self; end'
+  mutation 'until true; nil; bar; end'
+  mutation 'until true; self; bar; end'
+  mutation 'until true; raise; end'
+end

data/meta/while.rb

@@ -3,6 +3,9 @@
 Mutant::Meta::Example.add do
   source 'while true; foo; bar; end'
 
+  singleton_mutations
+  mutation 'while true; self; bar; end'
+  mutation 'while true; foo; self; end'
   mutation 'while true; bar; end'
   mutation 'while true; foo; end'
   mutation 'while true; end'
@@ -11,14 +14,13 @@ Mutant::Meta::Example.add do
   mutation 'while true;  foo; nil; end'
   mutation 'while true;  nil; bar; end'
   mutation 'while true;  raise; end'
-  mutation 'nil'
 end
 
 Mutant::Meta::Example.add do
   source 'while true; end'
 
+  singleton_mutations
   mutation 'while true; raise; end'
   mutation 'while false; end'
   mutation 'while nil; end'
-  mutation 'nil'
 end