* @return string representation of this FacetInfo instance
     */
    @Override
    public String toString() {
        return "FacetInfo [field=" + Arrays.toString(field) + ", query=" + Arrays.toString(query) + ", size=" + size + ", minDocCount="
                + minDocCount + ", sort=" + sort + ", missing=" + missing + "]";
    }

			<PatternLayout><Pattern>${log.pattern}</Pattern></PatternLayout><!-- <EcsLayout serviceName="fess" eventDataset="app" /> -->
			<Policies>
				<TimeBasedTriggeringPolicy />
				<SizeBasedTriggeringPolicy size="100 MB" />
			</Policies>
			<DefaultRolloverStrategy fileIndex="max" min="1"
				max="${backup.max.history}" compressionLevel="9">
				<Delete basePath="${log.file.basedir}">
					<IfFileName glob="${domain.name}*.log.gz" />

      val trustedCert = trustRootIndex.findByIssuerAndSignature(toVerify)
      if (trustedCert != null) {
        if (result.size > 1 || toVerify != trustedCert) {
          result.add(trustedCert)
        }
        if (verifySignature(trustedCert, trustedCert, result.size - 2)) {
          return result // The self-signed cert is a root CA. We're done.
        }
        foundTrustedCertificate = true
        continue

  @Param({"20", "2000"})
  int size;

  @Param({"2", "20"})
  int nonAlphaRatio; // one non-alpha char per this many chars

  @Param boolean noWorkToDo;

  Random random;
  String testString;

  @BeforeExperiment
  void setUp() {
    random = new Random(0xdeadbeef); // fix the seed so results are comparable across runs

    int nonAlpha = size / nonAlphaRatio;
    int alpha = size - nonAlpha;

        expectedSize += ((nameLen + 7) / 8) * 8; // size8(nameLen)
        expectedSize = ((expectedSize + 7) / 8) * 8; // size8(size)

        assertEquals(expectedSize, request.size());
    }

    @Test
    @DisplayName("Test size calculation with empty path")
    void testSizeWithEmptyPath() {
        request = new Smb2CreateRequest(mockConfig, "");

  }

  public void testSize() throws IOException {
    assertEquals(bytes.length, source.size());
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    // test that we can get the size even if skip() isn't supported
    assertEquals(bytes.length, new TestByteSource(bytes, SKIP_THROWS).size());

    // test that we can get the size even if available() always returns zero

func (z *allTierStats) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "ts"
	o = append(o, 0x81, 0xa2, 0x74, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.Tiers)))
	for za0001, za0002 := range z.Tiers {
		o = msgp.AppendString(o, za0001)
		// map header, size 3
		// string "ts"
		o = append(o, 0x83, 0xa2, 0x74, 0x73)
		o = msgp.AppendUint64(o, za0002.TotalSize)

        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of records to display per page.
     * If the page size is not set or is invalid, returns the default page size.
     *
     * @return the number of records per page
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }

        // Verify stats contain expected fields
        // Note: The actual fields may vary depending on the implementation
        // Common fields might include: document count, index size, etc.
        assertTrue(res.size() > 0, "Response should contain stats data");

        logger.info("[END] testRead");
    }

    @Override
    @AfterEach
    protected void tearDown() {
        // do nothing
    }

    void largeMessageIsReadCorrectly() throws IOException {
        // Create a message with 1000 bytes
        int size = 1000;
        byte[] data = new byte[size];
        for (int i = 0; i < size; i++) {
            data[i] = (byte) (i % 256);
        }

        byte[] fullData = concat(messageHeader(size), data);
        InputStream in = new ByteArrayInputStream(fullData);