cool.io 1.9.4 → 1.10.0

data/spec/iobuffer_spec.rb

@@ -31,8 +31,51 @@ describe Cool.io::Buffer do
       expect(buffer << "baz").to eq "baz"
       expect(buffer.read 3).to eq "arb"
     end
+
+    it "raises ArgumentError for a length below one" do
+      buffer << "foo"
+      expect { buffer.read 0 }.to raise_error ArgumentError
+      expect { buffer.read(-1) }.to raise_error ArgumentError
+      expect { buffer.read(-(2**100)) }.to raise_error ArgumentError
+    end
+
+    it "clamps a length which does not fit in a C int to the buffer size" do
+      buffer << "foobar"
+      expect(buffer.read 2**31).to eq "foobar"
+      expect(buffer.size).to eq 0
+    end
+
+    it "clamps lengths larger than an unsigned long or size_t to the buffer size" do
+      [2**32, 2**64, 2**100].each do |length|
+        buffer << "foobar"
+        expect(buffer.read(length)).to eq "foobar"
+        expect(buffer.size).to eq 0
+      end
+    end
+
+    it "keeps integer coercion for numeric and to_int lengths" do
+      length = Object.new
+      def length.to_int
+        2
+      end
+      buffer << "foobar"
+      expect(buffer.read(length)).to eq "fo"
+      expect(buffer.read(2.9)).to eq "ob"
+      expect(buffer.to_str).to eq "ar"
+    end
   end
-  
+
+  it "raises RangeError when to_str is called on a buffer past LONG_MAX",
+     :if => [0].pack("l!").bytesize == 4 do
+    long_max = 2**31 - 1
+    node_size = 16 * 1024 * 1024
+    big = Cool.io::Buffer.new(node_size)
+    chunk = "x" * node_size
+    ((long_max / node_size) + 1).times { big << chunk }
+    expect(big.size).to be > long_max
+    expect { big.to_str }.to raise_error(RangeError)
+  end
+
   describe "provides methods for performing non-blocking I/O" do
     require "tempfile"
     
@@ -126,6 +169,31 @@ describe Cool.io::Buffer do
       expect(buffer.size).to eq 0
       expect(buffer.empty?).to eq true
     end
+
+    it "reuses pooled nodes instead of leaking them" do
+      skip "GC.stat(:malloc_increase_bytes) is not available" unless GC.stat.key?(:malloc_increase_bytes)
+      node_size = Cool.io::Buffer.default_node_size
+      data = "a" * (node_size * 2 + 1)
+      cycle = proc do
+        buffer << data
+        buffer.clear
+        buffer << "x"
+        buffer.clear
+      end
+
+      # Marking a Buffer frees its pool, so keep GC off from the warm-up on.
+      GC.start
+      gc_was_disabled = GC.disable
+      begin
+        3.times { cycle.call }
+        before = GC.stat(:malloc_increase_bytes)
+        200.times { cycle.call }
+        grown = GC.stat(:malloc_increase_bytes) - before
+      ensure
+        GC.enable unless gc_was_disabled
+      end
+      expect(grown).to be < node_size * 4
+    end
   end
   
   context "#read_frame" do
@@ -142,6 +210,25 @@ describe Cool.io::Buffer do
       expect(data).to eq "foo\nbarbaz"
       expect(buffer.to_str).to eq ""
     end
+
+    it "raises TypeError instead of crashing when data is not a String" do
+      buffer << "hello world"
+      expect { buffer.read_frame 12345, " ".ord }.to raise_error(TypeError)
+      expect { buffer.read_frame nil, " ".ord }.to raise_error(TypeError)
+      expect { buffer.read_frame [], " ".ord }.to raise_error(TypeError)
+    end
+
+    it "raises FrozenError when data is a frozen String" do
+      buffer << "hello world"
+      expect { buffer.read_frame "frozen".freeze, " ".ord }.to raise_error(FrozenError)
+    end
+
+    it "coerces objects responding to #to_str" do
+      buffer << "foo\nbar"
+      convertible = Object.new
+      def convertible.to_str; +""; end
+      expect(buffer.read_frame convertible, "\n".ord).to eq true
+    end
   end
 
 end

