mutant 0.9.8 → 0.9.13

data/meta/block_pass.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :block_pass do
-  source 'foo(&bar)'
-
-  singleton_mutations
-  mutation 'foo'
-end

data/meta/blockarg.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :blockarg do
-  source 'foo { |&bar| }'
-
-  singleton_mutations
-  mutation 'foo { |&bar| raise }'
-  mutation 'foo {}'
-  mutation 'foo'
-end

data/meta/break.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :break do
-  source 'break true'
-
-  singleton_mutations
-  mutation 'break false'
-  mutation 'break nil'
-  mutation 'break'
-end

data/meta/case.rb

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :case do
-  source <<-RUBY
-    case
-    when true
-    else
-    end
-  RUBY
-
-  singleton_mutations
-
-  mutation <<-RUBY
-    case
-    when true
-      raise
-    else
-    end
-  RUBY
-  mutation <<-RUBY
-    case
-    when false
-    else
-    end
-  RUBY
-  mutation <<-RUBY
-    case
-    when nil
-    else
-    end
-  RUBY
-end
-
-# rubocop:disable Metrics/BlockLength
-Mutant::Meta::Example.add :case do
-  source <<-RUBY
-    case condition
-    when A
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  singleton_mutations
-
-  mutation <<-RUBY
-    case nil
-    when A
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case self
-    when A
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-      raise
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when nil
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when self
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when B, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, C
-      nil
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, C
-      self
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when nil, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when self, C
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, nil
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, self
-      C
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    else
-      D
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, C
-      C
-    else
-      nil
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, C
-      C
-    else
-      self
-    end
-  RUBY
-
-  mutation <<-RUBY
-    case condition
-    when A
-    when B, C
-      C
-    end
-  RUBY
-end

data/meta/casgn.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :casgn do
-  source 'A = true'
-
-  mutation 'A__MUTANT__ = true'
-  mutation 'A = false'
-  mutation 'A = nil'
-  mutation 'remove_const :A'
-end
-
-Mutant::Meta::Example.add :casgn do
-  source 'self::A = true'
-
-  mutation 'self::A__MUTANT__ = true'
-  mutation 'self::A = false'
-  mutation 'self::A = nil'
-  mutation 'self.remove_const :A'
-end
-
-Mutant::Meta::Example.add :casgn do
-  source 'A &&= true'
-
-  singleton_mutations
-  mutation 'A__MUTANT__ &&= true'
-  mutation 'A &&= false'
-  mutation 'A &&= nil'
-end

data/meta/cbase.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :cbase do
-  source '::A'
-
-  singleton_mutations
-  mutation 'A'
-end

data/meta/class.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :class do
-  source 'class Foo; bar; end'
-
-  mutation 'class Foo; nil; end'
-  mutation 'class Foo; self; end'
-end
-
-Mutant::Meta::Example.add :class do
-  source 'class Foo; end'
-end

data/meta/const.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :const do
-  source 'A::B::C'
-
-  singleton_mutations
-  mutation 'B::C'
-  mutation 'C'
-end
-
-Mutant::Meta::Example.add :const do
-  source 'A.foo'
-
-  singleton_mutations
-  mutation 'A'
-  mutation 'self.foo'
-end

data/meta/csend.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :csend do
-  source 'a&.b'
-
-  singleton_mutations
-  mutation 'a.b'
-  mutation 'self&.b'
-  mutation 'a'
-end

data/meta/cvar.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :cvar do
-  source '@@a'
-
-  singleton_mutations
-end

data/meta/cvasgn.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :cvasgn do
-  source '@@a = true'
-
-  singleton_mutations
-  mutation '@@a__mutant__ = true'
-  mutation '@@a = false'
-  mutation '@@a = nil'
-end

