const text = "abcdefghijklmn\nopqrstuvwxyz\n\r"
	lines := []string{
		"abcdefghijklmn",
		"opqrstuvwxyz",
		"",
	}
	testNoNewline(text, lines, t)
}

var testError = errors.New("testError")

// Test the correct error is returned when the split function errors out.
func TestSplitError(t *testing.T) {
	// Create a split function that delivers a little data, then a predictable error.

    void testRenewCredentials_True() {
        // Test renewCredentials(String locationHint, Throwable error) method when true
        String locationHint = "testLocation";
        Throwable error = new RuntimeException("testError");
        when(mockDelegate.renewCredentials(locationHint, error)).thenReturn(true);
        assertTrue(cifsContextWrapper.renewCredentials(locationHint, error));

     * @throws Exception
     */
    @Test
    public void testWarn() throws Exception {
        logger.warn("warn");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testError() throws Exception {
        logger.error("error");
    }

    /**
     * @throws Exception
     */
    @Test
    public void testFatal() throws Exception {
        logger.fatal("fatal");
    }

        assertTrue(mockResponse.isError());

        // Verify the method was called
        verify(mockResponse, times(2)).isError();
    }

    @Test
    void testError() {
        // Call the method
        mockResponse.error();

        // Verify that the method was called
        verify(mockResponse, times(1)).error();
    }

    @Test

import (
	"bytes"
	"errors"
	"fmt"
	"internal/testenv"
	"io"
	"io/fs"
	"maps"
	"math"
	"os"
	"path"
	"path/filepath"
	"reflect"
	"slices"
	"strings"
	"testing"
	"time"
)

type testError struct{ error }

type fileOps []any // []T where T is (string | int64)

// testFile is an io.ReadWriteSeeker where the IO operations performed
// on it must match the list of operations in ops.
type testFile struct {

            assertTrue(response.isReceived());
            assertSame(testException, response.getException());
        }

        @Test
        @DisplayName("Should handle error")
        void testError() throws InterruptedException {
            CountDownLatch latch = new CountDownLatch(1);

            Thread waiter = new Thread(() -> {
                synchronized (response) {
                    try {

						t.Fatalf("test %d, Write() = (%d, %v), want (%d, %v)", i, got, err, tf.wantCnt, tf.wantErr)
					}
				case testReadFrom:
					f := &testFile{ops: tf.ops}
					got, err := tw.readFrom(f)
					if _, ok := err.(testError); ok {
						t.Errorf("test %d, ReadFrom(): %v", i, err)
					} else if got != tf.wantCnt || !equalError(err, tf.wantErr) {
						t.Errorf("test %d, ReadFrom() = (%d, %v), want (%d, %v)", i, got, err, tf.wantCnt, tf.wantErr)

        // Then
        assertFalse(isError);
        verify(response).isError();
    }

    @Test
    @DisplayName("Test Response interface methods - error")
    void testError() {
        // Given
        doNothing().when(response).error();

        // When
        response.error();

        // Then
        verify(response).error();
    }

    @Test

				}
			case testWriteTo:
				f := &testFile{ops: tf.ops}
				got, err := fr.WriteTo(f)
				if _, ok := err.(testError); ok {
					t.Errorf("test %d.%d, WriteTo(): %v", i, j, err)
				} else if got != tf.wantCnt || err != tf.wantErr {
					t.Errorf("test %d.%d, WriteTo() = (%d, %v), want (%d, %v)", i, j, got, err, tf.wantCnt, tf.wantErr)

		t.Errorf("Write error: got %T, want testError1", err)
	}

	rb.CloseWithError(testError2{})
	if _, err := rb.Write(nil); err != (testError1{}) {
		t.Errorf("Write error: got %T, want testError1", err)
	}

	rb.Reset()
	rb.CloseWithError(testError1{})
	if _, err := rb.Read(nil); err != (testError1{}) {
		t.Errorf("Read error: got %T, want testError1", err)
	}