* limitations under the License.
 */
package gradlebuild.docs.dsl.docbook.model

class MixinMetaData {
    final String pluginId
    final String mixinClass

    MixinMetaData(String pluginId, String mixinClass) {
        this.pluginId = pluginId
        this.mixinClass = mixinClass
    }

        final Extractor extractor = new Extractor() {
            public ExtractData getText(final InputStream in, final Map<String, String> params) {
                return null;
            }
        };

        assertNull(extractorFactory.getExtractor("test"));
        final List<String> list = new ArrayList<String>();
        list.add("test");
        extractorFactory.addExtractor(list, extractor);

          localPort = 80,
        ),
      )
    val request = RecordedRequest(DEFAULT_REQUEST_LINE_HTTP_1, headers, emptyList(), 0, ByteString.EMPTY, 0, 0, socket)
    assertThat(request.url.toString()).isEqualTo("http://127.0.0.1/")
  }

  @Test fun testAuthorityForm() {
    val socket =
      MockWebServerSocket(
        FakeSocket(

      return new Chopper() {
        @Override
        Optional<String> chop(String str) {
          return i.chop(str).or(you.chop(str));
        }
      };
    }

    abstract Optional<String> chop(String str);

    static Chopper suffix(String suffix) {
      return new Chopper() {
        @Override
        Optional<String> chop(String str) {
          if (str.endsWith(suffix)) {

    private final InternalMavenSession session;

    private final Map<String, Path> paths = new ConcurrentHashMap<>();

    @Inject
    public DefaultArtifactManager(@Nonnull InternalMavenSession session) {
        this.session = session;
    }

    @Nonnull
    @Override
    public Optional<Path> getPath(@Nonnull Artifact artifact) {
        String id = id(requireNonNull(artifact, "artifact cannot be null"));

     * Creates the mapping of deprecated phase names to their Maven 4 equivalents.
     * Uses Maven API constants to ensure consistency with the lifecycle definitions.
     */
    private Map<String, String> createPhaseUpgradeMap() {
        Map<String, String> phaseUpgrades = new HashMap<>();

        // Clean lifecycle aliases
        phaseUpgrades.put("pre-clean", Lifecycle.BEFORE + Lifecycle.Phase.CLEAN);

			required: []string{"A", "B", "C"},
			ok:       true,
			out:      "",
		},
		{
			name:     "feature added",
			features: []string{"A", "B", "C", "D", "E", "F"},
			required: []string{"B", "D"},
			ok:       false,
			out:      "+A\n+C\n+E\n+F\n",
		},
		{
			name:     "feature removed",
			features: []string{"C", "A"},
			required: []string{"A", "B", "C"},
			ok:       false,

                            "pattern": "^password$",
                            "type": "string",
                        },
                        "username": {"title": "Username", "type": "string"},
                        "password": {"title": "Password", "type": "string"},
                        "scope": {"title": "Scope", "type": "string", "default": ""},
                        "client_id": {

 */
@Deprecated(since = "4.0.0")
public interface WorkspaceModelResolver {

    Model resolveRawModel(String groupId, String artifactId, String versionConstraint)
            throws UnresolvableModelException;

    Model resolveEffectiveModel(String groupId, String artifactId, String versionConstraint)
            throws UnresolvableModelException;

package common

enum class Arch(
    val suffix: String,
    val nameOnLinuxWindows: String,
    val nameOnMac: String,
) {
    AMD64("64bit", "amd64", "x86_64"),
    AARCH64("aarch64", "aarch64", "aarch64"),
    ;

    fun asName() = name.lowercase().toCapitalized()
}

enum class Os(
    val agentRequirement: String,
    val androidHome: String,
    val jprofilerHome: String,