ruby-fizzbuzz 0.0.6 → 0.7.0

data/ext/fizzbuzz/fizzbuzz.h

@@ -3,7 +3,7 @@
 /*
  * fizzbuzz.h
  *
- * Copyright 2012-2013 Krzysztof Wilczynski
+ * 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.
@@ -116,9 +116,9 @@ struct fizzbuzz_exception {
 typedef struct fizzbuzz_exception fizzbuzz_exception_t;
 
 static const char *errors[] = {
-    "must be an Integer or Bignum type",
-    "must be an Integer or Bignum type for start",
-    "must be an Integer or Bignum type for stop",
+    "must be a Fixnum or Bignum type",
+    "must be a Fixnum or Bignum type for start",
+    "must be a Fixnum or Bignum type for stop",
     "start value is higher than stop value",
     "stop value is lower than start value",
     NULL

data/lib/fizzbuzz.rb

@@ -5,7 +5,7 @@
 #
 # fizzbuzz.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.
@@ -22,12 +22,16 @@
 
 # :startdoc:
 
-require 'fizzbuzz/fizzbuzz'
-require 'fizzbuzz/version'
-require 'fizzbuzz/integer'
-require 'fizzbuzz/bignum'
-require 'fizzbuzz/array'
-require 'fizzbuzz/range'
+gem 'json', '>= 1.8.1'
+
+require 'json'
+
+require_relative 'fizzbuzz/fizzbuzz'
+require_relative 'fizzbuzz/version'
+require_relative 'fizzbuzz/core/integer'
+require_relative 'fizzbuzz/core/bignum'
+require_relative 'fizzbuzz/core/array'
+require_relative 'fizzbuzz/core/range'
 
 #
 # Yet another _FizzBuzz_ in Ruby.
@@ -37,12 +41,12 @@ require 'fizzbuzz/range'
 class FizzBuzz
   #
   # call-seq:
-  #    FizzBuzz.fizzbuzz( start, stop, reverse )                  -> array
   #    FizzBuzz.fizzbuzz( start, stop, reverse ) {|value| block } -> self
+  #    FizzBuzz.fizzbuzz( start, stop, reverse )                  -> array
   #
-  # Returns either an array or accepts a block if such is given. When a block is given
-  # then it will call the block once for each subsequent value for a given range from
-  # +start+ to +stop+, passing the value as a parameter to the block.
+  # Returns either an +array+ or accepts a block if such is given. When a block is
+  # given then it will call the block once for each subsequent value for a given
+  # range from +start+ to +stop+, passing the value as a parameter to the block.
   #
   # Additionally, if the value of +reverse+ is set to be +true+ then the results will
   # be given in an <em>reverse order</em> whether in a resulting array or when passing
@@ -77,15 +81,142 @@ class FizzBuzz
   #
   # See also: FizzBuzz::[], FizzBuzz::new, FizzBuzz#to_a, FizzBuzz#each and FizzBuzz#reverse_each
   #
-  def self.fizzbuzz(start, stop, reverse = false)
-    fb = FizzBuzz.new(start, stop)
+  def self.fizzbuzz(start, stop, reverse = false, &block)
+    fb = new(start, stop)
 
     if block_given?
-      fb.send(reverse ? :reverse_each : :each) {|i| yield i }
+      fb.send(reverse ? :reverse_each : :each, &block)
+      self
     else
-      reverse ? fb.to_a.reverse : fb.to_a
+      fb.to_a.send(reverse ? :reverse : :to_a)
     end
   end
+
+  #
+  # call-seq:
+  #    fizzbuzz.to_hash -> hash
+  #
+  # Returns a +hash+ representing the _FizzBuzz_ object.
+  #
+  # Example:
+  #
+  #    fb = FizzBuzz.new(1, 15)   #=> #<FizzBuzz:0x007fbe84 @start=1, @stop=15>
+  #    fb.to_hash
+  #
+  # Produces:
+  #
+  #    {
+  #      "fizzbuzz" => {
+  #        "start" => 1,
+  #         "stop" => 15
+  #      }
+  #    }
+  #
+  # See also: FizzBuzz#as_json and FizzBuzz#to_json
+  #
+  def to_hash
+    {
+      'fizzbuzz' => {
+        'start' => @start,
+        'stop' => @stop
+      }
+    }
+  end
+
+  #
+  # call-seq:
+  #    fizzbuzz.as_json -> hash
+  #
+  # Returns a +hash+ representing the _FizzBuzz_ object that will be
+  # used when generating a _JSON_ string representation.
+  #
+  # Example:
+  #
+  #    fb = FizzBuzz.new(1, 15)   #=> #<FizzBuzz:0x007f90c1 @start=1, @stop=15>
+  #    fb.as_json
+  #
+  # Produces:
+  #
+  #    {
+  #      "json_class" => "FizzBuzz",
+  #        "fizzbuzz" => {
+  #        "start" => 1,
+  #         "stop" => 15
+  #      }
+  #    }
+  #
+  # See also: FizzBuzz#to_json and FizzBuzz#to_hash
+  #
+  def as_json(*arguments)
+    { JSON.create_id => self.class.name }.merge(to_hash)
+  end
+
+  #
+  # call-seq:
+  #    fizzbuzz.to_json -> string
+  #
+  # Returns a _JSON_ string representing the _FizzBuzz_ object.
+  #
+  # Example:
+  #
+  #    fb = FizzBuzz.new(1, 15)   #=> #<FizzBuzz:0x007fce83 @start=1, @stop=15>
+  #    fb.to_json
+  #
+  # Produces:
+  #
+  #    {
+  #      "json_class": "FizzBuzz",
+  #      "fizzbuzz": {
+  #        "start": 1,
+  #        "stop": 15
+  #      }
+  #    }
+  #
+  # See also: FizzBuzz::json_create, FizzBuzz#as_json and FizzBuzz#to_hash
+  #
+  def to_json(*arguments)
+    as_json.to_json(*arguments)
+  end
+
+  #
+  # call-seq:
+  #    FizzBuzz.json_create( object ) -> FizzBuzz
+  #
+  # Creates a new _FizzBuzz_ object with both the +start+ and +stop+ values
+  # set accordingly given a _JSON_ string that is an representation of the
+  # _FizzBuzz_ object.
+  #
+  # Example:
+  #
+  #    json = <<-EOS
+  #      {
+  #        "json_class": "FizzBuzz",
+  #        "fizzbuzz": {
+  #          "start": 1,
+  #          "stop": 15
+  #        }
+  #      }
+  #    EOS
+  #
+  #    fb = JSON.load(json)   #=> #<FizzBuzz:0x007fc082 @start=1, @stop=15>
+  #    fb.to_hash
+  #
+  # Produces:
+  #
+  #    {
+  #      "fizzbuzz" => {
+  #        "start" => 1,
+  #         "stop" => 15
+  #      }
+  #    }
+  #
+  # See also: FizzBuzz#to_json, FizzBuzz::[], FizzBuzz::new and FizzBuzz::fizzbuzz
+  #
+  def self.json_create(object)
+    new(*object['fizzbuzz'].values_at('start', 'stop'))
+  end
+
+  alias_method :to_h, :to_hash
 end
 
 # :enddoc:

data/lib/fizzbuzz/{array.rb → core/array.rb}

@@ -3,9 +3,9 @@
 # :stopdoc:
 
 #
-# array.rb
+# core/array.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.
@@ -28,10 +28,10 @@
 class Array
   #
   # call-seq:
-  #    array.fizzbuzz( reverse )                  -> array
   #    array.fizzbuzz( reverse ) {|value| block } -> self
+  #    array.fizzbuzz( reverse )                  -> array
   #
-  # Returns either an array or accepts a block if such is given. When a block is given
+  # Returns either an +array+ or accepts a block if such is given. When a block is given
   # then it will call the block once for each subsequent value for a given array, passing
   # the value as a parameter to the block.
   #
@@ -71,7 +71,7 @@ class Array
   # See also: FizzBuzz::fizzbuzz, FizzBuzz#to_a, FizzBuzz#each and FizzBuzz#reverse_each
   #
   def fizzbuzz(reverse = false)
-    values = self.send(reverse ? :reverse : :entries)
+    values = self.send(reverse ? :reverse : :to_a)
 
     if block_given?
       values.each {|i| yield FizzBuzz[i] }

data/lib/fizzbuzz/{bignum.rb → core/bignum.rb}

@@ -3,9 +3,9 @@
 # :stopdoc:
 
 #
-# bignum.rb
+# core/bignum.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.

data/lib/fizzbuzz/{integer.rb → core/integer.rb}

@@ -3,9 +3,9 @@
 # :stopdoc:
 
 #
-# integer.rb
+# core/integer.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.

data/lib/fizzbuzz/{range.rb → core/range.rb}

@@ -3,9 +3,9 @@
 # :stopdoc:
 
 #
-# range.rb
+# core/range.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.
@@ -28,12 +28,12 @@
 class Range
   #
   # call-seq:
-  #    range.fizzbuzz( reverse )                  -> array
   #    range.fizzbuzz( reverse ) {|value| block } -> self
+  #    range.fizzbuzz( reverse )                  -> an Enumerator
   #
-  # Returns either an array or accepts a block if such is given. When a block is given
-  # then it will call the block once for each subsequent value for a given range, passing
-  # the value as a parameter to the block.
+  # Returns either an +Enumerator+ or accepts a block if such is given. When a block is
+  # given then it will call the block once for each subsequent value for a given range,
+  # passing the value as a parameter to the block.
   #
   # Additionally, if the value of +reverse+ is set to be +true+ then the results will
   # be given in an <em>reverse order</em> whether in a resulting array or when passing
@@ -41,8 +41,8 @@ class Range
   #
   # Example:
   #
-  #    (1..15).fizzbuzz         #=> [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz"]
-  #    (1..15).fizzbuzz(true)   #=> ["FizzBuzz", 14, 13, "Fizz", 11, "Buzz", "Fizz", 8, 7, "Fizz", "Buzz", 4, "Fizz", 2, 1]
+  #    (1..15).fizzbuzz         #=> #<Enumerator: 1..15:fizzbuzz(false)>
+  #    (1..15).fizzbuzz(true)   #=> #<Enumerator: 1..15:fizzbuzz(true)>
   #
   # Example:
   #
@@ -68,14 +68,12 @@ class Range
   #
   # See also: FizzBuzz::fizzbuzz, FizzBuzz#to_a, FizzBuzz#each and FizzBuzz#reverse_each
   #
-  def fizzbuzz(reverse = false)
-    values = self.collect {|i| FizzBuzz[i] }.send(reverse ? :reverse : :entries)
-
+  def fizzbuzz(reverse = false, &block)
     if block_given?
-      values.each {|i| yield i }
+      FizzBuzz.fizzbuzz(self.begin, self.end, reverse, &block)
       self
     else
-      values
+      enum_for(:fizzbuzz, reverse)
     end
   end
 end

data/lib/fizzbuzz/version.rb

@@ -5,7 +5,7 @@
 #
 # version.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.
@@ -26,7 +26,7 @@ class FizzBuzz
   #
   # Current version of _FizzBuzz_.
   #
-  VERSION = '0.0.6'
+  VERSION = '0.7.0'.freeze
 end
 
 # :enddoc:

data/ruby-fizzbuzz.gemspec

@@ -5,7 +5,7 @@
 #
 # ruby-fizzbuzz.gemspec
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.
@@ -23,7 +23,8 @@
 signing_key = File.expand_path('~/.gem/kwilczynski-private.pem')
 
 Gem::Specification.new do |s|
-  s.name = 'ruby-fizzbuzz'
+  s.name    = 'ruby-fizzbuzz'
+  s.summary = 'Yet another FizzBuzz in Ruby'
 
   s.description = <<-EOS
 Yet another FizzBuzz in Ruby.
@@ -40,12 +41,10 @@ arbitrary large numeric values via the Bignum class.
   s.author   = 'Krzysztof Wilczynski'
   s.email    = 'krzysztof.wilczynski@linux.com'
   s.homepage = 'http://about.me/kwilczynski'
+  s.has_rdoc = true
 
-  s.rubyforge_project = 'ruby-fizzbuzz'
-  s.rubygems_version  = '~> 2.2.0'
-  s.has_rdoc          = true
-
-  s.summary = 'Yet another FizzBuzz in Ruby'
+  s.required_ruby_version = '>= 1.9.2'
+  s.rubygems_version      = '~> 2.2.0'
 
   s.files = Dir['ext/**/*.{c,h,rb}'] +
             Dir['lib/**/*.rb']       +
