mutant 0.9.5 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da54128dceeae02111b3708c3b3bdc80d49d926661069bb1e852468ceaad0502
-  data.tar.gz: 3a925f8be1f50b4fa767047324e06a268a8ba3f6b2b5797b795bd1581c69a84f
+  metadata.gz: ef6c23cfd4cebac6873c8d422c919b3821a4eb09cb77b8b9786185fb711c7f70
+  data.tar.gz: 3035168adda27d5ba4476606ddbf84ddeba62d00bf12a9a26d9b55fcc48a8a74
 SHA512:
-  metadata.gz: bd0520621ef6fb51b2e31ca9232d1d56226a867a8684e7246a83b20382e506ac0e86457f8ac7a1d9d602f70f7459207153464e3c1cabb63144f3634a85f1a73f
-  data.tar.gz: 7293cb707fee3343a7e089b4c7ba35487262c35740a3caf3392fad5ec7f3d956a2fd54c43f5925deb1cb6e99e2f0b146fc2af4ab2a16ad5e339206e5d71c178e
+  metadata.gz: 0b137d304dfd008cb9e12373c9665fcd494ddaad91e630ee1cd0bf96ace97abb0181513d152d61dba38dab9ed71f9a473b441983e9e04361e1c4bced66449410
+  data.tar.gz: f1566c734cb33af620ae3a1d440cd26f9b2c8f8ecf9665bfade140438b5d5e2e8c21732db42cb6bb2130aae87481a11324ca47dac4fb51f17065ee7e2262f8f6

data/Changelog.md

@@ -1,3 +1,8 @@
+# v0.9.6 2020-04-20
+
+* Dependencies upgrade, should not change user facing semantics.
+* Bump license nudge to 40s
+
 # v0.9.5 2020-02-02
 
 * Change to 2.7 parser series.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mutant (0.9.4)
+    mutant (0.9.6)
       abstract_type (~> 0.0.7)
       adamantium (~> 0.2.0)
       anima (~> 0.3.1)
@@ -15,6 +15,7 @@ PATH
       parser (~> 2.7.0.2)
       procto (~> 0.0.2)
       unparser (~> 0.4.6)
+      variable (~> 0.0.1)
 
 GEM
   remote: https://rubygems.org/
@@ -142,6 +143,8 @@ GEM
       equalizer (~> 0.0.9)
       parser (>= 2.6.5)
       procto (~> 0.0.2)
+    variable (0.0.1)
+      equalizer (~> 0.0.11)
     virtus (1.0.5)
       axiom-types (~> 0.1)
       coercible (~> 1.0)

data/lib/mutant.rb

@@ -21,6 +21,7 @@ require 'set'
 require 'singleton'
 require 'stringio'
 require 'unparser'
+require 'variable'
 require 'yaml'
 
 # This setting is done to make errors within the parallel
@@ -185,7 +186,6 @@ require 'mutant/reporter/cli/format'
 require 'mutant/repository'
 require 'mutant/repository/diff'
 require 'mutant/repository/diff/ranges'
-require 'mutant/variable'
 require 'mutant/warnings'
 require 'mutant/zombifier'
 require 'mutant/range'

data/lib/mutant/license.rb

@@ -4,7 +4,7 @@ module Mutant
   module License
     NAME    = 'mutant-license'
     VERSION = '~> 0.1.0'
