* newFuture is a future that completes after this and all prior tasks are done.
     * oldFuture is the previous task's newFuture.
     * outputFuture is the future we return to the caller, a nonCancellationPropagating taskFuture.
     *
     * newFuture is guaranteed to only complete once all tasks previously submitted to this instance
     * have completed - namely after oldFuture is done, and taskFuture has either completed or been

        });
    }

    /**
     * Upload a stopwords file.
     *
     * @param form the upload form containing the file and dictionary ID
     * @return HTML response redirecting to the list page after successful upload
     */
    @Execute
    @Secured({ ROLE })
    public HtmlResponse upload(final UploadForm form) {
        validate(form, messages -> {}, () -> uploadpage(form.dictId));

		t, err := objlock.UTCNowNTP()
		if err != nil {
			// it is safe to assume that the object is locked when
			// we can't get the current time
			return true
		}
		if ret.RetainUntilDate.After(t) {
			return true
		}
	}
	return false
}

// eval will return a lifecycle event for each object in objs for a given time.
func (e *Evaluator) eval(objs []ObjectOpts, now time.Time) []Event {

      if (trySplit != null) {
        assertEquals(
            "sum of estimated sizes of trySplit and original spliterator after trySplit",
            originalSize,
            trySplit.estimateSize() + spliterator.estimateSize());
      } else {
        assertEquals(
            "estimated size of spliterator after failed trySplit",
            originalSize,
            spliterator.estimateSize());
      }
    }

      if (trySplit != null) {
        assertEquals(
            "sum of estimated sizes of trySplit and original spliterator after trySplit",
            originalSize,
            trySplit.estimateSize() + spliterator.estimateSize());
      } else {
        assertEquals(
            "estimated size of spliterator after failed trySplit",
            originalSize,
            spliterator.estimateSize());
      }
    }

  Lockable {
  private val key: String

  /** Non-null for client web sockets. These can be canceled. */
  internal var call: Call? = null

  /** This task processes the outgoing queues. Call [runWriter] to after enqueueing. */
  private var writerTask: Task? = null

  /** Null until this web socket is connected. Only accessed by the reader thread. */
  private var reader: WebSocketReader? = null

            this.supplier = supplier;
        }

        /**
         * Executes the provided {@link Consumer} with a {@link Stream} obtained from the supplier.
         * The stream is automatically closed after the consumer is executed.
         *
         * @param stream the {@link Consumer} to process the {@link Stream}
         */
        public void of(final Consumer<Stream<T>> stream) {

     */
    public OptionalEntity<RelatedContent> getRelatedContent(final String id) {
        return relatedContentBhv.selectByPK(id);
    }

    /**
     * Stores (inserts or updates) a related content entity.
     * After storing, updates the related content helper to refresh the cache.
     *
     * @param relatedContent the RelatedContent entity to store
     */
    public void store(final RelatedContent relatedContent) {

import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit
import kotlin.coroutines.cancellation.CancellationException
import okio.Buffer
import org.junit.After
import org.junit.Assert.assertEquals
import org.junit.Assert.assertTrue
import org.junit.Test
import org.junit.runner.RunWith

/**
 * Android HttpEngine.
 */
@RunWith(AndroidJUnit4::class)

With **FastAPI** it's very easy (thanks to Starlette), check the docs: [Testing](../tutorial/testing.md){.internal-link target=_blank}

After you have tests, then you can upgrade the **FastAPI** version to a more recent one, and make sure that all your code is working correctly by running your tests.

If everything is working, or after you make the necessary changes, and all your tests are passing, then you can pin your `fastapi` to that new recent version.