*
     * <p>This method configures the condition bean with search criteria from the pager,
     * including name wildcards, handler name wildcards, and description matching.
     * Results are ordered by sort order and name in ascending order.</p>
     *
     * <p>Description matching supports:</p>
     * <ul>
     *   <li>Wildcard matching (if starts or ends with *)</li>
     *   <li>Prefix matching (if ends with *)</li>

    assertThat(graph.hasEdgeConnecting(EndpointPair.unordered(N1, N2))).isTrue();
    assertThat(graph.hasEdgeConnecting(EndpointPair.unordered(N2, N1))).isTrue();
  }

  @Test
  public void hasEdgeConnecting_mismatch() {
    putEdge(N1, N2);
    assertThat(graph.hasEdgeConnecting(EndpointPair.ordered(N1, N2))).isFalse();
    assertThat(graph.hasEdgeConnecting(EndpointPair.ordered(N2, N1))).isFalse();
  }

  @Test

    assertThat(SignedBytes.join(",", (byte) -128, (byte) -1)).isEqualTo("-128,-1");
  }

  @J2ktIncompatible // b/285319375
  public void testLexicographicalComparator() {
    List<byte[]> ordered =
        Arrays.asList(
            new byte[] {},
            new byte[] {LEAST},
            new byte[] {LEAST, LEAST},
            new byte[] {LEAST, (byte) 1},
            new byte[] {(byte) 1},

 *
 * <ul>
 *   <li>directed graphs
 *   <li>undirected graphs
 *   <li>graphs that do/don't allow parallel edges
 *   <li>graphs that do/don't allow self-loops
 *   <li>graphs whose nodes/edges are insertion-ordered, sorted, or unordered
 *   <li>graphs whose edges are <a
 *       href="https://github.com/google/guava/wiki/GraphsExplained#uniqueness">unique</a> objects
 * </ul>
 *
 * <h3>Building a {@code Network}</h3>
 *

 */
@NullUnmarked
public abstract class AbstractStandardUndirectedNetworkTest extends AbstractNetworkTest {
  private static final EndpointPair<Integer> ENDPOINTS_N1N2 = EndpointPair.ordered(N1, N2);
  private static final EndpointPair<Integer> ENDPOINTS_N2N1 = EndpointPair.ordered(N2, N1);

  @After
  public void validateUndirectedEdges() {
    for (Integer node : network.nodes()) {
      new EqualsTester()
          .addEqualityGroup(

        return fileConfigBhv.selectByPK(id);
    }

    /**
     * Retrieves a file configuration by its name.
     * If multiple configurations exist with the same name, returns the first one
     * ordered by sort order.
     *
     * @param name the name of the file configuration to retrieve
     * @return an OptionalEntity containing the file configuration if found, empty otherwise
     */

    return new TreeBasedTable<>(Ordering.natural(), Ordering.natural());
  }

  /**
   * Creates an empty {@code TreeBasedTable} that is ordered by the specified comparators.
   *
   * @param rowComparator the comparator that orders the row keys
   * @param columnComparator the comparator that orders the column keys
   */
  public static <R, C, V> TreeBasedTable<R, C, V> create(

   * {@inheritDoc}
   *
   * <p>By default, returns the supplied elements in their given order; however, generators for
   * containers with a known order other than insertion order must override this method.
   *
   * <p>Note: This default implementation is overkill (but valid) for an unordered container. An
   * equally valid implementation for an unordered container is to throw an exception. The chosen

  public void testForEachKnownOrder() {
    List<E> elements = new ArrayList<>();
    collection.forEach(elements::add);
    List<E> expected = copyToList(getOrderedElements());
    assertEquals("Different ordered iteration", expected, elements);
  }

      public int resultIndex(int higherIndex) {
        return ~higherIndex;
      }
    };

    abstract int resultIndex(int higherIndex);
  }

  /**
   * Searches the specified naturally ordered list for the specified object using the binary search
   * algorithm.
   *
   * <p>Equivalent to {@link #binarySearch(List, Function, Object, Comparator, KeyPresentBehavior,