import org.checkerframework.checker.signedness.qual.*;

public class MaskedShifts {

    public void MaskedAndShifts(@Unsigned int unsigned, @Signed int signed) {

        @UnknownSignedness int testRes;

        // Use mask that renders the 9 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are masked away
        testRes = (unsigned >>> 8) & 0x7FFFFF;
        testRes = (unsigned >> 8) & 0x7FFFFF;
        testRes = (signed >>> 8) & 0x7FFFFF;
        testRes = (signed >> 8) & 0x7FFFFF;

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = (unsigned >>> 8) & 0xFFFFFF;
        testRes = (unsigned >> 8) & 0xFFFFFF;
        testRes = (signed >>> 8) & 0xFFFFFF;
        testRes = (signed >> 8) & 0xFFFFFF;

        // Use mask that renders the 7 MSB_s irrelevant

        // Now the right-most introduced bit matters
        testRes = (unsigned >>> 8) & 0x1FFFFFF;

        // :: error: (shift.signed)
        testRes = (unsigned >> 8) & 0x1FFFFFF;

        // :: error: (shift.unsigned)
        testRes = (signed >>> 8) & 0x1FFFFFF;
        testRes = (signed >> 8) & 0x1FFFFFF;

        // Use mask that doesn't render the MSB irrelevent, but does render the next 7 MSB_s
        // irrelevant.

        // Now the left-most introduced bit matters
        testRes = (unsigned >>> 8) & 0x90FFFFFF;

        // :: error: (shift.signed)
        testRes = (unsigned >> 8) & 0x90FFFFFF;

        // :: error: (shift.unsigned)
        testRes = (signed >>> 8) & 0x90FFFFFF;
        testRes = (signed >> 8) & 0x90FFFFFF;

        // Use mask that doesn't render any bits irrelevent

        testRes = (unsigned >>> 8) & 0xFFFFFFFF;

        // :: error: (shift.signed)
        testRes = (unsigned >> 8) & 0xFFFFFFFF;

        // :: error: (shift.unsigned)
        testRes = (signed >>> 8) & 0xFFFFFFFF;
        testRes = (signed >> 8) & 0xFFFFFFFF;

        // Tests with no parenthesis (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = unsigned >>> 8 & 0xFFFFFF;
        testRes = unsigned >> 8 & 0xFFFFFF;
        testRes = signed >>> 8 & 0xFFFFFF;
        testRes = signed >> 8 & 0xFFFFFF;

        // Use mask that doesn't render any bits irrelevent

        testRes = unsigned >>> 8 & 0xFFFFFFFF;

        // :: error: (shift.signed)
        testRes = unsigned >> 8 & 0xFFFFFFFF;

        // :: error: (shift.unsigned)
        testRes = signed >>> 8 & 0xFFFFFFFF;
        testRes = signed >> 8 & 0xFFFFFFFF;

        // Tests with double parenthesis (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = ((unsigned >>> 8)) & 0xFFFFFF;
        testRes = ((unsigned >> 8)) & 0xFFFFFF;
        testRes = ((signed >>> 8)) & 0xFFFFFF;
        testRes = ((signed >> 8)) & 0xFFFFFF;

        // Use mask that doesn't render any bits irrelevent

        testRes = ((unsigned >>> 8)) & 0xFFFFFFFF;

        // :: error: (shift.signed)
        testRes = ((unsigned >> 8)) & 0xFFFFFFFF;

        // :: error: (shift.unsigned)
        testRes = ((signed >>> 8)) & 0xFFFFFFFF;
        testRes = ((signed >> 8)) & 0xFFFFFFFF;

        // Tests shift on right (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = 0xFFFFFF & (unsigned >>> 8);
        testRes = 0xFFFFFF & (unsigned >> 8);
        testRes = 0xFFFFFF & (signed >>> 8);
        testRes = 0xFFFFFF & (signed >> 8);

        // Use mask that doesn't render any bits irrelevent

        testRes = 0xFFFFFFFF & (unsigned >>> 8);

        // :: error: (shift.signed)
        testRes = 0xFFFFFFFF & (unsigned >> 8);

        // :: error: (shift.unsigned)
        testRes = 0xFFFFFFFF & (signed >>> 8);
        testRes = 0xFFFFFFFF & (signed >> 8);

        // Tests shift on right (only 8 and 0 MSB_s), with no parenthesis on right

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = 0xFFFFFF & unsigned >>> 8;
        testRes = 0xFFFFFF & unsigned >> 8;
        testRes = 0xFFFFFF & signed >>> 8;
        testRes = 0xFFFFFF & signed >> 8;

        // Use mask that doesn't render any bits irrelevent

        testRes = 0xFFFFFFFF & unsigned >>> 8;

        // :: error: (shift.signed)
        testRes = 0xFFFFFFFF & unsigned >> 8;

        // :: error: (shift.unsigned)
        testRes = 0xFFFFFFFF & signed >>> 8;
        testRes = 0xFFFFFFFF & signed >> 8;

        // Tests with parenthesis on mask (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = unsigned >>> 8 & (0xFFFFFF);
        testRes = unsigned >> 8 & (0xFFFFFF);
        testRes = signed >>> 8 & (0xFFFFFF);
        testRes = signed >> 8 & (0xFFFFFF);

        // Use mask that doesn't render any bits irrelevent

        testRes = unsigned >>> 8 & (0xFFFFFFFF);

        // :: error: (shift.signed)
        testRes = unsigned >> 8 & (0xFFFFFFFF);

        // :: error: (shift.unsigned)
        testRes = signed >>> 8 & (0xFFFFFFFF);
        testRes = signed >> 8 & (0xFFFFFFFF);

        // Tests with double parenthesis on mask (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = unsigned >>> 8 & ((0xFFFFFF));
        testRes = unsigned >> 8 & ((0xFFFFFF));
        testRes = signed >>> 8 & ((0xFFFFFF));
        testRes = signed >> 8 & ((0xFFFFFF));

        // Use mask that doesn't render any bits irrelevent

        testRes = unsigned >>> 8 & ((0xFFFFFFFF));

        // :: error: (shift.signed)
        testRes = unsigned >> 8 & ((0xFFFFFFFF));

        // :: error: (shift.unsigned)
        testRes = signed >>> 8 & ((0xFFFFFFFF));
        testRes = signed >> 8 & ((0xFFFFFFFF));
    }

