import "p"

type _ = int
type a = struct{ x int }
type b = p.B

type (
	_ = chan<- int
	aa = interface{}
	bb = p.BB
)

// TODO(gri) We may want to put the '=' into a separate column if
// we have mixed (regular and alias) type declarations in a group.
type (
	_ chan<- int
	_ = chan<- int
	aa0 interface{}
	aaa = interface{}
	bb0 p.BB
	bbb = p.BB

    rev: v4.4.0
    hooks:
    -   id: check-added-large-files
    -   id: check-toml
    -   id: check-yaml
        args:
        -   --unsafe
    -   id: end-of-file-fixer
    -   id: trailing-whitespace
-   repo: https://github.com/charliermarsh/ruff-pre-commit
    rev: v0.2.0
    hooks:
    -   id: ruff
        args:
        - --fix
    -   id: ruff-format
ci:

			b: "hidden",
		},
		f3: T2{
			A: "world",
		},
	}
	V4 = T{
		f2: 1,
	}

	// Single-line declarations
	V5 = T{F1: "hello", f2: 1}
	V6 = T{f2: 1, F1: "hello"}
	V7 = T{f2: 1}

	// Mixed-mode declarations
	V8 = T{
		F1: "hello", f2: 1,
		F3: "world",
		f4: 2}
	V9 = T{
	f2: 1, F1: "hello",}
	V10 = T{
		F1: "hello", f2: 1,
		f3: 2,
		F4: "world", f5: 3,
	}

# This configs KinD to spin up a k8s cluster with mixed protocol LB support and GRPCContainerProbe enabled
# This should be used to create K8s clusters with versions >= 1.23
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
kubeadmConfigPatches:
  - |
    apiVersion: kubeadm.k8s.io/v1beta3
    kind: ClusterConfiguration
    metadata:
      name: config
    etcd:
      local:
        # Run etcd in a tmpfs (in RAM) for performance improvements

[short] skip

go test flag_test.go -v -args -v=7 # Two distinct -v flags
go test -v flag_test.go -args -v=7 # Two distinct -v flags

# Using a custom flag mixed with regular 'go test' flags should be OK.
go test -count=1 -custom -args -v=7

# However, it should be an error to use custom flags when -c is used,
# since we know for sure that no test binary will run at all.
! go test -c -custom
stderr '^go: unknown flag -custom cannot be used with -c$'

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

package org.gradle.internal.classloader;

import org.gradle.internal.hash.HashCode;

/**
 * Mixed into a ClassLoader implementation to allow the implementation hash of a  ClassLoader to be queried
 */
public interface ImplementationHashAware {
    HashCode getImplementationHash();

# 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" )
<% if ( mainClassName.startsWith('--module ') ) { %>    MODULE_PATH=\$( cygpath --path --mixed "\$MODULE_PATH" )<% } %>
    JAVACMD=\$( cygpath --unix "\$JAVACMD" )

    # Now convert the arguments - kludge to limit ourselves to /bin/sh

		// Compare if service has mixed mode like headless and clusterIP
		if !addedHeadless && (firstService.ClusterIP == corev1.ClusterIPNone) != (service.ClusterIP == corev1.ClusterIPNone) {
			addedHeadless = true
			for c := range services {
				inconsistentClusters.Insert(c.String())
			}
			inconsistentReasons.Insert("service has mixed mode like headless and clusterIP")
		}

package org.gradle.internal.state;

import org.gradle.api.Describable;
import org.gradle.api.Task;

import javax.annotation.Nullable;

/**
 * An object that represents some part of a model. This interface is mixed-in to all generated classes and should
 * not be implemented directly.
 */
public interface ModelObject {
    /**
     * Returns the display name of this object that indicates its identity, if this is known.
     */

 * limitations under the License.
 */

package org.gradle.tooling.provider.model.internal;

import java.lang.annotation.*;

/**
 * Indicates that a given marker interface should be mixed in to instances of the annotated type before they
 * are passed to the tooling API client.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface LegacyConsumerInterface {
    String value();