@@ -59,11 +58,6 @@ arbitrary large numeric values via the Bignum class.
   s.require_paths << 'lib'
   s.extensions    << 'ext/fizzbuzz/extconf.rb'
 
-  s.add_development_dependency 'rake', '~> 10.1', '>= 10.1.1'
-  s.add_development_dependency 'rdoc', '~> 4.1', '>= 4.1.1'
-  s.add_development_dependency 'test-unit', '~> 2.5', '>= 2.5.5'
-  s.add_development_dependency 'rake-compiler', '~> 0.9', '>= 0.9.2'
-
   s.signing_key = signing_key if File.exists?(signing_key)
 end
 

data/test/test_fizzbuzz.rb

@@ -5,7 +5,7 @@
 #
 # test_fizzbuzz.rb
 #
-# Copyright 2012-2013 Krzysztof Wilczynski
+# 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.
@@ -27,161 +27,225 @@ rescue LoadError
   STDERR.puts 'The Coveralls gem is not installed, skipping ...'
 end
 
-gem 'test-unit', '>= 2.5.2'
+gem 'test-unit', '>= 3.0.0'
 
 require 'test/unit'
 require 'fizzbuzz'
 
-DEFAULT_START    = 1
-DEFAULT_STOP     = 15
-DEFAULT_WORDS    = ['Fizz', 'Buzz', 'FizzBuzz']
-DEFAULT_EXPECTED = [1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'FizzBuzz']
-
-DEFAULT_SINGLETON_METHODS = [:fizzbuzz, :is_fizz?, :is_buzz?, :is_fizzbuzz?]
-DEFAULT_INSTANCE_METHODS  = [:to_a, :each, :reverse_each]
-
-DEFAULT_INSTANCE_METHODS_ADDED = [:fizz?, :buzz?, :fizzbuzz?]
-
 class Fixnum
