vagrant-unbundled 2.2.19.0 → 2.3.2.0

data/vendor/bundle/ruby/3.0.0/gems/logging-2.3.0/test/benchmark.rb

@@ -1,113 +0,0 @@
-require 'rubygems'
-
-libpath = File.expand_path('../../lib', __FILE__)
-$:.unshift libpath
-require 'logging'
-
-begin
-  gem 'log4r'
-  require 'log4r'
-  $log4r = true
-rescue LoadError
-  $log4r = false
-end
-
-require 'benchmark'
-require 'logger'
-
-module Logging
-  class Benchmark
-
-    def run
-      this_many = 300_000
-
-      pattern = Logging.layouts.pattern \
-        :pattern      => '%.1l, [%d #%p] %5l -- %c: %m\n',
-        :date_pattern => "%Y-%m-%dT%H:%M:%S.%s"
-
-      Logging.appenders.string_io('sio', :layout => pattern)
-      sio = Logging.appenders['sio'].sio
-
-      logging = ::Logging.logger['benchmark']
-      logging.level = :warn
-      logging.appenders = 'sio'
-
-      logger = ::Logger.new sio
-      logger.level = ::Logger::WARN
-
-      log4r = if $log4r
-        l4r = ::Log4r::Logger.new('benchmark')
-        l4r.level = ::Log4r::WARN
-        l4r.add ::Log4r::IOOutputter.new(
-          'benchmark', sio,
-          :formatter => ::Log4r::PatternFormatter.new(
-            :pattern => "%.1l, [%d #\#{Process.pid}] %5l : %M\n",
-            :date_pattern => "%Y-%m-%dT%H:%M:%S.%6N"
-          )
-        )
-        l4r
-      end
-
-      puts "== Debug (not logged) ==\n"
-      ::Benchmark.bm(10) do |bm|
-        bm.report('Logging:') {this_many.times {logging.debug 'not logged'}}
-        bm.report('Logger:') {this_many.times {logger.debug 'not logged'}}
-        bm.report('Log4r:') {this_many.times {log4r.debug 'not logged'}} if log4r
-      end
-
-      puts "\n== Warn (logged) ==\n"
-      ::Benchmark.bm(10) do |bm|
-        sio.seek 0
-        bm.report('Logging:') {this_many.times {logging.warn 'logged'}}
-        sio.seek 0
-        bm.report('Logger:') {this_many.times {logger.warn 'logged'}}
-        sio.seek 0
-        bm.report('Log4r:') {this_many.times {log4r.warn 'logged'}} if log4r
-      end
-
-      puts "\n== Concat ==\n"
-      ::Benchmark.bm(10) do |bm|
-        sio.seek 0
-        bm.report('Logging:') {this_many.times {logging << 'logged'}}
-        sio.seek 0
-        bm.report('Logger:') {this_many.times {logger << 'logged'}}
-        puts "Log4r:      not supported" if log4r
-      end
-
-      write_size         = 250
-      auto_flushing_size = 500
-
-      logging_async = ::Logging.logger['AsyncFile']
-      logging_async.level = :info
-      logging_async.appenders = Logging.appenders.file \
-          'benchmark_async.log',
-          :layout => pattern,
-          :write_size => write_size,
-          :auto_flushing => auto_flushing_size,
-          :async => true
-
-      logging_sync = ::Logging.logger['SyncFile']
-      logging_sync.level = :info
-      logging_sync.appenders = Logging.appenders.file \
-          'benchmark_sync.log',
-          :layout => pattern,
-          :write_size => write_size,
-          :auto_flushing => auto_flushing_size,
-          :async => false
-
-      puts "\n== File ==\n"
-      ::Benchmark.bm(20) do |bm|
-        bm.report('Logging (Async):') {this_many.times { |n| logging_async.info "Iteration #{n}"}}
-        bm.report('Logging (Sync):')  {this_many.times { |n| logging_sync.info  "Iteration #{n}"}}
-      end
-
-      File.delete('benchmark_async.log')
-      File.delete('benchmark_sync.log')
-    end
-  end
-end
-
-if __FILE__ == $0
-  bm = ::Logging::Benchmark.new
-  bm.run
-end