data/spec/loop_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'rbconfig'
+require 'open3'
+
+describe Cool.io::Loop do
+  it "ignores $LIBEV_FLAGS when skip_environment is true" do
+    script = <<~'RUBY'
+      require 'cool.io'
+      loop = Cool.io::Loop.new(skip_environment: true)
+      fired = false
+      timer = Cool.io::TimerWatcher.new(0.01)
+      timer.on_timer { fired = true; timer.detach }
+      timer.attach(loop)
+      loop.run
+      print fired
+    RUBY
+    lib = File.expand_path('../lib', __dir__)
+    # No CI platform has the Solaris event port backend, so honoring this would leave no backend.
+    env = { 'LIBEV_FLAGS' => Cool.io::Loop::EVBACKEND_PORT.to_s }
+    output, error, status = Open3.capture3(env, RbConfig.ruby, '-I', lib, '-e', script)
+    expect(status.success?).to eq(true), error
+    expect(output).to eq("true")
+  end
+
+  it "raises an error when no requested backend is usable" do
+    backend = RUBY_PLATFORM.include?("solaris") ? :kqueue : :port
+    expect {
+      Cool.io::Loop.new(skip_environment: true, backend: backend)
+    }.to raise_error(RuntimeError, /no usable backend/)
+  end
+end

data/spec/stat_watcher_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../spec_helper', __FILE__)
+require 'tmpdir'
 
 TEMP_FILE_PATH = "./test.txt"
 
@@ -18,12 +19,31 @@ class MyStatWatcher < Cool.io::StatWatcher
   end
 end
 
-def run_with_file_change(path)
+def run_with_file_change(path, compact: false)
   reactor = Cool.io::Loop.new
 
   sw = MyStatWatcher.new(path)
   sw.attach(reactor)
 
+  # libev retains the path pointer passed to ev_stat_init() for the lifetime of
+  # the watcher.  If the watcher held RSTRING_PTR(@path) directly, a compaction
+  # that relocates the @path String would leave libev dereferencing a stale
+  # address on every stat.  Force a maximal relocation here so the watcher keeps
+  # operating against a path buffer it owns rather than Ruby-managed memory.
+  if compact
+    if GC.respond_to?(:verify_compaction_references)
+      # verify_compaction_references moves every movable object to a fresh slot.
+      # Its keyword arguments have varied across Ruby versions, so fall back.
+      begin
+        GC.verify_compaction_references(expand_heap: true, toplevel: true)
+      rescue ArgumentError
+        GC.verify_compaction_references(expand_heap: true)
+      end
+    elsif GC.respond_to?(:compact)
+      GC.compact
+    end
+  end
+
   tw = Cool.io::TimerWatcher.new(INTERVAL, true)
   tw.on_timer do
     reactor.stop if sw.accessed
@@ -69,6 +89,71 @@ describe Cool.io::StatWatcher do
     expect(watcher.previous.ino).to eq(watcher.current.ino)
   end
 
