TF_ASSERT_OK(ExecuteWithBatch(graph, b));
  }
  TF_ASSERT_OK(listener()->VerifyPersistentCacheUseListenerHistory(
      /*expect_persistent_cache_use=*/false));

  // Reset the cluster numbering between sessions so we can get the same
  // cluster numbering.
  testing::ResetClusterSequenceNumber();

  // Run again but these should all hit in the persistent cache.
  listener()->ClearListenerHistory();
  for (int b = 1; b < 4; ++b) {

    TF_ASSERT_OK(ExecuteWithBatch(graph, b));
  }
  TF_ASSERT_OK(listener()->VerifyPersistentCacheUseListenerHistory(
      /*expect_persistent_cache_use=*/false));

  // Reset the cluster numbering between sessions so we can get the same
  // cluster numbering.
  testing::ResetClusterSequenceNumber();

  auto status =
      AlterPersistentCacheEntryHloModuleNames(tensorflow::testing::TmpDir());
  EXPECT_FALSE(status.ok());

// compile

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 6247: 5g used to be confused by the numbering
// of floating-point registers.

package main

var p map[string]interface{}
var v interface{}

func F() {
	p["hello"] = v.(complex128) * v.(complex128)

// run

// Copyright 2012 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 4138: bug in floating-point registers numbering.
// Makes 6g unable to use more than 11 registers.

package main

func formula() float32 {
	mA := [1]float32{1.0}
	det1 := mA[0]
	det2 := mA[0]
	det3 := mA[0]
	det4 := mA[0]
	det5 := mA[0]
	det6 := mA[0]

// Reg returns the register assigned to v, in cmd/internal/obj/$ARCH numbering.
func (v *Value) Reg() int16 {
	reg := v.Block.Func.RegAlloc[v.ID]
	if reg == nil {
		v.Fatalf("nil register for value: %s\n%s\n", v.LongString(), v.Block.Func)
	}
	return reg.(*Register).objNum
}

// Reg0 returns the register assigned to the first output of v, in cmd/internal/obj/$ARCH numbering.
func (v *Value) Reg0() int16 {

}

// A Register is a machine register, like AX.
// They are numbered densely from 0 (for each architecture).
type Register struct {
	num    int32 // dense numbering
	objNum int16 // register number from cmd/internal/obj/$ARCH
	gcNum  int16 // GC register map number (dense numbering of registers that can contain pointers)
	name   string
}

func (r *Register) String() string {
	return r.name
}

// package comment
package main

import (
	"fmt"
	"math"
	"log"
	"errors"
	"io"
)

import (
	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

// We reset the line numbering to test that
// the formatting works independent of line directives
//line :19

import (
	"fmt"
	"math"
	"log"
	"errors"
	"io"

	"fmt"

	"math"

	"log"

	"errors"

// package comment
package main

import (
	"errors"
	"fmt"
	"io"
	"log"
	"math"
)

import (
	"fmt"

	"math"

	"log"

	"errors"

	"io"
)

// We reset the line numbering to test that
// the formatting works independent of line directives
//line :19

import (
	"errors"
	"fmt"
	"io"
	"log"
	"math"

	"fmt"

	"math"

	"log"

	"errors"

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

package testing_test

import (
	"sync"
	"testing"
)

// The line numbering of this file is important for TestTBHelper.

func notHelper(t *testing.T, msg string) {
	t.Error(msg)
}

func helper(t *testing.T, msg string) {
	t.Helper()
	t.Error(msg)
}

// (or, if this is a server, sent).
func (p *Pipeline) EndResponse(id uint) {
	p.response.End(id)
}

// A sequencer schedules a sequence of numbered events that must
// happen in order, one after the other. The event numbering must start
// at 0 and increment without skipping. The event number wraps around
// safely as long as there are not 2^32 simultaneous events pending.
type sequencer struct {
	mu   sync.Mutex
	id   uint