data/vendor/bundle/ruby/3.0.0/gems/logging-2.3.0/test/layouts/test_basic.rb

@@ -1,41 +0,0 @@
-
-require File.expand_path('../setup', File.dirname(__FILE__))
-
-module TestLogging
-module TestLayouts
-
-  class TestBasic < Test::Unit::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-      @layout = Logging.layouts.basic({})
-      @levels = Logging::LEVELS
-    end
-
-    def test_format
-      event = Logging::LogEvent.new( 'ArrayLogger', @levels['info'],
-                                     'log message', false)
-      assert_equal " INFO  ArrayLogger : log message\n", @layout.format(event)
-
-      event.data = [1, 2, 3, 4]
-      assert_equal(" INFO  ArrayLogger : <Array> #{[1,2,3,4]}\n",
-                   @layout.format(event))
-
-      event.level = @levels['debug']
-      event.data = 'and another message'
-      log = "DEBUG  ArrayLogger : and another message\n"
-      assert_equal log, @layout.format(event)
-
-      event.logger = 'Test'
-      event.level = @levels['fatal']
-      event.data = Exception.new
-      log = "FATAL  Test : <Exception> Exception\n"
-      assert_equal log, @layout.format(event)
-    end
-
-  end  # class TestBasic
-
-end  # module TestLayouts
-end  # module TestLogging
-

data/vendor/bundle/ruby/3.0.0/gems/logging-2.3.0/test/layouts/test_color_pattern.rb

@@ -1,90 +0,0 @@
-
-require File.expand_path('../../setup', __FILE__)
-
-module TestLogging
-module TestLayouts
-
-  class TestColorPattern < Test::Unit::TestCase
-    include LoggingTestCase
-    CS = ::Logging::ColorScheme
-
-    def setup
-      super
-
-      ::Logging.color_scheme :levels, :levels => {
-          :debug => :blue, :info => :green, :warn => :yellow, :error => :red, :fatal => :cyan
-      }
-
-      ::Logging.color_scheme :lines, :lines => {
-          :debug => :blue, :info => :green, :warn => :yellow, :error => :red, :fatal => :cyan
-      }, :date => :blue, :logger => :cyan
-
-      ::Logging.color_scheme :tokens, :date => :blue, :logger => :green, :message => :magenta
-
-      @levels = Logging::LEVELS
-    end
-
-    def test_level_coloring
-      layout = Logging.layouts.pattern(:color_scheme => :levels)
-      event = Logging::LogEvent.new('ArrayLogger', @levels['info'], 'log message', false)
-
-      rgxp = Regexp.new(Regexp.escape("#{CS::GREEN}INFO #{CS::RESET}"))
-      assert_match rgxp, layout.format(event)
-
-      event.level = @levels['debug']
-      rgxp = Regexp.new(Regexp.escape("#{CS::BLUE}DEBUG#{CS::RESET}"))
-      assert_match rgxp, layout.format(event)
-
-      event.level = @levels['error']
-      rgxp = Regexp.new(Regexp.escape("#{CS::RED}ERROR#{CS::RESET}"))
-      assert_match rgxp, layout.format(event)
-    end
-
-    def test_multiple_level_coloring
-      layout = Logging.layouts.pattern(:pattern => '%.1l, %5l -- %c: %m\n', :color_scheme => :levels)
-      event = Logging::LogEvent.new('ArrayLogger', @levels['info'], 'log message', false)
-
-      rgxp = Regexp.new(Regexp.escape("#{CS::GREEN}I#{CS::RESET}, #{CS::GREEN} INFO#{CS::RESET}"))
-      assert_match rgxp, layout.format(event)
-
-      event.level = @levels['debug']
-      rgxp = Regexp.new(Regexp.escape("#{CS::BLUE}D#{CS::RESET}, #{CS::BLUE}DEBUG#{CS::RESET}"))
-      assert_match rgxp, layout.format(event)
-
-      event.level = @levels['error']
-      rgxp = Regexp.new(Regexp.escape("#{CS::RED}E#{CS::RESET}, #{CS::RED}ERROR#{CS::RESET}"))
-      assert_match rgxp, layout.format(event)
-    end
-
-    def test_line_coloring
-      layout = Logging.layouts.pattern(:color_scheme => :lines)
-      event = Logging::LogEvent.new('ArrayLogger', @levels['info'], 'log message', false)
-
-      rgxp = Regexp.new('^'+Regexp.escape(CS::GREEN)+'.*?'+Regexp.escape(CS::RESET)+'$', Regexp::MULTILINE)
-      assert_match rgxp, layout.format(event)
-
-      event.level = @levels['error']
-      rgxp = Regexp.new('^'+Regexp.escape(CS::RED)+'.*?'+Regexp.escape(CS::RESET)+'$', Regexp::MULTILINE)
-      assert_match rgxp, layout.format(event)
-
-      event.level = @levels['warn']
-      rgxp = Regexp.new('^'+Regexp.escape(CS::YELLOW)+'.*?'+Regexp.escape(CS::RESET)+'$', Regexp::MULTILINE)
-      assert_match rgxp, layout.format(event)
-    end
-
-    def test_token_coloring
-      layout = Logging.layouts.pattern(:color_scheme => :tokens)
-      event = Logging::LogEvent.new('ArrayLogger', @levels['info'], 'log message', false)
-
-      rgxp = Regexp.new(
-        '^\['+Regexp.escape(CS::BLUE)+'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}'+Regexp.escape(CS::RESET)+
-        '\] INFO  -- '+Regexp.escape(CS::GREEN)+'ArrayLogger'+Regexp.escape(CS::RESET)+
-        ' : '+Regexp.escape(CS::MAGENTA)+'log message'+Regexp.escape(CS::RESET)
-      )
-      assert_match rgxp, layout.format(event)
-    end
-
-  end  # TestColorPattern
-end  # TestLayouts
-end  # TestLogging
-

