if newGlobalAuthZPluginFn() != nil {
		return claims, nil
	}

	// Check if a session policy is set. If so, decode it here.
	sp, spok := claims.Lookup(policy.SessionPolicyName)
	if spok {
		// Looks like subpolicy is set and is a string, if set then its
		// base64 encoded, decode it. Decoding fails reject such
		// requests.
		spBytes, err := base64.StdEncoding.DecodeString(sp)
		if err != nil {

        int decoded = resp.decode(buf, headerStart);
        assertTrue(decoded > 0, "Decode should return positive length");

        assertEquals(NtStatus.NT_STATUS_MORE_PROCESSING_REQUIRED, resp.getStatus());
        assertArrayEquals(blob, resp.getBlob(), "Security blob should match");
        assertEquals(sessionFlags, resp.getSessionFlags(), "Session flags should decode");

		return
	}

	info, err := globalSiteReplicationSys.GetClusterInfo(ctx)
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	if err = json.NewEncoder(w).Encode(info); err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}
}

func (a adminAPIHandlers) SRPeerGetIDPSettings(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

        SMBUtil.writeInt4(messageLength, buffer, bufferIndex + 12);
        System.arraycopy(testData, 0, buffer, bufferIndex + 16, testData.length);

        // Decode
        int bytesDecoded = response.decode(buffer, bufferIndex, buffer.length);

        // Verify results
        assertEquals(namedPipeState, response.getNamedPipeState());
        assertEquals(readDataAvailable, response.getReadDataAvailable());

    }

    @Test
    @DisplayName("Test decode with valid single entry")
    void testDecodeValidSingleEntry() throws SMBProtocolDecodingException {
        String fileName = "document.pdf";
        int action = FileNotifyInformation.FILE_ACTION_MODIFIED;
        byte[] buffer = createValidNotificationBuffer(fileName, action);

        int bytesRead = notifyInfo.decode(buffer, 0, buffer.length);

        assertTrue(bytesRead > 0);

    throw IllegalArgumentException("failed to decode certificate", nsee)
  } catch (iae: IllegalArgumentException) {
    throw IllegalArgumentException("failed to decode certificate", iae)
  } catch (e: GeneralSecurityException) {
    throw IllegalArgumentException("failed to decode certificate", e)
  }
}

/**
 * Returns the certificate encoded in [PEM format][rfc_7468].
 *

    @Override
    int writeBodyWireFormat(final byte[] dst, final int dstIndex) {
        final int tmp = this.questionName.hexCode;
        this.questionName.hexCode = 0x00; // type has to be 0x00 for node status
        final int result = writeQuestionSectionWireFormat(dst, dstIndex);
        this.questionName.hexCode = tmp;
        return result;
    }

    @Override
    int readBodyWireFormat(final byte[] src, final int srcIndex) {

// ContainsAny reports whether any of the UTF-8-encoded code points in chars are within b.
func ContainsAny(b []byte, chars string) bool {
	return IndexAny(b, chars) >= 0
}

// ContainsRune reports whether the rune is contained in the UTF-8-encoded byte slice b.
func ContainsRune(b []byte, r rune) bool {
	return IndexRune(b, r) >= 0
}

// ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r).

    }

    @Test
    @DisplayName("Test decode with owner SID only")
    void testDecodeWithOwnerSidOnly() throws SMBProtocolDecodingException {
        // Prepare buffer with owner SID only
        prepareMinimalSecurityDescriptorBuffer(testBuffer, 0, true, false, false);

        int size = securityDescriptor.decode(testBuffer, 0, testBuffer.length);

        // decode returns 0 when no DACL is present (falls through)

        assertThrows(IllegalArgumentException.class, () -> new Smb2LeaseKey(new byte[17]));
        assertThrows(IllegalArgumentException.class, () -> new Smb2LeaseKey(new byte[0]));
    }

    @Test
    @DisplayName("Should encode lease key to buffer")
    void testEncode() {
        byte[] testBytes = new byte[] { 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, (byte) 0x88, (byte) 0x99, (byte) 0xAA, (byte) 0xBB,