"project.description = java.lang.management.ManagementFactory.runtimeMXBean.inputArguments.join('##')"

        when:
        BuildEnvironment env = withConnection { it.getModel(BuildEnvironment.class) }
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        def inputArgsInBuild = project.description.split('##') as List
        env.java.jvmArguments.each { inputArgsInBuild.contains(it) }

        pluginProject.getModel().setParent(createParent(parentProject));
        projects.add(pluginProject);

        Plugin plugin = createPlugin(pluginProject);

        plugin.addDependency(createDependency(pluginLevelDepProject));

        Build build = declaringProject.getModel().getBuild();

        build.addPlugin(plugin);

        declaringProject.getModel().setBuild(build);

class FetchProjectsCustomModelsAction implements BuildAction<Void> {

    @Override
    Void execute(BuildController controller) {
        def projects = controller.getModel(GradleBuild).projects
        projects.forEach { project ->
            controller.getModel(project, CustomModel)
        }

        return null
    }

            connection.getModel(ProjectPublications)
        }

        then:
        publications.publications.empty
    }

    def "project without any configured publications"() {
        buildFile << "apply plugin: 'java'"

        when:
        ProjectPublications publications = withConnection { connection ->
            connection.getModel(ProjectPublications)
        }

        then:

        }

        Properties thisProvides = this.getModel().getProvides();
        Properties otherProvides = other.getModel().getProvides();

        return Objects.equals(thisProvides, otherProvides);
    }

    @Override
    public int hashCode() {
        int hashCode = (type == null) ? 0 : type.hashCode();

        if (this.getModel().getProvides() != null) {

    @Override
    public GradleProject execute(BuildController controller) {
        GradleBuild buildModel = controller.getModel(GradleBuild.class);
        for (GradleBuild build : buildModel.getEditableBuilds()) {
            if (build.getBuildIdentifier().getRootDir().getName().equals("buildSrc")) {
                return controller.getModel(build, GradleProject.class);
            }
        }
        return null;
    }

    @Override
    public GradleProject execute(BuildController controller) {
        GradleBuild buildModel = controller.getModel(GradleBuild.class);
        for (GradleBuild build : buildModel.getEditableBuilds()) {
            if (build.getBuildIdentifier().getRootDir().getName().equals("buildSrc")) {
                return controller.getModel(build.getRootProject(), GradleProject.class);
            }
        }
        return null;
    }

        List<GradleBuild> result = new ArrayList<GradleBuild>();
        GradleBuild build = controller.getBuildModel();
        result.add(controller.getModel(build, GradleBuild.class));
        for (GradleBuild includedBuild : build.getIncludedBuilds()) {
            result.add(controller.getModel(includedBuild, GradleBuild.class));
        }
        return result;
    }

    @Override
    public List<CustomModel> execute(BuildController controller) {
        List<CustomModel> result = new LinkedList<CustomModel>();
        final CustomModel model0 = controller.getModel(CustomModel.class);
        final CustomModel model1 = controller.getModel(CustomModel.class, CustomParameter.class, new Action<CustomParameter>() {
            @Override
            public void execute(CustomParameter customParameter) {

    @Override
    public <T, P> T getModel(Model target, Class<T> modelType, Class<P> parameterType, Action<? super P> parameterInitializer) throws UnsupportedVersionException {
        if (parameterType != null) {
            throw new UnsupportedVersionException(String.format("Gradle version %s does not support parameterized tooling models.", gradleVersion.getVersion()));
        }