logstash-output-scalyr 0.1.3 → 0.1.8

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/Rakefile

@@ -1,6 +0,0 @@
-require 'bundler/gem_tasks'
-
-require 'rake/testtask'
-Rake::TestTask.new
-
-task :default => :test

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/connection_pool.gemspec

@@ -1,21 +0,0 @@
-# -*- encoding: utf-8 -*-
-require "./lib/connection_pool/version"
-
-Gem::Specification.new do |s|
-  s.name        = "connection_pool"
-  s.version     = ConnectionPool::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Mike Perham", "Damian Janowski"]
-  s.email       = ["mperham@gmail.com", "damian@educabilia.com"]
-  s.homepage    = "https://github.com/mperham/connection_pool"
-  s.description = s.summary = %q{Generic connection pool for Ruby}
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-  s.license = "MIT"
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency 'minitest', '>= 5.0.0'
-  s.add_development_dependency 'rake'
-end

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/lib/connection_pool.rb

@@ -1,161 +0,0 @@
-require_relative 'connection_pool/version'
-require_relative 'connection_pool/timed_stack'
-
-
-# Generic connection pool class for e.g. sharing a limited number of network connections
-# among many threads.  Note: Connections are lazily created.
-#
-# Example usage with block (faster):
-#
-#    @pool = ConnectionPool.new { Redis.new }
-#
-#    @pool.with do |redis|
-#      redis.lpop('my-list') if redis.llen('my-list') > 0
-#    end
-#
-# Using optional timeout override (for that single invocation)
-#
-#    @pool.with(timeout: 2.0) do |redis|
-#      redis.lpop('my-list') if redis.llen('my-list') > 0
-#    end
-#
-# Example usage replacing an existing connection (slower):
-#
-#    $redis = ConnectionPool.wrap { Redis.new }
-#
-#    def do_work
-#      $redis.lpop('my-list') if $redis.llen('my-list') > 0
-#    end
-#
-# Accepts the following options:
-# - :size - number of connections to pool, defaults to 5
-# - :timeout - amount of time to wait for a connection if none currently available, defaults to 5 seconds
-#
-class ConnectionPool
-  DEFAULTS = {size: 5, timeout: 5}
-
-  class Error < RuntimeError
-  end
-
-  def self.wrap(options, &block)
-    Wrapper.new(options, &block)
-  end
-
-  def initialize(options = {}, &block)
-    raise ArgumentError, 'Connection pool requires a block' unless block
-
-    options = DEFAULTS.merge(options)
-
-    @size = options.fetch(:size)
-    @timeout = options.fetch(:timeout)
-
-    @available = TimedStack.new(@size, &block)
-    @key = :"current-#{@available.object_id}"
-    @key_count = :"current-#{@available.object_id}-count"
-  end
-
-if Thread.respond_to?(:handle_interrupt)
-
-  # MRI
-  def with(options = {})
-    Thread.handle_interrupt(Exception => :never) do
-      conn = checkout(options)
-      begin
-        Thread.handle_interrupt(Exception => :immediate) do
-          yield conn
-        end
-      ensure
-        checkin
-      end
-    end
-  end
-
-else
-
-  # jruby 1.7.x
-  def with(options = {})
-    conn = checkout(options)
-    begin
-      yield conn
-    ensure
-      checkin
-    end
-  end
-
-end
-
-  def checkout(options = {})
-    if ::Thread.current[@key]
-      ::Thread.current[@key_count]+= 1
-      ::Thread.current[@key]
-    else
-      ::Thread.current[@key_count]= 1
-      ::Thread.current[@key]= @available.pop(options[:timeout] || @timeout)
-    end
-  end
-
-  def checkin
-    if ::Thread.current[@key]
-      if ::Thread.current[@key_count] == 1
-        @available.push(::Thread.current[@key])
-        ::Thread.current[@key]= nil
-      else
-        ::Thread.current[@key_count]-= 1
-      end
-    else
-      raise ConnectionPool::Error, 'no connections are checked out'
-    end
-
-    nil
-  end
-
-  def shutdown(&block)
-    @available.shutdown(&block)
-  end
-
-  # Size of this connection pool
-  def size
-    @size
-  end
-
-  # Number of pool entries available for checkout at this instant.
-  def available
-    @available.length
-  end
-
-  private
-
-  class Wrapper < ::BasicObject
-    METHODS = [:with, :pool_shutdown]
-
-    def initialize(options = {}, &block)
-      @pool = options.fetch(:pool) { ::ConnectionPool.new(options, &block) }
-    end
-
-    def with(&block)
-      @pool.with(&block)
-    end
-
-    def pool_shutdown(&block)
-      @pool.shutdown(&block)
-    end
-
-    def pool_size
-      @pool.size
-    end
-
-    def pool_available
-      @pool.available
-    end
-
-    def respond_to?(id, *args)
-      METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
-    end
-
-    def method_missing(name, *args, &block)
-      with do |connection|
-        connection.send(name, *args, &block)
-      end
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/lib/connection_pool/monotonic_time.rb

