assertThat(requirements.getPresentFeatures()).isEmpty();
    assertThat(requirements.getAbsentFeatures()).isEmpty();
  }

  public void testBuildTesterRequirements_class_empty() throws Exception {
    @Require
    class Tester {}

    TesterRequirements requirements = buildTesterRequirements(Tester.class);

    assertThat(requirements.getPresentFeatures()).isEmpty();

        mergeSite_Url(target, source, sourceDominant, context);
    }

    protected boolean isSiteEmpty(Site site) {
        return StringUtils.isEmpty(site.getId())
                && StringUtils.isEmpty(site.getName())
                && StringUtils.isEmpty(site.getUrl());
    }

    @Override
    protected void mergeSite_Url(Site target, Site source, boolean sourceDominant, Map<Object, Object> context) {

     *             If the argument is <code>null</code> or an empty string.
     */
    public static void assertArgumentNotEmpty(final String argName, final String argValue) {
        if (StringUtil.isEmpty(argValue)) {
            throw new EmptyArgumentException(argName, "ECL0010", asArray(argName));
        }
    }

    /**
     * Asserts that the argument is neither <code>null</code> nor an empty string.
     *

            final int leftCount = leftPart.isEmpty() ? 0 : leftPart.split(":").length;
            final int rightCount = rightPart.isEmpty() ? 0 : rightPart.split(":").length;
            final int zerosCount = 8 - leftCount - rightCount;
            final StringBuilder expanded = new StringBuilder(leftPart);
            for (int i = 0; i < zerosCount; i++) {
                if (expanded.length() > 0) {

    assertThat(findClassesToTest(ImmutableList.of(EmptyTest.class))).isEmpty();
    assertThat(findClassesToTest(ImmutableList.of(EmptyTests.class))).isEmpty();
    assertThat(findClassesToTest(ImmutableList.of(EmptyTestCase.class))).isEmpty();
    assertThat(findClassesToTest(ImmutableList.of(EmptyTestSuite.class))).isEmpty();
  }

  public void testFindClassesToTest_noCorrespondingTestClass() {

        map.put(keyOne, valueOne);
        assertThat(segment.recencyQueue.isEmpty()).isTrue();

        for (int i = 0; i < DRAIN_THRESHOLD / 2; i++) {
          map.get(keyOne);
        }
        assertThat(segment.recencyQueue.isEmpty()).isFalse();

        map.put(keyTwo, valueTwo);
        assertThat(segment.recencyQueue.isEmpty()).isTrue();
      }
    }
  }

    private String join(String message1, String message2) {
        String message = "";

        if (message1 != null && !message1.isEmpty()) {
            message = message1.trim();
        }

        if (message2 != null && !message2.isEmpty()) {
            if (message != null && !message.isEmpty()) {
                if (message.endsWith(".") || message.endsWith("!") || message.endsWith(":")) {
                    message += " ";

        map.put(keyOne, valueOne);
        assertThat(segment.recencyQueue.isEmpty()).isTrue();

        for (int i = 0; i < DRAIN_THRESHOLD / 2; i++) {
          map.get(keyOne);
        }
        assertThat(segment.recencyQueue.isEmpty()).isFalse();

        map.put(keyTwo, valueTwo);
        assertThat(segment.recencyQueue.isEmpty()).isTrue();
      }
    }
  }

    }

    public ExecutionListener chainListener(ExecutionListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyExecutionListener(this, listener);
    }

    public RepositoryListener chainListener(RepositoryListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyRepositoryListener(this, listener);

                PluginContainer target, PluginContainer source, boolean sourceDominant, Map<Object, Object> context) {
            List<Plugin> src = source.getPlugins();
            if (!src.isEmpty()) {
                List<Plugin> tgt = target.getPlugins();
                Map<Object, Plugin> master = new LinkedHashMap<>(tgt.size() * 2);

                for (Plugin element : tgt) {