}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}

	// read back zip file and check that we get to the end of it
	r, err := NewReader(buf, buf.Size())
	if err != nil {
		t.Fatal("reader:", err)
	}
	f0 := r.File[0]
	rc, err := f0.Open()
	if err != nil {
		t.Fatal("opening:", err)
	}
	rc.(*checksumReader).hash = fakeHash32{}
	for i := 0; i < chunks; i++ {

import org.codelibs.fess.app.pager.BoostDocPager;
import org.codelibs.fess.app.service.BoostDocumentRuleService;
import org.codelibs.fess.app.web.CrudMode;
import org.codelibs.fess.app.web.base.FessAdminAction;
import org.codelibs.fess.helper.SystemHelper;
import org.codelibs.fess.opensearch.config.exentity.BoostDocumentRule;
import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.RenderDataUtil;
import org.dbflute.optional.OptionalEntity;

        byte[] expectedBytes = unicodeFileName.getBytes(StandardCharsets.UTF_16LE);
        assertEquals(32 + expectedBytes.length, bytesWritten);

        // Verify filename length in header
        int fnLength = buffer[Smb2Constants.SMB2_HEADER_LENGTH + 26] | (buffer[Smb2Constants.SMB2_HEADER_LENGTH + 27] << 8);
        assertEquals(expectedBytes.length, fnLength);
    }

    @Test

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import jcifs.pac.PACDecodingException;

class KerberosApRequestTest {

    // Helper: build a minimal, valid-looking ASN.1 AP-REQ sequence with tags 0/1/2
    private ASN1Sequence buildMinimalApReqSeq(byte apOptions) {
        ASN1EncodableVector v = new ASN1EncodableVector();
        // pvno [0] INTEGER 5

        response.readParameterWordsWireFormat(buffer, 0);

        // When 0xFFFFFFFF is read as signed int, it becomes -1
        assertEquals(-1L, response.getSize());
    }

    // Helper methods for reflection
    private void setFieldValue(Object obj, String fieldName, Object value) {
        try {
            Field field = findField(obj.getClass(), fieldName);
            field.setAccessible(true);

    call.eventListener.responseHeadersEnd(call, response)
  }

  @Throws(IOException::class)
  fun openResponseBody(response: Response): ResponseBody {
    try {
      val contentType = response.header("Content-Type")
      val contentLength = codec.reportedContentLength(response)
      val rawSource = codec.openResponseBodySource(response)
      val source =
        ResponseBodySource(
          delegate = rawSource,

import org.dbflute.optional.OptionalEntity;
import org.dbflute.optional.OptionalThing;
import org.lastaflute.web.Execute;
import org.lastaflute.web.response.HtmlResponse;
import org.lastaflute.web.response.render.RenderData;
import org.lastaflute.web.ruts.process.ActionRuntime;

import jakarta.annotation.Resource;

/**
 * Admin action for Role management.
 *
 */
public class AdminRoleAction extends FessAdminAction {

		}
		return err
	}
	if len(data) == 0 {
		// Seems to be empty create a new poolMeta object.
		return nil
	}
	if len(data) <= 4 {
		return fmt.Errorf("poolMeta: no data")
	}
	// Read header
	switch binary.LittleEndian.Uint16(data[0:2]) {
	case poolMetaFormat:
	default:
		return fmt.Errorf("poolMeta: unknown format: %d", binary.LittleEndian.Uint16(data[0:2]))
	}

Ahora utilizaremos una dependencia simple para leer un header `X-Token` personalizado:

{* ../../docs_src/bigger_applications/app_an_py39/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}

/// tip | Consejo

Estamos usando un header inventado para simplificar este ejemplo.

        }
    }

    // ===================================================================================
    //                                                                        Small Helper
    //                                                                        ============

    private HtmlResponse asListHtml() {
        return asHtml(path_AdminDesign_AdminDesignJsp).useForm(DesignForm.class);
    }