#!/usr/local/bin/ruby
$:.unshift '.'
require 'test/unit'
require 'test/unit/ui/console/testrunner'
require 'bitset'
class TC_BitSet < Test::Unit::TestCase
# BitSet.new
def test_s_new_nil
a = BitSet.new
assert_equal(1, a.size)
assert_equal("0", a.to_s)
end
def test_s_new_fixnum
assert_raises(ArgumentError) {
a = BitSet.new(0)
}
assert_raises(ArgumentError) {
a = BitSet.new(-1)
}
[1,7,8,15,16,255,256,65535,65536].each {|n|
a = BitSet.new(n)
assert_equal(n, a.size)
assert_equal("0" * n, a.to_s)
}
end
def test_s_new_string
a = BitSet.new("a")
assert_equal(8, a.size)
assert_equal("10000110", a.to_s)
a = BitSet.new("ab")
assert_equal(16, a.size)
assert_equal("1000011001000110", a.to_s)
# a\0b
a = BitSet.new("a\0b")
assert_equal(24, a.size)
assert_equal("100001100000000001000110", a.to_s)
end
def test_s_new_other
assert_raises(ArgumentError) {
a = BitSet.new({})
}
assert_raises(ArgumentError) {
a = BitSet.new(:symbol)
}
assert_raises(ArgumentError) {
a = BitSet.new(1.0)
}
end
def test_s_new_GC
ary = Array.new(10)
assert_nothing_raised {
200.times do
idx = rand(10)
size = rand(1000000) + 1
bits = BitSet.new(size)
ary[idx] = bits
end
}
end
# BitSet.from_bin
def test_s_from_bin
a = BitSet.from_bin("00000")
assert_equal(5, a.size)
assert_equal("00000", a.to_s)
a = BitSet.from_bin("0000011111")
assert_equal(10, a.size)
assert_equal("0000011111", a.to_s)
end
# BitSet#to_s
def test_to_s
(0..255).each {|i|
a = BitSet.new(i.chr)
bit = ("%08b" % i).reverse
assert_equal(bit, a.to_s)
}
end
# BitSet#size
def test_size_getter
[1,7,8,15,16,255,256,65535,65536].each {|n|
a = BitSet.new(n)
assert_equal(a.size, n)
}
end
# BitSet#size=
def test_size_setter
a = BitSet.new()
[1,7,8,15,16,255,256,65535,65536].each {|n|
a.size = n
assert_equal(n, a.size)
}
assert_raises(ArgumentError) {
a.size = 0
}
assert_raises(ArgumentError) {
a.size = -1
}
end
# BitSet#length
def test_length
[1,7,8,15,16,255,256,65535,65536].each {|n|
a = BitSet.new(n)
assert_equal(a.length, n)
}
end
# BitSet#bytes
def test_bytes
[1,7,8,15,16,255,256,65535,65536].each {|n|
a = BitSet.new(n)
bytes = (n + 7) / 8;
assert_equal(a.bytes, bytes)
}
end
# BitSet#dup
def test_dup
a = BitSet.from_bin("0")
b = a.dup
assert_equal("0", b.to_s)
a = BitSet.from_bin("10101010101010101")
b = a.dup
assert_equal("10101010101010101", b.to_s)
end
# BitSet#clone
def test_clone
a = BitSet.from_bin("0")
b = a.clone
assert_equal("0", b.to_s)
a = BitSet.from_bin("10101010101010101")
b = a.clone
assert_equal("10101010101010101", b.to_s)
end
# BitSet#get
def test_get
a = BitSet.from_bin("1")
assert_equal(1, a.get(0))
assert_equal(0, a.get(1))
assert_equal(0, a.get(100))
a = BitSet.from_bin("10"*50)
assert_equal(1, a.get(98))
assert_equal(0, a.get(99))
end
# BitSet#set
def test_set
a = BitSet.new
a.set 1,1
assert_equal("01", a.to_s)
a.set 5,1
assert_equal("010001", a.to_s)
a.set 6,1
assert_equal("0100011", a.to_s)
a.set 5,0
assert_equal("0100001", a.to_s)
end
# BitSet#on
def test_on
a = BitSet.new
a.on 3
assert_equal("0001", a.to_s)
a.on 9
assert_equal("0001000001", a.to_s)
end
# BitSet#on range
def test_on_range
a = BitSet.new
a.on 1..3
assert_equal("0111", a.to_s)
a.on 6..10
assert_equal("01110011111", a.to_s)
end
# BitSet#off
def test_off
a = BitSet.from_bin("11111111111111111111")
a.off 5
assert_equal("11111011111111111111", a.to_s)
a.off 9
assert_equal("11111011101111111111", a.to_s)
end
# BitSet#off
def test_off_range
a = BitSet.from_bin("11111111111111111111")
a.off 2..4
assert_equal("11000111111111111111", a.to_s)
a.off 6..10
assert_equal("11000100000111111111", a.to_s)
end
# BitSet#clear
def test_clear
a = BitSet.from_bin("0")
a.clear
assert_equal(1, a.size)
assert_equal("0", a.to_s)
a = BitSet.from_bin("1111")
a.clear
assert_equal(4, a.size)
assert_equal("0000", a.to_s)
a = BitSet.from_bin("111100001111000011")
a.clear
assert_equal(18, a.size)
assert_equal("000000000000000000", a.to_s)
end
# BitSet#|
def test_or
a = BitSet.from_bin("000000")
b = BitSet.from_bin("111000")
x = a | b
assert_equal("000000", a.to_s)
assert_equal("111000", b.to_s)
assert_equal("111000", x.to_s)
a = BitSet.from_bin("0101010101")
b = BitSet.from_bin("1111100000")
x = a | b
assert_equal("0101010101", a.to_s)
assert_equal("1111100000", b.to_s)
assert_equal("1111110101", x.to_s)
a = BitSet.from_bin("00000000000001")
b = BitSet.from_bin("00000000000010")
x = a | b
assert_equal("00000000000011", x.to_s)
a = BitSet.from_bin("1")
b = BitSet.from_bin("000000001")
x = a | b
assert_equal("100000001", x.to_s)
a = BitSet.from_bin("000000001")
b = BitSet.from_bin("1")
x = a | b
assert_equal("100000001", x.to_s)
end
# BitSet#+
def test_plus
a = BitSet.from_bin("000000")
b = BitSet.from_bin("111000")
x = a + b
assert_equal("000000", a.to_s)
assert_equal("111000", b.to_s)
assert_equal("111000", x.to_s)
a = BitSet.from_bin("0101010101")
b = BitSet.from_bin("1111100000")
x = a + b
assert_equal("0101010101", a.to_s)
assert_equal("1111100000", b.to_s)
assert_equal("1111110101", x.to_s)
a = BitSet.from_bin("00000000000001")
b = BitSet.from_bin("00000000000010")
x = a + b
assert_equal("00000000000011", x.to_s)
a = BitSet.from_bin("1")
b = BitSet.from_bin("000000001")
x = a + b
assert_equal("100000001", x.to_s)
a = BitSet.from_bin("000000001")
b = BitSet.from_bin("1")
x = a + b
assert_equal("100000001", x.to_s)
end
# BitSet#-
def test_minus
a = BitSet.from_bin("01010101")
b = BitSet.from_bin("00001111")
x = a - b
assert_equal("01010101", a.to_s)
assert_equal("00001111", b.to_s)
assert_equal("01010000", x.to_s)
a = BitSet.from_bin("111111111111111111111111")
b = BitSet.from_bin("111111111")
x = a - b
assert_equal("000000000111111111111111", x.to_s)
x = b - a
assert_equal("000000000", x.to_s)
end
# BitSet#<=>
def test_cmp
a = BitSet.from_bin("0")
b = BitSet.from_bin("1")
assert_equal(-1, a <=> b)
assert_equal(0, a <=> a)
assert_equal(1, b <=> a)
a = BitSet.from_bin("1000000000")
b = BitSet.from_bin("1")
assert_equal(0, a <=> b)
end
# BitSet#&
def test_and
a = BitSet.from_bin("010111")
b = BitSet.from_bin("001110")
x = a & b
assert_equal("010111", a.to_s)
assert_equal("001110", b.to_s)
assert_equal("000110", x.to_s)
a = BitSet.from_bin("01010101")
b = BitSet.from_bin("00001111")
x = a & b
assert_equal("01010101", a.to_s)
assert_equal("00001111", b.to_s)
assert_equal("00000101", x.to_s)
a = BitSet.from_bin("0")
b = BitSet.from_bin("1111111111")
x = a & b
assert_equal("0", x.to_s)
x = b & a
assert_equal("0000000000", x.to_s)
a = BitSet.from_bin("11111111")
b = BitSet.from_bin("1111111111111111")
x = a & b
assert_equal("11111111", x.to_s)
x = b & a
assert_equal("1111111100000000", x.to_s)
a = BitSet.from_bin("11001100")
b = BitSet.from_bin("1110111011101110")
x = a & b
assert_equal("11001100", x.to_s)
x = b & a
assert_equal("1100110000000000", x.to_s)
end
# BitSet#^
def test_xor
a = BitSet.from_bin("01010101")
b = BitSet.from_bin("00110011")
x = a ^ b
assert_equal("01010101", a.to_s)
assert_equal("00110011", b.to_s)
assert_equal("01100110", x.to_s)
a = BitSet.from_bin("0")
b = BitSet.from_bin("10101010101010")
x = a ^ b
assert_equal("10101010101010", x.to_s)
x = b ^ a
assert_equal("10101010101010", x.to_s)
end
# BitSet#*
def test_multi
a = BitSet.from_bin("010111")
b = BitSet.from_bin("001110")
x = a * b
assert_equal("010111", a.to_s)
assert_equal("001110", b.to_s)
assert_equal("000110", x.to_s)
a = BitSet.from_bin("01010101")
b = BitSet.from_bin("00001111")
x = a * b
assert_equal("01010101", a.to_s)
assert_equal("00001111", b.to_s)
assert_equal("00000101", x.to_s)
a = BitSet.from_bin("0")
b = BitSet.from_bin("1111111111")
x = a * b
assert_equal("0", x.to_s)
x = b * a
assert_equal("0000000000", x.to_s)
a = BitSet.from_bin("11111111")
b = BitSet.from_bin("1111111111111111")
x = a * b
assert_equal("11111111", x.to_s)
x = b * a
assert_equal("1111111100000000", x.to_s)
a = BitSet.from_bin("11001100")
b = BitSet.from_bin("1110111011101110")
x = a * b
assert_equal("11001100", x.to_s)
x = b * a
assert_equal("1100110000000000", x.to_s)
end
# BitSet#~
def test_not
a = BitSet.from_bin("0")
x = ~a
assert_equal("0", a.to_s)
assert_equal("1", x.to_s)
a = BitSet.from_bin("0101")
x = ~a
assert_equal("1010", x.to_s)
a = BitSet.from_bin("00000000001111111111")
x = ~a
assert_equal("11111111110000000000", x.to_s)
end
# BitSet#zero?
def test_zero?
a = BitSet.from_bin("0")
assert_equal(true, a.zero?)
a = BitSet.from_bin("0"*100)
assert_equal(true, a.zero?)
a = BitSet.from_bin("1")
assert_equal(false, a.zero?)
a = BitSet.from_bin("0"*100 + "1")
assert_equal(false, a.zero?)
end
# BitSet#nonzero?
def test_nonzero?
a = BitSet.from_bin("0")
assert_equal(false, a.nonzero?)
a = BitSet.from_bin("0"*100)
assert_equal(false, a.nonzero?)
a = BitSet.from_bin("1")
assert_equal(true, a.nonzero?)
a = BitSet.from_bin("0"*100 + "1")
assert_equal(true, a.nonzero?)
end
# BitSet#max
def test_max
a = BitSet.from_bin("0")
assert_equal(nil, a.max)
a = BitSet.from_bin("1")
assert_equal(0, a.max)
a = BitSet.from_bin("11")
assert_equal(1, a.max)
a = BitSet.from_bin("10000000001")
assert_equal(10, a.max)
end
# BitSet#min
def test_min
a = BitSet.from_bin("0")
assert_equal(nil, a.min)
a = BitSet.from_bin("1")
assert_equal(0, a.min)
a = BitSet.from_bin("11")
assert_equal(0, a.min)
a = BitSet.from_bin("0000100001")
assert_equal(4, a.min)
end
# BitSet#normalize
def test_normalize
a = BitSet.from_bin("0")
x = a.normalize
assert_equal("0", x.to_s)
a = BitSet.from_bin("00000")
x = a.normalize
assert_equal("0", x.to_s)
a = BitSet.from_bin("0101010101010000000")
x = a.normalize
assert_equal("010101010101", x.to_s)
assert_equal("0101010101010000000", a.to_s)
end
# BitSet#normalize!
def test_normalize!
a = BitSet.from_bin("0")
x = a.normalize!
assert_equal("0", a.to_s)
assert_equal("0", x.to_s)
a = BitSet.from_bin("00000")
x = a.normalize!
assert_equal("0", a.to_s)
assert_equal("0", x.to_s)
a = BitSet.from_bin("0101010101010000000")
x = a.normalize!
assert_equal("010101010101", x.to_s)
assert_equal("010101010101", a.to_s)
end
# BitSet#to_ary
def test_to_ary
a = BitSet.from_bin("00000")
assert_equal([], a.to_ary)
a = BitSet.from_bin("01010")
assert_equal([1,3], a.to_ary)
a = BitSet.from_bin("1100110101")
assert_equal([0..1, 4..5, 7, 9], a.to_ary)
a = BitSet.from_bin("00111111111111011111111111100000000001111111111")
assert_equal([2..13, 15..26, 37..46], a.to_ary)
end
# BitSet#each
def test_each
a = BitSet.from_bin("010101011")
ary = []
a.each {|idx|
ary << idx
}
assert_equal([1, 3, 5, 7, 8], ary)
end
# BitSet#to_bytes
def test_to_bytes
a = BitSet.new("abc")
assert_equal("abc", a.to_bytes)
a = BitSet.from_bin("00000000000000000")
assert_equal("\x00\x00\x00", a.to_bytes)
end
end
if $0==__FILE__
Test::Unit::UI::Console::TestRunner.run(TC_BitSet.suite)
end
syntax highlighted by Code2HTML, v. 0.9.1