# Additional Status Codes { #additional-status-codes }

By default, **FastAPI** will return the responses using a `JSONResponse`, putting the content you return from your *path operation* inside of that `JSONResponse`.

It will use the default status code or the one you set in your *path operation*.

## Additional status codes { #additional-status-codes_1 }

      object : EventListener() {
        var socket: SSLSocket? = null
        var closed = false

        override fun connectionAcquired(
          call: Call,
          connection: Connection,
        ) {
          socket = connection.socket() as SSLSocket
        }

        override fun requestHeadersStart(call: Call) {
          if (closed) {
            throw IOException("fake socket failure")
          }
        }

        return this.open && this.tree_num == this.tree.getTreeId() && this.tree.isConnected();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close(long)
     */
    @Override
    public synchronized void close(final long lastWriteTime) throws CIFSException {
        closeInternal(lastWriteTime, true);
    }

    /**
     * @param lastWriteTime
     * @throws SmbException
     */

        @Throws(IOException::class)
        override fun close() {
          if (!cacheRequestClosed &&
            !discard(ExchangeCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)
          ) {
            cacheRequestClosed = true
            cacheRequest.abort()
          }
          source.close()
        }
      }

     * Enqueued on shutdown to release threads waiting on [dispatch]. Note that this response
     * isn't transmitted because the connection is closed before this response is returned.
     */
    private val DEAD_LETTER = MockResponse(code = HTTP_UNAVAILABLE)

    private val logger = Logger.getLogger(QueueDispatcher::class.java.name)
  }

          e: IOException,
        ) {
          exceptionRef.set(e)
          latch.countDown()
        }

        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()

    while (!toClose.isEmpty()) {
      toClose.pop().close()
    }
    taskFaker.close()

    (filesystem.delegate as? FakeFileSystem)?.checkNoOpenFiles()
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)
  fun emptyCache(parameters: Pair<FileSystem, Boolean>) {
    setUp(parameters.first, parameters.second)
    cache.close()
    assertJournalEquals()
  }

    @Test
    public void testMultipleCloseCalls() {
        keyManager.storeSessionKey("session", testKey, "AES");

        keyManager.close();
        keyManager.close(); // Should not throw

        assertEquals(0, keyManager.getKeyCount(), "Should have no keys after close");
    }

    @Test
    public void testAutoCloseable() throws Exception {
        try (SecureKeyManager manager = new SecureKeyManager()) {

        UnsupportedOperationException ex = assertThrows(UnsupportedOperationException.class, it::remove);
        assertEquals("remove", ex.getMessage());
    }

    @Nested
    @DisplayName("Invalid constructor inputs")
    class InvalidInputs {
        @Test
        @DisplayName("Null delegate causes NullPointerException during construction")
        void nullDelegate_throwsNPE() throws Exception {

     */
    InputStream openInputStream() throws CIFSException;

    /**
     * Close/release the file
     *
     * This releases all resources that this file holds. If not using strict mode this is currently a no-op.
     *
     * @see java.lang.AutoCloseable#close()
     */
    @Override
    void close();

    /**
     * Fetch all children
     *
     * @return an iterator over the child resources