osheet 0.7.0 → 0.8.0

data/test/format/fraction_test.rb

@@ -1,84 +1,84 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/fraction'
 
 module Osheet::Format
 
-  class FractionTest < Test::Unit::TestCase
-    context "Fraction format" do
-      subject { Fraction.new }
+  class FractionTest < Assert::Context
+    desc "Fraction format"
+    before { @f = Fraction.new }
+    subject { @f }
 
-      should_have_accessors :type
+    should have_accessors :type
 
-      should "provide options for type" do
-        assert_equal 9, Fraction.type_set.size
-        [ :one_digit, :two_digits, :three_digits,
-          :halves, :quarters, :eighths, :sixteenths,
-          :tenths, :hundredths
-        ].each do |a|
-          assert Fraction.type_set.include?(a)
-        end
-      end
-
-      should "set default values" do
-        assert_equal '??/??', subject.type
-        assert_equal :two_digits, subject.type_key
+    should "provide options for type" do
+      assert_equal 9, Fraction.type_set.size
+      [ :one_digit, :two_digits, :three_digits,
+        :halves, :quarters, :eighths, :sixteenths,
+        :tenths, :hundredths
+      ].each do |a|
+        assert Fraction.type_set.include?(a)
       end
+    end
 
-      should "generate a one_digit type style strings and key" do
-        f = Fraction.new(:type => :one_digit)
-        assert_equal "#\ ?/?", f.style
-        assert_equal "fraction_onedigit", f.key
-      end
+    should "set default values" do
+      assert_equal '??/??', subject.type
+      assert_equal :two_digits, subject.type_key
+    end
 
-      should "generate a two_digit type style strings and key" do
-        f = Fraction.new(:type => :two_digits)
-        assert_equal "#\ ??/??", f.style
-        assert_equal "fraction_twodigits", f.key
-      end
+    should "generate a one_digit type style strings and key" do
+      f = Fraction.new(:type => :one_digit)
+      assert_equal "#\ ?/?", f.style
+      assert_equal "fraction_onedigit", f.key
+    end
 
-      should "generate a three_digit type style strings and key" do
-        f = Fraction.new(:type => :three_digits)
-        assert_equal "#\ ???/???", f.style
-        assert_equal "fraction_threedigits", f.key
-      end
+    should "generate a two_digit type style strings and key" do
+      f = Fraction.new(:type => :two_digits)
+      assert_equal "#\ ??/??", f.style
+      assert_equal "fraction_twodigits", f.key
+    end
 
-      should "generate a halves type style strings and key" do
-        f = Fraction.new(:type => :halves)
-        assert_equal "#\ ?/2", f.style
-        assert_equal "fraction_halves", f.key
-      end
+    should "generate a three_digit type style strings and key" do
+      f = Fraction.new(:type => :three_digits)
+      assert_equal "#\ ???/???", f.style
+      assert_equal "fraction_threedigits", f.key
+    end
 
-      should "generate a quarters type style strings and key" do
-        f = Fraction.new(:type => :quarters)
-        assert_equal "#\ ?/4", f.style
-        assert_equal "fraction_quarters", f.key
-      end
+    should "generate a halves type style strings and key" do
+      f = Fraction.new(:type => :halves)
+      assert_equal "#\ ?/2", f.style
+      assert_equal "fraction_halves", f.key
+    end
 
-      should "generate a eighths type style strings and key" do
-        f = Fraction.new(:type => :eighths)
-        assert_equal "#\ ?/8", f.style
-        assert_equal "fraction_eighths", f.key
-      end
+    should "generate a quarters type style strings and key" do
+      f = Fraction.new(:type => :quarters)
+      assert_equal "#\ ?/4", f.style
+      assert_equal "fraction_quarters", f.key
+    end
 
-      should "generate a sixteenths type style strings and key" do
-        f = Fraction.new(:type => :sixteenths)
-        assert_equal "#\ ??/16", f.style
-        assert_equal "fraction_sixteenths", f.key
-      end
+    should "generate a eighths type style strings and key" do
+      f = Fraction.new(:type => :eighths)
+      assert_equal "#\ ?/8", f.style
+      assert_equal "fraction_eighths", f.key
+    end
 
-      should "generate a tenths type style strings and key" do
-        f = Fraction.new(:type => :tenths)
-        assert_equal "#\ ?/10", f.style
-        assert_equal "fraction_tenths", f.key
-      end
+    should "generate a sixteenths type style strings and key" do
+      f = Fraction.new(:type => :sixteenths)
+      assert_equal "#\ ??/16", f.style
+      assert_equal "fraction_sixteenths", f.key
+    end
 
