Model target,
            List<? extends DependencyManagement> sources,
            ModelBuildingRequest request,
            ModelProblemCollector problems) {
        if (sources != null && !sources.isEmpty()) {
            Map<String, Dependency> dependencies = new LinkedHashMap<>();

            DependencyManagement depMgmt = target.getDependencyManagement();

            if (depMgmt != null) {

  }

  @Override
  protected void assertGet(K key, Collection<? extends V> values) {
    assertEqualInOrder(values, multimap().get(key));

    if (!values.isEmpty()) {
      assertEqualInOrder(values, multimap().asMap().get(key));
      assertFalse(multimap().isEmpty());
    } else {
      assertNull(multimap().asMap().get(key));
    }

    assertEquals(values.size(), multimap().get(key).size());

    public int getColumnNumber() {
        return columnNumber;
    }

    @Override
    public String getLocation() {
        StringBuilder buffer = new StringBuilder(256);

        if (!getSource().isEmpty()) {
            if (buffer.length() > 0) {
                buffer.append(", ");
            }
            buffer.append(getSource());
        }

        if (getLineNumber() > 0) {

  }

  @Override
  @CheckForNull
  public V get(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {
    return delegate().get(rowKey, columnKey);
  }

  @Override
  public boolean isEmpty() {
    return delegate().isEmpty();
  }

  @CanIgnoreReturnValue
  @Override
  @CheckForNull
  public V put(
      @ParametricNullness R rowKey, @ParametricNullness C columnKey, @ParametricNullness V value) {

            return ((Boolean) o) ? (long) 1 : (long) 0;
        } else {
            return toLong(o.toString());
        }
    }

    private static Long toLong(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Long.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * 変換された{@literal long}に変換します。
     *
     * @param o
     *            変換元のオブジェクト

    assertThat(directedGraph.nodes()).isEmpty();
    assertThat(directedGraph.edges()).isEmpty();
    assertThat(directedGraph.addEdge(N1, N2, E12)).isTrue();
    assertThat(directedGraph.edgesConnecting(N1, N2)).isEqualTo(ImmutableSet.of(E12));
    assertThat(directedGraph.edgesConnecting(N2, N1)).isEmpty();

    // By default, parallel edges are not allowed.
    IllegalArgumentException e =

        this.resolutionNodes = resolutionNodes;
    }

    public boolean hasMissingArtifacts() {
        return missingArtifacts != null && !missingArtifacts.isEmpty();
    }

    public List<Artifact> getMissingArtifacts() {
        return missingArtifacts == null ? Collections.emptyList() : Collections.unmodifiableList(missingArtifacts);
    }

        runtime.registerData("labelTypeItems", labelTypeItems);
        runtime.registerData("displayLabelTypeItems", labelTypeItems != null && !labelTypeItems.isEmpty());

        Locale locale = ComponentUtil.getRequestManager().getUserLocale();
        if (locale == null) {
            locale = Locale.ENGLISH;
        }

    return line
  }

  /** Reads headers or trailers. */
  fun readHeaders(): Headers {
    val result = Headers.Builder()
    while (true) {
      val line = readLine()
      if (line.isEmpty()) break
      result.addLenient(line)
    }
    return result.build()
  }

  companion object {
    private const val HEADER_LIMIT = 256 * 1024
  }

      assertTrue(Thread.holdsLock(mutex));
      return delegate.removeAll(collection);
    }

    @Override
    public boolean isEmpty() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.isEmpty();
    }

    @Override
    public boolean contains(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.contains(object);
    }