windows-server-2003/base/ntsetup/complnce/comptest/section.cpp

#pragma warning( disable:4786 )

#include <section.h>
#include <cstdlib>
#include <strutil.h>
#include <compfile.h>
#include <iomanip>
#include <media.h>

extern "C" {
    DWORD SourceInstallType;
    CHAR  *SourcePaths[] = { 0};
    DWORD OsVersion;
    VOID GetSourceInstallType(LPDWORD InstallVariation);
};

//
// ValueSection methods
//

void ValueSection::parse() {
    vector<string>::const_iterator  iter = lines().begin();

    while (iter != lines().end()) {
        vector<string>  tokens;

        Tokenize((const string&)(*iter), string(" ="), tokens);

        if (tokens.size() != 2)
            throw InvalidSectionFormat(name());

        m_values[tokens[0]] = toUnsignedLong(tokens[1].c_str());
        iter++;
    }
}

//
// TestSection methods
//
void TestSection::parse() {
    vector<string>::const_iterator  iter = lines().begin();

    while (iter != lines().end()) {
        m_testCases.push_back(testCaseFactory().create(*this, *iter));
        iter++;
    }
}

TestSection& TestSection::operator=(const TestSection& rhs){
    cerr << "Copying section " << endl;
    *(Section *)this = (Section&)rhs;

    m_testCases.clear();

    vector<TestCase*>::const_iterator iter = rhs.m_testCases.begin();

    while (iter != rhs.m_testCases.end()) {
        m_testCases.push_back(testCaseFactory().create(**iter));
        iter++;
    }

    return *this;
}

void TestSection::executeTestCases(ostream& os) {
    vector<TestCase*>::iterator iter = m_testCases.begin();

    bool allpassed = true;

    os << endl << endl;
    if( iter != m_testCases.end() && (*iter)->mediamatched()) {
        os << "Media Matched:";
    }

    os << "Executing test cases for {" << name() << "}" 
    << endl << endl;

    
    while (iter != m_testCases.end()) {
        if( bVerbose) {
        os << dec << setw(3) << setfill('0') 
            << (iter - m_testCases.begin() + 1) << ": TestCase : [" 
            << (*iter)->line() << "]" << " " << endl;
        }
        (*iter)->execute(os);

        if (!(*iter)->passed()) {
            if( !bVerbose) {
                os << dec << setw(3) << setfill('0') 
                << (iter - m_testCases.begin() + 1) << ": TestCase : [" 
                << (*iter)->line() << "]" << " FAILED" << endl;
            }
            (*iter)->dump(os);
            allpassed = false;
        }

        iter++;
    }

    if (allpassed)
        os << "all the test cases passed for this section" << endl;
}


//
// ComplianceTestCase methods
//
void ComplianceTestCase::parse() {
    vector<string>  tokens;

    Tokenize(line(), string("#=,"), tokens);

    if (tokens.size() == 7) {
        m_expectedResult = ((tokens[6][0] == 'y') || (tokens[6][0] == 'Y'));
        sourceDetails();
        installationDetails(tokens);
    } else {
        throw InvalidFormat(line(), section().name());
    }
}

void ComplianceTestCase::sourceDetails() {
    vector<string>  tokens;
    char *pstr;

    Tokenize(section().name(), string("[#]"), tokens);

    if ((tokens.size() == 7) && (tokens[0] == "test")) {
        m_sourceSKU = section().file().sourcesSection().value(tokens[1] + "#" + tokens[6]);
        m_sourceVAR = section().file().varsSection().value(tokens[5]);
        m_sourceVer = atol(tokens[2].c_str()) * 100; // (major * 100 + minor)
        pstr = strchr( tokens[2].c_str(), '.');
        if( pstr != NULL && *(pstr+1) != NULL) {
            m_sourceVer += atol( pstr+1);
        }
        m_sourceBuild = atol(tokens[3].c_str());

        //wprintf( TEXT("SKU=%d, VAR=%d, Ver=%d, Build=%d\n"), m_sourceSKU, m_sourceVAR, m_sourceVer, m_sourceBuild);
        if( m_sourceSKU == SourceSku &&
            m_sourceVAR == SourceSkuVariation &&
            m_sourceVer == SourceVersion &&
            m_sourceBuild == SourceBuildNum) {
            m_mediamatched = TRUE;
            //printf("Media matched\n");
        } else {
            m_mediamatched = FALSE;
        }
    } else {
        throw Section::InvalidSectionName(section().name());
    }
}

