home | career | drupal | java | mac | mysql | perl | scala | uml | unix

Groovy example source code file (BitwiseOperatorsTest.groovy)

This example Groovy source code file (BitwiseOperatorsTest.groovy) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Groovy tags/keywords

bitwiseoperatorstest, bitwiseoperatorstest, groovytestcase, groovytestcase, object, object

The Groovy BitwiseOperatorsTest.groovy source code

package groovy.operator

/** 
 * Test Bitwise Operations
 * 
 * @author Pilho Kim
 * @version $Revision: 4996 $
 */
class BitwiseOperatorsTest extends GroovyTestCase {

    void testBitwiseShift() {
        def a = 4
        def b = -4
        assert a << 1 == 8
        assert a << 2 == 16
        assert a >> 1 == 2
        assert a >> 2 == 1
        assert a >>> 1 == 2
        assert a >>> 2 == 1
        assert b << 1 == -8
        assert b << 2 == -16
        assert b >> 1 == -2
        assert b >> 2 == -1
        assert b >>> 1 == 0x7FFFFFFE
        assert b >>> 2 == 0x3FFFFFFF
    }

    void testBitwiseShiftEQUAL() {
        def a = 4
        a <<= 1
        assert a == 8
        a <<= 2
        assert a == 32
        a >>= 1
        assert a == 16
        a >>= 2
        assert a == 4

        def b = -4
        b <<= 1
        assert b == -8
        b <<= 2
        assert b == -32
        b >>= 1
        assert b == -16
        b >>= 2
        assert b == -4

        b = -4
        b >>>= 1
        assert b == 0x7FFFFFFE
        b = -8
        b >>>= 2
        assert b == 0x3FFFFFFE
    }

    void testBitwiseAnd() {

        def a = 13
        assert (a & 3) == 1 // 0x0000000D & 0x00000003
        assert (a & 7) == 5 // 0x0000000D & 0x00000007
        def b = -13
        assert (b & 3) == 3 // 0xFFFFFFF3 & 0x00000003
        assert (b & 7) == 3 // 0xFFFFFFF3 & 0x00000007
    }

    void testBitwiseAndOperatorPrecedence() {
        def a = 13
        assert (a & 3) == 1 // 0x0000000D & 0x00000003
        assert (a & 7) == 5 // 0x0000000D & 0x00000007
        def b = -13
        assert (b & 3) == 3 // 0xFFFFFFF3 & 0x00000003
        assert (b & 7) == 3 // 0xFFFFFFF3 & 0x00000007
    }

    void testBitwiseAndEqual() {
        def a = 13
        a &= 3
        assert a == 1 // 0x0000000D & 0x00000003
        a &= 4
        assert a == 0 // 0x00000001 & 0x00000004
        def b = -13
        b &= 3
        assert b == 3 // 0xFFFFFFF3 & 0x00000003
        b &= 7
        assert b == 3 // 0x00000003 & 0x00000007
    }

    void testBitwiseOr() {
        def a = 13
        assert (a | 8) == 13 // 0x0000000D | 0x00000008
        assert (a | 16) == 29 // 0x0000000D | 0x00000010
        def b = -13
        assert (b | 8) == -5 // 0xFFFFFFF3 | 0x00000008
        assert (b | 16) == -13 // 0xFFFFFFF3 | 0x00000010
    }

    void testBitwiseOrOperatorPrecedence() {
        def a = 13
        assert (a | 8) == 13 // 0x0000000D | 0x00000008
        assert (a | 16) == 29 // 0x0000000D | 0x00000010
        def b = -13
        assert (b | 8) == -5 // 0xFFFFFFF3 | 0x00000008
        assert (b | 16) == -13 // 0xFFFFFFF3 | 0x00000010
    }

    void testBitwiseOrEqual() {
        def a = 13
        a |= 2
        assert a == 15 // 0x0000000D | 0x00000002
        a |= 16
        assert a == 31 // 0x0000000F | 0x0000001F
        def b = -13
        b |= 8
        assert b == -5 // 0xFFFFFFF3 | 0x00000008
        b |= 1
        assert b == -5 // 0xFFFFFFFB | 0x00000001
    }

    void testBitwiseXor() {
        def a = 13
        assert (a ^ 10) == 7 // 0x0000000D ^ 0x0000000A = 0x000000007
        assert (a ^ 15) == 2 // 0x0000000D ^ 0x0000000F = 0x000000002
        def b = -13
        assert (b ^ 10) == -7 // 0xFFFFFFF3 ^ 0x0000000A = 0xFFFFFFF9
        assert (b ^ 15) == -4 // 0xFFFFFFF3 ^ 0x0000000F = 0xFFFFFFFC
    }

    void testBitwiseXorOperatorPrecedence() {
        def a = 13
        assert (a ^ 10) == 7 // 0x0000000D ^ 0x0000000A = 0x000000007
        assert (a ^ 15) == 2 // 0x0000000D ^ 0x0000000F = 0x000000002
        def b = -13
        assert (b ^ 10) == -7 // 0xFFFFFFF3 ^ 0x0000000A = 0xFFFFFFF9
        assert (b ^ 15) == -4 // 0xFFFFFFF3 ^ 0x0000000F = 0xFFFFFFFC
    }

