rewrite of FASTQ internals

[biopieces.git] / code_ruby / test / maasha / test_bitarray.rb

diff --git a/code_ruby/test/maasha/test_bitarray.rb b/code_ruby/test/maasha/test_bitarray.rb
index b1fcaa0d17a16435b5b5b4b4bfc81c6cb5fae3d1..e19e2d4acad158fac3fd905ce915843984f5023a 100755 (executable)
--- a/code_ruby/test/maasha/test_bitarray.rb
+++ b/code_ruby/test/maasha/test_bitarray.rb
@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__), '..', '..')
 
-# Copyright (C) 2007-2010 Martin A. Hansen.
+# Copyright (C) 2007-2013 Martin A. Hansen.
 
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU General Public License
@@ -28,48 +28,48 @@ $:.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'maasha/bitarray'
 require 'test/unit'
-require 'pp'
+require 'test/helper'
 
 class TestBitArray < Test::Unit::TestCase 
   def setup
     @ba = BitArray.new(10)
   end
 
-  def test_BitArray_initialize_raises_on_bad_sizes
+  test "BitArray.new raises on bad sizes" do
     [ -1, 0, 1.1, "a" ].each do |size|
       assert_raise(BitArrayError) { BitArray.new(size) }
     end
   end
 
-  def test_BitArray_initialize_dont_raise_on_ok_sizes
+  test "BitArray.new dont raise on ok sizes" do
     [ 1, 10, 1000 ].each do |size|
       assert_nothing_raised { BitArray.new(size) }
     end
   end
 
-  def test_BitArray_size_returns_correctly
+  test "#size returns correctly" do
     assert_equal(10, @ba.size)
   end
 
-  def test_BitArray_to_s_returns_correctly
+  test "#to_s returns correctly" do
     assert_equal("0000000000", @ba.to_s)
   end
 
-  def test_BitArray_fill_returns_correctly
+  test "#fill returns correctly" do
     assert_equal("1111111111", @ba.fill!.to_s)
   end
 
-  def test_BitArray_clear_returns_correctly
+  test "#clear returns correctly" do
     assert_equal("0000000000", @ba.fill!.clear!.to_s)
   end
 
-  def test_BitArray_bit_set_with_bad_pos_raises
+  test "#bit_set with bad pos raises" do
     [-1, 10, 1.1].each do |pos|
       assert_raise(BitArrayError) { @ba.bit_set(pos) }
     end
   end
 
-  def test_BitArray_bit_unset
+  test "#bit_unset" do
     @ba.fill!
 
     str = "1111111111"
@@ -81,43 +81,43 @@ class TestBitArray < Test::Unit::TestCase
     end
   end
 
-  def test_BitArray_bit_unset_with_bad_pos_raises
+  test "#bit_unset with bad pos raises" do
     [-1, 10, 1.1].each do |pos|
       assert_raise(BitArrayError) { @ba.bit_unset(pos) }
     end
   end
 
-  def test_BitArray_bit_set_questionmark_with_bad_pos_raises
+  test "#bit_set? with bad pos raises" do
     [-1, 10, 1.1].each do |pos|
       assert_raise(BitArrayError) { @ba.bit_set?(pos) }
     end
   end
 
-  def test_BitArray_bit_set_questionmark
+  test "#bit_set? returns correctly" do
     (0.upto 9).each do |pos|
       @ba.bit_set(pos)
       assert_equal(true, @ba.bit_set?(pos))
     end
   end
 
-  def test_BitArray_bits_on_returns_correctly
+  test "#bits_on returns correctly" do
     @ba.bit_set(4)
     @ba.bit_set(0)
     @ba.bit_set(1)
     assert_equal(3, @ba.bits_on)
   end
 
-  def test_BitArray_bits_off_returns_correctly
+  test "#bits_off returns correctly" do
     @ba.bit_set(4)
     assert_equal(9, @ba.bits_off)
   end
 
-  def test_BitArray_AND_with_uneven_sizes_raises
+  test "#& with uneven sizes raises" do
     ba = BitArray.new(11)
     assert_raise(BitArrayError) { @ba & ba }
   end
 
-  def test_BitArray_AND_returns_correctly
+  test "#& returns correctly" do
     ba = BitArray.new(10)
     @ba.bit_set(4)
     @ba.bit_set(5)
@@ -126,12 +126,12 @@ class TestBitArray < Test::Unit::TestCase
     assert_equal("0000010000", (@ba & ba).to_s)
   end
 
-  def test_BitArray_OR_with_uneven_sizes_raises
+  test "#| with uneven sizes raises" do
     ba = BitArray.new(11)
     assert_raise(BitArrayError) { @ba | ba }
   end
 
-  def test_BitArray_OR_returns_correctly
+  test "#| returns correctly" do
     ba = BitArray.new(10)
     @ba.bit_set(4)
     @ba.bit_set(5)
@@ -140,12 +140,12 @@ class TestBitArray < Test::Unit::TestCase
     assert_equal("0000111000", (@ba | ba).to_s)
   end
 
-  def test_BitArray_XOR_with_uneven_sizes_raises
+  test "#^ with uneven sizes raises" do
     ba = BitArray.new(11)
     assert_raise(BitArrayError) { @ba ^ ba }
   end
 
-  def test_BitArray_XOR_returns_correctly
+  test "#^ returns correctly" do
     ba = BitArray.new(10)
     @ba.bit_set(4)
     @ba.bit_set(5)
@@ -154,20 +154,20 @@ class TestBitArray < Test::Unit::TestCase
     assert_equal("0000101000", (@ba ^ ba).to_s)
   end
 
-  def test_BitArray_FLIP_returns_correctly
+  test "#~ returns correctly" do
     @ba.bit_set(0)
     @ba.bit_set(9)
 
     assert_equal("0111111110", (~@ba).to_s)
   end
 
-  def test_interval_set_with_bad_interval_raises
+  test "#interval_set with bad interval raises" do
     assert_raise(BitArrayError) { @ba.interval_set(-1, 4) }
     assert_raise(BitArrayError) { @ba.interval_set(1, 10) }
     assert_raise(BitArrayError) { @ba.interval_set(4, 2) }
   end
 
-  def test_interval_set_returns_correctly
+  test "#interval_set returns correctly" do
     @ba.interval_set(0, 0)
     assert_equal("1000000000", @ba.to_s)
     @ba.interval_set(9, 9)
@@ -178,13 +178,13 @@ class TestBitArray < Test::Unit::TestCase
     assert_equal("1111111111", @ba.to_s)
   end
 
-  def test_interval_unset_with_bad_interval_raises
+  test "#interval_unset with bad interval raises" do
     assert_raise(BitArrayError) { @ba.interval_unset(-1, 4) }
     assert_raise(BitArrayError) { @ba.interval_unset(1, 10) }
     assert_raise(BitArrayError) { @ba.interval_unset(4, 2) }
   end
 
-  def test_interval_unset_returns_correctly
+  test "#interval_unset returns correctly" do
     ~@ba
 
     @ba.interval_unset(0, 0)
@@ -197,7 +197,7 @@ class TestBitArray < Test::Unit::TestCase
     assert_equal("0000000000", @ba.to_s)
   end
 
-  def test_each_interval_returns_correctly
+  test "#each_interval returns correctly" do
     @ba.fill!
     @ba.bit_unset(4)