this.type = type;
        this.value = value;
    }

    @Override
    public T execute(BuildController controller) {
        controller.send(new CustomModel(value));
        return controller.getModel(type);
    }

    }

    def "Eclipse model respects composite build substitutions in root build"() {
        given:
        compositeIncludedRoot()

        when:
        def model = withConnection {
            getModel(HierarchicalEclipseProject)
        }

        then:
        model.children[1].projectDependencies.size() == 1
        model.children[1].projectDependencies[0].path == 'sub-a'
    }

	}

	// At this point, we should have wasmNetworkFilterConfig or wasmHTTPFilterConfig should be unmarshalled.
	if wasmNetwork {
		if wasmNetworkFilterConfig.Config.GetVmConfig().GetCode().GetRemote() == nil {
			if wasmNetworkFilterConfig.Config.GetVmConfig().GetCode().GetLocal() == nil {
				return nil, nil, nil, fmt.Errorf("no remote and local load found in Wasm Network filter %+v", wasmNetworkFilterConfig)
			}

	if kubeClient == nil {
		return nil
	}

	logger := klog.FromContext(ctx)
	logger = klog.LoggerWithName(logger, "node resources controller")
	ctx = klog.NewContext(ctx, logger)

	c := &nodeResourcesController{
		ctx:        ctx,
		kubeClient: kubeClient,
		getNode:    getNode,

    public NativePlatformBackedStat(PosixFiles posixFiles) {
        this.posixFiles = posixFiles;
    }

    @Override
    public int getUnixMode(File f) {
        return posixFiles.getMode(f, true);
    }

                ${javaSourceCompatibility(targetVersion, JavaVersion.VERSION_1_5)}
            }

        """

        when:
        def ideaProject = withConnection { connection -> connection.getModel(IdeaProject) }

        then:
        ideaProject.javaLanguageSettings.languageLevel == JavaVersion.VERSION_1_7
        ideaProject.modules.find { it.name == 'root' }.javaLanguageSettings == null

		err = fakeAssignQuota(testcase.path, testcase.poduid, testcase.bytes)
	case "Clear":
		err = fakeClearQuota(testcase.path)
	case "GetConsumption":
		_, err = GetConsumption(testcase.path)
	case "GetInodes":
		_, err = GetInodes(testcase.path)
	default:
		t.Errorf("Case %v (%s, %s, %v) unknown operation %s", seq, testcase.name, testcase.path, true, testcase.op)
		return true
	}
	if err != nil && testcase.expectsSetQuota {

        rootProject.name = "root"
        include 'api', 'impl', 'contrib:api', 'contrib:impl'"""

        when:

        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }

        then:
        def allNames = project.modules*.name
        allNames.unique().size() == 6

        IdeaModule impl = project.modules.find { it.name == 'root-impl' }

    }

    @Override
    public FileLock lock(File target, LockOptions options, String targetDisplayName, String operationDisplayName, @Nullable Consumer<FileLockReleasedSignal> whenContended) {
        if (options.getMode() == LockMode.OnDemand) {
            throw new UnsupportedOperationException(String.format("No %s mode lock implementation available.", options));
        }
        File canonicalTarget;
        try {

            }
        } catch (InternalBuildActionFailureException e) {
            throw new BuildActionFailureException("The supplied build action failed with an exception.", e.getCause());
        }
        return result.getModel();
    }

    @SuppressWarnings("deprecation")
    protected <T> BuildResult<T> execute(InternalBuildActionAdapter<T> buildActionAdapter, InternalCancellationToken cancellationTokenAdapter, BuildParameters operationParameters) {