private PacSignature kdcSignature;


    public Pac ( byte[] data, Map<Integer, KerberosKey> keys ) throws PACDecodingException {
        byte[] checksumData = data.clone();
        try {
            PacDataInputStream pacStream = new PacDataInputStream(new DataInputStream(new ByteArrayInputStream(data)));

            if ( data.length <= 8 )
                throw new PACDecodingException("Empty PAC");

public class RenderDataUtilTest extends UnitFessTestCase {

    public void test_register() {
        RenderData data = new RenderData();

        RenderDataUtil.register(data, "key1", null);
        assertNull(data.getDataMap().get("key1"));

        RenderDataUtil.register(data, "key5", "");
        assertEquals(data.getDataMap().get("key5"), "");

    }

                                            <c:forEach var="data" varStatus="s"
                                                       items="${duplicateHostItems}">
                                                <tr
                                                        data-href="${contextPath}/admin/duplicatehost/details/4/${f:u(data.id)}">
                                                    <td>${f:h(data.regularName)}</td>

func ParsePublicCertFile(certFile string) (x509Certs []*x509.Certificate, err error) {
	// Read certificate file.
	var data []byte
	if data, err = os.ReadFile(certFile); err != nil {
		return nil, err
	}

	// Trimming leading and tailing white spaces.
	data = bytes.TrimSpace(data)

	// Parse all certs in the chain.
	current := data
	for len(current) > 0 {
		var pemBlock *pem.Block

            searchPaging(data, form);
        });
    }

    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse reset(final SearchForm form) {
        validate(form, messages -> {}, this::asDictIndexHtml);
        synonymPager.clear();
        return asHtml(path_AdminDictSynonym_AdminDictSynonymJsp).renderWith(data -> {
            searchPaging(data, form);

@pytest.mark.anyio
async def test_upload_file():
    stream = io.BytesIO(b"data")
    file = UploadFile(filename="file", file=stream, size=4)
    assert await file.read() == b"data"
    assert file.size == 4
    await file.write(b" and more data!")
    assert await file.read() == b""
    assert file.size == 19
    await file.seek(0)
    assert await file.read() == b"data and more data!"

@app.post("/form/")
def post_form(user: Annotated[FormModel, Form()]):
    return user


client = TestClient(app)


def test_send_all_data():
    response = client.post(
        "/form/",
        data={
            "username": "Rick",
            "lastname": "Sanchez",
            "age": "70",
            "tags": ["plumbus", "citadel"],
            "with": "something",
        },
    )

	attr := "user.total_deletes"

	data := make([]byte, 8)
	binary.LittleEndian.PutUint64(data, deleteCount)
	return xattr.LSet(s.formatFile, attr, data)
}

func (s *xlStorage) setWriteAttribute(writeCount uint64) error {
	attr := "user.total_writes"

	data := make([]byte, 8)
	binary.LittleEndian.PutUint64(data, writeCount)
	return xattr.LSet(s.formatFile, attr, data)
}

    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)
    assertThat(encodedLength(data).toLong()).isEqualTo(encodeBuffer.size)
    val decodeBuffer = Buffer()
    decode(encodeBuffer, encodeBuffer.size, decodeBuffer)
    assertEquals(data, decodeBuffer.readByteString())
  }

            for ( int i = 0; i < 8; i++ )
                data[ index + i ] = 0;
            SMBUtil.writeInt4(this.signSequence, data, index);
            update(data, offset, length);
            System.arraycopy(digest(), 0, data, index, 8);
            if ( this.bypass ) {
                this.bypass = false;
                System.arraycopy("BSRSPYL ".getBytes(), 0, data, index, 8);
            }
        }