import org.gradle.tooling.BuildController;

public class InvalidModel2Action implements BuildAction<CustomModel2> {
    @Override
    public CustomModel2 execute(BuildController controller) {
        return controller.getModel(CustomModel2.class, CustomParameter.class, new Action<CustomParameter>() {
            @Override
            public void execute(CustomParameter customParameter) {}
        });
    }

// GetSELinuxSupport always returns an error on unsupported platforms
func (hu *HostUtil) GetSELinuxSupport(pathname string) (bool, error) {
	return false, errUnsupported
}

// GetMode always returns an error on unsupported platforms
func (hu *HostUtil) GetMode(pathname string) (os.FileMode, error) {
	return 0, errUnsupported
}

func getDeviceNameFromMount(mounter mount.Interface, mountPath, pluginMountDir string) (string, error) {

                        .getCanonicalPath());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }

            project.getModel().addDependency(dependency);
        }

        @Override
        public void afterSessionStart(MavenSession session) {
            session.getUserProperties().setProperty("injected", "bar");
        }
    }

        }

        dependencies {
            implementation(localGroovy())
        }
        """

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

        then:
        def ideaModule = ideaProject.modules.find { it.name == 'root' }
        def dependency = ideaModule.dependencies.find { it.file.name.contains("groovy-") }

 */
public enum Destination implements Serializable {

    StdOut(0),
    StdErr(1);

    private final int code;

     Destination(int code) {
        this.code = code;
    }

    public int getCode() {
        return code;
    }

    public static Destination fromCode(int code) {
        for (Destination d : Destination.values()) {
            if (d.code == code) {
                 return d;
            }

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

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

import org.gradle.tooling.BuildController;
import org.gradle.tooling.model.GradleProject;

public class HangingBuildAction implements BuildAction<Void> {
    public Void execute(BuildController controller) {
        controller.getModel(GradleProject.class);
        throw new GradleException("Should be cancelled before the end of action.");
    }

    @Override
    public ProjectPublications execute(BuildController controller) {
        GradleBuild buildModel = controller.getBuildModel();
        return controller.getModel(buildModel.getRootProject(), ProjectPublications.class);
    }

        ProjectConnection connection = connector.connect();
        try {
            // Load the custom model for the project
            CustomModel model = connection.getModel(CustomModel.class);
            System.out.println("Project: " + model.getName());
            System.out.println("Tasks: ");
            for (String task : model.getTasks()) {
                System.out.println("   " + task);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache;

public interface LockOptions {

    FileLockManager.LockMode getMode();

    boolean isUseCrossVersionImplementation();

    /**
     * Creates a copy of this options instance using the given mode.
     *
     * @param mode the mode to overwrite the current mode with
     */