}
}

type jsonErrType struct{}

func (e *jsonErrType) MarshalJSON() ([]byte, error) {
	return nil, errors.New("beep */ boop </script blip <!--")
}

func TestJSValEscaper(t *testing.T) {
	tests := []struct {
		x        any
		js       string
		skipNest bool
	}{
		{int(42), " 42 ", false},
		{uint(42), " 42 ", false},
		{int16(42), " 42 ", false},
		{uint16(42), " 42 ", false},

		},
		{
			"{{range .Items}}<a{{end}}",
			`z:1: on range loop re-entry: "<" in attribute name: "<a"`,
		},
		{
			"\n{{range .Items}} x='<a{{end}}",
			"z:2:8: on range loop re-entry: {{range}} branches",
		},
		{
			"{{range .Items}}<a{{if .X}}{{break}}{{end}}>{{end}}",
			"z:1:29: at range loop break: {{range}} branches end in different contexts",
		},
		{

// cancelled. The returned error is the error returned by the last condition or the
// context error if the context was terminated.
//
// This is the common loop construct for all polling in the wait package.
func loopConditionUntilContext(ctx context.Context, t Timer, immediate, sliding bool, condition ConditionWithContextFunc) error {
	defer t.Stop()

	var timeCh <-chan time.Time
	doneCh := ctx.Done()

	if !sliding {
		timeCh = t.C()

// RUN: tf-mlir-translate -mlir-to-graphdef %s -o - | FileCheck %s

func.func @main() {
  tf_executor.graph {
    tf_executor.island wraps "tf.NoOp"() {} : () -> () loc("noop")
    tf_executor.fetch
  }
  func.return
}

// CHECK: node {
// CHECK-NEXT:  name: "noop"
// CHECK-NEXT:  op: "NoOp"
// CHECK-NEXT:  experimental_debug_info {
// CHECK-NEXT:  }

// Copyright 2014 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.

// This file contains tests for the bool checker.

package bool

func _() {
	var f, g func() int

	if v, w := f(), g(); v == w || v == w { // ERROR "redundant or: v == w || v == w"
	}

func convertNeq0B(x uint8, c bool) bool {
	// amd64:"ANDL\t[$]1",-"SETNE"
	// ppc64x:"RLDICL",-"CMPW",-"ISEL"
	b := x&1 != 0
	return c && b
}

func convertNeq0W(x uint16, c bool) bool {
	// amd64:"ANDL\t[$]1",-"SETNE"
	// ppc64x:"RLDICL",-"CMPW",-"ISEL"
	b := x&1 != 0
	return c && b
}

func convertNeq0L(x uint32, c bool) bool {
	// amd64:"ANDL\t[$]1",-"SETB"

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package config

import (
	"encoding/json"
	"fmt"
	"strconv"
	"strings"
)

// BoolFlag - wrapper bool type.
type BoolFlag bool

// String - returns string of BoolFlag.
func (bf BoolFlag) String() string {
	if bf {
		return "on"
	}

	return "off"
}

// MarshalJSON - converts BoolFlag into JSON data.

		}
	}
}

// Test BoolFlag.UnmarshalJSON()
func TestBoolFlagUnmarshalJSON(t *testing.T) {
	testCases := []struct {
		data           []byte
		expectedResult BoolFlag
		expectedErr    bool
	}{
		{[]byte(`{}`), BoolFlag(false), true},
		{[]byte(`["on"]`), BoolFlag(false), true},
		{[]byte(`"junk"`), BoolFlag(false), true},
		{[]byte(`""`), BoolFlag(true), false},
		{[]byte(`"on"`), BoolFlag(true), false},

// RUN: tf-mlir-translate -mlir-to-graphdef %s -o - | FileCheck %s

// Verify the ops generated when Ref type is used in a while loop.
func.func @main() {
  // CHECK:  op: "RefEnter"
  // CHECK:  op: "RefMerge"
  // CHECK:  op: "RefSwitch"
  // CHECK:  op: "RefExit"
  // CHECK:  op: "RefNextIteration"
  tf_executor.graph {
    %0:3 = tf_executor.NextIteration.Source : tensor<*x!tf_type.int32ref> {device = "", T = "tfdtype$DT_INT32"} loc("while/NextIteration")

Adrian Kuegel <******@****.***> 1648469008 -0700