rspec-benchmark 0.5.1 → 0.6.0

data/spec/unit/composable_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'composable specs' do
-  it "composes perform_under and perform_at_least matchers" do
-    expect { 
-      'x' * 1024 * 10
-    }.to perform_under(6).ms and perform_at_least(10_000).ips
-  end
-end

data/spec/unit/configuration_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe RSpec::Benchmark do
-  after(:example) do
-    RSpec::Benchmark.reset_configuration
-  end
-
-  it "defaults :run_in_subprocess option to false" do
-    config = RSpec::Benchmark.configuration
-
-    expect(config.run_in_subprocess).to eq(false)
-  end
-
-  it "defaults :disable_gc option to false" do
-    config = RSpec::Benchmark.configuration
-
-    expect(config.disable_gc).to eq(false)
-  end
-
-  it "defaults :samples option to 1" do
-    config = RSpec::Benchmark.configuration
-
-    expect(config.samples).to eq(1)
-  end
-
-  it "sets :run_in_subprocess option to true" do
-    RSpec::Benchmark.configure do |config|
-      config.run_in_subprocess = true
-    end
-
-    config = RSpec::Benchmark.configuration
-
-    expect(config.run_in_subprocess).to eq(true)
-  end
-
-  it "sets :disable_gc option to true" do
-    RSpec::Benchmark.configure do |config|
-      config.disable_gc = true
-    end
-
-    config = RSpec::Benchmark.configuration
-
-    expect(config.disable_gc).to eq(true)
-  end
-
-  it "sets :samples option to 10" do
-    RSpec::Benchmark.configure do |config|
-      config.samples = 10
-    end
-
-    config = RSpec::Benchmark.configuration
-
-    expect(config.samples).to eq(10)
-  end
-
-  it "uses the :run_in_subprocess option in timing matcher" do
-    RSpec::Benchmark.configure do |config|
-      config.run_in_subprocess = true
-      config.samples = 10
-    end
-
-    bench = [0.005, 0.00001]
-    allow(::Benchmark::Perf::ExecutionTime).to receive(:run).and_return(bench)
-
-    expect { 'x' * 1024 }.to perform_under(0.1)
-
-    expect(::Benchmark::Perf::ExecutionTime).to have_received(:run).with(
-      subprocess: true, warmup: 1, repeat: 10)
-  end
-
-  it "uses the :samples option in complexity matcher" do
-    RSpec::Benchmark.configure do |config|
-      config.samples = 10
-    end
-
-    bench = [:constant, {constant: {residual: 0.9}}]
-    allow(::Benchmark::Trend).to receive(:infer_trend).and_return(bench)
-
-    expect { 'x' * 1024 }.to perform_constant
-
-    expect(::Benchmark::Trend).to have_received(:infer_trend).with(
-      [8, 64, 512, 4096, 8192], repeat: 10)
-  end
-end

data/spec/unit/format_time_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe RSpec::Benchmark, '#format_time' do
-  {
-    1e-10   => "0 ns",
-    0.42e-6 => "420 ns",
-    3.4e-6  => "3.4 μs",
-    34e-6   => "34 μs",
-    340e-6  => "340 μs",
-    1e-3    => "1 ms",
-    12e-3   => "12 ms",
-    1.0     => "1 sec",
-    1.2345  => "1.23 sec",
-    123.45  => "123 sec",
-    1234    => "1234 sec"
-  }.each do |input, expected|
-    it "#{input} -> #{expected}" do
-      expect(described_class.format_time(input)).to eq(expected)
-    end
-  end
-end

