bytesize 0.1.0 → 0.1.1

data/spec/bytesize_spec.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby -w
-#
-# ByteSize
-#
-# Spec
-#
-# © 2018 Adam Hunt
-# Created: 2018-04-07
-# Modified: 2018-04-07
-#
-
-
-
-require 'rspec'
-require 'test_enum'
-require 'shared_examples'
-
-require 'bytesize'
-
-
-
-describe ByteSize do
-	TestEnum.new( base:1000 ).each do |value|
-
-		it_behaves_like "a byte size", value
-
-		#include_examples "compares to an instance of equal value correctly", new_class:IECByteSize
-
-	end
-end

data/spec/iecbytesize_spec.rb

@@ -1,30 +0,0 @@
-#!/usr/bin/env ruby -w
-#
-# ByteSize
-#
-# Spec
-#
-# © 2018 Adam Hunt
-# Created: 2018-04-07
-# Modified: 2018-04-07
-#
-
-
-
-require 'rspec'
-require 'test_enum'
-require 'shared_examples'
-
-require 'bytesize'
-
-
-
-describe IECByteSize do
-	TestEnum.new( base:1024 ).each do |value|
-
-		include_examples "a byte size", value
-
-		#include_examples "compares to an instance of equal value correctly", new_class:ByteSize
-
-	end
-end

data/spec/shared_examples.rb