-  class << self
-    def overflow_size_with_sign
-      bits = [''].pack('p').size * 8
-      2 ** (bits - 1) - 1
-    end
+  def self.overflow_size_with_sign
+    bits = [''].pack('p').size * 8
+    2 ** (bits - 1) - 1
   end
 end
 
 class FizzBuzzTest < Test::Unit::TestCase
   def setup
-    @integer = 1
+    @fixnum = 1
+
     @bignum       = 1_000_000_000_000
     @large_bignum = 1_000_000_000_000_000
 
-    if Fixnum::overflow_size_with_sign + 1 > 2147483647
+    if Fixnum.overflow_size_with_sign + 1 > 2147483647
       @bignum       = @bignum       ** 2
       @large_bignum = @large_bignum ** 2
     end
-  end
 
-  def test_fizzbuzz_alias
-    assert(FB == FizzBuzz)
-  end
+    @words = %w(Fizz Buzz FizzBuzz).freeze
 
-  def test_fizzbuzz_singleton_methods
-    fb = FizzBuzz
+    @expected = [
+      1,      2,      'Fizz',
+      4,      'Buzz', 'Fizz',
+      7,      8,      'Fizz',
+      'Buzz', 11,     'Fizz',
+      13,     14,     'FizzBuzz'
+    ].freeze
 
