# [Include]
        # String columns may not be needed
        # to be set these condition-keys basically.
        #; GreaterThan = map:{}
        #; LessThan = map:{}
        #; GreaterEqual = map:{}
        #; LessEqual = map:{}

        # [Exclude]
        # Common columns of String type may not be needed
        # to be set these condition-keys basically.
        #; !NotEqual = map:{ $$ALL$$ = list:{ $$CommonColumn$$ } }

     *
     * They may be subsequently nulled out by TreeMultiset.clear(). I think that the only place that
     * we can reference a node whose fields have been cleared is inside the iterator (and presumably
     * only under concurrent modification).
     *
     * To access these fields when you know that they are not null, call the pred() and succ()
     * methods, which perform null checks before returning the fields.
     */

     * @return the domain the user account is in
     */
    String getUserDomain();

    /**
     * Check if these are anonymous credentials.
     * @return whether these are anonymous credentials
     */
    boolean isAnonymous();

    /**
     * Check if these are guest credentials.
     * @return whether these are guest credentials
     */
    boolean isGuest();

These are the exceptions that you can raise to show errors to the client.

When you raise an exception, as would happen with normal Python, the rest of the execution is aborted. This way you can raise these exceptions from anywhere in the code to abort a request and show the error to the client.

You can use:

* `HTTPException`
* `WebSocketException`

These exceptions can be imported directly from `fastapi`:

  private final NullPointerTester nullPointerTester = new NullPointerTester();

  public ClassSanityTester() {
    // TODO(benyu): bake these into ArbitraryInstances.
    setDefault(byte.class, (byte) 1);
    setDefault(Byte.class, (byte) 1);
    setDefault(short.class, (short) 1);
    setDefault(Short.class, (short) 1);
    setDefault(int.class, 1);

"errors" "math/bits" ) const ( // _W is the size in bits of our limbs. _W = bits.UintSize // _S is the size in bytes of our limbs. _S = _W / 8 ) // Note: These functions make many loops over all the words in a Nat. // These loops used to be in assembly, invisible to -race, -asan, and -msan, // but now they are in Go and incur significant overhead in those modes. // To bring the old performance back, we mark all functions that loop // over Nat words with //go:norace. Because //go:norace does not // propagate...

          NullPointerException.class, () -> builder.addAll((Iterable<String>) iterableWithNulls));
    }
  }

  /**
   * Verify thread safety by using a collection whose size() may be inconsistent with the actual
   * number of elements and whose elements may change over time.
   *
   * <p>This test might fail in GWT because the GWT emulations might count on the input collection

      cache.getUnchecked(1);
      cache.getUnchecked(2);

      Set<Object> keys = cache.asMap().keySet();
      // We don't know whether these are still in the cache, so we can't assert on the return
      // values of these removes, but the cache should be empty after the removes, regardless.
      keys.remove(1);
      keys.remove(2);
      assertFalse(keys.remove(null));

  /** Returns an iterable whose iterator returns the given elements in order. */
  public static <E extends @Nullable Object> MinimalIterable<E> of(E... elements) {
    // Make sure to get an unmodifiable iterator
    return new MinimalIterable<>(asList(elements).iterator());
  }

  /**
   * Returns an iterable whose iterator returns the given elements in order. The elements are copied

 * allowed to be reclaimed if nobody is holding on to them. This is useful, for example, if one
 * wants to create a {@code Striped<Lock>} of many locks, but worries that in most cases only a
 * small portion of these would be in use.
 *
 * <p>Prior to this class, one might be tempted to use {@code Map<K, Lock>}, where {@code K}
 * represents the task. This maximizes concurrency by having each unique key mapped to a unique