require_relative 'local_in_procs'

f = lambda { message }
a = {:message => "Hello, world!"}

# Test the speed when using normal proc params
f_control = lambda {|a| a[:message] }

def rand_letters(n, l)
  r = []
  n.times do
    a = ""
    l.times do
      a << ("a".."z").to_a[rand(26)]
    end
    r << a
  end
  r
end

def rands(n)
  r = []
  n.times do
    r << rand
  end
  r
end


a_1 = {:message => "Hello, world!"}
a_10 = Hash[ rand_letters(9, 8).zip(rands(9)) << [:message, "Hello, world!"] ]
a_100 = Hash[ rand_letters(99, 8).zip(rands(99)) << [:message, "Hello, world!"] ]
a_1000 = Hash[ rand_letters(999, 8).zip(rands(999)) << [:message, "Hello, world!"] ]

n = 1000
as = [a_1, a_10, a_100, a_1000]

require 'benchmark'

Benchmark.bm(20) do |x|
  as.each do |a|
    puts "\na.size = #{a.size} ----------------------------------------------------------"
    x.report "  in a class:" do
      n.times { in_class(a, f) }
    end

    x.report "  multi-use class:" do
      n.times { in_missing_class(a, f) }
    end

    x.report "  multi-use object:" do
      n.times { in_missing_object(a, f) }
    end

    x.report "  control case:" do
      n.times { f_control.call(a) }
    end

    x.report "  control in class:" do
      n.times { in_missing_class(a, f_control) }
    end

    x.report "  control in object:" do
      n.times { in_missing_object(a, f_control) }
    end

    GC.start # Make sure to run each run as though freshly started
  end
end