staf.cpp

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

            if (objPtr->size() > 0) cout << endl;

            if (objPtr->hasKey(sMapClassKey) &&
                context && (context->type() == kSTAFMarshallingContextObject) &&
                context->hasMapClassDefinition(objPtr->get(sMapClassKey)->asString()))
            {
                // Map object has a map class definition in the context

                STAFMapClassDefinitionPtr mapClass =
                    context->getMapClassDefinition(
                        objPtr->get(sMapClassKey)->asString());

                // Determine maximum key length

                STAFObjectIteratorPtr iterPtr;
                unsigned int maxKeyLength = 0;

                for (iterPtr = mapClass->keyIterator(); iterPtr->hasNext();)
                {
                    STAFObjectPtr theKey = iterPtr->next();
                    STAFString theKeyString;

                    if (theKey->hasKey(sDisplayName))
                        theKeyString = theKey->get(sDisplayName)->asString();
                    else
                        theKeyString = theKey->get(sKey)->asString();

                    if (theKeyString.length(STAFString::kChar) > maxKeyLength)
                        maxKeyLength = theKeyString.length(STAFString::kChar);
                }

                // Now print each object in the map

                for (iterPtr = mapClass->keyIterator(); iterPtr->hasNext();)
                {
                    STAFObjectPtr theKey = iterPtr->next();
                    STAFString theKeyString;

                    if (theKey->hasKey(sDisplayName))
                        theKeyString = theKey->get(sDisplayName)->asString();
                    else
                        theKeyString = theKey->get(sKey)->asString();

                    cout << gSpaces.subString(0, indentLevel * gIndentDelta)
                         << theKeyString
                         << gSpaces.subString(0, maxKeyLength -
                                theKeyString.length(STAFString::kChar))
                         << gMapKeySeparator;

                    STAFObjectPtr thisObj =
                        objPtr->get(theKey->get(sKey)->asString());

                    if ((thisObj->type() == kSTAFListObject) ||
                        (thisObj->type() == kSTAFMapObject) ||
                        (thisObj->type() == kSTAFMarshallingContextObject))
                    {
                        printVerbose(thisObj, context, indentLevel);
                    }
                    else if (thisObj->type() == kSTAFNoneObject)
                    {
                        cout << thisObj->asString();
                    }
                    else
                    {
                        cout << thisObj->asString();
                    }

                    if (iterPtr->hasNext()) cout << gEntrySeparator;

                    cout << endl;
                }
            }
            else
            {
                // Determine maximum key length

                STAFObjectIteratorPtr iterPtr;
                unsigned int maxKeyLength = 0;

                for (iterPtr = objPtr->keyIterator(); iterPtr->hasNext();)
                {
                    STAFString theKeyString = iterPtr->next()->asString();

                    if (theKeyString.length(STAFString::kChar) > maxKeyLength)
                        maxKeyLength = theKeyString.length(STAFString::kChar);
                }

                // Now print each object in the map

                for (iterPtr = objPtr->keyIterator(); iterPtr->hasNext();)
                {
                    STAFString theKeyString = iterPtr->next()->asString();

                    cout << gSpaces.subString(0, indentLevel * gIndentDelta)
                         << theKeyString
                         << gSpaces.subString(0, maxKeyLength -
                                theKeyString.length(STAFString::kChar))
                         << gMapKeySeparator;

                    STAFObjectPtr thisObj = objPtr->get(theKeyString);

                    if ((thisObj->type() == kSTAFListObject) ||
                        (thisObj->type() == kSTAFMapObject) ||
                        (thisObj->type() == kSTAFMarshallingContextObject))
                    {
                        printVerbose(thisObj, context, indentLevel);
                    }
                    else if (thisObj->type() == kSTAFNoneObject)
                    {
                        cout << thisObj->asString();
                    }
                    else
                    {
                        cout << thisObj->asString();
                    }

                    if (iterPtr->hasNext()) cout << gEntrySeparator;

                    cout << endl;
                }
            }

            --indentLevel;

            if (objPtr->size() > 0)
                cout << gSpaces.subString(0, indentLevel * gIndentDelta);

            cout << gMapOutdent;

            break;
        }
        case kSTAFMarshallingContextObject:
        {
            printVerbose(objPtr->getRootObject(), objPtr, indentLevel);
            break;
        }
        default:
        {
            cout << gSpaces.subString(0, indentLevel * gIndentDelta)
                 << objPtr->asString();
            break;
        }
    }
}


