*** Test operation 'set_bit' ***

set_bit(00000000, 0) = 00000001
set_bit(00000000, 1) = 00000010
set_bit(00000000, 2) = 00000100
set_bit(00000000, 3) = 00001000
set_bit(00000000, 4) = 00010000
set_bit(00000000, 5) = 00100000
set_bit(00000000, 6) = 01000000
set_bit(00000000, 7) = 10000000
set_bit(00000000, 8) = <<exception>>
set_bit(11111111, 0) = 11111111
set_bit(11111111, 1) = 11111111
set_bit(11111111, 2) = 11111111
set_bit(11111111, 3) = 11111111
set_bit(11111111, 4) = 11111111
set_bit(11111111, 5) = 11111111
set_bit(11111111, 6) = 11111111
set_bit(11111111, 7) = 11111111
set_bit(11111111, 8) = <<exception>>

*** Test operation 'clear_bit' ***

clear_bit(00000000, 0) = 00000000
clear_bit(00000000, 1) = 00000000
clear_bit(00000000, 2) = 00000000
clear_bit(00000000, 3) = 00000000
clear_bit(00000000, 4) = 00000000
clear_bit(00000000, 5) = 00000000
clear_bit(00000000, 6) = 00000000
clear_bit(00000000, 7) = 00000000
clear_bit(00000000, 8) = <<exception>>
clear_bit(11111111, 0) = 11111110
clear_bit(11111111, 1) = 11111101
clear_bit(11111111, 2) = 11111011
clear_bit(11111111, 3) = 11110111
clear_bit(11111111, 4) = 11101111
clear_bit(11111111, 5) = 11011111
clear_bit(11111111, 6) = 10111111
clear_bit(11111111, 7) = 01111111
clear_bit(11111111, 8) = <<exception>>

*** Test operation 'flip_bit' ***

flip_bit(00000000, 0) = 00000001
flip_bit(00000000, 1) = 00000010
flip_bit(00000000, 2) = 00000100
flip_bit(00000000, 3) = 00001000
flip_bit(00000000, 4) = 00010000
flip_bit(00000000, 5) = 00100000
flip_bit(00000000, 6) = 01000000
flip_bit(00000000, 7) = 10000000
flip_bit(00000000, 8) = <<exception>>
flip_bit(11111111, 0) = 11111110
flip_bit(11111111, 1) = 11111101
flip_bit(11111111, 2) = 11111011
flip_bit(11111111, 3) = 11110111
flip_bit(11111111, 4) = 11101111
flip_bit(11111111, 5) = 11011111
flip_bit(11111111, 6) = 10111111
flip_bit(11111111, 7) = 01111111
flip_bit(11111111, 8) = <<exception>>

*** Test operation 'bit_is_set' ***

bit_is_set(00000000, 0) ==> false
bit_is_set(00000000, 1) ==> false
bit_is_set(00000000, 2) ==> false
bit_is_set(00000000, 3) ==> false
bit_is_set(00000000, 4) ==> false
bit_is_set(00000000, 5) ==> false
bit_is_set(00000000, 6) ==> false
bit_is_set(00000000, 7) ==> false
bit_is_set(00000000, 8) ==> <<exception>>
bit_is_set(00000001, 0) ==> true
bit_is_set(00000001, 1) ==> false
bit_is_set(00000001, 2) ==> false
bit_is_set(00000001, 3) ==> false
bit_is_set(00000001, 4) ==> false
bit_is_set(00000001, 5) ==> false
bit_is_set(00000001, 6) ==> false
bit_is_set(00000001, 7) ==> false
bit_is_set(00000001, 8) ==> <<exception>>
bit_is_set(00000010, 0) ==> false
bit_is_set(00000010, 1) ==> true
bit_is_set(00000010, 2) ==> false
bit_is_set(00000010, 3) ==> false
bit_is_set(00000010, 4) ==> false
bit_is_set(00000010, 5) ==> false
bit_is_set(00000010, 6) ==> false
bit_is_set(00000010, 7) ==> false
bit_is_set(00000010, 8) ==> <<exception>>
bit_is_set(00001000, 0) ==> false
bit_is_set(00001000, 1) ==> false
bit_is_set(00001000, 2) ==> false
bit_is_set(00001000, 3) ==> true
bit_is_set(00001000, 4) ==> false
bit_is_set(00001000, 5) ==> false
bit_is_set(00001000, 6) ==> false
bit_is_set(00001000, 7) ==> false
bit_is_set(00001000, 8) ==> <<exception>>
bit_is_set(01111111, 0) ==> true
bit_is_set(01111111, 1) ==> true
bit_is_set(01111111, 2) ==> true
bit_is_set(01111111, 3) ==> true
bit_is_set(01111111, 4) ==> true
bit_is_set(01111111, 5) ==> true
bit_is_set(01111111, 6) ==> true
bit_is_set(01111111, 7) ==> false
bit_is_set(01111111, 8) ==> <<exception>>
bit_is_set(11111111, 0) ==> true
bit_is_set(11111111, 1) ==> true
bit_is_set(11111111, 2) ==> true
bit_is_set(11111111, 3) ==> true
bit_is_set(11111111, 4) ==> true
bit_is_set(11111111, 5) ==> true
bit_is_set(11111111, 6) ==> true
bit_is_set(11111111, 7) ==> true
bit_is_set(11111111, 8) ==> <<exception>>

