test for pc-id stability

open-license-manager

2014-07-28 91965e66c651de648a8edd1338907fed773d0998

test for pc-id stability

 src/library/pc-identifiers.c

@@ -78,7 +78,7 @@

    adapterInfos = (AdapterInfo*) malloc(adapters * sizeof(AdapterInfo));
    result_adapterInfos = getAdapterInfos(adapterInfos, &adapters);
    for (j = 0; j < adapters; i++) {
    for (j = 0; j < adapters; j++) {
        for (k = 0; k < 6; k++)
            if (use_mac) {
                identifiers[j][k] = adapterInfos[j].mac_address[k + 2];
@@ -303,7 +303,9 @@
    unsigned int calc_identifiers_size = 0;
    int i = 0, j = 0;
    //bool found;

#ifdef _DEBUG
    printf("Comparing pc identifiers: \n");
#endif
    result = decode_pc_id(user_identifiers[0], user_identifiers[1], str_code);
    if (result != OK) {
        return result;
@@ -319,7 +321,7 @@
            if (calculated_identifiers != NULL) {
                free(calculated_identifiers);
            }
            current_strategy_id = previous_strategy_id;
            previous_strategy_id = current_strategy_id;
            generate_pc_id(NULL, &calc_identifiers_size, current_strategy_id);
            calculated_identifiers = (PcIdentifier *) malloc(
                    sizeof(PcIdentifier) * calc_identifiers_size);
@@ -328,6 +330,13 @@
        }
        //maybe skip the byte 0
        for (j = 0; j < calc_identifiers_size; j++) {
#ifdef _DEBUG
            printf("generated id: %02x%02x%02x%02x%02x%02x index %d, user_supplied id %02x%02x%02x%02x%02x%02x idx: %d\n",
                    calculated_identifiers[j][0],calculated_identifiers[j][1],calculated_identifiers[j][2],
                    calculated_identifiers[j][3],calculated_identifiers[j][4],calculated_identifiers[j][5],j,
                    user_identifiers[i][0],user_identifiers[i][1],user_identifiers[i][2],user_identifiers[i][3],user_identifiers[i][4],user_identifiers[i][5],i);

#endif
            if (!memcmp(user_identifiers[i], calculated_identifiers[j],
                    sizeof(PcIdentifier))) {
                free(calculated_identifiers);

 test/functional/volid_test.cpp

@@ -2,6 +2,8 @@
//#define BOOST_TEST_MAIN
#define BOOST_TEST_DYN_LINK
#include <boost/test/unit_test.hpp>
#include <fstream>
#include <cstring>
#include "../../../src/license-generator/license-generator.h"
#include "../../../src/library/api/license++.h"
#include <build_properties.h>
@@ -18,14 +20,14 @@
    const string licLocation(PROJECT_TEST_TEMP_DIR "/volid_license.lic");
    PcSignature identifier_out;

    IDENTIFICATION_STRATEGY strategy = IDENTIFICATION_STRATEGY::DEFAULT;
    IDENTIFICATION_STRATEGY strategy = IDENTIFICATION_STRATEGY::ETHERNET;
    FUNCTION_RETURN generate_ok = generate_user_pc_signature(identifier_out,
            strategy);
    BOOST_ASSERT(generate_ok == FUNCTION_RETURN::OK);
    cout << "Identifier:" << identifier_out << endl;
    vector<string> extraArgs = { "-s", identifier_out };
    generate_license(licLocation, extraArgs);
    /* */

    LicenseInfo license;
    LicenseLocation licenseLocation;
    licenseLocation.openFileNearModule = false;
@@ -37,3 +39,62 @@
    BOOST_CHECK_EQUAL(license.linked_to_pc, true);
}

static void generate_reference_file(const string& idfileLocation,
        IDENTIFICATION_STRATEGY strategies[], int num_strategies) {
    ofstream idfile(idfileLocation);
    PcSignature identifier_out;
    for (int i = 0; i < num_strategies; i++) {
        FUNCTION_RETURN generate_ok = generate_user_pc_signature(identifier_out,
                strategies[i]);
        BOOST_ASSERT(generate_ok == FUNCTION_RETURN::OK);
        idfile << identifier_out << endl;
    }
    idfile.close();
}

BOOST_AUTO_TEST_CASE(generated_identifiers_stability) {
    const string idfileLocation(PROJECT_TEST_TEMP_DIR "/identifiers_file");
    IDENTIFICATION_STRATEGY strategies[] =
            { IDENTIFICATION_STRATEGY::DEFAULT,
                    IDENTIFICATION_STRATEGY::DISK_LABEL,
                    IDENTIFICATION_STRATEGY::DISK_NUM,
                    IDENTIFICATION_STRATEGY::ETHERNET };
    const int num_strategies = sizeof(strategies) / sizeof(strategies[0]);
    std::ifstream test_idfile_exist(idfileLocation);
    if (!test_idfile_exist.good()) {
        generate_reference_file(idfileLocation, strategies, num_strategies);
    }
    std::ifstream is(idfileLocation);
    std::istream_iterator<string> start(is), end;
    std::vector<string> reference_signatures(start, end);
    BOOST_CHECK_EQUAL(reference_signatures.size(), num_strategies);
    PcSignature generated_identifier;
    BOOST_CHECKPOINT("Generating current signatures and comparing with past");
    for (int i = 0; i < num_strategies; i++) {
        FUNCTION_RETURN generate_ok = generate_user_pc_signature(
                generated_identifier, strategies[i]);
        BOOST_ASSERT(generate_ok == FUNCTION_RETURN::OK);
        if (memcmp(generated_identifier, reference_signatures[i].c_str(),
                sizeof(PcSignature))) {
            string message = string("pc signature compare fail: strategy:")
                    + to_string(strategies[i]) + " generated: ["
                    + generated_identifier + "] reference: ["
                    + reference_signatures[i] + "]";
            BOOST_FAIL(message);
        }
    }

    BOOST_CHECKPOINT("Verifying signatures");
    for (int j = 0; j < 100; j++) {
        for (unsigned int i = 0; i < reference_signatures.size(); i++) {
            PcSignature pcsig;
            memcpy(pcsig, reference_signatures[i].c_str(), sizeof(PcSignature));
            EVENT_TYPE val_result = validate_pc_signature(pcsig);
            string message = string("pc signature verification strategy:")
                    + to_string(i) + " generated: [" + generated_identifier
                    + "] reference: [" + reference_signatures[i] + "]";
            BOOST_CHECKPOINT("Verifying signature: ");
            BOOST_CHECK_EQUAL(val_result, LICENSE_OK);
        }
    }
}