ruby-fizzbuzz 0.7.0 → 0.8.0

data/CHANGES.rdoc

@@ -1,84 +0,0 @@
-fizzbuzz (0.7.0)
-
-  * Added to_hash, as_json, to_json and from_json (singleton) to the FizzBuzz class.
-  * Add rudimentary Vagrantfile that can be used to build a development environment.
-  * Re-factored fizzbuzz (singleton) from the FizzBuzz class to speed it up.
-  * No longer use of Enumerable#entries in the Array integration, achieving better performance.
-  * Correctly return Enumerator when integrating with the Range class.
-  * Updated Rakefile to no longer run test before benchmark.
-  * Fixed benchmarks concerning Array and Range integration.
-  * Retired testing with Ruby 1.9.2 and 2.1.0, and added 2.1.5 on Travis CI.
-  * Fixed Travis CI build against Rubinius.
-  * Re-factored tests to utilise modern version of the "test-unit" Ruby gem.
-  * Fixed build to make it work with C++ compilers.
-  * Added the Guard Ruby gem for convenience, with an appropriate Guardfile.
-  * Added LLVM (clang) compiler to build with to Travis CI.
-  * Fixed version number to comply with Semantic Versioning 2 (http://semver.org/).
-  * Re-factored and cleaned up small portions of code and documentation.
-  * Removed BitDeli badge.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Mon, 15 Dec 2014 00:27:26 +0000
-
-fizzbuzz (0.0.6)
-
-  * Fixed issue reported by LLVM (clang).
-  * Updated development dependencies.
-  * Added Ruby 2.1.0 to Travis CI.
-  * Added BitDeli and Gemnasium integration.
-  * Re-factored and cleaned up small portions of code.
-  * Made Rake "test" task to be the default tasks.
-  * Updated the ".gitignore" file to cover Bundler, rbenv, etc.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Sun, 23 Feb 2014 13:52:08 +0000
-
-fizzbuzz (0.0.5)
-
-  * Added integration with Array and Range types.
-  * Added simple benchmark.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Tue, 26 Nov 2013 12:40:34 +0000
-
-fizzbuzz (0.0.4)
-
-  * Retired support for Ruby 1.8.x (no support for MRI, Ruby Enterprise Edition and Rubinius).
-  * Added Coveralls and Code Climate integration (and hence improved code test coverage).
-  * Improved error handling and made code more resilient to errors.
-  * Fixed formatting and white spaces.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Mon, 18 Nov 2013 11:22:26 +0000
-
-fizzbuzz (0.0.3)
-
-  * Added custom exceptions and improved error handling.
-  * Added more variety of Rubies on which tests are being run with Travis CI.
-  * Added project to Rubygems (http://rubygems.org) so it can be installed
-    with just "gem install ruby-fizzbuzz" command.
-  * Renamed project from "fizzbuzz" to "ruby-fizzbuzz" to avoid clashes with
-    other Ruby gems hosted on Rubygems web site.
-  * Made "mkmf" in extconf.rb more user-friendly (it now reports missing
-    build-time dependencies better).
-  * Split Ruby gem specification (or gemspec if you wish) away from Rakefile
-    into its own file (namely ruby-fizzbuzz.gemspec).
-  * Improved documentation and removed bunch of small code smells.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Sat, 31 Aug 2013 17:54:54 +0000
-
-fizzbuzz (0.0.2)
-
-  * Added is_fizz?, is_buzz? and is_fizzbuzz? singleton methods to FizzBuzz class.
-  * Added fizz?, buzz? and fizzbuzz? methods to the Integer class via a monkey-patch
-    for convenience.
-  * Changed behaviour of the FizzBuzz#[] singleton method, so it will yield a FizzBuzz
-    result for a given arbitrary Integer value.
-  * Re-factored code to make it cleaner, and added more tests and improved coverage.
-  * Re-factored FizzBuzz so it now does not assume that we always want to calculate
-    results from 1 to n -- it is now possible to calculate FizzBuzz results for given
-    n, m values, where n denotes start and m denotes stop value.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Sat, 29 Sep 2012 14:53:35 +0100
-
-fizzbuzz (0.0.1)
-
-  * First version.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Thu, 27 Sep 2012 12:54:45 +0200

data/README

@@ -1,5 +0,0 @@
-Yet another FizzBuzz in Ruby. Provides simple and fast solution
-to a popular FizzBuzz problem for Ruby.
-
-Written in C as an example of using Ruby's C API - with the support
-for arbitrary large numeric values via the Bignum class.

data/README.rdoc

@@ -1,12 +0,0 @@
-Yet another FizzBuzz in Ruby. Provides simple and fast solution
-to a popular FizzBuzz problem for Ruby.
-
-Written in C as an example of using Ruby's C API - with the support
-for arbitrary large numeric values via the Bignum class.
-
-{<img src="https://travis-ci.org/kwilczynski/ruby-fizzbuzz.png?branch=master" alt="Build Status"/>}[https://travis-ci.org/kwilczynski/ruby-fizzbuzz]
-{<img src="http://inch-ci.org/github/kwilczynski/ruby-fizzbuzz.svg?branch=master" alt="Documentation Status" />}[http://inch-ci.org/github/kwilczynski/ruby-fizzbuzz]
-{<img src="https://badge.fury.io/rb/ruby-fizzbuzz.png" alt="Gem Version" />}[http://badge.fury.io/rb/ruby-fizzbuzz]
-{<img src="https://coveralls.io/repos/kwilczynski/ruby-fizzbuzz/badge.png?branch=master" alt="Coverage Status" />}[https://coveralls.io/r/kwilczynski/ruby-fizzbuzz?branch=master]
-{<img src="https://codeclimate.com/github/kwilczynski/ruby-fizzbuzz.png" alt="Code Quality" />}[https://codeclimate.com/github/kwilczynski/ruby-fizzbuzz]
-{<img src="https://gemnasium.com/kwilczynski/ruby-fizzbuzz.png" alt="Dependency Status" />}[https://gemnasium.com/kwilczynski/ruby-fizzbuzz]

data/Rakefile

@@ -1,97 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-# :enddoc:
-
-#
-# Rakefile
-#
-# Copyright 2012-2014 Krzysztof Wilczynski
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-gem 'rdoc', '>= 4.1.1'
-
-begin
-  require 'rake'
-  require 'rdoc/task'
-  require 'rake/testtask'
-  require 'rake/extensiontask'
-rescue LoadError
-  require 'rubygems'
-  require 'rake'
-  require 'rdoc/task'
-  require 'rake/testtask'
-  require 'rake/extensiontask'
-end
-
-CLEAN.include   '*{.h,.o,.log,.so}', 'ext/**/*{.o,.log,.so}', 'Makefile', 'ext/**/Makefile'
-CLOBBER.include 'lib/**/*.so', 'doc/**/*'
-
-gem = eval File.read('ruby-fizzbuzz.gemspec')
-
-RDoc::Task.new do |d|
-  files = %w(AUTHORS CHANGES.rdoc COPYRIGHT LICENSE README.rdoc TODO)
-
-  d.title = 'Yet another FizzBuzz in Ruby'
-  d.main  = 'README.rdoc'
-
-  d.rdoc_dir = 'doc/rdoc'
-
-  d.rdoc_files.include 'ext/**/*.{c,h}', 'lib/**/*.rb'
-  d.rdoc_files.include.add(files)
-
-  d.options << '--line-numbers'
-end
-
-Rake::TestTask.new do |t|
-  t.verbose    = true
-  t.warning    = true
-  t.test_files = Dir['test/**/test_*']
-end
-
-Gem::PackageTask.new(gem) do |p|
-  p.need_zip = true
-  p.need_tar = true
-end
-
-Rake::ExtensionTask.new('fizzbuzz', gem) do |e|
-  e.ext_dir = 'ext/fizzbuzz'
-  e.lib_dir = 'lib/fizzbuzz'
-end
-
-desc 'Run benchmarks'
-task :benchmark, [:first] do |t,argument|
-  glob = File.expand_path("../benchmark/*.rb", __FILE__)
-  Dir[glob].each do |f|
-    process = ['ruby', f]
-    process << argument[:first] if argument[:first]
-
-    STDOUT.sync = true
-    STDERR.sync = true
-
-    IO.popen(process) do |stream|
-      stream.each {|line| puts line }
-    end
-
-    Process.waitpid rescue Errno::ECHILD
-  end
-end
-
-Rake::Task[:test].prerequisites << :clobber
-Rake::Task[:test].prerequisites << :compile
-
-task :default => :test
-
-# vim: set ts=2 sw=2 sts=2 et :
-# encoding: utf-8

data/TODO

@@ -1,16 +0,0 @@
-fizzbuzz (0.9.0)
-
-  * Improve github project page;
-  * Re-factor unit tests to make them more idiomatic (maybe move to Rspec and BDD?).
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Mon, 15 Dec 2014 00:27:26 +0000
-
-fizzbuzz (0.8.0)
-
-  * Move to YARD from RDoc (as RDoc is very bad, really);
-  * Add pure-Ruby implementation;
-  * Add some examples;
-  * Add Doxygen style comments for other functions in the source code;
-  * Improve documentation i.e. source code commenting, README file, etc.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Mon, 15 Dec 2014 00:27:26 +0000

data/benchmark/benchmark_fizzbuzz.rb

@@ -1,107 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-# :enddoc:
-
-#
-# benchmark_fizzbuzz.rb
-#
-# Copyright 2012-2014 Krzysztof Wilczynski
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-$: << File.expand_path('../../lib', __FILE__)
-
-require 'time'
-require 'benchmark'
-
-begin
-  require 'fizzbuzz'
-rescue LoadError
-  require 'rubygems'
-  require 'fizzbuzz'
-end
-
-CAPTION = "%8s%12s%11s%10s\n" % %w(User System Total Real)
-
-n = (ARGV.shift || 1_000_000).to_i
-
-start   = Time.now
-array   = (1..n).to_a
-reports = []
-
-puts "FizzBuzz #{FizzBuzz::VERSION}, n = #{n}\n\n"
-
-Benchmark.benchmark(CAPTION, 24) do |bm|
-  reports << bm.report('FizzBuzz::fizzbuzz') do
-    FizzBuzz.fizzbuzz(1, n)
-  end
-
-  reports << bm.report('FizzBuzz#each') do
-    FizzBuzz.new(1, n).each {|i| i }
-  end
-
-  reports << bm.report('FizzBuzz#reverse_each') do
-    FizzBuzz.new(1, n).reverse_each {|i| i }
-  end
-
-  reports << bm.report('FizzBuzz#to_a') do
-    FizzBuzz.new(1, n).to_a
-  end
-
-  reports << bm.report('FizzBuzz::[]') do
-    n.times {|i| FizzBuzz[i] }
-  end
-
-  reports << bm.report('FizzBuzz::is_fizz?') do
-    n.times {|i| FizzBuzz.is_fizz?(i) }
-  end
-
-  reports << bm.report('FizzBuzz::is_buzz?') do
-    n.times {|i| FizzBuzz.is_buzz?(i) }
-  end
-
-  reports << bm.report('FizzBuzz::is_fizzbuzz?') do
-    n.times {|i| FizzBuzz.is_fizzbuzz?(i) }
-  end
-
-  reports << bm.report('Array#fizzbuzz') do
-    array.fizzbuzz
-  end
-
-  reports << bm.report('Range#fizzbuzz') do
-    (1..n).fizzbuzz {|i| i }
-  end
-
-  []
-end
-
-reports.sort_by! {|i| i.real }
-
-overall = reports.reduce(:+)
-average = overall / reports.size
-
-fastest, slowest = reports.shift, reports.pop
-
-padding = [fastest.label, slowest.label].max
-padding = padding.size > 16 ? 24 : 16
-
-puts "\n%15s%s%16s\n" % ['', CAPTION.strip, 'Name'] +
-  "%s%48s [ %-#{padding}s ]\n" % ['Fastest:', fastest.to_s.strip, fastest.label.strip] +
-  "%s%48s [ %-#{padding}s ]\n" % ['Slowest:', slowest.to_s.strip, slowest.label.strip] +
-  "%s%48s\n" % ['Average:', average.to_s.strip] +
-  "%s%48s\n" % ['Overall:', overall.to_s.strip] +
-  "\n%s%13.6f\n" % ['Wall Clock Time:', Time.now.to_f - start.to_f]
-
-# vim: set ts=2 sw=2 sts=2 et :
-# encoding: utf-8

data/ruby-fizzbuzz.gemspec

@@ -1,65 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-# :enddoc:
-
-#
-# ruby-fizzbuzz.gemspec
-#
-# Copyright 2012-2014 Krzysztof Wilczynski
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-signing_key = File.expand_path('~/.gem/kwilczynski-private.pem')
-
-Gem::Specification.new do |s|
-  s.name    = 'ruby-fizzbuzz'
-  s.summary = 'Yet another FizzBuzz in Ruby'
-
-  s.description = <<-EOS
-Yet another FizzBuzz in Ruby.
-
-Provides simple and fast solution to a popular FizzBuzz problem for Ruby.
-
-Written in C as an example of using Ruby's C API - with the support for
-arbitrary large numeric values via the Bignum class.
-  EOS
-
-  s.platform = Gem::Platform::RUBY
-  s.version  = File.read('VERSION').strip
-  s.license  = 'Apache License, Version 2.0'
-  s.author   = 'Krzysztof Wilczynski'
-  s.email    = 'krzysztof.wilczynski@linux.com'
-  s.homepage = 'http://about.me/kwilczynski'
-  s.has_rdoc = true
-
-  s.required_ruby_version = '>= 1.9.2'
-  s.rubygems_version      = '~> 2.2.0'
-
-  s.files = Dir['ext/**/*.{c,h,rb}'] +
-            Dir['lib/**/*.rb']       +
-            Dir['benchmark/**/*.rb'] +
-            Dir['test/**/*.rb']      +
-            %w(Rakefile ruby-fizzbuzz.gemspec AUTHORS
-               CHANGES CHANGES.rdoc COPYRIGHT LICENSE
-               README README.rdoc TODO VERSION)
-
-  s.executables   << 'fizzbuzz'
-  s.require_paths << 'lib'
-  s.extensions    << 'ext/fizzbuzz/extconf.rb'
-
-  s.signing_key = signing_key if File.exists?(signing_key)
-end
-
-# vim: set ts=2 sw=2 sts=2 et :
-# encoding: utf-8

data/test/test_fizzbuzz.rb

@@ -1,639 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-# :enddoc:
-
-#
-# test_fizzbuzz.rb
-#
-# Copyright 2012-2014 Krzysztof Wilczynski
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-begin
-  require 'coveralls'
-  Coveralls.wear!
-rescue LoadError
-  STDERR.puts 'The Coveralls gem is not installed, skipping ...'
-end
-
-gem 'test-unit', '>= 3.0.0'
-
-require 'test/unit'
-require 'fizzbuzz'
-
-class Fixnum
-  def self.overflow_size_with_sign
-    bits = [''].pack('p').size * 8
-    2 ** (bits - 1) - 1
-  end
-end
-
-class FizzBuzzTest < Test::Unit::TestCase
-  def setup
-    @fixnum = 1
-
-    @bignum       = 1_000_000_000_000
-    @large_bignum = 1_000_000_000_000_000
-
-    if Fixnum.overflow_size_with_sign + 1 > 2147483647
-      @bignum       = @bignum       ** 2
-      @large_bignum = @large_bignum ** 2
-    end
-
-    @words = %w(Fizz Buzz FizzBuzz).freeze
-
-    @expected = [
-      1,      2,      'Fizz',
-      4,      'Buzz', 'Fizz',
-      7,      8,      'Fizz',
-      'Buzz', 11,     'Fizz',
-      13,     14,     'FizzBuzz'
-    ].freeze
-
-    @expected_bignum = [
-      @bignum + 1,  'Fizz',     @bignum + 3,
-      @bignum + 4,  'FizzBuzz', @bignum + 6,
-      @bignum + 7,  'Fizz',     @bignum + 9,
-      'Buzz',       'Fizz',     @bignum + 12,
-      @bignum + 13, 'Fizz',     'Buzz'
-    ]
-
-    @fizzbuzz = FizzBuzz.new(1, 15)
-  end
-
-  def test_fizzbuzz_alias
-    assert_same(FB, FizzBuzz)
-  end
-
-  def test_fizzbuzz_singleton_methods
-    [
-      :fizzbuzz,
-      :is_fizz?,
-      :is_buzz?,
-      :is_fizzbuzz?
-    ].each {|i| assert_respond_to(FizzBuzz, i) }
-  end
-
-  def test_fizzbuzz_new_instance
-    assert(@fizzbuzz.class == FizzBuzz)
-  end
-
-  def test_fizzbuzz_instance_methods
-    [
-      :to_a,
-      :each,
-      :reverse_each,
-      :to_hash,
-      :as_json,
-      :to_json
-    ].each {|i| assert_respond_to(@fizzbuzz, i) }
-  end
-
-  def test_fixnum_integration
-    [
-      :fizz?,
-      :buzz?,
-      :fizzbuzz?
-    ].each {|i| assert_respond_to(@fixnum, i) }
-  end
-
-  def test_to_hash
-    obtained = @fizzbuzz.to_hash
-    assert({
-      'fizzbuzz' => {
-        'start' => 1,
-        'stop' => 15
-      }
-    } == obtained)
-  end
-
-  def test_as_json
-    obtained = @fizzbuzz.as_json
-    assert({
-      'json_class' => 'FizzBuzz',
-      'fizzbuzz' => {
-        'start' => 1,
-        'stop' => 15
-      }
-    } == obtained)
-  end
-
-  def test_to_json
-    obtained = @fizzbuzz.to_json
-    assert({
-      'json_class' => 'FizzBuzz',
-      'fizzbuzz' => {
-        'start' => 1,
-        'stop' => 15
-      }
-    }.to_json == obtained)
-  end
-
-  def test_singleton_from_json
-    # About JSON::parse, see:
-    # https://www.ruby-lang.org/en/news/2013/02/22/json-dos-cve-2013-0269/
-    obtained = @fizzbuzz.to_json
-    assert({
-      'fizzbuzz' => {
-        'start' => 1,
-        'stop' => 15
-      }
-    } == JSON.load(obtained).to_hash)
-  end
-
-  def test_fixnum_is_fizz
-    assert_true(3.fizz?)
-    assert_false(15.fizz?)
-  end
-
-  def test_fixnum_is_buzz
-    assert_true(5.buzz?)
-    assert_false(15.buzz?)
-  end
-
-  def test_fixnum_is_fizzbuzz
-    assert_equal(15.fizzbuzz?, true)
-    assert_false(3.fizzbuzz?, false)
-    assert_false(5.fizzbuzz?, false)
-  end
-
-  def test_bignum_integration
-    [
-      :fizz?,
-      :buzz?,
-      :fizzbuzz?
-    ].each {|i| assert_respond_to(@bignum, i) }
-  end
-
-  def test_bignum_is_fizz
-    assert_true((@bignum + 2).fizz?)
-    assert_false((@bignum + 15).fizz?)
-  end
-
-  def test_bignum_is_buzz
-    assert_true((@bignum + 15).buzz?)
-    assert_false((@bignum + 5).buzz?)
-  end
-
-  def test_bignum_is_fizzbuzz
-    assert_true((@bignum + 5).fizzbuzz?)
-    assert_false((@bignum + 2).fizzbuzz?)
-    assert_false((@bignum + 15).fizzbuzz?)
-  end
-
-  def test_array_integration
-    assert_respond_to([], :fizzbuzz)
-  end
-
-  def test_array_integration_fizzbuzz
-    obtained = Array(1..15).fizzbuzz
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, @expected)
-  end
-
-  def test_array_integration_fizzbuzz_reverse
-    obtained = Array(1..15).fizzbuzz(true)
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, @expected.reverse)
-  end
-
-  def test_array_integration_fizzbuzz_block
-    obtained = []
-    Array(1..15).fizzbuzz {|i| obtained << i }
-    assert_equal(obtained, @expected)
-  end
-
-  def test_array_integration_fizzbuzz_block_reverse
-    obtained = []
-    Array(1..15).fizzbuzz(true) {|i| obtained << i }
-    assert_equal(obtained, @expected.reverse)
-  end
-
-  def test_range_integration
-    assert_respond_to((0..0), :fizzbuzz)
-  end
-
-  def test_range_integration_fizzbuzz
-    obtained = (1..15).fizzbuzz
-    assert_kind_of(Enumerator, obtained)
-    assert_equal(obtained.to_a, @expected)
-  end
-
-  def test_range_integration_fizzbuzz_reverse
-    obtained = (1..15).fizzbuzz(true)
-    assert_kind_of(Enumerator, obtained)
-    assert_equal(obtained.to_a, @expected.reverse)
-  end
-
-  def test_range_integration_fizzbuzz_block
-    obtained = []
-    (1..15).fizzbuzz {|i| obtained << i }
-    assert_equal(obtained, @expected)
-  end
-
-  def test_range_integration_fizzbuzz_block_reverse
-    obtained = []
-    (1..15).fizzbuzz(true) {|i| obtained << i }
-    assert_equal(obtained, @expected.reverse)
-  end
-
-  def test_singleton_fizzbuzz_incorrect_range_error
-    assert_raise FizzBuzz::RangeError do
-      FizzBuzz.fizzbuzz(2, 1)
-    end
-  end
-
-  def test_singleton_fizzbuzz_incorrect_type_error
-    assert_raise FizzBuzz::TypeError do
-      FizzBuzz.fizzbuzz('', '')
-    end
-  end
-
-  def test_singleton_fizzbuzz_fixnum
-    obtained = FizzBuzz.fizzbuzz(15, 15)
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, ['FizzBuzz'])
-  end
-
-  def test_singleton_fizzbuzz_bignum
-    obtained = FizzBuzz.fizzbuzz(@bignum + 5, @bignum + 5)
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, ['FizzBuzz'])
-  end
-
-  def test_singleton_fizzbuzz_large_bignum
-    obtained = FizzBuzz.fizzbuzz(@large_bignum + 5, @large_bignum + 5)
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, ['FizzBuzz'])
-  end
-
-  def test_singleton_fizzbuzz_array
-    obtained = FizzBuzz.fizzbuzz(1, 15)
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, @expected)
-  end
-
-  def test_singleton_fizzbuzz_array_reverse
-    obtained = FizzBuzz.fizzbuzz(1, 15, true)
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, @expected.reverse)
-  end
-
-  def test_singleton_fizzbuzz_block
-    obtained = []
-    FizzBuzz.fizzbuzz(1, 15) {|i| obtained << i }
-    assert_equal(obtained, @expected)
-  end
-
-  def test_singleton_fizzbuzz_block_reverse
-    obtained = []
-    FizzBuzz.fizzbuzz(1, 15, true) {|i| obtained << i }
-    assert_equal(obtained, @expected.reverse)
-  end
-
-  def test_singleton_squre_fixnum
-    obtained = []
-
-    obtained << FizzBuzz[3]
-    obtained << FizzBuzz[5]
-    obtained << FizzBuzz[15]
-
-    assert_kind_of(Fixnum, FizzBuzz[0])
-
-    obtained.each_with_index do |v,i|
-      assert_kind_of(String, v)
-      assert_equal(obtained[i], @words[i])
-    end
-  end
-
-  def test_singleton_squre_bignum
-    obtained = []
-
-    obtained << FizzBuzz[@bignum + 2]
-    obtained << FizzBuzz[@bignum + 15]
-    obtained << FizzBuzz[@bignum + 5]
-
-    assert_kind_of(Bignum, FizzBuzz[@bignum + 3])
-
-    obtained.each_with_index do |v,i|
-      assert_kind_of(String, v)
-      assert_equal(obtained[i], @words[i])
-    end
-  end
-
-  def test_singleton_squre_large_bignum
-    obtained = []
-
-    obtained << FizzBuzz[@large_bignum + 2]
-    obtained << FizzBuzz[@large_bignum + 15]
-    obtained << FizzBuzz[@large_bignum + 5]
-
-    assert_kind_of(Bignum, FizzBuzz[@large_bignum + 3])
-
-    obtained.each_with_index do |v,i|
-      assert_kind_of(String, v)
-      assert_equal(obtained[i], @words[i])
-    end
-  end
-
-  def test_singleton_is_fizz
-    assert_true(FizzBuzz.is_fizz?(3))
-    assert_false(FizzBuzz.is_fizz?(15))
-  end
-
-  def test_singleton_is_buzz
-    assert_true(FizzBuzz.is_buzz?(5))
-    assert_false(FizzBuzz.is_buzz?(15))
-  end
-
-  def test_singleton_is_fizzbuzz
-    assert_true(FizzBuzz.is_fizzbuzz?(15))
-    assert_false(FizzBuzz.is_fizzbuzz?(3))
-    assert_false(FizzBuzz.is_fizzbuzz?(5))
-  end
-
-  def test_fizzbuzz_for_0
-    obtained_square      = FizzBuzz[0]
-    obtained_is_fizzbuzz = FizzBuzz.is_fizzbuzz?(0)
-
-    assert_kind_of(Fixnum, obtained_square)
-    assert_equal(obtained_square, 0)
-    assert_false(obtained_is_fizzbuzz)
-  end
-
-  def test_fizzbuzz_for_negative_fixnum
-    obtained_square      = FizzBuzz[-1]
-    obtained_is_fizzbuzz = FizzBuzz.is_fizzbuzz?(-1)
-
-    assert_kind_of(Fixnum, obtained_square)
-    assert_equal(obtained_square, -1)
-    assert_false(obtained_is_fizzbuzz)
-  end
-
-  def test_to_a_fixnum
-    obtained = @fizzbuzz.to_a
-
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, @expected)
-  end
-
-  def test_each_fixnum
-    obtained = []
-    @fizzbuzz.each {|i| obtained << i }
-    assert_equal(obtained, @expected)
-  end
-
-  def test_reverse_each_fixnum
-    obtained = []
-    @fizzbuzz.reverse_each {|i| obtained << i }
-    assert_equal(obtained, @expected.reverse)
-  end
-
-  def test_to_a_bignum
-    @fizzbuzz = FizzBuzz.new(@bignum + 1, @bignum + 15)
-    obtained = @fizzbuzz.to_a
-
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained, @expected_bignum)
-  end
-
-  def test_each_bignum
-    @fizzbuzz = FizzBuzz.new(@bignum + 1, @bignum + 15)
-
-    obtained = []
-    @fizzbuzz.each {|i| obtained << i }
-
-    assert_equal(obtained, @expected_bignum)
-  end
-
-  def test_reverse_each_bignum
-    @fizzbuzz = FizzBuzz.new(@bignum + 1, @bignum + 15)
-
-    obtained = []
-    @fizzbuzz.reverse_each {|i| obtained << i }
-
-    assert_equal(obtained, @expected_bignum.reverse)
-  end
-
-  def test_for_fizzbuzz_fixnum
-    obtained = @fizzbuzz.to_a
-
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained[14], 'FizzBuzz')
-  end
-
-  def test_for_fizzbuzz_bignum
-    @fizzbuzz = FizzBuzz.new(@bignum + 5, @bignum + 5)
-
-    obtained = @fizzbuzz.to_a
-
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained[0], 'FizzBuzz')
-  end
-
-  def test_for_fizzbuzz_large_bignum
-    @fizzbuzz = FizzBuzz.new(@large_bignum + 5, @large_bignum + 5)
-
-    obtained = @fizzbuzz.to_a
-
-    assert_kind_of(Array, obtained)
-    assert_equal(obtained[0], 'FizzBuzz')
-  end
-
-  def test_correct_start_fixnum
-    assert_kind_of(Fixnum, @fizzbuzz.start)
-    assert_equal(@fizzbuzz.start, 1)
-
-    @fizzbuzz.start = 2
-
-    assert_kind_of(Fixnum, @fizzbuzz.start)
-    assert_equal(@fizzbuzz.start, 2)
-  end
-
-  def test_correct_start_bignum
-    @fizzbuzz = FizzBuzz.new(@bignum, @bignum)
-
-    assert_kind_of(Bignum, @fizzbuzz.start)
-    assert_equal(@fizzbuzz.start, @bignum)
-
-    @fizzbuzz.start = @bignum - 5
-
-    assert_kind_of(Bignum, @fizzbuzz.start)
-    assert_equal(@fizzbuzz.start, @bignum - 5)
-  end
-
-  def test_correct_start_large_bignum
-    @fizzbuzz = FizzBuzz.new(@large_bignum, @large_bignum)
-
-    assert_kind_of(Bignum, @fizzbuzz.start)
-    assert_equal(@fizzbuzz.start, @large_bignum)
-
-    @fizzbuzz.start = @large_bignum - 5
-
-    assert_kind_of(Bignum, @fizzbuzz.start)
-    assert_equal(@fizzbuzz.start, @large_bignum - 5)
-  end
-
-  def test_correct_stop_fixnum
-    assert_kind_of(Fixnum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.stop, 15)
-
-    @fizzbuzz.stop = 5
-
-    assert_kind_of(Fixnum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.stop, 5)
-  end
-
-  def test_correct_stop_bignum
-    @fizzbuzz = FizzBuzz.new(@bignum, @bignum)
-
-    assert_kind_of(Bignum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.stop, @bignum)
-
-    @fizzbuzz.stop = @bignum + 5
-
-    assert_kind_of(Bignum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.stop, @bignum + 5)
-  end
-
-  def test_correct_stop_large_bignum
-    @fizzbuzz = FizzBuzz.new(@large_bignum, @large_bignum)
-
-    assert_kind_of(Bignum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.stop, @large_bignum)
-
-    @fizzbuzz.stop = @large_bignum + 5
-
-    assert_kind_of(Bignum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.stop, @large_bignum + 5)
-  end
-
-  def test_missing_arguments
-    assert_raise ArgumentError do
-      FizzBuzz.new
-    end
-  end
-
-  def test_arguments_type_error_strings
-    assert_raise FizzBuzz::TypeError do
-      FizzBuzz.new('', '')
-    end
-  end
-
-  def test_arguments_type_error_message
-    FizzBuzz['']
-  rescue FizzBuzz::TypeError => error
-    assert_equal(error.message, 'must be a Fixnum or Bignum type')
-  end
-
-  def test_arguments_type_error_nils
-    assert_raise FizzBuzz::TypeError do
-      FizzBuzz.new(nil, nil)
-    end
-  end
-
-  def test_incorrect_range_error
-    assert_raise FizzBuzz::RangeError do
-      FizzBuzz.new(2, 1)
-    end
-  end
-
-  def test_start_type_error
-    assert_raise FizzBuzz::TypeError do
-      @fizzbuzz.start = ''
-    end
-  end
-
-  def test_stop_type_error
-    assert_raise FizzBuzz::TypeError do
-      @fizzbuzz.stop = ''
-    end
-  end
-
-  def test_correct_start_stop
-    @fizzbuzz.start = 2
-    @fizzbuzz.stop  = 3
-
-    assert_kind_of(Fixnum, @fizzbuzz.start)
-    assert_kind_of(Fixnum, @fizzbuzz.stop)
-    assert_equal(@fizzbuzz.start, 2)
-    assert_equal(@fizzbuzz.stop, 3)
-  end
-
-  def test_fizzbuzz_error
-    message = 'The quick brown fox jumps over the lazy dog'
-    error = FizzBuzz::Error.new(message)
-
-    assert_respond_to(error, :start)
-    assert_respond_to(error, :stop)
-    assert_equal(error.message, message)
-    assert_nil(error.start)
-    assert_nil(error.stop)
-  end
-
-  def test_start_range_error
-    assert_raise FizzBuzz::RangeError do
-      @fizzbuzz.start = 16
-    end
-  end
-
-  def test_stop_range_error
-    assert_raise FizzBuzz::RangeError do
-      @fizzbuzz.stop = -1
-    end
-  end
-
-  def test_for_not_raising_range_error
-    assert_nothing_raised do
-      FizzBuzz.new(1, @bignum ** 2)
-      FizzBuzz.new(-@large_bignum, 15)
-    end
-  end
-
-  def test_error_attributes_not_nil
-    @fizzbuzz.start = 1
-    @fizzbuzz.stop  = 0
-  rescue FizzBuzz::RangeError => error
-    assert_equal(error.start, 1)
-    assert_equal(error.stop, 0)
-  end
-
-  def test_error_attributes_nil
-    FizzBuzz.new('', '')
-  rescue FizzBuzz::TypeError => error
-    assert_nil(error.start)
-    assert_nil(error.stop)
-  end
-
-  def test_start_type_error_message
-    FizzBuzz.new('', 15)
-  rescue FizzBuzz::TypeError => error
-    assert_equal(error.message, 'must be a Fixnum or Bignum type for start')
-  end
-
-  def test_stop_type_error_message
-    FizzBuzz.new(1, '')
-  rescue FizzBuzz::TypeError => error
-    assert_equal(error.message, 'must be a Fixnum or Bignum type for stop')
-  end
-
-  def test_range_error_message
-    FizzBuzz.new(15, 1)
-  rescue FizzBuzz::RangeError => error
-    assert_equal(error.message, 'start value is higher than stop value')
-  end
-end
-
-# vim: set ts=2 sw=2 sts=2 et :
-# encoding: utf-8