data/vendor/bundle/ruby/3.0.0/gems/logging-2.3.0/test/layouts/test_json.rb

@@ -1,185 +0,0 @@
-
-require File.expand_path('../setup', File.dirname(__FILE__))
-
-module TestLogging
-module TestLayouts
-
-  class TestJson < Test::Unit::TestCase
-    include LoggingTestCase
-
-    def setup
-      super
-      @layout = Logging.layouts.json({})
-      @levels = Logging::LEVELS
-      @date_fmt = '\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{6}(Z|[+-]\d{2}:\d{2})'
-      Thread.current[:name] = nil
-    end
-
-    def test_initializer
-      assert_raise(ArgumentError) {
-        Logging.layouts.parseable.new :style => :foo
-      }
-    end
-
-    def test_format
-      event = Logging::LogEvent.new('ArrayLogger', @levels['info'],
-                                    'log message', false)
-      format = @layout.format(event)
-      assert_match %r/"timestamp":"#@date_fmt"/, format
-      assert_match %r/"level":"INFO"/, format
-      assert_match %r/"logger":"ArrayLogger"/, format
-      assert_match %r/"message":"log message"/, format
-
-      event.data = [1, 2, 3, 4]
-      format = @layout.format(event)
-      assert_match %r/"timestamp":"#@date_fmt"/, format
-      assert_match %r/"level":"INFO"/, format
-      assert_match %r/"logger":"ArrayLogger"/, format
-      assert_match %r/"message":\[1,2,3,4\]/, format
-
-      event.level = @levels['debug']
-      event.data = 'and another message'
-      format = @layout.format(event)
-      assert_match %r/"timestamp":"#@date_fmt"/, format
-      assert_match %r/"level":"DEBUG"/, format
-      assert_match %r/"logger":"ArrayLogger"/, format
-      assert_match %r/"message":"and another message"/, format
-
-      event.logger = 'Test'
-      event.level = @levels['fatal']
-      event.data = Exception.new
-      format = @layout.format(event)
-      assert_match %r/"timestamp":"#@date_fmt"/, format
-      assert_match %r/"level":"FATAL"/, format
-      assert_match %r/"logger":"Test"/, format
-      assert_match %r/"message":\{(?:"(?:class|message)":"Exception",?){2}\}/, format
-    end
-
-    def test_items
-      assert_equal %w[timestamp level logger message], @layout.items
-    end
-
-    def test_items_eq
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    ['log message'], false)
-
-      @layout.items = %w[timestamp]
-      assert_equal %w[timestamp], @layout.items
-      assert_match %r/\{"timestamp":"#@date_fmt"\}\n/, @layout.format(event)
-
-      # 'foo' is not a recognized item
-      assert_raise(ArgumentError) {
-        @layout.items = %w[timestamp logger foo]
-      }
-    end
-
-    def test_items_all
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    'log message', false)
-      event.file = 'test_file.rb'
-      event.line = 123
-      event.method_name = 'method_name'
-
-      @layout.items = %w[logger]
-      assert_equal %Q[{"logger":"TestLogger"}\n], @layout.format(event)
-
-      @layout.items = %w[file]
-      assert_equal %Q[{"file":"test_file.rb"}\n], @layout.format(event)
-
-      @layout.items = %w[level]
-      assert_equal %Q[{"level":"INFO"}\n], @layout.format(event)
-
-      @layout.items = %w[line]
-      assert_equal %Q[{"line":123}\n], @layout.format(event)
-
-      @layout.items = %w[message]
-      assert_equal %Q[{"message":"log message"}\n], @layout.format(event)
-
-      @layout.items = %w[method]
-      assert_equal %Q[{"method":"method_name"}\n], @layout.format(event)
-
-      @layout.items = %w[hostname]
-      assert_equal %Q[{"hostname":"#{Socket.gethostname}"}\n], @layout.format(event)
-
-      @layout.items = %w[pid]
-      assert_match %r/\A\{"pid":\d+\}\n\z/, @layout.format(event)
-
-      @layout.items = %w[millis]
-      assert_match %r/\A\{"millis":\d+\}\n\z/, @layout.format(event)
-
-      @layout.items = %w[thread_id]
-      assert_match %r/\A\{"thread_id":-?\d+\}\n\z/, @layout.format(event)
-
-      @layout.items = %w[thread]
-      assert_equal %Q[{"thread":null}\n], @layout.format(event)
-      Thread.current[:name] = "Main"
-      assert_equal %Q[{"thread":"Main"}\n], @layout.format(event)
-
-      @layout.items = %w[mdc]
-      assert_match %r/\A\{"mdc":\{\}\}\n\z/, @layout.format(event)
-
-      @layout.items = %w[ndc]
-      assert_match %r/\A\{"ndc":\[\]\}\n\z/, @layout.format(event)
-    end
-
-    def test_mdc_output
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    'log message', false)
-      Logging.mdc['X-Session'] = '123abc'
-      Logging.mdc['Cookie'] = 'monster'
-
-      @layout.items = %w[timestamp level logger message mdc]
-
-      format = @layout.format(event)
-      assert_match %r/"timestamp":"#@date_fmt"/, format
-      assert_match %r/"level":"INFO"/, format
-      assert_match %r/"logger":"TestLogger"/, format
-      assert_match %r/"message":"log message"/, format
-      assert_match %r/"mdc":\{(?:(?:"X-Session":"123abc"|"Cookie":"monster"),?){2}\}/, format
-
-      Logging.mdc.delete 'Cookie'
-      format = @layout.format(event)
-      assert_match %r/"mdc":\{"X-Session":"123abc"\}/, format
-    end
-
-    def test_ndc_output
-      event = Logging::LogEvent.new('TestLogger', @levels['info'],
-                                    'log message', false)
-      Logging.ndc << 'context a'
-      Logging.ndc << 'context b'
-
-      @layout.items = %w[timestamp level logger message ndc]
-
-      format = @layout.format(event)
-      assert_match %r/"timestamp":"#@date_fmt"/, format
-      assert_match %r/"level":"INFO"/, format
-      assert_match %r/"logger":"TestLogger"/, format
-      assert_match %r/"message":"log message"/, format
-      assert_match %r/"ndc":\["context a","context b"\]/, format
-
-      Logging.ndc.pop
-      format = @layout.format(event)
-      assert_match %r/"ndc":\["context a"\]/, format
-
-      Logging.ndc.pop
-      format = @layout.format(event)
-      assert_match %r/"ndc":\[\]/, format
-    end
-
-    def test_utc_offset
-      layout = Logging.layouts.json(:items => %w[timestamp])
-      event = Logging::LogEvent.new('TimestampLogger', @levels['info'], 'log message', false)
-      event.time = Time.utc(2016, 12, 1, 12, 0, 0).freeze
-
-      assert_equal %Q/{"timestamp":"2016-12-01T12:00:00.000000Z"}\n/, layout.format(event)
-
-      layout.utc_offset = "-06:00"
-      assert_equal %Q/{"timestamp":"2016-12-01T06:00:00.000000-06:00"}\n/, layout.format(event)
-
-      layout.utc_offset = "+01:00"
-      assert_equal %Q/{"timestamp":"2016-12-01T13:00:00.000000+01:00"}\n/, layout.format(event)
-    end
-  end  # class TestJson
-end  # module TestLayouts
-end  # module TestLogging
-

