/*
 * [CrossCheckProject.java]
 *
 * Summary: cross check different files files related to the project.
 *
 * Copyright: (c) 2009-2017 Roedy Green, Canadian Mind Products, http://mindprod.com
 *
 * Licence: This software may be copied and used freely for any purpose but military.
 *          http://mindprod.com/contact/nonmil.html
 *
 * Requires: JDK 1.8+
 *
 * Created with: JetBrains IntelliJ IDEA IDE http://www.jetbrains.com/idea/
 *
 * Version History:
 *  1.0 2007-05-12 initial version.
 */
package com.mindprod.zzz;

import com.mindprod.common18.Build;
import com.mindprod.common18.EIO;
import com.mindprod.common18.ST;
import com.mindprod.fastcat.FastCat;
import com.mindprod.hunkio.HunkIO;
import com.mindprod.prices.AppCat;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import static com.mindprod.zzz.CompilerCat.JAVA;
import static com.mindprod.zzz.PADType.PAD40;
import static java.lang.System.*;

/**
 * cross check different files files related to the project.
 * <p/>
 * Version History:
 * 1.0 2007-05-12 - initial version.
 *
 * @author Roedy Green, Canadian Mind Products
 * @version 1.0 2007-05-12 initial version.
 * @since 2007-05-12
 */