data/spec/unit/perform_allocation_spec.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "#perform_allocation" do
-  context "expect { ... }.to perform_allocation(...)" do
-    it "passes if the block performs allocations" do
-      expect {
-        _a = [Object.new]
-      }.to perform_allocation(2)
-    end
-
-    it "fails if the block doesn't perform allocation(...)" do
-      expect {
-        expect {
-          _a = [Object.new]
-        }.to perform_allocation(1)
-      }.to raise_error(/expected block to perform allocation of \d object, but allocated \d objects/)
-    end
-  end
-
-  context "expect { ... }.not_to perform_allocation(...)" do
-    it "passes if the block does not perform allocation" do
-      expect {
-        ["foo", "bar", "baz"].sort[1]
-      }.to_not perform_allocation(2)
-    end
-
-    it "fails if the block performs allocation" do
-      expect {
-        expect {
-          _a = [Object.new]
-        }.to_not perform_allocation(2)
-      }.to raise_error(/expected block not to perform allocation of \d objects, but allocated \d objects/)
-    end
-  end
-
-  context "expect { ... }.to perform_allocation(Object => ???, ...).objects" do
-    it "splits object allocations by count" do
-      expect {
-        _a = [Object.new]
-        _b = {Object.new => 'foo'}
-      }.to perform_allocation({Object => 2, Array => 1}).objects
-    end
-
-    it "fails to split object allocations by count" do
-      expect {
-        expect {
-          _a = [Object.new]
-          _b = {Object.new => 'bar'}
-        }.to perform_allocation({Object => 1, Array => 1}).objects
-      }.to raise_error("expected block to perform allocation of 1 Array and 1 Object objects, but allocated 1 Array and 2 Object objects")
-    end
-  end
-
-  context "expect { ... }.not_to perform_allocation(Object => ???, ...).objects" do
-    it "passes if the split of object allocations by count is wrong" do
-      expect {
-        _a = [Object.new]
-        _b = {Object.new => 'foo'}
-      }.to_not perform_allocation({Object => 1, Array => 1}).objects
-    end
-
-    it "fails to split object allocations by count" do
-      expect {
-        expect {
-          _a = [Object.new]
-          _b = {Object.new => 'bar'}
-        }.to_not perform_allocation({Object => 2, Array => 1}).objects
-      }.to raise_error("expected block not to perform allocation of 1 Array and 2 Object objects, but allocated 1 Array and 2 Object objects")
-    end
-  end
-
-  context "expect { ... }.to perform_allocation(...).bytes" do
-    it "passes if the block performs allocations" do
-      expect {
-        _a = [Object.new]
-        _b = {Object.new => 'foo'}
-      }.to perform_allocation(600).bytes
-    end
-
-    it "fails if the block doesn't perform allocation" do
-      expect {
-        expect {
-          _a = {Object.new => 'foo'}
-        }.to perform_allocation(10).bytes
-      }.to raise_error(/expected block to perform allocation of \d+ bytes, but allocated \d+ bytes/)
-    end
-  end
-
-  context "expect { ... }.not_to perform_allocation(...).bytes" do
-    it "passes if the block does not perform allocation" do
-      expect {
-        _a = {Object.new => 'foo'}
-      }.to_not perform_allocation(10).bytes
-    end
-
-    it "fails if the block performs allocation" do
-      expect {
-        expect {
-          _a = [Object.new]
-        }.to_not perform_allocation(200).bytes
-      }.to raise_error(/expected block not to perform allocation of \d+ bytes, but allocated \d+ bytes/)
-    end
-  end
-
-  context "expect { ... }.to perform_allocation(Object => ???, ...).bytes" do
-    it "splits object allocations by memory size" do
-      expect {
-        _a = [Object.new]
-        _b = {Object.new => 'foo'}
-      }.to perform_allocation({Object => 80, Array => 40, Hash => 500}).bytes
-    end
-
-    it "fails to split object allocations by memory size" do
-      expect {
-        expect {
-          _a = [Object.new]
-          _b = {Object.new => 'bar'}
-        }.to perform_allocation({Object => 80, Hash => 0}).bytes
-      }.to raise_error(/expected block to perform allocation of \d+ Hash and \d+ Object bytes, but allocated \d+ Hash and \d+ Object bytes/)
-    end
-  end
-
-  it "fails to recognize expectation type" do
-    expect {
-      expect { Object.new }.to perform_allocation(:error)
-    }.to raise_error(ArgumentError, "'error' is not a recognized argument")
-  end
-end

