@CanIgnoreReturnValue
  public final <A extends Appendable> A appendTo(
      A appendable, @Nullable Object first, @Nullable Object second, @Nullable Object... rest)
      throws IOException {
    return appendTo(appendable, iterable(first, second, rest));
  }

  /**
   * Appends the string representation of each of {@code parts}, using the previously configured

        bb.getInt();

        // LinkSpeed (8 bytes) - in bits per second
        long linkSpeedBps = bb.getLong();

        // Parse sockaddr structure (starts at offset + 24)
        InetAddress addr = parseSockaddr(data, offset + 24);

        if (addr == null) {
            return null;
        }

        // Convert bits per second to Mbps for internal use

    }

    @Test
    @DisplayName("Iterator with rejecting filter - finds next acceptable")
    void iteratorWithRejectingFilter() throws Exception {
        // Setup: first entry rejected, second accepted
        FileEntry entry1 = mock(FileEntry.class);
        FileEntry entry2 = mock(FileEntry.class);

        when(delegate.hasNext()).thenReturn(true, true, false);

        // Second call - should use cache
        long start2 = System.nanoTime();
        helper.setProperty(bean2, "name", String.class, config);
        long time2 = System.nanoTime() - start2;

        assertEquals("testValue", bean1.getName());
        assertEquals("testValue", bean2.getName());

        // Second call should be faster (though this is not guaranteed in all environments)

     */
    protected ObjectUtil() {
    }

    /**
     * Returns true if the two objects are equal, or both are null.
     *
     * @param object1 the first object
     * @param object2 the second object
     * @return true if equal or both null, false otherwise
     */
    public static boolean equals(final Object object1, final Object object2) {
        if (object1 == object2) {
            return true;
        }

     * </p>
     *
     * @param <T>
     *            the type of the array elements
     * @param a
     *            first array
     * @param b
     *            second array
     * @return the concatenated result array
     */
    public static <T> T[] addAll(final T[] a, final T[] b) {
        if (a == null) {
            return b;
        }
        if (b == null) {

   * @param first the first element
   * @param second the second element
   * @param rest an array of additional elements, possibly empty
   * @return an unmodifiable list containing the specified elements
   */
  public static <E extends @Nullable Object> List<E> asList(
      @ParametricNullness E first, @ParametricNullness E second, E[] rest) {
    return new TwoPlusArrayList<>(first, second, rest);
  }

  /**

            DfsReferralDataImpl second = createInitializedDfsReferralDataImpl();
            DfsReferralDataImpl third = createInitializedDfsReferralDataImpl();

            // Build chain
            first.append(second);
            first.append(third);

            // Verify chain
            assertEquals(third, first.next());
            assertEquals(second, third.next());

    builder.addEscape(' ', "-");
    builder.addEscape('!', "$");
    Escaper second = builder.build();
    // This should have no effect on existing escapers.
    builder.addEscape(' ', "*");

    // Test both escapers after modifying the builder.
    assertThat(first.escape("The Quick Brown Fox!")).isEqualTo("Xhe_Xuick_Xrown_XoxX");
    assertThat(second.escape("The Quick Brown Fox!")).isEqualTo("Xhe-Xuick-Xrown-Xox$");
  }

          serialNumber = it[1] as BigInteger,
          signature = it[2] as AlgorithmIdentifier,
          issuer = (it[3] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          validity = it[4] as Validity,
          subject = (it[5] as Pair<*, *>).second as List<List<AttributeTypeAndValue>>,
          subjectPublicKeyInfo = it[6] as SubjectPublicKeyInfo,
          issuerUniqueID = it[7] as BitString?,