sus-fixtures-benchmark 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 63078795b33d87a934f27e4b1a3499b67a5a1dbc3d4fb9c50cc83a3014dc9916
+  data.tar.gz: c2c82e5e602dfd1f3a2e9f27609cbd518fc8822b70da8bb226a606bd9f6de06a
+SHA512:
+  metadata.gz: a7fb2ab5b00ab5061b5fee54bb1bdfe0587ec6e95f811eca1b49e914a3511c0f7da13dbabe861b30c797c476c65577d3eb4200243cd2557ce19083b25269ab0a
+  data.tar.gz: 96a95d1c1e20585ff56e82035b0819f0c40cb967436ef32837bc389e67524b318e7e04b2ac863f55d172f8e108151e2850de2d169d4b36b10e796514ddb626a4

data/agent.md

@@ -0,0 +1,47 @@
+# Agent
+
+## Context
+
+This section provides links to documentation from installed packages. It is automatically generated and may be updated by running `bake agent:context:install`.
+
+**Important:** Before performing any code, documentation, or analysis tasks, always read and apply the full content of any relevant documentation referenced in the following sections. These context files contain authoritative standards and best practices for documentation, code style, and project-specific workflows. **Do not proceed with any actions until you have read and incorporated the guidance from relevant context files.**
+
+### agent-context
+
+Install and manage context files from Ruby gems.
+
+#### [Usage Guide](.context/agent-context/usage.md)
+
+`agent-context` is a tool that helps you discover and install contextual information from Ruby gems for AI agents. Gems can provide additional documentation, examples, and guidance in a `context/` ...
+
+### decode
+
+Code analysis for documentation generation.
+
+#### [Getting Started with Decode](.context/decode/getting-started.md)
+
+The Decode gem provides programmatic access to Ruby code structure and metadata. It can parse Ruby files and extract definitions, comments, and documentation pragmas, enabling code analysis, docume...
+
+#### [Documentation Coverage](.context/decode/coverage.md)
+
+This guide explains how to test and monitor documentation coverage in your Ruby projects using the Decode gem's built-in bake tasks.
+
+#### [Ruby Documentation](.context/decode/ruby-documentation.md)
+
+This guide covers documentation practices and pragmas supported by the Decode gem for documenting Ruby code. These pragmas provide structured documentation that can be parsed and used to generate A...
+
+### sus
+
+A fast and scalable test runner.
+
+#### [Using Sus Testing Framework](.context/sus/usage.md)
+
+Sus is a modern Ruby testing framework that provides a clean, BDD-style syntax for writing tests. It's designed to be fast, simple, and expressive.
+
+#### [Mocking](.context/sus/mocking.md)
+
+There are two types of mocking in sus: `receive` and `mock`. The `receive` matcher is a subset of full mocking and is used to set expectations on method calls, while `mock` can be used to replace m...
+
+#### [Shared Test Behaviors and Fixtures](.context/sus/shared.md)
+
+Sus provides shared test contexts which can be used to define common behaviours or tests that can be reused across one or more test files.

data/lib/sus/fixtures/benchmark/repeats.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+#
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "time"
+
+module Sus
+	module Fixtures
+		module Benchmark
+			# Represents a benchmarking helper that executes a block multiple times, collecting timing samples until statistical convergence is reached.
+			class Repeats
+				# Initializes a new {Repeats} object with a sampler to collect timing data.
+				# @parameter samples [Sampler] The sampler object to collect timing data.
+				def initialize(samples)
+					@samples = samples
+				end
+				
+				# Samples the execution time of the given block and adds the result to the sampler.
+				# @parameter block [Proc] The block to benchmark.
+				private def sample!(block)
+					time = Benchmark::Time.measure do
+						block.call
+					end
+					@samples.add(time.real)
+				end
+				
+				# Repeatedly executes the block until the sampler reports convergence.
+				# @parameter block [Proc] The block to benchmark.
+				def times(&block)
+					until @samples.converged?
+						sample!(block)
+					end
+				end
+			end
+		end
+	end
+end

