-> TYPE_VALID

    TYPE_DISALLOWED -> TYPE_DISALLOWED

    else -> error("unexpected type: $type")
  }
}

internal infix fun Byte.and(mask: Int): Int = toInt() and mask

internal infix fun Short.and(mask: Int): Int = toInt() and mask

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static com.google.common.base.Strings.isNullOrEmpty;

public class AggregateMultiProjectTaskReportModel implements TaskReportModel {
    private final List<TaskReportModel> projects = new ArrayList<>();
    private SetMultimap<String, TaskDetails> groups;

import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * A configuration-friendly view of a task selection.
 */
class TaskDetailsModel {
    private final String taskPath;
    private final List<TaskDetails> tasks;
    private final TaskSelectionException failure;

    private TaskDetailsModel(String taskPath, List<TaskDetails> tasks) {

        return newAgpRunner(agpVersion, runner(tasks))
    }

    SmokeTestGradleRunner kgpRunner(boolean parallel, VersionNumber kotlinVersion, String... tasks) {
        newKotlinRunner(parallel, kotlinVersion, tasks.toList())
    }

    private SmokeTestGradleRunner newAgpRunner(String agpVersion, SmokeTestGradleRunner runner) {
        def extraArgs = []
        if (AGP_VERSIONS.isAgpNightly(agpVersion)) {

                        // ignore
                        e.printStackTrace();
                    }
                    List<Supplier<Object>> list =
                            res3.stream().map(this::compile).collect(Collectors.toList());
                    //noinspection unchecked
                    return () -> (Q) list(list);
                }
                if (key.getRawType() == Map.class) {

        this.attributes = this.node.getAttributes().entrySet().stream()
                .filter(a -> a.getKey().equals(qname.getName()) || "*".equals(qname.getName()))
                .collect(Collectors.toList());
    }

    public NodePointer getNodePointer() {
        if (position == 0) {
            setPosition(1);
        }
        return (attribute == null) ? null : new Xpp3DomAttributePointer(parent, attribute);

     */
    @JvmField
    val SYSTEM: Dns = DnsSystem()

    private class DnsSystem : Dns {
      override fun lookup(hostname: String): List<InetAddress> {
        try {
          return InetAddress.getAllByName(hostname).toList()
        } catch (e: NullPointerException) {
          throw UnknownHostException("Broken system behaviour for dns lookup of $hostname").apply {
            initCause(e)
          }
        }
      }

            }
        }

        return generateSequence<PsiElement>(candidate) { it.nextSibling }
            .filterIsInstance<KtExpression>()
            .filter { it.textRange in textRange }
            .toList()
    }

        return interceptionRequests.stream()
            .filter(request -> request.getInterceptedCallable().getOwner().isInterceptSubtypes())
            .collect(Collectors.toList());
    }

    @Override
    public GenerationResult generateResourceForRequests(Collection<CallInterceptionRequest> filteredRequests) {
        return new GenerationResult.CanGenerateResource() {
            @Override

            outputLocation = project.file(it.name)
        }
        task.reports = container
        return container
    }

    List<File> getOutputFiles(Task task = task) {
        task.outputs.files.files.toList().sort()
    }

    List<String> getInputPropertyValue() {
        TaskPropertyTestUtils.getProperties(task).keySet().findAll {
            (it.startsWith('reports.enabledReports.'))