"tfl.yield"(%test) : (tensor<i1>) -> ()
  },  {
  ^bb0(%arg2: tensor<i32>, %arg3: tensor<f32>):
    %cst = arith.constant dense<22.0> : tensor<f32>
    %stride = arith.constant dense<1> : tensor<i32>
    %inc = tfl.add %arg2, %stride {fused_activation_function = "NONE"} : tensor<i32>
    "tfl.yield"(%inc, %cst) : (tensor<i32>, tensor<f32>) -> ()

/**
 * Mechanism by which the scan plugin registers for notifications.
 * <p>
 * One instance of this exists per build tree.
 * Only one listener may register.
 * Subsequent attempts yield exceptions.
 *
 * @since 4.0
 */
@UsedByScanPlugin("obtained from the root build's root project's service registry")
@ServiceScope(Scope.CrossBuildSession.class)

              while (!shutdown.get()) {
                interruptee.interrupt();
                Thread.yield();
              }
            }
          });
      this.shutdown = shutdown;
      start();
    }

    void shutdown() {
      shutdown.set(true);
      while (this.isAlive()) {
        Thread.yield();
      }
    }
  }

  void assertWrapsInterruptedException(RuntimeException e) {

  for (Value value : extern_values) {
    auto arg = block.addArgument(value.getType(), loc);
    replaceAllUsesInRegionWith(value, arg, func_region);
    new_args.push_back(arg);
  }

  // Replace yield op with return.
  Operation* yield_op = outlined_func.getBody().front().getTerminator();
  OpBuilder b(yield_op);
  llvm::SmallVector<Value, 4> args;
  auto loop_carried_yield_operands =

      %result_2 = "tf.StatefulPartitionedCall"() {config = "", config_proto = "", executor_type = "", f = @inline_into_island_multi_block_callee} : () -> tensor<2xi32>

      // CHECK-NEXT: tf_executor.yield %[[CST]], %[[CALL]]
      tf_executor.yield %result, %result_2 : tensor<2xi32>, tensor<2xi32>
    }
    tf_executor.fetch %1#1, %1#1 : tensor<2xi32>, tensor<2xi32>
  }
  func.return %0#1, %0#1 : tensor<2xi32>, tensor<2xi32>
}

  // CHECK-NEXT:   "tf.Yield"(%arg1) : (tensor<1xi8>) -> ()
  // CHECK-NEXT:   }, {
  // CHECK-NEXT:   "tf.Yield"(%arg2) : (tensor<1xi8>) -> ()
  // CHECK-NEXT:  }) : (tensor<i1>) -> tensor<1xi8>
  // CHECK-NEXT: return %0 : tensor<1xi8>
  %0 = "tf.IfRegion"(%arg0) <{is_stateless = false}> ({
    "tf.Yield"(%arg1) : (tensor<1x!tf_type.qint8>) -> ()
    }, {
    "tf.Yield"(%arg2) : (tensor<1x!tf_type.qint8>) -> ()

module {
func.func @simpleWhile(%arg0: tensor<i32>) -> tensor<i32> {
  %0 = "tfl.while"(%arg0) ({
  ^bb0(%block: tensor<i32>):
    "tfl.yield"(%block) : (tensor<i32>) -> ()
  },{
  ^bb0(%block: tensor<i32>):
    "tfl.yield"(%block) : (tensor<i32>) -> ()
  }) {tac.device = "CPU", fused_activation_function = "RELU6", tac.inference_type = "FLOAT"} : (tensor<i32>) -> tensor<i32>
  func.return %0 : tensor<i32>
}

        sequence {
            analysisSession.useSitePackageProvider.getSubPackageFqNames(fqName, analysisSession.targetPlatform, nameFilter).forEach {
                yield(analysisSession.firSymbolBuilder.createPackageSymbol(fqName.child(it)))
            }
        }
    }

  %tmp2 = "tfl.custom_tf"(%tmp1, %tmp1) ({
    ^bb0(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>) :
      %wrap_result = "tf.AddV2"(%arg0, %arg1) { device = "" } : (tensor<1xf32>, tensor<1xf32>) -> tensor<1xf32>
      "tfl.yield"(%wrap_result): (tensor<1xf32>)->()
      }): (tensor<1xf32>, tensor<1xf32>) -> (tensor<1xf32>)
  %tmp3 = "tfl.add"(%const, %tmp2) { fused_activation_function = "NONE" } : (tensor<1xf32>, tensor<1xf32>) -> (tensor<1xf32>)

from ...utils import needs_pydanticv1


@pytest.fixture(name="app", scope="module")
def get_app():
    with pytest.warns(DeprecationWarning):
        from docs_src.async_sql_databases.tutorial001 import app
    yield app


# TODO: pv2 add version with Pydantic v2
@needs_pydanticv1
def test_create_read(app: FastAPI):
    with TestClient(app) as client:
        note = {"text": "Foo bar", "completed": False}