-      should "generate a hundredths type style strings and key" do
-        f = Fraction.new(:type => :hundredths)
-        assert_equal "#\ ??/100", f.style
-        assert_equal "fraction_hundredths", f.key
-      end
+    should "generate a tenths type style strings and key" do
+      f = Fraction.new(:type => :tenths)
+      assert_equal "#\ ?/10", f.style
+      assert_equal "fraction_tenths", f.key
+    end
 
+    should "generate a hundredths type style strings and key" do
+      f = Fraction.new(:type => :hundredths)
+      assert_equal "#\ ??/100", f.style
+      assert_equal "fraction_hundredths", f.key
     end
+
   end
 
 end

data/test/format/general_test.rb

@@ -1,21 +1,21 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/general'
 
 module Osheet::Format
 
-  class GeneralTest < Test::Unit::TestCase
-    context "General format" do
-      subject { General.new }
+  class GeneralTest < Assert::Context
+    desc "General format"
+    before { @f = General.new }
+    subject { @f }
 
-      should "always provide a nil style string" do
-        assert_equal nil, subject.style
-      end
-
-      should "always provide and empty format key" do
-        assert_equal '', subject.key
-      end
+    should "always provide a nil style string" do
+      assert_equal nil, subject.style
+    end
 
+    should "always provide and empty format key" do
+      assert_equal '', subject.key
     end
+
   end
 
 end

data/test/format/number_test.rb

@@ -1,93 +1,91 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/number'
 
 module Osheet::Format
 
-  class NumberTest < Test::Unit::TestCase
-    context "Number format" do
-      subject { Number.new }
+  class NumberTest < Assert::Context
+    desc "Number format"
+    before { @n = Number.new }
+    subject { @n }
 
-      should_have_accessors :decimal_places, :comma_separator, :negative_numbers
+    should have_accessors :decimal_places, :comma_separator, :negative_numbers
 
-      should "provide options for negative numbers" do
-        assert_equal 4, Number.negative_numbers_set.size
-        [:black, :black_parenth, :red, :red_parenth].each do |a|
-          assert Number.negative_numbers_set.include?(a)
-        end
+    should "provide options for negative numbers" do
+      assert_equal 4, Number.negative_numbers_set.size
+      [:black, :black_parenth, :red, :red_parenth].each do |a|
+        assert Number.negative_numbers_set.include?(a)
       end
+    end
 
-      should "set default values" do
-        assert_equal 0, subject.decimal_places
-        assert_equal false, subject.comma_separator
-        assert_equal :black, subject.negative_numbers
-      end
+    should "set default values" do
+      assert_equal 0, subject.decimal_places
+      assert_equal false, subject.comma_separator
+      assert_equal :black, subject.negative_numbers
+    end
 
-      should "only allow Fixnum decimal places between 0 and 30" do
-        assert_raises ArgumentError do
-          Number.new({:decimal_places => -1})
-        end
-        assert_raises ArgumentError do
-          Number.new({:decimal_places => 31})
-        end
-        assert_raises ArgumentError do
-          Number.new({:decimal_places => 'poo'})
-        end
-        assert_nothing_raised do
-          Number.new({:decimal_places => 1})
-        end
+    should "only allow Fixnum decimal places between 0 and 30" do
+      assert_raises ArgumentError do
+        Number.new({:decimal_places => -1})
       end
-
-      should "generate decimal place style strings" do
-        assert_equal "0", Number.new({:decimal_places => 0}).style
-        (1..5).each do |n|
-          assert_equal "0.#{'0'*n}", Number.new({:decimal_places => n}).style
-        end
+      assert_raises ArgumentError do
+        Number.new({:decimal_places => 31})
       end
-
-      should "generate comma separator style strings" do
-        assert_equal "0", Number.new({:comma_separator => false}).style
-        assert_equal "#,##0", Number.new({:comma_separator => true}).style
+      assert_raises ArgumentError do
+        Number.new({:decimal_places => 'poo'})
       end
-
-      should "generate parenth negative numbers style strings" do
-        assert_equal "0", Number.new({:negative_numbers => :black}).style
-        assert_equal "0_);\(0\)", Number.new({:negative_numbers => :black_parenth}).style
+      assert_nothing_raised do
+        Number.new({:decimal_places => 1})
       end
+    end
 
