*   <li><b>collision-averse:</b> while it can't be helped that a hash function will sometimes
 *       produce the same hash code for distinct inputs (a "collision"), every hash function strives
 *       to <i>some</i> degree to make this unlikely. (Without this condition, a function that
 *       always returns zero could be called a hash function. It is not.)
 * </ul>
 *

import java.nio.ByteBuffer;
import java.nio.ByteOrder;

/**
 * A convenience base class for implementors of {@code Hasher}; handles accumulating data until an
 * entire "chunk" (of implementation-dependent length) is ready to be hashed.
 *
 * @author Kevin Bourrillion
 * @author Dimitris Andreou
 */
// TODO(kevinb): this class still needs some design-and-document-for-inheritance love
abstract class AbstractStreamingHasher extends AbstractHasher {

	sync.RWMutex

	// map of heal path to heal sequence
	healSeqMap map[string]*healSequence // Indexed by endpoint
	// keep track of the healing status of disks in the memory
	//   false: the disk needs to be healed but no healing routine is started
	//    true: the disk is currently healing
	healLocalDisks map[Endpoint]bool
	healStatus     map[string]healingTracker // Indexed by disk ID
}

        assertTrue(mockResponse.isReceived());

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

    @Test
    void testReceived() {
        // Call the method
        mockResponse.received();

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

    @Test
    void testClearReceived() {

     * Verifies that the encode method of a concrete implementation is called
     * and interacts with the NdrBuffer as expected.
     * @throws NdrException if encoding fails.
     */
    @Test
    void testEncode() throws NdrException {
        // When
        ndrObject.encode(mockBuffer);

        // Then
        // Verify that our mock buffer had the expected method called.
        verify(mockBuffer).enc_ndr_long(123);
    }

    }

    @Test
    void testWrapMethodIsCalled() throws DcerpcException {
        // Test that the wrap method can be called without throwing an exception
        dcerpcSecurityProvider.wrap(mockNdrBuffer);

        // Verify that the wrap method was called exactly once with the mockNdrBuffer
        verify(dcerpcSecurityProvider, times(1)).wrap(mockNdrBuffer);
    }

    @Test

// Temp files created in default Tmp dir
var globalTestTmpDir = os.TempDir()

// reseed - returns a new seed every time the function is called.
func reseed() uint32 {
	return uint32(time.Now().UnixNano() + int64(os.Getpid()))
}

// nextSuffix - provides a new unique suffix every time the function is called.
func nextSuffix() string {
	randmu.Lock()
	r := randN
	// Initial seed required, generate one.
	if r == 0 {

    public Listener() {}

    /**
     * Called when the service transitions from {@linkplain State#NEW NEW} to {@linkplain
     * State#STARTING STARTING}. This occurs when {@link Service#startAsync} is called the first
     * time.
     */
    public void starting() {}

    /**
     * Called when the service transitions from {@linkplain State#STARTING STARTING} to {@linkplain

        verify(smbTransport).unwrap(SmbTransport.class); // Verify that the method was called
    }

    @Test
    void testClose() throws Exception {
        // Act
        smbTransport.close();

        // Assert
        verify(smbTransport).close(); // Verify that the close method was called
    }

    @Test
    void testGetRemoteAddress() {
        // Arrange

package callbacks

import (
	"reflect"

	"gorm.io/gorm"
)

func callMethod(db *gorm.DB, fc func(value interface{}, tx *gorm.DB) bool) {
	tx := db.Session(&gorm.Session{NewDB: true})
	if called := fc(db.Statement.ReflectValue.Interface(), tx); !called {
		switch db.Statement.ReflectValue.Kind() {
		case reflect.Slice, reflect.Array:
			db.Statement.CurDestIndex = 0
			for i := 0; i < db.Statement.ReflectValue.Len(); i++ {