    void testBitwiseXorEqual() {
        def a = 13
        a ^= 8
        assert a == 5 // 0x0000000D ^ 0x00000008 = 0x000000005
        a ^= 16
        assert a == 21 // 0x00000005 ^ 0x00000010 = 0x000000015
        def b = -13
        b ^= 8
        assert b == -5 // 0xFFFFFFF3 ^ 0x00000008 = 0xFFFFFFFB
        b ^= 16
        assert b == -21 // 0xFFFFFFFB ^ 0x00000010 = 0xFFFFFFEB
    }

    void testBitwiseOrInClosure() {
        def c1 = {x, y -> return x | y}
        assert c1(14, 5) == 15 // 0x0000000E | 0x00000005 = 0x0000000F
        assert c1(0x0D, 0xFE) == 255 // 0x0000000D | 0x000000FE = 0x000000FF

        def c2 = {x, y -> return x | y}
        assert c2(14, 5) == 15 // 0x0000000E | 0x00000005 = 0x0000000F
        assert c2(0x0D, 0xFE) == 255 // 0x0000000D | 0x000000FE = 0x000000FF
    }

    void testAmbiguityOfBitwiseOr() {
        def c1 = {x, y -> return x | y}
        assert c1(14, 5) == 15 // 0x0000000E | 0x00000005 = 0x0000000F
        assert c1(0x0D, 0xFE) == 255 // 0x0000000D | 0x000000FE = 0x000000FF

        def c2 = {x, y -> return x | y}
        assert c2(14, 5) == 15 // 0x0000000E | 0x00000005 = 0x0000000F
        assert c2(0x0D, 0xFE) == 255 // 0x0000000D | 0x000000FE = 0x000000FF

        def x = 3
        def y = 5
        c1 = {xx -> return y} // -> is a closure delimiter
        c2 = {return x & y} // & is a bitAnd
        def c3 = {return x ^ y} // & is a bitXor
        def c11 = {
            xx -> return y // -> is a closure delimiter
        }
        def c12 = {
            return (x | y) // | is a bitOr
        }
        def c13 = {xx -> return y // -> is a closure delimiter
        }
        def c14 = {-> return x | y // last | is a bitOr
        }

        assert c1(null) == 5
        assert c2() == 1
        assert c3() == 6
        assert c11(null) == 5
        assert c12() == 7
        assert c13(null) == 5
        assert c14() == 7

        x = 0x03

        def d1 = {xx -> return xx} // -> is a closure delimiter
        def d2 = {return x & x} // & is a bitAnd
        def d3 = {return x ^ x} // & is a bitXor
        def d11 = {
            xx -> return xx // -> is a closure delimiter
        }
        def d12 = {
            return (x | x) // | is a bitOr
        }
        def d13 = {xx -> return xx // -> is a closure delimiter
        }
        def d14 = {-> return x | x // last | is a bitOr
        }
        assert d1(0xF0) == 0xF0
        assert d2(0xF0) == 0x03
        assert d3(0xF0) == 0
        assert d11(0xF0) == 0xF0
        assert d12(0xF0) == 0x03
        assert d13(0xF0) == 0xF0
        assert d14() == 0x03
    }

    void testBitwiseNegation() {
        assert ~1 == -2 // ~0x00000001 = 0xFFFFFFFE
        assert ~-1 == 0 // ~0xFFFFFFFF = 0x00000000
        assert ~~5 == 5 // ~~0x00000005 = ~0xFFFFFFFA = 0xFFFFFFF5
        def a = 13
        assert ~a == -14 // ~0x0000000D = 0xFFFFFFF2
        assert ~~a == 13 // ~~0x0000000D = ~0xFFFFFFF2 = 0x0000000D
        assert -~a == 14 // -~0x0000000D = -0xFFFFFFF2 = 0x0000000E
    }

    void testBitwiseNegationType() {
        def x = ~7
        assert x.class == java.lang.Integer

        def y = ~"foo"
        assert y.class == java.util.regex.Pattern

        def z = ~"${x}"
        assert z.class == java.util.regex.Pattern
    }

    void testBitwiseNegationTypeCallFunction() {
        // integer test
        assert neg(2).class == java.lang.Integer
        assert neg(2) instanceof java.lang.Integer
        assert neg(2) == ~2

        // long test
        assert neg(2L).class == java.lang.Long
        assert neg(2L) instanceof java.lang.Long
        assert neg(2L) == ~2

        // BigInteger test
        assert neg(new java.math.BigInteger("2")).class == java.math.BigInteger
        assert neg(new java.math.BigInteger("2")) instanceof java.math.BigInteger
        assert neg(new java.math.BigInteger("2")) == ~2

        // BigInteger test
        assert neg(2G).class == java.math.BigInteger
        assert neg(2G) instanceof java.math.BigInteger
        assert neg(2G) == ~2

        assert neg("foo").class == java.util.regex.Pattern
        assert neg("foo") instanceof java.util.regex.Pattern
    }

    void testCorrectAutoboxing() {
        // test that the first parameter is boxed correctly, if not then this test
        // will possibly produce a verify error
        assert (!true | false) == false
        assert (true | false) == true
        assert (!true & false) == false
        assert (true & false) == false
        assert (true & !false) == true

    }

    Object neg(n) {
        if (n instanceof java.lang.Integer) {
            return ~n
        }
        if (n instanceof java.lang.Long) {
            return ~n
        }
        if (n instanceof java.math.BigInteger) {
            return ~n
        }
        return ~n.toString()
    }
}

Other Groovy examples (source code examples)

Here is a short list of links related to this Groovy BitwiseOperatorsTest.groovy source code file:

new blog posts

 

Copyright 1998-2013 Alvin Alexander, alvinalexander.com
All Rights Reserved.