checkNotBinaryCompatibleJava(
            v1 = """
                public class Source {
                    public String foo() { return "bar"; }
                    public String[] baz() { return new String[] {"some"}; }
                }
            """,
            v2 = """
                public class Source {
                    @$nullUnmarkedAnnotationName public String foo() { return "bar"; }

                .singleton("compressorStreamFactory", CompressorStreamFactory.class)
                .singleton("mimeTypeHelper", MimeTypeHelperImpl.class)
                .singleton("tikaExtractor", TikaExtractor.class)
                .singleton("tarExtractor", TarExtractor.class)
                .<ExtractorFactory> singleton("extractorFactory", ExtractorFactory.class, factory -> {

            return when (methodJsonNode.get("name")?.asText()) {
                null -> None
                None::class.simpleName -> None
                TestDistribution::class.simpleName -> TestDistribution
                TestDistributionAlpine::class.simpleName -> TestDistributionAlpine
                TeamCityParallelTests::class.simpleName ->
                    TeamCityParallelTests(

      contentLength = contentLength,
      isSocket = false,
    )
  }

  @Throws(IOException::class)
  fun flushRequest() {
    try {
      codec.flushRequest()
    } catch (e: IOException) {
      call.eventListener.requestFailed(call, e)
      trackFailure(e)
      throw e
    }
  }

  @Throws(IOException::class)
  fun finishRequest() {
    try {
      codec.finishRequest()
    } catch (e: IOException) {

 * retrieve the resource. Although URLs have many schemes (`mailto`, `file`, `ftp`), this class only
 * supports `http` and `https`. Use [java.net.URI][URI] for URLs with arbitrary schemes.
 *
 * ### Username and Password
 *
 * Username and password are either present, or the empty string `""` if absent. This class offers
 * no mechanism to differentiate empty from absent. Neither of these components are popular in

WebSocketErrorModel: type[BaseModel] = create_model("WebSocket")


class FastAPIError(RuntimeError):
    """
    A generic, FastAPI-specific error.
    """


class DependencyScopeError(FastAPIError):
    """
    A dependency declared that it depends on another dependency with an invalid
    (narrower) scope.
    """


class ValidationException(Exception):
    def __init__(
        self,

 * value correctness and array integrity.  A tiny Mockito example
 * demonstrates that the interface can be mocked if another class
 * depends on it.
 */
public class WinErrorTest {

    @Nested
    @DisplayName("Constant value checks")
    class ConstantValues {
        @Test
        void successIsZero() {
            assertEquals(0, WinError.ERROR_SUCCESS, "ERROR_SUCCESS should be 0");
        }

@GwtIncompatible
@J2ktIncompatible
@NullMarked
abstract class DummyProxy {

  /**
   * Returns a new proxy for {@code interfaceType}. Proxies of the same interface are equal to each
   * other if the {@link DummyProxy} instance that created the proxies are equal.
   */
  final <T> T newProxy(TypeToken<T> interfaceType) {
    Set<Class<?>> interfaceClasses = new LinkedHashSet<>();

import org.junit.platform.suite.api.Suite;

/**
 * Test suite for SMB3 Multi-Channel functionality
 */
@Suite
@SelectClasses({ NetworkInterfaceInfoTest.class, ChannelInfoTest.class, ChannelLoadBalancerTest.class, ChannelFailoverTest.class,
        ChannelManagerTest.class })
public class MultiChannelTestSuite {
    // Test suite definition - no additional code needed

 * a single method, the tests simply ensure that the lambda expression
 * correctly implements the method and that any exception is propagated.
 */
class SmbFilenameFilterTest {

    @Test
    void acceptReturnsTrueWhenNameMatches() throws Exception {
        SmbFile dir = Mockito.mock(SmbFile.class);
        SmbFilenameFilter filter = (d, n) -> n.equalsIgnoreCase("hello.txt");
        assertTrue(filter.accept(dir, "Hello.TXT"));
    }