import (
	"internal/platform"
	"testing"
)

// TestSupported tests that dist and the main tools agree on
// which build modes are supported for a given target. We do things
// this way because the dist tool needs to be buildable directly by
// the bootstrap compiler, and as such can't import internal packages.
func TestSupported(t *testing.T) {
	defer func(a, o string) {
		goarch = a
		goos = o
	}(goarch, goos)

	var modes = []string{

     * Returns a name for this binary that is unique for all binaries in the current project.
     */
    String getProjectScopedName();

    Class<? extends BinarySpec> getPublicType();

    void setBuildable(boolean buildable);

    BinaryBuildAbility getBuildAbility();

    boolean isLegacyBinary();

    BinaryNamingScheme getNamingScheme();

    void setNamingScheme(BinaryNamingScheme namingScheme);

     *
     * <li>{@link org.gradle.api.tasks.TaskDependency}</li>
     *
     * <li>{@link org.gradle.api.internal.tasks.TaskDependencyContainer}</li>
     *
     * <li>{@link org.gradle.api.Buildable}</li>
     *
     * <li>{@link TransformNodeDependency}</li>
     *
     * <li>{@link WorkNodeAction}</li>
     *
     * </ul>
     */
    void add(Object dependency);

    /**

                assert sampleBinary.buildable
            }
        }
    }
}
'''
        then:
        succeeds "checkModel"
    }

    def "can configure managed binary defined by rule method using rule DSL"() {
        when:
        buildWithCustomBinaryPlugin()

        and:
        buildFile << '''
model {
    tasks {
        checkModel(Task) {

import javax.annotation.concurrent.ThreadSafe;
import java.util.Collection;

/**
 * A build scoped service that collects information on the local "publications" of each project within a build. A "publication" here means some buildable thing that the project produces that can be consumed outside of the project.
 *
 * The information is gathered from multiple sources ({@code publishing.publications} container, etc.).
 */
@ThreadSafe

        }
    }

    @Requires(UnitTestPreconditions.HasXCode)
    @ToBeFixedForConfigurationCache
    def "returns meaningful errors from xcode when component product is unbuildable due to operating system"() {
        useXcodebuildTool()

        given:
        makeSingleProject()
        buildFile << configureTargetMachines("machines.os('os-family')")

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.plugins.jvm;

import org.gradle.api.Action;
import org.gradle.api.Buildable;
import org.gradle.api.ExtensiblePolymorphicDomainObjectContainer;
import org.gradle.api.Incubating;
import org.gradle.api.attributes.TestSuiteType;
import org.gradle.api.provider.Property;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact

import org.gradle.api.Buildable
import org.gradle.api.artifacts.component.ComponentArtifactIdentifier
import org.gradle.api.artifacts.component.ModuleComponentIdentifier
import org.gradle.api.artifacts.component.ProjectComponentIdentifier

        withComponentsForAppAndLib("shared")
    }

    def withComponentsForAppAndLib(String libType) {
        buildFile << app.pluginScript
        buildFile << app.getExtraConfiguration("mainExecutable")
        buildFile << app.getExtraConfiguration("mainLib${libType.capitalize()}Library")
        buildFile << """
            model {
                components {
                    main(NativeExecutableSpec) {

                if (dep.isTestSuite()) {
                    output.withStyle(Info).text(" (t)");
                    seenTestSuite = true;
                }
                if (!dep.isBuildable()) {
                    output.withStyle(Info).text(" NOT BUILDABLE");
                }
            }
        }
    }

    private static class ShowDependentPredicate implements Predicate<RenderableDependency> {