TF_OpKernelContext* ctx, int i, TF_Buffer* serialized_resource_handle_proto,
    TF_Status* status);

// Notifies the given OpKernelConstruction that kernel construction has failed.
TF_CAPI_EXPORT extern void TF_OpKernelConstruction_Failure(
    TF_OpKernelConstruction* ctx, TF_Status* status);

// Notifies the given OpKernelContext that the kernel's compute function has
// failed.

private
val Class<*>.isKotlinVisible: Boolean
    get() = isPublic && !isLocalClass && !isAnonymousClass && !isSynthetic


private
val Class<*>.isPublic
    get() = Modifier.isPublic(modifiers)


private
class ProjectSchemaNamedDomainObjectSchema(
    private val objectName: String,
    private val objectPublicType: TypeOf<*>
) : NamedDomainObjectSchema {

            children.forEach {
                when (val tokenType = it.tokenType) {
                    MODIFIER_LIST -> {
                        val modifiers = tree.children(it)
                        modifiers.forEach { modifier ->
                            when (modifier.tokenType) {

			continue
		}
		s.istiodCertBundleWatcher.SetAndNotify(keyPEM, certChain, s.istiodCertBundleWatcher.GetCABundle())
	}
}

// updateRootCertAndGenKeyCert when CA certs is updated, it generates new dns certs and notifies keycertbundle about the changes
func (s *Server) updateRootCertAndGenKeyCert() error {
	log.Infof("update root cert and generate new dns certs")
	caBundle := s.CA.GetCAKeyCertBundle().GetRootCertPem()

                { it.resultType == ResultType.FAILURE && it.exception.is(failure.rawFailure) && it.exceptions == [failure.rawFailure] },
                _
        )
        0 * _
    }

    def "notifies output listener"() {
        given:
        def event = new DefaultTestOutputEvent(TestOutputEvent.Destination.StdOut, "hey!")
        def test = new DefaultTestDescriptor("testid", "DogTest", "shouldBarkAtStrangers");

		reqInfo := (&logger.ReqInfo{}).AppendTags("peerAddress", nErr.Host.String())
		if nErr.Err != nil {
			peersLogOnceIf(logger.SetReqInfo(ctx, reqInfo), nErr.Err, nErr.Host.String())
		}
	}
}

// StopRebalance notifies all MinIO nodes to signal any ongoing rebalance
// goroutine to stop.
func (sys *NotificationSys) StopRebalance(ctx context.Context) {
	objAPI := newObjectLayerFn()
	if objAPI == nil {

                    )
                )
            )""".trimIndent()
        parse(code).assert(expected)
    }

    @Test
    fun `rejects modifiers on vals`() {
        val code = """
            public val x: Int = 0
            private val x: Int""".trimIndent()
        val expected = """
        ErroneousStatement (
            MultipleFailures(

	keyFile                   string
	dynamicCertificateContent *dynamiccertificates.DynamicCertKeyPairContent
	currentTLSCertificate     atomic.Pointer[tls.Certificate]
}

// Enqueue implements the functions to be notified when the serving cert content changes.
func (m *kubeletServerCertificateDynamicFileManager) Enqueue() {
	certContent, keyContent := m.dynamicCertificateContent.CurrentCertKeyContent()

    @CheckReturnValue
    public static SnapshotHierarchy removeUnwatchableContentAfterBuildFinished(SnapshotHierarchy root, Invalidator invalidator) {
        SnapshotHierarchy newRoot = root;
        // We are not being notified about changes to content accessed via symlinks
        newRoot = removeIndirectlySymlinkedRoots(newRoot, invalidator);
        newRoot = removeDirectSymlinks(newRoot, invalidator);
        return newRoot;
    }

          nanos: Long,
        ) {
          taskRunner.assertThreadHoldsLock()
          check(waitingCoordinatorTask == null)
          if (nanos == 0L) return

          // Yield until notified, interrupted, or the duration elapses.
          val waitUntil = nanoTime + nanos
          val self = currentTask
          waitingCoordinatorTask = self
          waitingCoordinatorNotified = false