+  it "keeps firing on_change after GC compaction relocates objects" do
+    skip "GC compaction not available" unless GC.respond_to?(:compact)
+
+    watcher = run_with_file_change(TEMP_FILE_PATH, compact: true)
+    expect(watcher.accessed).to eq(true)
+  end
+
+  it "reports sizes and timestamps beyond the 32-bit range" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "large")
+      File.write(path, "a")
+      size = 2**32 + 1
+      time = Time.utc(2040, 1, 1)
+      current = nil
+      reactor = Cool.io::Loop.new
+      watcher = Cool.io::StatWatcher.new(path, INTERVAL)
+      watcher.define_singleton_method(:on_change) { |_, cur| current = cur }
+      watcher.attach(reactor)
+
+      File.truncate(path, size)
+      File.utime(time, time, path)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+      until (current && current.size == size && current.mtime == time) ||
+            Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+        reactor.run_once(0.1)
+      end
+      watcher.detach
+
+      expect(current.size).to eq(size)
+      expect(current.mtime).to eq(time)
+    end
+  end
+
+  it "reports blksize and blocks as File.lstat does" do
+    Dir.mktmpdir do |dir|
+      path = File.join(dir, "file")
+      File.write(path, "a")
+      size = 8192
+      current = nil
+      reactor = Cool.io::Loop.new
+      watcher = Cool.io::StatWatcher.new(path, INTERVAL)
+      watcher.define_singleton_method(:on_change) { |_, cur| current = cur }
+      watcher.attach(reactor)
+      begin
+        File.write(path, "a" * size)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + 5
+        until (current && current.size == size) ||
+              Process.clock_gettime(Process::CLOCK_MONOTONIC) > deadline
+          reactor.run_once(0.1)
+        end
+      ensure
+        watcher.detach
+      end
+
+      stat = File.lstat(path)
+      expect(current).not_to be_nil
+      expect(current.blksize).to eq(stat.blksize)
+      expect(current.blocks).to eq(stat.blocks)
+    end
+  end
+
+  it "raises ArgumentError when the path contains a null byte" do
+    expect { MyStatWatcher.new("foo\0bar") }.to raise_error(ArgumentError)
+  end
+
   it "should raise when the handler does not take 2 parameters" do
     class MyStatWatcher < Cool.io::StatWatcher
       remove_method :on_change

data/spec/tcp_server_spec.rb

@@ -1,4 +1,5 @@
 require File.expand_path('../spec_helper', __FILE__)
+require 'timeout'
 
 TIMEOUT = 0.010
 HOST = '127.0.0.1'
@@ -39,13 +40,31 @@ def on_message(data)
   @data = data
 end
 
+# The reactor can be an order of magnitude slower under valgrind, so sleeping a
+# fixed interval and assuming the event was processed by then makes these specs
+# fail intermittently. Wait for the result instead. The timeout is generous
+# enough that a slow machine still passes, and a genuine hang raises
+# Timeout::Error here instead of blocking the suite forever.
+WAIT_TIMEOUT = 5.0
+
+def wait_until(timeout = WAIT_TIMEOUT)
+  Timeout.timeout(timeout) do
+    sleep 0.001 until yield
+  end
+end
+
 def test_run(data = nil)
+  @data = ""
   reactor = Coolio::Loop.new
   server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
   reactor.attach(server)
   thread = Thread.new { reactor.run }
-  send_data(data) if data
-  sleep TIMEOUT
+  if data
+    send_data(data)
+    wait_until { @data == data }
+  else
+    sleep TIMEOUT
+  end
   reactor.stop
   server.detach
   send_data('') # to leave from blocking loop
@@ -86,6 +105,7 @@ ensure
 end
 
 def test_run_timeout(data = nil, timeout = TIMEOUT)
+  @data = ""
   reactor = Coolio::Loop.new
   server = Cool.io::TCPServer.new(HOST, PORT, MyConnection, method(:on_message))
   reactor.attach(server)
@@ -95,8 +115,12 @@ def test_run_timeout(data = nil, timeout = TIMEOUT)
       reactor.run_once(timeout)
     end
   end
-  send_data(data) if data
-  sleep timeout
+  if data
+    send_data(data)
+    wait_until { @data == data }
+  else
+    sleep timeout
+  end
   server.detach
   running = false # another send is not required
   thread.join
@@ -151,9 +175,9 @@ describe Coolio::TCPServer do
       it "connected socket called on_connect" do
         begin
           connected = false
-          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { connected = true })
+          server = Cool.io::TCPServer.new(HOST, port, ServerOnConnect, proc { connected = true })
           loop.attach server
-          s = TCPSocket.open("localhost", port)
+          s = TCPSocket.open(HOST, port)
           loop.run_once
           s.close
           expect(connected).to eq true
@@ -177,9 +201,9 @@ describe Coolio::TCPServer do
       it "closed socket called on_close" do
         begin
           closed = false
-          server = Cool.io::TCPServer.new("localhost", port, ServerOnConnect, proc { closed = true })
+          server = Cool.io::TCPServer.new(HOST, port, ServerOnConnect, proc { closed = true })
           loop.attach server
