rspec-benchmark 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e97c37d92aad25cc4818e165c58fce09b261bd2
-  data.tar.gz: 9ca0eb8504cb3ee565f2c0708c1e5595e6563de7
+  metadata.gz: 9e2f1ed591f703a89dbf9a01070a9ba4cf893e82
+  data.tar.gz: f837f60f9864f23ff94e88a0d48adafff16fcd13
 SHA512:
-  metadata.gz: e3f034d4c0b725f1e94ead47cb8ca826757f7dad1c3e948a92b60fbfa2434935ed91a5bec606a7c411c2ecca498464499393909eb089a305793218eec2b38612
-  data.tar.gz: 87079a2e2953c7e90bc05623928a858a06514f5f7860dc45db9eaa2b7682bb345ecff4eb592a44fb506ec54dbcd4d395988bca6b0d773319920b8a278bda2ce1
+  metadata.gz: 63d13b9d25a62d5ad5e3afacb0e538b0d7b5c5bdc0f35488a375401a5e6ad86cc840dddb87b711bdf7f6a303c910d6786271fbe5e56a65ee4cbaa56947c04d56
+  data.tar.gz: df7988107e1e39c7dbfdd2c560ddfba738d9972786671245f5273cd089c50070fabbac8cd2fa9a7f186d0990cd2f18b9a29f681224f27c7bc0ab4ee00024abb9

data/.travis.yml

@@ -6,18 +6,19 @@ script: "bundle exec rake ci"
 rvm:
   - 2.0.0
   - 2.1.10
-  - 2.2.5
-  - 2.3.1
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
   - ruby-head
   - jruby-9000
   - jruby-head
-  - rbx
+  - rbx-3
 env:
   global:
     - JRUBY_OPTS="-Xcli.debug=true --debug"
 matrix:
   allow_failures:
-    - rvm: rbx
+    - rvm: rbx-3
     - rvm: ruby-head
     - rvm: jruby-head
   fast_finish: true

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change log
 
+## [v0.3.0] - 2017-02-05
+
+### Added
+* Add ComparisonMatcher with #perform_faster_than and #perform_slower_than expectations by Dmitri(@WildDima)
+* Add ability to configure timing options for all Matchers such as :warmup & :time
+
 ## [v0.2.0] - 2016-11-01
 
 ### Changed
@@ -9,5 +15,6 @@
 
 Initial release
 
+[v0.3.0]: https://github.com/peter-murach/rspec-benchmark/compare/v0.2.0...v0.3.0
 [v0.2.0]: https://github.com/peter-murach/rspec-benchmark/compare/v0.1.0...v0.2.0
 [v0.1.0]: https://github.com/peter-murach/rspec-benchmark/compare/v0.1.0

data/Gemfile

@@ -2,8 +2,8 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :metrics do
-  gem 'coveralls', '~> 0.8.9'
-  gem 'simplecov', '~> 0.10.0'
+group :test do
+  gem 'coveralls', '~> 0.8.15'
+  gem 'simplecov', '~> 0.12.0'
   gem 'yardstick', '~> 0.9.9'
 end

data/README.md

