if (this.password != null) {
            // Multi-pass secure wipe of password char array
            Arrays.fill(this.password, '\0');
            Arrays.fill(this.password, '\uFFFF');
            Arrays.fill(this.password, '\uAAAA');
            Arrays.fill(this.password, '\u5555');
            Arrays.fill(this.password, '\0');
            this.password = null;
        }

    }

    /**
     * Sets the array of web protocols to recognize for URL classification.
     *
     * @param webProtocols array of protocol prefixes (e.g., "http:", "https:")
     */
    public void setWebProtocols(final String[] webProtocols) {
        this.webProtocols = webProtocols;
    }

    /**
     * Sets the array of file protocols to recognize for URL classification.
     *

  }

  public void testCreation_emptyArray() {
    String[] array = new String[0];
    Multiset<String> multiset = ImmutableMultiset.copyOf(array);
    assertTrue(multiset.isEmpty());
  }

  public void testCreation_arrayOfOneElement() {
    String[] array = new String[] {"a"};
    Multiset<String> multiset = ImmutableMultiset.copyOf(array);
    assertEquals(HashMultiset.create(asList("a")), multiset);
  }

            byte[] longFileId = new byte[32];
            Arrays.fill(longFileId, (byte) 0xCD);
            request.setFileId(longFileId);

            Arrays.fill(buffer, (byte) 0);
            bytesWritten = request.writeBytesWireFormat(buffer, 0);

            assertEquals(48, bytesWritten);
            assertArrayEquals(Arrays.copyOfRange(longFileId, 0, 16), Arrays.copyOfRange(buffer, 8, 24));
        }

        @Test

  }

  public void testCreation_emptyArray() {
    String[] array = new String[0];
    Multiset<String> multiset = ImmutableMultiset.copyOf(array);
    assertTrue(multiset.isEmpty());
  }

  public void testCreation_arrayOfOneElement() {
    String[] array = new String[] {"a"};
    Multiset<String> multiset = ImmutableMultiset.copyOf(array);
    assertEquals(HashMultiset.create(asList("a")), multiset);
  }

     *
     * @param values the array of JVM options to filter
     * @return the filtered array of JVM options applicable to the current Java version
     */
    public static String[] filterJvmOptions(final String[] values) {
        final int version = getJavaVersion();
        return Arrays.stream(values).map(s -> {
            final Matcher matcher = VERSION_PREFIX_PATTERN.matcher(s);

      }
    }
  }

  /**
   * Resizes the internal entries array to the specified capacity, which may be greater or less than
   * the current capacity.
   */
  void resizeEntries(int newCapacity) {
    this.entries = Arrays.copyOf(requireEntries(), newCapacity);
    this.keys = Arrays.copyOf(requireKeys(), newCapacity);
    this.values = Arrays.copyOf(requireValues(), newCapacity);
  }

  @CanIgnoreReturnValue

    Object[] array = new Object[12 + others.length];
    array[0] = e1;
    array[1] = e2;
    array[2] = e3;
    array[3] = e4;
    array[4] = e5;
    array[5] = e6;
    array[6] = e7;
    array[7] = e8;
    array[8] = e9;
    array[9] = e10;
    array[10] = e11;
    array[11] = e12;
    System.arraycopy(others, 0, array, 12, others.length);
    return construct(array);

  }

  /** Returns whether arrays need to be allocated. */
  boolean needsAllocArrays() {
    return table == null;
  }

  /** Handle lazy allocation of arrays. */
  @CanIgnoreReturnValue
  int allocArrays() {
    Preconditions.checkState(needsAllocArrays(), "Arrays already allocated");

    int expectedSize = metadata;

  @Override
  public HashCode hashInt(int input) {
    return hashBytes(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(input).array());
  }

  @Override
  public HashCode hashLong(long input) {
    return hashBytes(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(input).array());
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {
    int len = input.length();