-          s = TCPSocket.open("localhost", port)
+          s = TCPSocket.open(HOST, port)
           loop.run_once
           s.close
           loop.run_once
@@ -205,10 +229,10 @@ describe Coolio::TCPServer do
       it "server socket received data" do
         begin
           data = "aaa"
-          server = Cool.io::TCPServer.new("localhost", port, Echo, proc { |d| data = d })
+          server = Cool.io::TCPServer.new(HOST, port, Echo, proc { |d| data = d })
           loop.attach server
           thread = Thread.new { loop.run }
-          s = TCPSocket.open("localhost", port)
+          s = TCPSocket.open(HOST, port)
           s.write "zzz"
           sleep 0.1
           expect(data).to eq "zzz"

data/spec/watcher_reattach_spec.rb

@@ -0,0 +1,54 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe 'Watcher reattachment' do
+  [:timer, :io].each do |type|
+    [false, true].each do |disabled|
+      [false, true].each do |same_loop|
+        it "reattaches a #{disabled ? 'disabled' : 'enabled'} #{type} watcher to #{same_loop ? 'the same' : 'another'} loop" do
+          original = Coolio::Loop.new
+          destination = same_loop ? original : Coolio::Loop.new
+          if type == :io
+            server = TCPServer.new('127.0.0.1', 0)
+            writer = TCPSocket.new('127.0.0.1', server.addr[1])
+            reader = server.accept
+            server.close
+            watcher = Coolio::IOWatcher.new(reader)
+          else
+            watcher = Coolio::TimerWatcher.new(0.01, true)
+          end
+          fired = false
+          callback = proc { fired = true }
+          if type == :io
+            watcher.on_readable(&callback)
+          else
+            watcher.on_timer(&callback)
+          end
+
+          watcher.attach(original)
+          watcher.disable if disabled
+          expect(watcher.attach(destination)).to equal(watcher)
+          expect(watcher.evloop).to equal(destination)
+          expect(watcher).to be_enabled
+          expect(destination.instance_variable_get(:@active_watchers)).to eq(1)
+          unless same_loop
+            expect(original.watchers).to be_empty
+            expect(original.instance_variable_get(:@active_watchers)).to eq(0)
+          end
+
+          writer.write('a') if writer
+          sleep 0.02 if type == :timer
+          destination.run_once(0.1)
+          expect(fired).to eq(true)
+          watcher.detach
+          expect(destination.watchers).to be_empty
+          expect(destination.instance_variable_get(:@active_watchers)).to eq(0)
+        ensure
+          watcher.detach if watcher && watcher.attached?
+          reader.close if reader
+          writer.close if writer
+          server.close if server && !server.closed?
+        end
+      end
+    end
+  end
+end

data/spec/windows_stat_native_spec.rb

