ant-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Marcus" <marc...@criticalpointsoftware.com>
Subject Re: ant/junit & files
Date Thu, 27 Dec 2001 21:34:22 GMT
Erik,

build.xml snippet:
  <!-- RUN ALL THE TESTS IN THIS SECTTION maybe put this in an other
run_tests.xml file?? -->
  <target name="run_tests" depends="deploy_tests, deploy_debug"
description="Execute Unit Tests">
    <junit printsummary="yes" fork="no" haltonfailure="no">
     <sysproperty key="mdb.properties.file" value="mdb.properties"/>
      <classpath>
        <fileset dir="${java_deploy_dir}/lib">
          <include name="*.jar"/>
        </fileset>
        <fileset dir="${JLIB}">
          <include name="*.jar"/>
        </fileset>
      </classpath>
      <formatter type="xml" />
     <test name="cp_test.system.TestMiniMetanet" />
    </junit>

    <java classname="cp_test.system.TestMiniMetanet" fork="yes" >
      <classpath>
        <pathelement path="${CLASSPATH}"/>
      </classpath>
      <jvmarg
value="-Dmdb.properties.file=p:\cpdev\main\src\html\prototype\Web-Inf\mdb.pr
operties"/>
    </java>


unit test:
package cp_test.system;

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;

import criticalpoint.db.DomainConnection;
import criticalpoint.db.DomainManager;
import criticalpoint.db.ParserDBServices;

import criticalpoint.util.TimeMeasurements;
import criticalpoint.util.SystemProperties;

import criticalpoint.command.query.*;

import java.util.Iterator;
import java.util.ArrayList;
import java.util.Hashtable;

import java.io.File;
import java.io.IOException;