data/spec/unit/perform_at_least_spec.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe '#perform_at_least' do
-  it "allows to configure matcher timings" do
-    bench = [10_000, 100]
-    allow(::Benchmark::Perf::Iteration).to receive(:run).and_return(bench)
-
-    expect {
-      'x' * 1024 * 10
-    }.to perform_at_least(10_000).within(0.3).warmup(0.2)
-
-    expect(::Benchmark::Perf::Iteration).to have_received(:run).
-      with(time: 0.3, warmup: 0.2)
-  end
-
-  context "expect { ... }.to perform_at_least(...).ips" do
-    it "passes if the block perfoms more than 10K ips" do
-      expect {
-        'x' * 1024 * 10
-      }.to perform_at_least(10_000).ips
-    end
-
-    it "fails if the block performs less than 10K ips" do
-      expect {
-        expect {
-          'x' * 1024 * 1024
-        }.to perform_at_least(10_000).ips
-      }.to raise_error(/expected block to perform at least 10000 i\/s, but performed only \d+ \(± \d+%\) i\/s/)
-    end
-  end
-
-  context "expect { ... }.not_to perform_at_least(...).ips" do
-    it "passes if the block does not perform more than 10K ips" do
-      expect {
-        'x' * 1024 * 1024 * 10
-      }.not_to perform_at_least(10_000).ips
-    end
-
-    it "fails if the block performs more than 10K ips" do
-      expect {
-        expect { 'x' * 1024 }.not_to perform_at_least(10_000).ips
-      }.to raise_error(/expected block not to perform at least 10000 i\/s, but performed \d+ \(± \d+%\) i\/s/)
-    end
-  end
-end

data/spec/unit/perform_constant_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'RSpec::Benchmark::ComplexityMatcher', '#perform_constant' do
-  # exponential
-  def fibonacci(n)
-    n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2)
-  end
-
-  it "propagates error inside expectation" do
-    expect {
-      expect { raise 'boom' }.to perform_constant
-    }.to raise_error(StandardError, /boom/)
-  end
-
-  context "expect { ... }.to perfom_constant" do
-    it "passes if the block performs constant" do
-      expect { |n, i|
-        n * i
-      }.to perform_constant.in_range(1, 1000).sample(100)
-    end
-
-    it "fails if the block doesn't perform constant" do
-      expect {
-        expect { |n, i|
-          fibonacci(n)
-        }.to perform_constant.in_range(1, 15).ratio(2).sample(100)
-      }.to raise_error("expected block to perform constant, but performed exponential")
-    end
-  end
-
-  context "expect { ... }.not_to perfom_constant" do
-    it "passes if the block does not perform constant" do
-      expect { |n, i|
-        fibonacci(n)
-      }.not_to perform_constant.in_range(1, 15).ratio(2).sample(100)
-    end
-
-    it "fails if the block doesn't perform constant" do
-      expect {
-        expect { |n, i|
-          n * i
-        }.not_to perform_constant.in_range(1, 1000).sample(100)
-      }.to raise_error("expected block not to perform constant, but performed constant")
-    end
-  end
-end