-    assert_block do
-      DEFAULT_SINGLETON_METHODS.all? {|i| fb.respond_to?(i) }
-    end
-  end
-
-  def test_fizzbuzz_new_instance
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-    assert(fb.class == FizzBuzz)
-  end
-
-  def test_fizzbuzz_instance_methods
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+    @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'
+    ]
 
-    assert_block do
-      DEFAULT_INSTANCE_METHODS.all? {|i| fb.respond_to?(i) }
-    end
+    @fizzbuzz = FizzBuzz.new(1, 15)
   end
 
-  def test_integer_integration
-    assert_block do
-      DEFAULT_INSTANCE_METHODS_ADDED.all? {|i| @integer.respond_to?(i) }
-    end
+  def test_fizzbuzz_alias
+    assert_same(FB, FizzBuzz)
   end
 
-  def test_integer_is_fizz
-    assert_equal(3.fizz?, true)
-    assert_equal(15.fizz?, false)
+  def test_fizzbuzz_singleton_methods
+    [
+      :fizzbuzz,
+      :is_fizz?,
+      :is_buzz?,
+      :is_fizzbuzz?
+    ].each {|i| assert_respond_to(FizzBuzz, i) }
   end
 
-  def test_integer_is_buzz
-    assert_equal(5.buzz?, true)
-    assert_equal(15.buzz?, false)
+  def test_fizzbuzz_new_instance
+    assert(@fizzbuzz.class == FizzBuzz)
   end
 
-  def test_integer_is_fizzbuzz
+  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_equal(3.fizzbuzz?, false)
-    assert_equal(5.fizzbuzz?, false)
+    assert_false(3.fizzbuzz?, false)
+    assert_false(5.fizzbuzz?, false)
   end
 
   def test_bignum_integration
-    assert_block do
-      DEFAULT_INSTANCE_METHODS_ADDED.all? {|i| @bignum.respond_to?(i) }
-    end
+    [
+      :fizz?,
+      :buzz?,
+      :fizzbuzz?
+    ].each {|i| assert_respond_to(@bignum, i) }
   end
 
   def test_bignum_is_fizz
