*/
    public static String concatName(final String s1, final String s2) {
        if (StringUtil.isEmpty(s1) && StringUtil.isEmpty(s2)) {
            return null;
        }
        if (!StringUtil.isEmpty(s1) && StringUtil.isEmpty(s2)) {
            return s1;
        }
        if (StringUtil.isEmpty(s1) && !StringUtil.isEmpty(s2)) {
            return s2;
        }
        return s1 + '.' + s2;
    }

  public UnmodifiableIterator<C> descendingIterator() {
    return emptyIterator();
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public boolean isEmpty() {
    return true;
  }

  @Override
  public ImmutableList<C> asList() {
    return ImmutableList.of();
  }

  @Override
  public String toString() {
    return "[]";
  }

  @Throws(InterruptedException::class)
  fun takeSink(): BufferedSink = requestBodySinks.poll(5, SECONDS) ?: throw AssertionError("no sink to take")

  fun assertNoMoreSinks() {
    assertTrue(requestBodySinks.isEmpty())
  }

    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
  }

    }

    @Subscribe
    public void subscriber(Object o) {
      subscriberEvents.add(o);
    }
  }

  public void testNonSubscriber() {
    assertThat(getSubscriber().nonSubscriberEvents).isEmpty();
  }

  public void testSubscriber() {
    assertThat(getSubscriber().subscriberEvents).contains(EVENT);
  }

  @Override
  Subscriber createSubscriber() {
    return new Subscriber();
  }

    }

    @Subscribe
    public void subscriber(Object o) {
      subscriberEvents.add(o);
    }
  }

  public void testNonSubscriber() {
    assertThat(getSubscriber().nonSubscriberEvents).isEmpty();
  }

  public void testSubscriber() {
    assertThat(getSubscriber().subscriberEvents).contains(EVENT);
  }

  @Override
  Subscriber createSubscriber() {
    return new Subscriber();
  }

        rangeMap.put(range1, 1);
        rangeMap.put(range2, 2);

        Range<Integer> expected;
        if (range1.isEmpty()) {
          if (range2.isEmpty()) {
            expected = null;
          } else {
            expected = range2;
          }
        } else {
          if (range2.isEmpty()) {
            expected = range1;
          } else {
            expected = range1.span(range2);
          }

            "isolatedProjectsIntegTest"
        } else {
            "${testCoverage.testType.asCamelCase()}Test"
        }
    return when {
        subprojects.isEmpty() -> {
            testTaskName
        }

        else -> {
            subprojects.joinToString(" ") { "$it:$testTaskName" }
        }
    }

            String msg = "Cannot register null or empty aggregation: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {

                sb.append(LS);
                sb.append("from the specified remote repositories:");
                sb.append(LS).append("  ");

                if (remoteRepositories.isEmpty()) {
                    sb.append("(none)");
                }

                for (Iterator<ArtifactRepository> i = remoteRepositories.iterator(); i.hasNext(); ) {