}

        return Objects.equals(a1.getGroupId(), a2.getGroupId())
                && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
                && Objects.equals(a1.getType(), a2.getType())
                && Objects.equals(a1.getVersion(), a2.getVersion())
                && Objects.equals(a1.getClassifier(), a2.getClassifier())
                && Objects.equals(a1.getScope(), a2.getScope())

        if (sourceLevelSet) {
            throw new IllegalStateException("Cannot reset sourceLevel attribute; it is already set to: " + sourceLevel);
        } else if (!(USER_LEVEL.equals(sourceLevel) || PROJECT_LEVEL.equals(sourceLevel)  || GLOBAL_LEVEL.equals(sourceLevel))) {
            throw new IllegalArgumentException("sourceLevel must be one of: {" + USER_LEVEL + "," + PROJECT_LEVEL + "," + GLOBAL_LEVEL + "}");
        } else {

	switch op {
	case opLt:
		return left.Before(right)
	case opLte:
		return left.Before(right) || left.Equal(right)
	case opGt:
		return left.After(right)
	case opGte:
		return left.After(right) || left.Equal(right)
	case opEq:
		return left.Equal(right)
	case opIneq:
		return !left.Equal(right)
	}
	// This case does not happen
	return false

  @AndroidIncompatible // Reflection bug, or actual binary compatibility problem?
  public void testElementSetBridgeMethods() {
    for (Method m : TreeMultiset.class.getMethods()) {
      if (m.getName().equals("elementSet") && m.getReturnType().equals(SortedSet.class)) {
        return;
      }
    }
    fail("No bridge method found");
  }

        if (FormatType.SEARCH.name().equals(type)) {
            return FormatType.SEARCH;
        }
        if (FormatType.LABEL.name().equals(type)) {
            return FormatType.LABEL;
        }
        if (FormatType.POPULARWORD.name().equals(type)) {
            return FormatType.POPULARWORD;
        }
        if (FormatType.FAVORITE.name().equals(type)) {
            return FormatType.FAVORITE;
        }

        throw new IllegalStateException("Cannot get() on a pending future.");
      }

      @Override
      boolean permitsPublicUserToTransitionTo(State state) {
        return !state.equals(PENDING);
      }
    },
    DELEGATED {
      @Override
      boolean isDone() {
        return false;
      }

      @Override

                val parameterEnd = header.delimiterOffset(';', pos, extensionEnd)
                val equals = header.delimiterOffset('=', pos, parameterEnd)
                val name = header.trimSubstring(pos, equals)
                val value =
                  if (equals < parameterEnd) {
                    header.trimSubstring(equals + 1, parameterEnd).removeSurrounding("\"")
                  } else {
                    null

      return !"Connection".equals(fieldName, ignoreCase = true) &&
        !"Keep-Alive".equals(fieldName, ignoreCase = true) &&
        !"Proxy-Authenticate".equals(fieldName, ignoreCase = true) &&
        !"Proxy-Authorization".equals(fieldName, ignoreCase = true) &&
        !"TE".equals(fieldName, ignoreCase = true) &&
        !"Trailers".equals(fieldName, ignoreCase = true) &&

                currentList = null;
                if (currentItem != null) {
                    currentItem = null;
                    nodes.pop();
                }
                nodes.pop();
            }
            if (element.equals("dt")) {
                nodes.pop();
            }
            if (element.equals("dd")) {
                nodes.pop();
            }
        }

                    && extension.equals(that.extension)
                    && version.equals(that.version)
                    && context.equals(that.context)
                    && localRepo.equals(that.localRepo)
                    && Objects.equals(workspace, that.workspace)
                    && repositories.equals(that.repositories);
        }

        @Override
        public int hashCode() {