xref: /aoo42x/main/xmerge/source/palmtests/qa-wrapper/bin/qa_test_driver.pl (revision 7e90fac2)

#!/usr/bin/perl
#########################################################################

 #**************************************************************
#
#  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.
#
#**************************************************************



####################################################################
# File Name: test_driver.pl
# Version  : 1.0
# Project  : Xmerge
# Author   : Brian Cameron
# Date	   : 5th Sept. 2001
#
#
# This script does the following:
#
# Processes the input file, and runs the tests specified in that
# file.  This will do the following for each test:
#
# 1. Convert a file from XML to PDB format
# 2. Starts up the Palm OS emulator with the appropriate program
#    running and the converted file loaded the program.
# 3. Makes automated changes as specified in the inputfile to
#    this script..
# 4. Returns to the main applications window.
#
# Parameter
#   Filename to convert and change
#
##########################################################################

# Turn on auto-flushing
#
$|=1;

use EmRPC;

# Directory where converterlib is located...
#
#use lib "/export/home/test/qadir/qa/lib";
use lib $ENV{'QA_LIB_HOME'};
use converterlib;

#-------------------- Start of main script ------------------------------------

# Environmental Settings

$pose_exe = "";
$pose_prc = "";
$test_list = "";
$infile = "";
$merge_opt = 0;
# if testcase hasn't completed in 10 mins, then kill it off
$testcase_timeout=600;

# You may need to change this from the default if your pose emulator
# starts faster or slower than mine.
#
if ($ENV{'POSE_TIMEOUT'})
{
  $pose_timeout  = "$ENV{'POSE_TIMEOUT'}";
}
else
{
  $pose_timeout = 15;
}

$cmdline_len = @ARGV;
if ($cmdline_len <= 0)
{
	print_usage();
	exit (0);
}

&process_cmdline(@ARGV);
&print_env();
&verify_env_options();

# Make the output directories with timestamps included in the
# directory names.
#
mkdir $pdb_orig, 0777 || die "can not create directory <$pdb_orig>.";
`chmod 777 $pdb_orig`;
mkdir $pdb_new,  0777 || die "can not create directory <$pdb_new>.";
`chmod 777 $pdb_new`;
mkdir $xml_new,  0777 || die "can not create directory <$xml_new>.";
`chmod 777 $xml_new`;

&verify_prcs_exist("DBExporter.prc");

if ($test_list ne "")
{
	open (TESTLIST, $test_list) || die "Couldn't open testcase list file $test_list";

	while (<TESTLIST>)
	{
		&process_testcase($_);
	}
}
elsif ($infile ne "")
{
	if (!defined($child_pid = fork()))
	{
		# there was an error forking a process
		print "ERROR: Unable to fork process\n";
		die "ERROR: Unable to fork process\n";
	}
	elsif ($child_pid)
	{
		# this is the parent process
		# run the actual test here
print "********\tPARENT (pid = $$): process_testcase...\n";
		&process_testcase($infile);
print "********\tPARENT (pid = $$): ...process_testcase finished normally\n";

		# test finished normally, so kill the monitor
		# that is running in the child process
print "********\tPARENT (pid = $$): kill child process ($child_pid)\n";
print "********\tPARENT Before:\n";
system( "/usr/bin/ptree" );
		kill( $child_pid );
		kill( 9, $child_pid );
print "********\tPARENT After:\n";
system( "/usr/bin/ptree" );
	}
	else
	{
print "********\tCHILD (pid = $$): sleep for $testcase_timeout seconds\n";
		# this is the child process
		# wait on the test running in the parent, and
		# kill it if it hasn't finished on time
		sleep( $testcase_timeout );

		# if the parent hasn't killed this process before it
		# gets here, then it's probably hung, so we need to
		# kill it.
		print "********\tCHILD (pid = $$): TEST HUNG? still "
			."running after [$testcase_timeout] seconds - "
			."need to kill test process\n";
		$parent = getppid;

		if ( $parent != 1 ) {
			print "********\nCHILD (pid = $$): Killing process ($parent)\n";
			kill( $parent );
			kill( 9, $parent );
		} else {
			# If we cannot get the ppid, then the parent might
			# have died abnormally, before it got a chance to
			# kill this (child) process.
			print "********\nCHILD (pid = $$): cannot determine ppid - "
				."terminating\n";
system( "/usr/bin/ptree" );
			exit(2);
		}

		exit(1);
	}
}
else
{
	die ("You didn't supply any test cases to process");
}

