ruby-fizzbuzz 0.0.4 → 0.0.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTllN2IxMDdjZWQ3MmYzZDk3ZTc1YjVkMDUzMGYxMzU2NzlhZDQ2Nw==
+    NGMwNWU1NjNiMzhmZGQwZGZlZjUyNTM4ZTE0N2ZiMWUyY2E0YjBkOA==
   data.tar.gz: !binary |-
-    ZDRhYTA3ZTdkNDg2ZWM4ODIxN2Y0OWE0M2ZkZGE2YmE4MjlmYzg3Mw==
+    MzNkMTQ2MTkxMjUzNTY3M2UxZWQyZjg3NTQ3YzlhMTlmMjYwYjZiYg==
 SHA512:
   metadata.gz: !binary |-
-    YmUwMDE4ZWI4OWE3ZDE4NjQ4NTUyYWVjOGUzYzZiYjlhNjcxNDIxMmY5OWMx
-    ZTZiNzkxOTVlM2ZkNzljMDFlMTNiYzIyNjRmZjQ5YmM0NjU4MmVmZDJkZjk0
-    YzkzZDU4ODI2MGU4MjZkZjBiMWQxYTk0NDBiYWY1OTJhZmVlMzg=
+    NmYwYTYzYzA1MjUyODRhMmVmNTM0NDQ4OGY1NzYwMzAwZDBkZWRlODRjMTNm
+    ODQ1YjE5ZjYwMmM1NzQ4MWU5NWE3YzE5ZTkyODIyZDVlODBkNTQ2MjcyMTI5
+    ZjRiZTE0YzQzMjkwM2RjYTVkYjUzMjVlMDM5NWIwNjIyMjRmNzY=
   data.tar.gz: !binary |-
-    MGI4ZDM2YjlkMTZkYjFiZGU3ZTc1MzQ3M2JiZTVmMDE4YzNhZWIxNzM0NmJj
-    NTYwODc1MTQ3ZTExMDc2MDhkNmNkNzMyZjYyMmExZjc4ZWQ5OWU0MmJhY2Vm
-    Njc0OGQ2M2ViYjIwYjAxNWZlYzI3NGNiNmZjNDBkOTNjNTEzZDc=
+    MTAxOTE2YjM0NGMxZjVhNjc4YWYyZGUzMzcwMjRiNjNiNDlkMTY4MWMxNGQ4
+    Y2RjYzYxYjhkZDM0ZmM5NWE4MDYyZTZmOGY5YTQ2YjBmMWUxOGFkOWFjYmRm
+    ZjkyZGVlODdjMzgyMzliYjI3NjE1MTJjMWE3MmI5ZTA5ZWEwMDY=

data/CHANGES

@@ -1,3 +1,10 @@
+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);

data/CHANGES.rdoc

@@ -1,3 +1,10 @@
+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);

data/Rakefile

@@ -72,6 +72,24 @@ end
 
 Rake::Task[:test].prerequisites << :compile
 
+desc 'Run benchmarks'
+task :benchmark, [:first] => :test 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
+
 task :default => :package
 
 # vim: set ts=2 sw=2 sts=2 et :

data/TODO

@@ -1,23 +1,16 @@
-fizzbuzz (1.0.0)
-
-  * Add simple web interface with RESTful backend API.
-
--- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Mon, 01 Oct 2012 17:57:18 +0100
-
-fizzbuzz (0.0.6)
+fizzbuzz (0.0.7)
 
   * 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, 18 Nov 2013 11:22:26 +0000
+-- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Tue, 26 Nov 2013 12:40:34 +0000
 
-fizzbuzz (0.0.5)
+fizzbuzz (0.0.6)
 
   * Move to YARD from RDoc (as RDoc is very bad, really);
   * Add pure-Ruby implementation;
-  * Add benchmarks;
   * 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, 18 Nov 2013 11:22:26 +0000
+-- Krzysztof Wilczynski <krzysztof.wilczynski@linux.com>  Tue, 26 Nov 2013 12:40:34 +0000

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/benchmark/benchmark_fizzbuzz.rb

