.newBuilder()
        .fastFallback(false)
        .apply {
          retryOnConnectionFailure = false
        }.build()

    executeSynchronously(request)
      .assertFailureMatches("stream was reset: REFUSED_STREAM")

    assertThat(client.routeDatabase.failedRoutes).isEmpty()
    assertThat(server1.requestCount).isEqualTo(1)
    assertThat(server2.requestCount).isEqualTo(0)

		t.Log("WARNING: TestEncodeDecodeBucketReplicationResyncStatus Msgsize() is inaccurate")
	}

	vn := BucketReplicationResyncStatus{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBucketReplicationResyncStatus(b *testing.B) {
	v := BucketReplicationResyncStatus{}

	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecoderebalanceInfo Msgsize() is inaccurate")
	}

	vn := rebalanceInfo{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncoderebalanceInfo(b *testing.B) {
	v := rebalanceInfo{}
	var buf bytes.Buffer

			if len(healDisks) == 0 {
				// Reset for next interval.
				diskCheckTimer.Reset(defaultMonitorNewDiskInterval)
				continue
			}

			// Reformat disks immediately
			_, err := z.HealFormat(context.Background(), false)
			if err != nil && !errors.Is(err, errNoHealRequired) {
				healingLogIf(ctx, err)
				// Reset for next interval.
				diskCheckTimer.Reset(defaultMonitorNewDiskInterval)
				continue
			}

	if buf.Len() > m {
		t.Log("WARNING: TestEncodeDecodeBaseOptions Msgsize() is inaccurate")
	}

	vn := BaseOptions{}
	err := msgp.Decode(&buf, &vn)
	if err != nil {
		t.Error(err)
	}

	buf.Reset()
	msgp.Encode(&buf, &v)
	err = msgp.NewReader(&buf).Skip()
	if err != nil {
		t.Error(err)
	}
}

func BenchmarkEncodeBaseOptions(b *testing.B) {
	v := BaseOptions{}
	var buf bytes.Buffer

import jcifs.smb.SmbException;

@ExtendWith(MockitoExtension.class)
class SamrPolicyHandleTest {

    @Mock
    private DcerpcHandle mockHandle;

    @BeforeEach
    void setUp() {
        // Reset mocks before each test
        reset(mockHandle);
    }

    @Test
    void testConstructor_SuccessfulConnect4() throws IOException {
        // Test case: Constructor with successful MsrpcSamrConnect4

            waitNewUrlCount++;
            if (shouldThrowException) {
                throw new RuntimeException("Test exception in delayForWaitingNewUrl");
            }
        }

        void reset() {
            beforeProcessingCount = 0;
            afterProcessingCount = 0;
            noUrlInQueueCount = 0;
            waitNewUrlCount = 0;
            shouldThrowException = false;
        }
    }

            consumer.accept(line);
            buf.reset();
        }
    }

    public void forceFlush() {
        if (buf.size() > 0) {
            String line = new String(buf.toByteArray(), 0, buf.size());
            ProjectBuildLogAppender.updateMdc();
            consumer.accept(line);
            buf.reset();
        }
    }

    static class EolBaos extends ByteArrayOutputStream {

        // Mark current position
        stream.mark(10);

        assertEquals('C', stream.read());
        assertEquals('D', stream.read());

        // Reset to marked position
        stream.reset();

        // Should read from marked position again
        assertEquals('C', stream.read());
        assertEquals('D', stream.read());
    }

        verify(mockResponse, times(1)).setExpiration(expiration);
    }

    @Test
    void testReset() {
        // Call the method
        mockResponse.reset();

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

    @Test
    void testGetException() {
        Exception testException = new RuntimeException("Test Exception");