data/lib/sus/fixtures/benchmark/sampler.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Sus
+	module Fixtures
+		module Benchmark
+			# Represents a statistical sampler for benchmarking, collecting timing samples and computing statistics.
+			class Sampler
+				B = [
+					1.570796288, 0.03706987906, -0.8364353589e-3,
+					-0.2250947176e-3, 0.6841218299e-5, 0.5824238515e-5,
+					-0.104527497e-5, 0.8360937017e-7, -0.3231081277e-8,
+					0.3657763036e-10, 0.6936233982e-12
+				]
+				private_constant :B
+				
+				# Return the inverse CDF or P-value of the corresponding integral
+				private def quantile(qn)
+					if qn < 0.0 || qn > 1.0
+						raise ArgumentError, "qn must be in the range [0, 1]"
+					end
+					
+					# Let's cache the standard normal quantiles for common values:
+					case qn
+					when 0.5
+						return 0.0
+					when 0.95
+						return 1.6448536269514722
+					when 0.96
+						return 1.7506860712521692
+					when 0.97
+						return 1.8807936081512509
+					when 0.98
+						return 2.0537489106318225
+					when 0.99
+						return 2.3263478740408408
+					end
+					
+					w1 = qn
+					w3 = -Math.log(4.0 * w1 * (1.0 - w1))
+					w1 = B[0]
+					
+					1.upto(10) do |i|
+						w1 += B[i] * w3**i
+					end
+					
+					if qn >= 0.5
+						return Math.sqrt(w1 * w3)
+					else
+						return -Math.sqrt(w1 * w3)
+					end
+				end
+				
+				# Initializes a new {Sampler} object with an optional minimum sample size, confidence level, and margin of error.
+				# @parameter minimum [Integer] The minimum number of samples required before convergence can be determined (default: 8).
+				# @parameter confidence [Float] The confidence level (default: 0.95). If we repeated this measurement process many times, % of the calculated intervals would include the true value we’re trying to estimate.
+				# @parameter margin_of_error [Float] The acceptable margin of error relative to the mean (default: 0.02, e.g. ±2%).
+				def initialize(minimum: 8, confidence: 0.95, margin_of_error: 0.02)
+					@minimum = minimum
+					@confidence = confidence
+					@margin_of_error = margin_of_error
+					
+					# Calculate the z-score for the given confidence level:
+					@z_score = quantile((1 + @confidence) / 2.0)
+					
+					# Welford's algorithm for calculating mean and variance in a single pass:
+					@count = 0
+					@mean = 0.0
+					@variance_accumulator = 0.0
+				end
+				
+				# The minimum number of samples required for convergence.
+				# @returns [Integer]
+				attr :minimum
+				
+				# Adds a new timing value to the sample set.
+				# @parameter value [Float] The timing value to add (in seconds).
+				def add(value)
+					@count += 1
+					delta = value - @mean
+					@mean += delta / @count
+					@variance_accumulator += delta * (value - @mean)
+				end
+				
+				# Returns the number of samples collected.
+				# @returns [Integer]
+				def size
+					@count
+				end
+				
+				# Returns the mean (average) of the collected samples.
+				# @returns [Float]
+				def mean
+					@mean
+				end
+				
+				# Returns the variance of the collected samples.
+				# @returns [Float | Nil] Returns nil if not enough samples.
+				def variance
+					if @count > 1
+						@variance_accumulator / (@count)
+					end
+				end
+				
+				# Returns the standard deviation of the collected samples.
+				# @returns [Float | Nil] Returns nil if not enough samples.
+				def standard_deviation
+					v = self.variance
+					v ? Math.sqrt(v) : nil
+				end
+				
+				# Returns the standard error of the mean for the collected samples.
+				# @returns [Float | Nil] Returns nil if not enough samples.
+				def standard_error
+					sd = self.standard_deviation
+					sd ? sd / Math.sqrt(@count) : nil
+				end
+				
+				# Formats a duration in seconds as a human-readable string.
+				# @parameter seconds [Float] The duration in seconds.
+				# @returns [String]
+				private def format_duration(seconds)
+					if seconds.nil?
+						return "N/A"
+					end
+					
+					if seconds < 1e-6
+						"#{(seconds * 1e9).round(2)}ns"
+					elsif seconds < 1e-3
+						"#{(seconds * 1e6).round(2)}μs"
+					elsif seconds < 1
+						"#{(seconds * 1e3).round(2)}ms"
+					else
+						"#{seconds.round(2)}s"
+					end
+				end
+				
+				# Returns a summary string of the sample statistics.
+				# @returns [String]
+				def to_s
+					"#{self.size} samples, mean: #{format_duration(self.mean)}, standard deviation: #{format_duration(self.standard_deviation)}, standard error: #{format_duration(self.standard_error)}"
+				end
+				
+				# Determines if the sample size has converged based on the confidence level and margin of error.
+				#
+				# Sampling data is always subject to some degree of uncertainty, and we want to ensure that our sample size is sufficient to provide a reliable estimate of the true value we're trying to measure (e.g. the mean execution time of a block).
+				#
+				# The mean of the data is the average of all samples, and the standard error tells us how much the sampled mean is expected to vary from the true value. So a big standard error indicates that the mean is not very reliable, and a small standard error indicates that the mean is more reliable.
+				#
+				# We could use the standard error to compute convergence, but we also want to ensure that the margin of error is within an acceptable range relative to the mean. This is where the confidence level and margin of error come into play. In other words, the margin of error is a relative measure, and we want an absolute measurement by which to determine convergence.
+				#
+				# The typical way to express this is to say that we are "confident" that the true mean is within a certain margin of error relative to the measured mean. For example, if we have a mean of 100 seconds and a margin of error of 0.02, then we are saying that we are confident (with the specified confidence level) that the true mean is within ±2 seconds (2% of the mean) of our measured mean.
+				#
+				# When we say "confident", we are referring to a statistical confidence level, which is a measure of how likely it is that the true value lies within the margin of error if we repeated the benchmark many times. A common confidence level is 95%, which means that if we repeated the measurement process many times, 95% of the calculated intervals would include the true value we’re trying to estimate, in other words, there is a 5% chance that the true value lies outside the margin of error.
+				#
+				# Assuming we are measuring in seconds, this tells us "Based on my current data, I am %confident that the true mean is within ±current_margin_of_error seconds of my measured mean." In other words, increasing the number of samples will make the margin of error smaller for the same confidence level. Given that we are asked to be at least some confidence level, we can calculate whether this is true or not yet (i.e. whether we need to keep sampling).
+				#
+				# The only caveat to this, is that we need to have at least @minimum samples before we can make this determination. If we have less than @minimum samples, we will return false. The reason for this is that we need a minimum number of samples to calculate a meaningful standard error and margin of error.
+				# @returns [Boolean] true if the sample size has converged, false otherwise.
+				def converged?
+					return false if @count < @minimum
+					# Calculate the current mean and standard error
+					mean = self.mean
+					standard_error = self.standard_error
+					if mean && standard_error
+						# Calculate the margin of error:
+						current_margin_of_error = @z_score * standard_error
+						# Normalize the margin of error relative to the mean:
+						relative_margin_of_error = @margin_of_error * mean.abs
+						# Check if the margin of error is within the acceptable range:
+						current_margin_of_error <= relative_margin_of_error
+					end
+				end
+			end
+		end
+	end
+end

