import org.gradle.test.fixtures.AbstractProjectBuilderSpec
import org.gradle.util.TestUtil

import static org.gradle.api.tasks.TaskDependencyMatchers.dependsOn

class WarPluginTest extends AbstractProjectBuilderSpec {
    def "applies Java plugin and adds convention"() {
        when:
        project.pluginManager.apply(WarPlugin)

        then:
        project.getPlugins().hasPlugin(JavaPlugin)

)

// volumeAttachmentStrategy implements behavior for VolumeAttachment objects
type volumeAttachmentStrategy struct {
	runtime.ObjectTyper
	names.NameGenerator
}

// Strategy is the default logic that applies when creating and updating
// VolumeAttachment objects via the REST API.
var Strategy = volumeAttachmentStrategy{legacyscheme.Scheme, names.SimpleNameGenerator}

func (volumeAttachmentStrategy) NamespaceScoped() bool {

import _ "unsafe"

// When using cgo, call the C library for mmap, so that we call into
// any sanitizer interceptors. This supports using the memory
// sanitizer with Go programs. The memory sanitizer only applies to
// C/C++ code; this permits that code to see the Go code as normal
// program addresses that have been initialized.

// To support interceptors that look for both mmap and munmap,
// also call the C library for munmap.

public interface TargetPlatformConfiguration {
    /**
     * Returns whether a platform is supported or not.
     */
    boolean supportsPlatform(NativePlatformInternal targetPlatform);

    /**
     *  applies a platform specific toolchain configuration
     */
    void apply(DefaultGccPlatformToolChain platformToolChain);

 * limitations under the License.
 */
package org.gradle.plugins.ide.eclipse.model;

/**
 * Specifies the type of resource that the Eclipse {@link ResourceFilter} applies to.
 *
 * @since 3.5
 */
public enum ResourceFilterAppliesTo {
    FILES,
    FOLDERS,
    FILES_AND_FOLDERS;

[!GOOS:windows] [short] stop 'this test only applies to Windows'
env GO111MODULE=off

go build run_go.go
exec ./run_go$GOEXE $GOPATH $GOPATH/src/vend/hello
stdout 'hello, world'

-- run_go.go --
package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

func changeVolume(s string, f func(s string) string) string {
	vol := filepath.VolumeName(s)
	return f(vol) + s[len(vol):]
}

func main() {

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

package util

// IsExportToAllNamespaces returns true if export to applies to all namespaces
// and false if it is set to namespace local.
func IsExportToAllNamespaces(exportTos []string) bool {
	exportedToAll := false
	for _, e := range exportTos {
		if e == ExportToAllNamespaces {

     * <p>
     * For further details on permissions see {@link ConfigurableUserClassFilePermissions}.
     * <p>
     * Note that the provided configuration action only applies incremental modifications on top of whatever permission
     * the user has at the moment and that the default values permissions start out are different for files and directories
     * (see {@link UserClassFilePermissions}).

//
// The unsafeptr analyzer reports likely incorrect uses of unsafe.Pointer
// to convert integers to pointers. A conversion from uintptr to
// unsafe.Pointer is invalid if it implies that there is a uintptr-typed
// word in memory that holds a pointer value, because that word will be
// invisible to stack copying and to the garbage collector.

	// Zero the permutation's state.
	for i := range d.a {
		d.a[i] = 0
	}
	d.state = spongeAbsorbing
	d.i, d.n = 0, 0
}

func (d *state) clone() *state {
	ret := *d
	return &ret
}

// permute applies the KeccakF-1600 permutation. It handles
// any input-output buffering.
func (d *state) permute() {
	switch d.state {
	case spongeAbsorbing:
		// If we're absorbing, we need to xor the input into the state