bool printSimple(const STAFObjectPtr &objPtr, const STAFObjectPtr &context)
{
    if (objPtr->type() == kSTAFMarshallingContextObject) return false;

    if ((objPtr->type() == kSTAFListObject) ||
        (objPtr->type() == kSTAFMapObject))
    {
        STAFObjectIteratorPtr iter =
            (objPtr->type() == kSTAFListObject) ?
                objPtr->iterate() :
                objPtr->valueIterator();

        while (iter->hasNext())
        {
            STAFObjectPtr thisObj = iter->next();

            switch (thisObj->type())
            {
                case kSTAFListObject:
                case kSTAFMapObject:
                case kSTAFMarshallingContextObject:
                    return false;
                default:
                    break;
            }
        }
    }

    if (objPtr->type() == kSTAFListObject)
    {
        for (STAFObjectIteratorPtr iterPtr = objPtr->iterate();
             iterPtr->hasNext();)
        {
            STAFObjectPtr thisObj = iterPtr->next();

            cout << thisObj->asString() << endl;
        }
    }
    else if (objPtr->type() == kSTAFMapObject)
    {
        if (objPtr->hasKey(sMapClassKey) &&
            context && (context->type() == kSTAFMarshallingContextObject) &&
            context->hasMapClassDefinition(objPtr->get(sMapClassKey)->asString()))
        {
            // Map object has a map class definition in the context

            STAFMapClassDefinitionPtr mapClass =
                context->getMapClassDefinition(
                    objPtr->get(sMapClassKey)->asString());

            // Determine maximum key length

            STAFObjectIteratorPtr iterPtr;
            unsigned int maxKeyLength = 0;

            for (iterPtr = mapClass->keyIterator(); iterPtr->hasNext();)
            {
                STAFObjectPtr theKey = iterPtr->next();
                STAFString theKeyString;

                if (theKey->hasKey(sDisplayName))
                    theKeyString = theKey->get(sDisplayName)->asString();
                else
                    theKeyString = theKey->get(sKey)->asString();

                if (theKeyString.length(STAFString::kChar) > maxKeyLength)
                    maxKeyLength = theKeyString.length(STAFString::kChar);
            }

            // Now print each object in the map

            for (iterPtr = mapClass->keyIterator(); iterPtr->hasNext();)
            {
                STAFObjectPtr theKey = iterPtr->next();
                STAFString theKeyString;

                if (theKey->hasKey(sDisplayName))
                    theKeyString = theKey->get(sDisplayName)->asString();
                else
                    theKeyString = theKey->get(sKey)->asString();

                cout << theKeyString
                     << gSpaces.subString(0, maxKeyLength -
                                          theKeyString.length(STAFString::kChar))
                     << gMapKeySeparator
                     << objPtr->get(theKey->get(sKey)->asString())->asString()
                     << endl;
            }
        }
        else
        {
            // Determine maximum key length

            STAFObjectIteratorPtr iterPtr;
            unsigned int maxKeyLength = 0;

            for (iterPtr = objPtr->keyIterator(); iterPtr->hasNext();)
            {
                STAFString theKeyString = iterPtr->next()->asString();

                if (theKeyString.length(STAFString::kChar) > maxKeyLength)
                    maxKeyLength = theKeyString.length(STAFString::kChar);
            }

            // Now print each object in the map

            for (iterPtr = objPtr->keyIterator(); iterPtr->hasNext();)
            {
                STAFString theKeyString = iterPtr->next()->asString();

                cout << theKeyString
                     << gSpaces.subString(0, maxKeyLength -
                                          theKeyString.length(STAFString::kChar))
                     << gMapKeySeparator
                     << objPtr->get(theKeyString)->asString()
                     << endl;
            }
        }
    }
    else
    {
        cout << objPtr->asString();
    }

    return true;
}

