rep_obj2_etag=$(echo "${stat_out2_rep}" | jq '.etag')
rep_obj2_size=$(echo "${stat_out2_rep}" | jq '.size')
rep_obj2_md5=$(echo "${stat_out2_rep}" | jq '.metadata."X-Amz-Server-Side-Encryption-Customer-Key-Md5"')

# Check the etag and size of replicated SSEC objects
if [ "${rep_obj1_etag}" != "${src_obj1_etag}" ]; then

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String permissions;

    /** The boost score multiplier applied to elevated documents */
    @Required
    @ValidateTypeFailure
    public Float boost;

    /** The username of who created this elevate word entry */
    @Size(max = 1000)
    public String createdBy;

    this.forward = forward;
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return forward.contains(object);
  }

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

  @Override
  public UnmodifiableIterator<E> iterator() {
    return forward.descendingIterator();
  }

  @Override
  ImmutableSortedSet<E> headSetImpl(E toElement, boolean inclusive) {

      tableSize <<= 1;
      return (tableSize > 0) ? tableSize : MAX_TABLE_SIZE;
    }
    return tableSize;
  }

  static boolean needsResizing(int size, int tableSize, double loadFactor) {
    return size > loadFactor * tableSize && tableSize < MAX_TABLE_SIZE;
  }

        Set set = project1.getArtifacts();
        assertNotNull(set, "No artifacts");
        assertFalse(set.isEmpty(), "No Artifacts");
        assertTrue(set.size() == 3, "Set size should be 3, is " + set.size());

        for (Object aSet : set) {
            Artifact artifact = (Artifact) aSet;
            assertFalse(artifact.getArtifactId().equals("t07-d"));

    assertThat(source.readByte() and 0xff).isEqualTo(0xbf)
    assertThat(source.readUtf8()).isEqualTo("hello")
  }

  @Test
  fun bytesEmpty() {
    val body = body("")
    assertThat(body.bytes().size).isEqualTo(0)
  }

  @Test
  fun bytesSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val bytes = body.bytes()
    assertThat(bytes[0] and 0xff).isEqualTo(0xef)

    private final DataInputStream dis;
    private final int size;

    /**
     * Constructs a PAC data input stream from the given input stream.
     * @param in the underlying input stream
     * @throws IOException if an I/O error occurs
     */
    public PacDataInputStream(final InputStream in) throws IOException {
        this.dis = new DataInputStream(in);
        this.size = in.available();
    }

    /**

        final int len = str.length();
        int ch, size = 0;
        byte[] dst;

        for (int i = 0; i < len; i++) {
            ch = str.charAt(i);
            size += ch > 0x07F ? ch > 0x7FF ? 3 : 2 : 1;
        }
        dst = new byte[size];
        writeShort(size);
        Encdec.enc_utf8(str, dst, 0, size);
        write(dst, 0, size);
    }

    }

    val bytes = source().use(consumer)
    val size = sizeMapper(bytes)
    if (contentLength != -1L && contentLength != size.toLong()) {
      throw IOException("Content-Length ($contentLength) and stream length ($size) disagree")
    }
    return bytes
  }

  /**
   * Returns the response as a character stream.
   *
   * If the response starts with a

    return sslSocket
  }

  override fun onStream(stream: Http2Stream) {
    try {
      val requestHeaders = stream.takeHeaders()
      var path: String? = null
      var i = 0
      val size = requestHeaders.size
      while (i < size) {
        if (requestHeaders.name(i) == Header.TARGET_PATH_UTF8) {
          path = requestHeaders.value(i)
          break
        }
        i++
      }
      if (path == null) {