return Nature.RELEASE;
            }
        } else {
            return Nature.RELEASE;
        }
    }

    public Map<String, String> getProperties() {
        return Collections.emptyMap();
    }

    @Override
    public Metadata setProperties(Map<String, String> properties) {
        return this;
    }

    @SuppressWarnings("deprecation")

        }
    }

    @Override
    public Map<String, String> getProperties() {
        return Collections.emptyMap();
    }

    @Override
    public org.eclipse.aether.metadata.Metadata setProperties(Map<String, String> properties) {
        return this;
    }

  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> {
    val cookieHeaders =
      try {
        // The RI passes all headers. We don't have 'em, so we don't pass 'em!
        cookieHandler.get(url.toUri(), emptyMap<String, List<String>>())
      } catch (e: IOException) {
        Platform.get().log("Loading cookies failed for " + url.resolve("/...")!!, WARN, e)
        return emptyList()
      }

        Map<String, LifecyclePhase> lphases = getLifecyclePhases();
        if (lphases == null) {
            return null;
        }

        if (lphases.isEmpty()) {
            return Collections.emptyMap();
        }

        Map<String, String> phases = new LinkedHashMap<>();
        for (Map.Entry<String, LifecyclePhase> e : lphases.entrySet()) {
            phases.put(e.getKey(), e.getValue().toString());
        }

    private static final Logger logger = LogManager.getLogger(RelatedContentHelper.class);

    protected Map<String, Pair<Map<String, String>, List<Pair<Pattern, String>>>> relatedContentMap = Collections.emptyMap();

    protected String regexPrefix = "regex:";

    protected String queryPlaceHolder = "__QUERY__";

    @PostConstruct
    public void init() {
        if (logger.isDebugEnabled()) {

            new TestStringMapGenerator() {
              @Override
              protected Map<String, String> create(Entry<String, String>[] entries) {
                return Collections.emptyMap();
              }
            })
        .named("emptyMap")
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
        .suppressing(suppressForEmptyMap())
        .createTestSuite();
  }

        this.columnNumber = columnNumber;
        this.source = source;
        this.locations =
                selfLocationKey != null ? Collections.singletonMap(selfLocationKey, this) : Collections.emptyMap();
    }

    public InputLocation(int lineNumber, int columnNumber, InputSource source, Map<Object, InputLocation> locations) {
        this.lineNumber = lineNumber;
        this.columnNumber = columnNumber;

        TestSortedMapGenerator<K, V> delegate, Bound to, Bound from) {
      super(delegate);
      this.to = to;
      this.from = from;

      SortedMap<K, V> emptyMap = delegate.create();
      this.entryComparator = Helpers.entryComparator(emptyMap.comparator());

      // derive values for inclusive filtering from the input samples
      SampleElements<Entry<K, V>> samples = delegate.samples();

            .add(SHORT_NAME, Collections.singletonMap("k1", "v1"))
            .add(LONG_NAME, Collections.singletonMap("k2", "v2"))
            .addValue(Collections.singletonMap("k3", "v3"))
            .addValue(Collections.emptyMap())
            .addValue(null)
            .add(SHORT_NAME, Optional.of("1"))
            .add(LONG_NAME, Optional.of("1"))
            .add(SHORT_NAME, Optional.absent())
            .add(LONG_NAME, Optional.absent())

        val classGraph = classGraph()

        val jarUri = URI.create("jar:${jarFile.toPath().toUri()}")
        FileSystems.newFileSystem(jarUri, emptyMap<String, Any>()).use { jarFileSystem ->
            jarFileSystem.rootDirectories.forEach {
                visitClassDirectory(it, classGraph, classesDir, manifestFile.toPath(), buildReceipt.toPath())
            }
        }