@@ -0,0 +1,193 @@
+require File.expand_path('../spec_helper', __FILE__)
+require 'tmpdir'
+require 'fileutils'
+require 'rbconfig'
+
+describe 'Windows stat notification internals', :if => RUBY_PLATFORM =~ /mingw|mswin/ do
+  before(:context) do
+    @build = Dir.mktmpdir('coolio-stat-native-')
+    source = File.expand_path('fixtures/windows_stat_native.c', __dir__)
+    libev = File.expand_path('../ext/libev', __dir__)
+    FileUtils.cp(source, @build)
+    File.write(File.join(@build, 'extconf.rb'), <<~RUBY)
+      begin
+        require 'devkit' if RUBY_PLATFORM =~ /mingw/
+      rescue LoadError
+        # Other Windows toolchains can provide the compiler through PATH.
+      end
+      require 'mkmf'
+      $INCFLAGS << ' -I"#{libev}"'
+      abort 'ws2_32 is required' unless have_library('ws2_32')
+      create_makefile('coolio_stat_native')
+    RUBY
+    File.open(File.join(@build, 'extconf.rb'), 'a') do |file|
+      file.write <<~'RUBY'
+        # Match cool.io's Windows link order so Winsock calls resolve to ws2_32.
+        contents = File.read('Makefile')
+        contents.gsub!(/LIBS = (.*) (\S*ws2_32\S*)/i) do
+          "LIBS = #{Regexp.last_match(2)} #{Regexp.last_match(1)}"
+        end
+        File.write('Makefile', contents)
+        make = ENV['MAKE'] || RbConfig::CONFIG['MAKE'] || (RUBY_PLATFORM =~ /mswin/ ? 'nmake' : 'make')
+        abort 'native stat test build failed' unless system(make)
+      RUBY
+    end
+    output = IO.popen([RbConfig.ruby, 'extconf.rb'], chdir: @build, err: [:child, :out], &:read)
+    raise output unless $?.success?
+  end
+
+  after(:context) do
+    FileUtils.remove_entry(@build) if @build && File.directory?(@build)
+  end
+
+  def native_result(script, *args)
+    error_log = File.join(@build, 'native-error.log')
+    command = [RbConfig.ruby, '-I', @build, '-rcoolio_stat_native', '-e',
+      "$stdout.binmode; #{script}", *args]
+    output = IO.popen(command, 'rb', err: error_log, &:read)
+    expect($?.success?).to eq(true), File.read(error_log)
+    Marshal.load(output)
+  end
+
+  def native_paths(paths)
+    args = paths.flat_map { |path, parent, _| [path, parent ? '1' : '0'] }
+    native_result(<<~'RUBY', *args)
+      paths = ARGV.each_slice(2).map { |path, parent| CoolioStatNativeSpec.path(path, parent == '1') }
+      $stdout.write(Marshal.dump(paths))
+    RUBY
+  end
+
+  it 'preserves ordinary and extended-length drive roots' do
+    paths = [
+      ['C:\\file.txt', true, 'C:\\'],
+      ['C:\\', false, 'C:\\'],
+      ['C:\\', true, 'C:\\'],
+      ['\\\\?\\C:\\file.txt', true, '\\\\?\\C:\\'],
+      ['\\\\?\\C:\\', false, '\\\\?\\C:\\'],
+      ['\\\\?\\C:\\', true, '\\\\?\\C:\\'],
+      ['\\\\?\\C:\\dir\\file', true, '\\\\?\\C:\\dir']
+    ]
+    expect(native_paths(paths)).to eq(paths.map(&:last))
+  end
+
+  it 'preserves ordinary and extended-length UNC share roots' do
+    paths = [
+      ['\\\\server\\share\\', false, '\\\\server\\share\\'],
+      ['\\\\server\\share\\', true, '\\\\server\\share\\'],
+      ['\\\\server\\share\\file', true, '\\\\server\\share\\'],
+      ['\\\\?\\UNC\\server\\share\\', false, '\\\\?\\UNC\\server\\share\\'],
+      ['\\\\?\\UNC\\server\\share\\file', true, '\\\\?\\UNC\\server\\share\\']
+    ]
+    expect(native_paths(paths)).to eq(paths.map(&:last))
+  end
+
+  it 'falls back to polling on pipe failure and recovers without creating a second pipe' do
+    path = File.join(@build, 'watched.txt')
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.check_pipe(ARGV[0])))', path)
+    expect(result).to eq(true)
+  end
+
+  it 'destroys the loop without waiting for delayed worker completions' do
+    path = File.join(@build, 'shutdown.txt')
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.check_shutdown(ARGV[0])))', path)
+    expect(result).to eq(true)
+  end
+
+  [[0, 'polling'], [1, 'notifications'], [2, 'polling after an unrelated name change']].each do |mode, description|
+    it "checks a shared directory once without alias lookups during #{description}" do
+      result = native_result(<<~'RUBY', @build, mode.to_s)
+        result = CoolioStatNativeSpec.path_work(ARGV[0], ARGV[1].to_i)
+        $stdout.write(Marshal.dump(result))
+      RUBY
+      # One open and two identity queries for 32 changed files; no alias work.
+      expect(result).to eq([1, 2, 0, true])
+    end
+  end
+
+  it 'keeps finding each watch as watchers stop, restart and re-register' do
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.watch_index(ARGV[0])))', @build)
+    expect(result).to eq([1, 2, 0, true, true])
+  end
+
+  it 'shares directories and routes name records through the directory index' do
+    result = native_result(<<~'RUBY', @build)
+      dir = File.join(ARGV[0], 'a')
+      Dir.mkdir(dir) unless Dir.exist?(dir)
+      File.write(File.join(dir, "\u00e9.txt"), 'a')
+      $stdout.write(Marshal.dump(CoolioStatNativeSpec.name_index(ARGV[0])))
+    RUBY
+    expect(result).to eq([true,
+      [false, true, false, true, false, true, true],
+      [true, true, false, true, false, true, true]])
+  end
+
+  it 'relinks changed alias names and unlinks them when the watcher stops' do
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.alias_index(ARGV[0])))', @build)
+    expect(result).to eq([true, false, true, true, true])
+  end
+
+  it 'skips name lookups for roots and wildcard names' do
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.name_guards(ARGV[0])))', @build)
+    expect(result).to eq(root: true, wildcard: true)
+  end
+
+  it 'routes records for the short and the long name of a watched file' do
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.short_alias(ARGV[0])))', @build)
+    skip 'the volume does not create 8.3 names' if result.nil?
+    expect(result).to eq(short: true, long: true)
+  end
+
+  it 'keeps sharing directories, queues and routing names after the tables grow' do
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.index_growth(ARGV[0])))', @build)
+    expect(result).to eq([true, true, true, true])
+  end
+
+  [[1, 'polling'], [0, 'an explicit registration']].each do |polling, description|
+    it "keeps a shared child directory when a relative directory moves with the current directory during #{description}" do
+      first, second = %w[cwd1 cwd2].map { |name| File.join(@build, "#{name}-#{polling}") }
+      FileUtils.mkdir_p(File.join(first, 'rel'))
+      File.write(File.join(first, 'rel', 'f.txt'), 'a')
+      FileUtils.mkdir_p(File.join(second, 'rel'))
+      script = '$stdout.write(Marshal.dump(CoolioStatNativeSpec.children_cwd(ARGV[0], ARGV[1], ARGV[2].to_i)))'
+      result = native_result(script, first, second, polling.to_s)
+      expect(result).to eq(shared: true, failed: false, moved: false, followed: true)
+    end
+  end
+
+  def replaced_dir(mode)
+    script = '$stdout.write(Marshal.dump(CoolioStatNativeSpec.replaced_dir(ARGV[0], ARGV[1].to_i)))'
+    native_result(script, @build, mode.to_s)
+  end
+
+  it 'moves directory and file watchers to a directory recreated under the same name' do
+    expect(replaced_dir(0)).to eq(directory: true, file: true)
+  end
+
+  it 'moves the watchers when a rename record arrives before the creation record' do
+    expect(replaced_dir(1)).to eq(directory: true, file: true)
+  end
+
+  it 'registers the contents of a directory that was missing while the watcher registered again' do
+    expect(replaced_dir(2)).to eq(directory: true, file: nil)
+  end
+
+  it 'refreshes aliases after replacement records and retries failed lookups' do
+    path = File.join(@build, 'aliases.txt')
+    result = native_result('$stdout.write(Marshal.dump(CoolioStatNativeSpec.alias_recovery(ARGV[0])))', path)
+    expect(result).to eq([true, true, true, true])
+  end
+
+  it 'uses effective notification flags and respects EVFLAG_NOENV' do
+    path = File.join(@build, 'flags.txt')
+    # EVFLAG_NOINOTIFY = 0x00100000; EVFLAG_NOENV = 0x01000000.
+    [[0, 1048576, false], [16777216, 1048576, true],
+     [1048576, 0, true], [17825792, 0, false]].each do |flags, environment, expected|
+      result = native_result(<<~'RUBY', path, flags.to_s, environment.to_s)
+        ENV['LIBEV_FLAGS'] = ARGV[2]
+        enabled = CoolioStatNativeSpec.notification_enabled(ARGV[0], ARGV[1].to_i)
+        $stdout.write(Marshal.dump(enabled))
+      RUBY
+      expect(result).to eq(expected), "flags=#{flags}, LIBEV_FLAGS=#{environment}"
+    end
+  end
+end