@@ -1,66 +0,0 @@
-# Global monotonic clock from Concurrent Ruby 1.0.
-# Copyright (c) Jerry D'Antonio -- released under the MIT license.
-# Slightly modified; used with permission.
-# https://github.com/ruby-concurrency/concurrent-ruby
-
-require 'thread'
-
-class ConnectionPool
-
-  class_definition = Class.new do
-
-    if defined?(Process::CLOCK_MONOTONIC)
-
-      # @!visibility private
-      def get_time
-        Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      end
-
-    elsif defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
-
-      # @!visibility private
-      def get_time
-        java.lang.System.nanoTime() / 1_000_000_000.0
-      end
-
-    else
-
-      # @!visibility private
-      def initialize
-        @mutex = Mutex.new
-        @last_time = Time.now.to_f
-      end
-
-      # @!visibility private
-      def get_time
-        @mutex.synchronize do
-          now = Time.now.to_f
-          if @last_time < now
-            @last_time = now
-          else # clock has moved back in time
-            @last_time += 0.000_001
-          end
-        end
-      end
-    end
-  end
-
-  ##
-  # Clock that cannot be set and represents monotonic time since
-  # some unspecified starting point.
-  #
-  # @!visibility private
-  GLOBAL_MONOTONIC_CLOCK = class_definition.new
-  private_constant :GLOBAL_MONOTONIC_CLOCK
-
-  class << self
-    ##
-    # Returns the current time a tracked by the application monotonic clock.
-    #
-    # @return [Float] The current monotonic time when `since` not given else
-    #   the elapsed monotonic time between `since` and the current time
-    def monotonic_time
-      GLOBAL_MONOTONIC_CLOCK.get_time
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/lib/connection_pool/timed_stack.rb

@@ -1,176 +0,0 @@
-require 'thread'
-require 'timeout'
-require_relative 'monotonic_time'
-
-##
-# Raised when you attempt to retrieve a connection from a pool that has been
-# shut down.
-
-class ConnectionPool::PoolShuttingDownError < RuntimeError; end
-
-##
-# The TimedStack manages a pool of homogeneous connections (or any resource
-# you wish to manage).  Connections are created lazily up to a given maximum
-# number.
-
-# Examples:
-#
-#    ts = TimedStack.new(1) { MyConnection.new }
-#
-#    # fetch a connection
-#    conn = ts.pop
-#
-#    # return a connection
-#    ts.push conn
-#
-#    conn = ts.pop
-#    ts.pop timeout: 5
-#    #=> raises Timeout::Error after 5 seconds
-
-class ConnectionPool::TimedStack
-  attr_reader :max
-
-  ##
-  # Creates a new pool with +size+ connections that are created from the given
-  # +block+.
-
-  def initialize(size = 0, &block)
-    @create_block = block
-    @created = 0
-    @que = []
-    @max = size
-    @mutex = Mutex.new
-    @resource = ConditionVariable.new
-    @shutdown_block = nil
-  end
-
-  ##
-  # Returns +obj+ to the stack.  +options+ is ignored in TimedStack but may be
-  # used by subclasses that extend TimedStack.
-
-  def push(obj, options = {})
-    @mutex.synchronize do
-      if @shutdown_block
-        @shutdown_block.call(obj)
-      else
-        store_connection obj, options
-      end
-
-      @resource.broadcast
-    end
-  end
-  alias_method :<<, :push
-
-  ##
-  # Retrieves a connection from the stack.  If a connection is available it is
-  # immediately returned.  If no connection is available within the given
-  # timeout a Timeout::Error is raised.
-  #
-  # +:timeout+ is the only checked entry in +options+ and is preferred over
-  # the +timeout+ argument (which will be removed in a future release).  Other
-  # options may be used by subclasses that extend TimedStack.
-
-  def pop(timeout = 0.5, options = {})
-    options, timeout = timeout, 0.5 if Hash === timeout
-    timeout = options.fetch :timeout, timeout
-
-    deadline = ConnectionPool.monotonic_time + timeout
-    @mutex.synchronize do
-      loop do
-        raise ConnectionPool::PoolShuttingDownError if @shutdown_block
-        return fetch_connection(options) if connection_stored?(options)
-
-        connection = try_create(options)
-        return connection if connection
-
-        to_wait = deadline - ConnectionPool.monotonic_time
-        raise Timeout::Error, "Waited #{timeout} sec" if to_wait <= 0
-        @resource.wait(@mutex, to_wait)
-      end
-    end
-  end
-
-  ##
-  # Shuts down the TimedStack which prevents connections from being checked
-  # out.  The +block+ is called once for each connection on the stack.
-
-  def shutdown(&block)
-    raise ArgumentError, "shutdown must receive a block" unless block_given?
-
-    @mutex.synchronize do
-      @shutdown_block = block
-      @resource.broadcast
-
-      shutdown_connections
-    end
-  end
-
-  ##
-  # Returns +true+ if there are no available connections.
-
-  def empty?
-    (@created - @que.length) >= @max
-  end
-
-  ##
-  # The number of connections available on the stack.
-
-  def length
-    @max - @created + @que.length
-  end
-
-  private
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must returns true if a connection is available on the stack.
-
-  def connection_stored?(options = nil)
-    !@que.empty?
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must return a connection from the stack.
-
-  def fetch_connection(options = nil)
-    @que.pop
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must shut down all connections on the stack.
-
-  def shutdown_connections(options = nil)
-    while connection_stored?(options)
-      conn = fetch_connection(options)
-      @shutdown_block.call(conn)
-    end
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must return +obj+ to the stack.
-
-  def store_connection(obj, options = nil)
-    @que.push obj
-  end
-
-  ##
-  # This is an extension point for TimedStack and is called with a mutex.
-  #
-  # This method must create a connection if and only if the total number of
-  # connections allowed has not been met.
-
-  def try_create(options = nil)
-    unless @created == @max
-      object = @create_block.call
-      @created += 1
-      object
-    end
-  end
-end

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/test/helper.rb

