char result = (char) value;
    checkArgument(result == value, "Out of range: %s", value);
    return result;
  }

  /**
   * Returns the {@code char} nearest in value to {@code value}.
   *
   * @param value any {@code long} value
   * @return the same value cast to {@code char} if it is in the range of the {@code char} type,

 *
 * The configuration of each spec changes with each OkHttp release. This is annoying: upgrading
 * your OkHttp library can break connectivity to certain web servers! But it’s a necessary annoyance
 * because the TLS ecosystem is dynamic and staying up to date is necessary to stay secure. See
 * [OkHttp's TLS Configuration History][tls_history] to track these changes.
 *

    assertThat(emptyGraph.nodeOrder()).isEqualTo(ElementOrder.<String>natural());
  }

  /**
   * Tests that the ImmutableValueGraph.Builder doesn't change when the creating ValueGraphBuilder
   * changes.
   */
  @Test
  @SuppressWarnings("CheckReturnValue")
  public void immutableValueGraphBuilder_copiesGraphBuilder() {
    ValueGraphBuilder<String, Object> graphBuilder =
        ValueGraphBuilder.directed()

   capacity and competence.

 * **Be considerate**: People use our work, and we depend on the work of others. Consider users and
   colleagues before taking action. For example, changes to code, infrastructure, policy, and
   documentation may negatively impact others.

 * **Be respectful**: We expect people to work together to resolve conflict, assume good intentions,

        Object element = transaction.nextElement();
        assertSame(transaction, element, "First nextElement should return the transaction itself");
    }

    @Test
    @DisplayName("Test nextElement() changes command on second call")
    void testNextElementSecondCall() {
        // First call - primary
        transaction.nextElement();
        byte initialCommand = transaction.command;

   */
  protected void startUp() throws Exception {}

  /**
   * Run the service. This method is invoked on the execution thread. Implementations must respond
   * to stop requests. You could poll for lifecycle changes in a work loop:
   *
   * <pre>
   *   public void run() {
   *     while ({@link #isRunning()}) {
   *       // perform a unit of work
   *     }
   *   }
   * </pre>
   *

     */
    public String queryId;

    /**
     * The user session ID field for filtering logs by session.
     */
    public String userSessionId;

    /**
     * The requested time range field for filtering logs by date.
     */
    public String requestedTimeRange;

    /**
     * The access type field for filtering logs by access method.
     */
    public String accessType;

    /**

@NullUnmarked
public class PowerSetBenchmark {
  @Param({"2", "4", "8", "16"})
  int elements;

  Set<Set<Integer>> powerSet;

  @BeforeExperiment
  void setUp() {
    Set<Integer> set = ContiguousSet.create(Range.closed(1, elements), integers());
    powerSet = Sets.powerSet(set);
  }

  @Benchmark
  int iteration(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Set<Integer> subset : powerSet) {

     *     are out of range of an unsigned short
     */
    // TODO: why is this public?
    public TeredoInfo(
        @Nullable Inet4Address server, @Nullable Inet4Address client, int port, int flags) {
      checkArgument(
          (port >= 0) && (port <= 0xffff), "port '%s' is out of range (0 <= port <= 0xffff)", port);
      checkArgument(

          .put(Comparable.class, ByToString.INSTANCE)
          .put(Comparator.class, AlwaysEqual.INSTANCE)
          .put(Ordering.class, AlwaysEqual.INSTANCE)
          .put(Range.class, Range.all())
          .put(MapDifference.class, Maps.difference(ImmutableMap.of(), ImmutableMap.of()))
          .put(
              SortedMapDifference.class,