@@ -2,13 +2,13 @@
 [![Gem Version](https://badge.fury.io/rb/rspec-benchmark.svg)][gem]
 [![Build Status](https://secure.travis-ci.org/piotrmurach/rspec-benchmark.svg?branch=master)][travis]
 [![Code Climate](https://codeclimate.com/github/piotrmurach/rspec-benchmark/badges/gpa.svg)][codeclimate]
-[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/rspec-benchmark/badge.svg?branch=master)][coverage]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/rspec-benchmark/badge.svg)][coverage]
 [![Inline docs](http://inch-ci.org/github/piotrmurach/rspec-benchmark.svg?branch=master)][inchpages]
 
 [gem]: http://badge.fury.io/rb/rspec-benchmark
 [travis]: http://travis-ci.org/piotrmurach/rspec-benchmark
 [codeclimate]: https://codeclimate.com/github/piotrmurach/rspec-benchmark
-[coverage]: https://coveralls.io/github/piotrmurach/rspec-benchmark?branch=master
+[coverage]: https://coveralls.io/github/piotrmurach/rspec-benchmark
 [inchpages]: http://inch-ci.org/github/piotrmurach/rspec-benchmark
 
 > Performance testing matchers for RSpec
@@ -26,6 +26,7 @@ If you are new to performance testing you may find [Caveats](#3-caveats) section
 * [1. Usage](#1-usage)
   * [1.1 Execution Time](#11-execution-time)
   * [1.2 Iterations ](#12-iterations)
+  * [1.3 Comparison ](#13-comparison)
 * [2. Filtering](#2-filtering)
 * [3. Caveats](#3-caveats)
 
@@ -57,7 +58,7 @@ RSpec.configure do |config|
 end
 ```
 
-This will add the `perform_under` and `perform_at_least` matchers to express expected performance benchmark from code executed inside the expectation.
+This will add the `perform_under`, `perform_at_least`, `perform_faster_than` and `perform_slower_than` matchers to express expected performance benchmark for code executed inside the expectation.
 
 Alternatively, you can add matchers for particular example:
 
@@ -97,6 +98,49 @@ expect { ... }.to perform_at_least(10000).ips
 
 The `ips` part is optional but its usage clarifies the intent.
 
+The performance timining of this matcher can be tweaked using the `:time` and `:warmup` parameters. These are expressed as seconds. By default `:time` is set to `0.2` and `:warmup` to `0.1` respectively. To change parameters do:
+
+```ruby
+expect { ... }.to perform_faster_than(time: 0.4, warmup: 0.2) { ... }
+```
+
+The higher values for `:time` and `:warmup` the more accurate average readings and hence more stable tests at the cost of longer test suite overall time.
+
+### 1.3 Comparison
+
+The `perform_faster_than` and `perform_slower_than` matchers allow you to test performance of your code compared with other. For example:
+
+```ruby
+expect { ... }.to perform_faster_than { ... }
+expect { ... }.to perform_slower_than { ... }
+```
+
+And if you want to compare how much faster or slower your code is do:
+
+```ruby
+expect { ... }.to perform_faster_than { ... }.once
+expect { ... }.to perform_faster_than { ... }.twice
+expect { ... }.to perform_faster_than { ... }.exactly(5).times
+expect { ... }.to perform_faster_than { ... }.at_least(5).times
+expect { ... }.to perform_faster_than { ... }.at_most(5).times
+
+expect { ... }.to perform_slower_than { ... }.once
+expect { ... }.to perform_slower_than { ... }.twice
+expect { ... }.to perform_slower_than { ... }.at_least(5).times
+expect { ... }.to perform_slower_than { ... }.at_most(5).times
+expect { ... }.to perform_slower_than { ... }.exactly(5).times
+```
+
+The `times` part is also optional.
+
+The performance timining of each matcher can be tweaked using the `:time` and `:warmup` parameters. These are expressed as seconds. By default `:time` is set to `0.2` and `:warmup` to `0.1` respectively. To change parameters do:
+
+```ruby
+expect { ... }.to perform_faster_than(time: 0.4, warmup: 0.2) { ... }
+```
+
+The higher values for `:time` and `:warmup` the more accurate average readings and hence more stable tests at the cost of longer test suite overall time.
+
 ## 2 Filtering
 
 Usually performance tests are best left for CI or occasional runs that do not affect TDD/BDD cycle. To achieve isolation you can use RSpec filters. For instance, in `spec_helper`:
@@ -136,4 +180,4 @@ If you have any other observations please share them!
 
 ## Copyright
 
-Copyright (c) 2016 Piotr Murach. See LICENSE for further details.
+Copyright (c) 2016-2017 Piotr Murach. See LICENSE for further details.

data/Rakefile

@@ -5,6 +5,6 @@ require "bundler/gem_tasks"
 FileList['tasks/**/*.rake'].each(&method(:import))
 
 desc 'Run all specs'
-task ci: %w[ spec ]
+task ci: %w[ coverage ]
 
 task default: :spec

data/lib/rspec/benchmark/comparison_matcher.rb

@@ -0,0 +1,237 @@
+# encoding: utf-8
+
+module RSpec
+  module Benchmark
+    module ComparisonMatcher
+      # Implements the `perform_faster_than` and `perform_slower_than` matchers
+      #
+      # @api private
+      class Matcher
+        def initialize(expected, comparison_type, **options)
+          check_comparison(comparison_type)
+          @expected = expected
+          @comparison_type = comparison_type
+          @count = 1
+          @count_type = :at_least
+          time   = options.fetch(:time) { 0.2 }
+          warmup = options.fetch(:warmup) { 0.1 }
+          @bench = ::Benchmark::Perf::Iteration.new(time: time, warmup: warmup)
+        end
+
+        # Indicates this matcher matches against a block
+        #
+        # @return [True]
+        #
+        # @api private
+        def supports_block_expectations?
+          true
+        end
+
+        def matcher_name
+          "perform_#{@comparison_type}_than"
+        end
+
+        # @return [Boolean]
+        #
+        # @api private
+        def matches?(block)
+          @actual = block
+          return false unless @actual.is_a?(Proc)
+
+          @expected_ips, @expected_stdev, = @bench.run(&@expected)
+          @actual_ips, @actual_stdev, = @bench.run(&@actual)
+
+          @ratio = @actual_ips / @expected_ips.to_f
+
+          case @count_type
+          when :at_most
+            at_most_comparison
+          when :exactly
+            exact_comparison
+          else
+            default_comparison
+          end
+        end
+
+        # Specify the minimum number of times a block
+        # is faster/slower than other.
+        # @api public
+        def at_least(n)
+          set_expected_times_count(:at_least, n)
+          self
+        end
+
+        # Specify the maximum number of times a block
+        # is faster/slower than another.
+        # @api public
+        def at_most(n)
+          set_expected_times_count(:at_most, n)
+          self
+        end
+
+        # Specify exact number of times a block
+        # is faster/slower than another.
+        # @api public
+        def exactly(n)
+          set_expected_times_count(:exactly, n)
+          self
+        end
+
+        # Specify that the code runs faster/slower exactly once.
+        # @api public
+        def once
+          exactly(1)
+          self
+        end
+
+        # Specify that the code runs faster/slower exactly twice.
+        def twice
+          exactly(2)
+          self
+        end
+
+        # Specify that the code runs faster/slower exactly thrice.
+        # @api public
+        def thrice
+          exactly(3)
+          self
+        end
+
+        # No-op, syntactic sugar.
+        # @api public
+        def times
+          self
+        end
+
+        # @api private
+        def failure_message
+          "expected given block to #{description}, but #{failure_reason}"
+        end
+
+        # @api private
+        def failure_message_when_negated
+          "expected given block not to #{description}, but #{failure_reason}"
+        end
+
+        # @api private
+        def description
+          if @count == 1
+            "perform #{@comparison_type} than comparison block"
+          else
+            "perform #{@comparison_type} than comparison block " \
+            "by #{@count_type} #{@count} times"
+          end
+        end
+
+        # @api private
+        def failure_reason
+          return "was not a block" unless @actual.is_a?(Proc)
+
+          if @ratio < 1
+            "performed slower by #{format('%.2f', (@ratio**-1))} times"
+          elsif @ratio > 1
+            "performed faster by #{format('%.2f', @ratio)} times"
+          else
+            "performed by the same time"
+          end
+        end
+
+        private
+
+        def convert_count(n)
+          case n
+          when Numeric then n
+          when :once then 1
+          when :twice then 2
+          when :thrice then 3
+          else
+            raise "The #{matcher_name} matcher is not designed to be used " \
+                  "with #{n} count type."
+          end
+        end
+
+        def set_expected_times_count(type, n)
+          @count_type = type
+          @count = convert_count(n)
+        end
+
+        # @return [Boolean]
+        # @example
+        #   @actual = 40
+        #   @count = 41
+        #   perform_faster_than { ... }.at_most(@count).times # => true
+        #
+        #   @actual = 40
+        #   @count = 41
+        #   perform_faster_than { ... }.at_most(@count).times # => false
+        #
+        #   @actual = 1/40
+        #   @count = 41
+        #   perform_slower_than { ... }.at_most(@count).times # => true
+        #
+        #   @actual = 1/40
+        #   @count = 41
+        #   perform_slower_than { ... }.at_most(@count).times # => false
+        # @api private
+        def at_most_comparison
+          if @comparison_type == :faster
+            1 < @ratio && @ratio < @count
+          else
+            @count**-1 < @ratio && @ratio < 1
+          end
+        end
+
+        # Check if expected ips is faster/slower than actual ips
+        # exactly number of counts.
+        #
+        # @example
+        #   @actual = 40.1
+        #   @count = 40
+        #   perform_faster_than { ... }.exact(@count).times # => true
+        #
+        #   @actual = 40.1
+        #   @count = 41
+        #   perform_faster_than { ... }.exact(@count).times # => true
+        #
+        # @return [Boolean]
+        #
+        # @api private
+        def exact_comparison
+          @count == @ratio.round
+        end
+
+        # @return [Boolean]
+        # @example
+        #   @actual = 41
+        #   @count = 40
+        #   perform_faster_than { ... } # => true
+        #
+        #   @actual = 41
+        #   @count = 40
+        #   perform_faster_than { ... }.at_least(@count).times # => true
+        #
+        #   @actual = 1/40
+        #   @count = 41
+        #   perform_slower_than { ... }.at_least(@count).times # => false
+        #
+        #   @actual = 1/41
+        #   @count = 40
+        #   perform_slower_than { ... }.at_least(@count).times # => true
+        # @api private
+        def default_comparison
+          if @comparison_type == :faster
+            @ratio / @count > 1
+          else
+            @ratio / @count < 1 / @count.to_f
+          end
+        end
+
+        def check_comparison(type)
+          [:slower, :faster].include?(type) ||
+            (raise ArgumentError, 'comparison_type must be ' \
+                   ":faster or :slower, not `:#{type}`")
+        end
+      end # Matcher
+    end # ComparisonMatcher
+  end # Benchmark
+end # RSpec

data/lib/rspec/benchmark/iteration_matcher.rb

@@ -7,8 +7,11 @@ module RSpec
       #
       # @api private
       class Matcher
-        def initialize(iterations, options = {})
+        def initialize(iterations, **options)
           @iterations = iterations
+          time   = options.fetch(:time) { 0.2 }
+          warmup = options.fetch(:warmup) { 0.1 }
+          @bench = ::Benchmark::Perf::Iteration.new(time: time, warmup: warmup)
         end
 
         # Indicates this matcher matches against a block
@@ -24,8 +27,7 @@ module RSpec
         #
         # @api private
         def matches?(block)
-          @bench = ::Benchmark::Perf::Iteration.new
-          @average, @stddev, _ = @bench.run(&block)
+          @average, @stddev, = @bench.run(&block)
           @iterations <= (@average + 3 * @stddev)
         end
 

data/lib/rspec/benchmark/matchers.rb

@@ -2,6 +2,7 @@
 
 require 'rspec/benchmark/timing_matcher'
 require 'rspec/benchmark/iteration_matcher'
+require 'rspec/benchmark/comparison_matcher'
 
 module RSpec
   module Benchmark
@@ -31,7 +32,7 @@ module RSpec
       #   expect { ... }.to perform_at_least(10000).ips
       #
       # @api public
-      def perform_at_least(iterations, options = {})
+      def perform_at_least(iterations, **options)
         IterationMatcher::Matcher.new(iterations, options)
       end
 
@@ -45,9 +46,35 @@ module RSpec
       #   expect { ... }.to peform_under(10).ms
       #
       # @api public
-      def perform_under(threshold, options = {})
+      def perform_under(threshold, **options)
         TimingMatcher::Matcher.new(threshold, options)
       end
+
+      # Passes if code block performs faster than sample block
+      #
+      # @param [Proc] sample
+      #
+      # @example
+      #   expect { ... }.to peform_faster_than { ... }
+      #   expect { ... }.to peform_faster_than { ... }.at_least(5).times
+      #
+      # @api public
+      def perform_faster_than(**options, &sample)
+        ComparisonMatcher::Matcher.new(sample, :faster, options)
+      end
+
+      # Passes if code block performs slower than sample block
+      #
+      # @param [Proc] sample
+      #
+      # @example
+      #   expect { ... }.to peform_slower_than { ... }
+      #   expect { ... }.to peform_slower_than { ... }.at_most(5).times
+      #
+      # @api public
+      def perform_slower_than(**options, &sample)
+        ComparisonMatcher::Matcher.new(sample, :slower, options)
+      end
     end # Matchers
   end # Benchmark
 end # RSpec

data/lib/rspec/benchmark/timing_matcher.rb

@@ -11,12 +11,14 @@ module RSpec
 
         attr_reader :threshold
 
-        def initialize(threshold, options = {})
+        def initialize(threshold, **options)
           @threshold = threshold
           @samples = options.fetch(:samples) { 30 }
           @scale = threshold.to_s.split(/\./).last.size
           @block = nil
           @confidence_interval = nil
+          warmup = options.fetch(:warmup) { 1 }
+          @bench = ::Benchmark::Perf::ExecutionTime.new(warmup: warmup)
         end
 
         # Indicates this matcher matches against a block
@@ -34,7 +36,6 @@ module RSpec
         def matches?(block)
           @block = block
           return false unless block.is_a?(Proc)
-          @bench = ::Benchmark::Perf::ExecutionTime.new
           @average, @stddev = @bench.run(@samples, &block)
           @average <= @threshold
         end
@@ -51,7 +52,7 @@ module RSpec
         def secs
           self
         end
-        alias_method :sec, :secs
+        alias sec secs
 
         # Tell this matcher to convert threshold to ms
         # @api public

data/lib/rspec/benchmark/version.rb

@@ -2,6 +2,6 @@
 
 module RSpec
   module Benchmark
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end # Benchmark
 end # RSpec

data/spec/unit/comparison_matcher_spec.rb

@@ -0,0 +1,183 @@
+# encoding: utf-8
+
+RSpec.describe RSpec::Benchmark::ComparisonMatcher::Matcher do
+
+  it "validates comparison type" do
+    expect {
+      described_class.new(-> { 1 + 2 }, :unknown)
+    }.to raise_error(ArgumentError, /comparison_type must be :faster or :slower, not `:unknown`/)
+  end
+
+  it "raises expectation error when not given a block" do
+    expect {
+      expect(1 + 1).to perform_faster_than { 'x' * 10 * 1024 }
+    }.to raise_error(RSpec::Expectations::ExpectationNotMetError,
+    "expected given block to perform faster than comparison block, but was not a block")
+  end
+
+  it "allows to configure matcher timings" do
+    bench = double(run: 100)
+    allow(::Benchmark::Perf::Iteration).to receive(:new).and_return(bench)
+    sample = -> { 'x' * 10 * 1024 }
+    expect { 1 << 1 }.to perform_faster_than(warmup: 0.2, time: 0.3, &sample).exactly(1).times
+
+    expect(::Benchmark::Perf::Iteration).to have_received(:new).
+      with(time: 0.3, warmup: 0.2)
+  end
+
+  describe "expect { ... }.to perform_faster_than(...)" do
+    it "passes if the block performs faster than sample" do
+      expect { 1 << 1 }.to perform_faster_than { 'x' * 10 * 1024 }
+    end
+
+    it "fails if the block performs slower than sample" do
+      expect {
+        expect { 'x' * 10 * 1024 }.to perform_faster_than { 1 << 1 }
+      }.to raise_error(/expected given block to perform faster than comparison block, but performed slower by \d+.\d+ times/)
+    end
+
+    context 'with exact count' do
+      it "passes if the block performs faster than sample" do
+        expect { 1 << 1 }.to perform_faster_than { 1 << 1 }.exactly(1).times
+      end
+
+      it "passes if the block performs specified number of times" do
+        expect { 1 << 1 }.to perform_faster_than { 1 << 1 }.once
+      end
+    end
+
+    context "with at_least count" do
+      it "passes if the block performs faster by count times" do
+        expect { 1 << 1 }.to perform_faster_than { 'x' * 10 * 1024 }.at_least(2)
+      end
+
+      it "fails if the block doesn't perform faster by count times" do
+        expect {
+          expect {
+            'x' * 10 * 1024
+          }.to perform_faster_than { 1 << 1 }.at_least(2).times
+        }.to raise_error(/expected given block to perform faster than comparison block by at_least \d+ times, but performed slower by \d+.\d+ times/)
+      end
+    end
+
+    context "with at_most count" do
+      it "passes if the block performs faster than sample" do
+        expect { 1 << 1 }.to perform_faster_than { 'x' * 10 * 1024 }.at_most(125)
+      end
+
+      it "fails if the block performs faster than sample more than in 20 times" do
+        expect {
+          expect {
+            1 << 1
+          }.to perform_faster_than { 'x' * 10 * 1024 }.at_most(2).times
+        }.to raise_error(/expected given block to perform faster than comparison block by at_most \d+ times, but performed faster by \d+.\d+ times/)
+      end
+    end
+  end
+
+  context "expect { ... }.not_to perform_faster_than(...)" do
+    it "passes if the block performs slower than sample" do
+      expect { 'x' * 10 * 1024 }.not_to perform_faster_than { 1 << 1 }
+    end
+
+    it "fails if the block performs faster than sample" do
+      expect {
+        expect { 1 << 1 }.not_to perform_faster_than { 'x' * 10 * 1024 }
+      }.to raise_error(/expected given block not to perform faster than comparison block, but performed faster by \d+.\d+ times/)
+    end
+
+    context 'with at_least count' do
+      it "passes if the block performs slower than sample" do
+        expect {
+          'x' * 10 * 1024
+        }.not_to perform_faster_than { 1 << 1 }.at_least(20).times
+      end
+
+      it "fails if the block performs faster than sample" do
+        expect {
+          expect {
+            1 << 1
+          }.not_to perform_faster_than { 'x' * 10 * 1024 }.at_least(2).times
+        }.to raise_error(/expected given block not to perform faster than comparison block by at_least \d+ times, but performed faster by \d+.\d+ times/)
+      end
+    end
+  end
+
+  describe "expect { ... }.not_to perform_slower_than(...)" do
+    it "passes if the block performs faster than sample" do
+      expect { 1 << 1 }.not_to perform_slower_than { 'x' * 10 * 1024 }
+    end
+
+    it "fails if the block performs slower than sample" do
+      expect {
+        expect { 'x' * 10 * 1024 }.not_to perform_slower_than { 1 << 1 }
+      }.to raise_error(/expected given block not to perform slower than comparison block, but performed slower by \d+.\d+ times/)
+    end
+
+    context "with at_least count" do
+      it "passes if the block performs faster than sample" do
+        expect {
+          1 << 1
+        }.not_to perform_slower_than { 'x' * 10 * 1024 }.at_least(2).times
+      end
+
+      it "fails if the block performs slower than sample" do
+        expect {
+          expect {
+            'x' * 10 * 1024
+          }.not_to perform_slower_than { 1 << 1 }.at_least(5).times
+        }.to raise_error(/expected given block not to perform slower than comparison block by at_least \d+ times, but performed slower by \d+.\d+ times/)
+      end
+    end
+  end
+
+  describe "expect { ... }.to perform_slower_than(...)" do
+    it "passes if the block performs slower than sample" do
+      expect { 'x' * 10 * 1024 }.to perform_slower_than { 1 << 1 }
+    end
+
+    it "fails if the block performs faster than sample" do
+      expect {
+        expect { 1 << 1 }.to perform_slower_than { 'x' * 10 * 1024 }
+      }.to raise_error(/expected given block to perform slower than comparison block, but performed faster by \d+.\d+ times/)
+    end
+
+    context "with at_least count" do
+      it "passes if the block does performs slower than sample" do
+        expect {
+          'x' * 10 * 1024
+        }.to perform_slower_than { 1 << 1 }.at_least(20).times
+      end
+
+      it "fails if the block does performs faster than sample" do
+        expect {
+          expect {
+            1 << 1
+          }.to perform_slower_than { 'x' * 10 * 1024 }.at_least(2).times
+        }.to raise_error(/expected given block to perform slower than comparison block by at_least \d+ times, but performed faster by \d+.\d+ times/)
+      end
+    end
+
+    context "with exact count" do
+      it "passes if the block performs slower than sample" do
+        expect { 1 << 1 }.to perform_slower_than { 1 << 1 }.exactly(1).times
+      end
+    end
+
+    context "with at_most count" do
+      it "passes if the block performs faster than sample" do
+        expect {
+          'x' * 10 * 1024
+        }.to perform_slower_than { 1 << 1 }.at_most(125).times
+      end
+
+      it "fails if the block performs slower than sample more than in 20 times" do
+        expect {
+          expect {
+            'x' * 10 * 1024
+          }.to perform_slower_than { 1 << 1 }.at_most(2).times
+        }.to raise_error(/expected given block to perform slower than comparison block by at_most \d+ times, but performed slower by \d+.\d+ times/)
+      end
+    end
+  end
+end

data/spec/unit/perform_at_least_spec.rb

@@ -2,6 +2,17 @@
 
 RSpec.describe '#perform_at_least' do
 
+  it "allows to configure matcher timings" do
+    bench = double(run: [10_000, 100])
+    allow(::Benchmark::Perf::Iteration).to receive(:new).and_return(bench)
+    expect {
+      'x' * 1024 * 10
+    }.to perform_at_least(10_000, warmup: 0.2, time: 0.3)
+
+    expect(::Benchmark::Perf::Iteration).to have_received(:new).
+      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 {

data/spec/unit/perform_under_spec.rb

@@ -2,11 +2,18 @@
 
 RSpec.describe 'RSpec::Benchmark::TimingMatcher', '#perform_under' do
   it "propagates error inside expectation" do
-    expect { 
+    expect {
       expect { raise 'boom' }.to perform_under(0.01).sec
     }.to raise_error(StandardError, /boom/)
   end
 
+  it "allows to configure warmup cycles" do
+    bench = double(run: [0.005, 0.00001])
+    allow(::Benchmark::Perf::ExecutionTime).to receive(:new).and_return(bench)
+    expect { 'x' * 1024 * 10 }.to perform_under(0.006, warmup: 2).sec.and_sample(2)
+    expect(::Benchmark::Perf::ExecutionTime).to have_received(:new).with(warmup: 2)
+  end
+
   context "expect { ... }.to perfom_under(...).and_sample" do
     it "passes if the block performs under threshold" do
       expect {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-benchmark
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Murach
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-01 00:00:00.000000000 Z
+date: 2017-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-perf
@@ -96,6 +96,7 @@ files:
 - Rakefile
 - lib/rspec-benchmark.rb
 - lib/rspec/benchmark.rb
+- lib/rspec/benchmark/comparison_matcher.rb
 - lib/rspec/benchmark/format_time.rb
 - lib/rspec/benchmark/iteration_matcher.rb
 - lib/rspec/benchmark/matchers.rb
@@ -103,6 +104,7 @@ files:
 - lib/rspec/benchmark/version.rb
 - rspec-benchmark.gemspec
 - spec/spec_helper.rb
+- spec/unit/comparison_matcher_spec.rb
 - spec/unit/format_time_spec.rb
 - spec/unit/perform_at_least_spec.rb
 - spec/unit/perform_under_spec.rb
@@ -134,6 +136,7 @@ specification_version: 4
 summary: Performance testing matchers for RSpec
 test_files:
 - spec/spec_helper.rb
+- spec/unit/comparison_matcher_spec.rb
 - spec/unit/format_time_spec.rb
 - spec/unit/perform_at_least_spec.rb
 - spec/unit/perform_under_spec.rb