expect64(t, s+":c", c, expected)
	expect64(t, s+":d", d, expected)
	expect64(t, s+":e", e, expected)
	expect64(t, s+":f", f, expected)
	expect64(t, s+":g", g, expected)
}

func expectAll32(t *testing.T, s string, expected, a, b, c, d, e, f, g, h, i float32) {
	expect32(t, s+":a", a, expected)
	expect32(t, s+":b", b, expected)
	expect32(t, s+":c", c, expected)
	expect32(t, s+":d", d, expected)

Tom Tresansky <******@****.***> 1697219015 -0400

	expected = updatedAtRe.ReplaceAllString(expected, `"updated_at"=?`)

	// ignore RETURNING "id" (only in PostgreSQL)
	returningRe := regexp.MustCompile(`(?i)RETURNING "id"`)
	actually = returningRe.ReplaceAllString(actually, ``)
	expected = returningRe.ReplaceAllString(expected, ``)

	actually = strings.TrimSpace(actually)
	expected = strings.TrimSpace(expected)

	if c.fn != nil {
		errs := c.fn(fs, dir, c)
		if len(errs) > 0 {
			for _, err := range errs {
				utiltest.ExpectError(t, err, c.err)
			}
			// skip checking expected files if we expected errors
			// (usually means we didn't create file)
			return
		}
		c.expect(t, fs, dir)
		return
	}
	// just check expected files, and compare errors from c.expect to c.err

Ben Leggett <******@****.***> 1716316321 -0400

    }

    /**
     * Expects exactly the given number of calls to be made concurrently from any combination of the expected calls. Blocks each call until they are explicitly released.
     * Is not considered "complete" until all expected calls have been received.
     */
    public BlockingHandler expectConcurrentAndBlock(int concurrent, String... expectedCalls) {

    }

    /**
     * Expects one GET request, which fails with a 500 status code
     */
    void expectGetBroken(String path) {
        expect(path, false, ['GET'], broken())
    }

    /**
     *  Expects one GET request, which fails with a 401 status code.
     */
    void expectGetUnauthorized(String path) {
        expect(path, false, ['GET'], unauthorized())
    }

    /**

Paul Merlin <******@****.***> 1690890212 +0200

	goldenFile := filepath.Join("testdata", name+".golden")
	testutil.CompareContent(t, gotBytes, goldenFile)
}

func TestBuilder(t *testing.T) {
	cases := []struct {
		name         string
		expectV4     bool
		expectV6     bool
		config       func(builder *IptablesRuleBuilder)
		sharedGolden bool
	}{
		{
			"insert-single-v4",
			true,
			false,
			func(builder *IptablesRuleBuilder) {

  tf_executor.graph {
    "tf_executor.island"() ({
// expected-error@-1 {{'tf_executor.island' op expected 1 or more results}}
    }) : () -> ()
  }
  func.return
}

// -----

// Check that an island region can't be empty.
func.func @invalid_island(%arg0: tensor<*xf32>, %ctl: !tf_executor.control) {
  tf_executor.graph {
    "tf_executor.island"() ({