- Method ${ruleDescription} is not a valid rule method: A method annotated with @BinaryTasks must have void return type.
- Method ${ruleDescription} is not a valid rule method: The first parameter of a method annotated with @BinaryTasks must be of type org.gradle.model.ModelMap.

		{"valid, but IPv6 CIDR too small. At least 10 addresses needed", "10.0.0.16/12,2001:db8::/125", 10, false},
		{"valid, but only IPv4 family addresses specified. IPv6 CIDR is necessary.", "10.0.0.16/12,192.168.0.0/16", 10, false},
		{"valid, but only IPv6 family addresses specified. IPv4 CIDR is necessary.", "2001:db8::/98,2005:db8::/98", 10, false},
		{"valid IPv4 and IPv6 CIDR", "10.0.0.16/12,2001:db8::/98", 10, true},

		return host, port, nil
	}

	return "", "", errors.Errorf("hostport %s: host '%s' must be a valid IP address or a valid RFC-1123 DNS subdomain", hostport, host)
}

// ParsePort parses a string representing a TCP port.
// If the string is not a valid representation of a TCP port, ParsePort returns an error.
func ParsePort(port string) (int, error) {
	portInt, err := netutils.ParsePort(port, true)

		},
		{
			name:           "valid output format and --template argument succeeds",
			outputFormat:   "jsonpath",
			templateArg:    "{ .metadata.name }",
			expectedOutput: "foo",
		},
		{
			name:           "valid jsonpath-as-json output format also containing argument succeeds",
			outputFormat:   "jsonpath-as-json={ .metadata.name }",
			expectedOutput: "foo",
		},
		{

		expectedPatchType  types.PatchType
		expectedWarning    bool
		expectedError      bool
	}{
		{
			name:               "valid: known target and patch type",
			fileName:           "etcd+merge.json",
			expectedTargetName: "etcd",
			expectedPatchType:  types.MergePatchType,
		},
		{
			name:               "valid: known target and default patch type",
			fileName:           "etcd0.yaml",
			expectedTargetName: "etcd",

type S1 struct {
	x int "S1.x"
}

type S2 struct {
	x int "S2.x"
}

func _[P1 S1, P2 S2]() {
	type A = P1
	var p A
	_ = P2(p) // conversion must be valid
}

func _[P1 S1, P2 S2]() {
	var p P1
	type A = P2
	_ = A(p) // conversion must be valid
}

func _[P int | string]() {
	var p P
	type A = int
	// preserve target type name A in error messages when using Alias types

// RUN: tf-mlir-translate -mlir-to-graphdef %s | tf-mlir-translate -graphdef-to-mlir

// Test graphdef export is producing valid GraphDef. The test imports the
// generated GraphDef to make sure the export is valid.

module attributes {tf.versions = {bad_consumers = [], min_consumer = 12 : i32, producer = 890 : i32}}  {

  // CHECK: "tf.Conv2D"(%[[INPUT_TRANSPOSE:[0-9]*]], %arg1)
  // CHECK-SAME: data_format = "NCHW"
  %0 = "tf.Conv2D"(%input, %filter)
       {
         data_format = "NHWC",
         padding = "VALID",
         strides = [1, 1, 1, 1]
       } : (tensor<1x28x28x64xf32>, tensor<3x3x64x64xf32>)
        -> tensor<1x26x26x64xf32>

  func.return %0 : tensor<1x26x26x64xf32>
}

		//           in that issue `type A[P any] [1]P` is a valid type on its own
		//           and the (uninstantiated) A is recorded in check.valids. As a
		//           consequence, when checking the remaining declarations, which
		//           are not valid, the validity check ends prematurely because A
		//           is considered valid, even though its validity depends on the
		//           type argument provided to it.
		//

		//           in that issue `type A[P any] [1]P` is a valid type on its own
		//           and the (uninstantiated) A is recorded in check.valids. As a
		//           consequence, when checking the remaining declarations, which
		//           are not valid, the validity check ends prematurely because A
		//           is considered valid, even though its validity depends on the
		//           type argument provided to it.
		//