 ------
 Introduction
 ------
 Denis Cabasson
 ------
 2010-01-18
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Maven Verifier Plugin

  Useful for integration tests - verifies the existence of certain conditions.

* Goals Overview

  * {{{./verify-mojo.html}verifier:verify}} Verifies the existence or non-existence of files/directories and optionally checks file content against a regular expression.

* Usage

  General instructions on how to use the Verifier Plugin can be found on the {{{./usage.html}usage page}}. Some more
  specific use cases are described in the examples given below. Last but not least, users occasionally contribute
  additional examples, tips or errata to the
  {{{http://docs.codehaus.org/display/MAVENUSER/Verifier+Plugin}plugin's wiki page}}.

  In case you still have questions regarding the plugin's usage, please have a look at the {{{./faq.html}FAQ}} and feel
  free to contact the {{{./mail-lists.html}user mailing list}}. The posts to the mailing list are archived and could
  already contain the answer to your question as part of an older thread. Hence, it is also worth browsing/searching
  the {{{./mail-lists.html}mail archive}}.

  If you feel like the plugin is missing a feature or has a defect, you can fill a feature request or bug report in our
  {{{./issue-tracking.html}issue tracker}}. When creating a new issue, please provide a comprehensive description of your
  concern. Especially for fixing bugs it is crucial that the developers can reproduce your problem. For this reason,
  entire debug logs, POMs or most preferably little demo projects attached to the issue are very much appreciated.
  Of course, patches are welcome, too. Contributors can check out the project from our
  {{{./source-repository.html}source repository}} and will find supplementary information in the
  {{{http://maven.apache.org/guides/development/guide-helping.html}guide to helping with Maven}}.

* Examples

  To provide you with better understanding on some usages of the Verifier Plugin,
  you can take a look into the following examples:

  * {{{./examples/sample-verifications.html}Sample Verifications}}

  []