class CrossCheckProject extends ProjectInfo
    {
    // declarations

    /**
     * max allowable error in Pad file size in K before reporting the discrepancy.
     * Asked to make manual correction on AppVisor if outside bounds.
     */
    private static final double ALLOWABLE_FILESIZE_SLOP_PERCENT = 4.0d;

    /**
     * Regex to look for Windows EOL sequence
     */
    private static final String A_EOL = "\\r\\n";

    /**
     * regex fragment to match a =
     */
    private static final String A_EQUAL = "=";

    /**
     * regex fragment to match a "
     */
    private static final String A_QUOTE = "\"";

    /**
     * regex fragment to look for some spaces
     */
    private static final String A_SPACES = "\\s++";

    /**
     * regex fragment to look for <!--
     */
    private static final String A_START_HTML_COMMENT = "<!\\-\\-";

    /**
     * regex to find a version number eg. 1.5 for program or JDK versions
     */
    private static final String A_VERSION = "\\d++\\.\\d";

    /**
     * Regex fragment to find YYYY-MM-DD
     */
    private static final String A_YYYYMMDD = "[12]\\d{3}\\-\\d{2}\\-\\d{2}";

    /**
     * look for reference to appvisor site
     * match  <Application_XML_File_URL>http://repository.appvisor.com/info/app-e4007bbb9bb0/Canadian_Sales_Tax_Calculator_pad.xml</Application_XML_File_URL>
     */
    private static final Pattern APPVISOR_FINDER = Pattern.compile( "<Application_XML_File_URL>\\s*(http://repository.appvisor.com[\\-\\_\\+\\.:/\\w]+)\\s*</Application_XML_File_URL>" );

    /**
     * pattern to look for APPLET_HEIGHT in Intellij Java source.
     */
    private static final Pattern FIND_APPLET_HEIGHT;

    /**
     * pattern to look for APPLET_WIDTH in Intellij Java source.
     */
    private static final Pattern FIND_APPLET_WIDTH;

    /**
     * pattern to look for @version 9.9
     */
    private static final Pattern FIND_AT_VERSION;

    /**
     * pattern to look for <!-- macro CMPApplet 1.6
     */
    private static final Pattern FIND_CMP_APPLET;

    /**
     * pattern to look for
     * Copyright: (c) 2009-2017    or Copyright: (c) 2012
     * extract- start year
     */
    private static final Pattern FIND_COPYRIGHT =
            Pattern.compile( "Copyright: \\(c\\) (\\p{Digit}{4})" );

    /**
     * pattern to look for FIRST_COPYRIGHT_YEAR = 1996
     */
    private static final Pattern FIND_FIRST_COPYRIGHT_YEAR =
            Pattern.compile( "FIRST_COPYRIGHT_YEAR = (\\p{Digit}{4})" );

    /**
     * pattern to look for Requires: JDK 1.8+.
     */
    private static final Pattern FIND_JDK_REQUIRED_COMMENT;

    /**
     * pattern to look for <!-- macro NeedsJava 1.8
     */
    private static final Pattern FIND_NEEDSJAVA_PARMS;

    /**
     * pattern to look for RELEASE_DATE = "2007-04-11", does not capture YYYY-MM-DD
     */
    private static final Pattern FIND_RELEASE_DATE;

    /**
     * pattern to look for 9.9 2008-01-01 version history, preceded by a blank line
     */
    private static final Pattern FIND_VERSION_HISTORY;

    /**
     * pattern to look for versionString = "9.9".
     */
    private static final Pattern FIND_VERSION_STRING_IN_JAVA;

    /**
     * look for refe9rence to pad verslion
     * <MASTER_PAD_VERSION>3.10</MASTER_PAD_VERSION>
     */
    private static final Pattern PADVERSION_FINDER = Pattern.compile( "<MASTER_PAD_VERSION>\\s*([\\-\\.\\d]+)\\s*</MASTER_PAD_VERSION>" );

    /**
     * look for reference to File_Size_K
     * File_Size_K>852</File_Size_K>
     */
    private static final Pattern SIZE_FINDER = Pattern.compile( "<File_Size_K>\\s*([\\d]+)\\s*</File_Size_K>" );

    /**
     * expected Applet height from Java source
     */
    private static String appletHeight;

    /**
     * expected Applet width from Java source
     */
    private static String appletWidth;

    /**
     * string to use to tell which type of PAD we are using.
     */
    private static String padVersion = null;

    // /declarations
    static
        {
        FIND_AT_VERSION = Pattern.compile( "@version"
                                           + A_SPACES
                                           + "("
                                           + A_VERSION
                                           + ")" );
        // e.g.  <!-- macro CMPApplet 1.5 submitter Submitter 680 450 -->
        FIND_CMP_APPLET =
                Pattern.compile( A_START_HTML_COMMENT
                                 + A_SPACES
                                 + "macro"
                                 + A_SPACES
                                 + "CMPApplet"
                                 + A_SPACES
                                 + "("
                                 + A_VERSION  // jdk version
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\w+"  // package  without com.mindprod
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\w+"  // program
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\d+"  // width
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\d+"  // height
                                 + ")"
                );
        FIND_JDK_REQUIRED_COMMENT =
                Pattern.compile( "Requires:"
                                 + A_SPACES
                                 + "JDK"
                                 + A_SPACES
                                 + "("
                                 + A_VERSION
                                 + ")\\+" );
        // macro NeedsJava javaVersion(e.g. 1.1) (signed/unsigned) (jni/nojni)
        // (Applet/hybrid/webstart) (ClassName) (Desc) [why signed]";
        FIND_NEEDSJAVA_PARMS =
                Pattern.compile( A_START_HTML_COMMENT
                                 + A_SPACES
                                 + "macro"
                                 + A_SPACES
                                 + "NeedsJava"
                                 + A_SPACES
                                 + "("
                                 + A_VERSION   // 1.1
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\w+"  // signed/unsigned
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\w+"  // jni/nojni
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\w+"  // Applet/hybrid/webstart   any case
                                 + ")"
                                 + A_SPACES
                                 + "("
                                 + "\\w+"  // className
                                 + ")"
                                 + A_SPACES
                );
        FIND_RELEASE_DATE =
                Pattern.compile( "RELEASE_DATE"
                                 + A_SPACES
                                 + A_EQUAL
                                 + A_SPACES
                                 + A_QUOTE
                                 + A_YYYYMMDD
                                 + A_QUOTE );
        FIND_VERSION_HISTORY =
                Pattern.compile( A_EOL
                                 + A_EOL
                                 + "\\s?"
                                 + "("
                                 + A_VERSION
                                 + ") ("
                                 + A_YYYYMMDD
                                 + ")"
                                 + " " );
        FIND_VERSION_STRING_IN_JAVA =
                Pattern.compile( "VERSION_STRING"
                                 + A_SPACES
                                 + A_EQUAL
                                 + A_SPACES
                                 + A_QUOTE
                                 + "("
                                 + A_VERSION
                                 + ")"
                                 + A_QUOTE );
        FIND_APPLET_WIDTH = Pattern.compile( "APPLET_WIDTH = (\\d+);" );
        FIND_APPLET_HEIGHT = Pattern.compile( "APPLET_HEIGHT = (\\d+);" );
        }
    // methods

    /**
     * Copy constructor
     *
     * @param pi Copy constructor to extend class
     */
    @SuppressWarnings( { "SameParameterValue" } )
    CrossCheckProject( ProjectInfo pi )
        {
        super( pi );
        }

    /**
     * makes sure @version is correct
     *
     * @param jdkVersionString what to expect for JDK value
     * @param mainClass        main class name without .class
     * @param versionString    what to expert for version in #version
     * @param program          java source code
     */
    private static void checkAtVersion( String jdkVersionString, String mainClass, String versionString,
                                        String program )
        {
        Matcher m = FIND_AT_VERSION.matcher( program );
        int found = 0;
        while ( m.find() )
            {
            found++;
            String match = m.group( 1 );
            if ( !match.equals( versionString ) )
                {
                final FastCat sb = new FastCat( 8 );
                sb.append( "J" );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " mismatched @version in Intellij Java source: " );
                sb.append( match );
                sb.append( " should match stomp " );
                sb.append( versionString );
                err.println( sb.toString() );
                }
            }
        switch ( found )
            {
            case 0:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " missing @version in Intellij Java source " );
            sb.append( versionString );
            err.println( sb.toString() );
            }
            break;
            case 1:
                // all ok
                break;
            default:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " too many @versions in Intellij Java source " );
            sb.append( found );
            err.println( sb.toString() );
            }
            break;
            }
        }// /method

    /**
     * make sure JDK_REQUIRED in CMPApplet macros in corresponding Applet html  is correct
     *
     * @param projectLower     name of project in lower case, without lead com.mindprod
     * @param mainClass        main class name without .class
     * @param jdkVersionString what to expect for JDK value
     * @param appletHtml       applet html
     * @param appletHtmlFile   file where html text came from
     */
    private static void checkCMPApplet( final String projectLower,
                                        final String mainClass,
                                        final String jdkVersionString,
                                        final String appletHtml,
                                        final File appletHtmlFile )
        {
        final Matcher a = FIND_CMP_APPLET.matcher( appletHtml );
        int found = 0;
        while ( a.find() )
            {
            found++;
            if ( !( a.groupCount() == 5
                    && a.group( 1 ).equals( jdkVersionString )
                    && a.group( 2 ).equals( projectLower )
                    && a.group( 3 ).equals( mainClass )
                    && a.group( 4 ).equals( appletWidth )
                    && a.group( 5 ).equals( appletHeight ) ) )
                {
                final FastCat sb = new FastCat( 22 );
                sb.append( "In file " );
                sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
                sb.append( " malformed Applet is: " );
                sb.append( a.group( 1 ) );
                sb.append( " " );
                sb.append( a.group( 2 ) );
                sb.append( " " );
                sb.append( a.group( 3 ) );
                sb.append( " " );
                sb.append( a.group( 4 ) );
                sb.append( " " );
                sb.append( a.group( 5 ) );
                sb.append( "\nShould be: CMPApplet " );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( projectLower );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " " );
                sb.append( appletWidth );
                sb.append( " " );
                sb.append( appletHeight );
                err.println( sb.toString() );
                }
            switch ( found )
                {
                case 0:
                {
                final FastCat sb = new FastCat( 13 );
                sb.append( "In file " );
                sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
                sb.append( " CMPApplet missing. Should be: CMPApplet" );
                sb.append( " " );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( projectLower );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " " );
                sb.append( appletWidth );
                sb.append( " " );
                sb.append( appletHeight );
                err.println( sb.toString() );
                err.println( appletHtml.substring( 0, 100 ) );
                }
                break;
                case 1:
                    // all ok
                    break;
                default:
                {
                final FastCat sb = new FastCat( 12 );
                sb.append( "In file " );
                sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
                sb.append( "Too many CMPApplet macros. Should just be one CMPApplet " );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( projectLower );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " " );
                sb.append( appletWidth );
                sb.append( " " );
                sb.append( appletHeight );
                err.println( sb.toString() );
                }
                break;
                } // end switch
            } // end while
        }// /method

    /**
     * make sure @copyright is correct
     *
     * @param mainClass        main class name without .class
     * @param jdkVersionString what to expect for JDK value
     * @param program          java source code
     * @param forgiveExcess    true if we should forgive excess copyright lines.
     *
     * @return firstCopyrightYear as int
     */
    private static int checkCopyright( final String mainClass,
                                       final String jdkVersionString,
                                       final String program,
                                       final boolean forgiveExcess )
        {
        final int firstCopyrightYear;
        final Matcher mf = FIND_FIRST_COPYRIGHT_YEAR.matcher( program );
        if ( mf.find() )
            {
            firstCopyrightYear = Integer.parseInt( mf.group( 1 ) );
            }
        else
            {
            firstCopyrightYear = Build.THIS_COPYRIGHT_YEAR;
            final FastCat sb = new FastCat( 5 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " missing FIRST_COPYRIGHT_YEAR  " +
                       "in Intellij source " );
            err.println( sb.toString() );
            }
        final Matcher m = FIND_COPYRIGHT.matcher( program );
        int found = 0;
        while ( m.find() )
            {
            if ( firstCopyrightYear != Integer.parseInt( m.group( 1 ) ) )
                {
                final FastCat sb = new FastCat( 5 );
                sb.append( "J" );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " inconsistent Copyright: (c) in Intellij source " );
                err.println( sb.toString() );
                }
            found++;
            }
        switch ( found )
            {
            case 0:
            {
            final FastCat sb = new FastCat( 5 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " missing Copyright: (c) in Intellij source " );
            err.println( sb.toString() );
            }
            break;
            case 2:
                // all ok, should find one in packaged comment and one in embedded copyright.
                break;
            case 1:
            default:
            {
            if ( !forgiveExcess )
                {
                final FastCat sb = new FastCat( 10 );
                sb.append( "J" );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " should have two lines containing Copyright: (c) in Intellij Java source. Found " );
                sb.append( found );
                err.println( sb.toString() );
                }
            }
            break;
            } // end switch
        return firstCopyrightYear;
        }// /method

    /**
     * make sure JDK_REQUIRED in comment is correct
     *
     * @param mainClass        main class name without .class
     * @param jdkVersionString what to expect for JDK value
     * @param program          java source code
     */
    private static void checkJDKRequiredInComment( String mainClass, String jdkVersionString, String program )
        {
        Matcher m = FIND_JDK_REQUIRED_COMMENT.matcher( program );
        int found = 0;
        while ( m.find() )
            {
            found++;
            String match = m.group( 1 );
            if ( !match.equals( jdkVersionString ) )
                {
                {
                final FastCat sb = new FastCat( 8 );
                sb.append( "J" );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " mismatched 'Requires: JDK' comment in Intellij Java source: " );
                sb.append( match );
                sb.append( " should match stomp: " );
                sb.append( jdkVersionString );
                err.println( sb.toString() );
                }
                }
            }
        switch ( found )
            {
            case 0:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " missing 'Requires: JDK' comment in Intellij Java source " );
            sb.append( jdkVersionString );
            err.println( sb.toString() );
            }
            break;
            case 1:
                // all ok
                break;
            default:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " too many 'Requires: JDK' comments in Intellij Java source " );
            sb.append( found );
            err.println( sb.toString() );
            }
            break;
            }
        }// /method

    /**
     * make sure JDK_REQUIRED in NeedsJava macros in corresponding Applet html  is correct
     *
     * @param appletHtml               applet html
     * @param appletHtmlFile           file where html text came from
     * @param expectedMainClass        main class name without .class
     * @param expectedJDKVersionString what to expect for JDK value
     * @param expectedAppcat           applet category to expect in NeedsJava macro
     * @param expectedSigning          signed/unsigned
     * @param expectedJNI              jni/nojni
     */
    private static void checkJDKRequiredInNeedsJava( final String appletHtml,
                                                     final File appletHtmlFile,
                                                     final String expectedMainClass,
                                                     final String expectedJDKVersionString,
                                                     final String expectedAppcat,
                                                     final String expectedSigning,
                                                     final String expectedJNI
    )
        {
        Matcher m = FIND_NEEDSJAVA_PARMS.matcher( appletHtml );
        int found = 0;
        while ( m.find() )
            {
            found++;
            String match = m.group( 1 );
            if ( match.equals( expectedJDKVersionString ) )
                {
                // macro NeedsJava javaVersion(e.g. 1.1) (signed/unsigned) (jni/nojni)
                // (Applet/hybrid/webstart) (ClassName) (Desc) [why signed;
                if ( !( expectedSigning.equals( m.group( 2 ) )
                        && expectedJNI.equals( m.group( 3 ) )
                        && expectedAppcat.equals( m.group( 4 ).toLowerCase() )
                        && expectedMainClass.equals( m.group( 5 ) ) ) )
                    {
                    final FastCat sb = new FastCat( 17 );
                    sb.append( "In file " );
                    sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
                    sb.append( " " );
                    sb.append( expectedMainClass );
                    sb.append( " inconsistent NeedsJava macro in html\n      Is: " );
                    sb.append( m.group( 0 ) );
                    sb.append( "\nExpected: <!-- macro NeedsJava " );
                    sb.append( expectedJDKVersionString );
                    sb.append( " " );
                    sb.append( expectedSigning );
                    sb.append( " " );
                    sb.append( expectedJNI );
                    sb.append( " " );
                    sb.append( expectedAppcat );
                    sb.append( " " );
                    sb.append( expectedMainClass );
                    sb.append( "\n" );
                    err.println( sb.toString() );
                    }
                }
            else
                {
                final FastCat sb = new FastCat( 10 );
                sb.append( "In file " );
                sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
                sb.append( " J" );
                sb.append( expectedJDKVersionString );
                sb.append( " " );
                sb.append( expectedMainClass );
                sb.append( " mismatched NeedsJava macro in html is: " );
                sb.append( match );
                sb.append( " should match stomp: " );
                sb.append( expectedJDKVersionString );
                err.println( sb.toString() );
                }
            }
        switch ( found )
            {
            case 0:
            {
            final FastCat sb = new FastCat( 8 );
            sb.append( "In file " );
            sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
            sb.append( " J" );
            sb.append( expectedJDKVersionString );
            sb.append( " " );
            sb.append( expectedMainClass );
            sb.append( " missing NeedsJava macro in html " );
            sb.append( expectedJDKVersionString );
            err.println( sb.toString() );
            }
            break;
            case 1:
                // all ok
                break;
            default:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "In file " );
            sb.append( EIO.getCanOrAbsPath( appletHtmlFile ) );
            sb.append( " J" );
            sb.append( expectedJDKVersionString );
            sb.append( " " );
            sb.append( expectedMainClass );
            sb.append( " too many NeedsJava macros in HTML source" );
            sb.append( found );
            err.println( sb.toString() );
            }
            break;
            }
        }// /method

    /**
     * make sure correct version and release exists in *.jnlp
     *
     * @param projectLower  name of project in lower case
     * @param versionString version as a decimal string
     */
    private static void checkJnlp( String projectLower, String versionString )
        {
        // presumes  appCat == AppCat.JWS )
        try
            {
            final String text =
                    HunkIO.readEntireFile( new File( Build.MINDPROD_SOURCE
                                                     + "/"
                                                     + projectLower
                                                     + "/"
                                                     + projectLower
                                                     + ".jnlp" ) );
            if ( !text.contains( "version=\""
                                 + versionString
                                 + "\">" ) )
                {
                {
                final FastCat sb = new FastCat( 4 );
                sb.append( projectLower );
                sb.append( ".jnlp is missing <jnlp ... version=\"" );
                sb.append( versionString );
                sb.append( "\">" );
                err.println( sb.toString() );
                }
                }
            final int start = text.indexOf( "<title>" );
            final int stop = text.indexOf( "</title>" );
            if ( start < 0 || stop < 0 || !text.substring( start
                                                           + "<title>".length(),
                    stop
            ).contains( versionString ) )
                {
                final FastCat sb = new FastCat( 4 );
                sb.append( projectLower );
                sb.append( ".jnlp is missing <title>... " );
                sb.append( versionString );
                sb.append( "</title>" );
                err.println( sb.toString() );
                }
            }
        catch ( IOException e )
            {
            final FastCat sb = new FastCat( 3 );
            sb.append( "Unable to access " );
            sb.append( projectLower );
            sb.append( ".jnlp" );
            err.println( sb.toString() );
            }
        }// /method

    /**
     * make sure RELEASE_DATE is correct
     *
     * @param mainClass        main class name without .class
     * @param jdkVersionString what to expect for JDK value
     * @param program          java source code
     */
    private static void checkReleaseDate( String mainClass, String jdkVersionString, String program )
        {
        Matcher m = FIND_RELEASE_DATE.matcher( program );
        int found = 0;
        while ( m.find() )
            {
            found++;
            }
        switch ( found )
            {
            case 0:
            {
            final FastCat sb = new FastCat( 5 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " missing RELEASE_DATE in Intellij Java source" );
            err.println( sb.toString() );
            }
            break;
            case 1:
                // all ok
                break;
            default:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " should have one and only one RELEASE_DATE declaration in Intellij Java source. Found " );
            sb.append( found );
            err.println( sb.toString() );
            }
            break;
            }
        }// /method

    /**
     * make sure VERSION_STRING is correct
     *
     * @param mainClass        main class name without .class
     * @param jdkVersionString what to expect for JDK value
     * @param versionString    what to expert for version in #version
     * @param program          java source code
     */
    private static void checkVersionString( String mainClass, String jdkVersionString, String versionString,
                                            String program )
        {
        Matcher m = FIND_VERSION_STRING_IN_JAVA.matcher( program );
        int found = 0;
        while ( m.find() )
            {
            found++;
            String match = m.group( 1 );
            if ( !match.equals( versionString ) )
                {
                final FastCat sb = new FastCat( 8 );
                sb.append( "J" );
                sb.append( jdkVersionString );
                sb.append( " " );
                sb.append( mainClass );
                sb.append( " mismatched VERSION_STRING in Intellij Java source is: " );
                sb.append( match );
                sb.append( " should match stomp: " );
                sb.append( versionString );
                err.println( sb.toString() );
                }
            }
        switch ( found )
            {
            case 0:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " missing VERSION_STRING in Intellij Java source " );
            sb.append( versionString );
            err.println( sb.toString() );
            }
            break;
            case 1:
                // all ok
                break;
            default:
            {
            final FastCat sb = new FastCat( 6 );
            sb.append( "J" );
            sb.append( jdkVersionString );
            sb.append( " " );
            sb.append( mainClass );
            sb.append( " too many VERSION_STRINGs in Intellij Java source " );
            sb.append( found );
            err.println( sb.toString() );
            }
            break;
            }
        }// /method

    /**
     * get the set of classes represented by resources and classes in a zip file
     *
     * @param zip jar/zip containing class files.
     *
     * @return HashSet of classes found. Can lookup by fully qualified class name.
     */
    private static HashSet<String> getSetOfClassesInZip( File zip )
        {
        try
            {
            final HashSet<String> zipClasses = new HashSet<>( 1000 );
            ZipFile z = new ZipFile( zip );
            // loop for each zip entry
            for ( Enumeration<? extends ZipEntry> e = z.entries(); e.hasMoreElements(); )
                {
                final ZipEntry zipEntry = e.nextElement();
                final String elementName = zipEntry.getName();
                // zip won't have matching manifest
                // truezip-6.8.1.jar de.schlichtherle is not included in zip, though classes are included in jar.
                // Can't check png since some are resources and some are not.
                if ( ( elementName.endsWith( ".class" )
                       || elementName.endsWith( ".ser" )
                       || elementName.endsWith( ".dat" )
                       || elementName.endsWith( ".au" ) )
                     && !( elementName.startsWith( "META-INF/" )
                           || elementName.startsWith( "de/schlichtherle/" )
                           || elementName.startsWith( "decrypt" )
                           || elementName.startsWith( "encrypt" )
                           || elementName.startsWith( "nzip" )
                           || elementName.startsWith( "org/apache/tools/tar/" ) ) )
                    {
                    // extract package included from zisp entry name.
                    // eg. com/mindprod/common18/Misc.class
                    zipClasses.add( elementName ); // qualified
                    }
                } // end for
            z.close();
            return zipClasses;
            }
        catch ( IOException e )
            {
            err.println();
            e.printStackTrace( System.err );
            err.println( "jar or zip I/O problem reading " + zip.toString() );
            err.println();
            return null;
            }
        }// /method

    /**
     * get the set of packages represented by resources and classes in a zip file
     *
     * @param zip jar/zip containing class files.
     *
     * @return HashSet of classes found. Can lookup by fully qualified class name.
     */
    private static HashSet<String> getSetOfPackagesInZip( File zip )
        {
        try
            {
            final HashSet<String> zipPackages = new HashSet<>( 200 );
            ZipFile z = new ZipFile( zip );
            // loop for each zip entry
            for ( Enumeration<? extends ZipEntry> e = z.entries(); e.hasMoreElements(); )
                {
                final ZipEntry zipEntry = e.nextElement();
                final String elementName = zipEntry.getName();
                // zip won't have matching manifest
                // truezip-6.8.1.jar de.schlichtherle is not included in zip, though classes are included in jar.
                // Can't do png since some are resources and some are not.
                if ( ( elementName.endsWith( ".class" )
                       || elementName.endsWith( ".ser" )
                       || elementName.endsWith( ".dat" )
                       || elementName.endsWith( ".au" ) )
                     && !( elementName.startsWith( "META-INF/" )
                           || elementName.startsWith( "de/schlichtherle/" )
                           || elementName.startsWith( "decrypt" )
                           || elementName.startsWith( "encrypt" )
                           || elementName.startsWith( "nzip" )
                           || elementName.startsWith( "org/apache/tools/tar/" ) ) )
                    {
                    // extract package included from zip entry name.
                    // eg. com/mindprod/common18/Misc.class
                    final int end = elementName.lastIndexOf( '/' );
                    if ( end >= 0 )
                        {
                        // will dedup
                        final String zipPackage = elementName.substring( 0, end );
                        zipPackages.add( zipPackage );
                        }
                    }
                } // end for
            z.close();
            return zipPackages;
            }
        catch ( IOException e )
            {
            err.println();
            err.println( "jar or zip I/O problem reading " + zip.toString() );
            e.printStackTrace( System.err );
            err.println();
            return null;
            }
        }// /method

    /**
     * report on Unneeded packages in zip
     *
     * @param zip                   name of zip file with version number
     * @param unneededPackagesInZip HashSet of excess packages in zip
     */
    private static void reportUnneededPackagesInZip( final File zip, final HashSet<String> unneededPackagesInZip )
        {
        if ( unneededPackagesInZip.size() > 0 )
            {
            String[] unneededPackages = unneededPackagesInZip.toArray( new String[ unneededPackagesInZip.size() ] );
            Arrays.sort( unneededPackages );
            err.println( "<><><>Warning<><><> extra in zip: The following packages appear in " + zip + " but not in " +
                         "jar.\n"
                         + "They might not be needed. Consider removing from forzip.xml" );
            for ( String unneededPackage : unneededPackages )
                {
                err.println( unneededPackage );
                }
            err.println();
            }
        }// /method

    /**
     * make sure correct version and release exists in E:\mindprod\applet\xxxx.html
     */
    private void checkAppletHtml()
        {
        // appCat == AppCat.APPLET _|| appCat == AppCat.HYBRID
        final String appletHtmlFilename = "E:/mindprod/applet/"
                                          + projectLower
                                          + ".html";
        final File appletHtmlFile = new File( appletHtmlFilename );
        if ( !appletHtmlFile.exists() )
            // often there is no *.html file
            {
            return;
            }
        try
            {
            final String htmlText = HunkIO.readEntireFile( appletHtmlFile );
            if ( htmlText == null )
                {
                // often there is no *.html file
                return;
                }
            if ( mainClassName.equals( "CurrCon" )
                 || mainClassName.equals( "JDisplay" )
                 || mainClassName.equals( "NetworkCam" ) )
                {
                //  these have specialised macros. They don't use the CMPApplet macro. We don't check them
                }
            else
                {
                checkCMPApplet( projectLower, mainClassName, jdkVersionString, htmlText, appletHtmlFile );
                }
            checkJDKRequiredInNeedsJava( htmlText, appletHtmlFile,
                    mainClassName,
                    jdkVersionString,
                    appCat.getCssClass(),
                    isSigned ? "signed" : "unsigned",
                    usesJni ? "jni" : "nojni" );
            }
        catch ( IOException e )
            {
            // often there is no *.html file
            }
        }// /method

    /**
     * check fields specific to a PAD 3.11
     *
     * @param padFile local file containing pad
     * @param text    text in the PAD file
     */
    private void checkPad310Fields( final File padFile, final String text )
        {
        // pad 3.11
        if ( EIO.getExtension( padFile ).equals( "xml" ) )
            {
            Matcher m0 = PADVERSION_FINDER.matcher( text );
            if ( m0.find() )
                {
                final String s = m0.group( 1 );
                if ( !s.equals( "3.11" ) )
                    {
                    err.println( padVersion + EIO.getCanOrAbsPath( padFile ) + " <MASTER_PAD_VERSION> should be 3.11" );
                    err.println( "is: " + s );
                    err.println( "context: " + m0.group( 0 ) );
                    }
                }
            else
                {
                err.println( EIO.getCanOrAbsPath( padFile ) + "  missing <MASTER_PAD_VERSION> in " + padVersion + EIO.getCanOrAbsPath( padFile ) );
                }
            }
        if ( !text.contains( "<Application_XML_File_URL>http://mindprod.com/pad/" + projectLower +
                             ".xml</Application_XML_File_URL>" ) )
            {
            err.println(
                    "<Application_XML_File_URL>http://mindprod.com/pad/" + projectLower +
                    ".xml</Application_XML_File_URL> missing from " + padVersion + EIO.getCanOrAbsPath( padFile )
            );
            }
        }// /method

    /**
     * check fields specific to a PAD 4.00
     *
     * @param padFile local file containing pad
     * @param text    text in the PAD file
     */
    private void checkPad4Fields( final File padFile, final String text )
        {
        Matcher m0 = PADVERSION_FINDER.matcher( text );
        if ( m0.find() )
            {
            final String s = m0.group( 1 );
            if ( !s.equals( "4.0" ) )
                {
                err.println( padVersion + EIO.getCanOrAbsPath( padFile ) + " <MASTER_PAD_VERSION> should be 4.0" );
                err.println( "is: " + s + " Fix at Appvisor.com." );
                }
            }
        else
            {
            err.println( EIO.getCanOrAbsPath( padFile ) + "  missing <MASTER_PAD_VERSION> in " + padVersion + EIO.getCanOrAbsPath( padFile ) + " Fix at Appvisor.com." );
            }
        Matcher m1 = APPVISOR_FINDER.matcher( text );
        if ( m1.find() )
            {
            final String s = m1.group( 1 );
            if ( !s.contains( "http://repository.appvisor.com/" ) )
                {
                err.println( padVersion + EIO.getCanOrAbsPath( padFile ) + " <Application_XML_File_URL> does not point to appvisor.com" );
                err.println( "Points to: " + s + " Fix at Appvisor.com." );
                }
            }
        else
            {
            err.println( EIO.getCanOrAbsPath( padFile ) + "  missing <Application_XML_File_URL> in " + padVersion + EIO.getCanOrAbsPath( padFile ) + " Fix at Appvisor.com." );
            }
        Matcher m2 = SIZE_FINDER.matcher( text );
        if ( m2.find() )
            {
            final int sizeInKInPad = Integer.parseInt( m2.group( 1 ) );
            final File distribFile = new File( "E:/mindprod/zips/" + projectLower + versionTimesTen + ".zip" );
            final long actualSizeInK = distribFile.length() / 1024;
            if ( ( double ) Math.abs( sizeInKInPad - actualSizeInK )
                 / ( double ) actualSizeInK >
                 ALLOWABLE_FILESIZE_SLOP_PERCENT * 0.01d )
                {
                err.println( padVersion + EIO.getCanOrAbsPath( padFile ) + " <File_Size_K> is " + sizeInKInPad + ". It needs to be manually updated to " + actualSizeInK + " at Appvisor.com" );
                }
            }
        else
            {
            err.println( padVersion + EIO.getCanOrAbsPath( padFile ) + "  missing <File_Size_K> Fix at Appvisor.com." );
            }
        }// /method

    /**
     * check Application_Info_URL
     *
     * @param padFile local file containing pad
     * @param text    text in the PAD file
     */
    private void checkPadApplicationInfoURL( final File padFile, final String text )
        {
        // might legitimately point to applet or application page
        if ( text.contains( "<Application_Info_URL>http://mindprod.com/products" ) )
            {
            if ( !text.contains( "<Application_Info_URL>http://mindprod.com/products"
                                 + pcPage
                                 + ".html#"
                                 + projectUpper
                                 + "</Application_Info_URL>"
            ) )
                {
                final FastCat sb = new FastCat( 7 );
                sb.append( "<Application_Info_URL>http://mindprod.com/products", Integer.toString( pcPage ), ".html#", projectUpper, "</Application_Info_URL>" );
                sb.append( " missing from : " );
                sb.append( EIO.getCanOrAbsPath( padFile ) );
                err.println( sb.toString() );
                }
            }
        }// /method

    /**
     * check Application_Order_URL
     *
     * @param padFile local file containing pad
     * @param text    text in the PAD file
     */
    private void checkPadApplicationOrderURL( final File padFile, final String text )
        {
        if ( !text.contains( "<Application_Order_URL>http://mindprod.com/products"
                             + pcPage
                             + ".html#"
                             + projectUpper
                             + "</Application_Order_URL>"
        ) )
            {
            final FastCat sb = new FastCat( 8 );
            sb.append( "<Application_Order_URL>http://mindprod.com/products", Integer.toString( pcPage ), ".html#", projectUpper, "</Application_Order_URL>" );
            sb.append( " missing from ", padVersion );
            sb.append( EIO.getCanOrAbsPath( padFile ) );
            err.println( sb.toString() );
            }
        }// /method

    /**
     * check all fields in PADS 3.10 or 4.0 or both.
     *
     * @param padFile PAD xml file.
     */
    private void checkPadFields( final File padFile )
        {
        try
            {
            final String text = HunkIO.readEntireFile( padFile );
            checkProgramName( padFile, text );
            checkPadVersion( padFile, text );
            checkPadReleaseDate( padFile, text );
            checkPadApplicationInfoURL( padFile, text );
            checkPadApplicationOrderURL( padFile, text );
            checkPadPrimaryDownload( padFile, text );
            switch ( padType )
                {
                case PAD40:
                    checkPad4Fields( padFile, text );
                    break;
                case PAD311:
                    checkPad310Fields( padFile, text );
                    break;
                default:
                case NO_PAD:
                }
            }
        catch ( IOException e )
            {
            err.println( "Unable to access : " + padFile.toString()
            );
            }
        }// /method

    private void checkPadPrimaryDownload( final File padFile, final String text )
        {
        if ( !text.contains( "<Primary_Download_URL>http://mindprod.com/zips/"
                             + projectLower
                             + versionTimesTen
                             + ".zip</Primary_Download_URL>" ) )
            {
            final FastCat sb = new FastCat( 8 );
            sb.append( "<Primary_Download_URL>http://mindprod.com/zips/" );
            sb.append( projectLower );
            sb.append( versionTimesTen );
            sb.append( ".zip</Primary_Download_URL>" );
            sb.append( " missing from ", padVersion );
            sb.append( EIO.getCanOrAbsPath( padFile ) );
            if ( padType == PAD40 )
                {
                sb.append( " Fix at AppVisor.com." );
                }
            err.println( sb.toString() );
            }
        }// /method

    private void checkPadReleaseDate( final File padFile, final String text )
        {
        if ( pcOfficialRELEASE_DATE.length() == "YYYY-MM-DD".length() && !text.contains( "<Program_Release_Year>"
                                                                                         + pcOfficialRELEASE_DATE
                                                                                                 .substring(
                                                                                                         0,
                                                                                                         4 )
                                                                                         +
                                                                                         "</Program_Release_Year>" ) )
            {
            err.println( "Program_Release_Year differs from prices "
                         + pcOfficialRELEASE_DATE + " " + padVersion + padFile.toString() );
            }
        if ( pcOfficialRELEASE_DATE.length() == "YYYY-MM-DD".length() && !text.contains( "<Program_Release_Month>"
                                                                                         + pcOfficialRELEASE_DATE
                                                                                                 .substring(
                                                                                                         5,
                                                                                                         7 )
                                                                                         +
                                                                                         "</Program_Release_Month>"
        ) )
            {
            err.println( "Program_Release_Month differs from prices "
                         + pcOfficialRELEASE_DATE + " " + padVersion + padFile.toString()
                         + ( padType == PAD40 ? " Fix at AppVisor.com." : "" ) );
            }
        if ( pcOfficialRELEASE_DATE.length() == "YYYY-MM-DD".length() && !text.contains( "<Program_Release_Day>"
                                                                                         + pcOfficialRELEASE_DATE
                                                                                                 .substring(
                                                                                                         8,
                                                                                                         10 )
                                                                                         + "</Program_Release_Day>"
        ) )
            {
            err.println( "PAD Program_Release_Day differs from prices "
                         + pcOfficialRELEASE_DATE + " " + padVersion + padFile.toString()
                         + ( padType == PAD40 ? " Fix at AppVisor.com." : "" ) );
            }
        }// /method

    private void checkPadVersion( final File padFile, final String text )
        {
        if ( !text.contains( "<Program_Version>"
                             + versionString
                             + "</Program_Version>" ) )
            {
            err.println(
                    "<Program_Version>"
                    + versionString
                    + "</Program_Version> missing from " + padVersion + EIO.getCanOrAbsPath( padFile )
                    + ( padType == PAD40 ? " Fix at AppVisor.com." : "" ) );
            }
        }// /method

    private void checkProgramName( final File padFile, final String text )
        {
        // e.g.<Program_Name>Entity Strip/Insert</Program_Name>
        if ( !text.contains( "<Program_Name>"
                             + pcAspName
                             + "</Program_Name>" ) )
            {
            err.println(
                    "<Program_Name>"
                    + pcAspName
                    + "</Program_Name> missing, misspelled, mis-spaced or wrong case in " + padVersion + EIO.getCanOrAbsPath( padFile )
                    + ( padType == PAD40 ? " You will have to fix this at AppVisor or in prices.csv" : "" ) );
            }
        }// /method

    /**
     * check that all contents of the jar are also in the ZIP and up to date.
     */
    private void checkSyncJarAndZip()
        {
        final File jar = new File( WinJarFileQual );
        final File zip = new File( winZipFileQual );
        if ( !jar.exists() )
            {
            err.println( "Missing jar " + jar.toString() );
            return;
            }
        for ( String winAltJarFile : winAltJarFiles )
            {
            if ( !new File( winAltJarFile ).exists() )
                {
                err.println( "Missing jar " + winAltJarFile );
                return;
                }
            }
        if ( !zip.exists() )
            {
            err.println( "Missing zip " + zip.toString() );
            return;
            }
        }// /method

    /**
     * make sure version history has been generated in versionhistory.txt, check version and release date.
     */
    private void checkVersionHistoryTxt()
        {
        // not picky about versionhistory.txt if not yet distributed.
        // todo: partial check, not including pc info.
        if ( !hasDistributedZip )
            {
            return;
            }
        // presume hasZip
        // refresh before testing
        new MkAuxFiles( this ).mkVersionHistoryTxt();
        try
            {
            final String text = HunkIO.readEntireFile( new File( winAbsoluteProjectDir + "\\versionhistory.txt" ) );
            final Matcher m = FIND_VERSION_HISTORY.matcher( text );
            // look for anything with form 9.9 20xx
            boolean found = false;
            while ( m.find() )
                {
                final String version = m.group( 1 );
                final String release = m.group( 2 );
                if ( version.equals( versionString ) )
                    {
                    if ( release.equals( pcOfficialRELEASE_DATE ) )
                        {
                        found = true;
                        break;
                        }
                    else
                        {
                        final FastCat sb = new FastCat( 10 );
                        sb.append( "J" );
                        sb.append( jdkVersionString );
                        sb.append( " " );
                        sb.append( projectLower );
                        sb.append( ": version history in versionhistory.txt for " );
                        sb.append( versionString );
                        sb.append( " release date:" );
                        sb.append( release );
                        sb.append( " should match prices: " );
                        sb.append( pcOfficialRELEASE_DATE );
                        err.println( sb.toString() );
                        err.println();
                        found = true;
                        break;
                        }
                    }
                } // end while
            if ( !found )
                {
                final FastCat sb = new FastCat( 9 );
                sb.append( "J", jdkVersionString, " ", projectLower );
                sb.append( ": missing version history line in versionhistory.txt for " );
                sb.append( versionString, " ", pcOfficialRELEASE_DATE );
                sb.append( " must match regex: " + FIND_VERSION_HISTORY.toString() );
                err.println( sb.toString() );
                }
            }
        catch ( IOException e )
            {
            err.println( "Unable to access versionhistory.txt for "
                         + projectLower );
            }
        }// /method

    /**
     * Make sure  IntelliJ version in mainclass.java matches the official version.
     *
     * @param projectLower     name of project in lower case
     * @param mainClass        name of main class
     * @param jdkVersionString version of JDK used to compile
     * @param versionString    version as a decimal string
     * @param forgiveExcess    true if should forgive Excess copyright lines.
     */
    private void checkVersionInMainClassJava( final String projectLower,
                                              final String mainClass,
                                              final String jdkVersionString,
                                              final String versionString,
                                              final boolean forgiveExcess )
        {
        // presume hasMainProg )
        try
            {
            final String javaSource;
            {
            final FastCat sb = new FastCat( 7 );
            sb.append( "E:/intellij/mp/j" );
            sb.append( jdkVersionString.charAt( 2 ) );
            sb.append( "/src/com/mindprod/", projectLower, '/', mainClass, ".java" );
            javaSource = sb.toString();
            }
            String program = HunkIO.readEntireFile( new File( javaSource ) );
            final Matcher w = FIND_APPLET_WIDTH.matcher( program );
            if ( w.find() && w.groupCount() == 1 )
                {
                appletWidth = w.group( 1 );
                }
            final Matcher h = FIND_APPLET_HEIGHT.matcher( program );
            if ( h.find() && h.groupCount() == 1 )
                {
                appletHeight = h.group( 1 );
                }
            firstCopyrightYear = checkCopyright( mainClass, jdkVersionString, program, forgiveExcess );
            checkAtVersion( jdkVersionString, mainClass, versionString, program );
            if ( !projectLower.startsWith( "replicator" ) )
                {
                checkJDKRequiredInComment( mainClass, jdkVersionString, program );
                checkVersionString( mainClass, jdkVersionString, versionString, program );
                checkReleaseDate( mainClass, jdkVersionString, program );
                // replicator uses ReplicatorCommon.VERSION_STRING
                }
            }
        catch ( IOException e )
            {
            err.println( e.getMessage() );
            err.println( "Unable to access intellij version of Java source code for "
                         + mainClass );
            }
        }// /method

    /**
     * check that zip is consistent
     */
    private void checkZip()
        {
        final PriceCapsule pc = PriceCapsule.findPriceCapsule( this.projectLower );
        if ( pc == null )
            {
            if ( this.hasDistributedZip )
                {
                err.println( "No prices entry for " + this
                        .projectLower );
                }
            }
        else
            {
            if ( !pc.getVersion().equals( this.versionString ) )
                {
                final FastCat sb = new FastCat( 6 );
                sb.append( "app version mismatch on " );
                sb.append( this.projectLower );
                sb.append( " prices:" );
                sb.append( pc.getVersion() );
                sb.append( " stomp:" );
                sb.append( versionString );
                err.println( sb.toString() );
                }
            }
        }

    /**
     * Do the cross checks between files
     */
    void doAllCrossFileChecks()
        {
        // same for fullBuild and simple
        if ( compilerCat == JAVA && hasMainProg )
            {
            checkVersionInMainClassJava( projectLower,
                    mainClassName,
                    jdkVersionString,
                    versionString,
                    forgive.contains( Forgive.EXCESS_COPYRIGHT ) );
            }
        if ( hasZip )
            {
            checkZip();
            checkVersionHistoryTxt();
            }
        switch ( padType )
            {
            case NO_PAD:
                break;
            case PAD40:
                padVersion = "PAD4.0: ";
                getPADPmlFile().delete();  // avoid temptation to update and regenerete xml
                checkPadFields( getPADXmlFile() );
                break;
            case PAD311:
                padVersion = "PAD3.11: ";
                checkPadFields( getPADPmlFile() );
                checkPadFields( getPADXmlFile() );
                break;
            }
        if ( appCat == AppCat.APPLET || appCat == AppCat.HYBRID )
            {
            checkAppletHtml();
            }
        if ( appCat == AppCat.JWS )
            {
            checkJnlp( projectLower, versionString );
            }
        if ( hasJar && hasZip )
            {
            checkSyncJarAndZip();
            }
        }// /method

    /**
     * check that all files are present.  If files are missing we continue, since they legitimate may not have been
     * created yet.
     */
    void ensureAllFilesPresent()
        {
        if ( hasZip )
            {
            assert !ST.isEmpty( antProjectDir ) : "empty antProjectDir";
            // if not yet  distributing, we don't need the niceties.
            // We check the sizes in RightSize.btm
            String[] shouldExists = {
                    antIcon16Dir + '/' + projectLower + ".png",
                    antIcon32Dir + '/' + projectLower + ".png",
                    antIcon48Dir + '/' + projectLower + ".png",
                    antIcon64Dir + '/' + projectLower + ".png",
                    antIcon128Dir + '/' + projectLower + ".png",
                    screenshotDir + '/' + projectLower + ".png",
                    antProjectDir + '/' + "use.txt" };
            for ( String shouldExist : shouldExists )
                {
                if ( !new File( shouldExist ).exists() )
                    {
                    err.println( "Missing file: " + shouldExist );
                    }
                }
            if ( padType != PADType.NO_PAD )
                {
                final String shouldExist = antPadDir + '/' + projectLower + ".xml";
                if ( !new File( shouldExist ).exists() )
                    {
                    err.println( "Missing file: " + shouldExist );
                    }
                }
            }
        }// /method

    /**
     * Avoid complaining about excess packages in zip that are deliberate.
     *
     * @param unneededPackagesInZip HashSet of excess packages.
     */
    private void pruneUnneededPackagesInZip( HashSet<String> unneededPackagesInZip )
        {
        if ( this.extraPackages != null )
            {
            for ( String extra : extraPackages )
                {
                unneededPackagesInZip.remove( extra );
                }
            }
        }// /method
    // /methods
    }