-      should "generate red negative numbers style strings" do
-        assert_equal "0;[Red]0", Number.new({:negative_numbers => :red}).style
-        assert_equal "0_);[Red]\(0\)", Number.new({:negative_numbers => :red_parenth}).style
+    should "generate decimal place style strings" do
+      assert_equal "0", Number.new({:decimal_places => 0}).style
+      (1..5).each do |n|
+        assert_equal "0.#{'0'*n}", Number.new({:decimal_places => n}).style
       end
+    end
 
-      should "generate complex style string" do
-        assert_equal("0.00_);\(0.00\)", Number.new({
-          :decimal_places => 2,
-          :negative_numbers => :black_parenth,
-          :comma_separator => false
-        }).style)
-        assert_equal("#,##0.0000_);[Red]\(#,##0.0000\)", Number.new({
-          :decimal_places => 4,
-          :negative_numbers => :red_parenth,
-          :comma_separator => true
-        }).style)
-      end
+    should "generate comma separator style strings" do
+      assert_equal "0", Number.new({:comma_separator => false}).style
+      assert_equal "#,##0", Number.new({:comma_separator => true}).style
+    end
 
-      should "provide unique format keys" do
-        assert_equal("number_none_2_nocomma_blackparenth", Number.new({
-          :decimal_places => 2,
-          :negative_numbers => :black_parenth,
-          :comma_separator => false
-        }).key)
-        assert_equal("number_none_4_comma_redparenth", Number.new({
-          :decimal_places => 4,
-          :negative_numbers => :red_parenth,
-          :comma_separator => true
-        }).key)
-      end
+    should "generate parenth negative numbers style strings" do
+      assert_equal "0", Number.new({:negative_numbers => :black}).style
+      assert_equal "0_);\(0\)", Number.new({:negative_numbers => :black_parenth}).style
+    end
 
+    should "generate red negative numbers style strings" do
+      assert_equal "0;[Red]0", Number.new({:negative_numbers => :red}).style
+      assert_equal "0_);[Red]\(0\)", Number.new({:negative_numbers => :red_parenth}).style
+    end
 