-    assert_equal((@bignum + 2).fizz?, true)
-    assert_equal((@bignum + 15).fizz?, false)
+    assert_true((@bignum + 2).fizz?)
+    assert_false((@bignum + 15).fizz?)
   end
 
   def test_bignum_is_buzz
-    assert_equal((@bignum + 15).buzz?, true)
-    assert_equal((@bignum + 5).buzz?, false)
+    assert_true((@bignum + 15).buzz?)
+    assert_false((@bignum + 5).buzz?)
   end
 
   def test_bignum_is_fizzbuzz
-    assert_equal((@bignum + 5).fizzbuzz?, true)
-    assert_equal((@bignum + 2).fizzbuzz?, false)
-    assert_equal((@bignum + 15).fizzbuzz?, false)
+    assert_true((@bignum + 5).fizzbuzz?)
+    assert_false((@bignum + 2).fizzbuzz?)
+    assert_false((@bignum + 15).fizzbuzz?)
   end
 
   def test_array_integration
-    assert([].respond_to?(:fizzbuzz))
+    assert_respond_to([], :fizzbuzz)
   end
 
   def test_array_integration_fizzbuzz
-    obtainted = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].fizzbuzz
-    assert_equal(obtainted, DEFAULT_EXPECTED)
+    obtained = Array(1..15).fizzbuzz
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, @expected)
   end
 
   def test_array_integration_fizzbuzz_reverse
-    obtainted = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].fizzbuzz(true)
-    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+    obtained = Array(1..15).fizzbuzz(true)
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, @expected.reverse)
   end
 
   def test_array_integration_fizzbuzz_block
-    obtainted = []
-    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].fizzbuzz {|i| obtainted << i }
-    assert_equal(obtainted, DEFAULT_EXPECTED)
+    obtained = []
+    Array(1..15).fizzbuzz {|i| obtained << i }
+    assert_equal(obtained, @expected)
   end
 
   def test_array_integration_fizzbuzz_block_reverse
-    obtainted = []
-    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15].fizzbuzz(true) {|i| obtainted << i }
-    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+    obtained = []
+    Array(1..15).fizzbuzz(true) {|i| obtained << i }
+    assert_equal(obtained, @expected.reverse)
   end
 
   def test_range_integration
-    assert((0..0).respond_to?(:fizzbuzz))
+    assert_respond_to((0..0), :fizzbuzz)
   end
 
   def test_range_integration_fizzbuzz
-    obtainted = (DEFAULT_START .. DEFAULT_STOP).fizzbuzz
-    assert_equal(obtainted, DEFAULT_EXPECTED)
+    obtained = (1..15).fizzbuzz
+    assert_kind_of(Enumerator, obtained)
+    assert_equal(obtained.to_a, @expected)
   end
 
   def test_range_integration_fizzbuzz_reverse
-    obtainted = (DEFAULT_START .. DEFAULT_STOP).fizzbuzz(true)
-    assert_equal(obtainted, DEFAULT_EXPECTED.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
-    obtainted = []
-    (DEFAULT_START .. DEFAULT_STOP).fizzbuzz {|i| obtainted << i }
-    assert_equal(obtainted, DEFAULT_EXPECTED)
+    obtained = []
+    (1..15).fizzbuzz {|i| obtained << i }
+    assert_equal(obtained, @expected)
   end
 
   def test_range_integration_fizzbuzz_block_reverse
-    obtainted = []
-    (DEFAULT_START .. DEFAULT_STOP).fizzbuzz(true) {|i| obtainted << i }
-    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+    obtained = []
+    (1..15).fizzbuzz(true) {|i| obtained << i }
+    assert_equal(obtained, @expected.reverse)
   end
 
   def test_singleton_fizzbuzz_incorrect_range_error
@@ -196,201 +260,263 @@ class FizzBuzzTest < Test::Unit::TestCase
     end
   end
 
-  def test_singleton_fizzbuzz_integer
-    integer = @integer + 14
-    obtainted = FizzBuzz.fizzbuzz(integer, integer)
-    assert_equal(obtainted, ['FizzBuzz'])
+  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
-    bignum = @bignum + 5
-    obtainted = FizzBuzz.fizzbuzz(bignum, bignum)
-    assert_equal(obtainted, ['FizzBuzz'])
+    obtained = FizzBuzz.fizzbuzz(@bignum + 5, @bignum + 5)
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, ['FizzBuzz'])
   end
 
   def test_singleton_fizzbuzz_large_bignum
