try {
            final Method method = UriType.class.getMethod("protocolType");
            assertNotNull(method, "protocolType method should exist");
            assertNull(method.getDefaultValue(), "protocolType should not have default value");
        } catch (final NoSuchMethodException e) {
            fail("protocolType method should exist");
        }
    }

import org.jspecify.annotations.Nullable;

/**
 * Static convenience methods that help a method or constructor check whether it was invoked
 * correctly (that is, whether its <i>preconditions</i> were met).
 *
 * <p>If the precondition is not met, the {@code Preconditions} method throws an unchecked exception
 * of a specified type, which helps the method in which the exception was thrown communicate that

    for (Method method : testMethods) {
      suite.addTest(new CharSourceTester(factory, string, name, desc, method));
    }
    return suite;
  }

  private final ImmutableList<String> expectedLines;

  private CharSource source;

  public CharSourceTester(
      CharSourceFactory factory, String string, String suiteName, String caseDesc, Method method) {

        }

        // Verify that the scroll method exists with correct signature
        try {
            SearchEngineUtil.class.getMethod("scroll", String.class, java.util.function.Function.class);
        } catch (NoSuchMethodException e) {
            fail("scroll method should exist with correct signature");
        }
    }

    @Test

}
```

## 🏗️ Architecture & Design Patterns

### Core Design Principles
CoreLib follows a **utility-class pattern** where most functionality is exposed through static methods:

- **Assertion-based validation** - All methods validate inputs using `AssertionUtil.assertArgumentNotNull()` and `AssertionUtil.assertArgumentNotEmpty()`

    open fun query(body: RequestBody): Builder = method("QUERY", body)

    open fun method(
      method: String,
      body: RequestBody?,
    ): Builder =
      apply {
        require(method.isNotEmpty()) {
          "method.isEmpty() == true"
        }
        if (body == null) {
          require(!HttpMethod.requiresRequestBody(method)) {
            "method $method must have a request body."
          }

 *
 * <p>Performance note: Even though the {@code ComparisonChain} caller always invokes its {@code
 * compare} methods unconditionally, the {@code ComparisonChain} implementation stops calling its
 * inputs' {@link Comparable#compareTo compareTo} and {@link Comparator#compare compare} methods as
 * soon as one of them returns a nonzero result. This optimization is typically important only in

      String name, CharSinkFactory factory, String string, String desc) {
    TestSuite stringSuite = new TestSuite(name + " [" + desc + "]");
    for (Method method : testMethods) {
      stringSuite.addTest(new CharSinkTester(factory, string, name, desc, method));
    }
    return stringSuite;
  }

  private final ImmutableList<String> lines;
  private final ImmutableList<String> expectedLines;

   * containing one element (the given set itself).
   *
   * <p>Despite the method name, this method attempts to avoid actually copying the data when it is
   * safe to do so. The exact circumstances under which a copy will or will not be performed are
   * undocumented and subject to change.
   *
   * <p>This method is not type-safe, as it may be called on elements that are not mutually
   * comparable.
   *

                        return false;
                    }
                })
                .map(Method::getName)
                .toList();

        List<String> overriddenMethods = Stream.of(FileToRawModelMerger.class.getDeclaredMethods())
                .map(Method::getName)
                .filter(m -> m.startsWith("merge"))
                .collect(Collectors.toList());

        assertTrue(