*** Test operation 'bit_is_clear' ***

bit_is_clear(00000000, 0) ==> true
bit_is_clear(00000000, 1) ==> true
bit_is_clear(00000000, 2) ==> true
bit_is_clear(00000000, 3) ==> true
bit_is_clear(00000000, 4) ==> true
bit_is_clear(00000000, 5) ==> true
bit_is_clear(00000000, 6) ==> true
bit_is_clear(00000000, 7) ==> true
bit_is_clear(00000000, 8) ==> <<exception>>
bit_is_clear(00000001, 0) ==> false
bit_is_clear(00000001, 1) ==> true
bit_is_clear(00000001, 2) ==> true
bit_is_clear(00000001, 3) ==> true
bit_is_clear(00000001, 4) ==> true
bit_is_clear(00000001, 5) ==> true
bit_is_clear(00000001, 6) ==> true
bit_is_clear(00000001, 7) ==> true
bit_is_clear(00000001, 8) ==> <<exception>>
bit_is_clear(00000010, 0) ==> true
bit_is_clear(00000010, 1) ==> false
bit_is_clear(00000010, 2) ==> true
bit_is_clear(00000010, 3) ==> true
bit_is_clear(00000010, 4) ==> true
bit_is_clear(00000010, 5) ==> true
bit_is_clear(00000010, 6) ==> true
bit_is_clear(00000010, 7) ==> true
bit_is_clear(00000010, 8) ==> <<exception>>
bit_is_clear(00001000, 0) ==> true
bit_is_clear(00001000, 1) ==> true
bit_is_clear(00001000, 2) ==> true
bit_is_clear(00001000, 3) ==> false
bit_is_clear(00001000, 4) ==> true
bit_is_clear(00001000, 5) ==> true
bit_is_clear(00001000, 6) ==> true
bit_is_clear(00001000, 7) ==> true
bit_is_clear(00001000, 8) ==> <<exception>>
bit_is_clear(01111111, 0) ==> false
bit_is_clear(01111111, 1) ==> false
bit_is_clear(01111111, 2) ==> false
bit_is_clear(01111111, 3) ==> false
bit_is_clear(01111111, 4) ==> false
bit_is_clear(01111111, 5) ==> false
bit_is_clear(01111111, 6) ==> false
bit_is_clear(01111111, 7) ==> true
bit_is_clear(01111111, 8) ==> <<exception>>
bit_is_clear(11111111, 0) ==> false
bit_is_clear(11111111, 1) ==> false
bit_is_clear(11111111, 2) ==> false
bit_is_clear(11111111, 3) ==> false
bit_is_clear(11111111, 4) ==> false
bit_is_clear(11111111, 5) ==> false
bit_is_clear(11111111, 6) ==> false
bit_is_clear(11111111, 7) ==> false
bit_is_clear(11111111, 8) ==> <<exception>>