-    bignum = @large_bignum + 5
-    obtainted = FizzBuzz.fizzbuzz(bignum, bignum)
-    assert_equal(obtainted, ['FizzBuzz'])
+    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(DEFAULT_START, DEFAULT_STOP)
-    assert_equal(obtained, DEFAULT_EXPECTED)
+    obtained = FizzBuzz.fizzbuzz(1, 15)
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, @expected)
   end
 
   def test_singleton_fizzbuzz_array_reverse
-    obtained = FizzBuzz.fizzbuzz(DEFAULT_START, DEFAULT_STOP, true)
-    assert_equal(obtained, DEFAULT_EXPECTED.reverse)
+    obtained = FizzBuzz.fizzbuzz(1, 15, true)
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, @expected.reverse)
   end
 
   def test_singleton_fizzbuzz_block
-    obtainted = []
-    FizzBuzz.fizzbuzz(DEFAULT_START, DEFAULT_STOP) {|i| obtainted << i }
-    assert_equal(obtainted, DEFAULT_EXPECTED)
+    obtained = []
+    FizzBuzz.fizzbuzz(1, 15) {|i| obtained << i }
+    assert_equal(obtained, @expected)
   end
 
   def test_singleton_fizzbuzz_block_reverse
-    obtainted = []
-    FizzBuzz.fizzbuzz(DEFAULT_START, DEFAULT_STOP, true) {|i| obtainted << i }
-    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+    obtained = []
+    FizzBuzz.fizzbuzz(1, 15, true) {|i| obtained << i }
+    assert_equal(obtained, @expected.reverse)
   end
 
-  def test_singleton_squre
-    obtained_fizz     = FizzBuzz[3]
-    obtained_buzz     = FizzBuzz[5]
-    obtained_fizzbuzz = FizzBuzz[15]
+  def test_singleton_squre_fixnum
+    obtained = []
 
-    obtained = [obtained_fizz, obtained_buzz, obtained_fizzbuzz]
+    obtained << FizzBuzz[3]
+    obtained << FizzBuzz[5]
+    obtained << FizzBuzz[15]
 
-    assert(FizzBuzz[@integer].class == Fixnum)
-    assert_block do
-      obtained.each_with_index.all? do |v,i|
-        v.is_a?(String) && obtained[i] == DEFAULT_WORDS[i]
-      end
+    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_fizz     = FizzBuzz[@bignum + 2]
-    obtained_buzz     = FizzBuzz[@bignum + 15]
-    obtained_fizzbuzz = FizzBuzz[@bignum + 5]
+    obtained = []
+
+    obtained << FizzBuzz[@bignum + 2]
+    obtained << FizzBuzz[@bignum + 15]
+    obtained << FizzBuzz[@bignum + 5]
 
-    obtained = [obtained_fizz, obtained_buzz, obtained_fizzbuzz]
+    assert_kind_of(Bignum, FizzBuzz[@bignum + 3])
 
-    assert(FizzBuzz[@bignum + 3].class == Bignum)
-    assert_block do
-      obtained.each_with_index.all? do |v,i|
-        v.is_a?(String) && obtained[i] == DEFAULT_WORDS[i]
-      end
+    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_fizz     = FizzBuzz[@large_bignum + 2]
-    obtained_buzz     = FizzBuzz[@large_bignum + 15]
-    obtained_fizzbuzz = FizzBuzz[@large_bignum + 5]
+    obtained = []
 
-    obtained = [obtained_fizz, obtained_buzz, obtained_fizzbuzz]
+    obtained << FizzBuzz[@large_bignum + 2]
+    obtained << FizzBuzz[@large_bignum + 15]
+    obtained << FizzBuzz[@large_bignum + 5]
 
-    assert(FizzBuzz[@large_bignum + 3].class == Bignum)
-    assert_block do
-      obtained.each_with_index.all? do |v,i|
-        v.is_a?(String) && obtained[i] == DEFAULT_WORDS[i]
-      end
+    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_equal(FizzBuzz.is_fizz?(3), true)
-    assert_equal(FizzBuzz.is_fizz?(15), false)
+    assert_true(FizzBuzz.is_fizz?(3))
+    assert_false(FizzBuzz.is_fizz?(15))
   end
 
   def test_singleton_is_buzz