bool printTable(const STAFObjectPtr &objPtr, const STAFObjectPtr &context)
{
    if (!gPrintTables) return false;

    if (objPtr->type() != kSTAFListObject) return false;

    STAFObjectIteratorPtr iter = objPtr->iterate();

    if (!iter->hasNext()) return false;

    STAFObjectPtr firstObj = iter->next();

    if (firstObj->type() != kSTAFMapObject) return false;

    if (!firstObj->hasKey(sMapClassKey)) return false;

    STAFString mapClassName = firstObj->get(sMapClassKey)->asString();

    if (!context) return false;
    if (context->type() != kSTAFMarshallingContextObject) return false;
    if (!context->hasMapClassDefinition(mapClassName)) return false;

    STAFMapClassDefinitionPtr mapClassObj =
        context->getMapClassDefinition(mapClassName);

    // Initialize table info from map class

    unsigned int maxSizeCount = gMaxTableWidth * gMaxLinesPerTableRecord;
    TableColumnList columnList;

    for (STAFObjectIteratorPtr mcIter = mapClassObj->keyIterator();
         mcIter->hasNext();)
    {
        TableColumn thisColumn;

        thisColumn.sizeCounts = std::vector<unsigned int>(maxSizeCount + 1, 0);
        thisColumn.cwLineCounts = std::vector<std::vector<unsigned int> >(gMaxTableWidth + 1, std::vector<unsigned int>(gMaxLinesPerTableRecord + 1, 0));
        thisColumn.cwLineCountSums = std::vector<std::vector<unsigned int> >(gMaxTableWidth + 1, std::vector<unsigned int>(gMaxLinesPerTableRecord + 1, 0));
        thisColumn.cwLineSums = std::vector<unsigned int>(gMaxTableWidth, 0);

        STAFObjectPtr thisKey = mcIter->next();

        thisColumn.key = thisKey->get(sKey)->asString();

        if (thisKey->hasKey(sDisplayName))
            thisColumn.longHeader = thisKey->get(sDisplayName)->asString();
        else
            thisColumn.longHeader = thisKey->get(sKey)->asString();

        if (thisKey->hasKey(sShortDisplayName))
            thisColumn.shortHeader = thisKey->get(sShortDisplayName)->asString();
        else
            thisColumn.shortHeader = thisColumn.longHeader;

        thisColumn.header = thisColumn.longHeader;

        thisColumn.longHeaderLength =
            thisColumn.longHeader.length(STAFString::kChar);
        thisColumn.shortHeaderLength =
            thisColumn.shortHeader.length(STAFString::kChar);

        thisColumn.width = 0;
        thisColumn.maxValueLength = 0;

        columnList.push_back(thisColumn);
    }

    // Process first object

    TableColumnList::iterator clIter;
    
    for (clIter = columnList.begin(); clIter != columnList.end(); ++clIter)
    {
        STAFObjectPtr thisValueObj = firstObj->get(clIter->key);

        if ((thisValueObj->type() != kSTAFScalarStringObject) &&
            (thisValueObj->type() != kSTAFNoneObject))
        {
            if (gStrictTables) return false;
        }

        unsigned int firstItemColumnWidth =
            thisValueObj->asString().length(STAFString::kChar);

        ++clIter->sizeCounts[STAF_MIN(firstItemColumnWidth, maxSizeCount)];

        for (unsigned int columnIndex = 0, columnWidth = 1;
             columnIndex < gMaxTableWidth;
             ++columnIndex, ++columnWidth)
        {
            // At least one line is needed even if the length of an entry
            // in the table is 0 (e.g. due to an empty string, etc.)
            unsigned int linesNeeded = STAF_MAX(
                1, firstItemColumnWidth / columnWidth);

            if (firstItemColumnWidth % columnWidth != 0)
                ++linesNeeded;

            linesNeeded = STAF_MIN(linesNeeded, gMaxLinesPerTableRecord);

            ++clIter->cwLineCounts[columnIndex][linesNeeded - 1];
            clIter->cwLineSums[columnIndex] += linesNeeded;

            for (unsigned int lineIndex = linesNeeded - 1;
                 lineIndex < gMaxLinesPerTableRecord + 1;
                 ++lineIndex)
            {
                ++clIter->cwLineCountSums[columnIndex][lineIndex];
            }
        }

        clIter->maxValueLength = STAF_MAX(clIter->maxValueLength,
                                          firstItemColumnWidth);
    }
    
    // Loop through and process the rest of the objects
    
    while (iter->hasNext())
    {
        STAFObjectPtr thisObj = iter->next();