// Create test input stream
        String content = "updated1\n" + "updated2\n";
        InputStream is = new ByteArrayInputStream(content.getBytes(StandardCharsets.UTF_8));

        // Update from input stream
        protwordsFile.update(is);

        // Verify update
        PagingList<ProtwordsItem> list = protwordsFile.selectList(0, 100);
        assertEquals(2, list.size());

../mkzip ../../zoneinfo.zip
cd ../..

files="update.bash zoneinfo.zip"
modified=true
if git diff --quiet $files; then
	modified=false
fi

if [ "$1" = "-work" ]; then
	echo Left workspace behind in work/.
	shift
else
	rm -rf work
fi

if ! $modified; then
	echo No updates needed.
	exit 0
fi

echo Updated for $CODE/$DATA: $files

commitmsg="lib/time: update to $CODE/$DATA

# Body - Updates { #body-updates }

## Update replacing with `PUT` { #update-replacing-with-put }

To update an item you can use the <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a> operation.

You can use the `jsonable_encoder` to convert the input data to data that can be stored as JSON (e.g. with a NoSQL database). For example, converting `datetime` to `str`.

	if utils.AssertEqual(result.UpdatedAt, user.UpdatedAt) {
		t.Fatalf("Update struct should update UpdatedAt, was %+v, got %+v", result.UpdatedAt, user.UpdatedAt)
	}

	AssertObjEqual(t, result, User{Name: "update_with_select"}, "Name", "Age")
}

func TestSelectWithUpdateWithMap(t *testing.T) {

        try (MappingUpdater updater = new MappingUpdater(item)) {
            reload(updater);
        }
    }

    /**
     * Reloads the character mapping items from the dictionary file.
     *
     * @param updater the mapping updater to use for writing changes, or null for read-only reload
     */
    protected void reload(final MappingUpdater updater) {

      long next = doubleToRawLongBits(nextVal);
      if (updater.compareAndSet(this, current, next)) {
        return currentVal;
      }
    }
  }

  /**
   * Atomically updates the current value with the results of applying the given function.
   *
   * @param updateFunction the update function
   * @return the updated value
   * @since 31.1
   */
  @CanIgnoreReturnValue

		t.Errorf("UpdatedAt should be updated")
	}

	var animals []Animal
	DB.Find(&animals)
	if count := DB.Model(Animal{}).Where("1=1").Update("CreatedAt", time.Now().Add(2*time.Hour)).RowsAffected; count != int64(len(animals)) {
		t.Error("RowsAffected should be correct when do batch update")
	}

	if lastUpdatedAt.Format(time.RFC3339) == user4.Account.UpdatedAt.Format(time.RFC3339) {
		t.Fatalf("updated at should be updated, but not, old: %v, new %v", lastUpdatedAt.Format(time.RFC3339), user3.Account.UpdatedAt.Format(time.RFC3339))
	} else {
		user.Account.UpdatedAt = user4.Account.UpdatedAt
		CheckUser(t, user4, user)
	}

	t.Run("Polymorphic", func(t *testing.T) {
		pet := Pet{Name: "create"}

        try (ProtwordsUpdater updater = new ProtwordsUpdater(item)) {
            reload(updater);
        }
    }

    /**
     * Reloads the dictionary file with the specified updater.
     * @param updater the updater to use for processing items
     */
    protected void reload(final ProtwordsUpdater updater) {

        assertNull(result);

        updater.close();
    }

    public void test_updater_writeLine() {
        StopwordsFile.StopwordsUpdater updater = stopwordsFile.new StopwordsUpdater(null);

        // Test writing a comment line
        updater.write("# This is a comment");

        updater.close();
    }

    // Test edge cases
    public void test_emptyFile() {