@@ -1,408 +0,0 @@
-#!/usr/bin/env ruby -w
-#
-# ByteSize
-#
-# Shared Examples
-#
-# © 2018 Adam Hunt
-# Created: 2018-04-07
-# Modified: 2018-04-07
-#
-
-
-
-require 'value_class_helper'
-
-
-
-shared_examples "a byte size" do |value|
-	context "and" do
-
-		let(:instance){ described_class.new(value) }
-
-		let(:i){ instance.to_i }
-
-
-		###
-		# Initialization
-		###
-
-		context "initialized from an integer" do
-			it "returns an instance of the correct class" do
-				expect(instance.class).to be(described_class)
-			end
-			it "stores and returns the correct value" do
-				expect(i).to eq(value)
-			end
-		end
-
-
-		###
-		# Type Conversion
-		###
-
-		describe "#to_i" do
-			it "returns an integer" do
-				expect(i.class).to be(Integer)
-			end
-		end
-
-
-		###
-		# Unit Conversion
-		###
-
-		describe "#bytes" do
-			let(:v){ instance.bytes }
-			it "returns the correct value in bytes" do
-				expect(v).to eq(value)
-			end
-			it "returns an integer" do
-				expect(v.class).to eq(Integer)
-			end
-		end
-
-		describe "#to_bytes" do
-			let(:v){ instance.to_bytes }
-			it "returns the correct value in bytes" do
-				expect(v).to eq(value)
-			end
-			it "returns an integer" do
-				expect(v.class).to eq(Integer)
-			end
-		end
-
-		describe "#to_kb" do
-			let(:v){ instance.to_kb }
-			it "returns the correct value in kilobytes" do
-				expect(v).to be( value.to_f / 1000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_kib" do
-			let(:v){ instance.to_kib }
-			it "returns the correct value in kibibyte" do
-				expect(v).to be( value.to_f / 1024 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_mb" do
-			let(:v){ instance.to_mb }
-			it "returns the correct value in megabytes" do
-				expect(v).to be( value.to_f / 1000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_mib" do
-			let(:v){ instance.to_mib }
-			it "returns the correct value in mebibytes" do
-				expect(v).to be( value.to_f / 1048576 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_gb" do
-			let(:v){ instance.to_gb }
-			it "returns the correct value in gigabytes" do
-				expect(v).to be( value.to_f / 1000000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_gib" do
-			let(:v){ instance.to_gib }
-			it "returns the correct value in gibibytes" do
-				expect(v).to be( value.to_f / 1073741824 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_tb" do
-			let(:v){ instance.to_tb }
-			it "returns the correct value in terabytes" do
-				expect(v).to be( value.to_f / 1000000000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_tib" do
-			let(:v){ instance.to_tib }
-			it "returns the correct value in tebibytes" do
-				expect(v).to be( value.to_f / 1099511627776 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_pb" do
-			let(:v){ instance.to_pb }
-			it "returns the correct value in petabytes" do
-				expect(v).to be( value.to_f / 1000000000000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_pib" do
-			let(:v){ instance.to_pib }
-			it "returns the correct value in pebibytes" do
-				expect(v).to be( value.to_f / 1125899906842624 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_eb" do
-			let(:v){ instance.to_eb }
-			it "returns the correct value in exabytes" do
-				expect(v).to be( value.to_f / 1000000000000000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_eib" do
-			let(:v){ instance.to_eib }
-			it "returns the correct value in exbibytes" do
-				expect(v).to be( value.to_f / 1152921504606846976 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_zb" do
-			let(:v){ instance.to_zb }
-			it "returns the correct value in zettabytes" do
-				expect(v).to be( value.to_f / 1000000000000000000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_zib" do
-			let(:v){ instance.to_zib }
-			it "returns the correct value in zebibytes" do
-				expect(v).to be( value.to_f / 1180591620717411303424 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_yb" do
-			let(:v){ instance.to_yb }
-			it "returns the correct value in yottabytes" do
-				expect(v).to be( value.to_f / 1000000000000000000000000 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-		describe "#to_yib" do
-			let(:v){ instance.to_yib }
-			it "returns the correct value in yobibytes" do
-				expect(v).to be( value.to_f / 1208925819614629174706176 )
-			end
-			it "returns an float" do
-				expect(v.class).to eq(Float)
-			end
-		end
-
-
-		###
-		# Comparison
-		###
-
-		include_examples "compares to itself correctly"
-
-		include_examples "compares to a duplicate instance correctly"
-
-		include_examples "compares to an instance of equal value correctly"
-
-		#include_examples "compares to an equal numeric correctly", value:value.to_i
-
-		#include_examples "compares to an equal numeric correctly", value:value.to_r
-
-		#include_examples "compares to an equal float correctly", value
-
-		#larger_value = rand(value+1..1024**9)
-
-		#include_examples "compares to a larger numeric correctly", value, larger_value.to_i
-
-		#include_examples "compares to a larger numeric correctly", value, larger_value.to_r
-
-		#include_examples "compares to a larger float correctly", value, larger_value
-
-
-
-
-
-
-
-
-
-
-		# larger_value = rand(value+1..1024**9)
-
-		# context "when compared to a larger instance (#{larger_value} bytes)" do
-		# 	let(:a){ instance }
-		# 	let(:b){ described_class.new(larger_value) }
-		# 	include_examples "correct comparison", {
-		# 		:==     => false,
-		# 		:===    => false,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => -1,
-		# 		:>      => false,
-		# 		:<      => true,
-		# 		:>=     => false,
-		# 		:<=     => true
-		# 	}
-		# end
-
-		# context "when a larger instance (#{larger_value} bytes) is compared to it" do
-		# 	let(:a){ described_class.new(larger_value) }
-		# 	let(:b){ instance }
-		# 	include_examples "correct comparison", {
-		# 		:==     => false,
-		# 		:===    => false,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => 1,
-		# 		:>      => true,
-		# 		:<      => false,
-		# 		:>=     => true,
-		# 		:<=     => false
-		# 	}
-		# end
-
-		# context "when compared to a larger integer (#{larger_value.to_i})" do
-		# 	let(:a){ instance }
-		# 	let(:b){ larger_value.to_i }
-		# 	include_examples "correct comparison", {
-		# 		:==     => false,
-		# 		:===    => false,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => -1,
-		# 		:>      => false,
-		# 		:<      => true,
-		# 		:>=     => false,
-		# 		:<=     => true
-		# 	}
-		# end
-
-		# context "when a larger integer (#{larger_value.to_i}) is compared to it" do
-		# 	let(:a){ larger_value.to_i }
-		# 	let(:b){ instance }
-		# 	include_examples "correct comparison", {
-		# 		:==     => false,
-		# 		:===    => false,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => 1,
-		# 		:>      => true,
-		# 		:<      => false,
-		# 		:>=     => true,
-		# 		:<=     => false
-		# 	}
-		# end
-
-		# f = value.to_f
-		# context "when compared to a larger float (#{f})" do
-		# 	rounding_error_direction = f <=> value.to_i
-		# 	let(:a){ instance }
-		# 	let(:b){ f }
-		# 	include_examples "correct comparison", {
-		# 		:==     => rounding_error_direction.zero?,
-		# 		:===    => rounding_error_direction.zero?,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => -rounding_error_direction,
-		# 		:>      => false,
-		# 		:<      => true,
-		# 		:>=     => ( rounding_error.zero? or rounding_error.positive? ),
-		# 		:<=     => ( rounding_error.zero? or rounding_error.negative? )
-		# 	}
-		# end
-
-		# context "when an equal float is compared to it" do
-		# 	f = value.to_f
-		# 	rounding_error = value.to_i <=> value.to_f
-		# 	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
-
-		# context "when compared to an equal rational" do
-		# 	let(:a){ instance }
-		# 	let(:b){ value.to_r }
-		# 	include_examples "correct comparison", {
-		# 		:==     => true,
-		# 		:===    => true,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => 0,
-		# 		:>      => false,
-		# 		:<      => false,
-		# 		:>=     => true,
-		# 		:<=     => true
-		# 	}
-		# end
-
-		# context "when an equal rational is compared to it" do
-		# 	let(:a){ value.to_r }
-		# 	let(:b){ instance }
-		# 	include_examples "correct comparison", {
-		# 		:==     => true,
-		# 		:===    => true,
-		# 		:eql?   => false,
-		# 		:equal? => false,
-		# 		:<=>    => 0,
-		# 		:>      => false,
-		# 		:<      => false,
-		# 		:>=     => true,
-		# 		:<=     => true
-		# 	}
-		# end
-
-
-
-		include_examples "correctly reports positive, negative, and zero", value
-
-	end
-end