class TestModule(tf.Module):

  @tf.function(input_signature=[tf.TensorSpec([], tf.float32)])
  def some_function(self, x):
    return self.callee(x)

  # CHECK: While importing SavedModel function 'callee': in input signature:
  # CHECK-SAME: Unhandled structured value kind {{.*}} at index path: <value>.1.foo
  @tf.function
  def callee(self, x, n={'foo': 42}):
    return x


if __name__ == '__main__':

    public infix fun and(other: KaRendererOtherModifiersProvider): KaRendererOtherModifiersProvider {
        val self = this
        return object : KaRendererOtherModifiersProvider {
            override fun getOtherModifiers(analysisSession: KaSession, symbol: KaDeclarationSymbol): List<KtModifierKeywordToken> {
                return self.getOtherModifiers(analysisSession, symbol) + other.getOtherModifiers(analysisSession, symbol)
            }
        }

	}
}

// Update implements Manager.
func (f *managedFieldsUpdater) Update(liveObj, newObj runtime.Object, managed Managed, manager string) (runtime.Object, Managed, error) {
	self := "current-operation"
	object, managed, err := f.fieldManager.Update(liveObj, newObj, managed, self)
	if err != nil {
		return object, managed, err
	}

	// If the current operation took any fields from anything, it means the object changed,

// license that can be found in the LICENSE file.

package p

// Self recursion.
type i interface{ m() interface{ i } } // ERROR "invalid recursive type"
type _ interface{ i }                  // no redundant error

// Mutual recursion.
type j interface{ m() interface{ k } } // ERROR "invalid recursive type"
type k interface{ m() interface{ j } }

// Both self and mutual recursion.
type (

        buildFile << """
            Exception selfReferencingException = new Exception("BOOM self")
            selfReferencingException.initCause(new Exception("BOOM cause", selfReferencingException))
            throw selfReferencingException
        """

        when:
        fails("help", "-s")

        then:
        failureCauseContains("BOOM self")

                def projectInOtherBuild = rootComponent.dependencies[0].selected
                def self = rootComponent.dependencies[1].selected
                assert rootComponent.id.build.currentBuild
                assert self.id.build.currentBuild
                assert self == rootComponent
                assert !projectInOtherBuild.id.build.currentBuild
            }
        """
        buildC.buildFile << """

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse


class UnicornException(Exception):
    def __init__(self, name: str):
        self.name = name


app = FastAPI()


@app.exception_handler(UnicornException)
async def unicorn_exception_handler(request: Request, exc: UnicornException):
    return JSONResponse(
        status_code=418,

import tensorflow.compat.v2 as tf
from tensorflow.compiler.mlir.tensorflow.tests.tf_saved_model import common


class TestModule(tf.Module):

  def __init__(self):
    super(TestModule, self).__init__()
    # CHECK: "tf_saved_model.global_tensor"() <{is_mutable, {{.*}} type = tensor<*xf32>, value = dense<0.000000e+00> : tensor<1xf32>}> {tf_saved_model.exported_names = ["v0"]} : () -> ()

			c.FuzzNoCustom(obj) // fuzz self without calling this function again
			// length in bytes of the IP Family: IPv4: 4 bytes IPv6: 16 bytes
			boolean := []bool{false, true}
			is6 := boolean[c.Rand.Intn(2)]
			ip := generateRandomIP(is6, c)
			obj.Name = ip
		},
		func(obj *networking.ServiceCIDR, c fuzz.Continue) {
			c.FuzzNoCustom(obj) // fuzz self without calling this function again

                - message: url must have schema one of [http, https, file, oci]
                  rule: 'isURL(self) ? (url(self).getScheme() in ['''', ''http'',
                    ''https'', ''oci'', ''file'']) : (isURL(''http://'' + self) &&
                    url(''http://'' +self).getScheme() in ['''', ''http'', ''https'',
                    ''oci'', ''file''])'
              verificationKey: