if goarm == 6 {
			testEndToEnd(t, "arm", "armv6")
		}
	}
}

func TestGoBuildErrors(t *testing.T) {
	testErrors(t, "amd64", "buildtagerror")
}

func TestGenericErrors(t *testing.T) {
	testErrors(t, "amd64", "duperror")
}

func TestARMErrors(t *testing.T) {
	testErrors(t, "arm", "armerror")
}

func TestARM64EndToEnd(t *testing.T) {
	testEndToEnd(t, "arm64", "arm64")
}

    assertTrue(c2.isClosed());

    assertSuppressed(
        new Suppression(c2, tryException, c2Exception),
        new Suppression(c1, tryException, c1Exception));
  }

  public void testErrors() throws IOException {
    Closer closer = new Closer(suppressor);

    Error c1Exception = new Error();
    Error c2Exception = new Error();
    Error c3Exception = new Error();

    assertTrue(c2.isClosed());

    assertSuppressed(
        new Suppression(c2, tryException, c2Exception),
        new Suppression(c1, tryException, c1Exception));
  }

  public void testErrors() throws IOException {
    Closer closer = new Closer(suppressor);

    Error c1Exception = new Error();
    Error c2Exception = new Error();
    Error c3Exception = new Error();

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

	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.

        def testStartEvent2 = startEvent("testId2")
        def testError2 = Mock(Throwable)

        when:
        processor.started(rootDescriptor, rootTestStartEvent)
        processor.started(testDescriptor1, testStartEvent1)
        processor.started(testDescriptor2, testStartEvent2)
        processor.failure("testId2", testError2)
        processor.completed("rootId", rootCompleteEvent)

        then:

        errorCount.set(5);
        assertEquals(5, crawlingConfigHelper.getExcludedUrlList("123").size());
        systemProperties.setProperty(Constants.IGNORE_FAILURE_TYPE_PROPERTY, "TestError0");
        assertEquals(4, crawlingConfigHelper.getExcludedUrlList("123").size());
    }

    @Test
    public void test_getDefaultConfig() {

    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