-    assert_equal(FizzBuzz.is_buzz?(5), true)
-    assert_equal(FizzBuzz.is_buzz?(15), false)
+    assert_true(FizzBuzz.is_buzz?(5))
+    assert_false(FizzBuzz.is_buzz?(15))
   end
 
   def test_singleton_is_fizzbuzz
-    assert_equal(FizzBuzz.is_fizzbuzz?(15), true)
-    assert_equal(FizzBuzz.is_fizzbuzz?(3), false)
-    assert_equal(FizzBuzz.is_fizzbuzz?(5), false)
+    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(obtained_square.is_a?(Integer) && obtained_square == 0)
-    assert(obtained_is_fizzbuzz.is_a?(FalseClass) && obtained_is_fizzbuzz == false)
+    assert_kind_of(Fixnum, obtained_square)
+    assert_equal(obtained_square, 0)
+    assert_false(obtained_is_fizzbuzz)
   end
 
-  def test_to_a
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-    assert_equal(fb.to_a, DEFAULT_EXPECTED)
+  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_each
-    obtainted = []
+  def test_to_a_fixnum
+    obtained = @fizzbuzz.to_a
 
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-    fb.each {|i| obtainted << i }
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, @expected)
+  end
 
-    assert_equal(obtainted, DEFAULT_EXPECTED)
+  def test_each_fixnum
+    obtained = []
+    @fizzbuzz.each {|i| obtained << i }
+    assert_equal(obtained, @expected)
   end
 
-  def test_reverse_each
-    obtainted = []
+  def test_reverse_each_fixnum
+    obtained = []
+    @fizzbuzz.reverse_each {|i| obtained << i }
+    assert_equal(obtained, @expected.reverse)
+  end
 
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-    fb.reverse_each {|i| obtainted << i }
+  def test_to_a_bignum
+    @fizzbuzz = FizzBuzz.new(@bignum + 1, @bignum + 15)
+    obtained = @fizzbuzz.to_a
 
-    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+    assert_kind_of(Array, obtained)
+    assert_equal(obtained, @expected_bignum)
   end
 
-  def test_for_fizzbuzz_integer
-    fb = FizzBuzz.new(DEFAULT_START, 15)
-    assert_equal(fb.to_a[14], 'FizzBuzz')
+  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
-    fb = FizzBuzz.new(@bignum + 5, @bignum + 5)
-    assert_equal(fb.to_a[0], 'FizzBuzz')
+    @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
-    fb = FizzBuzz.new(@large_bignum + 5, @large_bignum + 5)
-    assert_equal(fb.to_a[0], 'FizzBuzz')
+    @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_integer
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+  def test_correct_start_fixnum
+    assert_kind_of(Fixnum, @fizzbuzz.start)
+    assert_equal(@fizzbuzz.start, 1)
+
+    @fizzbuzz.start = 2
 
-    assert(fb.start.is_a?(Integer) && fb.start == 1)
-    fb.start = 2
-    assert(fb.start.is_a?(Integer) && fb.start == 2)
+    assert_kind_of(Fixnum, @fizzbuzz.start)
+    assert_equal(@fizzbuzz.start, 2)
   end
 
   def test_correct_start_bignum
-    fb = FizzBuzz.new(@bignum, @bignum)
+    @fizzbuzz = FizzBuzz.new(@bignum, @bignum)
 
-    assert_block do
-      fb.start.is_a?(Bignum) && fb.start == @bignum
-      fb.start = @bignum - 5
-      fb.start.is_a?(Bignum) && fb.start == (@bignum - 5)
-    end
+    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
-    fb = FizzBuzz.new(@large_bignum, @large_bignum)
+    @fizzbuzz = FizzBuzz.new(@large_bignum, @large_bignum)
+
+    assert_kind_of(Bignum, @fizzbuzz.start)
+    assert_equal(@fizzbuzz.start, @large_bignum)
 
-    assert(fb.start.is_a?(Bignum) && fb.start == @large_bignum)
-    fb.start = @large_bignum - 5
-    assert(fb.start.is_a?(Bignum) && fb.start == (@large_bignum - 5))
+    @fizzbuzz.start = @large_bignum - 5
+
+    assert_kind_of(Bignum, @fizzbuzz.start)
+    assert_equal(@fizzbuzz.start, @large_bignum - 5)
   end
 
-  def test_correct_stop_integer
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+  def test_correct_stop_fixnum
+    assert_kind_of(Fixnum, @fizzbuzz.stop)
+    assert_equal(@fizzbuzz.stop, 15)
+
+    @fizzbuzz.stop = 5
 
