* methods were introduced</a>. For newer methods, like {@code forEachRemaining}, it inherits their
 * default implementations. When those implementations invoke methods, they invoke methods on the
 * {@code ForwardingIterator}.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@GwtCompatible
public abstract class ForwardingIterator<T extends @Nullable Object> extends ForwardingObject

 * <li>{@link ThreadSafe}: Implies that implementations of this interface must
 * be safe to invoke from multiple threads concurrently.</li>
 * </ul>
 *
 * @since 4.0.0
 */
@Experimental
@FunctionalInterface
@Consumer
@ThreadSafe
public interface Mojo {
    /**
     * Executes the behavior defined by this {@code Mojo}. This method is invoked
     * during the Maven build lifecycle to perform the Mojo's designated task.
     *

            Method makePipeUrlMethod = DcerpcPipeHandle.class.getDeclaredMethod("makePipeUrl");
            makePipeUrlMethod.setAccessible(true);
            String result = (String) makePipeUrlMethod.invoke(handle);

            assertEquals("smb://server/IPC$/test", result);
        }

        @Test
        @DisplayName("Should generate correct pipe URL with server option")

        method.setAccessible(true);
        return (int) method.invoke(response);
    }

    private void setNumEntries(NetShareEnumResponse response, int value) throws Exception {
        Method method = getSuperclassMethod(response.getClass(), "setNumEntries", int.class);
        method.setAccessible(true);
        method.invoke(response, value);
    }

 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingDeque}.
 *
 * <p>The {@code standard} methods are not guaranteed to be thread-safe, even when all of the
 * methods that they depend on are thread-safe.
 *

            // Then
            assertTrue(Modifier.isProtected(method.getModifiers()));
            method.setAccessible(true); // Required to invoke protected method
            assertEquals(443, method.invoke(testHandler));
        }

        @Test
        @DisplayName("Should maintain inheritance hierarchy")
        void testInheritanceHierarchy() {
            // When

        .dispatcher(Dispatcher(newVirtualThreadPerTaskExecutor()))
        .build()
  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService =
    Executors::class.java.getMethod("newVirtualThreadPerTaskExecutor").invoke(null) as ExecutorService

  @Test
  fun testRequest() {
    server.enqueue(MockResponse())

    val request = Request(server.url("/"))

    client.newCall(request).execute().use {

                method.setAccessible(true);
                byte[] targetInfo = (byte[]) method.invoke(null, mockContext, null);

                assertNotNull(targetInfo);
                assertEquals(4, targetInfo.length); // Only the 4-byte terminator
            } catch (Exception e) {
                fail("Failed to invoke makeTargetInfo via reflection: " + e.getMessage());
            }
        }
    }

 * pattern</a>.
 *
 * <p><b>{@code default} method warning:</b> This class does <i>not</i> forward calls to {@code
 * default} methods. Instead, it inherits their default implementations. When those implementations
 * invoke methods, they invoke methods on the {@code ForwardingBlockingQueue}.
 *
 * @author Raimundo Mirisola
 * @param <E> the type of elements held in this collection
 * @since 4.0
 */
@J2ktIncompatible
@GwtIncompatible

        method.setAccessible(true);
        return (int) method.invoke(response);
    }

    private void setNumEntries(NetServerEnum2Response response, int value) throws Exception {
        Method method = getSuperclassMethod(response.getClass(), "setNumEntries", int.class);
        method.setAccessible(true);
        method.invoke(response, value);
    }