),
    )

    classpath = compileKotlinTask.libraries
    modularity.inferModulePath.set(true)

    val javaToolchains = project.extensions.getByType<JavaToolchainService>()
    val javaPluginExtension = project.extensions.getByType<JavaPluginExtension>()
    javaCompiler.set(javaToolchains.compilerFor(javaPluginExtension.toolchain))
  }

    void testType1MessageCreation() {
        // When
        Type1Message type1 = new Type1Message(mockContext);

        // Then
        assertNotNull(type1);
        // Note: getType() method does not exist in Type1Message
        assertTrue(type1.getFlags() != 0); // Should have some flags set
    }

    @Test
    @DisplayName("Should create Type 1 message with custom flags")

            for (ToolchainModel model : toolchains.getToolchains()) {
                if (!groupedToolchains.containsKey(model.getType())) {
                    groupedToolchains.put(model.getType(), new ArrayList<>());
                }

                groupedToolchains.get(model.getType()).add(model);
            }

            request.setToolchains(groupedToolchains);
        }
        return request;
    }

                Field[] fields = FIELDS_BY_CLASS.computeIfAbsent(cls, k -> cls.getDeclaredFields());

                for (Field field : fields) {
                    Class<?> type = field.getType();
                    if (isQualifiedForInterpolation(field, type)) {
                        boolean isAccessible = field.isAccessible();
                        field.setAccessible(true);
                        try {

                return (com.google.inject.Key<U>) com.google.inject.Key.get(key.getType(), Names.named(s));
            } else if (key.getQualifier() instanceof Annotation a) {
                return (com.google.inject.Key<U>) com.google.inject.Key.get(key.getType(), a);
            } else {
                return (com.google.inject.Key<U>) com.google.inject.Key.get(key.getType(), Named.class);
            }
        }

import org.gradle.api.artifacts.VersionCatalogsExtension
import okhttp3.buildsupport.platform
import okhttp3.buildsupport.testJavaVersion

plugins {
  id("okhttp.base-conventions")
}

val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")

fun library(alias: String) = libs.findLibrary(alias).get().get().let {
  "${it.module.group}:${it.module.name}:${it.versionConstraint.requiredVersion}"
}

  private static Type getSupertype(Type type, Class<?> superclass) {
    Class rawType = superclass;
    return TypeToken.of(type).getSupertype(rawType).getType();
  }

  private static Type getSubtype(Type type, Class<?> subclass) {
    return TypeToken.of(type).getSubtype(subclass).getType();
  }

            SmbFile file = new SmbFile("smb1://server/share/file.txt");
            // Without a real connection, getType relies on path parsing.
            // getUncPath0() will result in a path > 1, so it should be TYPE_FILESYSTEM
            assertEquals(SmbFile.TYPE_FILESYSTEM, file.getType());
        }

        @Test
        public void testGetTypeForShare() throws Exception {

    @Test
    @DisplayName("Test ServerInfo1 getType for workgroup")
    void testServerInfo1GetTypeWorkgroup() throws Exception {
        NetServerEnum2Response.ServerInfo1 server = response.new ServerInfo1();
        server.type = 0x80000000; // SV_TYPE_DOMAIN_ENUM flag
        assertEquals(SmbConstants.TYPE_WORKGROUP, server.getType());
    }

    @Test
    @DisplayName("Test ServerInfo1 getType for server")

        this.type = type;
        this.session = session;
        this.mojoExecution = mojoExecution;
        this.exception = exception;
    }

    @Override
    public Type getType() {
        return type;
    }

    @Override
    public MavenSession getSession() {
        return session;
    }

    @Override
    public MavenProject getProject() {