testperl.pl

Software Testing Automation Framework (STAF)的开发代码

# Test private methods passing in non-English data

my $data = "墺";
my $expectedResult = "!!@墺@!!";
my $outString = STAF::AddPrivacyDelimiters($data);
print "  STAF::AddPrivacyDelimiters($data, 1): $outString\n";
if ($outString != $expectedResult) {
   print "Error: STAF::AddPrivacyDelimiters($data): $outString\n";
   print "       Should return the following instead: $expectedResult";
   exit 1;
}

my $data = "!!@墺@!!";
my $expectedResult = "^!!@墺!@!!";
my $outString = STAF::EscapePrivacyDelimiters($data);
print "  STAF::EscapePrivacyDelimiters($data, 1): $outString\n";
if ($outString != $expectedResult) {
   print "Error: STAF::EscapePrivacyDelimiters($data): $outString\n";
   print "       Should return the following instead: $expectedResult";
   exit 1;
}

my $outString = STAF::MaskPrivateData($data);
my $expectedResult = "********";
print "  STAF::MaskPrivateData($data, 1): $outString\n";
if ($outString != $expectedResult) {
   print "Error: STAF::MaskPrivateData($data): $outString\n";
   print "       Should return the following instead: $expectedResult";
   exit 1;
}

my $outString = STAF::RemovePrivacyDelimiters($data);
my $expectedResult = "墺";
print "  STAF::RemovePrivacyDelimiters($data, 1): $outString\n";
if ($outString != $expectedResult) {
   print "Error: STAF::RemovePrivacyDelimiters($data): $outString\n";
   print "       Should return the following instead: $expectedResult";
   exit 1;
}

# Test the Monitor wrapper APIs

print "\nTesting Monitor Service Wrapper...\n";

my $machine = $result->{result};
print "  STAF/Config/Machine=$machine\n";

print "  Log a message to the monitor service\n";
$rc = STAF::Monitor::Log("Hello World"); 
if ($rc != $STAF::kOk) { 
    print "Error logging message to Monitor, RC: $rc\n"; 
    exit $rc; 
}

$mon = STAF::STAFMonitor->new($handle); 
$result = $mon->log("Hello World Again"); 
if ($result->{rc} != $STAF::kOk) { 
    print "Error logging message to Monitor, RC: $result->{rc}\n"; 
    exit $rc; 
} 

print "\nTesting Log Service Wrapper...\n";

print "  Init Log\n";
$rc = STAF::Log::Init("TestCase1", "GLOBAL", "FATAL ERROR"); 
print "  Log a message\n";
$rc = STAF::Log::Log("WARNING", "Unable to find specified file"); 
if ($rc != $STAF::kOk) { 
    print "Error logging message to Log, RC: $rc\n"; 
    exit $rc; 
}

print "  Init TestCase2 log\n";
$log = STAF::STAFLog->new($handle, "TestCase2", "GLOBAL", "FATAL ERROR"); 
$result = $log->log("WARNING", "Unable to find specified file"); 
if ($result->{rc} != $STAF::kOk) { 
    print "Error logging message to Log, RC: $result->{rc}\n"; 
    exit $result->{rc}; 
}

$logtype = $log->getLogType(); 
print "  Log Type: $logtype\n"; 
$logmask = $log->getMonitorMask(); 
print "  Log's Monitor Mask: $logmask\n"; 
$system = $log->getSystemName(); 
print "  Log Service System Name: $system\n"; 
$service = $log->getServiceName(); 
print "  Log Service Name: $service\n"; 

print "\nTesting Unmarshalling...\n";

# Submit a FS QUERY ENTRY request and unmarshall it's result

print "\n  STAF local FS QUERY ENTRY {STAF/Config/ConfigFile}\n\n";
$result = $handle->submit("local", "FS", "QUERY ENTRY {STAF/Config/ConfigFile}");

if ($handle->{rc} != $STAF::kOk) {
    print "Error on FS QUERY ENTRY request.\n";
    print "Expected RC: 0\n";
    print "Received RC: $handle->{rc}, Result: $result->{result}\n";
    exit $handle->{rc}; 
}

if (!STAF::STAFIsMarshalledData($result->{result})) {
    print "ERROR: Not marshalled data:  Result: $result->{result}\n";
}

my $mc = STAF::STAFUnmarshall($result->{result});
my $entryMap = $mc->getRootObject();

if ($entryMap->{type} eq "F") {
    print "  File Name         : $entryMap->{name}\n";
    print "  Size              : $entryMap->{lowerSize}\n";
    print "  Date Last Modified: $entryMap->{lastModifiedTimestamp}\n";
}
else {
    print "Error on FS QUERY ENTRY result.\n";
    print "$fileName is not a file.  Type=$entryMap->{type}\n";
    exit 1;
}

# Submit a PROCESS START request without a WAIT option

my $command = 'dir {STAF/Config/STAFRoot}';
my $request = "START COMMAND ".STAF::WrapData($command).
              " RETURNSTDOUT STDERRTOSTDOUT";

print "\n  STAF local PROCESS $request\n";

$result = $handle->submit("local", "PROCESS", $request);

if ($handle->{rc} != $STAF::kOk) {
    print "Error on STAF local PROCESS $request\n";
    print "Expected RC: 0\n";
    print "Received RC: $handle->{rc}, Result: $result->{result}\n";
    exit $handle->{rc}; 
}

print "\n  Process Handle: $result->{result}";