-    assert(fb.stop.is_a?(Integer) && fb.stop == 15)
-    fb.stop = 5
-    assert(fb.stop.is_a?(Integer) && fb.stop == 5)
+    assert_kind_of(Fixnum, @fizzbuzz.stop)
+    assert_equal(@fizzbuzz.stop, 5)
   end
 
   def test_correct_stop_bignum
-    fb = FizzBuzz.new(@bignum, @bignum)
+    @fizzbuzz = FizzBuzz.new(@bignum, @bignum)
 
-    assert(fb.stop.is_a?(Bignum) && fb.stop == @bignum)
-    fb.stop = @bignum + 5
-    assert(fb.stop.is_a?(Bignum) && fb.stop == (@bignum + 5))
+    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
-    fb = FizzBuzz.new(@large_bignum, @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(fb.stop.is_a?(Bignum) && fb.stop == @large_bignum)
-    fb.stop = @large_bignum + 5
-    assert(fb.stop.is_a?(Bignum) && fb.stop == (@large_bignum + 5))
+    assert_kind_of(Bignum, @fizzbuzz.stop)
+    assert_equal(@fizzbuzz.stop, @large_bignum + 5)
   end
 
   def test_missing_arguments
@@ -405,6 +531,12 @@ class FizzBuzzTest < Test::Unit::TestCase
     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)
@@ -419,94 +551,87 @@ class FizzBuzzTest < Test::Unit::TestCase
 
   def test_start_type_error
     assert_raise FizzBuzz::TypeError do
-      fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-      fb.start = ''
+      @fizzbuzz.start = ''
     end
   end
 
   def test_stop_type_error
     assert_raise FizzBuzz::TypeError do
-      fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-      fb.stop = ''
+      @fizzbuzz.stop = ''
     end
   end
 
   def test_correct_start_stop
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_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
 
-    fb.start = 2
-    fb.stop  = 3
+  def test_fizzbuzz_error
+    message = 'The quick brown fox jumps over the lazy dog'
+    error = FizzBuzz::Error.new(message)
 
-    assert(fb.start.is_a?(Integer) && fb.start == 2)
-    assert(fb.stop.is_a?(Integer) && fb.stop == 3)
+    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
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-
     assert_raise FizzBuzz::RangeError do
-      fb.start = 16
+      @fizzbuzz.start = 16
     end
   end
 
   def test_stop_range_error
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-
     assert_raise FizzBuzz::RangeError do
-      fb.stop = -1
+      @fizzbuzz.stop = -1
     end
   end
 
-  def test_for_range_error
+  def test_for_not_raising_range_error
     assert_nothing_raised do
-      FizzBuzz.new(DEFAULT_START, @bignum ** 2)
-      FizzBuzz.new(-@large_bignum, DEFAULT_STOP)
+      FizzBuzz.new(1, @bignum ** 2)
+      FizzBuzz.new(-@large_bignum, 15)
     end
   end
 
   def test_error_attributes_not_nil
-    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
-
-    begin
-      fb.start = 1
-      fb.stop  = 0
-    rescue FizzBuzz::RangeError => error
-      assert_equal(error.start, 1)
-      assert_equal(error.stop, 0)
-    end
+    @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
-    begin
-      FizzBuzz.new('', '')
-    rescue FizzBuzz::TypeError => error
-      assert_equal(error.start, nil)
-      assert_equal(error.stop, nil)
-    end
+    FizzBuzz.new('', '')
+  rescue FizzBuzz::TypeError => error
+    assert_nil(error.start)
+    assert_nil(error.stop)
   end
 
   def test_start_type_error_message
-    begin
-      FizzBuzz.new('', DEFAULT_STOP)
-    rescue FizzBuzz::TypeError => error
-      assert_equal(error.message, 'must be an Integer or Bignum type for start')
-    end
+    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
-    begin
-      FizzBuzz.new(DEFAULT_START, '')
-    rescue FizzBuzz::TypeError => error
-      assert_equal(error.message, 'must be an Integer or Bignum type for stop')
-    end
+    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
-    begin
-      FizzBuzz.new(DEFAULT_STOP, DEFAULT_START)
-    rescue FizzBuzz::RangeError => error
-      assert_equal(error.message, 'start value is higher than stop value')
-    end
+    FizzBuzz.new(15, 1)
+  rescue FizzBuzz::RangeError => error
+    assert_equal(error.message, 'start value is higher than stop value')
   end
 end