bytesize 0.1.0 → 0.1.1

data/spec/test_enum.rb

@@ -1,86 +0,0 @@
-#!/usr/bin/env ruby -w
-#
-# ByteSize
-#
-# TestEnum
-#
-# An enumerable class that generates integer test values that include a range around each
-# unit transition point and a random set of intervals in between.
-#
-# © 2018 Adam Hunt
-# Created: 2018-04-07
-# Modified: 2018-04-07
-#
-
-
-
-class TestEnum
-	include Enumerable
-
-	def initialize( base:, num_powers:8, transition_range:(-2..2), random_intervals:5, negative:true )
-		@base             = base.to_i
-		@num_powers       = num_powers.to_i
-
-		@transition_range = transition_range.is_a?(Range) ? transition_range.freeze : Range.new(*transition_range).freeze
-		if @transition_range.max.nil? then
-			@transition_range = Range( @transition_range.last, @transition_range.first ).freeze
-		end
-
-		@random_intervals = random_intervals.to_i
-		@negative         = !! negative
-	end
-
-	attr_reader :base, :num_powers, :transition_range, :random_intervals
-
-	def negative?; @negative; end
-
-	def each
-		return enum_for(:each) unless block_given?
-
-		(( negative? ? -num_powers : 0 )..num_powers).inject(nil) do |last, current|
-			current = current == 0 ? 0 : (base**current.abs) * ( current.negative? ? -1 : 1 )
-
-			unless last.nil? or transition_range.max.nil?
-				interval_range = (last+transition_range.max+1..current+transition_range.min-1)
-
-				unless interval_range.max.nil?
-					if interval_range.size <= random_intervals
-						interval_range.each do |i|
-							yield(i)
-						end
-					else
-						intervals = []
-						random_intervals.times do
-							begin
-								r = rand(interval_range)
-							end while intervals.include?(r)
-							intervals.push(r)
-						end
-						intervals.sort!
-						intervals.each do |i|
-							yield(i)
-						end
-					end
-				end
-
-			end
-
-			if negative? or current != 0
-				transition_range.each do |r|
-					yield( current + r )
-				end
-			else
-				if transition_range.max != 0
-					(0..transition_range.max).each do |r|
-						yield( current + r )
-					end
-				end
-			end
-
-			current
-		end
-
-		return nil
-	end
-
-end

data/spec/value_class_helper.rb

