code: public static <I> boolean incrementalCover(DeterministicAutomaton<?, I, ?> automaton,
                                                 Collection<? extends I> inputs,
                                                 Collection<? extends Word<I>> oldStateCover,
                                                 Collection<? extends Word<I>> oldTransCover,
                                                 Collection<? super Word<I>> newStateCover,
                                                 Collection<? super Word<I>> newTransCover) {
          final int oldStateSize = newStateCover.size();
          final int oldTransSize = newTransCover.size();
  
          incrementalCover(automaton, inputs, oldStateCover, oldTransCover, newStateCover::add, newTransCover::add);
  
          return oldStateSize < newStateCover.size() || oldTransSize < newTransCover.size();
      }
docs: Utility method that allows to compute an incremental state and transition cover simultaneously.
  
  @param automaton
  the automaton for which the covers should be computed
  @param inputs
  the set of input symbols allowed in the cover sequences
  @param oldStateCover
  the collection containing the already existing sequences of the state cover
  @param oldTransCover
  the collection containing the already existing sequences of the transition cover
  @param newStateCover
  the collection in which the missing state cover sequences will be stored
  @param newTransCover
  the collection in which the missing transition cover sequences will be stored
  @param <I>
  input symbol type
  
  @return {@code true} if new sequences have been added to the structural cover, {@code false} otherwise.
  
  @see #incrementalStateCover(DeterministicAutomaton, Collection, Collection, Collection)
  @see #incrementalStateCover(DeterministicAutomaton, Collection, Collection, Collection)