void ComplianceTestCase::installationDetails(const vector<string>& tokens) {
    int length,i;
    int version;

    if ((tokens.size() == 7)) {
        m_errExpected = section().file().errorsSection().value(tokens[5]);
        m_cd.InstallType = section().file().typesSection().value(tokens[0]);
        m_cd.InstallVariation = section().file().varsSection().value(tokens[4]);
        m_cd.InstallSuite = section().file().suitesSection().value(tokens[3]);
        m_cd.RequiresValidation = (section().name().find("#ccp") != section().name().npos);
        //m_cd.MinimumVersion = ::strtod(tokens[1].c_str()) * 100;
        length = tokens[1].size();
        i = 0;
        version = 0;
        while (i < length) {
            if ( tokens[1][i] != '.') {
                version = version*10 + tokens[1][i] - '0';
            } else {
                if (i == (length-3)) { // two decimal places
                    version = version*100+ (tokens[1][i+1] - '0')*10 + (tokens[1][i+2]-'0');
                } else {
                    version = version*100+ (tokens[1][i+1] - '0');
                }
                i = length;
            }
            i++;
        }
        m_cd.MinimumVersion = version;
        // cerr << "minimum version" << m_cd.MinimumVersion << endl;
        m_cd.MaximumKnownVersionNt = 510;
        if ( m_cd.InstallType & COMPLIANCE_INSTALLTYPE_WIN9X) {
            m_cd.BuildNumberWin9x = toUnsignedLong(tokens[2].c_str());
            m_cd.BuildNumberNt = 0;
        } else {
            m_cd.BuildNumberNt = toUnsignedLong(tokens[2].c_str());
            m_cd.BuildNumberWin9x = 0;
        }
    } else
        throw Section::InvalidSectionName(section().name());
}

bool ComplianceTestCase::passed() {
    bool  result = false;

    if (m_errExpected) {
        // negative testcase
        if (m_cd.RequiresValidation) {
            // should have failed with expected error code & upgrade flag
            result = (!m_passed && (m_errExpected == m_reason) &&
                      (m_allowUpgrade == m_expectedResult));
        } else {
            // should pass with expected error code & upgrade flag			
            // target errors are special case
            result = ((m_reason != 0x5) ? m_passed : !m_passed) && (m_errExpected == m_reason) &&
                     (m_allowUpgrade == m_expectedResult);
        }                               
    } else {
        result = (m_passed && (m_allowUpgrade == m_expectedResult) && (m_errExpected == m_reason));
    }    

    return result;
}

void ComplianceTestCase::execute(ostream &os) {
    m_reason = 0;
    m_noUpgrade = true;

    if( bUITest) {
        m_passed = UITest( m_sourceSKU, m_sourceVAR, m_sourceVer,
                               m_sourceBuild, &m_cd,  &m_reason, &m_noUpgrade) ? true : false;
    
    }else {
        m_passed = CheckCompliance(m_sourceSKU, m_sourceVAR, m_sourceVer,
                               m_sourceBuild, &m_cd,  &m_reason, &m_noUpgrade) ? true : false;

    }
    m_allowUpgrade = (m_noUpgrade) ? false : true;  
}

void ComplianceTestCase::dump(ostream &os) {
    // (Error expected or not, The error that was expected in hex, Upgrade allowed)
    os << "Expected result : (error="  << hex << m_errExpected << ",upgradeallowed="
    << ((m_expectedResult) ? "true" : "false") << ")" << endl;

    // (Compliant or not(can we do clean install?), Reason in hex, Upgrade allowed)
    os << "Actual result   : (compliant=" << (m_passed  ? "true" : "false")
    << ",error=" << hex << m_reason << ",upgradeallowed="
    << ((m_allowUpgrade) ? "true" : "false") << ")" << endl; 
}