-    SLEEP   = 20
+    SLEEP   = 40
 
     UNLICENSED =
       IceNine.deep_freeze(

data/lib/mutant/parallel.rb

@@ -52,7 +52,7 @@ module Mutant
     # @param [Class] klass
     # @param [Config] config
     #
-    # @return [Mutant::Variable]
+    # @return [Variable]
     #
     # ignore :reek:LongParameterList
     def self.shared(klass, config, **attributes)

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.9.5'
+  VERSION = '0.9.6'
 end # Mutant

data/mutant.gemspec

@@ -34,6 +34,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('parser',        '~> 2.7.0.2')
   gem.add_runtime_dependency('procto',        '~> 0.0.2')
   gem.add_runtime_dependency('unparser',      '~> 0.4.6')
+  gem.add_runtime_dependency('variable',      '~> 0.0.1')
 
   gem.add_development_dependency('devtools', '~> 0.1.25')
   gem.add_development_dependency('parallel', '~> 1.3')

data/spec/integrations.yml

@@ -2,13 +2,14 @@
 - name: rubyspec
   namespace: Rubyspec
   repo_uri: 'https://github.com/ruby/rubyspec.git'
-  repo_ref: 'origin/master'
+  repo_ref: 249a36c2e9fcddbb208a0d618d05f6bd9a64fd17
   integration: mspec
   mutation_coverage: false
   mutation_generation: true
   exclude:
     - command_line/fixtures/bad_syntax.rb
     - command_line/fixtures/freeze_flag_required_diff_enc.rb
+    - core/file/stat_spec.rb
     - core/kernel/shared/sprintf_encoding.rb
     - core/module/fixtures/autoload_empty.rb
     - core/module/fixtures/autoload_never_set.rb
@@ -26,6 +27,7 @@
     - language/predefined/fixtures/data_only.rb
     - language/source_encoding_spec.rb
     - library/base64/decode64_spec.rb
+    - library/cgi/escapeHTML_spec.rb
     - security/cve_2010_1330_spec.rb
 - name: regexp_parser
   namespace: Regexp

data/spec/unit/mutant/license_spec.rb

@@ -89,7 +89,7 @@ RSpec.describe Mutant::License do
 
       expect(stderr)
         .to have_received(:puts)
-        .with('[Mutant-License-Error]: Soft fail, continuing in 20 seconds')
+        .with('[Mutant-License-Error]: Soft fail, continuing in 40 seconds')
         .ordered
 
       expect(stderr)
@@ -104,7 +104,7 @@ RSpec.describe Mutant::License do
 
       expect(kernel)
         .to have_received(:sleep)
-        .with(20)
+        .with(40)
         .ordered
     end
   end

data/spec/unit/mutant/parallel/driver_spec.rb

@@ -16,15 +16,15 @@ RSpec.describe Mutant::Parallel::Driver do
   end
 
   let(:var_active_jobs) do
-    instance_double(Mutant::Variable::IVar, 'active jobs')
+    instance_double(Variable::IVar, 'active jobs')
   end
 
   let(:var_final) do
-    instance_double(Mutant::Variable::IVar, 'final')
+    instance_double(Variable::IVar, 'final')
   end
 
   let(:var_sink) do
-    instance_double(Mutant::Variable::IVar, 'sink')
+    instance_double(Variable::IVar, 'sink')
   end
 
   subject do
@@ -64,7 +64,7 @@ RSpec.describe Mutant::Parallel::Driver do
           receiver:  var_final,
           selector:  :take_timeout,
           arguments: [timeout],
-          reaction:  { return: Mutant::Variable.const_get(:Result)::Timeout.new }
+          reaction:  { return: Variable.const_get(:Result)::Timeout.new }
         },
         {
           receiver: var_active_jobs,

data/spec/unit/mutant/parallel/worker_spec.rb

@@ -31,23 +31,23 @@ RSpec.describe Mutant::Parallel::Worker do
     end
 
     let(:var_active_jobs) do
-      instance_double(Mutant::Variable::IVar, 'active jobs')
+      instance_double(Variable::IVar, 'active jobs')
     end
 
     let(:var_final) do
-      instance_double(Mutant::Variable::IVar, 'final')
+      instance_double(Variable::IVar, 'final')
     end
 
     let(:var_running) do
-      instance_double(Mutant::Variable::MVar, 'running')
+      instance_double(Variable::MVar, 'running')
     end
 
     let(:var_sink) do
-      instance_double(Mutant::Variable::IVar, 'sink')
+      instance_double(Variable::IVar, 'sink')
     end
 
     let(:var_source) do
-      instance_double(Mutant::Variable::IVar, 'source')
+      instance_double(Variable::IVar, 'source')
     end
 
     subject do

data/spec/unit/mutant/parallel_spec.rb

@@ -30,28 +30,28 @@ RSpec.describe Mutant::Parallel do
     end
 
     let(:var_active_jobs) do
-      instance_double(Mutant::Variable::IVar, 'active jobs')
+      instance_double(Variable::IVar, 'active jobs')
     end
 
     let(:var_final) do
-      instance_double(Mutant::Variable::IVar, 'final')
+      instance_double(Variable::IVar, 'final')
     end
 
     let(:var_running) do
-      instance_double(Mutant::Variable::MVar, 'running')
+      instance_double(Variable::MVar, 'running')
     end
 
     let(:var_sink) do
-      instance_double(Mutant::Variable::IVar, 'sink')
+      instance_double(Variable::IVar, 'sink')
     end
 
     let(:var_source) do
-      instance_double(Mutant::Variable::IVar, 'source')
+      instance_double(Variable::IVar, 'source')
     end
 
     def ivar(value, **attributes)
       {
-        receiver:  Mutant::Variable::IVar,
+        receiver:  Variable::IVar,
         selector:  :new,
         arguments: [
           condition_variable: condition_variable,
@@ -63,7 +63,7 @@ RSpec.describe Mutant::Parallel do
     end
 
     def mvar(*arguments)
-      ivar(*arguments).merge(receiver: Mutant::Variable::MVar)
+      ivar(*arguments).merge(receiver: Variable::MVar)
     end
 
     let(:raw_expectations) do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.9.5
+  version: 0.9.6
 platform: ruby
 authors:
 - Markus Schirp
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-02 00:00:00.000000000 Z
+date: 2020-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -192,6 +192,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.6
+- !ruby/object:Gem::Dependency
+  name: variable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: devtools
   requirement: !ruby/object:Gem::Requirement
@@ -409,7 +423,6 @@ files:
 - lib/mutant/timer.rb
 - lib/mutant/transform.rb
 - lib/mutant/util.rb
-- lib/mutant/variable.rb
 - lib/mutant/version.rb
 - lib/mutant/warnings.rb
 - lib/mutant/zombifier.rb
@@ -594,7 +607,6 @@ files:
 - spec/unit/mutant/transform/primitive_spec.rb
 - spec/unit/mutant/transform/sequence_spec.rb
 - spec/unit/mutant/util/one_spec.rb
-- spec/unit/mutant/variable_spec.rb
 - spec/unit/mutant/warnings_spec.rb
 - spec/unit/mutant/world_spec.rb
 - spec/unit/mutant/zombifier_spec.rb
@@ -625,7 +637,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: ''
@@ -730,7 +742,6 @@ test_files:
 - spec/unit/mutant/transform/primitive_spec.rb
 - spec/unit/mutant/transform/sequence_spec.rb
 - spec/unit/mutant/util/one_spec.rb
-- spec/unit/mutant/variable_spec.rb
 - spec/unit/mutant/warnings_spec.rb
 - spec/unit/mutant/world_spec.rb
 - spec/unit/mutant/zombifier_spec.rb

data/lib/mutant/variable.rb

@@ -1,282 +0,0 @@
-# frozen_string_literal: true
-
-module Mutant
-  # Lightweight shared variables
-  #
-  # ignore :reek:TooManyMethods
-  class Variable
-    EMPTY = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::EMPTY')
-    end.new.freeze
-
-    TIMEOUT = Class.new do
-      const_set(:INSPECT, 'Mutant::Variable::TIMEOUT')
-    end.new.freeze
-
-    # Result of operation that may time out
-    class Result
-      include AbstractType, Adamantium::Flat
-
-      # Test if take resulted in a timeout
-      #
-      # @return [Boolean]
-      #
-      # @api private
-      def timeout?
-        instance_of?(Timeout)
-      end
-
-      abstract_method :value
-
-      # Instance returned on timeouts
-      class Timeout < self
-        include Equalizer.new
-
-        INSTANCE = new
-
-        # Construct new object
-        #
-        # @return [Timeout]
-        def self.new
-          INSTANCE
-        end
-      end # Timeout
-
-      # Instance returned without timeouts
-      class Value < self
-        include Concord::Public.new(:value)
-      end # Value
-    end # Result
-
-    private_constant(*constants(false))
-
-    # Initialize object
-    #
-    # @param [Object] value
-    #   the initial value
-    #
-    # @return [undefined]
-    def initialize(condition_variable:, mutex:, value: EMPTY)
-      @full  = condition_variable.new
-      @mutex = mutex.new
-      @value = value
-    end
-
-    # Take value from mvar, block on empty
-    #
-    # @return [Object]
-    def take
-      synchronize do
-        wait_full
-        perform_take
-      end
-    end
-
-    # Take value from mvar, with timeout
-    #
-    # @param [Float] Timeout
-    #
-    # @return [Result::Timeout]
-    #   in case take resulted in a timeout
-    #
-    # @return [Result::Value]
-    #   in case take resulted in a value
-    def take_timeout(timeout)
-      synchronize do
-        if wait_timeout(@full, timeout, &method(:full?))
-          Result::Timeout.new
-        else
-          Result::Value.new(perform_take)
-        end
-      end
-    end
-
-    # Read value from variable
-    #
-    # @return [Object]
-    #   the contents of the mvar
-    def read
-      synchronize do
-        wait_full
-        @value
-      end
-    end
-
-    # Try put value into the variable, non blocking
-    #
-    # @param [Object] value
-    #
-    # @return [self]
-    def try_put(value)
-      synchronize do
-        perform_put(value) if empty?
-      end
-
-      self
-    end
-
-    # Execute block with value, blocking
-    #
-    # @yield [Object]
-    #
-    # @return [Object]
-    #   the blocks return value
-    def with
-      synchronize do
-        wait_full
-        yield @value
-      end
-    end
-
-  private
-
-    # Perform the put
-    #
-    # @param [Object] value
-    def perform_put(value)
-      (@value = value).tap { @full.signal }
-    end
-
-    # Execute block under mutex
-    #
-    # @return [self]
-    def synchronize(&block)
-      @mutex.synchronize(&block)
-    end
-
-    # Wait for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [undefined]
-    def wait(event)
-      event.wait(@mutex) until yield
-    end
-
-    # Wait with timeout for block predicate
-    #
-    # @param [ConditionVariable] event
-    #
-    # @return [Boolean]
-    #   if wait was terminated due a timeout
-    #
-    # @return [undefined]
-    #   otherwise
-    def wait_timeout(event, timeout)
-      loop do
-        break true if timeout <= 0
-        break if yield
-        timeout -= Timer.elapsed { event.wait(@mutex, timeout) }
-      end
-    end
-
-    # Wait till mvar is full
-    #
-    # @return [undefined]
-    def wait_full
-      wait(@full, &method(:full?))
-    end
-
-    # Test if state is full
-    #
-    # @return [Boolean]
-    def full?
-      !empty?
-    end
-
-    # Test if state is empty
-    #
-    # @return [Boolean]
-    def empty?
-      @value.equal?(EMPTY)
-    end
-
-    # Shared variable that can be written at most once
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class IVar < self
-
-      # Exception raised on ivar errors
-      class Error < RuntimeError; end
-
-      # Put valie into the mvar, raises if already full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      #
-      # @raise Error
-      #   if already full
-      def put(value)
-        synchronize do
-          fail Error, 'is immutable' if full?
-          perform_put(value)
-        end
-
-        self
-      end
-
-    private
-
-      # Perform take operation
-      #
-      # @return [Object]
-      def perform_take
-        @value
-      end
-    end # IVar
-
-    # Shared variable that can be written multiple times
-    #
-    # ignore :reek:InstanceVariableAssumption
-    class MVar < self
-
-      # Initialize object
-      #
-      # @param [Object] value
-      #   the initial value
-      #
-      # @return [undefined]
-      def initialize(condition_variable:, mutex:, value: EMPTY)
-        super
-        @empty = condition_variable.new
-      end
-
-      # Put value into mvar, block on full
-      #
-      # @param [Object] value
-      #
-      # @return [self]
-      def put(value)
-        synchronize do
-          wait(@empty, &method(:empty?))
-          perform_put(value)
-        end
-
-        self
-      end
-
-      # Modify mvar
-      #
-      # @return [Object]
-      def modify
-        synchronize do
-          wait_full
-          perform_put(yield(@value))
-        end
-      end
-
-    private
-
-      # Empty the mvar
-      #
-      # @return [Object]
-      def perform_take
-        @value.tap do
-          @value = EMPTY
-          @empty.signal
-        end
-      end
-    end # MVar
-  end # Variable
-end # Mutant

data/spec/unit/mutant/variable_spec.rb

@@ -1,618 +0,0 @@
-# frozen_string_literal: true
-
-module MutantSpec
-  module VariableHelper
-    def empty
-      described_class.new(
-        condition_variable: condition_variable_class,
-        mutex:              mutex_class
-      )
-    end
-
-    def full(value)
-      described_class.new(
-        condition_variable: condition_variable_class,
-        mutex:              mutex_class,
-        value:              value
-      )
-    end
-
-    # rubocop:disable Metrics/AbcSize
-    # rubocop:disable Metrics/MethodLength
-    def self.shared_setup
-      lambda do |_host|
-        let(:condition_variable_class) { class_double(ConditionVariable)            }
-        let(:expected_result)          { value                                      }
-        let(:full_condition)           { instance_double(ConditionVariable, 'full') }
-        let(:mutex)                    { instance_double(Mutex)                     }
-        let(:mutex_class)              { class_double(Mutex)                        }
-        let(:value)                    { instance_double(Object, 'value')           }
-
-        let(:synchronize) do
-          {
-            receiver: mutex,
-            selector: :synchronize,
-            reaction: { yields: [] }
-          }
-        end
-
-        let(:signal_full) do
-          {
-            receiver: full_condition,
-            selector: :signal
-          }
-        end
-
-        let(:put) do
-          {
-            receiver:  full_condition,
-            selector:  :wait,
-            arguments: [mutex],
-            reaction:  { execute: -> { subject.put(value) } }
-          }
-        end
-
-        let(:wait_empty) do
-          {
-            receiver:  empty_condition,
-            selector:  :wait,
-            arguments: [mutex]
-          }
-        end
-
-        let(:wait_full) do
-          {
-            receiver:  full_condition,
-            selector:  :wait,
-            arguments: [mutex]
-          }
-        end
-
-        let(:signal_empty) do
-          {
-            receiver: empty_condition,
-            selector: :signal
-          }
-        end
-
-        shared_examples 'consumes events' do
-          specify do
-            verify_events do
-              expect(apply).to eql(expected_result)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-RSpec.describe Mutant::Variable::IVar do
-  include MutantSpec::VariableHelper
-
-  class_eval(&MutantSpec::VariableHelper.shared_setup)
-
-  subject { empty }
-
-  let(:setup) do
-    [
-      {
-        receiver: condition_variable_class,
-        selector: :new,
-        reaction: { return: full_condition }
-      },
-      {
-        receiver: mutex_class,
-        selector: :new,
-        reaction: { return: mutex }
-      },
-      synchronize
-    ]
-  end
-
-  describe '#take' do
-    def apply
-      subject.take
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) { setup }
-
-      include_examples 'consumes events'
-    end
-
-    context 'when ivar is initially empty' do
-      let(:raw_expectations) do
-        [
-          *setup,
-          put,
-          synchronize,
-          signal_full
-        ]
-      end
-
-      include_examples 'consumes events'
-    end
-  end
-
-  describe '#take_timeout' do
-    def apply
-      subject.take_timeout(1.0)
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) { setup }
-
-      let(:expected_result) do
-        Mutant::Variable.const_get(:Result)::Value.new(value)
-      end
-
-      include_examples 'consumes events'
-    end
-
-    context 'when ivar is initially empty' do
-      def wait(time)
-        {
-          receiver:  full_condition,
-          selector:  :wait,
-          arguments: [mutex, time]
-        }
-      end
-
-      def elapsed(time)
-        {
-          receiver: Mutant::Timer,
-          selector: :elapsed,
-          reaction: { yields: [], return: time }
-        }
-      end
-
-      context 'and timeout occurs before value is put' do
-        let(:expected_result) do
-          Mutant::Variable.const_get(:Result)::Timeout.new
-        end
-
-        context 'wait exactly runs to zero left time on the clock' do
-          let(:raw_expectations) do
-            [
-              *setup,
-              elapsed(0.5),
-              wait(1.0),
-              elapsed(0.5),
-              wait(0.5)
-            ]
-          end
-
-          include_examples 'consumes events'
-        end
-
-        context 'wait overruns timeout' do
-          let(:raw_expectations) do
-            [
-              *setup,
-              elapsed(1.5),
-              wait(1.0)
-            ]
-          end
-
-          include_examples 'consumes events'
-        end
-      end
-
-      context 'and put occurs before timeout' do
-        let(:expected_result) do
-          Mutant::Variable.const_get(:Result)::Value.new(value)
-        end
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            elapsed(0.5),
-            wait(1.0).merge(reaction: { execute: -> { subject.put(value) } }),
-            synchronize,
-            signal_full
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-    end
-  end
-
-  describe '#put' do
-    def apply
-      subject.put(value)
-    end
-
-    context 'when ivar is initially empty' do
-      context 'when not reading result' do
-        let(:expected_result) { subject }
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            signal_full
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-
-      context 'when reading result back' do
-        let(:expected_result) { value }
-
-        def apply
-          super
-          subject.read
-        end
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            signal_full,
-            synchronize
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) { setup }
-
-      it 'raises expected exception' do
-        verify_events do
-          expect { apply }.to raise_error(Mutant::Variable::IVar::Error, 'is immutable')
-        end
-      end
-    end
-  end
-
-  describe '#try_put' do
-    def apply
-      subject.try_put(value)
-    end
-
-    let(:expected_result) { subject }
-
-    context 'when ivar is initially empty' do
-      let(:raw_expectations) do
-        [
-          *setup,
-          signal_full
-        ]
-      end
-
-      include_examples 'consumes events'
-
-      context 'reading the put value' do
-        let(:expected_result) { value }
-
-        let(:raw_expectations) do
-          [
-            *super(),
-            synchronize
-          ]
-        end
-
-        def apply
-          super
-          subject.read
-        end
-
-        include_examples 'consumes events'
-      end
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) { setup }
-
-      include_examples 'consumes events'
-    end
-  end
-
-  describe '#read' do
-    def apply
-      subject.read
-    end
-
-    context 'when ivar is initially empty' do
-      let(:raw_expectations) do
-        [
-          *setup,
-          wait_full.merge(reaction: { execute: -> { subject.put(value) } }),
-          synchronize,
-          signal_full
-        ]
-      end
-
-      include_examples 'consumes events'
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) { setup }
-
-      include_examples 'consumes events'
-    end
-  end
-
-  describe '#with' do
-    def apply
-      subject.with do |value|
-        @value = value
-      end
-    end
-
-    before { @value = nil }
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) { setup }
-
-      include_examples 'consumes events'
-
-      it 'should yield value' do
-        verify_events do
-          expect { apply }.to change { @value }.from(nil).to(value)
-        end
-      end
-    end
-
-    context 'when ivar is initially empty' do
-      subject { empty }
-
-      let(:raw_expectations) do
-        [
-          *setup,
-          put,
-          synchronize,
-          signal_full
-        ]
-      end
-
-      include_examples 'consumes events'
-
-      it 'should yield value' do
-        verify_events do
-          expect { apply }.to change { @value }.from(nil).to(value)
-        end
-      end
-    end
-  end
-end
-
-describe Mutant::Variable::MVar do
-  include MutantSpec::VariableHelper
-
-  class_eval(&MutantSpec::VariableHelper.shared_setup)
-
-  subject { empty }
-
-  let(:empty_condition) { instance_double(ConditionVariable, 'empty') }
-
-  let(:setup) do
-    [
-      {
-        receiver: condition_variable_class,
-        selector: :new,
-        reaction: { return: full_condition }
-      },
-      {
-        receiver: mutex_class,
-        selector: :new,
-        reaction: { return: mutex }
-      },
-      {
-        receiver: condition_variable_class,
-        selector: :new,
-        reaction: { return: empty_condition }
-      },
-      synchronize
-    ]
-  end
-
-  describe '#put' do
-    def apply
-      subject.put(value)
-    end
-
-    context 'when ivar is initially empty' do
-      context 'when not reading result' do
-        let(:expected_result) { subject }
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            signal_full
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-
-      context 'when reading result back' do
-        let(:expected_result) { value }
-
-        def apply
-          super
-          subject.read
-        end
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            signal_full,
-            synchronize
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-    end
-
-    context 'when ivar is initially full' do
-      context 'when not reading result' do
-        subject { full(value) }
-
-        let(:expected_result) { subject }
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            wait_empty.merge(reaction: { execute: -> { subject.take } }),
-            synchronize,
-            signal_empty,
-            signal_full
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-
-      context 'when reading result back' do
-        subject { full(value) }
-
-        def apply
-          super
-          subject.read
-        end
-
-        let(:expected_result) { value }
-
-        let(:raw_expectations) do
-          [
-            *setup,
-            wait_empty.merge(reaction: { execute: -> { subject.take } }),
-            synchronize,
-            signal_empty,
-            signal_full,
-            synchronize
-          ]
-        end
-
-        include_examples 'consumes events'
-      end
-    end
-  end
-
-  describe '#modify' do
-    let(:expected_result) { 1 }
-    let(:value)           { 0 }
-
-    def apply
-      subject.modify(&:succ)
-    end
-
-    context 'when ivar is initially empty' do
-      let(:raw_expectations) do
-        [
-          *setup,
-          wait_full.merge(reaction: { execute: -> { subject.put(value) } }),
-          synchronize,
-          signal_full,
-          signal_full
-        ]
-      end
-
-      include_examples 'consumes events'
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:raw_expectations) do
-        [
-          *setup,
-          signal_full
-        ]
-      end
-
-      include_examples 'consumes events'
-    end
-  end
-
-  describe '#take' do
-    def apply
-      subject.take
-    end
-
-    context 'when ivar is initially empty' do
-      let(:expected_result) { value }
-
-      let(:raw_expectations) do
-        [
-          *setup,
-          wait_full.merge(reaction: { execute: -> { subject.put(value) } }),
-          synchronize,
-          signal_full,
-          signal_empty
-        ]
-      end
-
-      include_examples 'consumes events'
-    end
-
-    context 'when ivar is initially full' do
-      subject { full(value) }
-
-      let(:expected_result) { value }
-
-      let(:raw_expectations) do
-        [
-          *setup,
-          signal_empty
-        ]
-      end
-
-      include_examples 'consumes events'
-    end
-  end
-end
-
-describe Mutant::Variable.const_get(:Result)::Value do
-  subject { described_class.new(nil) }
-
-  describe '#timeout?' do
-    def apply
-      subject.timeout?
-    end
-
-    it 'returns false' do
-      expect(apply).to be(false)
-    end
-  end
-end
-
-describe Mutant::Variable.const_get(:Result)::Timeout do
-  describe '.new' do
-    it 'is instance of timeout' do
-      expect(described_class.new.instance_of?(described_class)).to be(true)
-    end
-
-    it 'is idempotent' do
-      expect(described_class.new).to be(described_class.new)
-    end
-  end
-
-  describe '#timeout?' do
-    def apply
-      subject.timeout?
-    end
-
-    it 'returns true' do
-      expect(apply).to be(true)
-    end
-  end
-end