public boolean isEmpty() {
        return entry == null || vertices == null || vertices.isEmpty();
    }

    // ------------------------------------------------------------------------
    public boolean isEmptyEdges() {
        return isEmpty() || incidentEdges == null || incidentEdges.isEmpty();
    }

    val errors: List<ReportMessage>,
    val warnings: List<ReportMessage>,
    val information: List<ReportMessage>,
    val accepted: List<ReportMessage>
) {

    val isEmpty: Boolean
        get() = errors.isEmpty() && warnings.isEmpty() && information.isEmpty()

    fun toText() =
        StringBuilder("Binary compatibility\n").apply {

    assertEquals(rangeSet.asRanges().isEmpty(), rangeSet.isEmpty());
    assertEquals(rangeSet.asDescendingSetOfRanges().isEmpty(), rangeSet.isEmpty());
    assertEquals(!rangeSet.asRanges().iterator().hasNext(), rangeSet.isEmpty());
    assertEquals(!rangeSet.asDescendingSetOfRanges().iterator().hasNext(), rangeSet.isEmpty());

    List<Range<C>> asRanges = ImmutableList.copyOf(rangeSet.asRanges());

            if (path != null && !path.isEmpty()) {
                validatePath(path);
            }

            // Reconstruct normalized URL
            StringBuilder normalized = new StringBuilder("smb://");

            // Add credentials if present
            String userInfo = url.getUserInfo();
            if (userInfo != null && !userInfo.isEmpty()) {
                // Don't log credentials

    }

    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);

  }

  /**
   * Returns an immutable range set containing the specified single range. If {@link Range#isEmpty()
   * range.isEmpty()}, this is equivalent to {@link ImmutableRangeSet#of()}.
   */
  public static <C extends Comparable> ImmutableRangeSet<C> of(Range<C> range) {
    checkNotNull(range);
    if (range.isEmpty()) {
      return of();
    } else if (range.equals(Range.all())) {
      return all();
    } else {

        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();
      }
    }
  }

        Set<ConstraintViolation<TestBean>> violations = validator.validate(bean);
        assertTrue(violations.isEmpty());

        // Test empty string (should be valid)
        bean.setCronExpression("");
        violations = validator.validate(bean);
        assertTrue(violations.isEmpty());

        // Test blank string (should be valid)
        bean.setCronExpression("   ");

        }
        visitor.onEnd();
    }

    private void skipComment() {
        scanner.next(4);
        while (!scanner.isEmpty() && !scanner.lookingAt(END_HTML_COMMENT)) {
            scanner.next();
        }
        if (!scanner.isEmpty()) {
            scanner.next(3);
        }
    }

    private void parseHtmlEntity(StringBuilder buffer) {
        scanner.next();

        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();
      }
    }
  }