*/

package org.gradle.nativeplatform.toolchain;

import org.gradle.internal.HasInternalProtocol;
import org.gradle.platform.base.ToolChain;

/**
 * A set of compilers and linkers that are used together to construct a native binary.
 */
@HasInternalProtocol
public interface NativeToolChain extends ToolChain {

 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Named;
import org.gradle.internal.HasInternalProtocol;

/**
 * A set of compilers that are used together to construct binaries.
 */
@HasInternalProtocol
public interface ToolChain extends Named {
    /**
     * Returns a human consumable name for this tool chain.
     *
     * @since 1.11
     */

     * * A directory with a set of .classfiles for JVM Libraries
     * * A Kotlin/Native, Kotlin/Common, Kotlin/JS KLib.
     * In this case, all KLib dependencies should be provided together with the KLib itself.
     */
    public fun addBinaryRoot(root: Path) {
        binaryRoots.add(root)
    }

    /**
     * Adds a collection of [roots] to the current library.
     *

import org.gradle.api.Incubating;
import org.gradle.platform.base.ComponentSpec;
import org.gradle.platform.base.GeneralComponentSpec;

/**
 * A component representing a suite of tests that will be built and executed together.
 */
@Incubating
public interface TestSuiteSpec extends GeneralComponentSpec {
    /**
     * The tested component.
     */
    ComponentSpec getTestedComponent();

    /**

package org.gradle.model.internal.core;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Applied together with {@link org.gradle.model.Model} annotation the registered model element
 * will not be shown in reports.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Hidden {

//     dependencies of the application and its plugins are built from
//     exactly the same source code.
//
//   - Together, these restrictions mean that, in practice, the
//     application and its plugins must all be built together by a
//     single person or component of a system. In that case, it may
//     be simpler for that person or component to generate Go source

import org.gradle.language.nativeplatform.DependentSourceSet;
import org.gradle.language.nativeplatform.HeaderExportingSourceSet;

/**
 * A set of C source files.
 *
 * <p>A C source set contains a set of source files, together with an optional set of exported header files.</p>
 *
 * <pre class='autoTested'>
 * plugins {
 *     id 'c'
 * }
 *
 * model {
 *     components {
 *         main(NativeLibrarySpec) {

// tag::use[]
// Iterate over the contents of a tree
tree.each {File file ->
    println file
}

// Filter a tree
FileTree filtered = tree.matching {
    include 'org/gradle/api/**'
}

// Add trees together
FileTree sum = tree + fileTree(dir: 'src/test')

// Visit the elements of the tree
tree.visit {element ->
    println "$element.relativePath => $element.file"
}
// end::use[]

// tag::archive-trees[]

    // The jacoco plugin does not add tasks to an empty project.
    // We apply the java plugin too here in this test to check that
    // the jacoco plugin behaves well when used together
    // with the java plugin (a typical scenario).

    def setup(){
        buildFile << """
            apply plugin:'java'
        """
    }

    /**
     * Returns all schemas that are implemented by this struct. These schemas include the public view schema, any internal view schemas specified
     * when declaring the struct, together with all their super-type schemas. This is an exhaustive list of every type a node can be
     * viewed as. In other words this is the full list of interfaces that a view proxy class generated for this struct type might implement.