+    should "generate complex style string" do
+      assert_equal("0.00_);\(0.00\)", Number.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).style)
+      assert_equal("#,##0.0000_);[Red]\(#,##0.0000\)", Number.new({
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).style)
+    end
 
+    should "provide unique format keys" do
+      assert_equal("number_none_2_nocomma_blackparenth", Number.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).key)
+      assert_equal("number_none_4_comma_redparenth", Number.new({
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).key)
     end
+
   end
 
 end

data/test/format/percentage_test.rb

@@ -1,116 +1,114 @@
-require "test/helper"
+require "assert"
 require 'osheet/format/percentage'
 
 module Osheet::Format
 
-  class PercentageTest < Test::Unit::TestCase
-    context "Percentage format" do
-      subject { Percentage.new }
+  class PercentageTest < Assert::Context
+    desc "Percentage format"
+    before { @p = Percentage.new }
+    subject { @p }
 
-      should_have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
+    should have_accessors :decimal_places, :symbol, :comma_separator, :negative_numbers
 
-      should "provide negative numbers options" do
-        assert_equal 4, Percentage.negative_numbers_set.size
-        [:black, :black_parenth, :red, :red_parenth].each do |a|
-          assert Percentage.negative_numbers_set.include?(a)
-        end
+    should "provide negative numbers options" do
+      assert_equal 4, Percentage.negative_numbers_set.size
+      [:black, :black_parenth, :red, :red_parenth].each do |a|
+        assert Percentage.negative_numbers_set.include?(a)
       end
+    end
 
-      should "set default values" do
-        assert_equal 2, subject.decimal_places
-        assert_equal false, subject.comma_separator
-        assert_equal :black, subject.negative_numbers
-      end
+    should "set default values" do
+      assert_equal 2, subject.decimal_places
+      assert_equal false, subject.comma_separator
+      assert_equal :black, subject.negative_numbers
+    end
 
-      should "only allow Fixnum decimal places between 0 and 30" do
-        assert_raises ArgumentError do
-          Percentage.new({:decimal_places => -1})
-        end
-        assert_raises ArgumentError do
-          Percentage.new({:decimal_places => 31})
-        end
-        assert_raises ArgumentError do
-          Percentage.new({:decimal_places => 'poo'})
-        end
-        assert_nothing_raised do
-          Percentage.new({:decimal_places => 1})
-        end
+    should "only allow Fixnum decimal places between 0 and 30" do
+      assert_raises ArgumentError do
+        Percentage.new({:decimal_places => -1})
       end
-
-      should "generate decimal place style strings" do
-        assert_equal "0%", Percentage.new({
-          :decimal_places => 0
-        }).style
-        (1..5).each do |n|
-          assert_equal "0.#{'0'*n}%", Percentage.new({
-            :decimal_places => n
-          }).style
-        end
+      assert_raises ArgumentError do
+        Percentage.new({:decimal_places => 31})
       end
-
-      should "generate comma separator style strings" do
-        assert_equal "0%", Percentage.new({
-          :comma_separator => false,
-          :decimal_places => 0
-        }).style
-        assert_equal "#,##0%", Percentage.new({
-          :comma_separator => true,
-          :decimal_places => 0
-        }).style
+      assert_raises ArgumentError do
+        Percentage.new({:decimal_places => 'poo'})
       end
-
-      should "generate parenth negative numbers style strings" do
-        assert_equal "0%", Percentage.new({
-          :negative_numbers => :black,
-          :decimal_places => 0
-        }).style
-        assert_equal "0%_);\(0%\)", Percentage.new({
-          :negative_numbers => :black_parenth,
-          :decimal_places => 0
-        }).style
+      assert_nothing_raised do
+        Percentage.new({:decimal_places => 1})
       end
+    end
 
-      should "generate red negative numbers style strings" do
-        assert_equal "0%;[Red]0%", Percentage.new({
-          :negative_numbers => :red,
-          :decimal_places => 0
-        }).style
-        assert_equal "0%_);[Red]\(0%\)", Percentage.new({
-          :negative_numbers => :red_parenth,
-          :decimal_places => 0
+    should "generate decimal place style strings" do
+      assert_equal "0%", Percentage.new({
+        :decimal_places => 0
+      }).style
+      (1..5).each do |n|
+        assert_equal "0.#{'0'*n}%", Percentage.new({
+          :decimal_places => n
         }).style
       end
+    end
 
-      should "generate complex style string" do
-        assert_equal("0.00%_);\(0.00%\)", Percentage.new({
-          :decimal_places => 2,
-          :negative_numbers => :black_parenth,
-          :comma_separator => false
-        }).style)
-        assert_equal("#,##0.0000%_);[Red]\(#,##0.0000%\)", Percentage.new({
-          :decimal_places => 4,
-          :negative_numbers => :red_parenth,
-          :comma_separator => true
-        }).style)
-      end
+    should "generate comma separator style strings" do
+      assert_equal "0%", Percentage.new({
+        :comma_separator => false,
+        :decimal_places => 0
+      }).style
+      assert_equal "#,##0%", Percentage.new({
+        :comma_separator => true,
+        :decimal_places => 0
+      }).style
+    end
 
-      should "provide unique format keys" do
-        assert_equal("percentage_none_2_nocomma_blackparenth", Percentage.new({
-          :decimal_places => 2,
-          :negative_numbers => :black_parenth,
-          :comma_separator => false
-        }).key)
-        assert_equal("percentage_none_4_comma_redparenth", Percentage.new({
-          :symbol => :none,
-          :decimal_places => 4,
-          :negative_numbers => :red_parenth,
-          :comma_separator => true
-        }).key)
-      end
+    should "generate parenth negative numbers style strings" do
+      assert_equal "0%", Percentage.new({
+        :negative_numbers => :black,
+        :decimal_places => 0
+      }).style
+      assert_equal "0%_);\(0%\)", Percentage.new({
+        :negative_numbers => :black_parenth,
+        :decimal_places => 0
+      }).style
+    end
 
+    should "generate red negative numbers style strings" do
+      assert_equal "0%;[Red]0%", Percentage.new({
+        :negative_numbers => :red,
+        :decimal_places => 0
+      }).style
+      assert_equal "0%_);[Red]\(0%\)", Percentage.new({
+        :negative_numbers => :red_parenth,
+        :decimal_places => 0
+      }).style
+    end
 
+    should "generate complex style string" do
+      assert_equal("0.00%_);\(0.00%\)", Percentage.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).style)
+      assert_equal("#,##0.0000%_);[Red]\(#,##0.0000%\)", Percentage.new({
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).style)
+    end
 
+    should "provide unique format keys" do
+      assert_equal("percentage_none_2_nocomma_blackparenth", Percentage.new({
+        :decimal_places => 2,
+        :negative_numbers => :black_parenth,
+        :comma_separator => false
+      }).key)
+      assert_equal("percentage_none_4_comma_redparenth", Percentage.new({
+        :symbol => :none,
+        :decimal_places => 4,
+        :negative_numbers => :red_parenth,
+        :comma_separator => true
+      }).key)
     end
+
   end
 
 end