testing 7.3.2.2 Bitwise logical operators

( WE TRUST 1S, INVERT, AND BITSSET?; WE WILL CONFIRM RSHIFT LATER )
1S 1 RSHIFT INVERT CONSTANT MSB
T{ MSB BITSSET? -> 0 0 }T

T{ 1 0 LSHIFT -> 1 }T
T{ 1 1 LSHIFT -> 2 }T
T{ 1 2 LSHIFT -> 4 }T
T{ 1 F LSHIFT -> 8000 }T         \ BIGGEST GUARANTEED SHIFT
T{ 1S 1 LSHIFT 1 XOR -> 1S }T
T{ MSB 1 LSHIFT -> 0 }T

T{ 1 0 RSHIFT -> 1 }T
T{ 1 1 RSHIFT -> 0 }T
T{ 2 1 RSHIFT -> 1 }T
T{ 4 2 RSHIFT -> 1 }T
T{ 8000 F RSHIFT -> 1 }T         \ BIGGEST
T{ MSB 1 RSHIFT MSB AND -> 0 }T      \ RSHIFT ZERO FILLS MSBS
T{ MSB 1 RSHIFT 2* -> MSB }T

t{ 1 1 >>a -> 0 }t
t{ 0 1 >>a -> 0 }t
t{ 0 invert 1 >> 1 >>a 0< -> false }t
t{ -1 1 >>a -> -1 }t
t{ -1 2 >>a -> -1 }t
t{ -1 4 >>a -> -1 }t
t{ -2 1 >>a -> -1 }t
t{ -4 1 >>a -> -2 }t

\ << >> are synonyms for lshift and rshift, do abbreviated test
T{ 1 0 << -> 1 }T
T{ 1 1 << -> 2 }T
T{ 1 2 << -> 4 }T

T{ 1 0 >> -> 1 }T
T{ 1 1 >> -> 0 }T
T{ 2 1 >> -> 1 }T
T{ 4 2 >> -> 1 }T

T{ 0S 2* -> 0S }T
T{ 1 2* -> 2 }T
T{ 4000 2* -> 8000 }T
T{ 1S 2* 1 XOR -> 1S }T
T{ MSB 2* -> 0S }T

T{ 0S 2/ -> 0S }T
T{ 1 2/ -> 0 }T
T{ 4000 2/ -> 2000 }T
T{ 1S 2/ -> 1S }T            \ MSB PROPOGATED
T{ 1S 1 XOR 2/ -> 1S }T
T{ MSB 2/ MSB AND -> MSB }T

t{ 0 invert u2/ 0< -> false }t
t{ 0 invert u2/ u2/ -> 0 invert 2 >> }t

T{ 0 0 AND -> 0 }T
T{ 0 1 AND -> 0 }T
T{ 1 0 AND -> 0 }T
T{ 1 1 AND -> 1 }T

T{ 0 INVERT 1 AND -> 1 }T
T{ 1 INVERT 1 AND -> 0 }T

T{ 0S 0S AND -> 0S }T
T{ 0S 1S AND -> 0S }T
T{ 1S 0S AND -> 0S }T
T{ 1S 1S AND -> 1S }T

T{ 0S 0S OR -> 0S }T
T{ 0S 1S OR -> 1S }T
T{ 1S 0S OR -> 1S }T
T{ 1S 1S OR -> 1S }T

T{ 0S 0S XOR -> 0S }T
T{ 0S 1S XOR -> 1S }T
T{ 1S 0S XOR -> 1S }T
T{ 1S 1S XOR -> 0S }T

T{ 0S INVERT -> 1S }T
T{ 1S INVERT -> 0S }T

t{ 0S not -> 1S }t
t{ 1S not -> 0S }t