// license that can be found in the LICENSE file.

package testing_test

import (
	"testing"
	"time"
)

var sink time.Time
var sinkHPT testing.HighPrecisionTime

func BenchmarkTimeNow(b *testing.B) {
	for i := 0; i < b.N; i++ {
		sink = time.Now()
	}
}

func BenchmarkHighPrecisionTimeNow(b *testing.B) {
	for i := 0; i < b.N; i++ {
		sinkHPT = testing.HighPrecisionTimeNow()
	}

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.io;

/**
 * Options controlling the behavior of sources/sinks/streams for testing.
 *
 * @author Colin Decker
 */
public enum TestOption {
  OPEN_THROWS,
  SKIP_THROWS,
  READ_THROWS,
  WRITE_THROWS,
  CLOSE_THROWS,
  AVAILABLE_ALWAYS_ZERO

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.io;

/**
 * Options controlling the behavior of sources/sinks/streams for testing.
 *
 * @author Colin Decker
 */
public enum TestOption {
  OPEN_THROWS,
  SKIP_THROWS,
  READ_THROWS,
  WRITE_THROWS,
  CLOSE_THROWS,
  AVAILABLE_ALWAYS_ZERO

    randomAccessFile!!.getChannel().force(false)
    val source = file!!.source().buffer()
    return source.readByteString()
  }

  private fun write(data: ByteString) {
    val sink = file!!.sink().buffer()
    sink.write(data)
    sink.close()
  }

      }

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8("<el")
        sink.flush()
        throw IOException("failed to stream the XML")
      }
    }

    class ValidRequestBody : RequestBody() {
      override fun contentType(): MediaType {
        return "application/xml".toMediaType()
      }

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8("<element/>")

		}
		EmptyOpContext(r1, -1)
	}
}

var sink any

func BenchmarkIsWordChar(b *testing.B) {
	const chars = "Don't communicate by sharing memory, share memory by communicating."
	for i := 0; i < b.N; i++ {
		for _, r := range chars {
			sink = IsWordChar(r)
		}
	}
	if sink == nil {
		b.Fatal("Benchmark did not run")
	}
	sink = nil

		}

		w.Write([]byte("two"))
		if err := ctl.Flush(); err == nil {
			t.Errorf("after setting deadline: ctl.Flush() = nil, want non-nil")
		}
		// Connection errors are sticky, so resetting the deadline does not permit
		// making more progress. We might want to change this in the future, but verify
		// the current behavior for now. If we do change this, we'll want to make sure

type T struct {
	pad uint32
	f float64
}

//go:noinline
func f(t, u *T) float64 {
	return 3.0 + t.f + u.f
}

func main() {
	t := [2]T{{0, 1.0}, {0, 2.0}}
	sink = f(&t[0], &t[1])
}

		f := runtime.FuncForPC(stack[0] + i)
		if f.Name() != "main.main" && f.Name() != "main.f" {
			// Reached next function successfully.
			break
		}
	}
}

func f() {
	sink = 0 // one instruction which can't be removed
}

var trees [16]*node
var ballast *[16]*[1024]*node
var sink [][]byte

func main() {
	for i := range trees {
		trees[i] = makeTree(6)
	}
	ballast = new([16]*[1024]*node)
	for i := range ballast {
		ballast[i] = new([1024]*node)
		for j := range ballast[i] {
			ballast[i][j] = &node{
				data: [128]byte{1, 2, 3, 4},
			}
		}
	}

	procs := runtime.GOMAXPROCS(-1)
	sink = make([][]byte, procs)