@@ -0,0 +1,107 @@
+# -*- encoding: utf-8 -*-
+
+# :enddoc:
+
+#
+# benchmark_fizzbuzz.rb
+#
+# Copyright 2012-2013 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
+    (1 .. n).fizzbuzz
+  end
+
+  reports << bm.report('Range#fizzbuzz') do
+    array.fizzbuzz
+  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/ext/fizzbuzz/fizzbuzz.c

@@ -66,7 +66,7 @@ static VALUE fizzbuzz_range_error(VALUE klass, VALUE start, VALUE stop,
  * Will raise a <i>FizzBuzz::TypeError</i> exception if given value of either
  * +start+ or +stop+ is not an _Integer_ or _Bignum_ type.
  *
- * See also: FizzBuzz::fizzbuzz
+ * See also: FizzBuzz::fizzbuzz and FizzBuzz::[]
  */
 VALUE
 rb_fb_initialize(int argc, VALUE *argv, VALUE object)
@@ -182,7 +182,7 @@ rb_fb_set_stop(VALUE object, VALUE value)
  * call-seq:
  *    fizzbuzz.to_a -> array
  *
- * Returns an array containing results upon calculating an appropriate
+ * Returns an +array+ containing results upon calculating an appropriate
  * values for a given range from +start+ to +stop+.
  *
  * Example:
@@ -203,7 +203,7 @@ rb_fb_array(VALUE object)
  *    fizzbuzz.each {|value| block } -> self
  *    fizzbuzz.each                  -> an Enumerator
  *
- * Calls the block once for each subsequent value for a given range
+ * Calls the block _once_ for each subsequent value for a given range
  * from +start+ to +stop+, passing the value as a parameter to the block.
  *
  * If no block is given, an +Enumerator+ is returned instead.
@@ -244,7 +244,7 @@ rb_fb_enumerator(VALUE object)
  *    fizzbuzz.reverse_each {|value| block } -> self
  *    fizzbuzz.reverse_each                  -> an Enumerator
  *
- * Calls the block once for each subsequent value for a given range
+ * Calls the block _once_ for each subsequent value for a given range
  * from +start+ to +stop+ in an <i>reverse order</i>, passing the value
  * as a parameter to the block.
  *

data/lib/fizzbuzz.rb

@@ -26,6 +26,8 @@ require 'fizzbuzz/fizzbuzz'
 require 'fizzbuzz/version'
 require 'fizzbuzz/integer'
 require 'fizzbuzz/bignum'
+require 'fizzbuzz/array'
+require 'fizzbuzz/range'
 
 #
 # Yet another _FizzBuzz_ in Ruby.

data/lib/fizzbuzz/array.rb

@@ -0,0 +1,88 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# array.rb
+#
+# Copyright 2012-2013 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.
+#
+
+# :startdoc:
+
+#
+# Provides a convenient integration of _FizzBuzz_ with _Array_ class.
+#
+class Array
+  #
+  # call-seq:
+  #    array.fizzbuzz( reverse )                  -> array
+  #    array.fizzbuzz( reverse ) {|value| block } -> self
+  #
+  # 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.
+  #
+  # 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
+  # values to a block given.
+  #
+  # Example:
+  #
+  #    array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+  #    array.fizzbuzz         #=> [1, 2, "Fizz", 4, "Buzz", "Fizz", 7, 8, "Fizz", "Buzz", 11, "Fizz", 13, 14, "FizzBuzz"]
+  #    array.fizzbuzz(true)   #=> ["FizzBuzz", 14, 13, "Fizz", 11, "Buzz", "Fizz", 8, 7, "Fizz", "Buzz", 4, "Fizz", 2, 1]
+  #
+  # Example:
+  #
+  #    array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+  #    array.fizzbuzz {|value| puts "Got #{value}" }
+  #
+  # Produces:
+  #
+  #    Got 1
+  #    Got 2
+  #    Got Fizz
+  #    Got 4
+  #    Got Buzz
+  #    Got Fizz
+  #    Got 7
+  #    Got 8
+  #    Got Fizz
+  #    Got Buzz
+  #    Got 11
+  #    Got Fizz
+  #    Got 13
+  #    Got 14
+  #    Got FizzBuzz
+  #
+  # See also: FizzBuzz::fizzbuzz, FizzBuzz#to_a, FizzBuzz#each and FizzBuzz#reverse_each
+  #
+  def fizzbuzz(reverse = false)
+    values = self.send(reverse ? :reverse : :entries)
+
+    if block_given?
+      values.each {|i| yield FizzBuzz[i] }
+      self
+    else
+      values.collect {|i| FizzBuzz[i] }
+    end
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/fizzbuzz/integer.rb

@@ -5,7 +5,7 @@
 #
 # integer.rb
 #
-# Copyright 2012 Krzysztof Wilczynski
+# Copyright 2012-2013 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

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+# :stopdoc:
+
+#
+# range.rb
+#
+# Copyright 2012-2013 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.
+#
+
+# :startdoc:
+
+#
+# Provides a convenient integration of _FizzBuzz_ with _Range_ class.
+#
+class Range
+  #
+  # call-seq:
+  #    range.fizzbuzz( reverse )                  -> array
+  #    range.fizzbuzz( reverse ) {|value| block } -> self
+  #
+  # 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.
+  #
+  # 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
+  # values to a block given.
+  #
+  # 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]
+  #
+  # Example:
+  #
+  #    (1..15).fizzbuzz {|value| puts "Got #{value}" }
+  #
+  # Produces:
+  #
+  #    Got 1
+  #    Got 2
+  #    Got Fizz
+  #    Got 4
+  #    Got Buzz
+  #    Got Fizz
+  #    Got 7
+  #    Got 8
+  #    Got Fizz
+  #    Got Buzz
+  #    Got 11
+  #    Got Fizz
+  #    Got 13
+  #    Got 14
+  #    Got FizzBuzz
+  #
+  # 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)
+
+    if block_given?
+      values.each {|i| yield i }
+      self
+    else
+      values
+    end
+  end
+end
+
+# :enddoc:
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

data/lib/fizzbuzz/version.rb

@@ -26,7 +26,7 @@ class FizzBuzz
   #
   # Current version of _FizzBuzz_.
   #
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end
 
 # :enddoc:

data/ruby-fizzbuzz.gemspec

@@ -0,0 +1,71 @@
+# -*- encoding: utf-8 -*-
+
+# :enddoc:
+
+#
+# ruby-fizzbuzz.gemspec
+#
+# Copyright 2012-2013 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.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.rubyforge_project = 'ruby-fizzbuzz'
+  s.rubygems_version  = '~> 1.3.7'
+  s.has_rdoc          = true
+
+  s.summary = 'Yet another FizzBuzz in Ruby'
+
+  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.add_development_dependency 'rake', '>= 0.8.7'
+  s.add_development_dependency 'rdoc', '>= 3.12'
+  s.add_development_dependency 'test-unit', '>= 2.5.2'
+  s.add_development_dependency 'rake-compiler', '>= 0.7.1'
+
+  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

@@ -0,0 +1,514 @@
+# -*- encoding: utf-8 -*-
+
+# :enddoc:
+
+#
+# test_fizzbuzz.rb
+#
+# Copyright 2012-2013 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', '>= 2.5.2'
+
+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
+  end
+end
+
+class FizzBuzzTest < Test::Unit::TestCase
+  def setup
+    @integer = 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
+  end
+
+  def test_fizzbuzz_alias
+    assert(FB == FizzBuzz)
+  end
+
+  def test_fizzbuzz_singleton_methods
+    fb = FizzBuzz
+
+    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)
+
+    assert_block do
+      DEFAULT_INSTANCE_METHODS.all? {|i| fb.respond_to?(i) }
+    end
+  end
+
+  def test_integer_integration
+    assert_block do
+      DEFAULT_INSTANCE_METHODS_ADDED.all? {|i| @integer.respond_to?(i) }
+    end
+  end
+
+  def test_integer_is_fizz
+    assert_equal(3.fizz?, true)
+    assert_equal(15.fizz?, false)
+  end
+
+  def test_integer_is_buzz
+    assert_equal(5.buzz?, true)
+    assert_equal(15.buzz?, false)
+  end
+
+  def test_integer_is_fizzbuzz
+    assert_equal(15.fizzbuzz?, true)
+    assert_equal(3.fizzbuzz?, false)
+    assert_equal(5.fizzbuzz?, false)
+  end
+
+  def test_bignum_integration
+    assert_block do
+      DEFAULT_INSTANCE_METHODS_ADDED.all? {|i| @bignum.respond_to?(i) }
+    end
+  end
+
+  def test_bignum_is_fizz
+    assert_equal((@bignum + 2).fizz?, true)
+    assert_equal((@bignum + 15).fizz?, false)
+  end
+
+  def test_bignum_is_buzz
+    assert_equal((@bignum + 15).buzz?, true)
+    assert_equal((@bignum + 5).buzz?, false)
+  end
+
+  def test_bignum_is_fizzbuzz
+    assert_equal((@bignum + 5).fizzbuzz?, true)
+    assert_equal((@bignum + 2).fizzbuzz?, false)
+    assert_equal((@bignum + 15).fizzbuzz?, false)
+  end
+
+  def test_array_integration
+    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)
+  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)
+  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)
+  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)
+  end
+
+  def test_range_integration
+    assert((0..0).respond_to?(:fizzbuzz))
+  end
+
+  def test_range_integration_fizzbuzz
+    obtainted = (DEFAULT_START .. DEFAULT_STOP).fizzbuzz
+    assert_equal(obtainted, DEFAULT_EXPECTED)
+  end
+
+  def test_range_integration_fizzbuzz_reverse
+    obtainted = (DEFAULT_START .. DEFAULT_STOP).fizzbuzz(true)
+    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+  end
+
+  def test_range_integration_fizzbuzz_block
+    obtainted = []
+    (DEFAULT_START .. DEFAULT_STOP).fizzbuzz {|i| obtainted << i }
+    assert_equal(obtainted, DEFAULT_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)
+  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_integer
+    integer = @integer + 14
+    obtainted = FizzBuzz.fizzbuzz(integer, integer)
+    assert_equal(obtainted, ['FizzBuzz'])
+  end
+
+  def test_singleton_fizzbuzz_bignum
+    bignum = @bignum + 5
+    obtainted = FizzBuzz.fizzbuzz(bignum, bignum)
+    assert_equal(obtainted, ['FizzBuzz'])
+  end
+
+  def test_singleton_fizzbuzz_large_bignum
+    bignum = @large_bignum + 5
+    obtainted = FizzBuzz.fizzbuzz(bignum, bignum)
+    assert_equal(obtainted, ['FizzBuzz'])
+  end
+
+  def test_singleton_fizzbuzz_array
+    obtained = FizzBuzz.fizzbuzz(DEFAULT_START, DEFAULT_STOP)
+    assert_equal(obtained, DEFAULT_EXPECTED)
+  end
+
+  def test_singleton_fizzbuzz_array_reverse
+    obtained = FizzBuzz.fizzbuzz(DEFAULT_START, DEFAULT_STOP, true)
+    assert_equal(obtained, DEFAULT_EXPECTED.reverse)
+  end
+
+  def test_singleton_fizzbuzz_block
+    obtainted = []
+    FizzBuzz.fizzbuzz(DEFAULT_START, DEFAULT_STOP) {|i| obtainted << i }
+    assert_equal(obtainted, DEFAULT_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)
+  end
+
+  def test_singleton_squre
+    obtained_fizz     = FizzBuzz[3]
+    obtained_buzz     = FizzBuzz[5]
+    obtained_fizzbuzz = FizzBuzz[15]
+
+    obtained = [obtained_fizz, obtained_buzz, obtained_fizzbuzz]
+
+    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
+    end
+  end
+
+  def test_singleton_squre_bignum
+    obtained_fizz     = FizzBuzz[@bignum + 2]
+    obtained_buzz     = FizzBuzz[@bignum + 15]
+    obtained_fizzbuzz = FizzBuzz[@bignum + 5]
+
+    obtained = [obtained_fizz, obtained_buzz, obtained_fizzbuzz]
+
+    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
+    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_fizz, obtained_buzz, obtained_fizzbuzz]
+
+    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
+    end
+  end
+
+  def test_singleton_is_fizz
+    assert_equal(FizzBuzz.is_fizz?(3), true)
+    assert_equal(FizzBuzz.is_fizz?(15), false)
+  end
+
+  def test_singleton_is_buzz
+    assert_equal(FizzBuzz.is_buzz?(5), true)
+    assert_equal(FizzBuzz.is_buzz?(15), false)
+  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)
+  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)
+  end
+
+  def test_to_a
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+    assert_equal(fb.to_a, DEFAULT_EXPECTED)
+  end
+
+  def test_each
+    obtainted = []
+
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+    fb.each {|i| obtainted << i }
+
+    assert_equal(obtainted, DEFAULT_EXPECTED)
+  end
+
+  def test_reverse_each
+    obtainted = []
+
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+    fb.reverse_each {|i| obtainted << i }
+
+    assert_equal(obtainted, DEFAULT_EXPECTED.reverse)
+  end
+
+  def test_for_fizzbuzz_integer
+    fb = FizzBuzz.new(DEFAULT_START, 15)
+    assert_equal(fb.to_a[14], 'FizzBuzz')
+  end
+
+  def test_for_fizzbuzz_bignum
+    fb = FizzBuzz.new(@bignum + 5, @bignum + 5)
+    assert_equal(fb.to_a[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')
+  end
+
+  def test_correct_start_integer
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+
+    assert(fb.start.is_a?(Integer) && fb.start == 1)
+    fb.start = 2
+    assert(fb.start.is_a?(Integer) && fb.start == 2)
+  end
+
+  def test_correct_start_bignum
+    fb = 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
+  end
+
+  def test_correct_start_large_bignum
+    fb = FizzBuzz.new(@large_bignum, @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))
+  end
+
+  def test_correct_stop_integer
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+
+    assert(fb.stop.is_a?(Integer) && fb.stop == 15)
+    fb.stop = 5
+    assert(fb.stop.is_a?(Integer) && fb.stop == 5)
+  end
+
+  def test_correct_stop_bignum
+    fb = 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))
+  end
+
+  def test_correct_stop_large_bignum
+    fb = FizzBuzz.new(@large_bignum, @large_bignum)
+
+    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))
+  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_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
+      fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+      fb.start = ''
+    end
+  end
+
+  def test_stop_type_error
+    assert_raise FizzBuzz::TypeError do
+      fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+      fb.stop = ''
+    end
+  end
+
+  def test_correct_start_stop
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+
+    fb.start = 2
+    fb.stop  = 3
+
+    assert(fb.start.is_a?(Integer) && fb.start == 2)
+    assert(fb.stop.is_a?(Integer) && fb.stop == 3)
+  end
+
+  def test_start_range_error
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+
+    assert_raise FizzBuzz::RangeError do
+      fb.start = 16
+    end
+  end
+
+  def test_stop_range_error
+    fb = FizzBuzz.new(DEFAULT_START, DEFAULT_STOP)
+
+    assert_raise FizzBuzz::RangeError do
+      fb.stop = -1
+    end
+  end
+
+  def test_for_range_error
+    assert_nothing_raised do
+      FizzBuzz.new(DEFAULT_START, @bignum ** 2)
+      FizzBuzz.new(-@large_bignum, DEFAULT_STOP)
+    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
+  end
+
+  def test_error_attributes_nil
+    begin
+      FizzBuzz.new('', '')
+    rescue FizzBuzz::TypeError => error
+      assert_equal(error.start, nil)
+      assert_equal(error.stop, nil)
+    end
+  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
+  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
+  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
+  end
+end
+
+# vim: set ts=2 sw=2 sts=2 et :
+# encoding: utf-8

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-fizzbuzz
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Krzysztof Wilczynski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-18 00:00:00.000000000 Z
+date: 2013-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -89,10 +89,15 @@ files:
 - ext/fizzbuzz/fizzbuzz.h
 - ext/fizzbuzz/extconf.rb
 - lib/fizzbuzz/bignum.rb
+- lib/fizzbuzz/array.rb
 - lib/fizzbuzz/integer.rb
+- lib/fizzbuzz/range.rb
 - lib/fizzbuzz/version.rb
 - lib/fizzbuzz.rb
+- benchmark/benchmark_fizzbuzz.rb
+- test/test_fizzbuzz.rb
 - Rakefile
+- ruby-fizzbuzz.gemspec
 - AUTHORS
 - CHANGES
 - CHANGES.rdoc