#!/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
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"
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)
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)
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)
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, 14) }
+ assert_raise(BitArrayError) { @ba.interval_set(1, 10) }
assert_raise(BitArrayError) { @ba.interval_set(4, 2) }
end
- def test_interval_set_returns_correctly
- @ba.interval_set(1, 9)
-
- assert_equal("0111111110", @ba.to_s)
+ test "#interval_set returns correctly" do
+ @ba.interval_set(0, 0)
+ assert_equal("1000000000", @ba.to_s)
+ @ba.interval_set(9, 9)
+ assert_equal("1000000001", @ba.to_s)
+ @ba.interval_set(2, 7)
+ assert_equal("1011111101", @ba.to_s)
+ @ba.interval_set(1, 8)
+ 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, 14) }
+ 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(1, 9)
- assert_equal("1000000001", @ba.to_s)
+ @ba.interval_unset(0, 0)
+ assert_equal("0111111111", @ba.to_s)
+ @ba.interval_unset(9, 9)
+ assert_equal("0111111110", @ba.to_s)
+ @ba.interval_unset(2, 7)
+ assert_equal("0100000010", @ba.to_s)
+ @ba.interval_unset(1, 8)
+ 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)
- assert_equal([[0, 4], [5, 10]], @ba.each_interval.to_a)
+ assert_equal([[0, 3], [5, 9]], @ba.each_interval.to_a)
end
end