// 
PACKAGE issue13742

IMPORTPATH
	testdata/issue13742

IMPORTS
	go/ast

FILENAMES
	testdata/issue13742.go

FUNCTIONS
	// Both F0 and G0 should appear as functions. 
	func F0(Node)

	// Both F1 and G1 should appear as functions. 
	func F1(ast.Node)

	// 
	func G0() Node

	// 

Let's look at how we can make that work.

## pytest.mark.anyio

If we want to call asynchronous functions in our tests, our test functions have to be asynchronous. AnyIO provides a neat plugin for this, that allows us to specify that some test functions are to be called asynchronously.

## HTTPX

Even if your **FastAPI** application uses normal `def` functions instead of `async def`, it is still an `async` application underneath.

 --%><%@taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %><%--
 --%><%@taglib prefix="la" uri="http://lastaflute.org/latags" %><%--
 --%><%@taglib prefix="f" uri="http://lastaflute.org/functions" %><%--
 --%><%@taglib prefix="fe" uri="http://fess.codelibs.org/functions" %><%--

    inner (anonymous) class MainKt$ArticleScreenContent$2
    synthetic static method ArticleScreenContent$default(p0: java.lang.String, p1: kotlin.jvm.functions.Function0, p2: int, p3: java.lang.Object): void
    private final static method ArticleScreenContent(p0: java.lang.String, p1: kotlin.jvm.functions.Function0): void
    private final static method TopAppBar(p0: java.lang.String): void

	}

	if installAction != nil {
		if runAction != installAction {
			installAction.Deps = append(installAction.Deps, runAction)
		}
		if cleanAction != nil {
			cleanAction.Deps = append(cleanAction.Deps, installAction)
		}
	}

	return buildAction, runAction, printAction, nil
}

func addTestVet(b *work.Builder, p *load.Package, runAction, installAction *work.Action) {
	if testVet.off {

// Required when using LLVM_DEBUG macro.
#define DEBUG_TYPE "mark-functions-noinline"

namespace mlir {
namespace quant {
namespace {

// Name of the boolean attribute indicating whether the function can be
// inlined or not.
constexpr StringRef kTfNoinlineAttr = "tf._noinline";

// This pass marks functions with the attribute `tf._noinline = true` so that

    test::ExpectTensorEqual<float>(
        outputs[0],
        test::AsTensor<float>({2, 2.5, 3, 3.5}, TensorShape({4, 1})));

    // Validate the `output_partition_graphs` is not supported.
    RunOptions run_options;
    run_options.set_output_partition_graphs(true);
    RunMetadata run_metadata;
    Status s =
        bundle.GetSession()->Run(run_options, {{input_name, input}},

      }
    } else {
      funcs_to_trim.push_back(func);
    }
  }

  // remove all unexported functions from the module.
  for (auto func : funcs_to_trim) {
    func.erase();
  }
  return true;
}

// validate that all reachable functions from the remaining functions are
// also in the allowlist.
void TrimFunctionsPass::Verify() {

                                  const RunOptions& run_options = RunOptions());

  /// Starts the queue runner with the given session, and wait for up to the
  /// specified time (in milliseconds) for the queues to start to fill up.
  Status Start(Session* sess, int wait_for_ms);
  Status StartAndCollectCostGraph(Session* session, int wait_for_ms,
                                  const RunOptions& run_options = RunOptions());

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package sha3 implements the SHA-3 fixed-output-length hash functions and
// the SHAKE variable-output-length hash functions defined by FIPS-202.
//
// Both types of hash function use the "sponge" construction and the Keccak
// permutation. For a detailed specification see http://keccak.noekeon.org/
//
// # Guidance