// Add a bad intermediate CA and have that issue a rogue certificate for localhost. Prepare
    // an SSL context for an attacking webserver. It includes both these rogue certificates plus the
    // trusted good certificate above. The attack is that by including the good certificate in the
    // chain, we may trick the certificate pinner into accepting the rouge certificate.
    val compromisedIntermediateCa =
      HeldCertificate
        .Builder()

///

## Use `SecurityScopes` { #use-securityscopes }

Now update the dependency `get_current_user`.

This is the one used by the dependencies above.

Here's where we are using the same OAuth2 scheme we created before, declaring it as a dependency: `oauth2_scheme`.

                    return mapEntry("~~ b", (Collection<String>) ImmutableSortedSet.of("~above"));
                  }

                  @Override
                  public Entry<String, Collection<String>> aboveSamplesGreater() {
                    return mapEntry("~~ c", (Collection<String>) ImmutableSortedSet.of("~above"));
                  }
                })
            .named("TreeMultimap.asMap")

    }

    /**
     * Returns the base directory above the root package from a URL representing a file.
     *
     * @param url
     *            The URL representing the file.
     * @param baseName
     *            The base name.
     * @return The base directory above the root package.
     */
    protected static File getBaseDir(final URL url, final String baseName) {

    /*
     * Under Java 8, there is no need to test the no-VarHandle case here: It's already tested by the
     * main AbstractFutureTest, which uses the default AtomicHelper, which we verified above to be
     * UnsafeAtomicHelper.
     */
    if (!isJava8()) {
      runTestMethod(NO_VAR_HANDLE);
    }

    runTestMethod(NO_UNSAFE);

    runTestMethod(NO_ATOMIC_REFERENCE_FIELD_UPDATER);

 * are provided.
 * <p>
 * The jCIFS client maps DOS error codes to NTSTATUS codes. This means that
 * the user may receive a different error from a legacy server than that of
 * a newer variant such as Windows NT and above. If you should encounter
 * such a case, please report it to jcifs at samba dot org and we will
 * change the mapping.
 */

public class SmbException extends CIFSException implements NtStatus, DosError, WinError {

    }

    assertThat(server.requestCount).isEqualTo(0)

    // Confirm that the connection pool was not corrupted by making another call. This doesn't use
    // makeSimpleCall() because it uses the MockResponse enqueued above.
    val callB = client.newCall(Request(server.url("/")))
    callB.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
    }
  }

  private fun makeSimpleCall() {

As, by default, singular values are interpreted as query parameters, you don't have to explicitly add a `Query`, you can just do:

```Python
q: Union[str, None] = None
```

Or in Python 3.10 and above:

```Python
q: str | None = None
```

For example:

{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}


/// info

                    "Error while attempting to shut down the service after failure.",
                    ignored);
          }
          notifyFailed(t);
          // requireNonNull is safe now, just as it was above.
          requireNonNull(runningTask).cancel(false); // prevent future invocations.
        } finally {
          lock.unlock();
        }
      }
    }

    private final Runnable task = new Task();

    xStats.addAll(values.xStats());
    if (yStats.count() == 0) {
      sumOfProductsOfDeltas = values.sumOfProductsOfDeltas();
    } else {
      // This is a generalized version of the calculation in add(double, double) above. Note that
      // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result
      // in NaN naturally.
      sumOfProductsOfDeltas +=
          values.sumOfProductsOfDeltas()