assertThat(expected.message).isEqualTo(
        "Payload size must be less than or equal to 125",
      )
    }
  }

  private fun assertData(hex: String) {
    assertData(hex.decodeHex())
  }

  private fun assertData(expected: ByteString) {
    val actual = data.readByteString(Math.min(expected.size.toLong(), data.size))
    assertThat(actual).isEqualTo(expected)
  }

  companion object {

// EncodeMsg implements msgp.Encodable
func (z *StatInfo) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 5
	// write "Size"
	err = en.Append(0x85, 0xa4, 0x53, 0x69, 0x7a, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt64(z.Size)
	if err != nil {
		err = msgp.WrapError(err, "Size")
		return
	}
	// write "ModTime"
	err = en.Append(0xa7, 0x4d, 0x6f, 0x64, 0x54, 0x69, 0x6d, 0x65)

                throw new IOException("transport closed in negotiate");
            }
            final int size = Encdec.dec_uint16be(sbuf, 2) & 0xFFFF;
            if (size < 33 || 4 + size > sbuf.length) {
                throw new IOException("Invalid payload size: " + size);
            }
            readn(in, sbuf, 4 + 32, size - 32);
            resp.decode(sbuf, 4);

            if (LogStream.level >= 4) {

//
//msgp:tuple FileInfo
type FilesInfo struct {
	Files       []FileInfo
	IsTruncated bool
}

// Size returns size of all versions for the object 'Name'
func (f FileInfoVersions) Size() (size int64) {
	for _, v := range f.Versions {
		size += v.Size
	}
	return size
}

// FileInfoVersions represent a list of versions for a given file.

                              <Status>OK</Status>
	                    </Rule>`,
			expectedErr: errInvalidRuleStatus,
		},
		{ // Rule with negative values for ObjectSizeLessThan
			inputXML: `<Rule>
				<ID>negative-obj-size-less-than</ID>
				<Filter><ObjectSizeLessThan>-1</ObjectSizeLessThan></Filter>
				<Expiration>
					<Days>365</Days>
				</Expiration>
                            <Status>Enabled</Status>
	                    </Rule>`,

    }

    public static List<String> format(String... lines) {
        int size = DEFAULT_MAX_SIZE;
        int remainder = size - 4; // 4 chars = 2 box_char + 2 spaces
        List<String> result = new ArrayList<>();
        StringBuilder sb = new StringBuilder(size);
        // first line
        sb.setLength(0);
        repeat(sb, BOX_CHAR, size);
        result.add(sb.toString());
        // lines

}

// Resize changes the cache size. Size of 0 means unlimited.
func (c *LRU[K, V]) Resize(size int) (evicted int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	if size <= 0 {
		c.size = 0
		return 0
	}
	diff := c.evictList.Length() - size
	if diff < 0 {
		diff = 0
	}
	for i := 0; i < diff; i++ {
		c.removeOldest()
	}
	c.size = size
	return diff
}

            assertEquals(16, bytesRead); // Structure size + reserved (4) + count (4) + remaining (4) + channel info (4)
            assertEquals(1024, response.getCount());
            assertEquals(512, response.getRemaining());
        }

        @Test
        @DisplayName("Should throw exception for invalid structure size")
        void testInvalidStructureSize() {
            byte[] buffer = new byte[64];

      }
      this.size = size;
    }

    @Override
    public int size() {
      return size;
    }

    @Override
    public Range<C> get(int index) {
      checkElementIndex(index, size);

      Cut<C> lowerBound;
      if (positiveBoundedBelow) {
        lowerBound = (index == 0) ? Cut.belowAll() : ranges.get(index - 1).upperBound;
      } else {

    }
  }

  @Override
  int distinctElements() {
    return distinctElements;
  }

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }

  @Override
  public int count(@Nullable Object element) {
    // isActuallyE checks for null, but we check explicitly to help nullness checkers.