import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * Test ComparableVersion.
 */
@SuppressWarnings("unchecked")
class ComparableVersionTest {
    private ComparableVersion newComparable(String version) {
        ComparableVersion ret = new ComparableVersion(version);
        String canonical = ret.getCanonical();

            return versionScheme.parseVersionRange(spec);
        } catch (InvalidVersionSpecificationException e) {
            throw new RuntimeException(e);
        }
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    private Map<String, String> createMergedProperties(MavenExecutionRequest request) {
        // this throwaway map is really ONLY to get config from (profiles + env + system + user)

    }
  }

  public void testTwoStageResolution() {
    class ForTwoStageResolution<A extends Number> {
      <B extends A> void verifyTwoStageResolution() {
        @SuppressWarnings({"unchecked", "rawtypes"})
        Type type =
            new TypeToken<B>(getClass()) {}
            // B's bound may have already resolved to something.
            // Make sure it can still further resolve when given a context.

    }
  }

  public void testTwoStageResolution() {
    class ForTwoStageResolution<A extends Number> {
      <B extends A> void verifyTwoStageResolution() {
        @SuppressWarnings({"unchecked", "rawtypes"})
        Type type =
            new TypeToken<B>(getClass()) {}
            // B's bound may have already resolved to something.
            // Make sure it can still further resolve when given a context.

           * handle either reference, so it's safe to circumvent compile-time type checking.
           */
          @SuppressWarnings("unchecked")
          Equivalence<Object> equivalence = (Equivalence<Object>) this.equivalence;
          return equivalence.equivalent(this.reference, that.reference);
        }
      }
      return false;
    }

   * This does perform a little more work than necessary, so another option is to insert an
   * unchecked cast at some later point:
   *
   * {@snippet :
   * @SuppressWarnings("unchecked") // safe because of ::isInstance check
   * ImmutableList<NewType> result =
   *     (ImmutableList) stream.filter(NewType.class::isInstance).collect(toImmutableList());
   * }

   *
   * <p>This is equivalent to {@code Stream.of(streams).flatMap(stream -> stream)}, but the returned
   * stream may perform better.
   *
   * @see Stream#concat(Stream, Stream)
   */
  @SuppressWarnings("unchecked") // could probably be avoided with a forwarding Spliterator
  @SafeVarargs
  public static <T extends @Nullable Object> Stream<T> concat(Stream<? extends T>... streams) {

   * This does perform a little more work than necessary, so another option is to insert an
   * unchecked cast at some later point:
   *
   * {@snippet :
   * @SuppressWarnings("unchecked") // safe because of ::isInstance check
   * ImmutableList<NewType> result =
   *     (ImmutableList) stream.filter(NewType.class::isInstance).collect(toImmutableList());
   * }

        }
    }

    private void assertHighlightedQueries(Set<String> highlightedQuerySet) {
        @SuppressWarnings("unchecked")
        Set<String> set = (Set<String>) getMockRequest().getAttribute(Constants.HIGHLIGHT_QUERIES);
        if (highlightedQuerySet != null) {

      stream.defaultWriteObject();
      stream.writeObject(inverse());
    }

    @GwtIncompatible
    @J2ktIncompatible
        @SuppressWarnings("unchecked") // reading data stored by writeObject
    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
      stream.defaultReadObject();