data/meta/date.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :send do
-  source 'Date.parse(nil)'
-
-  singleton_mutations
-  mutation 'Date.parse'
-  mutation 'self.parse(nil)'
-  mutation 'Date'
-  mutation 'Date.jd(nil)'
-  mutation 'Date.civil(nil)'
-  mutation 'Date.strptime(nil)'
-  mutation 'Date.iso8601(nil)'
-  mutation 'Date.rfc3339(nil)'
-  mutation 'Date.xmlschema(nil)'
-  mutation 'Date.rfc2822(nil)'
-  mutation 'Date.rfc822(nil)'
-  mutation 'Date.httpdate(nil)'
-  mutation 'Date.jisx0301(nil)'
-end
-
-Mutant::Meta::Example.add :send do
-  source '::Date.parse(nil)'
-
-  singleton_mutations
-  mutation '::Date.parse'
-  mutation 'Date.parse(nil)'
-  mutation 'self.parse(nil)'
-  mutation '::Date'
-  mutation '::Date.jd(nil)'
-  mutation '::Date.civil(nil)'
-  mutation '::Date.strptime(nil)'
-  mutation '::Date.iso8601(nil)'
-  mutation '::Date.rfc3339(nil)'
-  mutation '::Date.xmlschema(nil)'
-  mutation '::Date.rfc2822(nil)'
-  mutation '::Date.rfc822(nil)'
-  mutation '::Date.httpdate(nil)'
-  mutation '::Date.jisx0301(nil)'
-end
-
-Mutant::Meta::Example.add :send do
-  source 'Date.iso8601(nil)'
-
-  singleton_mutations
-  mutation 'Date.iso8601'
-  mutation 'self.iso8601(nil)'
-  mutation 'Date'
-end
-
-Mutant::Meta::Example.add :send do
-  source 'Foo::Date.parse(nil)'
-
-  singleton_mutations
-  mutation 'Foo::Date.parse'
-  mutation 'Foo::Date'
-  mutation 'Date.parse(nil)'
-  mutation 'self.parse(nil)'
-end