# Submit a PROCESS START request and wait for it to complete

my $command = 'dir {STAF/Config/STAFRoot}';
my $request = "START COMMAND ".STAF::WrapData($command).
              " RETURNSTDOUT STDERRTOSTDOUT WAIT";

print "\n  STAF local PROCESS $request\n";

$result = $handle->submit("local", "PROCESS", $request);

if ($handle->{rc} != $STAF::kOk) {
    print "Error on STAF local PROCESS $request\n";
    print "Expected RC: 0\n";
    print "Received RC: $handle->{rc}, Result: $result->{result}\n";
    exit $handle->{rc}; 
}

# Unmarshall the result which is a marshalling context whose 
# root object is a map containing keys 'rc', and 'fileList'.
# The value for 'fileList' is a list of the returned files.
# Each entry in the list consists of a map that contains keys
# 'rc' and 'data'.  In our PROCESS START request, we returned
# one file, stdout (and returned stderr to this same file).

my $mc = STAF::STAFUnmarshall($result->{result});
my $mcRootObject = $mc->getRootObject();

# Verify that the process rc is 0

my $processRC = $mcRootObject->{rc};

if ($processRC != $STAF::kOk) {
    print "  Process RC: $processRC\n";
    exit $processRC;
}

# Verify that the rc is 0 for returning data for the Stdout file 

my $stdoutRC = $mcRootObject->{fileList}[0]{rc};

if ($stdoutRC != $STAF::kOk) {
    print "Error on retrieving process's stdout data.\n";
    print "Expected RC: 0\n";
    print "Received RC: $stdoutRC\n";
    exit $stdoutRC; 
}

# Print the data in the stdout file created by the process

my $stdoutData = $mcRootObject->{fileList}[0]{data};

print "\n  Process Stdout File Contains:\n";
print "$stdoutData\n";

print "\nTesting Class STAFMapClassDefinition's methods...\n";

my $myMapClassDef = STAF::STAFMapClassDefinition->new('Test/MyMap');
$myMapClassDef->addKey('name', 'Name');
$myMapClassDef->addKey('exec', "Executable");
$myMapClassDef->addKey('testType', 'Test Type');
$myMapClassDef->setKeyProperty('testType', 'display-short-name', 'Test');
$myMapClassDef->addKey('outputList', 'Outputs');
 
my $myMapClassName = $myMapClassDef->name();

my $foundKeys = 0;

for my $key ($myMapClassDef->keys()) {
    if ($key->{'key'} eq "name") {
        $foundKeys = $foundKeys + 1;
    }
    elsif ($key->{'key'} eq "exec") {
        $foundKeys = $foundKeys + 1;
    }
    elsif (($key->{'key'} eq "testType") && ($key->{'display-short-name'} eq "Test")) {
        $foundKeys = $foundKeys + 1;
        print "  key=$key->{'key'} display-name=$key->{'display-name'}".
              "  display-short-name=$key->{'display-short-name'}\n";
    }
    elsif ($key->{'key'} eq "outputList") {
        $foundKeys = $foundKeys + 1;
    }
}

if ($foundKeys != 4) {
    print "ERROR: Map Class Definition does not contain the correct 4 keys.\n".
          "Contains $foundKeys keys.\n";
    exit 1;
}

# Create a map class definition

$myMapClassDef = STAF::STAFMapClassDefinition->new('Test/MyMap');
$myMapClassDef->addKey('name', 'Name');
$myMapClassDef->addKey('exec', 'Executable');

# Create a marshalling context and assign a map class definition to it

print "\nTesting Class STAFMarshallingContext Methods...\n";

my $mc = STAF::STAFMarshallingContext->new();
$mc->setMapClassDefinition($myMapClassDef);

if (!$mc->hasMapClassDefinition('Test/MyMap'))
{
    print "Oops, map class 'Test/MyMap' doesn't exist\n";
    exit 1;
}

# Get the map class definition from the marshalling context

my $mapClassDef = $mc->getMapClassDefinition('Test/MyMap');

# Set the root object for a marshalling context to be a string
# and get the root object.

$data = "This is a string";
$mc->setRootObject($data);
my $rootObj = $mc->getRootObject($myTestList);

print "  Root object: $rootObj\n";

# Create a map class definition without a name

my $myDef = STAF::STAFMapClassDefinition->new();
$myDef->addKey('key1', 'Key 1');
my $myDefName = $myDef->name();

# Test STAFResult->new

print "\nTesting STAFResult->new...\n";

my $result = STAF::STAFResult->new(0, 'Successful');
if (($result->{rc} != $STAF::kOk) or
    (!$result->{result} eq 'Successful')) {
    print "ERROR: Wrong STAFResult.".
          "RC: $result->{rc} Result: $result->{result}\n";
    exit $result->{rc};
}

# Test STAF::WrapData function

print "\nTesting STAF::WrapData...\n";

my $message = "Hello World";
$result = $handle->submit(
    "local", "monitor", "log message ".STAF::WrapData($message));

if ($result->{rc} != $STAF::kOk) { 
    print "Error logging message to Monitor,".
          " RC: $result->{rc} Result: $result->{result}\n"; 
    exit $result->{rc}; 
} 

# Unregister the handle

print "\nUnregistering handle $handle->{handle}\n";

$rc = $handle->unRegister();
if ($rc != $STAF::kOk) {
    print "Error unregistering with STAF, RC: $STAF::RC\n";
    exit $rc;
}

print "\n *** All tests successful ***\n";