totalBytesWritten += byteCount
            progressListener.update(totalBytesWritten, contentLength(), completed)
          }

          override fun close() {
            super.close()
            if (!completed) {
              completed = true
              progressListener.update(totalBytesWritten, contentLength(), completed)
            }
          }
        }

    protected byte[] engineDigest() {
        final byte[] digest = md5.digest();
        md5.update(opad);
        return md5.digest(digest);
    }

    @Override
    protected int engineDigest(final byte[] buf, final int offset, final int len) {
        final byte[] digest = md5.digest();
        md5.update(opad);
        md5.update(digest);
        try {
            return md5.digest(buf, offset, len);

        final byte[] digest = this.md5.digest();
        this.md5.update(this.opad);
        return this.md5.digest(digest);
    }

    @Override
    protected int engineDigest(final byte[] buf, final int offset, final int len) {
        final byte[] digest = this.md5.digest();
        this.md5.update(this.opad);
        this.md5.update(digest);
        try {
            return this.md5.digest(buf, offset, len);

        indexingHelper.deleteDocumentsByDocId(client, docList);
        assertEquals("fess.update", resultMap.get("index"));
        assertEquals(0, ((List<String>) resultMap.get("ids")).size());

        docList.add("001");
        indexingHelper.deleteDocumentsByDocId(client, docList);
        assertEquals("fess.update", resultMap.get("index"));
        assertEquals(1, ((List<String>) resultMap.get("ids")).size());

    return (initialCapacity == UNSET_INT) ? DEFAULT_INITIAL_CAPACITY : initialCapacity;
  }

  /**
   * Guides the allowed concurrency among update operations. Used as a hint for internal sizing. The
   * table is internally partitioned to try to permit the indicated number of concurrent updates
   * without contention. Because assignment of entries to these partitions is not necessarily

        final byte[] response = new byte[24];
        MessageDigest hmac = Crypto.getHMACT64(passwordHash);
        hmac.update(Strings.getUNIBytes(user.toUpperCase()));
        hmac.update(Strings.getUNIBytes(domain.toUpperCase()));
        hmac = Crypto.getHMACT64(hmac.digest());
        hmac.update(challenge);
        hmac.update(clientChallenge);
        hmac.digest(response, 0, 16);
        System.arraycopy(clientChallenge, 0, response, 16, 8);

and RHS match (become identical or assignment-compatible, depending on
context).
To that effect, type inference maintains a map of bound type parameters
to inferred type arguments; this map is consulted and updated during type unification.
Initially, the bound type parameters are known but the map is empty.
During type unification, if a new type argument <code>A</code> is inferred,

		switch reflectValue.Kind() {
		case reflect.Slice, reflect.Array:
			var (
				elem        reflect.Value
				isArrayKind = reflectValue.Kind() == reflect.Array
			)

			if !update || reflectValue.Len() == 0 {
				update = false
				if isArrayKind {
					db.Statement.ReflectValue.Set(reflect.Zero(reflectValue.Type()))
				} else {

     * @return the document count
     */
    long getDocumentSize();

    /**
     * Returns the total execution time for index update operations.
     *
     * @return the execution time in milliseconds
     */
    long getExecuteTime();

    /**
     * Commits all pending index update operations to ensure data persistence.
     * This method should be called after all documents have been stored.
     */
    void commit();

	}
}

func TestScanNullValue(t *testing.T) {
	user := GetUser("scan_null_value", Config{})
	DB.Create(&user)

	if err := DB.Model(&user).Update("age", nil).Error; err != nil {
		t.Fatalf("failed to update column age for struct, got error %v", err)
	}

	var result User
	if err := DB.First(&result, "id = ?", user.ID).Error; err != nil {