* mirror, its URL and ID will be updated to match the values from the mirror specification. Repositories without a
     * matching mirror will pass through unchanged. Note: This method must be called before
     * {@link #injectAuthentication(List, List)} or the repositories will end up with the wrong credentials.
     *

	}
	if beforeUpdateCall != 1 {
		t.Fatalf("before update should be called")
	}

	err = DB.Model(Product5{}).Where("id", p.ID).Update("name", "update_name_2").Error
	if !errors.Is(err, gorm.ErrInvalidValue) {
		t.Fatalf("should got RecordNotFound, but got %v", err)
	}
	if beforeUpdateCall != 1 {
		t.Fatalf("before update should not be called")
	}

         * Verifies that the close method can be called without throwing an exception.
         * @throws CIFSException if an error occurs during close.
         */
        @Test
        public void testClose() throws CIFSException {
            assertDoesNotThrow(() -> smbPipeHandle.close(), "close() should not throw an exception on a mock object.");
            // Verify that the close method was called
            Mockito.verify(smbPipeHandle).close();

        InetAddress addr = mock(InetAddress.class);
        when(addr.getHostName()).thenReturn(hostname);
        UniAddress ua = new UniAddress(addr);
        // Act
        String called = ua.firstCalledName();
        // Assert
        assertEquals(expectedPrefix, called, "firstCalledName should return uppercase prefix or SMBSERVER_NAME");
    }

    @Test
    void nextCalledNameWithNbtAddressReturnsDelegateValue() {
        // Arrange

func (s *Singleton[T]) IsSet() bool {
	select {
	case <-s.set:
		return true
	default:
		return false
	}
}

// Set the value and unblock all Get requests.
// This may only be called once, a second call will panic.
func (s *Singleton[T]) Set(v *T) {
	s.v = v
	close(s.set)

    // JVM shutdown will not be prevented from exiting after this service has stopped or failed.
    // Technically this listener is added after start() was called so it is a little gross, but it
    // is called within doStart() so we know that the service cannot terminate or fail concurrently
    // with adding this listener so it is impossible to miss an event that we are interested in.
    addListener(

 *
 * <p>The service is called during model building for all model objects, allowing
 * implementations to decide which objects to process and how to optimize them.</p>
 *
 * @since 4.0.0
 */
public interface ModelObjectProcessor {

    /**
     * Process a model object, potentially returning a pooled or optimized version.
     *
     * <p>This method is called during model building for various model objects.

        assertEquals(expectedFlags, msrpcSamrOpenDomain.getFlags(), "flags should be initialized to DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG");

        // Since SamrOpenDomain's constructor is called, we implicitly test that the arguments
        // are passed up. Mockito cannot directly verify super() calls without PowerMock,
        // which is not ideal for simple constructor tests.

       * requireNonNull is safe because we don't null out `sequencer` except:
       *
       * - after the requireNonNull call below. (And this object has its Runnable.run override
       *   called only once, just as it has its Executor.execute override called only once.)
       *
       * - if we return immediately from `execute` (in which case we never get here)
       *

    manager.awaitStopped(5, SECONDS); // no exception thrown
  }

  /**
   * This covers a case where if the last service to stop failed then the stopped callback would
   * never be called.
   */
  public void testSingleFailedServiceCallsStopped() {
    Service a = new FailStartService();
    ServiceManager manager = new ServiceManager(asList(a));
    RecordingListener listener = new RecordingListener();