}

func writeOutFileList(t *testing.T, infiles []string, outdir, tag string) ([]string, string) {
	outfilelist := filepath.Join(outdir, tag+"outfilelist.txt")
	var sb strings.Builder
	cv := filepath.Join(outdir, "covervars.go")
	outfs := []string{cv}
	fmt.Fprintf(&sb, "%s\n", cv)
	for _, inf := range infiles {
		base := filepath.Base(inf)
		of := filepath.Join(outdir, tag+".cov."+base)
		outfs = append(outfs, of)

package genutils

import (
	"testing"
)

func TestValidDir(t *testing.T) {
	_, err := OutDir("./")
	if err != nil {
		t.Fatal(err)
	}
}

func TestInvalidDir(t *testing.T) {
	_, err := OutDir("./nondir")
	if err == nil {
		t.Fatal("expected an error")
	}
}

func TestNotDir(t *testing.T) {
	_, err := OutDir("./genutils_test.go")
	if err == nil {
		t.Fatal("expected an error")
	}

    }


    public static byte[] expandNFold ( byte[] data, int outlen ) {
        int lcm = lcm(outlen, data.length);
        byte[] buf = new byte[outlen];
        int carry = 0;
        for ( int i = lcm - 1; i >= 0; i-- ) {
            carry = carry_add(data, buf, carry, i);
        }

        if ( carry != 0 ) {
            for ( int i = outlen - 1; i >= 0; i-- ) {
                carry += ( buf[ i ] & 0xff );

go 1.21

require example.net/outer/inner v0.1.0
-- a/a.go --
package a
-- a/a_test.go --
package a_test

import _ "example.net/outer/inner"
-- b/go.mod --
module example.net/b

go 1.21

require example.net/outer v0.1.0
-- b/b.go --
package b
-- b/b_test.go --
package b_test

import _ "example.net/outer/inner"
-- inner/go.mod --
module example.net/outer/inner

go 1.21

  builder->create<func::ReturnOp>(cluster_return_op.getLoc(),
                                  cluster_return_op.getOperands());
  cluster_return_op.erase();
}

// Builds a function that outlines region attached to cluster_op or launch_op,
// and inserts built function into given module.
template <typename ClusterOrLaunchOp>
func::FuncOp BuildFunction(llvm::ArrayRef<Value> live_ins, ClusterOrLaunchOp op,

	path := "docs/"
	if len(os.Args) == 2 {
		path = os.Args[1]
	} else if len(os.Args) > 2 {
		fmt.Fprintf(os.Stderr, "usage: %s [output directory]\n", os.Args[0])
		os.Exit(1)
	}

	outDir, err := genutils.OutDir(path)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to get output directory: %v\n", err)
		os.Exit(1)
	}

	// Set environment variables used by kubectl so the output is consistent,

// TODO(srbs): Add APIs for specifying attrs etc.
// `op_type` must outlive `op`.
void TF_AbstractOpSetOpType(TF_AbstractOp* op, const char* const op_type,
                            TF_Status* s);
// `op_name` must outlive `op`.
void TF_AbstractOpSetOpName(TF_AbstractOp* op, const char* const op_name,
                            TF_Status* s);
// `attr_name` must outlive `op`.

// RUN: tf-opt %s -split-input-file -verify-diagnostics  -tf-xla-cluster-formation | FileCheck %s

// Check that we outline the partitioned call with `_xla_compile_device_type`
// to a device cluster.
// CHECK-LABEL: func.func @xla_must_compile_true
// CHECK: tf_device.cluster
// CHECK-NEXT: tf.StatefulPartitionedCall
// CHECK-NEXT: tf_device.return
// CHECK: _cluster_outlined_function_name = "stateful_pcall_func"
// CHECK-SAME: allow_soft_placement = true

stdout '"Test":"TestWeirdTiming","Output":"[^"]* logging to outer again\\n"'

-- go.mod --
module example.com
go 1.15
-- main_test.go --
package main

import (
	"testing"
)

func TestWeirdTiming(outer *testing.T) {
	outer.Run("pauser", func(pauser *testing.T) {
		outer.Logf("logging to outer")
		pauser.Parallel()
	})

	outer.Logf("logging to outer again")

	runtime.Callers(2, stack[:])

	return nil
}

func main() {
	funcs := listFuncs(New())
	for _, f := range funcs {
		f()
	}
}

func listFuncs(outer Outer) []func() error {
	return []func() error{outer.DoStuff}