data/lib/sus/fixtures/benchmark/time.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Sus
+	module Fixtures
+		module Benchmark
+			# Represents a timing sample for benchmarking, including user, system, and real time.
+			class Time
+				# Measures the execution time of a block, returning a new {Time} object with user, system, and real time.
+				# @returns [Time] The measured timing sample.
+				def self.measure
+					t0, r0 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
+					yield
+					t1, r1 = Process.times, Process.clock_gettime(Process::CLOCK_MONOTONIC)
+					
+					self.new(
+						t1.utime  - t0.utime,
+						t1.stime  - t0.stime,
+						r1 - r0,
+					)
+				end
+				
+				# Initializes a new {Time} object with user, system, and real time values.
+				# @parameter user [Float] The user CPU time in seconds.
+				# @parameter system [Float] The system CPU time in seconds.
+				# @parameter real [Float] The real (wall clock) time in seconds.
+				def initialize(user = 0.0, system = 0.0, real = 0.0)
+					@user = user
+					@system = system
+					@real = real
+				end
+				
+				# The user CPU time in seconds.
+				# @returns [Float]
+				attr :user
+				# The system CPU time in seconds.
+				# @returns [Float]
+				attr :system
+				# The real (wall clock) time in seconds.
+				# @returns [Float]
+				attr :real
+
+				# Returns a string representation of the real time in seconds.
+				# @returns [String]
+				def to_s
+					"#{self.real}s"
+				end
+				
+				# Returns a detailed string representation of the timing sample.
+				# @returns [String]
+				def inspect
+					"#<#{self.class} user=#{self.user}s system=#{self.system}s real=#{self.real}s>"
+				end
+			end
+		end
+	end
+end

data/lib/sus/fixtures/benchmark/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024-2025, by Samuel Williams.
+
+module Sus
+	module Fixtures
+		module Benchmark
+			VERSION = "0.1.0"
+		end
+	end
+end

