# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

    JAVACMD=$( cygpath --unix "$JAVACMD" )

    # Now convert the arguments - kludge to limit ourselves to /bin/sh
    for arg do
        if

# For Cygwin or MSYS, switch paths to Windows format before running java
if "$cygwin" || "$msys" ; then
    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )

    JAVACMD=$( cygpath --unix "$JAVACMD" )

    # Now convert the arguments - kludge to limit ourselves to /bin/sh
    for arg do
        if

 * limitations under the License.
 */

package org.gradle.api.publish.ivy

class IvyPublishEarIntegTest extends AbstractIvyPublishIntegTest {
    void "can publish EAR only for mixed java and WAR and EAR project"() {
        given:
        file("settings.gradle") << "rootProject.name = 'publishEar' "

        and:
        buildFile << """
            apply plugin: 'java'

	// Single-line declarations
	V5	= T{F1: "hello", /* contains filtered or unexported fields */}
	V6	= T{F1: "hello", /* contains filtered or unexported fields */}
	V7	= T{/* contains filtered or unexported fields */}

	// Mixed-mode declarations
	V8	= T{
		F1:	"hello",
		F3:	"world",
		// contains filtered or unexported fields
	}
	V9	= T{
		F1: "hello",
		// contains filtered or unexported fields
	}
	V10	= T{
		F1:	"hello",

 */

package org.gradle.internal.state;

import org.gradle.internal.DisplayName;

import javax.annotation.Nullable;

/**
 * Represents an object that may be owned by some model object. This is mixed-in to generated classes and may
 * also be implemented directly.
 */
public interface OwnerAware {
    /**
     * Notifies this object that it now has an owner associated with it.
     *

			},
			expected: false,
		},
		{
			name:     "existing cert paths",
			paths:    []string{cert.Name(), cert.Name(), cert.Name()},
			expected: true,
		},
		{
			name:     "mixed non-existing and existing cert paths",
			paths:    []string{cert.Name(), "/this-is-a-nonexisting-path-1", "/this-is-a-nonexisting-path-2"},
			expected: false,
		},
	}
	for _, tt := range tests {

 * limitations under the License.
 */

package org.gradle.internal.state;

import javax.annotation.Nullable;

/**
 * Implemented by types whose state is fully managed by Gradle. Mixed into generated classes whose state is fully managed.
 */
public interface Managed {
    /**

// run

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test Implicit methods for embedded types and
// mixed pointer and non-pointer receivers.

package main

type T int

var nv, np int

func (t T) V() {
	if t != 42 {
		panic(t)
	}
	nv++
}

func (t *T) P() {
	if *t != 42 {
		println(t, *t)

	t[a,]
	t[a, b]
	t[a, b,]
}
type _ struct {
	t [n, /* ERROR "unexpected comma; expecting ]" */ ]byte
}
type _ interface {
	t[a]
	t[a,]
	m[ /* ERROR "method must have no type parameters" */ _ _, /* ERROR mixed */ _]()
	t[a, b]
	t[a, b,]
}

func _[] /* ERROR "empty type parameter list" */ ()
func _[a, b ] /* ERROR "missing type constraint" */ ()
func _[a t, b t, c] /* ERROR "missing type constraint" */ ()

				t.Errorf("pop returns wrong element: want %d, got %d", want, x)
			}
		}
		if !h.empty() {
			t.Errorf("heap is not empty after all pops")
		}
	}

	// Also check that mixed pushes and pops work correctly.
	for _, s := range tests {
		h := heap{}
		for i := 0; i < len(s)/2; i++ {
			// two pushes, one pop
			h.push(s[2*i])
			if !verify(&h, 0) {