assertArrayEquals(hashAlgos, context.getHashAlgos());
            assertArrayEquals(salt, context.getSalt());
            assertEquals(0, context.getHashAlgos().length);
            assertEquals(0, context.getSalt().length);
        }

        @Test
        @DisplayName("Should create instance with default constructor")
        void testDefaultConstructor() {

    input = Arrays.copyOf(input, input.length);
    Doubles.sortDescending(input);
    for (int i = 0; i < input.length; i++) {
      assertThat(input[i]).isEqualTo(expectedOutput[i]);
    }
  }

  private static void testSortDescending(
      double[] input, int fromIndex, int toIndex, double[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Doubles.sortDescending(input, fromIndex, toIndex);

    E[] array = collection.toArray(empty);
    assertEquals(
        "toArray(emptyT[]) should return an array of type T", empty.getClass(), array.getClass());
    assertEquals("toArray(emptyT[]).length:", getNumElements(), array.length);
    expectArrayContentsAnyOrder(createSamplesArray(), array);
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testToArray_emptyArray_ordered() {

        int writeBodyWireFormat(byte[] dst, int dstIndex) {
            // For testing purposes, we can return a fixed length or mock behavior
            return 0;
        }

        @Override
        int readBodyWireFormat(byte[] src, int srcIndex) {
            // For testing purposes, we can return a fixed length or mock behavior
            return 0;
        }

        @Override

                ip = i = 0;
                for (; i < data.length && c == '.'; i++) {
                    int b = 0x00;

                    for (; i < data.length && (c = data[i]) >= 48 && c <= 57; i++) {
                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;

		}
	}
	if entries.len() != len(want) {
		t.Fatal("unexpected length:", entries.len(), "want:", len(want))
	}

	want = want[:0]
	entries, err = r.readN(0, false, true, false, "")
	if err != nil {
		t.Fatal(err, entries.len())
	}
	if entries.len() != len(want) {
		t.Fatal("unexpected length:", entries.len(), "want:", len(want))
	}

	// Reload.
	r = loadMetacacheSample(t)

| :--                  | :--                                            |
| *Type*               | *String*                                       |
| *Length Constraints* | *Minimum length of 4. Maximum length of 2048.* |
| *Required*           | *Yes*                                          |

### Version

        // better safe than sorry: prevent leaks if there is some out of bound access
        Arrays.fill(buf, (byte) 0);
        synchronized (this.cache) {
            if (this.freeBuffers < this.cache.length) {
                for (int i = 0; i < this.cache.length; i++) {
                    if (this.cache[i] == null) {
                        this.cache[i] = buf;
                        this.freeBuffers++;
                        return;

        return ("TransCallNamedPipeResponse[" + super.toString() + "]");
    }

    /**
     * Gets the length of the response data received from the named pipe.
     *
     * @return response data length
     */
    public int getResponseLength() {
        return getDataCount();
    }

        buf.enc_ndr_small(2); // ptype = 2 (Response)
        buf.enc_ndr_small(0); // flags
        buf.enc_ndr_long(0x00000010); // data representation
        buf.enc_ndr_short(20); // length
        buf.enc_ndr_short(0); // auth length
        buf.enc_ndr_long(0); // call_id

        // Response body
        buf.enc_ndr_long(4); // alloc_hint
        buf.enc_ndr_short(0); // context_id