print "Finished.\n";
exit(0);

#-------------------- End of main script ----------------------------------------

#--------------------------------------------------------------------------------
# Various sub routines
#--------------------------------------------------------------------------------

# process_testcase
# infile - test case file name
#
# This is the main driver function
# Opens the infile, reads it in parses it, runs the appropriate conversion
# starts pose and load the file into the emulator. It launches the
# appropriate editor and then runs the commands specified in the test case.
# It then exports the file and saves it locally. Finally it is converted
# back to the original office format.
#
sub process_testcase
{
    my $infile = $_[0];
    my $convert_file = "";
    my $rc;

	# Process the inputfile
	#
	open (INFILE, $infile) || die "Failed to open test case <$infile>";

	$running_testtype = "";

	# Process the input file.
	#
	while ($c_inline = <INFILE>)
	{
	   chomp $c_inline;
	   @entry = split('\|', $c_inline);

	   # Process TEST
	   #
	   if ($c_inline =~ /^ *#/ || $c_inline =~ /^[ \t]*$/)
	   {
	      # skip comments and blank lines.
	      #
	      next;
	   }
	   elsif ("$entry[0]" eq "TEST")
	   {
	      # Close the test if one is running.
	      #
	      &close_program($convert_file);
	      $running_testtype = "";

	      $valid_test = 0;

	      if ($#entry != 3)
	      {
	         print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      else
	      {
	         # Start the test.
	         #
	         print "\nStarting test: $entry[1]\n";
	         $convert_file = $entry[3];

	         if ("$entry[2]"  =~ /[Qq][Uu][Ii][Cc][Kk][Ww][Oo][Rr][Dd]/)
	         {
	            $xml_extension = "sxw";
	            $convert_to = "application/x-aportisdoc";

	            # Convert XML file to pdb format.
	            #
	            $rc = &convert_to_pdb("$xml_orig", $convert_file, $xml_extension ,
	               $convert_to,"$pdb_orig");
	            if ($rc != 0)
	            {
	               print "\nERROR, problem converting file $convert_file\n\n";
	            }
	            else
	            {
	               # Start pose
	               #
	               $rc = &start_pose("$pose_exe",
                     "$pose_prc/Quickword.PRC,$pose_prc/DBExporter.prc,$pdb_orig/$convert_file.pdb",
	                 "Quickword", $pose_timeout);

	               if ($rc == 0)
	               {
	                  &start_quickword();
	                  $valid_test = 1;
	                  $running_testtype = "QUICKWORD";
                      print "\npose launched, begin automated test sequence for QuickWord\n";
	               }
                   else
                   {
                      &kill_pose();
	                  $running_testtype = "";
                   }
	            }
	         }
	         elsif ("$entry[2]"  =~ /[Mm][Ii][Nn][Ii][Cc][Aa][Ll][Cc]/)
	         {
	            $xml_extension = "sxc";
	            $convert_to = "application/x-minicalc";

	            # Convert XML file to pdb format.
	            #
	            $rc = &convert_to_pdb("$xml_orig", $convert_file,
                  $xml_extension, $convert_to,"$pdb_orig");
	            if ($rc != 0)
	            {
	               print "\nERROR, problem converting file $convert_file\n\n";
	            }
	            else
	            {
	               # Get minicalc PDB file names, since an SXC file can
	               # be converted to more than one.
	               #
	               $pdb_files="";
	               $i = 1;
	               while (-f "$pdb_orig/$convert_file-Sheet$i.pdb")
	               {
	                 if ($i > 1)
	                 {
	                   $pdb_files .= ",";
	                 }
	                 $pdb_files .= "$pdb_orig/$convert_file-Sheet$i.pdb";
	                 $i++;
	               }
	               $number = $i-1;

	               # Start pose
	               #
	               $rc = &start_pose("$pose_exe",
	                  "$pose_prc/MiniCalc.prc,$pose_prc/DBExporter.prc,$pdb_files",
	                  "MiniCalc", $pose_timeout);

	               if ($rc == 0)
	               {
	                  &start_minicalc();
	                  $valid_test = 1;
	                  $running_testtype = "MINICALC";
                      print "pose launched, begin automated test sequence for MiniCalc\n";
	               }
                   else
                   {
                      &kill_pose();
	                  $running_testtype = "";
                   }
	            }
	         }
	         else
	         {
	            print "\nERROR, invalid extension <$entry[2]>\n\n";
	         }
	      }
	   }

	   # Process DB_EXPORT
	   #
	   elsif ("$entry[0]" eq "DB_EXPORT")
	   {
	      if ($#entry != 1)
	      {
         	print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      else
	      {
	         &db_export($entry[1]);
	      }
	   }

	   # Process TAP_APPLICATIONS
	   #
	   elsif ("$entry[0]" eq "TAP_APPLICATIONS")
	   {
	      if ($#entry != 0)
	      {
         	print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      else
	      {
	         &tap_applications(0);
	      }
	   }

	   # Process ENTER_STRING_AT_LOCATION
	   #
	   elsif ("$entry[0]" eq "ENTER_STRING_AT_LOCATION")
	   {
	      if ($#entry != 3)
	      {
	         print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      elsif ($valid_test == 0)
	      {
	         print "\nERROR, can not process $entry[0] for invalid test\n\n";
	      }
	      else
	      {
	         &enter_string_at_location($entry[1], $entry[2],
               $entry[3], $running_testtype);
	      }
	   }

	   # Process TAP_PEN
	   #
	   elsif ("$entry[0]" eq "TAP_PEN")
	   {
	      if ($#entry != 2)
	      {
	         print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      elsif ($valid_test == 0)
	      {
	         print "\nERROR, can not process $entry[0] for invalid test\n\n";
	      }
	      else
	      {
	         &pose_tap_pen($entry[1], $entry[2], 0);
	      }
	   }

	   # Process TAP_BUTTON
	   #
	   elsif ("$entry[0]" eq "TAP_BUTTON")
	   {
	      if ($#entry != 1)
	      {
	         print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      elsif ($valid_test == 0)
	      {
	         print "\nERROR, can not process $entry[0] for invalid test\n\n";
	      }
	      else
	      {
	         &pose_tap_button($entry[1], 0);
	      }
	   }

           # Process TAP_PEN_HARD
           #
           elsif ("$entry[0]" eq "TAP_PEN_HARD")
           {
              if ($#entry != 2)
              {
                 print "\nERROR, $entry[0] invalid number of arguments\n\n";
              }
              elsif ($valid_test == 0)
              {
                 print "\nERROR, can not process $entry[0] for invalid test\n\n";
              }
              else
              {
                 &pose_tap_pen_hard($entry[1],$entry[2], 0);
              }
           }


	   # Process SLEEP
	   #
	   elsif ("$entry[0]" eq "SLEEP")
	   {
	      if ($#entry != 1)
	      {
         	print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      else
	      {
	         &pose_sleep($entry[1]);
	      }
	   }

	   # Process MINICALC_ENTER_CELL
	   #
	   elsif ("$entry[0]" eq "MINICALC_ENTER_CELL")
	   {
	      if ($#entry != 3)
	      {
	         print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      elsif ($valid_test == 0)
	      {
	         print "\nERROR, can not process $entry[0] for invalid test\n\n";
	      }
	      else
	      {
	         &minicalc_enter_cell($entry[1], $entry[2], $entry[3]);
	      }
	   }

	   # Process QUICKWORD_FIND_REPLACE
	   #
	   elsif ("$entry[0]" eq "QUICKWORD_FIND_REPLACE")
	   {
	      if ($#entry != 2)
	      {
	         print "\nERROR, $entry[0] invalid number of arguments\n\n";
	      }
	      elsif ($valid_test == 0)
	      {
	         print "\nERROR, can not process $entry[0] for invalid test\n\n";
	      }
	      else
	      {
	         &quickword_find_replace($entry[1], $entry[2]);
	      }
	   }
	   else
	   {
	      print "\nERROR, invalid line <$c_inline>\n";
	   }
	}

	&close_program($convert_file);
}

# close_program
# convert_file - file to export
#
# closes the program running in pose and kills pose
#
sub close_program
{
    my $convert_file = $_[0];

	if ($running_testtype eq "QUICKWORD")
    {
        print "QuickWord test completed.\n";
		&close_program_quickword($convert_file);
    }
	elsif ($running_testtype eq "MINICALC")
    {
        print "MiniCalc test completed.\n";
		&close_program_minicalc($convert_file, $number);
    }
}

# close_program_quickword
# convert_file - file to export
#
# Closes quickword and kills pose
#
sub close_program_quickword
{
      my $convert_file = $_[0];
      my $error_file = "./error.txt";
      my $rc;

      &close_quickword();

      &db_export($convert_file);
      print "Moving /tmp/$convert_file.pdb to $pdb_new\n";
      `mv /tmp/$convert_file.pdb $pdb_new`;
      `chmod 666 $pdb_new/$convert_file.pdb`;

      &close_connection(1);
      &kill_pose();
      print "\nFinishing test...\n";

      # The path of where to put the error file should be specified
      # in the properties file.  Not sure if it is really necessary
      # to put this out to a separate file.  STDOUT should be fine.
      #
      $rc = &convert_to_xml($xml_new, $xml_orig,
        "$pdb_new/$convert_file.pdb", "application/x-aportisdoc" ,
          "sxw", $convert_file, $merge_opt);
      if ($rc != 0)
      {
        print "\nERROR, problem converting file $pdb_new/$convert_file.pdb\n\n";
      }
}

# close_program_minicalc
# convert_file - file to export
#
# Closes minicalc and kills pose
#
sub close_program_minicalc
{
	  my $convert_file = $_[0];
	  my $num_files   = $_[1];
	  my $list="";
	  my $rc;

	  &close_minicalc();

	  for ($a=1; $a <= $num_files; $a++)
	  {
	    &db_export("$convert_file-Sheet$a");
	    print "Moving /tmp/$convert_file-Sheet$a.pdb to $pdb_new/\n";
	    `mv /tmp/$convert_file-Sheet$a.pdb $pdb_new/`;
	    `chmod 666 $pdb_new/$convert_file-Sheet$a.pdb`;
	  }

	  &close_connection(1);
	  &kill_pose();
	  print "\nFinishing test...\n";

	  for ($a=1; $a <= $num_files; $a++)
	  {
	    $list .="$pdb_new/$convert_file-Sheet$a.pdb "
	  }

	  $rc = &convert_to_xml($xml_new, $xml_orig, "$list",
		  "application/x-minicalc", "sxc", $convert_file, $merge_opt);
	  if ($rc != 0)
	  {
	    print "\nERROR, problem converting file(s) $list\n\n";
	  }

      &pose_sleep(5);
}

# print_usage
#
# prints the usage for this program.
#
sub print_usage
{
	print "Usage : test_driver.pl\n";
	print "\t-test=<file> \t\t: individual test case file to run\n";
	print "\t-list=<file> \t\t: list of test case files\n";
	print "\t-env=<file> \t\t: Properites like file defining env\n";
	print "\t-pose-exe=<fullpath> \t: path to pose executable\n";
	print "\t-pose-prc=<path> \t: path to directory holding prc files\n";
	print "\t-pdb-orig=<path> \t: directory to hold original pdb files\n";
	print "\t-pdb-new=<path> \t: directory to hold new pdb files\n";
	print "\t-xml-orig=<path> \t: directory to hold original office documents\n";
	print "\t-xml-new=<path> \t: directory to hold new office documents\n";
	print "\t-merge          \t: Invokes the merge option when converting\n";
	print "\t                \t  from PDB back to XML.\n";
}

# print_env
#
# Prints the current environment.
#
sub print_env
{
	print "\nUsing the following environment:\n";
	print "\tPOSE_EXE  = $pose_exe\n";
	print "\tPOSE_PRC  = $pose_prc\n";
	print "\tPDB_ORIG  = $pdb_orig\n";
	print "\tPDB_NEW   = $pdb_new\n";
	print "\tXML_ORIG  = $xml_orig\n";
	print "\tXML_NEW   = $xml_new\n";
}

# process_cmdline
#
# command line options come in as key/value pairs.
# read them and set the appropriate global variable
#
# Sets these globals: pose_exe, pose_prc, xml_orig, xml_new_dir,
# xml_new, pdb_orig_dir, pdb_orig, pdb_new_dir, pdb_new.
#
sub process_cmdline
{
	foreach $i (@_)
	{
		my @arg= split('=', $i);
		@arg[0] =~ tr/A-Z/a-z/;

		if (@arg[0] eq "-pose-exe")
		{
			$pose_exe=$arg[1];
		}
		elsif (@arg[0] eq "-pose-prc")
		{
			$pose_prc=$arg[1];
		}
		elsif (@arg[0] eq "-pdb-orig")
		{
			$pdb_orig_dir=$arg[1];
			$pdb_orig=$arg[1];
		}
		elsif (@arg[0] eq "-pdb-new")
		{
			$pdb_new_dir=$arg[1];
			$pdb_new=$arg[1];
		}
		elsif (@arg[0] eq "-xml-orig")
		{
			$xml_orig=$arg[1];
		}
		elsif (@arg[0] eq "-xml-new")
		{
			$xml_new_dir=$arg[1];
			$xml_new=$arg[1];
		}
		elsif (@arg[0] eq "-env")
		{
			&set_env_from_props($arg[1]);
		}
		elsif (@arg[0] eq "-list")
		{
			$test_list = $arg[1];
		}
		elsif (@arg[0] eq "-test")
		{
			$infile = $arg[1];
		}
		elsif (@arg[0] eq "-merge")
		{
		     $merge_opt = 1;
		}
		else
		{
			print_usage();
			die "Incorrect command line";
		}
	}
}

# set_env_from_props
# infile - property file
#
# Read the properties file, of the form key=value
# Valid key values are :
#	POSE_EXE
#	POSE_PRC
#	PDB_ORIG
#	PDB_NEW
#	XML_ORIG
#	XML_NEW
# If a value is found the appropriate global variable is set.
#
# Sets these globals: pose_exe, pose_prc, xml_orig, xml_new_dir,
# xml_new, pdb_orig_dir, pdb_orig, pdb_new_dir, pdb_new.
#
sub set_env_from_props
{
    my $infile = $_[0];

	open(PROPSFILE, $infile) || die "Could not open properties file <$infile>";

	while (<PROPSFILE>)
	{
		chomp $_;
		my @arg = split('=', $_);
		@arg[0] =~ tr/a-z/A-Z/;
		my $len = @arg;
		if ($len != 2)
		{
			die "Malformed property in $arg[0]";
		}
		if (@arg[0] eq "POSE_EXE")
		{
			$pose_exe=$arg[1];
		}
		elsif (@arg[0] eq "POSE_PRC")
		{
			$pose_prc=$arg[1];
		}
		elsif (@arg[0] eq "PDB_ORIG")
		{
			$pdb_orig_dir=$arg[1];
			$pdb_orig=$arg[1];
		}
		elsif (@arg[0] eq "PDB_NEW")
		{
			$pdb_new_dir=$arg[1];
			$pdb_new=$arg[1];
		}
		elsif (@arg[0] eq "XML_ORIG")
		{
			$xml_orig=$arg[1];
		}
		elsif (@arg[0] eq "XML_NEW")
		{
			$xml_new_dir=$arg[1];
			$xml_new=$arg[1];
		}

	}
	close PROPSFILE;
}

# verify_env_options
#
# Verify that input options are correctly set.
# Assumes pose_exe, pose_prc, xml_orig, xml_new_dir,
# pdb_orig_dir, and pdb_new_dir are already set.
#
sub verify_env_options
{
	if (!-e "$pose_exe")
	{
		die "The pose executable cannot be found at $pose_exe.";
	}
	if (!-x $pose_exe)
	{
		die "$pose_exe exists but is not executable.";
	}

	if (!-e "$pose_prc")
	{
		die "The PRC directory specified as $pose_prc does not exist.";
	}
	if (!-d "$pose_prc")
	{
		die "The PRC location specified as $pose_prc exists, but is not a directory.";
	}

	if (!-e "$pdb_orig_dir")
	{
		die "The original PDB directory specified as $pdb_orig_dir does not exist.";
	}
	if (!-d "$pdb_orig_dir")
	{
		die "The original PDB directory specified as $pdb_orig_dir exists but is not a directory.";
	}

	if (!-e "$pdb_new_dir")
	{
		die "The new PDB directory specified as $pdb_new_dir does not exist.";
	}
	if (!-d "$pdb_new_dir")
	{
		die "The new PDB directory specified as $pdb_new_dir exists but is not a directory.";
	}

	if (!-e "$xml_orig")
	{
		die "The original Office document directory specified as $xml_orig does not exist.";
	}
	if (!-d "$xml_orig")
	{
		die "The original Office document location specified as $xml_orig exists but is not a directory.";
	}

	if (!-e "$xml_new_dir")
	{
		die "The new Office document directory specified as $xml_new_dir does not exist.";
	}
	if (!-d "$xml_new_dir")
	{
		die "The new Office document location specified as $xml_new_dir exists but is not a directory.";
	}
}

# verify_prcs_exist
# prcfile - the PRC file to check
#
# Verifies that the specified PRC file exists.
#
sub verify_prcs_exist
{
    my $prcfile = $_[0];

	if (!-e "$pose_prc/$prcfile")
	{
		die "The pose PRC directory ($pose_prc) is correct, but I can't find $prcfile there.";
	}
}