}

    /**
     * Registers a callback to be executed when the computation is complete.
     * @param consumer The callback.
     * @return The promise.
     */
    public Promise then(final Consumer<RESPONSE> consumer) {
        return promise.then(consumer);
    }

    /**
     * Registers a callback to be executed when the computation fails.
     * @param consumer The callback.

        when(fileNotifyInfo1.getAction()).thenReturn(FileNotifyInformation.FILE_ACTION_ADDED);
        when(fileNotifyInfo1.getFileName()).thenReturn("newfile.txt");

        when(fileNotifyInfo2.getAction()).thenReturn(FileNotifyInformation.FILE_ACTION_MODIFIED);
        when(fileNotifyInfo2.getFileName()).thenReturn("existingfile.txt");

        verifyNoMoreInteractions(handle);
    }

    @Test
    @DisplayName("ensureDFSResolved(): throws CIFSException when underlying call fails")
    void ensureDFSResolved_throws() throws Exception {
        // Arrange: configure the mock to throw
        doThrow(new CIFSException("DFS resolution failed")).when(handle).ensureDFSResolved();

        // Act + Assert: exception is propagated with message

           assert expected == actual.get(i)
        }

        when:
        result = gradleRunner(transformTask).build()

        then:
        result.task(transformTask).outcome == TaskOutcome.UP_TO_DATE

        when:
        buildFile.write(buildFile.text.replace("blah", "baz"))
        result = gradleRunner(transformTask).build()

        then:
        result.task(transformTask).outcome == TaskOutcome.SUCCESS

    void testConstructorWithNetbiosNames() {
        when(mockCalledName.getName()).thenReturn("SERVER");
        when(mockCalledName.getNameType()).thenReturn(0x20);
        when(mockCalledName.getScope()).thenReturn(null);

        when(mockCallingName.getName()).thenReturn("CLIENT");
        when(mockCallingName.getNameType()).thenReturn(0x00);
        when(mockCallingName.getScope()).thenReturn(null);

        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {
            mockedCrypto.when(Crypto::getMD5).thenReturn(mockMd5);
            byte[] innerDigest = "inner_digest".getBytes();
            byte[] finalDigest = "final_digest".getBytes();

            when(mockMd5.digest()).thenReturn(innerDigest);
            when(mockMd5.digest(any(byte[].class))).thenReturn(finalDigest);

        smbPipeHandle = mock(SmbPipeHandle.class);

        // Define behavior for the mock handle
        when(smbPipeHandle.getPipe()).thenReturn(mockPipeResource);
        when(smbPipeHandle.getInput()).thenReturn(mockInputStream);
        when(smbPipeHandle.getOutput()).thenReturn(mockOutputStream);
    }

    /**

                    Arguments.of(null, null, "4.1.0", false, "Should disable plugins when only --model-version is set"),
                    Arguments.of(false, null, null, false, "Should disable plugins when --all=false"),
                    Arguments.of(null, null, null, true, "Should enable plugins by default when no options specified"));
        }
    }

	user := *GetUser("update-has-many", Config{})

	if err := DB.Create(&user).Error; err != nil {
		t.Fatalf("errors happened when create: %v", err)
	}

	user.Pets = []*Pet{{Name: "pet1"}, {Name: "pet2"}}
	if err := DB.Save(&user).Error; err != nil {
		t.Fatalf("errors happened when update: %v", err)
	}

	var user2 User
	DB.Preload("Pets").Find(&user2, "id = ?", user.ID)
	CheckUser(t, user2, user)

        }

        @Test
        @DisplayName("should be applicable when --all option is specified")
        void shouldBeApplicableWhenAllOptionSpecified() {
            UpgradeOptions options = mock(UpgradeOptions.class);
            when(options.all()).thenReturn(Optional.of(true));
            when(options.plugins()).thenReturn(Optional.empty());