assertNotSame(shadowClass, WillBeUnloadedException.class);
    getChecked(immediateFuture("foo"), shadowClass);
    return new WeakReference<>(shadowLoader);
  }

  /*
   * TODO(cpovirk): It would be great to run all these tests (including class unloading) in an
   * environment that forces Futures.getChecked to its fallback WeakSetValidator. One awful way of

        assertArrayEquals(blob, resp.getBlob());
        assertEquals(0, resp.getSessionFlags());
        assertFalse(resp.isLoggedInAsGuest());
    }

    @Test
    @DisplayName("Decode with ACCESS_DENIED should treat as error response")
    void testDecodeErrorResponsePath() throws Exception {
        Smb2SessionSetupResponse resp = newResponse();

        byte[] buf = new byte[256];
        int headerStart = 0;

                    c = Character.codePointAt(both, 0);
                    i++;
                } catch (IndexOutOfBoundsException ex) {
                    // high surrogate without low surrogate. Not a lot we can do here except treat it as a regular
                    // character
                }
            }

            if (c == '.') {
                if (i == startIndex) {
                    list.add(IntItem.ZERO);

Their sponsorship also demonstrates a strong commitment to the FastAPI **community** (you), showing that they care not only about offering a **great service** but also about supporting a **robust and thriving framework**, FastAPI. 🙇

For example, you might want to try:

/**
 * A wrapper class for unsigned {@code int} values, supporting arithmetic operations.
 *
 * <p>In some cases, when speed is more important than code readability, it may be faster simply to
 * treat primitive {@code int} values as unsigned, using the methods from {@link UnsignedInts}.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/PrimitivesExplained#unsigned-support">unsigned

          state = STATE_READ_RESPONSE_HEADERS
          responseBuilder
        }
        statusLine.code in (102 until 200) -> {
          // Processing and Early Hints will mean a second headers are coming.
          // Treat others the same for now
          state = STATE_READ_RESPONSE_HEADERS
          responseBuilder
        }
        else -> {
          state = STATE_OPEN_RESPONSE_BODY
          responseBuilder
        }

/**
 * A wrapper class for unsigned {@code long} values, supporting arithmetic operations.
 *
 * <p>In some cases, when speed is more important than code readability, it may be faster simply to
 * treat primitive {@code long} values as unsigned, using the methods from {@link UnsignedLongs}.
 *
 * <p>See the Guava User Guide article on <a
 * href="https://github.com/google/guava/wiki/PrimitivesExplained#unsigned-support">unsigned

      setException(e);
      return;
    } catch (Error e) {
      /*
       * StackOverflowError, OutOfMemoryError (e.g., from allocating ExecutionException), or
       * something. Try to treat it like a RuntimeException. If we overflow the stack again, the
       * resulting Error will propagate upward up to the root call to set().
       */
      setException(e);
      return;
    }

        block.headerStart = 0;

        byte[] buf = new byte[64];
        buf[0] = 4; // wordCount
        buf[1] = 0x42; // andxCommand
        // andxOffset = 0 triggers workaround -> treat as no andx
        ServerMessageBlock.writeInt2(0, buf, 3);
        ServerMessageBlock.writeInt2(10, buf, 9); // byteCount

        int n = block.readAndXWireFormat(buf, 0);
        assertTrue(n > 0);

      setException(e);
      return;
    } catch (Error e) {
      /*
       * StackOverflowError, OutOfMemoryError (e.g., from allocating ExecutionException), or
       * something. Try to treat it like a RuntimeException. If we overflow the stack again, the
       * resulting Error will propagate upward up to the root call to set().
       */
      setException(e);
      return;
    }