data/meta/def.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-Mutant::Meta::Example.add :def do
-  source 'def foo; end'
-
-  mutation 'def foo; raise; end'
-  mutation 'def foo; super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo; foo; rescue; end'
-
-  mutation 'def foo; raise; end'
-  mutation 'def foo; nil; rescue; end'
-  mutation 'def foo; self; rescue; end'
-  mutation 'def foo; end'
-  mutation 'def foo; super; end'
-
-  # Promote rescue resbody bodies
-  mutation 'def foo; foo; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def a; foo; rescue; bar; else; baz; end'
-
-  # Mutate all bodies
-  mutation 'def a; nil;  rescue; bar; else; baz; end'
-  mutation 'def a; self; rescue; bar; else; baz; end'
-  mutation 'def a; foo; rescue; nil;  else; baz; end'
-  mutation 'def a; foo; rescue; self; else; baz; end'
-  mutation 'def a; foo; rescue; bar; else; nil; end'
-  mutation 'def a; foo; rescue; bar; else; self; end'
-
-  # Promote and concat rescue resbody bodies
-  mutation 'def a; foo; bar; end'
-
-  # Promote and concat else body
-  mutation 'def a; foo; baz; end'
-
-  # Promote rescue body
-  mutation 'def a; foo; end'
-
-  # Empty body
-  mutation 'def a; end'
-
-  # Failing body
-  mutation 'def a; raise; end'
-
-  # Superclass implementation
-  mutation 'def a; super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo; true; false; end'
-
-  # Mutation of each statement in block
-  mutation 'def foo; true; true; end'
-  mutation 'def foo; false; false; end'
-  mutation 'def foo; true; nil; end'
-  mutation 'def foo; nil; false; end'
-
-  # Remove statement in block
-  mutation 'def foo; true; end'
-  mutation 'def foo; false; end'
-
-  # Remove all statements
-  mutation 'def foo; end'
-
-  mutation 'def foo; raise; end'
-
-  mutation 'def foo; super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo(a, b); end'
-
-  # Deletion of each argument
-  mutation 'def foo(a); end'
-  mutation 'def foo(b); end'
-
-  # Deletion of all arguments
-  mutation 'def foo; end'
-
-  # Rename each argument
-  mutation 'def foo(_a, b); end'
-  mutation 'def foo(a, _b); end'
-
-  # Mutation of body
-  mutation 'def foo(a, b); raise; end'
-  mutation 'def foo(a, b); super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo(a, b = nil); true; end'
-
-  mutation 'def foo(_a, b = nil); true; end'
-  mutation 'def foo(a, b = nil); end'
-  mutation 'def foo; true; end'
-  mutation 'def foo(a, b = nil); raise; end'
-  mutation 'def foo(a, b = nil); nil; end'
-  mutation 'def foo(a, b = nil); false; end'
-  mutation 'def foo(a); true; end'
-  mutation 'def foo(a, b = nil); b = nil; true; end'
-  mutation 'def foo(b = nil); true; end'
-  mutation 'def foo(a, _b = nil); true; end'
-  mutation 'def foo(a, b); true; end'
-  mutation 'def foo(a, b = nil); super; end'
-end
-
-Mutant::Meta::Example.add :def, :arg do
-  source 'def foo(_unused); end'
-
-  mutation 'def foo(_unused); raise; end'
-  mutation 'def foo; end'
-  mutation 'def foo(_unused); super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo(_unused = true); end'
-
-  mutation 'def foo(_unused = nil); end'
-  mutation 'def foo(_unused = false); end'
-  mutation 'def foo(_unused = true); raise; end'
-  mutation 'def foo(_unused); end'
-  mutation 'def foo; end'
-  mutation 'def foo(_unused = true); super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo(a = 0, b = 0); end'
-  mutation 'def foo(a = 0, _b = 0); end'
-  mutation 'def foo(_a = 0, b = 0); end'
-  mutation 'def foo(a = 0, b = 1); end'
-  mutation 'def foo(a = 0, b = -1); end'
-  mutation 'def foo(a = 0, b = self); end'
-  mutation 'def foo(a = 0, b = nil); end'
-  mutation 'def foo(a = -1, b = 0); end'
-  mutation 'def foo(a = self, b = 0); end'
-  mutation 'def foo(a = nil, b = 0); end'
-  mutation 'def foo(a = 1, b = 0); end'
-  mutation 'def foo(a = 0); end'
-  mutation 'def foo(b = 0); end'
-  mutation 'def foo(a, b = 0); end'
-  mutation 'def foo; end'
-  mutation 'def foo(a = 0, b = 0); a = 0; end'
-  mutation 'def foo(a = 0, b = 0); b = 0; end'
-  mutation 'def foo(a = 0, b = 0); raise; end'
-  mutation 'def foo(a = 0, b = 0); super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def foo(a = true); end'
-
-  mutation 'def foo(a); end'
-  mutation 'def foo(); end'
-  mutation 'def foo(a = false); end'
-  mutation 'def foo(a = nil); end'
-  mutation 'def foo(_a = true); end'
-  mutation 'def foo(a = true); raise; end'
-  mutation 'def foo(a = true); a = true; end'
-  mutation 'def foo(a = true); super; end'
-end
-
-Mutant::Meta::Example.add :def do
-  source 'def self.foo; true; false; end'
-
-  # Body presence mutation
-  mutation 'def self.foo; false; false; end'
-  mutation 'def self.foo; true; true; end'
-  mutation 'def self.foo; true; nil; end'
-  mutation 'def self.foo; nil; false; end'
-
-  # Body presence mutation
-  mutation 'def self.foo; true; end'
-  mutation 'def self.foo; false; end'
-
-  # Remove all statements
-  mutation 'def self.foo; end'
-
-  mutation 'def self.foo; raise; end'
-
-  mutation 'def self.foo; super; end'
-end
-
-Mutant::Meta::Example.add :def do
-
-  source 'def self.foo(a, b); end'
-
-  # Deletion of each argument
-  mutation 'def self.foo(a); end'
-  mutation 'def self.foo(b); end'
-
-  # Deletion of all arguments
-  mutation 'def self.foo; end'
-
-  # Rename each argument
-  mutation 'def self.foo(_a, b); end'
-  mutation 'def self.foo(a, _b); end'
-
-  # Mutation of body
-  mutation 'def self.foo(a, b); raise; end'
-  mutation 'def self.foo(a, b); super; end'
-end