@@ -1,8 +0,0 @@
-gem 'minitest'
-
-require 'minitest/pride'
-require 'minitest/autorun'
-
-$VERBOSE = 1
-
-require_relative '../lib/connection_pool'

data/vendor/bundle/jruby/2.5.0/gems/connection_pool-2.2.2/test/test_connection_pool.rb

@@ -1,516 +0,0 @@
-require_relative 'helper'
-
-class TestConnectionPool < Minitest::Test
-
-  class NetworkConnection
-    SLEEP_TIME = 0.1
-
-    def initialize
-      @x = 0
-    end
-
-    def do_something
-      @x += 1
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def fast
-      @x += 1
-    end
-
-    def do_something_with_block
-      @x += yield
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def respond_to?(method_id, *args)
-      method_id == :do_magic || super(method_id, *args)
-    end
-  end
-
-  class Recorder
-    def initialize
-      @calls = []
-    end
-
-    attr_reader :calls
-
-    def do_work(label)
-      @calls << label
-    end
-  end
-
-  def use_pool(pool, size)
-    Array.new(size) do
-      Thread.new do
-        pool.with do sleep end
-      end
-    end.each do |thread|
-      Thread.pass until thread.status == 'sleep'
-    end
-  end
-
-  def kill_threads(threads)
-    threads.each do |thread|
-      thread.kill
-      thread.join
-    end
-  end
-
-  def test_basic_multithreaded_usage
-    pool_size = 5
-    pool = ConnectionPool.new(size: pool_size) { NetworkConnection.new }
-
-    start = Time.new
-
-    generations = 3
-
-    result = Array.new(pool_size * generations) do
-      Thread.new do
-        pool.with do |net|
-          net.do_something
-        end
-      end
-    end.map(&:value)
-
-    finish = Time.new
-
-    assert_equal((1..generations).cycle(pool_size).sort, result.sort)
-
-    assert_operator(finish - start, :>, generations * NetworkConnection::SLEEP_TIME)
-  end
-
-  def test_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-    thread = Thread.new do
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    end
-
-    Thread.pass while thread.status == 'run'
-
-    assert_raises Timeout::Error do
-      pool.with { |net| net.do_something }
-    end
-
-    thread.join
-
-    pool.with do |conn|
-      refute_nil conn
-    end
-  end
-
-  def test_with
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.with do
-      assert_raises Timeout::Error do
-        Thread.new { pool.checkout }.join
-      end
-    end
-
-    assert Thread.new { pool.checkout }.join
-  end
-
-  def test_with_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    assert_raises Timeout::Error do
-      Timeout.timeout(0.01) do
-        pool.with do |obj|
-          assert_equal 0, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
-          sleep 0.015
-        end
-      end
-    end
-    assert_equal 1, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
-  end
-
-  def test_checkout_ignores_timeout
-    skip("Thread.handle_interrupt not available") unless Thread.respond_to?(:handle_interrupt)
-
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-    def pool.checkout(options)
-      sleep 0.015
-      super
-    end
-
-    did_something = false
-    assert_raises Timeout::Error do
-      Timeout.timeout(0.01) do
-        pool.with do |obj|
-          did_something = true
-          # Timeout::Error will be triggered by any non-trivial Ruby code
-          # executed here since it couldn't be raised during checkout.
-          # It looks like setting the local variable above does not trigger
-          # the Timeout check in MRI 2.2.1.
-          obj.tap { obj.hash }
-        end
-      end
-    end
-    assert did_something
-    assert_equal 1, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
-  end
-
-  def test_explicit_return
-    pool = ConnectionPool.new(timeout: 0, size: 1) do
-      mock = Minitest::Mock.new
-      def mock.disconnect!
-        raise "should not disconnect upon explicit return"
-      end
-      mock
-    end
-
-    pool.with do |conn|
-      return true
-    end
-  end
-
-  def test_with_timeout_override
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-
-    t = Thread.new do
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    end
-
-    Thread.pass while t.status == 'run'
-
-    assert_raises Timeout::Error do
-      pool.with { |net| net.do_something }
-    end
-
-    pool.with(timeout: 2 * NetworkConnection::SLEEP_TIME) do |conn|
-      refute_nil conn
-    end
-  end
-
-  def test_checkin
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-    conn = pool.checkout
-
-    assert_raises Timeout::Error do
-      Thread.new { pool.checkout }.join
-    end
-
-    pool.checkin
-
-    assert_same conn, Thread.new { pool.checkout }.value
-  end
-
-  def test_returns_value
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-    assert_equal 1, pool.with {|o| 1 }
-  end
-
-  def test_checkin_never_checkout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    e = assert_raises ConnectionPool::Error do
-      pool.checkin
-    end
-
-    assert_equal 'no connections are checked out', e.message
-  end
-
-  def test_checkin_no_current_checkout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.checkout
-    pool.checkin
-
-    assert_raises ConnectionPool::Error do
-      pool.checkin
-    end
-  end
-
-  def test_checkin_twice
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.checkout
-    pool.checkout
-
-    pool.checkin
-
-    assert_raises Timeout::Error do
-      Thread.new do
-        pool.checkout
-      end.join
-    end
-
-    pool.checkin
-
-    assert Thread.new { pool.checkout }.join
-  end
-
-  def test_checkout
-    pool = ConnectionPool.new(size: 1) { NetworkConnection.new }
-
-    conn = pool.checkout
-
-    assert_kind_of NetworkConnection, conn
-
-    assert_same conn, pool.checkout
-  end
-
-  def test_checkout_multithread
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-    conn = pool.checkout
-
-    t = Thread.new do
-      pool.checkout
-    end
-
-    refute_same conn, t.value
-  end
-
-  def test_checkout_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 0) { Object.new }
-
-    assert_raises Timeout::Error do
-      pool.checkout
-    end
-  end
-
-  def test_checkout_timeout_override
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-
-    thread = Thread.new do
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    end
-
-    Thread.pass while thread.status == 'run'
-
-    assert_raises Timeout::Error do
-      pool.checkout
-    end
-
-    assert pool.checkout timeout: 2 * NetworkConnection::SLEEP_TIME
-  end
-
-  def test_passthru
-    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    assert_equal 1, pool.do_something
-    assert_equal 2, pool.do_something
-    assert_equal 5, pool.do_something_with_block { 3 }
-    assert_equal 6, pool.with { |net| net.fast }
-  end
-
-  def test_passthru_respond_to
-    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    assert pool.respond_to?(:with)
-    assert pool.respond_to?(:do_something)
-    assert pool.respond_to?(:do_magic)
-    refute pool.respond_to?(:do_lots_of_magic)
-  end
-
-  def test_return_value
-    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    result = pool.with do |net|
-      net.fast
-    end
-    assert_equal 1, result
-  end
-
-  def test_heavy_threading
-    pool = ConnectionPool.new(timeout: 0.5, size: 3) { NetworkConnection.new }
-
-    threads = Array.new(20) do
-      Thread.new do
-        pool.with do |net|
-          sleep 0.01
-        end
-      end
-    end
-
-    threads.map { |thread| thread.join }
-  end
-
-  def test_reuses_objects_when_pool_not_saturated
-    pool = ConnectionPool.new(size: 5) { NetworkConnection.new }
-
-    ids = 10.times.map do
-      pool.with { |c| c.object_id }
-    end
-
-    assert_equal 1, ids.uniq.size
-  end
-
-  def test_nested_checkout
-    recorder = Recorder.new
-    pool = ConnectionPool.new(size: 1) { recorder }
-    pool.with do |r_outer|
-      @other = Thread.new do |t|
-        pool.with do |r_other|
-          r_other.do_work('other')
-        end
-      end
-
-      pool.with do |r_inner|
-        r_inner.do_work('inner')
-      end
-
-      Thread.pass
-
-      r_outer.do_work('outer')
-    end
-
-    @other.join
-
-    assert_equal ['inner', 'outer', 'other'], recorder.calls
-  end
-
-  def test_shutdown_is_executed_for_all_connections
-    recorders = []
-
-    pool = ConnectionPool.new(size: 3) do
-      Recorder.new.tap { |r| recorders << r }
-    end
-
-    threads = use_pool pool, 3
-
-    pool.shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
-  end
-
-  def test_raises_error_after_shutting_down
-    pool = ConnectionPool.new(size: 1) { true }
-
-    pool.shutdown { }
-
-    assert_raises ConnectionPool::PoolShuttingDownError do
-      pool.checkout
-    end
-  end
-
-  def test_runs_shutdown_block_asynchronously_if_connection_was_in_use
-    recorders = []
-
-    pool = ConnectionPool.new(size: 3) do
-      Recorder.new.tap { |r| recorders << r }
-    end
-
-    threads = use_pool pool, 2
-
-    pool.checkout
-
-    pool.shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"], ["shutdown"], []], recorders.map { |r| r.calls }
-
-    pool.checkin
-
-    assert_equal [["shutdown"], ["shutdown"], ["shutdown"]], recorders.map { |r| r.calls }
-  end
-
-  def test_raises_an_error_if_shutdown_is_called_without_a_block
-    pool = ConnectionPool.new(size: 1) { }
-
-    assert_raises ArgumentError do
-      pool.shutdown
-    end
-  end
-
-  def test_shutdown_is_executed_for_all_connections_in_wrapped_pool
-    recorders = []
-
-    wrapper = ConnectionPool::Wrapper.new(size: 3) do
-      Recorder.new.tap { |r| recorders << r }
-    end
-
-    threads = use_pool wrapper, 3
-
-    wrapper.pool_shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
-  end
-
-  def test_wrapper_method_missing
-    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
-
-    assert_equal 1, wrapper.fast
-  end
-
-  def test_wrapper_respond_to_eh
-    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
-
-    assert_respond_to wrapper, :with
-
-    assert_respond_to wrapper, :fast
-    refute_respond_to wrapper, :"nonexistent method"
-  end
-
-  def test_wrapper_with
-    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { Object.new }
-
-    wrapper.with do
-      assert_raises Timeout::Error do
-        Thread.new do
-          wrapper.with { flunk 'connection checked out :(' }
-        end.join
-      end
-    end
-
-    assert Thread.new { wrapper.with { } }.join
-  end
-
-  class ConnWithEval
-    def eval(arg)
-      "eval'ed #{arg}"
-    end
-  end
-
-  def test_wrapper_kernel_methods
-    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { ConnWithEval.new }
-
-    assert_equal "eval'ed 1", wrapper.eval(1)
-  end
-
-  def test_wrapper_with_connection_pool
-    recorder = Recorder.new
-    pool = ConnectionPool.new(size: 1) { recorder }
-    wrapper = ConnectionPool::Wrapper.new(pool: pool)
-
-    pool.with { |r| r.do_work('with') }
-    wrapper.do_work('wrapped')
-
-    assert_equal ['with', 'wrapped'], recorder.calls
-  end
-
-  def test_stats_without_active_connection
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-
-    assert_equal(2, pool.size)
-    assert_equal(2, pool.available)
-  end
-
-  def test_stats_with_active_connection
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-
-    pool.with do
-      assert_equal(1, pool.available)
-    end
-  end
-end