@Override
public void execute() throws BuildException
{
   final PropertyHelper propertyHelper = PropertyHelper.getPropertyHelper(getProject());
   if(propertyHelper.testUnlessCondition(requiredPropertyName))
   {
      // property is missing
   }
}

<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-vfs2</artifactId>
   <version>2.0</version>
</dependency>

import java.io.File;
import java.io.IOException;
import java.net.URI;
 
import org.apache.commons.vfs2.AllFileSelector;
import org.apache.commons.vfs2.FileObject;
import org.apache.commons.vfs2.FileSystemException;
import org.apache.commons.vfs2.FileSystemManager;
import org.apache.commons.vfs2.VFS;
 
public class ZipfileUnpacker
{
   private final FileSystemManager fileSystemManager;
   private final URI packLocation;
 
   public ZipfileUnpacker(final URI packLocation) throws FileSystemException
   {
      this.fileSystemManager = VFS.getManager();
      this.packLocation = packLocation;
   }
 
   @Override
   public void unpack(final File outputDir) throws IOException
   {
      outputDir.mkdirs();
 
      final FileObject packFileObject = fileSystemManager.resolveFile(packLocation.toString());
      try
      {
         final FileObject zipFileSystem = fileSystemManager.createFileSystem(packFileObject);
         try
         {
            fileSystemManager.toFileObject(outputDir).copyFrom(zipFileSystem, new AllFileSelector());
         }
         finally
         {
            zipFileSystem.close();
         }
      }
      finally
      {
         packFileObject.close();
      }
   }
}

import java.util.regex.Pattern;
 
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
 
/**
 * Matchers that use regular expressions
 *
 * @author t.wood
 */
public class RegexMatcher
{
   private static abstract class AbstractRegexpMatcher extends TypeSafeMatcher<String>
   {
      protected final String regex;
      protected final Pattern compiledRegex;
 
      private AbstractRegexpMatcher(final String regex)
      {
         this.regex = regex;
         compiledRegex = Pattern.compile(regex);
      }
   }
 
   private static class MatchesRegexpMatcher extends AbstractRegexpMatcher
   {
      private MatchesRegexpMatcher(final String regex)
      {
         super(regex);
      }
 
      @Override
      public boolean matchesSafely(final String item)
      {
         return compiledRegex.matcher(item).matches();
      }
 
      @Override
      public void describeTo(final Description description)
      {
         description.appendText("matches regex ").appendValue(regex);
      }
   }
 
   private static class ContainsMatchRegexpMatcher extends AbstractRegexpMatcher
   {
      private ContainsMatchRegexpMatcher(final String regex)
      {
         super(regex);
      }
 
      @Override
      public boolean matchesSafely(final String item)
      {
         return compiledRegex.matcher(item).find();
      }
 
      @Override
      public void describeTo(final Description description)
      {
         description.appendText("contains match for regex ").appendValue(regex);
      }
   }
 
   /**
    * Match the regexp against the whole input string
    *
    * @param regex the regular expression to match
    *
    * @return a matcher which matches the whole input string
    */
   public static Matcher<String> matches(final String regex)
   {
      return new MatchesRegexpMatcher(regex);
   }
 
   /**
    * Match the regexp against any substring of the input string
    *
    * @param regex the regular expression to match
    *
    * @return a matcher which matches anywhere in the input string
    */
   public static Matcher<String> containsMatch(final String regex)
   {
      return new ContainsMatchRegexpMatcher(regex);
   }
}

[ERROR] Failed to execute goal org.codehaus.enunciate:maven-enunciate-plugin:1.24:docs (default) on project Pluto: Execution default of goal org.codehaus.enunciate:maven-enunciate-plugin:1.24:docs failed: A required class was missing while executing org.codehaus.enunciate:maven-enunciate-plugin:1.24:docs: com/sun/mirror/apt/AnnotationProcessorFactory

<plugin>
   <groupId>org.codehaus.enunciate</groupId>
   <artifactId>maven-enunciate-plugin</artifactId>
   <configuration>
      <configFile>src/main/doc/enunciate.xml</configFile>
   </configuration>
   <executions>
      <execution>
         <goals>
            <goal>docs</goal>
         </goals>
         <configuration>
            ...
         </configuration>
      </execution>
   </executions>
   <dependencies>
      <dependency>
         <groupId>com.sun</groupId>
         <artifactId>tools</artifactId>
         <version>${java.version}</version>
         <scope>system</scope>
         <systemPath>${java.home}/../lib/tools.jar</systemPath>
      </dependency>
   </dependencies>
</plugin>

warning: The apt tool and its associated API are planned to be
removed in the next major JDK release.  These features have been
superseded by javac and the standardized annotation processing API,
javax.annotation.processing and javax.lang.model.  Users are
recommended to migrate to the annotation processing features of
javac; see the javac man page for more information.

import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.Module;
 
import org.junit.rules.MethodRule;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.Statement;
 
public class PerTestGuiceRule implements MethodRule
{
   private final Module module;
 
   public PerTestGuiceRule(final Module module)
   {
      this.module = module;
   }
 
   @Override
   public Statement apply(
            final Statement base,
            @SuppressWarnings("unused") final FrameworkMethod method,
            final Object target)
   {
      return new Statement()
      {
         @Override
         public void evaluate() throws Throwable
         {
            final Injector injector = Guice.createInjector(module);
 
            injector.injectMembers(target);
 
            base.evaluate();
         }
      };
   }
}

@Rule public PerTestGuiceRule guiceRule = 
                   new PerTestGuiceRule(new MyModule());
 
@Inject MyInjectableType myInjectableType;

@XmlJavaTypeAdapter(value = MyValueXmlAdapter.class)
public class MyValue
{
   private final String value;
 
   private MyValue(final String value)
   {
      this.value = value;
   }
 
   @Override
   public String toString()
   {
      return value;
   }
 
   public static MyValue valueOf(final String value)
   {
      return new MyValue(value);
   }
}

public class MyValueXmlAdapter extends XmlAdapter<String, MyValue>
{
   @Override
   public String marshal(final MyValue value) throws Exception
   {
      return value.toString();
   }
 
   @Override
   public MyValue unmarshal(final String value) throws Exception
   {
      return MyValue.valueOf(value);
   }
}