expect:
        loadBuildEnvironment { builder -> builder.addJvmArguments() }
    }

    def "Adding null JVM argument throws NPE"() {
        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as String) }

        then:
        thrown(NullPointerException)

        when:
        loadBuildEnvironment { builder -> builder.addJvmArguments(null as List) }

        then:

#include "tensorflow/core/lib/core/errors.h"

namespace tensorflow {

using mlir::Builder;
using mlir::ShapedType;
using mlir::Type;

Status ConvertDataType(DataType dtype, Builder builder, Type* type) {
  switch (dtype) {
    case DT_HALF:
      *type = builder.getF16Type();
      return absl::OkStatus();
    case DT_FLOAT:
      *type = builder.getF32Type();
      return absl::OkStatus();
    case DT_DOUBLE:

    }

    private void visitEntries(ClasspathBuilder.EntryBuilder builder) throws IOException, FileException {
        classpathWalker.visit(source, entry -> {
            visitEntry(builder, entry);
        });
        finishProcessing(builder);
    }

    private void visitEntry(ClasspathBuilder.EntryBuilder builder, ClasspathEntryVisitor.Entry entry) throws IOException {
        try {

	tcpFilters  []*listener.Filter
	builder     *builder.Builder
}

func NewBuilder(actionType ActionType, push *model.PushContext, proxy *model.Proxy, useFilterState bool) *Builder {
	return NewBuilderForService(actionType, push, proxy, useFilterState, nil)
}

func NewBuilderForService(actionType ActionType, push *model.PushContext, proxy *model.Proxy, useFilterState bool, svc *model.Service) *Builder {

                        part.typeArgumentList.typeArguments.map { builder.typeBuilder.buildTypeProjection(it.toConeTypeProjection()) },
                        builder.token
                    )
                }

            is ConeUnresolvedNameError -> listOf(
                KaClassTypeQualifier.KaUnresolvedClassTypeQualifier(coneDiagnostic.name, emptyList(), builder.token)
            )

            models.add(model)
            finished.countDown()
        } as ResultHandler

        withConnection {
            def builder = it.action(new ModelStreamingBuildAction())
            collectOutputs(builder)
            builder.setStreamedValueListener(listener)
            builder.run(handler)
            finished.await()
        }

        then:
        models.size() == 3

        and:

    public String getPrompt() {
        StringBuilder builder = new StringBuilder();
        builder.append(question);
        builder.append(":");
        builder.append(TextUtil.getPlatformLineSeparator());
        for (int i = 0; i < options.size(); i++) {
            builder.append("  ");
            builder.append(i + 1);
            builder.append(": ");
            builder.append(options.get(i));

        try (OutputStream out = SearchEngineUtil.getXContentBuilderOutputStream((builder, params) -> {
            builder.startObject();
            if (fieldSet.contains(CLUSTER_NAME)) {
                builder.field(CLUSTER_NAME, response.getClusterName());
            }
            if (fieldSet.contains(STATUS)) {
                builder.field(STATUS, response.getStatus().name().toLowerCase(Locale.ROOT));
            }

internal fun FirClassSymbol<*>.superTypesList(builder: KaSymbolByFirBuilder): List<KaType> = resolvedSuperTypeRefs.mapToKtType(builder)

private fun List<FirTypeRef>.mapToKtType(
    builder: KaSymbolByFirBuilder,
): List<KaType> = map { typeRef ->
    builder.typeBuilder.buildKtType(typeRef)
}

internal fun FirCallableSymbol<*>.returnType(builder: KaSymbolByFirBuilder): KaType =
    builder.typeBuilder.buildKtType(resolvedReturnType)

internal fun FirCallableSymbol<*>.createContextReceivers(
    builder: KaSymbolByFirBuilder
): List<KaContextReceiver> {
    return resolvedContextReceivers.map { createContextReceiver(builder, it) }
}

internal fun FirRegularClassSymbol.createContextReceivers(
    builder: KaSymbolByFirBuilder
): List<KaContextReceiver> {
    return resolvedContextReceivers.map { createContextReceiver(builder, it) }
}

private fun createContextReceiver(