public class TestMiniMetanet extends MultiThreadedTestCase
  implements TestConstants
{
  ////////////////////////////////////////////////////////////////
  // CONSTANTS
  ////////////////////////////////////////////////////////////////

  ////////////////////////////////////////////////////////////////
  // INSTANCE DATA
  ////////////////////////////////////////////////////////////////

  //useful when no answer file exists to compare against
  private boolean m_generateBenchmark = false;

  private ArrayList m_questionList = new ArrayList(500);

  private int m_numThreads;

  private String m_postfix1;
  private String m_postfix2;

  private String m_benchmarkFileName = null;
  private String m_outputFileNames = null;
  private String m_diffFileNames = null;
  private String m_questionFileName = null;
  private String m_answerFileName = null;

  public TimeMeasurements[] timers;

  private String m_dbName;

  public static final String REQUIRYSTRING = "requiry".intern();

  ////////////////////////////////////////////////////////////////
  // CONSTRUCTOR
  ////////////////////////////////////////////////////////////////
  public TestMiniMetanet( String name )
  {

    super( name );
    m_postfix1 = "." + name;

    SystemProperties.setProperty( SystemProperties.ADD_HEADING, "true" );
  }

  ////////////////////////////////////////////////////////////////
  // OTHER PUBLIC METHODS
  ////////////////////////////////////////////////////////////////
  public void setNumberThreads( int n )
  {
    m_numThreads = n;
  }

  public void setDbName( String dbName )
  {
    m_dbName = dbName;
  }

  public void setQuestionFileName( String questionFileName )
  {
    m_questionFileName = questionFileName;
   try {File thisfile=new File("");
      System.out.println( "THis is the file questionFileName:
"+questionFileName );
      }  catch (Exception e){}
  }

  public void setAnswerFileName( String answerFileName )
  {
    m_benchmarkFileName = answerFileName;
  }

  ////////////////////////////////////////////////////////////////
  // FIXTURE
  ////////////////////////////////////////////////////////////////
  protected void setUp() throws IOException
  {
    File tempDir = new File( OUTPUTDIRNAME );
    if( !tempDir.exists() )
    {
      tempDir.mkdir();
    }

    //m_benchmarkFileName = BENCHMARK + m_postfix1;
    m_outputFileNames = OUTPUT + m_postfix1;
    m_diffFileNames = DIFF + m_postfix1;
    try {File thisfile=new File("");
      System.out.println( "THis is the file m_questionFileName:
"+m_questionFileName );
      }  catch (Exception e){}

    m_questionList = FileUtil.getListFromFile( m_questionFileName );

    if( m_questionList.size() == 0 || m_questionList == null )
    {
      throw new RuntimeException( "empty question list" );
    }
  }

  protected void tearDown()
  {
    if( m_questionList != null )
    {
      m_questionList.clear();
    }
  }

  //////////////////////////////////////////////////////////////
  // INNER CLASS
  //////////////////////////////////////////////////////////////

  public void testSubmitQueryMThread()
  {
    TestCaseRunnable threads[] = new TestCaseRunnable[ m_numThreads ];

    TimeMeasurements timers[] = new TimeMeasurements[ m_numThreads ];
    TimeMeasurements timer = new TimeMeasurements();

    for ( int i = 0; i < threads.length; i++ )
    {
      threads[i] = new SubmitQueryThread();
      timers[i] = ( (SubmitQueryThread) threads[i]).getTimer();
    }

    runTestCaseRunnables(threads);

    for ( int i = 0; i < threads.length; i++ )
    {
      timer.add( timers[i] );
      System.out.println("THREAD-" + i + ": " + timers[i].toString() );
    }

    System.out.println("ALL THREADS: " + timer.toString() );

   }

  ////////////////////////////////////////////////////////////////
  // INDUCTION
  ////////////////////////////////////////////////////////////////

  public static void main( String[] args )
  {
    /*
    if( args.length != 4 )
    {
      System.out.println( "Usage: DbName, questionfile name,
benchmarkfilename and Number of threads" );
      System.out.println
        ( "Example: runj cp_test.system.TestMiniMetanet");
      System.out.print( " minitest QUESTIONFILE_minimetanet
ANSWERFILE_minimetanet 1\n");

      System.exit(0);
    }
    */
    try {File thisfile=new File("");
      System.out.println( "Trying to get the damn file:
"+thisfile.getCanonicalPath() );
      }  catch (Exception e){}

    TestMiniMetanet test =
      new TestMiniMetanet("testSubmitQueryMThread");

    test.setNumberThreads( 1 );
    test.setDbName( "minitest" );
    test.setQuestionFileName( "QUESTIONFILE_minimetanet" );
    test.setAnswerFileName( "ANSWER_minimetanet" );

    try
    {
      junit.textui.TestRunner.run( test );
    }
    catch( Throwable t )
    {
      System.exit(0);
    }
  }

  //////////////////////////////////////////////////////////////
  // INNER CLASS
  //////////////////////////////////////////////////////////////
  public class SubmitQueryThread extends TestCaseRunnable
  {
    private TimeMeasurements m_threadTimer = new TimeMeasurements();
    private String m_postfix2;
    private ArrayList m_resultList = new ArrayList(500);

    public TimeMeasurements getTimer()
    {
      return m_threadTimer;
    }

    public void runTestCase()
      throws Exception
    {
      m_postfix2 = "." + Thread.currentThread().getName();

      File file = new File( m_outputFileNames + m_postfix2 );
      if( file.exists() )
      {
        file.delete();
      }
      file = new File( m_diffFileNames + m_postfix2 );
      if( file.exists() )
      {
        file.delete();
      }

      if( m_resultList != null )
      {
        m_resultList.clear();
      }

      m_threadTimer.reset();

      // start generating and submitting queries
      Iterator it = m_questionList.iterator();

      DomainConnection connection = null;
      ParserDBServices dbs = null;
      StringBuffer buf = new StringBuffer();

      //sigle out the first query which takes long initialization time
      boolean isFirstQuery = true;

      //test whether a time measurement has been ended, so that
      //when error occurs the timer can be ended in the final block
      Hashtable timingEnded = new Hashtable();
      Query oldQuery = null;
      boolean isRequiry = false;
      Query query = null;

      while( it.hasNext() )
      {
        connection = DomainManager.connect( m_dbName );
        dbs = connection.parserDbServices();

        String question = (String) ( it.next() );

        int reIndex = 0;

        if( (reIndex = question.indexOf( REQUIRYSTRING )) >= 0 )
        {
          question = question.substring( reIndex+REQUIRYSTRING.length()+1 );
          if( oldQuery == null )
          {
            throw new RuntimeException("Error: trying to requiry an null old
query"
                                   + " for " + question );
          }

          isRequiry = true;
        }

        buf.append( "<question question=\"" + question + "\"/>\n");
        if( isRequiry )
        {
          buf.append( "<requiry oldSummary=" + oldQuery.getQuerySummary()
                      + "\"/>\n");
        }

        timingEnded.clear();

        try
        {
          timingEnded.put( isFirstQuery? "createFirstQuery":"createQuery",
                           Boolean.FALSE );

          m_threadTimer.startMeasurement( (isFirstQuery?

                                        "createFirstQuery":"createQuery") );
          if( !isRequiry )
          {
            query = QueryFunctions.createQuery( connection, question );
          }
          else
          {
            query = QueryFunctions.refineQuery( connection, oldQuery,
                                                question);
          }

          m_threadTimer.endMeasurement( (isFirstQuery?

                                        "createFirstQuery":"createQuery") );
          timingEnded.put( isFirstQuery? "createFirstQuery":"createQuery",
                           Boolean.TRUE );

          timingEnded.put( "executeQuery", Boolean.FALSE );
          m_threadTimer.startMeasurement( "executeQuery" );
          Iterator results = QueryFunctions.executeQuery( connection,
query );

          if( results.hasNext() )
          {
            AppendResultUtil.appendSuccessInfo( buf, query, results );
          }
          else
          {
            AlternateQuery[] alts = null;
            if( query.isUsefulSearch(dbs) )
            {
              alts = QueryFunctions.generateAlternates( connection, query );
            }
            if( alts == null || alts.length == 0 )
            {
              AppendResultUtil.appendFailureInfo( buf );
            }
            else if( alts.length == 1 )
            {
              AppendResultUtil.appendOneAlternateInfo( buf, alts );
            }
            else
            {
              AppendResultUtil.appendAlternatesInfo( buf, alts );
            }
          }

          DomainManager.disconnect( connection );

          m_resultList.add( buf.toString() );
          m_threadTimer.endMeasurement( "executeQuery" );
          timingEnded.put( "executeQuery", Boolean.TRUE );

          oldQuery = query;
          isRequiry = false;
        }
        catch( Exception e )
        {
          m_resultList.add( buf.toString() );
          m_resultList.add( (e.toString()).trim() );
        }
        finally
        {
          FileUtil.saveListToFile(m_resultList,
m_outputFileNames+m_postfix2);

          int b = buf.length();
          buf.delete( 0, buf.length() ); //clear stringbuffer for reuse

          Object o = timingEnded.get(isFirstQuery?
                                     "createFirstQuery":"createQuery");
          if( o != null && !((Boolean)o).booleanValue() )
          {
            m_threadTimer.endMeasurement( (isFirstQuery?
                                     "createFirstQuery":"createQuery") );
          }
          isFirstQuery = false;

          o = timingEnded.get("executeQuery");
          if( o != null && !((Boolean)o).booleanValue() )
          {
            m_threadTimer.endMeasurement( "executeQuery" );
          }
        }
      }

      // start testing
      assert("\n ERROR in TestMiniMetanet: Diffs are saved in file " +
             m_diffFileNames,
             DiffUtil.diffFiles( m_outputFileNames + m_postfix2,
                                 m_benchmarkFileName,
                                 m_diffFileNames + m_postfix2 )  );

      System.out.println( m_threadTimer.toString() );
    }
  }
}
----- Original Message -----
From: "Erik Hatcher" <jakarta-ant@ehatchersolutions.com>
To: "Ant Users List" <ant-user@jakarta.apache.org>
Sent: Thursday, December 27, 2001 1:14 PM
Subject: Re: ant/junit & files


> Marcus,
>
> The only way for us to help you is for you to post your test case code,
and
> your build.xml snippet that is calling the tests.
>
> Are you referencing files by full path?  Or by relative path?  Are they in
> the classpath?
>
>     Erik
>
> ----- Original Message -----
> From: "Marcus" <marcusz@criticalpointsoftware.com>
> To: "Ant Users List" <ant-user@jakarta.apache.org>
> Sent: Thursday, December 27, 2001 4:18 PM
> Subject: ant/junit & files
>
>
> Please excuse my ignorance, but I am new to ant and junit.
>
> My unit test reads a file and outputs a file. my problem is as long as my
> unit tests do not read in or spit out a file
> the test unit runs fine. what i get as an error when running with in ant
and
> using junit it can't find the file
> even thought:
> 1) the file is there
> 2) i run with java, from  line command, and it runs just fine
> 3) i run ant.java and it runs fine
>
> Does anyone know why it can't find the file when using ant/junit but
> ant/java works fine?
>
> Thanks in advance.
> -mez
>
>
>
> --
> To unsubscribe, e-mail:   <mailto:ant-user-unsubscribe@jakarta.apache.org>
> For additional commands, e-mail: <mailto:ant-user-help@jakarta.apache.org>
>
>


--
To unsubscribe, e-mail:   <mailto:ant-user-unsubscribe@jakarta.apache.org>
For additional commands, e-mail: <mailto:ant-user-help@jakarta.apache.org>


Mime
View raw message