FrT;@1|>>0|$15|HeaderDoc::Test%22|$4|CODE$7|COMMENT$7|CPPCODE$15|EXPECTED_RESULT$23|EXPECTED_RESULT_ALLDECS$7|FAILMSG$8|FILENAME$4|LANG$4|NAME$7|SUBLANG$4|TYPE$11365|sub runTest {
    my $self = shift;
    my $results = "";

    my $prevignore = $HeaderDoc::ignore_apiuid_errors;
    $HeaderDoc::ignore_apiuid_errors = 1;
    $HeaderDoc::test_mode = 1;
    $HeaderDoc::curParserState = undef;
    use strict;

    $HeaderDoc::dumb_as_dirt = 0;
    $HeaderDoc::parse_javadoc = 1;
    $HeaderDoc::IncludeSuper = 0;
    $HeaderDoc::ClassAsComposite = 1;
    $HeaderDoc::process_everything = 0;
    $HeaderDoc::align_columns = 0;
    $HeaderDoc::groupright = 1;
    $HeaderDoc::ignore_apiowner_names = 0;
    $HeaderDoc::add_link_requests = 1;
    $HeaderDoc::truncate_inline = 1;
    $HeaderDoc::sort_entries = 1;
    $HeaderDoc::enableParanoidWarnings = 0;
    $HeaderDoc::outerNamesOnly = 0;

    my ($cpp_hash_ref, $cpp_arg_hash_ref) = getAndClearCPPHash();

    my @commentLines = split(/\n/, $self->{COMMENT});
    map(s/$/\n/gm, @commentLines);

    # Set up some stuff for the line array code to filter the comment.
    $HeaderDoc::nodec = 0;

    HeaderDoc::APIOwner->apiUIDPrefix("test_ref");

    my $apiOwner = HeaderDoc::Header->new();
    $apiOwner->apiOwner($apiOwner);
    my $headerObject = $apiOwner;
    $HeaderDoc::headerObject = $headerObject;
    $apiOwner->filename($self->{FILENAME});
    $apiOwner->name($self->{NAME});
    $HeaderDoc::lang = $self->{LANG};
    $HeaderDoc::sublang = $self->{SUBLANG};

    %HeaderDoc::ignorePrefixes = ();
    %HeaderDoc::perHeaderIgnorePrefixes = ();
    %HeaderDoc::perHeaderIgnoreFuncMacros = ();

    # Filter the comment.
    my @commentLineArray = &getLineArrays(\@commentLines, $self->{LANG}, $self->{SUBLANG});
    my $comment = "";
    foreach my $arr (@commentLineArray) {
	foreach my $item (@$arr) {
	    my $localDebug = 0;
	    if (($self->{LANG} ne "pascal" && (
                             ($self->{LANG} ne "perl" && $self->{LANG} ne "shell" && $item =~ /^\s*\/\*\!/o) ||
                             (($self->{LANG} eq "perl" || $self->{LANG} eq "shell") && ($item =~ /^\s*\#\s*\/\*\!/o)) ||
                             (($self->{LANG} eq "java" || $HeaderDoc::parse_javadoc) && ($item =~ /^\s*\/\*\*[^\*]/o)))) ||
                            (($self->{LANG} eq "pascal") && ($item =~ s/^\s*\{!/\/\*!/so))) {
		if (($self->{LANG} ne "pascal" && ($item =~ /\s*\*\//o)) ||
                                    ($self->{LANG} eq "pascal" && ($item =~ s/\s*\}/\*\//so))) { # closing comment marker on same line
                                       print "PASCAL\n" if ($localDebug);
			if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                $item =~ s/^\s*\#//s;
                                                $item =~ s/\n( |\t)*\#/\n/sg;
                                                # print "NEWLINE: $item\n";
			}
		} else {
			$item =~ s/^ \*//o;
			if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
						    print "SHELL OR PERL\n" if ($localDebug);
                                                    $item =~ s/^\s*\#//o;
print "ITEM NOW $item\n";
                        }
		}
	    }
	    $comment .= $item; #$commentLineArray[0][0];
	}
    }


# print("COMMENT: $comment\n");


    if ($comment =~ /^\s*\/\*\*/s) {
	$comment =~ s/\s*\/\*\*/\/\*\!/s;
    }
    if ($comment =~ /^\s*\/\*!/s) {
	$comment =~ s/\*\/\s*$//s;
    }
    $comment =~ s/^\s*//s;
    # print "COM: $comment\n";

    # Try the top level comment parser code and see what we get.
    my ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug);
    if ($self->{TYPE} eq "parser") {
	($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", $comment, 0, 0, $self->{FILENAME}, 0, 0);
    } else {
	($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", "/*! CPP only */", 0, 0, $self->{FILENAME}, 0, 0);
    }

    if ($self->{TYPE} eq "parser") {
	$results .= "-=: TOP LEVEL COMMENT PARSE VALUES :=-\n";
	$results .= "inHeader: $inHeader\n";
	$results .= "inClass: $inClass\n";
	$results .= "inInterface: $inInterface\n";
	$results .= "inCPPHeader: $inCPPHeader\n";
	$results .= "inOCCHeader: $inOCCHeader\n";
	$results .= "inPerlScript: $inPerlScript\n";
	$results .= "inShellScript: $inShellScript\n";
	$results .= "inPHPScript: $inPHPScript\n";
	$results .= "inJavaSource: $inJavaSource\n";
	$results .= "inFunctionGroup: $inFunctionGroup\n";
	$results .= "inGroup: $inGroup\n";
	$results .= "inFunction: $inFunction\n";
	$results .= "inPDefine: $inPDefine\n";
	$results .= "inTypedef: $inTypedef\n";
	$results .= "inUnion: $inUnion\n";
	$results .= "inStruct: $inStruct\n";
	$results .= "inConstant: $inConstant\n";
	$results .= "inVar: $inVar\n";
	$results .= "inEnum: $inEnum\n";
	$results .= "inMethod: $inMethod\n";
	$results .= "inAvailabilityMacro: $inAvailabilityMacro\n";
	$results .= "inUnknown: $inUnknown\n";
	$results .= "classType: $classType\n";
	$results .= "inputCounter: $inputCounter\n";
	$results .= "blockOffset: $blockOffset\n";
	$results .= "filename: $filename\n";
    }

    my @perHeaderClassObjects = ();
    my @perHeaderCategoryObjects = ();
    my @fields = ();
    my $hangDebug = my $parmDebug = my $blockDebug = 0;
    my $allow_multi = 1;
    my $subparse = 0;
    my $subparseTree = undef;
    my $cppAccessControlState = "protected:"; # the default in C++
    my $objcAccessControlState = "private:"; # the default in Objective C
    my $functionGroup = "default_function_group";
    my @inputLines = split(/\n/, $self->{CODE});
    my @cppInputLines = split(/\n/, $self->{CPPCODE});
    my $preAtPart = "";
    my $xml_output = 0;

    map(s/$/\n/gm, @inputLines);
    map(s/$/\n/gm, @cppInputLines);


    my ($case_sensitive, $keywordhashref) = $headerObject->keywords();

    my $inputCounter = 0;

    # print "TYPE: $self->{TYPE}\n";
    $HeaderDoc::enable_cpp = 1;
    if ($self->{TYPE} eq "cpp") {
	$results .= "-=: CPP MACROS PARSED :=-\n";
	while ($inputCounter <= $#cppInputLines) {
		my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@cppInputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);
		$results .= "PARSED: $namelist\n";
		$inputCounter = $newcount;
	}
	$results .= "\n";
    }

    my $blockOffset = $inputCounter;
    $inputCounter = 0;
    my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@inputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);

    $results .= "-=: BLOCKPARSE PARSER STATE KEYS :=-\n";
    my @pskeys = keys %{$parserState};
    foreach my $key (@pskeys) {
	if ($key !~ /(pplStack|hollow|lastTreeNode|freezeStack|parsedParamList)/) {
		$results .= "\$parserState->{$key} => ".$parserState->{$key}."\n";
	} else {
		my $temp = $parserState->{$key};
		$temp =~ s/0x[0-9a-f]+/OBJID/sg;
		$results .= "\$parserState->{$key} => ".$temp."\n";
	}
    }
    $results .= "-=: BLOCKPARSE RETURN VALUES :=-\n";
    $results .= "newcount: $newcount\n";
    $results .= "typelist: $typelist\n";
    $results .= "namelist: $namelist\n";
    $results .= "posstypes: $posstypes\n";
    $results .= "value: $value\n";
    $results .= "returntype: $returntype\n";
    $results .= "pridec: $pridec\n";
    $results .= "simpleTDcontents: $simpleTDcontents\n";
    $results .= "bpavail: $bpavail\n";
    $results .= "blockOffset: $blockOffset\n";
    $results .= "conformsToList: $conformsToList\n";
    $results .= "functionContents: $functionContents\n";

    # Legacy declaration.
    # $results .= "declaration: $declaration\n";

    # Parsed parameters list (array)
    # $results .= "pplref: $pplref\n";
    my @parsedParamList = @{$pplref};

    $results .= "-=: LIST OF PARSED PARAMETERS :=-\n";
    my $count = 0;
    foreach my $ppl (@parsedParamList) {
	$results .= "Parsed Param $count => $ppl\n";
	$count++;
    }

    # Parse tree (data structure)
    # parseTree: $parseTree
    $results .= "-=: DUMP OF PARSE TREE :=-\n";
    $results .= $parseTree->test_output_dump();

    $results .= "-=: COMPUTED VALUE :=-\n";
    my ($success, $value) = $parseTree->getPTvalue();
    $results .= "SUCCESS: $success\n";
    $results .= "VALUE: $value\n";

    $results .= "-=: CPP CHANGES :=-\n";
    $results .= $self->cppTests();

# print "RESULTS: $results\n";

    if ($self->{TYPE} eq "parser") {
	# Only do this for parser tests.


	my $fieldref = stringToFields($comment, $filename, $inputCounter);
	@fields = @{$fieldref};

	if ($inHeader) {
		my $rootOutputDir = "/tmp/bogus";
		my $debugging = 0;
		my $reprocess_input = 0;

		processHeaderComment($apiOwner, $rootOutputDir, \@fields, $self->{LANG}, $debugging, $reprocess_input);
	}

	my ($newInputCounter, $cppAccessControlState, $classType, $classref, $catref, $blockOffset, $numcurlybraces, $foundMatch) =
            blockParseOutside($apiOwner, $inFunction, $inUnknown,
                $inTypedef, $inStruct, $inEnum, $inUnion,
                $inConstant, $inVar, $inMethod, $inPDefine,
                $inClass, $inInterface, $blockOffset, \@perHeaderCategoryObjects,
                \@perHeaderClassObjects, $classType, $cppAccessControlState,
                \@fields, $filename, $functionGroup,
                $headerObject, $inputCounter, \@inputLines,
                $self->{LANG}, $#inputLines, $preAtPart, $xml_output, $localDebug,
                $hangDebug, $parmDebug, $blockDebug, $subparse,
                $subparseTree, $HeaderDoc::nodec, $allow_multi);

	$results .= "-=: FOUND MATCH :=-\n";
	$results .= $foundMatch."\n";
	$results .= "-=: NAMED OBJECTS :=-\n";
	$results .= $self->dumpObjNames($headerObject);
    }

    # my @lines = split(

	# print "TEST RESULTS: $results\n";

    $HeaderDoc::test_mode = 0;
    $HeaderDoc::ignore_apiuid_errors = $prevignore;
    $self->{RESULT} = $results;
}
$18|/*! run tests. */
$0|$29929|-=: TOP LEVEL COMMENT PARSE VALUES :=-
inHeader: 0
inClass: 0
inInterface: 0
inCPPHeader: 0
inOCCHeader: 0
inPerlScript: 0
inShellScript: 0
inPHPScript: 0
inJavaSource: 0
inFunctionGroup: 0
inGroup: 0
inFunction: 0
inPDefine: 0
inTypedef: 0
inUnion: 0
inStruct: 0
inConstant: 0
inVar: 0
inEnum: 0
inMethod: 0
inAvailabilityMacro: 0
inUnknown: 1
classType: unknown
inputCounter: 0
blockOffset: 0
fullpath: /test_suite_bogus_path/Perl_function_3.test
-=: BLOCKPARSE PARSER STATE KEYS :=-
$parserState->{FULLPATH} => /test_suite_bogus_path/Perl_function_3.test
$parserState->{NEXTTOKENNOCPP} => 0
$parserState->{availability} => 
$parserState->{backslashcount} => 0
$parserState->{basetype} => 
$parserState->{bracePending} => 0
$parserState->{callbackIsTypedef} => 0
$parserState->{callbackName} => 
$parserState->{callbackNamePending} => -1
$parserState->{categoryClass} => 
$parserState->{classtype} => 
$parserState->{curvarstars} => *********************************
$parserState->{freezeStack} => ARRAY(OBJID)
$parserState->{freezereturn} => 1
$parserState->{frozensodname} => runTest
$parserState->{functionContents} => {
    my $self = shift;
    my $results = "";

    my $prevignore = $HeaderDoc::ignore_apiuid_errors;
    $HeaderDoc::ignore_apiuid_errors = 1;
    $HeaderDoc::test_mode = 1;
    $HeaderDoc::curParserState = undef;
    use strict;

    $HeaderDoc::dumb_as_dirt = 0;
    $HeaderDoc::parse_javadoc = 1;
    $HeaderDoc::IncludeSuper = 0;
    $HeaderDoc::ClassAsComposite = 1;
    $HeaderDoc::process_everything = 0;
    $HeaderDoc::align_columns = 0;
    $HeaderDoc::groupright = 1;
    $HeaderDoc::ignore_apiowner_names = 0;
    $HeaderDoc::add_link_requests = 1;
    $HeaderDoc::truncate_inline = 1;
    $HeaderDoc::sort_entries = 1;
    $HeaderDoc::enableParanoidWarnings = 0;
    $HeaderDoc::outerNamesOnly = 0;

    my ($cpp_hash_ref, $cpp_arg_hash_ref) = getAndClearCPPHash();

    my @commentLines = split(/\n/, $self->{COMMENT});
    map(s/$/\n/gm, @commentLines);

    # Set up some stuff for the line array code to filter the comment.
    $HeaderDoc::nodec = 0;

    HeaderDoc::APIOwner->apiUIDPrefix("test_ref");

    my $apiOwner = HeaderDoc::Header->new();
    $apiOwner->apiOwner($apiOwner);
    my $headerObject = $apiOwner;
    $HeaderDoc::headerObject = $headerObject;
    $apiOwner->filename($self->{FILENAME});
    $apiOwner->name($self->{NAME});
    $HeaderDoc::lang = $self->{LANG};
    $HeaderDoc::sublang = $self->{SUBLANG};

    %HeaderDoc::ignorePrefixes = ();
    %HeaderDoc::perHeaderIgnorePrefixes = ();
    %HeaderDoc::perHeaderIgnoreFuncMacros = ();

    # Filter the comment.
    my @commentLineArray = &getLineArrays(\@commentLines, $self->{LANG}, $self->{SUBLANG});
    my $comment = "";
    foreach my $arr (@commentLineArray) {
        foreach my $item (@$arr) {
            my $localDebug = 0;
            if (($self->{LANG} ne "pascal" && (
                             ($self->{LANG} ne "perl" && $self->{LANG} ne "shell" && $item =~ /^\s*\/\*\!/o) ||
                             (($self->{LANG} eq "perl" || $self->{LANG} eq "shell") && ($item =~ /^\s*\#\s*\/\*\!/o)) ||
                             (($self->{LANG} eq "java" || $HeaderDoc::parse_javadoc) && ($item =~ /^\s*\/\*\*[^\*]/o)))) ||
                            (($self->{LANG} eq "pascal") && ($item =~ s/^\s*\{!/\/\*!/so))) {
                if (($self->{LANG} ne "pascal" && ($item =~ /\s*\*\//o)) ||
                                    ($self->{LANG} eq "pascal" && ($item =~ s/\s*\}/\*\//so))) { # closing comment marker on same line
                                       print "PASCAL\n" if ($localDebug);
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                $item =~ s/^\s*\#//s;
                                                $item =~ s/\n( |\t)*\#/\n/sg;
                                                # print "NEWLINE: $item\n";
                        }
                } else {
                        $item =~ s/^ \*//o;
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                    print "SHELL OR PERL\n" if ($localDebug);
                                                    $item =~ s/^\s*\#//o;
print "ITEM NOW $item\n";
                        }
                }
            }
            $comment .= $item; #$commentLineArray[0][0];
        }
    }


# print("COMMENT: $comment\n");


    if ($comment =~ /^\s*\/\*\*/s) {
        $comment =~ s/\s*\/\*\*/\/\*\!/s;
    }
    if ($comment =~ /^\s*\/\*!/s) {
        $comment =~ s/\*\/\s*$//s;
    }
    $comment =~ s/^\s*//s;
    # print "COM: $comment\n";

    # Try the top level comment parser code and see what we get.
    my ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug);
    if ($self->{TYPE} eq "parser") {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", $comment, 0, 0, $self->{FILENAME}, 0, 0);
    } else {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", "/*! CPP only */", 0, 0, $self->{FILENAME}, 0, 0);
    }

    if ($self->{TYPE} eq "parser") {
        $results .= "-=: TOP LEVEL COMMENT PARSE VALUES :=-\n";
        $results .= "inHeader: $inHeader\n";
        $results .= "inClass: $inClass\n";
        $results .= "inInterface: $inInterface\n";
        $results .= "inCPPHeader: $inCPPHeader\n";
        $results .= "inOCCHeader: $inOCCHeader\n";
        $results .= "inPerlScript: $inPerlScript\n";
        $results .= "inShellScript: $inShellScript\n";
        $results .= "inPHPScript: $inPHPScript\n";
        $results .= "inJavaSource: $inJavaSource\n";
        $results .= "inFunctionGroup: $inFunctionGroup\n";
        $results .= "inGroup: $inGroup\n";
        $results .= "inFunction: $inFunction\n";
        $results .= "inPDefine: $inPDefine\n";
        $results .= "inTypedef: $inTypedef\n";
        $results .= "inUnion: $inUnion\n";
        $results .= "inStruct: $inStruct\n";
        $results .= "inConstant: $inConstant\n";
        $results .= "inVar: $inVar\n";
        $results .= "inEnum: $inEnum\n";
        $results .= "inMethod: $inMethod\n";
        $results .= "inAvailabilityMacro: $inAvailabilityMacro\n";
        $results .= "inUnknown: $inUnknown\n";
        $results .= "classType: $classType\n";
        $results .= "inputCounter: $inputCounter\n";
        $results .= "blockOffset: $blockOffset\n";
        $results .= "filename: $filename\n";
    }

    my @perHeaderClassObjects = ();
    my @perHeaderCategoryObjects = ();
    my @fields = ();
    my $hangDebug = my $parmDebug = my $blockDebug = 0;
    my $allow_multi = 1;
    my $subparse = 0;
    my $subparseTree = undef;
    my $cppAccessControlState = "protected:"; # the default in C++
    my $objcAccessControlState = "private:"; # the default in Objective C
    my $functionGroup = "default_function_group";
    my @inputLines = split(/\n/, $self->{CODE});
    my @cppInputLines = split(/\n/, $self->{CPPCODE});
    my $preAtPart = "";
    my $xml_output = 0;

    map(s/$/\n/gm, @inputLines);
    map(s/$/\n/gm, @cppInputLines);


    my ($case_sensitive, $keywordhashref) = $headerObject->keywords();

    my $inputCounter = 0;

    # print "TYPE: $self->{TYPE}\n";
    $HeaderDoc::enable_cpp = 1;
    if ($self->{TYPE} eq "cpp") {
        $results .= "-=: CPP MACROS PARSED :=-\n";
        while ($inputCounter <= $#cppInputLines) {
                my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@cppInputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);
                $results .= "PARSED: $namelist\n";
                $inputCounter = $newcount;
        }
        $results .= "\n";
    }

    my $blockOffset = $inputCounter;
    $inputCounter = 0;
    my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@inputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);

    $results .= "-=: BLOCKPARSE PARSER STATE KEYS :=-\n";
    my @pskeys = keys %{$parserState};
    foreach my $key (@pskeys) {
        if ($key !~ /(pplStack|hollow|lastTreeNode|freezeStack|parsedParamList)/) {
                $results .= "\$parserState->{$key} => ".$parserState->{$key}."\n";
        } else {
                my $temp = $parserState->{$key};
                $temp =~ s/0x[0-9a-f]+/OBJID/sg;
                $results .= "\$parserState->{$key} => ".$temp."\n";
        }
    }
    $results .= "-=: BLOCKPARSE RETURN VALUES :=-\n";
    $results .= "newcount: $newcount\n";
    $results .= "typelist: $typelist\n";
    $results .= "namelist: $namelist\n";
    $results .= "posstypes: $posstypes\n";
    $results .= "value: $value\n";
    $results .= "returntype: $returntype\n";
    $results .= "pridec: $pridec\n";
    $results .= "simpleTDcontents: $simpleTDcontents\n";
    $results .= "bpavail: $bpavail\n";
    $results .= "blockOffset: $blockOffset\n";
    $results .= "conformsToList: $conformsToList\n";
    $results .= "functionContents: $functionContents\n";

    # Legacy declaration.
    # $results .= "declaration: $declaration\n";

    # Parsed parameters list (array)
    # $results .= "pplref: $pplref\n";
    my @parsedParamList = @{$pplref};

    $results .= "-=: LIST OF PARSED PARAMETERS :=-\n";
    my $count = 0;
    foreach my $ppl (@parsedParamList) {
        $results .= "Parsed Param $count => $ppl\n";
        $count++;
    }

    # Parse tree (data structure)
    # parseTree: $parseTree
    $results .= "-=: DUMP OF PARSE TREE :=-\n";
    $results .= $parseTree->test_output_dump();

    $results .= "-=: COMPUTED VALUE :=-\n";
    my ($success, $value) = $parseTree->getPTvalue();
    $results .= "SUCCESS: $success\n";
    $results .= "VALUE: $value\n";

    $results .= "-=: CPP CHANGES :=-\n";
    $results .= $self->cppTests();

# print "RESULTS: $results\n";

    if ($self->{TYPE} eq "parser") {
        # Only do this for parser tests.


        my $fieldref = stringToFields($comment, $filename, $inputCounter);
        @fields = @{$fieldref};

        if ($inHeader) {
                my $rootOutputDir = "/tmp/bogus";
                my $debugging = 0;
                my $reprocess_input = 0;

                processHeaderComment($apiOwner, $rootOutputDir, \@fields, $self->{LANG}, $debugging, $reprocess_input);
        }

        my ($newInputCounter, $cppAccessControlState, $classType, $classref, $catref, $blockOffset, $numcurlybraces, $foundMatch) =
            blockParseOutside($apiOwner, $inFunction, $inUnknown,
                $inTypedef, $inStruct, $inEnum, $inUnion,
                $inConstant, $inVar, $inMethod, $inPDefine,
                $inClass, $inInterface, $blockOffset, \@perHeaderCategoryObjects,
                \@perHeaderClassObjects, $classType, $cppAccessControlState,
                \@fields, $filename, $functionGroup,
                $headerObject, $inputCounter, \@inputLines,
                $self->{LANG}, $#inputLines, $preAtPart, $xml_output, $localDebug,
                $hangDebug, $parmDebug, $blockDebug, $subparse,
                $subparseTree, $HeaderDoc::nodec, $allow_multi);

        $results .= "-=: FOUND MATCH :=-\n";
        $results .= $foundMatch."\n";
        $results .= "-=: NAMED OBJECTS :=-\n";
        $results .= $self->dumpObjNames($headerObject);
    }

    # my @lines = split(

        # print "TEST RESULTS: $results\n";

    $HeaderDoc::test_mode = 0;
    $HeaderDoc::ignore_apiuid_errors = $prevignore;
    $self->{RESULT} = $results;
}

$parserState->{functionReturnsCallback} => 0
$parserState->{hollow} => HeaderDoc::ParseTree=HASH(OBJID)
$parserState->{inBrackets} => 0
$parserState->{inChar} => 0
$parserState->{inClass} => 0
$parserState->{inComment} => 0
$parserState->{inInlineComment} => 0
$parserState->{inMacro} => 0
$parserState->{inMacroLine} => 0
$parserState->{inOperator} => 0
$parserState->{inPrivateParamTypes} => 0
$parserState->{inString} => 0
$parserState->{inTemplate} => 0
$parserState->{initbsCount} => 0
$parserState->{inputCounter} => 264
$parserState->{kr_c_function} => 0
$parserState->{kr_c_name} => 
$parserState->{lang} => perl
$parserState->{lastTreeNode} => HeaderDoc::ParseTree=HASH(OBJID)
$parserState->{lastsymbol} => 
$parserState->{macroNoTrunc} => 1
$parserState->{name} => runTest
$parserState->{namePending} => 0
$parserState->{noInsert} => 0
$parserState->{occmethod} => 0
$parserState->{occmethodname} => 
$parserState->{occparmlabelfound} => 2
$parserState->{onlyComments} => 0
$parserState->{parsedParamAtBrace} => ARRAY(OBJID)
$parserState->{parsedParamList} => ARRAY(OBJID)
$parserState->{parsedParamParse} => 0
$parserState->{parsedParamStateAtBrace} => ARRAY(OBJID)
$parserState->{posstypes} => 
$parserState->{posstypesPending} => 0
$parserState->{pplStack} => ARRAY(OBJID)
$parserState->{preEqualsSymbol} => 
$parserState->{preTemplateSymbol} => 
$parserState->{prekeywordsodname} => 
$parserState->{prekeywordsodtype} => 
$parserState->{returntype} => sub runTest
$parserState->{seenBraces} => 1
$parserState->{seenMacroPart} => 0
$parserState->{seenTilde} => 0
$parserState->{simpleTDcontents} => 
$parserState->{simpleTypedef} => 0
$parserState->{sodclass} => function
$parserState->{sodname} => runTest
$parserState->{sodtype} => 
$parserState->{stackFrozen} => 1
$parserState->{startOfDec} => 0
$parserState->{sublang} => perl
$parserState->{temponlyComments} => 0
$parserState->{typestring} => function
$parserState->{value} => 
$parserState->{valuepending} => 0
-=: BLOCKPARSE RETURN VALUES :=-
newcount: 264
typelist: function
namelist: runTest
posstypes: function method
value: 
returntype: 
pridec: 
simpleTDcontents: 
bpavail: 
blockOffset: 0
conformsToList: 
functionContents: {
    my $self = shift;
    my $results = "";

    my $prevignore = $HeaderDoc::ignore_apiuid_errors;
    $HeaderDoc::ignore_apiuid_errors = 1;
    $HeaderDoc::test_mode = 1;
    $HeaderDoc::curParserState = undef;
    use strict;

    $HeaderDoc::dumb_as_dirt = 0;
    $HeaderDoc::parse_javadoc = 1;
    $HeaderDoc::IncludeSuper = 0;
    $HeaderDoc::ClassAsComposite = 1;
    $HeaderDoc::process_everything = 0;
    $HeaderDoc::align_columns = 0;
    $HeaderDoc::groupright = 1;
    $HeaderDoc::ignore_apiowner_names = 0;
    $HeaderDoc::add_link_requests = 1;
    $HeaderDoc::truncate_inline = 1;
    $HeaderDoc::sort_entries = 1;
    $HeaderDoc::enableParanoidWarnings = 0;
    $HeaderDoc::outerNamesOnly = 0;

    my ($cpp_hash_ref, $cpp_arg_hash_ref) = getAndClearCPPHash();

    my @commentLines = split(/\n/, $self->{COMMENT});
    map(s/$/\n/gm, @commentLines);

    # Set up some stuff for the line array code to filter the comment.
    $HeaderDoc::nodec = 0;

    HeaderDoc::APIOwner->apiUIDPrefix("test_ref");

    my $apiOwner = HeaderDoc::Header->new();
    $apiOwner->apiOwner($apiOwner);
    my $headerObject = $apiOwner;
    $HeaderDoc::headerObject = $headerObject;
    $apiOwner->filename($self->{FILENAME});
    $apiOwner->name($self->{NAME});
    $HeaderDoc::lang = $self->{LANG};
    $HeaderDoc::sublang = $self->{SUBLANG};

    %HeaderDoc::ignorePrefixes = ();
    %HeaderDoc::perHeaderIgnorePrefixes = ();
    %HeaderDoc::perHeaderIgnoreFuncMacros = ();

    # Filter the comment.
    my @commentLineArray = &getLineArrays(\@commentLines, $self->{LANG}, $self->{SUBLANG});
    my $comment = "";
    foreach my $arr (@commentLineArray) {
        foreach my $item (@$arr) {
            my $localDebug = 0;
            if (($self->{LANG} ne "pascal" && (
                             ($self->{LANG} ne "perl" && $self->{LANG} ne "shell" && $item =~ /^\s*\/\*\!/o) ||
                             (($self->{LANG} eq "perl" || $self->{LANG} eq "shell") && ($item =~ /^\s*\#\s*\/\*\!/o)) ||
                             (($self->{LANG} eq "java" || $HeaderDoc::parse_javadoc) && ($item =~ /^\s*\/\*\*[^\*]/o)))) ||
                            (($self->{LANG} eq "pascal") && ($item =~ s/^\s*\{!/\/\*!/so))) {
                if (($self->{LANG} ne "pascal" && ($item =~ /\s*\*\//o)) ||
                                    ($self->{LANG} eq "pascal" && ($item =~ s/\s*\}/\*\//so))) { # closing comment marker on same line
                                       print "PASCAL\n" if ($localDebug);
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                $item =~ s/^\s*\#//s;
                                                $item =~ s/\n( |\t)*\#/\n/sg;
                                                # print "NEWLINE: $item\n";
                        }
                } else {
                        $item =~ s/^ \*//o;
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                    print "SHELL OR PERL\n" if ($localDebug);
                                                    $item =~ s/^\s*\#//o;
print "ITEM NOW $item\n";
                        }
                }
            }
            $comment .= $item; #$commentLineArray[0][0];
        }
    }


# print("COMMENT: $comment\n");


    if ($comment =~ /^\s*\/\*\*/s) {
        $comment =~ s/\s*\/\*\*/\/\*\!/s;
    }
    if ($comment =~ /^\s*\/\*!/s) {
        $comment =~ s/\*\/\s*$//s;
    }
    $comment =~ s/^\s*//s;
    # print "COM: $comment\n";

    # Try the top level comment parser code and see what we get.
    my ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug);
    if ($self->{TYPE} eq "parser") {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", $comment, 0, 0, $self->{FILENAME}, 0, 0);
    } else {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", "/*! CPP only */", 0, 0, $self->{FILENAME}, 0, 0);
    }

    if ($self->{TYPE} eq "parser") {
        $results .= "-=: TOP LEVEL COMMENT PARSE VALUES :=-\n";
        $results .= "inHeader: $inHeader\n";
        $results .= "inClass: $inClass\n";
        $results .= "inInterface: $inInterface\n";
        $results .= "inCPPHeader: $inCPPHeader\n";
        $results .= "inOCCHeader: $inOCCHeader\n";
        $results .= "inPerlScript: $inPerlScript\n";
        $results .= "inShellScript: $inShellScript\n";
        $results .= "inPHPScript: $inPHPScript\n";
        $results .= "inJavaSource: $inJavaSource\n";
        $results .= "inFunctionGroup: $inFunctionGroup\n";
        $results .= "inGroup: $inGroup\n";
        $results .= "inFunction: $inFunction\n";
        $results .= "inPDefine: $inPDefine\n";
        $results .= "inTypedef: $inTypedef\n";
        $results .= "inUnion: $inUnion\n";
        $results .= "inStruct: $inStruct\n";
        $results .= "inConstant: $inConstant\n";
        $results .= "inVar: $inVar\n";
        $results .= "inEnum: $inEnum\n";
        $results .= "inMethod: $inMethod\n";
        $results .= "inAvailabilityMacro: $inAvailabilityMacro\n";
        $results .= "inUnknown: $inUnknown\n";
        $results .= "classType: $classType\n";
        $results .= "inputCounter: $inputCounter\n";
        $results .= "blockOffset: $blockOffset\n";
        $results .= "filename: $filename\n";
    }

    my @perHeaderClassObjects = ();
    my @perHeaderCategoryObjects = ();
    my @fields = ();
    my $hangDebug = my $parmDebug = my $blockDebug = 0;
    my $allow_multi = 1;
    my $subparse = 0;
    my $subparseTree = undef;
    my $cppAccessControlState = "protected:"; # the default in C++
    my $objcAccessControlState = "private:"; # the default in Objective C
    my $functionGroup = "default_function_group";
    my @inputLines = split(/\n/, $self->{CODE});
    my @cppInputLines = split(/\n/, $self->{CPPCODE});
    my $preAtPart = "";
    my $xml_output = 0;

    map(s/$/\n/gm, @inputLines);
    map(s/$/\n/gm, @cppInputLines);


    my ($case_sensitive, $keywordhashref) = $headerObject->keywords();

    my $inputCounter = 0;

    # print "TYPE: $self->{TYPE}\n";
    $HeaderDoc::enable_cpp = 1;
    if ($self->{TYPE} eq "cpp") {
        $results .= "-=: CPP MACROS PARSED :=-\n";
        while ($inputCounter <= $#cppInputLines) {
                my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@cppInputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);
                $results .= "PARSED: $namelist\n";
                $inputCounter = $newcount;
        }
        $results .= "\n";
    }

    my $blockOffset = $inputCounter;
    $inputCounter = 0;
    my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@inputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);

    $results .= "-=: BLOCKPARSE PARSER STATE KEYS :=-\n";
    my @pskeys = keys %{$parserState};
    foreach my $key (@pskeys) {
        if ($key !~ /(pplStack|hollow|lastTreeNode|freezeStack|parsedParamList)/) {
                $results .= "\$parserState->{$key} => ".$parserState->{$key}."\n";
        } else {
                my $temp = $parserState->{$key};
                $temp =~ s/0x[0-9a-f]+/OBJID/sg;
                $results .= "\$parserState->{$key} => ".$temp."\n";
        }
    }
    $results .= "-=: BLOCKPARSE RETURN VALUES :=-\n";
    $results .= "newcount: $newcount\n";
    $results .= "typelist: $typelist\n";
    $results .= "namelist: $namelist\n";
    $results .= "posstypes: $posstypes\n";
    $results .= "value: $value\n";
    $results .= "returntype: $returntype\n";
    $results .= "pridec: $pridec\n";
    $results .= "simpleTDcontents: $simpleTDcontents\n";
    $results .= "bpavail: $bpavail\n";
    $results .= "blockOffset: $blockOffset\n";
    $results .= "conformsToList: $conformsToList\n";
    $results .= "functionContents: $functionContents\n";

    # Legacy declaration.
    # $results .= "declaration: $declaration\n";

    # Parsed parameters list (array)
    # $results .= "pplref: $pplref\n";
    my @parsedParamList = @{$pplref};

    $results .= "-=: LIST OF PARSED PARAMETERS :=-\n";
    my $count = 0;
    foreach my $ppl (@parsedParamList) {
        $results .= "Parsed Param $count => $ppl\n";
        $count++;
    }

    # Parse tree (data structure)
    # parseTree: $parseTree
    $results .= "-=: DUMP OF PARSE TREE :=-\n";
    $results .= $parseTree->test_output_dump();

    $results .= "-=: COMPUTED VALUE :=-\n";
    my ($success, $value) = $parseTree->getPTvalue();
    $results .= "SUCCESS: $success\n";
    $results .= "VALUE: $value\n";

    $results .= "-=: CPP CHANGES :=-\n";
    $results .= $self->cppTests();

# print "RESULTS: $results\n";

    if ($self->{TYPE} eq "parser") {
        # Only do this for parser tests.


        my $fieldref = stringToFields($comment, $filename, $inputCounter);
        @fields = @{$fieldref};

        if ($inHeader) {
                my $rootOutputDir = "/tmp/bogus";
                my $debugging = 0;
                my $reprocess_input = 0;

                processHeaderComment($apiOwner, $rootOutputDir, \@fields, $self->{LANG}, $debugging, $reprocess_input);
        }

        my ($newInputCounter, $cppAccessControlState, $classType, $classref, $catref, $blockOffset, $numcurlybraces, $foundMatch) =
            blockParseOutside($apiOwner, $inFunction, $inUnknown,
                $inTypedef, $inStruct, $inEnum, $inUnion,
                $inConstant, $inVar, $inMethod, $inPDefine,
                $inClass, $inInterface, $blockOffset, \@perHeaderCategoryObjects,
                \@perHeaderClassObjects, $classType, $cppAccessControlState,
                \@fields, $filename, $functionGroup,
                $headerObject, $inputCounter, \@inputLines,
                $self->{LANG}, $#inputLines, $preAtPart, $xml_output, $localDebug,
                $hangDebug, $parmDebug, $blockDebug, $subparse,
                $subparseTree, $HeaderDoc::nodec, $allow_multi);

        $results .= "-=: FOUND MATCH :=-\n";
        $results .= $foundMatch."\n";
        $results .= "-=: NAMED OBJECTS :=-\n";
        $results .= $self->dumpObjNames($headerObject);
    }

    # my @lines = split(

        # print "TEST RESULTS: $results\n";

    $HeaderDoc::test_mode = 0;
    $HeaderDoc::ignore_apiuid_errors = $prevignore;
    $self->{RESULT} = $results;
}

extendsClass: 
implementsClass: 
-=: LIST OF PARSED PARAMETERS :=-
-=: DUMP OF PARSE TREE :=-
+---sub
+--- 
+---runTest
+--- 
-=: COMPUTED VALUE :=-
SUCCESS: 0
VALUE: 0
-=: CPP CHANGES :=-
NO CPP CHANGES
-=: FOUND MATCH :=-
1
-=: NAMED OBJECTS :=-
TREE COUNT: 0
INDEX GROUP: 
IS BLOCK: 
OBJECT TYPE: HeaderDoc::Header
NAME: Perl function 3
APIUID: //test_ref/doc/header/Perl_function_3.test
ABSTRACT: ""
DISCUSSION: "<p></p>"
UPDATED: ""
COPYRIGHT: ""
HTMLMETA: ""
PRIVATEDECLARATION: ""
GROUP: ""
INDEXGROUP: ""
THROWS: ""
XMLTHROWS: ""
UPDATED: ""
LINKAGESTATE: ""
ACCESSCONTROL: ""
AVAILABILITY: ""
LINKUID: ""
ORIGCLASS: ""
ISDEFINE: ""
ISTEMPLATE: ""
VALUE: "UNKNOWN"
RETURNTYPE: ""
LINENUM: ""
CLASS: "HeaderDoc::Header"
MASTERENUM: ""
APIREFSETUPDONE: "1"
TPCDONE: ""
NOREGISTERUID: ""
SUPPRESSCHILDREN: ""
NAMELINE_DISCUSSION: ""
HIDEDOC: ""
HIDESINGLETONS: ""
HIDECONTENTS: ""
MAINOBJECT: ""
LIST ATTRIBUTES: 
SHORT ATTRIBUTES: 
LONG ATTRIBUTES: 
    TREE COUNT: 1
    INDEX GROUP: 
    IS BLOCK: 
    OBJECT TYPE: HeaderDoc::Function
    NAME: runTest
    APIUID: //test_ref/perl/func/runTest
    ABSTRACT: ""
    DISCUSSION: "<p>run tests. "
    UPDATED: ""
    COPYRIGHT: ""
    HTMLMETA: ""
    PRIVATEDECLARATION: ""
    GROUP: "default_function_group"
    INDEXGROUP: ""
    THROWS: ""
    XMLTHROWS: ""
    UPDATED: ""
    LINKAGESTATE: ""
    ACCESSCONTROL: ""
    AVAILABILITY: ""
    LINKUID: ""
    ORIGCLASS: ""
    ISDEFINE: ""
    ISTEMPLATE: ""
    VALUE: "UNKNOWN"
    RETURNTYPE: ""
    LINENUM: ""
    CLASS: "HeaderDoc::Function"
    MASTERENUM: ""
    APIREFSETUPDONE: "1"
    TPCDONE: ""
    NOREGISTERUID: ""
    SUPPRESSCHILDREN: "0"
    NAMELINE_DISCUSSION: ""
    HIDEDOC: ""
    HIDESINGLETONS: ""
    HIDECONTENTS: ""
    MAINOBJECT: ""
    LIST ATTRIBUTES: 
    SHORT ATTRIBUTES: 
    LONG ATTRIBUTES: 
-=: NAMED OBJECT PARSE TREES :=-
OBJECT: runTest (HeaderDoc::Function)
+---sub
+--- 
+---runTest
+--- 
END OF OBJECT



-=: HTML OUTPUT OF PARSE TREES :=-
OBJECT: runTest (HeaderDoc::Function)
	<span class="keyword">sub</span> <!-- a logicalPath="//test_ref/perl/instm/runTest //test_ref/perl/clm/runTest //test_ref/perl/intfcm/runTest //test_ref/perl/intfm/runTest //test_ref/perl/func/runTest //test_ref/perl/ftmplt/runTest //test_ref/perl/defn/runTest //test_ref/perl/macro/runTest //test_ref/doc/anysymbol/runTest" machineGenerated="true" --><span class="function">runTest</span><!-- /a --> 
END OF OBJECT



$29929|-=: TOP LEVEL COMMENT PARSE VALUES :=-
inHeader: 0
inClass: 0
inInterface: 0
inCPPHeader: 0
inOCCHeader: 0
inPerlScript: 0
inShellScript: 0
inPHPScript: 0
inJavaSource: 0
inFunctionGroup: 0
inGroup: 0
inFunction: 0
inPDefine: 0
inTypedef: 0
inUnion: 0
inStruct: 0
inConstant: 0
inVar: 0
inEnum: 0
inMethod: 0
inAvailabilityMacro: 0
inUnknown: 1
classType: unknown
inputCounter: 0
blockOffset: 0
fullpath: /test_suite_bogus_path/Perl_function_3.test
-=: BLOCKPARSE PARSER STATE KEYS :=-
$parserState->{FULLPATH} => /test_suite_bogus_path/Perl_function_3.test
$parserState->{NEXTTOKENNOCPP} => 0
$parserState->{availability} => 
$parserState->{backslashcount} => 0
$parserState->{basetype} => 
$parserState->{bracePending} => 0
$parserState->{callbackIsTypedef} => 0
$parserState->{callbackName} => 
$parserState->{callbackNamePending} => -1
$parserState->{categoryClass} => 
$parserState->{classtype} => 
$parserState->{curvarstars} => *********************************
$parserState->{freezeStack} => ARRAY(OBJID)
$parserState->{freezereturn} => 1
$parserState->{frozensodname} => runTest
$parserState->{functionContents} => {
    my $self = shift;
    my $results = "";

    my $prevignore = $HeaderDoc::ignore_apiuid_errors;
    $HeaderDoc::ignore_apiuid_errors = 1;
    $HeaderDoc::test_mode = 1;
    $HeaderDoc::curParserState = undef;
    use strict;

    $HeaderDoc::dumb_as_dirt = 0;
    $HeaderDoc::parse_javadoc = 1;
    $HeaderDoc::IncludeSuper = 0;
    $HeaderDoc::ClassAsComposite = 1;
    $HeaderDoc::process_everything = 0;
    $HeaderDoc::align_columns = 0;
    $HeaderDoc::groupright = 1;
    $HeaderDoc::ignore_apiowner_names = 0;
    $HeaderDoc::add_link_requests = 1;
    $HeaderDoc::truncate_inline = 1;
    $HeaderDoc::sort_entries = 1;
    $HeaderDoc::enableParanoidWarnings = 0;
    $HeaderDoc::outerNamesOnly = 0;

    my ($cpp_hash_ref, $cpp_arg_hash_ref) = getAndClearCPPHash();

    my @commentLines = split(/\n/, $self->{COMMENT});
    map(s/$/\n/gm, @commentLines);

    # Set up some stuff for the line array code to filter the comment.
    $HeaderDoc::nodec = 0;

    HeaderDoc::APIOwner->apiUIDPrefix("test_ref");

    my $apiOwner = HeaderDoc::Header->new();
    $apiOwner->apiOwner($apiOwner);
    my $headerObject = $apiOwner;
    $HeaderDoc::headerObject = $headerObject;
    $apiOwner->filename($self->{FILENAME});
    $apiOwner->name($self->{NAME});
    $HeaderDoc::lang = $self->{LANG};
    $HeaderDoc::sublang = $self->{SUBLANG};

    %HeaderDoc::ignorePrefixes = ();
    %HeaderDoc::perHeaderIgnorePrefixes = ();
    %HeaderDoc::perHeaderIgnoreFuncMacros = ();

    # Filter the comment.
    my @commentLineArray = &getLineArrays(\@commentLines, $self->{LANG}, $self->{SUBLANG});
    my $comment = "";
    foreach my $arr (@commentLineArray) {
        foreach my $item (@$arr) {
            my $localDebug = 0;
            if (($self->{LANG} ne "pascal" && (
                             ($self->{LANG} ne "perl" && $self->{LANG} ne "shell" && $item =~ /^\s*\/\*\!/o) ||
                             (($self->{LANG} eq "perl" || $self->{LANG} eq "shell") && ($item =~ /^\s*\#\s*\/\*\!/o)) ||
                             (($self->{LANG} eq "java" || $HeaderDoc::parse_javadoc) && ($item =~ /^\s*\/\*\*[^\*]/o)))) ||
                            (($self->{LANG} eq "pascal") && ($item =~ s/^\s*\{!/\/\*!/so))) {
                if (($self->{LANG} ne "pascal" && ($item =~ /\s*\*\//o)) ||
                                    ($self->{LANG} eq "pascal" && ($item =~ s/\s*\}/\*\//so))) { # closing comment marker on same line
                                       print "PASCAL\n" if ($localDebug);
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                $item =~ s/^\s*\#//s;
                                                $item =~ s/\n( |\t)*\#/\n/sg;
                                                # print "NEWLINE: $item\n";
                        }
                } else {
                        $item =~ s/^ \*//o;
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                    print "SHELL OR PERL\n" if ($localDebug);
                                                    $item =~ s/^\s*\#//o;
print "ITEM NOW $item\n";
                        }
                }
            }
            $comment .= $item; #$commentLineArray[0][0];
        }
    }


# print("COMMENT: $comment\n");


    if ($comment =~ /^\s*\/\*\*/s) {
        $comment =~ s/\s*\/\*\*/\/\*\!/s;
    }
    if ($comment =~ /^\s*\/\*!/s) {
        $comment =~ s/\*\/\s*$//s;
    }
    $comment =~ s/^\s*//s;
    # print "COM: $comment\n";

    # Try the top level comment parser code and see what we get.
    my ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug);
    if ($self->{TYPE} eq "parser") {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", $comment, 0, 0, $self->{FILENAME}, 0, 0);
    } else {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", "/*! CPP only */", 0, 0, $self->{FILENAME}, 0, 0);
    }

    if ($self->{TYPE} eq "parser") {
        $results .= "-=: TOP LEVEL COMMENT PARSE VALUES :=-\n";
        $results .= "inHeader: $inHeader\n";
        $results .= "inClass: $inClass\n";
        $results .= "inInterface: $inInterface\n";
        $results .= "inCPPHeader: $inCPPHeader\n";
        $results .= "inOCCHeader: $inOCCHeader\n";
        $results .= "inPerlScript: $inPerlScript\n";
        $results .= "inShellScript: $inShellScript\n";
        $results .= "inPHPScript: $inPHPScript\n";
        $results .= "inJavaSource: $inJavaSource\n";
        $results .= "inFunctionGroup: $inFunctionGroup\n";
        $results .= "inGroup: $inGroup\n";
        $results .= "inFunction: $inFunction\n";
        $results .= "inPDefine: $inPDefine\n";
        $results .= "inTypedef: $inTypedef\n";
        $results .= "inUnion: $inUnion\n";
        $results .= "inStruct: $inStruct\n";
        $results .= "inConstant: $inConstant\n";
        $results .= "inVar: $inVar\n";
        $results .= "inEnum: $inEnum\n";
        $results .= "inMethod: $inMethod\n";
        $results .= "inAvailabilityMacro: $inAvailabilityMacro\n";
        $results .= "inUnknown: $inUnknown\n";
        $results .= "classType: $classType\n";
        $results .= "inputCounter: $inputCounter\n";
        $results .= "blockOffset: $blockOffset\n";
        $results .= "filename: $filename\n";
    }

    my @perHeaderClassObjects = ();
    my @perHeaderCategoryObjects = ();
    my @fields = ();
    my $hangDebug = my $parmDebug = my $blockDebug = 0;
    my $allow_multi = 1;
    my $subparse = 0;
    my $subparseTree = undef;
    my $cppAccessControlState = "protected:"; # the default in C++
    my $objcAccessControlState = "private:"; # the default in Objective C
    my $functionGroup = "default_function_group";
    my @inputLines = split(/\n/, $self->{CODE});
    my @cppInputLines = split(/\n/, $self->{CPPCODE});
    my $preAtPart = "";
    my $xml_output = 0;

    map(s/$/\n/gm, @inputLines);
    map(s/$/\n/gm, @cppInputLines);


    my ($case_sensitive, $keywordhashref) = $headerObject->keywords();

    my $inputCounter = 0;

    # print "TYPE: $self->{TYPE}\n";
    $HeaderDoc::enable_cpp = 1;
    if ($self->{TYPE} eq "cpp") {
        $results .= "-=: CPP MACROS PARSED :=-\n";
        while ($inputCounter <= $#cppInputLines) {
                my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@cppInputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);
                $results .= "PARSED: $namelist\n";
                $inputCounter = $newcount;
        }
        $results .= "\n";
    }

    my $blockOffset = $inputCounter;
    $inputCounter = 0;
    my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@inputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);

    $results .= "-=: BLOCKPARSE PARSER STATE KEYS :=-\n";
    my @pskeys = keys %{$parserState};
    foreach my $key (@pskeys) {
        if ($key !~ /(pplStack|hollow|lastTreeNode|freezeStack|parsedParamList)/) {
                $results .= "\$parserState->{$key} => ".$parserState->{$key}."\n";
        } else {
                my $temp = $parserState->{$key};
                $temp =~ s/0x[0-9a-f]+/OBJID/sg;
                $results .= "\$parserState->{$key} => ".$temp."\n";
        }
    }
    $results .= "-=: BLOCKPARSE RETURN VALUES :=-\n";
    $results .= "newcount: $newcount\n";
    $results .= "typelist: $typelist\n";
    $results .= "namelist: $namelist\n";
    $results .= "posstypes: $posstypes\n";
    $results .= "value: $value\n";
    $results .= "returntype: $returntype\n";
    $results .= "pridec: $pridec\n";
    $results .= "simpleTDcontents: $simpleTDcontents\n";
    $results .= "bpavail: $bpavail\n";
    $results .= "blockOffset: $blockOffset\n";
    $results .= "conformsToList: $conformsToList\n";
    $results .= "functionContents: $functionContents\n";

    # Legacy declaration.
    # $results .= "declaration: $declaration\n";

    # Parsed parameters list (array)
    # $results .= "pplref: $pplref\n";
    my @parsedParamList = @{$pplref};

    $results .= "-=: LIST OF PARSED PARAMETERS :=-\n";
    my $count = 0;
    foreach my $ppl (@parsedParamList) {
        $results .= "Parsed Param $count => $ppl\n";
        $count++;
    }

    # Parse tree (data structure)
    # parseTree: $parseTree
    $results .= "-=: DUMP OF PARSE TREE :=-\n";
    $results .= $parseTree->test_output_dump();

    $results .= "-=: COMPUTED VALUE :=-\n";
    my ($success, $value) = $parseTree->getPTvalue();
    $results .= "SUCCESS: $success\n";
    $results .= "VALUE: $value\n";

    $results .= "-=: CPP CHANGES :=-\n";
    $results .= $self->cppTests();

# print "RESULTS: $results\n";

    if ($self->{TYPE} eq "parser") {
        # Only do this for parser tests.


        my $fieldref = stringToFields($comment, $filename, $inputCounter);
        @fields = @{$fieldref};

        if ($inHeader) {
                my $rootOutputDir = "/tmp/bogus";
                my $debugging = 0;
                my $reprocess_input = 0;

                processHeaderComment($apiOwner, $rootOutputDir, \@fields, $self->{LANG}, $debugging, $reprocess_input);
        }

        my ($newInputCounter, $cppAccessControlState, $classType, $classref, $catref, $blockOffset, $numcurlybraces, $foundMatch) =
            blockParseOutside($apiOwner, $inFunction, $inUnknown,
                $inTypedef, $inStruct, $inEnum, $inUnion,
                $inConstant, $inVar, $inMethod, $inPDefine,
                $inClass, $inInterface, $blockOffset, \@perHeaderCategoryObjects,
                \@perHeaderClassObjects, $classType, $cppAccessControlState,
                \@fields, $filename, $functionGroup,
                $headerObject, $inputCounter, \@inputLines,
                $self->{LANG}, $#inputLines, $preAtPart, $xml_output, $localDebug,
                $hangDebug, $parmDebug, $blockDebug, $subparse,
                $subparseTree, $HeaderDoc::nodec, $allow_multi);

        $results .= "-=: FOUND MATCH :=-\n";
        $results .= $foundMatch."\n";
        $results .= "-=: NAMED OBJECTS :=-\n";
        $results .= $self->dumpObjNames($headerObject);
    }

    # my @lines = split(

        # print "TEST RESULTS: $results\n";

    $HeaderDoc::test_mode = 0;
    $HeaderDoc::ignore_apiuid_errors = $prevignore;
    $self->{RESULT} = $results;
}

$parserState->{functionReturnsCallback} => 0
$parserState->{hollow} => HeaderDoc::ParseTree=HASH(OBJID)
$parserState->{inBrackets} => 0
$parserState->{inChar} => 0
$parserState->{inClass} => 0
$parserState->{inComment} => 0
$parserState->{inInlineComment} => 0
$parserState->{inMacro} => 0
$parserState->{inMacroLine} => 0
$parserState->{inOperator} => 0
$parserState->{inPrivateParamTypes} => 0
$parserState->{inString} => 0
$parserState->{inTemplate} => 0
$parserState->{initbsCount} => 0
$parserState->{inputCounter} => 264
$parserState->{kr_c_function} => 0
$parserState->{kr_c_name} => 
$parserState->{lang} => perl
$parserState->{lastTreeNode} => HeaderDoc::ParseTree=HASH(OBJID)
$parserState->{lastsymbol} => 
$parserState->{macroNoTrunc} => 1
$parserState->{name} => runTest
$parserState->{namePending} => 0
$parserState->{noInsert} => 0
$parserState->{occmethod} => 0
$parserState->{occmethodname} => 
$parserState->{occparmlabelfound} => 2
$parserState->{onlyComments} => 0
$parserState->{parsedParamAtBrace} => ARRAY(OBJID)
$parserState->{parsedParamList} => ARRAY(OBJID)
$parserState->{parsedParamParse} => 0
$parserState->{parsedParamStateAtBrace} => ARRAY(OBJID)
$parserState->{posstypes} => 
$parserState->{posstypesPending} => 0
$parserState->{pplStack} => ARRAY(OBJID)
$parserState->{preEqualsSymbol} => 
$parserState->{preTemplateSymbol} => 
$parserState->{prekeywordsodname} => 
$parserState->{prekeywordsodtype} => 
$parserState->{returntype} => sub runTest
$parserState->{seenBraces} => 1
$parserState->{seenMacroPart} => 0
$parserState->{seenTilde} => 0
$parserState->{simpleTDcontents} => 
$parserState->{simpleTypedef} => 0
$parserState->{sodclass} => function
$parserState->{sodname} => runTest
$parserState->{sodtype} => 
$parserState->{stackFrozen} => 1
$parserState->{startOfDec} => 0
$parserState->{sublang} => perl
$parserState->{temponlyComments} => 0
$parserState->{typestring} => function
$parserState->{value} => 
$parserState->{valuepending} => 0
-=: BLOCKPARSE RETURN VALUES :=-
newcount: 264
typelist: function
namelist: runTest
posstypes: function method
value: 
returntype: 
pridec: 
simpleTDcontents: 
bpavail: 
blockOffset: 0
conformsToList: 
functionContents: {
    my $self = shift;
    my $results = "";

    my $prevignore = $HeaderDoc::ignore_apiuid_errors;
    $HeaderDoc::ignore_apiuid_errors = 1;
    $HeaderDoc::test_mode = 1;
    $HeaderDoc::curParserState = undef;
    use strict;

    $HeaderDoc::dumb_as_dirt = 0;
    $HeaderDoc::parse_javadoc = 1;
    $HeaderDoc::IncludeSuper = 0;
    $HeaderDoc::ClassAsComposite = 1;
    $HeaderDoc::process_everything = 0;
    $HeaderDoc::align_columns = 0;
    $HeaderDoc::groupright = 1;
    $HeaderDoc::ignore_apiowner_names = 0;
    $HeaderDoc::add_link_requests = 1;
    $HeaderDoc::truncate_inline = 1;
    $HeaderDoc::sort_entries = 1;
    $HeaderDoc::enableParanoidWarnings = 0;
    $HeaderDoc::outerNamesOnly = 0;

    my ($cpp_hash_ref, $cpp_arg_hash_ref) = getAndClearCPPHash();

    my @commentLines = split(/\n/, $self->{COMMENT});
    map(s/$/\n/gm, @commentLines);

    # Set up some stuff for the line array code to filter the comment.
    $HeaderDoc::nodec = 0;

    HeaderDoc::APIOwner->apiUIDPrefix("test_ref");

    my $apiOwner = HeaderDoc::Header->new();
    $apiOwner->apiOwner($apiOwner);
    my $headerObject = $apiOwner;
    $HeaderDoc::headerObject = $headerObject;
    $apiOwner->filename($self->{FILENAME});
    $apiOwner->name($self->{NAME});
    $HeaderDoc::lang = $self->{LANG};
    $HeaderDoc::sublang = $self->{SUBLANG};

    %HeaderDoc::ignorePrefixes = ();
    %HeaderDoc::perHeaderIgnorePrefixes = ();
    %HeaderDoc::perHeaderIgnoreFuncMacros = ();

    # Filter the comment.
    my @commentLineArray = &getLineArrays(\@commentLines, $self->{LANG}, $self->{SUBLANG});
    my $comment = "";
    foreach my $arr (@commentLineArray) {
        foreach my $item (@$arr) {
            my $localDebug = 0;
            if (($self->{LANG} ne "pascal" && (
                             ($self->{LANG} ne "perl" && $self->{LANG} ne "shell" && $item =~ /^\s*\/\*\!/o) ||
                             (($self->{LANG} eq "perl" || $self->{LANG} eq "shell") && ($item =~ /^\s*\#\s*\/\*\!/o)) ||
                             (($self->{LANG} eq "java" || $HeaderDoc::parse_javadoc) && ($item =~ /^\s*\/\*\*[^\*]/o)))) ||
                            (($self->{LANG} eq "pascal") && ($item =~ s/^\s*\{!/\/\*!/so))) {
                if (($self->{LANG} ne "pascal" && ($item =~ /\s*\*\//o)) ||
                                    ($self->{LANG} eq "pascal" && ($item =~ s/\s*\}/\*\//so))) { # closing comment marker on same line
                                       print "PASCAL\n" if ($localDebug);
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                $item =~ s/^\s*\#//s;
                                                $item =~ s/\n( |\t)*\#/\n/sg;
                                                # print "NEWLINE: $item\n";
                        }
                } else {
                        $item =~ s/^ \*//o;
                        if ($self->{LANG} eq "perl" || $self->{LANG} eq "shell") {
                                                    print "SHELL OR PERL\n" if ($localDebug);
                                                    $item =~ s/^\s*\#//o;
print "ITEM NOW $item\n";
                        }
                }
            }
            $comment .= $item; #$commentLineArray[0][0];
        }
    }


# print("COMMENT: $comment\n");


    if ($comment =~ /^\s*\/\*\*/s) {
        $comment =~ s/\s*\/\*\*/\/\*\!/s;
    }
    if ($comment =~ /^\s*\/\*!/s) {
        $comment =~ s/\*\/\s*$//s;
    }
    $comment =~ s/^\s*//s;
    # print "COM: $comment\n";

    # Try the top level comment parser code and see what we get.
    my ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug);
    if ($self->{TYPE} eq "parser") {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", $comment, 0, 0, $self->{FILENAME}, 0, 0);
    } else {
        ($inHeader, $inClass, $inInterface, $inCPPHeader, $inOCCHeader, $inPerlScript, $inShellScript, $inPHPScript, $inJavaSource, $inFunctionGroup, $inGroup, $inFunction, $inPDefine, $inTypedef, $inUnion, $inStruct, $inConstant, $inVar, $inEnum, $inMethod, $inAvailabilityMacro, $inUnknown, $classType, $line, $inputCounter, $blockOffset, $filename, $linenumdebug, $localDebug) = processTopLevel(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "unknown", "/*! CPP only */", 0, 0, $self->{FILENAME}, 0, 0);
    }

    if ($self->{TYPE} eq "parser") {
        $results .= "-=: TOP LEVEL COMMENT PARSE VALUES :=-\n";
        $results .= "inHeader: $inHeader\n";
        $results .= "inClass: $inClass\n";
        $results .= "inInterface: $inInterface\n";
        $results .= "inCPPHeader: $inCPPHeader\n";
        $results .= "inOCCHeader: $inOCCHeader\n";
        $results .= "inPerlScript: $inPerlScript\n";
        $results .= "inShellScript: $inShellScript\n";
        $results .= "inPHPScript: $inPHPScript\n";
        $results .= "inJavaSource: $inJavaSource\n";
        $results .= "inFunctionGroup: $inFunctionGroup\n";
        $results .= "inGroup: $inGroup\n";
        $results .= "inFunction: $inFunction\n";
        $results .= "inPDefine: $inPDefine\n";
        $results .= "inTypedef: $inTypedef\n";
        $results .= "inUnion: $inUnion\n";
        $results .= "inStruct: $inStruct\n";
        $results .= "inConstant: $inConstant\n";
        $results .= "inVar: $inVar\n";
        $results .= "inEnum: $inEnum\n";
        $results .= "inMethod: $inMethod\n";
        $results .= "inAvailabilityMacro: $inAvailabilityMacro\n";
        $results .= "inUnknown: $inUnknown\n";
        $results .= "classType: $classType\n";
        $results .= "inputCounter: $inputCounter\n";
        $results .= "blockOffset: $blockOffset\n";
        $results .= "filename: $filename\n";
    }

    my @perHeaderClassObjects = ();
    my @perHeaderCategoryObjects = ();
    my @fields = ();
    my $hangDebug = my $parmDebug = my $blockDebug = 0;
    my $allow_multi = 1;
    my $subparse = 0;
    my $subparseTree = undef;
    my $cppAccessControlState = "protected:"; # the default in C++
    my $objcAccessControlState = "private:"; # the default in Objective C
    my $functionGroup = "default_function_group";
    my @inputLines = split(/\n/, $self->{CODE});
    my @cppInputLines = split(/\n/, $self->{CPPCODE});
    my $preAtPart = "";
    my $xml_output = 0;

    map(s/$/\n/gm, @inputLines);
    map(s/$/\n/gm, @cppInputLines);


    my ($case_sensitive, $keywordhashref) = $headerObject->keywords();

    my $inputCounter = 0;

    # print "TYPE: $self->{TYPE}\n";
    $HeaderDoc::enable_cpp = 1;
    if ($self->{TYPE} eq "cpp") {
        $results .= "-=: CPP MACROS PARSED :=-\n";
        while ($inputCounter <= $#cppInputLines) {
                my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@cppInputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);
                $results .= "PARSED: $namelist\n";
                $inputCounter = $newcount;
        }
        $results .= "\n";
    }

    my $blockOffset = $inputCounter;
    $inputCounter = 0;
    my ($newcount, $declaration, $typelist, $namelist, $posstypes, $value, $pplref, $returntype, $pridec, $parseTree, $simpleTDcontents, $bpavail, $blockOffset, $conformsToList, $functionContents, $parserState) = &blockParse($filename, $blockOffset, \@inputLines, $inputCounter, 0, \%HeaderDoc::ignorePrefixes, \%HeaderDoc::perHeaderIgnorePrefixes, \%HeaderDoc::perHeaderIgnoreFuncMacros, $keywordhashref, $case_sensitive);

    $results .= "-=: BLOCKPARSE PARSER STATE KEYS :=-\n";
    my @pskeys = keys %{$parserState};
    foreach my $key (@pskeys) {
        if ($key !~ /(pplStack|hollow|lastTreeNode|freezeStack|parsedParamList)/) {
                $results .= "\$parserState->{$key} => ".$parserState->{$key}."\n";
        } else {
                my $temp = $parserState->{$key};
                $temp =~ s/0x[0-9a-f]+/OBJID/sg;
                $results .= "\$parserState->{$key} => ".$temp."\n";
        }
    }
    $results .= "-=: BLOCKPARSE RETURN VALUES :=-\n";
    $results .= "newcount: $newcount\n";
    $results .= "typelist: $typelist\n";
    $results .= "namelist: $namelist\n";
    $results .= "posstypes: $posstypes\n";
    $results .= "value: $value\n";
    $results .= "returntype: $returntype\n";
    $results .= "pridec: $pridec\n";
    $results .= "simpleTDcontents: $simpleTDcontents\n";
    $results .= "bpavail: $bpavail\n";
    $results .= "blockOffset: $blockOffset\n";
    $results .= "conformsToList: $conformsToList\n";
    $results .= "functionContents: $functionContents\n";

    # Legacy declaration.
    # $results .= "declaration: $declaration\n";

    # Parsed parameters list (array)
    # $results .= "pplref: $pplref\n";
    my @parsedParamList = @{$pplref};

    $results .= "-=: LIST OF PARSED PARAMETERS :=-\n";
    my $count = 0;
    foreach my $ppl (@parsedParamList) {
        $results .= "Parsed Param $count => $ppl\n";
        $count++;
    }

    # Parse tree (data structure)
    # parseTree: $parseTree
    $results .= "-=: DUMP OF PARSE TREE :=-\n";
    $results .= $parseTree->test_output_dump();

    $results .= "-=: COMPUTED VALUE :=-\n";
    my ($success, $value) = $parseTree->getPTvalue();
    $results .= "SUCCESS: $success\n";
    $results .= "VALUE: $value\n";

    $results .= "-=: CPP CHANGES :=-\n";
    $results .= $self->cppTests();

# print "RESULTS: $results\n";

    if ($self->{TYPE} eq "parser") {
        # Only do this for parser tests.


        my $fieldref = stringToFields($comment, $filename, $inputCounter);
        @fields = @{$fieldref};

        if ($inHeader) {
                my $rootOutputDir = "/tmp/bogus";
                my $debugging = 0;
                my $reprocess_input = 0;

                processHeaderComment($apiOwner, $rootOutputDir, \@fields, $self->{LANG}, $debugging, $reprocess_input);
        }

        my ($newInputCounter, $cppAccessControlState, $classType, $classref, $catref, $blockOffset, $numcurlybraces, $foundMatch) =
            blockParseOutside($apiOwner, $inFunction, $inUnknown,
                $inTypedef, $inStruct, $inEnum, $inUnion,
                $inConstant, $inVar, $inMethod, $inPDefine,
                $inClass, $inInterface, $blockOffset, \@perHeaderCategoryObjects,
                \@perHeaderClassObjects, $classType, $cppAccessControlState,
                \@fields, $filename, $functionGroup,
                $headerObject, $inputCounter, \@inputLines,
                $self->{LANG}, $#inputLines, $preAtPart, $xml_output, $localDebug,
                $hangDebug, $parmDebug, $blockDebug, $subparse,
                $subparseTree, $HeaderDoc::nodec, $allow_multi);

        $results .= "-=: FOUND MATCH :=-\n";
        $results .= $foundMatch."\n";
        $results .= "-=: NAMED OBJECTS :=-\n";
        $results .= $self->dumpObjNames($headerObject);
    }

    # my @lines = split(

        # print "TEST RESULTS: $results\n";

    $HeaderDoc::test_mode = 0;
    $HeaderDoc::ignore_apiuid_errors = $prevignore;
    $self->{RESULT} = $results;
}

extendsClass: 
implementsClass: 
-=: LIST OF PARSED PARAMETERS :=-
-=: DUMP OF PARSE TREE :=-
+---sub
+--- 
+---runTest
+--- 
-=: COMPUTED VALUE :=-
SUCCESS: 0
VALUE: 0
-=: CPP CHANGES :=-
NO CPP CHANGES
-=: FOUND MATCH :=-
1
-=: NAMED OBJECTS :=-
TREE COUNT: 0
INDEX GROUP: 
IS BLOCK: 
OBJECT TYPE: HeaderDoc::Header
NAME: Perl function 3
APIUID: //test_ref/doc/header/Perl_function_3.test
ABSTRACT: ""
DISCUSSION: "<p></p>"
UPDATED: ""
COPYRIGHT: ""
HTMLMETA: ""
PRIVATEDECLARATION: ""
GROUP: ""
INDEXGROUP: ""
THROWS: ""
XMLTHROWS: ""
UPDATED: ""
LINKAGESTATE: ""
ACCESSCONTROL: ""
AVAILABILITY: ""
LINKUID: ""
ORIGCLASS: ""
ISDEFINE: ""
ISTEMPLATE: ""
VALUE: "UNKNOWN"
RETURNTYPE: ""
LINENUM: ""
CLASS: "HeaderDoc::Header"
MASTERENUM: ""
APIREFSETUPDONE: "1"
TPCDONE: ""
NOREGISTERUID: ""
SUPPRESSCHILDREN: ""
NAMELINE_DISCUSSION: ""
HIDEDOC: ""
HIDESINGLETONS: ""
HIDECONTENTS: ""
MAINOBJECT: ""
LIST ATTRIBUTES: 
SHORT ATTRIBUTES: 
LONG ATTRIBUTES: 
    TREE COUNT: 1
    INDEX GROUP: 
    IS BLOCK: 
    OBJECT TYPE: HeaderDoc::Function
    NAME: runTest
    APIUID: //test_ref/perl/func/runTest
    ABSTRACT: ""
    DISCUSSION: "<p>run tests. "
    UPDATED: ""
    COPYRIGHT: ""
    HTMLMETA: ""
    PRIVATEDECLARATION: ""
    GROUP: "default_function_group"
    INDEXGROUP: ""
    THROWS: ""
    XMLTHROWS: ""
    UPDATED: ""
    LINKAGESTATE: ""
    ACCESSCONTROL: ""
    AVAILABILITY: ""
    LINKUID: ""
    ORIGCLASS: ""
    ISDEFINE: ""
    ISTEMPLATE: ""
    VALUE: "UNKNOWN"
    RETURNTYPE: ""
    LINENUM: ""
    CLASS: "HeaderDoc::Function"
    MASTERENUM: ""
    APIREFSETUPDONE: "1"
    TPCDONE: ""
    NOREGISTERUID: ""
    SUPPRESSCHILDREN: "0"
    NAMELINE_DISCUSSION: ""
    HIDEDOC: ""
    HIDESINGLETONS: ""
    HIDECONTENTS: ""
    MAINOBJECT: ""
    LIST ATTRIBUTES: 
    SHORT ATTRIBUTES: 
    LONG ATTRIBUTES: 
-=: NAMED OBJECT PARSE TREES :=-
OBJECT: runTest (HeaderDoc::Function)
+---sub
+--- 
+---runTest
+--- 
END OF OBJECT



-=: HTML OUTPUT OF PARSE TREES :=-
OBJECT: runTest (HeaderDoc::Function)
	<span class="keyword">sub</span> <!-- a logicalPath="//test_ref/perl/instm/runTest //test_ref/perl/clm/runTest //test_ref/perl/intfcm/runTest //test_ref/perl/intfm/runTest //test_ref/perl/func/runTest //test_ref/perl/ftmplt/runTest //test_ref/perl/defn/runTest //test_ref/perl/macro/runTest //test_ref/doc/anysymbol/runTest" machineGenerated="true" --><span class="function">runTest</span><!-- /a --> 
END OF OBJECT



_$97|/Users/dg/headerdoc-techpubs/Modules/HeaderDoc//../../testsuite/parser_tests/Perl_function_3.test$4|perl$15|Perl function 3$4|perl$6|parser