bench property

({void Function(BenchDefinition b) $1, void Function(FutureOr<void> fn(BenchContext)) $2, void Function(String name, FutureOr<void> fn(BenchContext)) $3, void Function(dynamic options, FutureOr<void> fn(BenchContext)) $4, void Function(dynamic options, FutureOr<void> fn(BenchContext)) $5, void Function(String name, dynamic options, FutureOr<void> fn(BenchContext)) $6}) get bench

Overload accessor: $1, $2, $3, $4, $5, $6

Implementation

({
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench({
  ///   name: "example test",
  ///   fn() {
  ///     assertEquals("world", "world");
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example ignored test",
  ///   ignore: Deno.build.os === "windows",
  ///   fn() {
  ///     // This test is ignored only on Windows machines
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example async test",
  ///   async fn() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench("My test description", () => {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench("My async test description", async () => {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(function myTestName() {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench(async function myOtherTestName() {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   "My test description",
  ///   { permissions: { read: true } },
  ///   () => {
  ///    assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   "My async test description",
  ///   { permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { name: "My test description", permissions: { read: true } },
  ///   () => {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { name: "My async test description", permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { permissions: { read: true } },
  ///   function myTestName() {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { permissions: { read: false } },
  ///   async function myOtherTestName() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  void Function(_i4.BenchDefinition b) $1,

  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench({
  ///   name: "example test",
  ///   fn() {
  ///     assertEquals("world", "world");
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example ignored test",
  ///   ignore: Deno.build.os === "windows",
  ///   fn() {
  ///     // This test is ignored only on Windows machines
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example async test",
  ///   async fn() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench("My test description", () => {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench("My async test description", async () => {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(function myTestName() {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench(async function myOtherTestName() {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   "My test description",
  ///   { permissions: { read: true } },
  ///   () => {
  ///    assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   "My async test description",
  ///   { permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { name: "My test description", permissions: { read: true } },
  ///   () => {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { name: "My async test description", permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { permissions: { read: true } },
  ///   function myTestName() {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { permissions: { read: false } },
  ///   async function myOtherTestName() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  void Function(_i7.FutureOr<void> Function(_i4.BenchContext) fn) $2,

  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench({
  ///   name: "example test",
  ///   fn() {
  ///     assertEquals("world", "world");
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example ignored test",
  ///   ignore: Deno.build.os === "windows",
  ///   fn() {
  ///     // This test is ignored only on Windows machines
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example async test",
  ///   async fn() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench("My test description", () => {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench("My async test description", async () => {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(function myTestName() {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench(async function myOtherTestName() {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   "My test description",
  ///   { permissions: { read: true } },
  ///   () => {
  ///    assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   "My async test description",
  ///   { permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { name: "My test description", permissions: { read: true } },
  ///   () => {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { name: "My async test description", permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { permissions: { read: true } },
  ///   function myTestName() {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { permissions: { read: false } },
  ///   async function myOtherTestName() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  void Function(
    _i2.String name,
    _i7.FutureOr<void> Function(_i4.BenchContext) fn,
  ) $3,

  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench({
  ///   name: "example test",
  ///   fn() {
  ///     assertEquals("world", "world");
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example ignored test",
  ///   ignore: Deno.build.os === "windows",
  ///   fn() {
  ///     // This test is ignored only on Windows machines
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example async test",
  ///   async fn() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench("My test description", () => {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench("My async test description", async () => {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(function myTestName() {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench(async function myOtherTestName() {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   "My test description",
  ///   { permissions: { read: true } },
  ///   () => {
  ///    assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   "My async test description",
  ///   { permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { name: "My test description", permissions: { read: true } },
  ///   () => {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { name: "My async test description", permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { permissions: { read: true } },
  ///   function myTestName() {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { permissions: { read: false } },
  ///   async function myOtherTestName() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  void Function(
    _i8.Omit<_i4.BenchDefinition, _i2.String> options,
    _i7.FutureOr<void> Function(_i4.BenchContext) fn,
  ) $4,

  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench({
  ///   name: "example test",
  ///   fn() {
  ///     assertEquals("world", "world");
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example ignored test",
  ///   ignore: Deno.build.os === "windows",
  ///   fn() {
  ///     // This test is ignored only on Windows machines
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example async test",
  ///   async fn() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench("My test description", () => {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench("My async test description", async () => {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(function myTestName() {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench(async function myOtherTestName() {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   "My test description",
  ///   { permissions: { read: true } },
  ///   () => {
  ///    assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   "My async test description",
  ///   { permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { name: "My test description", permissions: { read: true } },
  ///   () => {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { name: "My async test description", permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { permissions: { read: true } },
  ///   function myTestName() {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { permissions: { read: false } },
  ///   async function myOtherTestName() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  void Function(
    _i8.Omit<_i4.BenchDefinition, _i4.BenchOptions> options,
    _i7.FutureOr<void> Function(_i4.BenchContext) fn,
  ) $5,

  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench({
  ///   name: "example test",
  ///   fn() {
  ///     assertEquals("world", "world");
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example ignored test",
  ///   ignore: Deno.build.os === "windows",
  ///   fn() {
  ///     // This test is ignored only on Windows machines
  ///   },
  /// });
  ///
  /// Deno.bench({
  ///   name: "example async test",
  ///   async fn() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench("My test description", () => {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench("My async test description", async () => {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(function myTestName() {
  ///   assertEquals("hello", "hello");
  /// });
  ///
  /// Deno.bench(async function myOtherTestName() {
  ///   const decoder = new TextDecoder("utf-8");
  ///   const data = await Deno.readFile("hello_world.txt");
  ///   assertEquals(decoder.decode(data), "Hello world");
  /// });
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   "My test description",
  ///   { permissions: { read: true } },
  ///   () => {
  ///    assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   "My async test description",
  ///   { permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { name: "My test description", permissions: { read: true } },
  ///   () => {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { name: "My async test description", permissions: { read: false } },
  ///   async () => {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  /// Register a benchmark test which will be run when `deno bench` is used on
  /// the command line and the containing module looks like a bench module.
  ///
  /// If the test function (`fn`) returns a promise or is async, the test runner
  /// will await resolution to consider the test complete.
  ///
  /// ```ts
  /// import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
  ///
  /// Deno.bench(
  ///   { permissions: { read: true } },
  ///   function myTestName() {
  ///     assertEquals("hello", "hello");
  ///   }
  /// );
  ///
  /// Deno.bench(
  ///   { permissions: { read: false } },
  ///   async function myOtherTestName() {
  ///     const decoder = new TextDecoder("utf-8");
  ///     const data = await Deno.readFile("hello_world.txt");
  ///     assertEquals(decoder.decode(data), "Hello world");
  ///   }
  /// );
  /// ```
  void Function(
    _i2.String name,
    _i8.Omit<_i4.BenchDefinition, _i4.Bench> options,
    _i7.FutureOr<void> Function(_i4.BenchContext) fn,
  ) $6,
}) get bench => (
      $1: _bench$1,
      $2: _bench$2,
      $3: _bench$3,
      $4: _bench$4,
      $5: _bench$5,
      $6: _bench$6,
    );