anchor.diff:  
   This approach has the side effect of copying the directory structure below `reports` as well as the files. This may be what you want. It may not be. Copying files includes many such decisions and there are too many to cover here, but know that there are very few requirements that can't be handled elegantly by Gradle copy specifications.
   
  -Head over to ~TBD~ in order to learn all the different options available for getting the exact behavior you want.
  +Head over to ~TODO~ in order to learn all the different options available for getting the exact behavior you want.
   
   === Copying directory hierarchies
   
  
positive.code: </sample>
  ++++
  
  You can also pass the `files()` method a closure or a `Callable` instance. This is called when the contents of the collection are queried, and its return value is converted to a set of `File` instances. The return value can be an object of any of the types supported by the `files()` method. This is a simple way to 'implement' the `FileCollection` interface.
  
  ++++
  <sample id="fileCollections" dir="userguide/files/fileCollections" title="Implementing a file collection">
      <sourcefile file="build.gradle" snippet="closure"/>
      <output args="-q list"/>
  </sample>
  ++++
  
  Some other types of things you can pass to `files()`:
  
  `FileCollection`::
  These are flattened and the contents included in the file collection.
  `Task`::
  The output files of the task are included in the file collection.
  `TaskOutputs`::
  The output files of the TaskOutputs are included in the file collection.
  
  
  It is important to note that the content of a file collection is evaluated lazily, when it is needed. This means you can, for example, create a `FileCollection` that represents files which will be created in the future by, say, some task.
  
  [[sec:file_trees]]
  === File trees
  
  A _file tree_ is a collection of files arranged in a hierarchy. For example, a file tree might represent a directory tree or the contents of a ZIP file. It is represented by the api:org.gradle.api.file.FileTree[] interface. The `FileTree` interface extends `FileCollection`, so you can treat a file tree exactly the same way as you would a file collection. Several objects in Gradle implement the `FileTree` interface, such as <<sec:source_sets,source sets>>.
  
  One way to obtain a `FileTree` instance is to use the api:org.gradle.api.Project#fileTree(java.util.Map)[] method. This creates a `FileTree` defined with a base directory, and optionally some Ant-style include and exclude patterns.
  
  ++++
  <sample id="fileTrees" dir="userguide/files/fileTrees" title="Creating a file tree">
  
negative.code: 
  As you can see, you can have multiple `from()` declarations in a copy specification, each with its own configuration.
  
  [[sec:unpacking_archives_example]]
  === Unpacking archives
  
  Archives are effectively self-contained file systems, so unpacking them is a case of copying the files from that file system into a directory (or even another archive). Gradle enables this by providing some wrapper functions that make archives available as hierarchical collections of files known as file trees (TODO: link to an in-depth discussion of file trees).
  