* of this method.
     */
    void putAll(LockFreeBitArray other) {
      checkArgument(
          data.length() == other.data.length(),
          "BitArrays must be of equal length (%s != %s)",
          data.length(),
          other.data.length());
      for (int i = 0; i < data.length(); i++) {
        putData(i, other.data.get(i));
      }
    }

    /**

    // step through the CharSequence 2 chars at a time
    for (int i = 1; i < input.length(); i += 2) {
      int k1 = input.charAt(i - 1) | (input.charAt(i) << 16);
      k1 = mixK1(k1);
      h1 = mixH1(h1, k1);
    }

    // deal with any remaining characters
    if ((input.length() & 1) == 1) {
      int k1 = input.charAt(input.length() - 1);
      k1 = mixK1(k1);
      h1 ^= k1;
    }

    assertTrue(x != y);
    assertEquals(x.length(), y.length());
    for (int i = 0; i < SIZE; i++) {
      assertBitEquals(x.get(i), y.get(i));
    }

    AtomicDoubleArray a = new AtomicDoubleArray(VALUES);
    AtomicDoubleArray b = serialClone(a);
    assertFalse(a.equals(b));
    assertFalse(b.equals(a));
    assertEquals(a.length(), b.length());
    for (int i = 0; i < VALUES.length; i++) {

      return delegate.order(insertionOrder);
    }

    @Override
    public K[] createKeyArray(int length) {
      return delegate.createKeyArray(length);
    }

    @Override
    public V[] createValueArray(int length) {
      return delegate.createValueArray(length);
    }

    @Override
    public SampleElements<Entry<K, V>> samples() {
      return delegate.samples();
    }

        int offset = 50;
        byte[] infoData = createMockFileBasicInfoBuffer();
        System.arraycopy(infoData, 0, buffer, offset, infoData.length);
        response.setDataCount(infoData.length);

        int bytesRead = response.readDataWireFormat(buffer, offset, buffer.length - offset);

        assertTrue(bytesRead > 0);
        assertNotNull(response.getInfo());
    }

        // Verify num_sids
        assertEquals(2, lsarSidArrayX.num_sids, "num_sids should match the array length");

        // Verify sids array and its contents
        assertNotNull(lsarSidArrayX.sids, "sids array should not be null");
        assertEquals(2, lsarSidArrayX.sids.length, "sids array length should match");
        assertEquals(sidT1, lsarSidArrayX.sids[0].sid, "First SID should be unwrapped correctly");

                  @Override
                  public Range<Integer>[] createKeyArray(int length) {
                    return (Range<Integer>[]) new Range<?>[length];
                  }

                  @Override
                  public String[] createValueArray(int length) {
                    return new String[length];
                  }
                })
            .named("TreeRangeMap.asMapOfRanges")

        final String[] roles = new String[roles1.length + roles2.length];

        if (roles1.length > 0) {
            System.arraycopy(roles1, 0, roles, 0, roles1.length);
        }
        if (roles2.length > 0) {
            System.arraycopy(roles2, 0, roles, roles1.length, roles2.length);
        }

        final List<SuggestItem> items = new ArrayList<>(fields.length);
        try {

        long expectedLength = 1024L;
        when(smbFile.length()).thenReturn(expectedLength);

        assertEquals(expectedLength, smbRandomAccessFile.length());
    }

    @Test
    void testSetLength() throws SmbException {
        long newLength = 2048L;
        smbRandomAccessFile.setLength(newLength);
        // Verify length was set (actual behavior depends on implementation)
    }

    @Test

        assertEquals(1, itemList.get(0).getInputs().length);
        assertEquals(1, itemList.get(0).getOutputs().length);
        assertEquals("a1", itemList.get(0).getInputs()[0]);
        assertEquals("A1", itemList.get(0).getOutputs()[0]);
        assertFalse(itemList.get(0).isUpdated());

        assertEquals(2, itemList.get(1).getInputs().length);
        assertEquals(1, itemList.get(1).getOutputs().length);