@tf.function(input_signature=[
      tf.TensorSpec([1], tf.float32),
      tf.TensorSpec([2], tf.float32)
  ])
  def f0000_function_arity(self, x, y):
    return

  # Check index paths for lists.
  #
  # CHECK:      func {{@[a-zA-Z_0-9]+}}(
  # CHECK-SAME:   %arg0: tensor<f32> {tf._user_specified_name = "l", tf_saved_model.index_path = [0, 0]},

												},
											},
											XValidations: apiextensions.ValidationRules{
												{
													Rule:              "true",
													MessageExpression: `self[0] + self[1] + self[2] + self[3] + self[4] + self[5] + self[6] + self[7] + self[8]`,
												},
											},
										},
									},
								},
							},
						},
						{
							Name: "v3", // new

    """

    def test_boilerplate(self):
        os.chdir("test/")

        class Args:
            filenames = []
            rootdir = "."
            boilerplate_dir = "../"
            verbose = True

        # capture stdout
        old_stdout = sys.stdout
        sys.stdout = StringIO()

        boilerplate.args = Args
        ret = boilerplate.main()
        self.assertEqual(ret, 0)

		return nil
	}

	// create self-signed cert+key with the fake server.LoopbackClientServerNameOverride and
	// let the server return it when the loopback client connects.
	certPem, keyPem, err := certutil.GenerateSelfSignedCertKey(server.LoopbackClientServerNameOverride, nil, nil)
	if err != nil {
		return fmt.Errorf("failed to generate self-signed certificate for loopback connection: %v", err)
	}

	out := make(FMap[V, K])
	return out
}

type MyType uint8

const (
	FIRST MyType = 0
)

var typeStrs = FMap[MyType, string]{
	FIRST: "FIRST",
}

func (self MyType) String() string {
	return typeStrs[self]

	// are accessible via `self[mapKey]`, map containment can be checked via `mapKey in self` and all entries of the map
	// are accessible via CEL macros and functions such as `self.all(...)`.
	// If the Rule is scoped to an array, the elements of the array are accessible via `self[i]` and also by macros and
	// functions.
	// If the Rule is scoped to a scalar, `self` is bound to the scalar value.
	// Examples:

  ./testdata/i22558.go
19:	func test(t *thing, u *thing) {
20:		if t.next != nil {
23:		fmt.Fprintf(os.Stderr, "%s\n", t.name)
24:		u.self = u
25:		t.self = t
26:		t.next = u
27:		for _, p := range t.stuff {
28:			if isFoo(t, p) {
29:				return

		rootCertFile, false, rsaKeySize)
	if err != nil {
		t.Fatalf("Failed to create a self-signed CA Options: %v", err)
	}

	ca, err := NewIstioCA(caopts)
	if err != nil {
		t.Errorf("Got error while creating self-signed CA: %v", err)
	}
	if ca == nil {
		t.Fatalf("Failed to create a self-signed CA.")
	}

	signingCert, _, certChainBytes, rootCertBytes := ca.GetCAKeyCertBundle().GetAll()

  src/cmd/compile/internal/ssa/testdata/i22558.go
19:	func test(t *thing, u *thing) {
20:		if t.next != nil {
23:		fmt.Fprintf(os.Stderr, "%s\n", t.name)
24:		u.self = u
25:		t.self = t
26:		t.next = u
27:		for _, p := range t.stuff {
28:			if isFoo(t, p) {
29:				return

Module example.com/retract/self/prerelease is a module that retracts its own
latest version and all other release version.

A pre-release version higher than the highest release version is still
available, and that should be matched by @latest.

-- .mod --
module example.com/retract/self/prerelease

go 1.15

-- .info --
{"Version":"v1.0.0"}

-- p.go --