    public void MaskedOrShifts(@Unsigned int unsigned, @Signed int signed) {

        @UnknownSignedness int testRes;

        // Use mask that renders the 9 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are masked away.
        testRes = (unsigned >>> 8) | 0xFF800000;
        testRes = (unsigned >> 8) | 0xFF800000;
        testRes = (signed >>> 8) | 0xFF800000;
        testRes = (signed >> 8) | 0xFF800000;

        // Use mask that render ths 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = (unsigned >>> 8) | 0xFF000000;
        testRes = (unsigned >> 8) | 0xFF000000;
        testRes = (signed >>> 8) | 0xFF000000;
        testRes = (signed >> 8) | 0xFF000000;

        // Use mask that renders the 7 MSB_s irrelevant.

        // The right-most introduced bit now matters.
        testRes = (unsigned >>> 8) | 0xFE000000;

        // :: error: (shift.signed)
        testRes = (unsigned >> 8) | 0xFE000000;

        // :: error: (shift.unsigned)
        testRes = (signed >>> 8) | 0xFE000000;
        testRes = (signed >> 8) | 0xFE000000;

        // Use mask that doesn't render the MSB irrelevent, but does render the next 7 MSB_s
        // irrelevant.

        // Now the left-most introduced bit matters
        testRes = (unsigned >>> 8) | 0x8F000000;

        // :: error: (shift.signed)
        testRes = (unsigned >> 8) | 0x8F000000;

        // :: error: (shift.unsigned)
        testRes = (signed >>> 8) | 0x8F000000;
        testRes = (signed >> 8) | 0x8F000000;

        // Use mask that doesn't render any bits irrelevent

        testRes = (unsigned >>> 8) | 0x0;

        // :: error: (shift.signed)
        testRes = (unsigned >> 8) | 0x0;

        // :: error: (shift.unsigned)
        testRes = (signed >>> 8) | 0x0;
        testRes = (signed >> 8) | 0x0;

        // Tests with no parenthesis (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = unsigned >>> 8 | 0xFF000000;
        testRes = unsigned >> 8 | 0xFF000000;
        testRes = signed >>> 8 | 0xFF000000;
        testRes = signed >> 8 | 0xFF000000;

        // Use mask that doesn't render any bits irrelevent

        testRes = unsigned >>> 8 | 0x0;

        // :: error: (shift.signed)
        testRes = unsigned >> 8 | 0x0;

        // :: error: (shift.unsigned)
        testRes = signed >>> 8 | 0x0;
        testRes = signed >> 8 | 0x0;

        // Tests with double parenthesis (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = ((unsigned >>> 8)) | 0xFF000000;
        testRes = ((unsigned >> 8)) | 0xFF000000;
        testRes = ((signed >>> 8)) | 0xFF000000;
        testRes = ((signed >> 8)) | 0xFF000000;

        // Use mask that doesn't render any bits irrelevent

        testRes = ((unsigned >>> 8)) | 0x0;

        // :: error: (shift.signed)
        testRes = ((unsigned >> 8)) | 0x0;

        // :: error: (shift.unsigned)
        testRes = ((signed >>> 8)) | 0x0;
        testRes = ((signed >> 8)) | 0x0;

        // Tests shift on right (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = 0xFF000000 | (unsigned >>> 8);
        testRes = 0xFF000000 | (unsigned >> 8);
        testRes = 0xFF000000 | (signed >>> 8);
        testRes = 0xFF000000 | (signed >> 8);

        // Use mask that doesn't render any bits irrelevent

        testRes = 0x0 | (unsigned >>> 8);

        // :: error: (shift.signed)
        testRes = 0x0 | (unsigned >> 8);

        // :: error: (shift.unsigned)
        testRes = 0x0 | (signed >>> 8);
        testRes = 0x0 | (signed >> 8);

        // Tests with parenthesis on mask (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = unsigned >>> 8 | (0xFF000000);
        testRes = unsigned >> 8 | (0xFF000000);
        testRes = signed >>> 8 | (0xFF000000);
        testRes = signed >> 8 | (0xFF000000);

        // Use mask that doesn't render any bits irrelevent

        testRes = unsigned >>> 8 | (0x0);

        // :: error: (shift.signed)
        testRes = unsigned >> 8 | (0x0);

        // :: error: (shift.unsigned)
        testRes = signed >>> 8 | (0x0);
        testRes = signed >> 8 | (0x0);

        // Tests with double parenthesis on mask (only 8 and 0 MSB_s)

        // Use mask that renders the 8 MSB_s irrelevant.

        // Shifting right by 8, the introduced bits are still masked away.
        testRes = unsigned >>> 8 | ((0xFF000000));
        testRes = unsigned >> 8 | ((0xFF000000));
        testRes = signed >>> 8 | ((0xFF000000));
        testRes = signed >> 8 | ((0xFF000000));

        // Use mask that doesn't render any bits irrelevent

        testRes = unsigned >>> 8 | ((0x0));

        // :: error: (shift.signed)
        testRes = unsigned >> 8 | ((0x0));

        // :: error: (shift.unsigned)
        testRes = signed >>> 8 | ((0x0));
        testRes = signed >> 8 | ((0x0));
    }

    public void ZeroShiftTests(@Unsigned int unsigned, @Signed int signed) {
        @UnknownSignedness int testRes;

        // Tests shift by zero followed by "and" mask
        testRes = (unsigned >>> 0) & 0xFFFFFFFF;
        testRes = (unsigned >> 0) & 0xFFFFFFFF;
        testRes = (signed >>> 0) & 0xFFFFFFFF;
        testRes = (signed >> 0) & 0xFFFFFFFF;

        // Tests shift by zero followed by "or" mask
        testRes = (unsigned >>> 0) | 0x0;
        testRes = (unsigned >> 0) | 0x0;
        testRes = (signed >>> 0) | 0x0;
        testRes = (signed >> 0) | 0x0;
    }
}