Arguments.of(ALL_SECURITY_INFORMATION, "All security information"), Arguments.of(0x00000000, "No security information"),
                Arguments.of(0xFFFFFFFF, "All bits set"));
    }

    @Test
    @DisplayName("Test writeParametersWireFormat buffer boundary")
    void testWriteParametersWireFormatBufferBoundary() {

            jcifs.internal.smb1.com.SmbComReadAndX req = cap.getValue();
            assertEquals(0x12345 & 0xFFFF, req.getMaxCount(), "maxCount should contain lower 16 bits");
            assertEquals(0x12345, req.getMinCount(), "minCount should remain original full value");
        }

        @Test
        @DisplayName("Named pipe request uses fixed 1024 hints")

En Python 3.10 también hay una **nueva sintaxis** donde puedes poner los posibles tipos separados por una <abbr title='también llamado "operador OR a nivel de bits", pero ese significado no es relevante aquí'>barra vertical (`|`)</abbr>.

//// tab | Python 3.10+

```Python hl_lines="1"
{!> ../../docs_src/python_types/tutorial008b_py310.py!}
```

////

// If parsing fails or an integer overflow occurs, err will be set.
func (p *parser) parseNumeric(b []byte) int64 {
	// Check for base-256 (binary) format first.
	// If the first bit is set, then all following bits constitute a two's
	// complement encoded number in big-endian byte order.
	if len(b) > 0 && b[0]&0x80 != 0 {
		// Handling negative numbers relies on the following identity:
		//	-a-1 == ^a
		//

                Arguments.of(FILE_NOTIFY_CHANGE_ALL, "All changes"), Arguments.of(0x00000000, "No filters"),
                Arguments.of(0xFFFFFFFF, "All bits set"));
    }

    @ParameterizedTest
    @DisplayName("Test writeSetupWireFormat with different watchTree values")
    @CsvSource({ "true, 0x01", "false, 0x00" })

func (z *Int) Bytes() []byte {
	b := make([]byte, (z.Len()+7)/8)
	n := C.size_t(len(b))
	C.mpz_export(unsafe.Pointer(&b[0]), &n, 1, 1, 1, 0, &z.i[0])
	return b[0:n]
}

// Len returns the length of z in bits.  0 is considered to have length 1.
func (z *Int) Len() int {
	z.doinit()
	return int(C.mpz_sizeinbase(&z.i[0], 2))
}

// Set sets z = x and returns z.
func (z *Int) Set(x *Int) *Int {
	z.doinit()

    }

    @Test
    void testPtypeAndFlagsValues() {
        // Verify specific flag values are correctly set
        assertEquals(0, msrpcShareGetInfo.getPtype());

        // Check individual flag bits
        int flags = msrpcShareGetInfo.getFlags();
        assertTrue((flags & DcerpcConstants.DCERPC_FIRST_FRAG) != 0);
        assertTrue((flags & DcerpcConstants.DCERPC_LAST_FRAG) != 0);
    }

    @Test

}

// Forked from Golang but chooses to avoid performing lookup
//
// osMkdirAll creates a directory named path,
// along with any necessary parents, and returns nil,
// or else returns an error.
// The permission bits perm (before umask) are used for all
// directories that MkdirAll creates.
// If path is already a directory, MkdirAll does nothing
// and returns nil.
func osMkdirAll(dirPath string, perm os.FileMode, baseDir string) error {

	if _, err := io.ReadFull(r, buf[off:12]); err != nil {
		return err
	}
	b := readBuf(buf[:12])
	if b.uint32() != f.CRC32 {
		return ErrChecksum
	}

	// The two sizes that follow here can be either 32 bits or 64 bits
	// but the spec is not very clear on this and different
	// interpretations has been made causing incompatibilities. We
	// already have the sizes from the central directory so we can
	// just ignore these.

	}
	z.XLV1, bts, err = msgp.ReadBoolBytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "XLV1")
		return
	}
	z.ModTime, bts, err = msgp.ReadTimeBytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "ModTime")
		return
	}
	z.Size, bts, err = msgp.ReadInt64Bytes(bts)
	if err != nil {
		err = msgp.WrapError(err, "Size")
		return
	}
	z.Mode, bts, err = msgp.ReadUint32Bytes(bts)