@@ -1,363 +0,0 @@
-#!/usr/bin/env ruby -w
-#
-# Value Classes Helper
-#
-# © 2018 Adam Hunt
-# Created: 2018-04-07
-# Modified: 2018-04-08
-#
-
-
-
-shared_examples "correct comparison" do |op_hash|
-	raise( TypeError, "expected #{Hash}, got #{op_hash.class}" ) unless op_hash.is_a?(Hash)
-
-	op_hash.each do |op,v|
-		describe "with \##{op}" do
-			it "returns #{v.inspect}" do
-				expect( a.send( op, b ) ).to be v
-			end
-		end
-	end
-
-end
-
-
-
-shared_examples "compares to itself correctly" do
-
-	context "when compared to itself" do
-		let(:a){ instance }
-		let(:b){ instance }
-		include_examples "correct comparison", {
-			:==     => true,
-			:===    => true,
-			:eql?   => true,
-			:equal? => true,
-			:<=>    => 0,
-			:>      => false,
-			:<      => false,
-			:>=     => true,
-			:<=     => true
-		}
-	end
-
-end
-
-
-
-shared_examples "compares to a duplicate instance correctly" do |reverse:true|
-
-	let(:other){ described_class.new(instance) }
-
-	context "when compared to a duplicate" do
-		let(:a){ instance }
-		let(:b){ other }
-		include_examples "correct comparison", {
-			:==     => true,
-			:===    => true,
-			:eql?   => true,
-			:equal? => false,
-			:<=>    => 0,
-			:>      => false,
-			:<      => false,
-			:>=     => true,
-			:<=     => true
-		}
-	end
-
-	if reverse
-		context "a duplicate is compared to it" do
-			let(:a){ other }
-			let(:b){ instance }
-			include_examples "correct comparison", {
-				:==     => true,
-				:===    => true,
-				:eql?   => true,
-				:equal? => false,
-				:<=>    => 0,
-				:>      => false,
-				:<      => false,
-				:>=     => true,
-				:<=     => true
-			}
-		end
-	end
-
-end
-
-
-
-shared_examples "compares to an instance of equal value correctly" do |new_class:nil, reverse:true, to_method:(:to_i)|
-
-	let(:num){ instance.send(to_method) }
-	
-	if new_class.nil?
-		cont = "when compared to an instance of equal value"
-		rcont = "an instance of equal value is compared to it"
-		let(:other){ described_class.new(num) }
-	else
-		cont = "when compared to an instance of #{new_class} of equal value"
-		rcont = "an instance of #{new_class} of equal value is compared to it"
-		let(:other){ new_class.new(num) }
-	end
-
-	context cont do
-		let(:a){ instance }
-		let(:b){ other }
-		include_examples "correct comparison", {
-			:==     => true,
-			:===    => true,
-			:eql?   => true,
-			:equal? => false,
-			:<=>    => 0,
-			:>      => false,
-			:<      => false,
-			:>=     => true,
-			:<=     => true
-		}
-	end
-
-	if reverse
-		context rcont do
-			let(:a){ other }
-			let(:b){ instance }
-			include_examples "correct comparison", {
-				:==     => true,
-				:===    => true,
-				:eql?   => true,
-				:equal? => false,
-				:<=>    => 0,
-				:>      => false,
-				:<      => false,
-				:>=     => true,
-				:<=     => true
-			}
-		end
-	end
-
-end
-
-
-
-shared_examples "compares to an equal numeric correctly" do |value:nil, reverse:true, to_method:(:to_i)|
-
-	let(:other) do
-		unless value.nil?
-			v = value
-			raise( StandardError, "comparison value must be a #{Numeric}" ) unless v.is_a?(Numeric)
-		else
-			v = instance.send(to_method)
-			raise( StandardError, "to_method did not return a #{Numeric}" ) unless v.is_a?(Numeric)
-		end
-		v
-	end
-
-	context "when compared to an equal numeric" do
-		let(:a){ instance }
-		let(:b){ other }
-		include_examples "correct comparison", {
-			:==     => true,
-			:===    => true,
-			:eql?   => false,
-			:equal? => false,
-			:<=>    => 0,
-			:>      => false,
-			:<      => false,
-			:>=     => true,
-			:<=     => true
-		}
-	end
-
-	if reverse
-		context "when an equal numeric is compared to it" do
-			let(:a){ other }
-			let(:b){ instance }
-			include_examples "correct comparison", {
-				:==     => true,
-				:===    => true,
-				:eql?   => false,
-				:equal? => false,
-				:<=>    => 0,
-				:>      => false,
-				:<      => false,
-				:>=     => true,
-				:<=     => true
-			}
-		end
-	end
-
-end
-
-
-
-shared_examples "compares to a larger numeric correctly" do |instance_value, num, reverse=true|
-
-	if num.is_a?(Float)
-		raise( NotImplimentedError, " use \"compares to an larger float correctly\" instead" )
-	end
-
-	context "when compared to a larger #{num.class}" do
-		let(:a){ instance }
-		let(:b){ num }
-		include_examples "correct comparison", {
-			:==     => false,
-			:===    => false,
-			:eql?   => false,
-			:equal? => false,
-			:<=>    => -1,
-			:>      => false,
-			:<      => true,
-			:>=     => false,
-			:<=     => true
-		}
-	end
-
-	if reverse
-		context "when an equal #{num.class} is compared to it" do
-			let(:a){ num }
-			let(:b){ instance }
-			include_examples "correct comparison", {
-				:==     => false,
-				:===    => false,
-				:eql?   => false,
-				:equal? => false,
-				:<=>    => 1,
-				:>      => true,
-				:<      => false,
-				:>=     => true,
-				:<=     => false
-			}
-		end
-	end
-
-end
-
-
-
-shared_examples "compares to an equal float correctly" do |instance_value, num, reverse=true|
-
-	f = num.to_f
-
-	rounding_error = ( f <=> num )
-
-	context "when compared to an equal #{f.class}" do
-		let(:a){ instance }
-		let(:b){ f }
-		include_examples "correct comparison", {
-			:==     => rounding_error.zero?,
-			:===    => rounding_error.zero?,
-			:eql?   => false,
-			:equal? => false,
-			:<=>    => -rounding_error,
-			:>      => rounding_error.negative?,
-			:<      => rounding_error.positive?,
-			:>=     => ( rounding_error.zero? or rounding_error.negative? ),
-			:<=     => ( rounding_error.zero? or rounding_error.positive? )
-		}
-	end
-
-	if reverse
-		context "when an equal #{f.class} is compared to it" do
-			let(:a){ f }
-			let(:b){ instance }
-			include_examples "correct comparison", {
-				:==     => rounding_error.zero?,
-				:===    => rounding_error.zero?,
-				:eql?   => false,
-				:equal? => false,
-				:<=>    => rounding_error,
-				:>      => rounding_error.positive?,
-				:<      => rounding_error.negative?,
-				:>=     => ( rounding_error.zero? or rounding_error.positive? ),
-				:<=     => ( rounding_error.zero? or rounding_error.negative? )
-			}
-		end
-	end
-
-end
-
-
-
-shared_examples "compares to a larger float correctly" do |instance_value, num, reverse=true|
-
-	f = num.to_f
-
-	rounding_error = ( f <=> num )
-
-	rounding_error_collision = ( f <=> instance_value )
-
-	context "when compared to a larger #{f.class}" do
-		let(:a){ instance }
-		let(:b){ f }
-		include_examples "correct comparison", {
-			:==     => rounding_error_collision.zero?,
-			:===    => rounding_error_collision.zero?,
-			:eql?   => false,
-			:equal? => false,
-			:<=>    => -rounding_error_collision,
-			:>      => rounding_error_collision.negative?,
-			:<      => rounding_error_collision.positive?,
-			:>=     => ( rounding_error_collision.zero? or rounding_error_collision.positive? ),
-			:<=     => ( rounding_error_collision.zero? or rounding_error_collision.negative? )
-		}
-	end
-
-	if reverse
-		context "when a larger #{f.class} is compared to it" do
-			let(:a){ f }
-			let(:b){ instance }
-			include_examples "correct comparison", {
-				:==     => rounding_error_collision.zero?,
-				:===    => rounding_error_collision.zero?,
-				:eql?   => false,
-				:equal? => false,
-				:<=>    => rounding_error_collision,
-				:>      => rounding_error_collision.positive?,
-				:<      => rounding_error_collision.negative?,
-				:>=     => ( rounding_error_collision.zero? or rounding_error_collision.negative? ),
-				:<=     => ( rounding_error_collision.zero? or rounding_error_collision.positive? )
-			}
-		end
-	end
-
-end
-
-
-
-shared_examples "correctly reports positive, negative, and zero" do |value|
-
-	describe "#positive?" do
-		let(:v){ instance.positive? }
-		it "returns a boolean" do
-			expect(v).to be(true).or be(false)
-		end
-		expected_value = ( value.positive? )
-		it "returns #{expected_value.inspect}" do
-			expect(v).to be(expected_value)
-		end
-	end
-
-	describe "#negative?" do
-		let(:v){ instance.negative? }
-		it "returns a boolean" do
-			expect(v).to be(true).or be(false)
-		end
-		expected_value = ( value.negative? )
-		it "returns #{expected_value.inspect}" do
-			expect(v).to be(expected_value)
-		end
-	end
-
-	describe "#zero?" do
-		let(:v){ instance.zero? }
-		it "returns a boolean" do
-			expect(v).to be(true).or be(false)
-		end
-		expected_value = ( value.zero? )
-		it "returns #{expected_value.inspect}" do
-			expect(v).to be(expected_value)
-		end
-	end
-
-end