data/vendor/bundle/ruby/3.0.0/gems/logging-2.3.0/test/layouts/test_nested_exceptions.rb

@@ -1,124 +0,0 @@
-
-require_relative '../setup'
-
-module TestLogging
-  module TestLayouts
-    class TestNestedExceptions < Test::Unit::TestCase
-      include LoggingTestCase
-
-      def test_basic_format_obj
-        err = nil
-        begin
-          begin
-            raise ArgumentError, 'nested exception'
-          rescue
-            raise StandardError, 'root exception'
-          end
-        rescue => e
-          err = e
-        end
-
-        layout = Logging.layouts.basic({})
-        log = layout.format_obj(err)
-        assert_not_nil log.index('<StandardError> root exception')
-
-        if err.respond_to?(:cause)
-          assert_not_nil log.index('<ArgumentError> nested exception')
-          assert(log.index('<StandardError> root exception') < log.index('<ArgumentError> nested exception'))
-        end
-      end
-
-      def test_cause_depth_limiting
-        err = nil
-        begin
-          begin
-            begin
-              raise TypeError, 'nested exception 2'
-            rescue
-              raise ArgumentError, 'nested exception 1'
-            end
-          rescue
-            raise StandardError, 'root exception'
-          end
-        rescue => e
-          err = e
-        end
-
-        layout = Logging.layouts.basic(cause_depth: 1)
-        log = layout.format_obj(err)
-        assert_not_nil log.index('<StandardError> root exception')
-
-        if err.respond_to?(:cause)
-          assert_not_nil log.index('<ArgumentError> nested exception 1')
-          assert_nil log.index('<TypeError> nested exception 2')
-          assert_equal '--- Further #cause backtraces were omitted ---', log.split("\n\t").last
-        end
-      end
-
-      def test_parseable_format_obj
-        err = nil
-        begin
-          begin
-            raise ArgumentError, 'nested exception'
-          rescue
-            raise StandardError, 'root exception'
-          end
-        rescue => e
-          err = e
-        end
-
-        layout = Logging.layouts.parseable.new
-        log = layout.format_obj(err)
-        assert_equal 'StandardError', log[:class]
-        assert_equal 'root exception', log[:message]
-        assert log[:backtrace].size > 0
-
-        if err.respond_to?(:cause)
-          assert_not_nil log[:cause]
-
-          log = log[:cause]
-          assert_equal 'ArgumentError', log[:class]
-          assert_equal 'nested exception', log[:message]
-          assert_nil log[:cause]
-          assert log[:backtrace].size > 0
-        end
-      end
-
-      def test_parseable_cause_depth_limiting
-        err = nil
-        begin
-          begin
-            begin
-              raise TypeError, 'nested exception 2'
-            rescue
-              raise ArgumentError, 'nested exception 1'
-            end
-          rescue
-            raise StandardError, 'root exception'
-          end
-        rescue => e
-          err = e
-        end
-
-        layout = Logging.layouts.parseable.new(cause_depth: 1)
-        log = layout.format_obj(err)
-
-        assert_equal 'StandardError', log[:class]
-        assert_equal 'root exception', log[:message]
-        assert log[:backtrace].size > 0
-
-        if err.respond_to?(:cause)
-          assert_not_nil log[:cause]
-
-          log = log[:cause]
-          assert_equal 'ArgumentError', log[:class]
-          assert_equal 'nested exception 1', log[:message]
-          assert_equal({message: "Further #cause backtraces were omitted"}, log[:cause])
-          assert log[:backtrace].size > 0
-        end
-      end
-    end
-  end
-end
-
-require 'pp'