// expected-error@-1 {{use of value '%arg0' expects different type than prior uses: 'tensor<*xf32>' vs 'tensor<*xi32>'}}
  }
  func.return
}

// -----

// Check that a replicate with multiple blocks in its region is invalid.
func.func @parser_replicate_region() {
  tf_device.replicate() {n = 2 : i32} {
// expected-error@-1 {{custom op 'tf_device.replicate' expects a single block region}}
    cf.br ^bb

//
//    * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual
//    * {ASSERT|EXPECT}_NE(v1, v2):           Tests that v1 != v2
//    * {ASSERT|EXPECT}_LT(v1, v2):           Tests that v1 < v2
//    * {ASSERT|EXPECT}_LE(v1, v2):           Tests that v1 <= v2
//    * {ASSERT|EXPECT}_GT(v1, v2):           Tests that v1 > v2
//    * {ASSERT|EXPECT}_GE(v1, v2):           Tests that v1 >= v2
//

		t.Fatalf("RemoveVolumeFromReportAsAttached failed. Expected: <no error> Actual: <%v>", markDesireToDetachErr)
	}
	if addErr != nil {
		t.Fatalf("AddVolumeNode failed. Expected: <no error> Actual: <%v>", addErr)
	}

	// Assert
	attachedVolumes := asw.GetAttachedVolumes()
	if len(attachedVolumes) != 1 {
		t.Fatalf("len(attachedVolumes) Expected: <1> Actual: <%v>", len(attachedVolumes))
	}

		// ok
	case test.matches == nil && result != nil:
		t.Errorf("expected no match; got one: %s", test)
	case test.matches != nil && result == nil:
		t.Errorf("expected match; got none: %s", test)
	case test.matches != nil && result != nil:
		expect := test.matches[0]
		if expect[0] != result[0] || expect[1] != result[1] {
			t.Errorf("expected %v got %v: %s", expect, result, test)
		}
	}
}

		{"TEXT", "$0É:0, 0, $1", "expected end of operand, found É"}, // Issue #12467.
		{"TEXT", "$:0:(SB, 0, $1", "expected '(', found 0"},          // Issue 12468.
		{"TEXT", "@B(SB),0,$0", "expected '(', found B"},             // Issue 23580.
		{"TEXT", "foo<ABIInternal>(SB),0", "ABI selector only permitted when compiling runtime, reference was to \"foo\""},
		{"FUNCDATA", "", "expect two operands for FUNCDATA"},

		if ret != tc.expect {
			t.Errorf("[%d] expected %v, got %v: %q", i, tc.expect, ret, tc.input)
		}
	}
}

func TestHasPathPrefix(t *testing.T) {
	cases := []struct {
		base   string
		pfx    string
		expect bool
	}{{
		base:   "",
		pfx:    "",
		expect: true,
	}, {
		base:   "/foo/bar",
		pfx:    "",
		expect: true,
	}, {
		base:   "",
		pfx:    "/foo",
		expect: false,
	}, {

	if err != nil {
		t.Errorf("Received unexpected error: %v", err)
	}

	if !reflect.DeepEqual(expect, output) {
		t.Errorf("Received unexpected output. Expected %#v, got %#v", expect, output)
	}
}

func TestDockerConfigEntryJSONDecode(t *testing.T) {
	tests := []struct {
		input  []byte
		expect DockerConfigEntry
		fail   bool
	}{
		// simple case, just decode the fields
		{

func TestStringList(t *testing.T) {
	cases := []struct {
		in          string
		expect      model.StringList
		noRoundTrip bool
	}{
		{in: `"a,b,c"`, expect: []string{"a", "b", "c"}},
		{in: `"\"a,b,c"`, expect: []string{`"a`, "b", "c"}},
		{in: `"a"`, expect: []string{"a"}},
		{in: `""`, expect: []string{}},
		{in: `"123,@#$#,abcdef"`, expect: []string{"123", "@#$#", "abcdef"}},
	}
	for _, tt := range cases {

	testBuf := io.Writer(buf)
	testWriter = &testBuf
	expected := ""
	expect := func(e string) {
		t.Helper()
		// In buffer mode we don't overwrite old data, so we are constantly appending to the expected
		newExpected := expected + "\n" + e
		if newExpected != buf.String() {
			t.Fatalf("expected '%v', \ngot '%v'", newExpected, buf.String())
		}
		expected = newExpected
	}

	p := NewLog()

			parts := yml.SplitString(c.doc)
			g := NewWithT(t)
			g.Expect(parts).To(Equal(expected))
		})
	}
}

func TestSplitWithNestedDocument(t *testing.T) {
	doc := `
b
    b1
    ---
    b2
`
	expected := []string{
		`b
    b1
    ---
    b2`,
	}

	g := NewWithT(t)
	parts := yml.SplitString(doc)
	g.Expect(parts).To(Equal(expected))
}

func TestJoinRemovesEmptyParts(t *testing.T) {