data/lib/sus/fixtures/benchmark.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024-2025, by Samuel Williams.
+
+require_relative "benchmark/version"
+
+require_relative "benchmark/sampler"
+require_relative "benchmark/repeats"
+
+# Provides the top-level namespace for the Sus testing framework.
+module Sus
+	# Provides reusable fixtures for benchmarking code.
+	module Fixtures
+		# Provides benchmarking utilities for Sus fixtures.
+		module Benchmark
+			# Extends a test context with benchmarking helpers when included.
+			# @parameter base [Class] The test context class to extend.
+			def self.included(base)
+				base.extend(Context)
+			end
+			
+			# Provides a benchmarking measure for a test case.
+			module Measure
+				# Builds a new benchmarking measure class for a test case.
+				# @parameter parent [Class] The parent test context class.
+				# @parameter description [String] The description of the measure.
+				# @parameter unique [Boolean] Whether the measure should have a unique identity.
+				# @parameter block [Proc] The block to execute for the measure.
+				# @returns [Class] The new measure class.
+				def self.build(parent, description, unique: true, &block)
+					base = Class.new(parent)
+					base.extend(self)
+					base.description = description
+					base.identity = Identity.nested(parent.identity, base.description, unique: unique)
+					base.set_temporary_name("#{self}[#{description}]")
+					
+					if block_given?
+						base.define_method(:run, &block)
+					end
+					
+					return base
+				end
+				
+				# Returns true if this is a leaf measure.
+				# @returns [Boolean]
+				def leaf?
+					true
+				end
+				
+				# Prints the measure description to the output.
+				# @parameter output [IO] The output stream.
+				def print(output)
+					self.superclass.print(output)
+					output.write(" measure ", :it, self.description, :reset, " ", :identity, self.identity.to_s, :reset)
+				end
+				
+				# Returns a string representation of the measure.
+				# @returns [String]
+				def to_s
+					"measure #{self.description}"
+				end
+				
+				# Executes the measure within the given assertions context.
+				# @parameter assertions [Object] The assertions context.
+				def call(assertions)
+					assertions.nested(self, identity: self.identity, isolated: true, measure: true) do |assertions|
+						instance = self.new(assertions)
+						
+						samples = Sampler.new
+						repeats = Repeats.new(samples)
+						
+						instance.around do
+							instance.run(repeats)
+						end
+						
+						assertions.inform(samples.to_s)
+					end
+				end
+			end
+			
+			# Provides benchmarking helpers for test contexts.
+			module Context
+				# Measures the execution time of a block and adds a benchmarking measure to the context.
+				def measure(...)
+					add Measure.build(self, ...)
+				end
+			end
+		end
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2024-2025, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,41 @@
+# Sus::Fixtures::Benchmark
+
+Provides fixtures for sus for running benchmarks.
+
+[![Development Status](https://github.com/socketry/sus-fixtures-benchmark/workflows/Test/badge.svg)](https://github.com/socketry/sus-fixtures-benchmark/actions?workflow=Test)
+
+## Installation
+
+``` bash
+bundle add sus-fixtures-benchmark
+```
+
+## Usage
+
+Please see the [project documentation](https://suspecting.github.io/sus-fixtures-benchmark/) for more details.
+
+## Releases
+
+Please see the [project releases](https://suspecting.github.io/sus-fixtures-benchmark/releases/index) for all releases.
+
+### v0.1.0
+
+  - Added `Sus::Fixtures::Benchmark::Repeats` which is not an integer, but an instance that allows the block to be executed multiple times until the benchmark converges.
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

data/releases.md

@@ -0,0 +1,5 @@
+# Releases
+
+## v0.1.0
+
+  - Added `Sus::Fixtures::Benchmark::Repeats` which is not an integer, but an instance that allows the block to be executed multiple times until the benchmark converges.

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: sus-fixtures-benchmark
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.31'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- agent.md
+- lib/sus/fixtures/benchmark.rb
+- lib/sus/fixtures/benchmark/repeats.rb
+- lib/sus/fixtures/benchmark/sampler.rb
+- lib/sus/fixtures/benchmark/time.rb
+- lib/sus/fixtures/benchmark/version.rb
+- license.md
+- readme.md
+- releases.md
+homepage: https://github.com/suspecting/sus-fixtures-benchmark
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://suspecting.github.io/sus-fixtures-benchmark/
+  funding_uri: https://github.com/sponsors/ioquatix/
+  source_code_uri: https://github.com/suspecting/sus-fixtures-benchmark.git
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Test fixtures for benchmarking.
+test_files: []

metadata.gz.sig

@@ -0,0 +1,3 @@
+	/��kb@^�
+�6�~�Z����I'�	O��%�c�dP@*�Q���{W�+L?����T��N�P�tZ,8jH��;�@��k��S���g���J����n�[Ž��\z��,�m����-W�(J���&�6�x���;n�� �%�C��M+�R��9���Qp>E�!�<,-�L�^�l�z��
+2�(gg	o�DN$�-%@p#0,�O+)�M���I��