data/spec/unit/perform_exponential_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'RSpec::Benchmark::ComplexityMatcher', '#perform_exponential' do
-  # exponential
-  def fibonacci(n)
-    n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2)
-  end
-
-  it "propagates error inside expectation" do
-    expect {
-      expect { raise 'boom' }.to perform_exponential
-    }.to raise_error(StandardError, /boom/)
-  end
-
-  context "expect { ... }.to perfom_exponential" do
-    it "passes if the block performs exponential" do
-      expect { |n, i|
-        fibonacci(n)
-      }.to perform_exp.in_range(1, 15).ratio(2).sample(100)
-    end
-
-    it "fails if the block doesn't perform exponential" do
-      expect {
-        expect { |n| n }.to perform_exponential.in_range(1, 10_000).sample(100)
-      }.to raise_error("expected block to perform exponential, but performed constant")
-    end
-  end
-
-  context "expect { ... }.not_to perfom_exponential" do
-    it "passes if the block does not perform exponential" do
-      expect { |n| n }.not_to perform_exponential.in_range(1, 10_000).sample(100)
-    end
-
-    it "fails if the block doesn't perform exponential" do
-      expect {
-        expect { |n|
-          fibonacci(n)
-        }.not_to perform_exponential.in_range(1, 15).ratio(2).sample(100)
-      }.to raise_error("expected block not to perform exponential, but performed exponential")
-    end
-  end
-end

data/spec/unit/perform_linear_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'RSpec::Benchmark::ComplexityMatcher', '#perform_linear' do
-  # exponential
-  def fibonacci(n)
-    n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2)
-  end
-
-  it "propagates error inside expectation" do
-    expect {
-      expect { raise 'boom' }.to perform_linear
-    }.to raise_error(StandardError, /boom/)
-  end
-
-  it "provides a default range" do
-    range = [1,2,3]
-    trend = [:linear, {linear: {residual: 0.95}}]
-    allow(::Benchmark::Trend).to receive(:range).and_return(range)
-    allow(::Benchmark::Trend).to receive(:infer_trend).and_return(trend)
-
-    expect { |n, i| n }.to perform_linear
-
-    expect(::Benchmark::Trend).to have_received(:range).with(8, 8192, ratio: 8)
-  end
-
-  it "changes default range using in_range and ratio matchers" do
-    range = [1,2,3]
-    trend = [:linear, {linear: {residual: 0.95}}]
-    allow(::Benchmark::Trend).to receive(:range).and_return(range)
-    allow(::Benchmark::Trend).to receive(:infer_trend).and_return(trend)
-
-    expect { |n, i| n }.to perform_linear.in_range(3, 33_000).ratio(2)
-
-    expect(::Benchmark::Trend).to have_received(:range).with(3, 33_000, ratio: 2)
-  end
-
-  it "fails when wrong argument for range" do
-    expect {
-      expect { |n, i| }.to perform_linear.in_range(1..10)
-    }.to raise_error(ArgumentError, "Wrong range argument '1..10', it expects an array or numeric start value.")
-  end
-
-  context "expect { ... }.to perfom_linear" do
-    it "passes if the block performs linear" do
-      range = bench_range(1, 8 << 10)
-      numbers = range.map { |n| Array.new(n) { rand(n) } }
-
-      expect { |n, i|
-        numbers[i].max
-      }.to perform_linear.in_range(range).sample(100).threshold(0.85)
-    end
-
-    it "fails if the block doesn't perform linear" do
-      expect {
-        expect { |n, i|
-          fibonacci(n)
-        }.to perform_linear.in_range(1, 18).ratio(2).sample(100)
-      }.to raise_error("expected block to perform linear, but performed exponential")
-    end
-  end
-
-  context "expect { ... }.not_to perfom_linear" do
-    it "passes if the block does not perform linear" do
-      expect { |n, i|
-        fibonacci(n)
-      }.not_to perform_linear.in_range(1, 18).ratio(2).sample(100)
-    end
-
-    it "fails if the block doesn't perform linear" do
-      range = bench_range(10, 8 << 12)
-      numbers = range.map { |n| Array.new(n) { rand(n) } }
-
-      expect {
-        expect { |n, i|
-          numbers[i].max
-        }.not_to perform_linear.in_range(range[0], range[-1]).sample(100)
-      }.to raise_error("expected block not to perform linear, but performed linear")
-    end
-  end
-end