fail("Not true that " + actual + " contains all of " + asList(expected));
    }
  }

  @CanIgnoreReturnValue
  public static <E extends @Nullable Object> boolean addAll(
      Collection<E> addTo, Iterable<? extends E> elementsToAdd) {
    boolean modified = false;
    for (E e : elementsToAdd) {
      modified |= addTo.add(e);
    }
    return modified;
  }

            this.epoch++;
        }
        
        public boolean hasReadCache() {
            return (leaseState & Smb2LeaseState.SMB2_LEASE_READ_CACHING) != 0;
        }
        
        public boolean hasWriteCache() {
            return (leaseState & Smb2LeaseState.SMB2_LEASE_WRITE_CACHING) != 0;
        }
        
        public boolean hasHandleCache() {

     */
    @Override
    public boolean renewCredentials(final String locationHint, final Throwable error) {
        return false;
    }

    /**
     * {@inheritDoc}
     *
     *
     * @see jcifs.CIFSContext#close()
     */
    @Override
    public boolean close() throws CIFSException {
        if (!this.closed) {

        super(createMetadata(artifact, versioning));
        this.artifact = artifact;
    }

    @Override
    public boolean storedInGroupDirectory() {
        return false;
    }

    @Override
    public boolean storedInArtifactVersionDirectory() {
        return false;
    }

    @Override
    public String getGroupId() {
        return artifact.getGroupId();
    }

      @Override
      public boolean hasNext() {
        return entryItr.hasNext();
      }

      @Override
      public V next() {
        return entryItr.next().getValue();
      }
    };
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && Iterators.contains(iterator(), object);
  }

  @Override
  boolean isPartialView() {
    return true;
  }

    }

    def format(Iterable<? extends Node> nodes, boolean prettyPrint = false) {
        StringBuilder builder = new StringBuilder()
        nodes.each { node ->
            format(node, builder, 0, prettyPrint, prettyPrint)
        }
        return builder.toString()
    }

    def format(Node node, Appendable target, int depth, boolean prettyPrint, boolean indentSelf) {
        if (node instanceof Element) {

     * @return true if change notifications are enabled
     */
    public boolean isNotificationEnabled() {
        return notificationEnabled;
    }

    /**
     * Enables or disables directory change notifications
     * @param notificationEnabled true to enable change notifications
     */
    public void setNotificationEnabled(boolean notificationEnabled) {
        this.notificationEnabled = notificationEnabled;
    }

  private var uncaughtException: Throwable? = null
  private lateinit var testName: String
  private var defaultUncaughtExceptionHandler: Thread.UncaughtExceptionHandler? = null
  private var taskQueuesWereIdle: Boolean = false
  private val connectionListener = RecordingConnectionListener()

  var logger: Logger? = null

  var recordEvents = true
  var recordTaskRunner = false
  var recordFrames = false

            }
        }

        return taskSegments;
    }

    private boolean projectIsNotPresent(MavenSession session) {
        return !session.getRequest().isProjectPresent();
    }

    private boolean requiresProject(MavenSession session) {
        List<String> goals = session.getGoals();
        if (goals != null) {

                return (T) value;
            }
            return (T) Float.valueOf(value.toString());
        }
        if (clazz.isAssignableFrom(Boolean.class)) {
            if (value instanceof Boolean) {
                return (T) value;
            }
            return (T) Boolean.valueOf(value.toString());
        }
        return null;
    }

    /**
     * Encodes a URL by encoding non-URL-safe characters.