logger.log(format("ECL0017", e.getMessage()), e);
        }
    }

    /**
     * Returns the result set.
     *
     * @param statement
     *            {@link Statement}. Must not be {@literal null}.
     * @return The result set.
     */
    public static ResultSet getResultSet(final Statement statement) {
        assertArgumentNotNull("statement", statement);

        try {

    }

    /**
     * Sets whether there is a next page available.
     *
     * @param existNextPage true if there is a next page, false otherwise
     */
    public void setExistNextPage(final boolean existNextPage) {
        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of records to display per page.
     * If the page size is not set or is invalid, returns the default page size.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.collect.Sets.newHashSet;

import java.util.Set;
import org.jspecify.annotations.Nullable;

/** Emulation of AggregateFutureState. */
abstract class AggregateFutureState<OutputT extends @Nullable Object>

      }
    }
    shuffle(queryList, random);
    return queryList.toArray(new Element[0]);
  }

  private Set<Element> createData() {
    Set<Element> set = Sets.newHashSetWithExpectedSize(size);
    while (set.size() < size) {
      set.add(newElement());
    }
    return set;
  }

  private Element newElement() {
    int value = random.nextInt();

   * of their natural ordering.
   */
  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
    return new Builder<>(Collections.reverseOrder());
  }

  /**
   * Returns a builder that creates immutable sorted sets whose elements are ordered by their

     * This method sets the job executor and then calls the abstract execute method.
     *
     * @param jobExecutor the job executor to use for execution
     * @return the execution result message or summary
     */
    public String execute(final JobExecutor jobExecutor) {
        jobExecutor(jobExecutor);
        return execute();
    }

    /**
     * Sets the job executor for this job.
     *

    }

    /**
     * Sets the encoding for the response content.
     *
     * @param encoding the encoding to set.
     */
    public void setEncoding(final String encoding) {
        this.encoding = encoding;
    }

    /**
     * Sets the exception that occurred while accessing the content.
     *
     * @param e the exception to set.
     */

  }

  // Node/edge sets are the same, but node/edge connections differ due to edge type.
  @Test
  public void equivalent_directedVsUndirected() {
    graph.putEdge(N1, N2);

    MutableGraph<Integer> g2 = createGraph(oppositeType(edgeType));
    g2.putEdge(N1, N2);

    assertThat(graph).isNotEqualTo(g2);
  }

  // Node/edge sets and node/edge connections are the same, but directedness differs.

  }

  @LazyInit private transient @Nullable Set<K> keySet;

  @Override
  public Set<K> keySet() {
    Set<K> result = keySet;
    return (result == null) ? keySet = createKeySet() : result;
  }

  abstract Set<K> createKeySet();

  @LazyInit private transient @Nullable Multiset<K> keys;

  @Override
  public Multiset<K> keys() {

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.SampleElements.Ints;
import java.util.List;
import java.util.Set;
import org.jspecify.annotations.NullMarked;

/**
 * Create integer sets for collection tests.
 *
 * @author Gregory Kick
 */
@GwtCompatible
@NullMarked
public abstract class TestIntegerSetGenerator implements TestSetGenerator<Integer> {