* <li>Version components in the text can be digits or strings,</li>
 * <li>Strings are checked for well-known qualifiers, and the qualifier ordering is used for version ordering.
 *     Well-known qualifiers (case-insensitive) are, in order from least to greatest:<ol>
 *     <li><code>alpha</code> or <code>a</code></li>
 *     <li><code>beta</code> or <code>b</code></li>
 *     <li><code>milestone</code> or <code>m</code></li>

        removeSourceRoot(ProjectScope.TEST, Language.JAVA_FAMILY, path);
    }
    /**
     * {@return all source root directories, including the disabled ones, for all languages and scopes}.
     * The iteration order is the order in which the sources are declared in the POM file.
     * The returned collection is unmodifiable.
     *
     * @see #addSourceRoot(SourceRoot)
     */
    public Collection<SourceRoot> getSourceRoots() {

    /** The regex pattern. */
    public String regex;

    /** The replacement string. */
    public String replacement;

    /** The process type. */
    public String processType;

    /** The sort order. */
    public String sortOrder;

    /** The creator. */
    public String createdBy;

    /** The creation time. */
    public String createdTime;

    /** The version number. */

///

## Порядок выполнения нескольких middleware { #multiple-middleware-execution-order }

  }

  /**
   * Compares the specified object to this multimap for equality.
   *
   * <p>Two {@code ListMultimap} instances are equal if, for each key, they contain the same values
   * in the same order. If the value orderings disagree, the multimaps will not be considered equal.
   */
  @Override
  public boolean equals(@Nullable Object object) {
    return super.equals(object);
  }

                    return new StandardImplForwardingSortedMultiset<>(
                        TreeMultiset.create(asList(elements)));
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {
                    return Ordering.natural().sortedCopy(insertionOrder);
                  }
                })
            .named("ForwardingSortedMultiset with standard impls")

    g2.putEdge(N1, N2);

    assertThat(graph).isEqualTo(g2);
  }

  // Node/edge sets and node/edge connections are the same, but edge order differs.
  // In this case the graphs are considered equivalent; the edge add orderings are irrelevant.
  @Test
  public void equivalent_edgeAddOrdersDiffer() {
    GraphBuilder<Integer> builder = GraphBuilder.from(graph);

     */
    public String boost;

    /**
     * Search criteria: availability status.
     */
    public String available;

    /**
     * Search criteria: sort order.
     */
    public String sortOrder;

    /**
     * Search criteria: creator user.
     */
    public String createdBy;

    /**
     * Search criteria: creation time.
     */

        ChannelInfo second = loadBalancer.selectChannel(mockMessage);

        assertNotNull(first);
        assertNotNull(second);
        // Due to round-robin, should get different channels or same order
        assertTrue(Arrays.asList(channel1, channel2).contains(first));
        assertTrue(Arrays.asList(channel1, channel2).contains(second));
    }

    @Test
    void testLeastLoadedStrategy() {

    public Entry<TypeToken, Object>[] createArray(int length) {
      return (Entry<TypeToken, Object>[]) new Entry<?, ?>[length];
    }

    @Override
    public Iterable<Entry<TypeToken, Object>> order(List<Entry<TypeToken, Object>> insertionOrder) {
      return insertionOrder;
    }
  }