return (Listener) listenersUpdater.getAndSet(future, update);
    }

    @Override
    @Nullable Waiter gasWaiters(AbstractFutureState<?> future, Waiter update) {
      return (Waiter) waitersUpdater.getAndSet(future, update);
    }

    @Override
    boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
      return valueUpdater.compareAndSet(future, expect, update);

	doneCh := make(chan error, 1)
	defer xioutil.SafeClose(doneCh)

	// Save rebalance.bin periodically.
	go func() {
		// Update rebalance.bin periodically once every 5-10s, chosen randomly
		// to avoid multiple pool leaders herding to update around the same
		// time.
		r := rand.New(rand.NewSource(time.Now().UnixNano()))
		randSleepFor := func() time.Duration {

      return listenersUpdater.getAndSet(future, update);
    }

    @Override
    @Nullable Waiter gasWaiters(AbstractFutureState<?> future, Waiter update) {
      return waitersUpdater.getAndSet(future, update);
    }

    @Override
    boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
      return valueUpdater.compareAndSet(future, expect, update);
    }

      return ImmutableMap.copyOf(loadTimes);
    }

    /**
     * Updates the state with the given service transition.
     *
     * <p>This method performs the main logic of ServiceManager in the following steps.
     *
     * <ol>
     *   <li>Update the {@link #servicesByState()}
     *   <li>Update the {@link #startupTimers}
     *   <li>Based on the new state queue listeners to run

      return ImmutableMap.copyOf(loadTimes);
    }

    /**
     * Updates the state with the given service transition.
     *
     * <p>This method performs the main logic of ServiceManager in the following steps.
     *
     * <ol>
     *   <li>Update the {@link #servicesByState()}
     *   <li>Update the {@link #startupTimers}
     *   <li>Based on the new state queue listeners to run

        for (int i = key.length; i < 64; i++) {
            ipad[i] = 0x36;
            opad[i] = 0x5c;
        }

        md5.update(ipad);
        md5.update(data);
        byte[] innerHash = md5.digest();

        md5.reset();
        md5.update(opad);
        md5.update(innerHash);
        byte[] expected = md5.digest();

        try (MockedStatic<Crypto> mockedCrypto = mockStatic(Crypto.class)) {

		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{clause.Update{}},
			"UPDATE `users`", nil,
		},
		{
			[]clause.Interface{clause.Update{Modifier: "LOW_PRIORITY"}},
			"UPDATE LOW_PRIORITY `users`", nil,
		},
		{
			[]clause.Interface{clause.Update{Table: clause.Table{Name: "products"}, Modifier: "LOW_PRIORITY"}},
			"UPDATE LOW_PRIORITY `products`", nil,
		},
	}

	for idx, result := range results {

        /**
         * Called when the timeout expires. Updates the job log if the job is still running.
         */
        @Override
        public void expired() {
            if (jobLog.getEndTime() == null) {
                jobLog.setLastUpdated(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());
                if (logger.isDebugEnabled()) {
                    logger.debug("Update {}", jobLog);
                }

      entries[srcIndex] = 0;

      // also need to update whoever's "next" pointer was pointing to the last entry place
      int tableIndex = smearedHash(object) & mask;
      int next = CompactHashing.tableGet(table, tableIndex);
      int srcNext = srcIndex + 1;
      if (next == srcNext) {
        // we need to update the root pointer
        CompactHashing.tableSet(table, tableIndex, dstIndex + 1);

    public void addInclude(String include) {
        // Update the underlying Resource model
        super.addInclude(include);

        // Update the project's SourceRoots
        updateProjectSourceRoot();
    }

    @Override
    public void removeInclude(String include) {
        // Update the underlying Resource model
        super.removeInclude(include);

        // Update the project's SourceRoots