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
		{

  ASSERT_TRUE(status.ok()) << status.message();

  EXPECT_EQ(tensor.dims(), 1);
  EXPECT_EQ(tensor.dtype(), dtype);
  absl::Span<const typename TypeParam::type> tensor_view(
      reinterpret_cast<typename TypeParam::type*>(tensor.data()), value.size());
  EXPECT_EQ(tensor_view[0], 42);
  EXPECT_EQ(tensor_view[1], 100);
  EXPECT_EQ(tensor_view[2], 0);
  EXPECT_EQ(tensor_view[3], 1);
  EXPECT_EQ(tensor_view[4], 4);
  EXPECT_EQ(tensor_view[5], 29);

	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) {

mkdir tmp3
mkdir tmp4
mkdir tmp5

# First build: no external linking expected
go build -ldflags=-tmpdir=tmp1 -o $devnull ./noUseOfCgo &

# Second build: using only "runtime/cgo", expect internal linking.
go build -ldflags=-tmpdir=tmp2 -o $devnull ./usesInternalCgo &

# Third build: program uses only "runtime/cgo", so we would normally
# expect internal linking, except that cflags contain suspicious entries

	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockCgroupNotifier) EXPECT() *MockCgroupNotifierMockRecorder {
	return m.recorder
}

// Start mocks base method.
func (m *MockCgroupNotifier) Start(eventCh chan<- struct{}) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start", eventCh)
}

// Start indicates an expected call of Start.

		newMap   func() *model.AddressMap
		expected int
	}{
		{
			name: "nil addresses map",
			newMap: func() *model.AddressMap {
				return nil
			},
			expected: 0,
		},
		{
			name: "empty addresses map",
			newMap: func() *model.AddressMap {
				m := model.AddressMap{}
				m.AddAddressesFor(c1ID, make([]string, 0))
				return &m
			},
			expected: 0,
		},
		{
			name: "non-empty addresses map",

commands: [{
  executable: gradle
  args: "--rerun-tasks someTask -DsomeDestination=dest"
  expect-failure: true
  expected-output-file: fail.out
  allow-additional-output: true
  allow-disordered-output: true
},{
  executable: gradle
  args: "--rerun-tasks --configuration-cache-problems=warn someTask -DsomeDestination=dest"
  expect-failure: false
  expected-output-file: store.out
  allow-additional-output: true
}, {
  executable: gradle

  EXPECT_EQ(tensor.dims(), 1);
  EXPECT_EQ(tensor.dtype(), dtype);
  absl::Span<const typename TypeParam::type> tensor_view(
      reinterpret_cast<typename TypeParam::type*>(tensor.data()), value.size());
  EXPECT_EQ(tensor_view[0], 42);
  EXPECT_EQ(tensor_view[1], 100);
  EXPECT_EQ(tensor_view[2], 0);
  EXPECT_EQ(tensor_view[3], 1);
  EXPECT_EQ(tensor_view[4], 4);