fix tests

gcontini

2020-03-08 538760b37cf128ba6056dcb720703010925660da

fix tests

 CMakeLists.txt

@@ -56,7 +56,7 @@
        SET ( ZLIB_USE_STATIC_LIBS ON ) 
        find_package(ZLIB REQUIRED)
        list(APPEND EXTERNAL_LIBS ${ZLIB_LIBRARIES})
        MESSAGE(STATUS "Found zlib version ${ZLIB_VERSION_STRING} ")
        MESSAGE(STATUS "Found zlib version ${ZLIB_VERSION_STRING} - licensecc")
    ENDIF(OPENSSL_VERSION VERSION_LESS 1.0.2)
    find_package(Threads)
    if(THREADS_HAVE_PTHREAD_ARG)

 src/inspector/inspector.cpp

@@ -6,11 +6,19 @@
#include "../library/os/cpu_info.hpp"

using namespace std;
const map<LCC_API_IDENTIFICATION_STRATEGY, string> stringByStrategyId = {

struct enum_hash {
    template <typename T>
    constexpr typename std::enable_if<std::is_enum<T>::value, std::size_t>::type operator()(T s) const noexcept {
        return static_cast<std::size_t>(s);
    }
};

const map<LCC_API_IDENTIFICATION_STRATEGY, string, enum_hash> stringByStrategyId = {
    {STRATEGY_DEFAULT, "DEFAULT"}, {STRATEGY_ETHERNET, "MAC"},     {STRATEGY_IP_ADDRESS, "IP"},
    {STRATEGY_DISK_NUM, "Disk1"},  {STRATEGY_DISK_LABEL, "Disk2"}, {STRATEGY_NONE, "Custom"}};

const unordered_map<LCC_EVENT_TYPE, string> stringByEventType = {
const unordered_map<LCC_EVENT_TYPE, string, enum_hash> stringByEventType = {
    {LICENSE_OK, "OK "},
    {LICENSE_FILE_NOT_FOUND, "license file not found "},
    {LICENSE_SERVER_NOT_FOUND, "license server can't be contacted "},

 src/library/os/windows/execution_environment.cpp

@@ -1,64 +1,39 @@
#include <paths.h>
/*
 * virtualization.cpp
 *
 *  Created on: Dec 15, 2019
 *      Author: GC
 */
#include <sys/stat.h>
#include <unistd.h>
#include <fstream>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <dirent.h>
#include <sys/utsname.h>
#include <string>

#include "isvm/BIOSReader.h"
#include "isvm/Native.h"
#include "../../base/base.h"
#include "../../base/StringUtils.h"
#include "../cpu_info.hpp"
#include "../execution_environment.hpp"

namespace license {
namespace os {
using namespace std;



VIRTUALIZATION ExecutionEnvironment::getVirtualization() {
    VIRTUALIZATION result;
    CpuInfo cpuInfo;
    bool isContainer = false;
    if (isContainer) {
        result = CONTAINER;
    } else if (cpuInfo.cpu_virtual() || is_cloud()) {
        result = VM;
    } else {
        result = NONE;
    }
    return result;
}

bool ExecutionEnvironment::is_cloud() { return getCloudProvider() != ON_PREMISE; }

bool ExecutionEnvironment::is_docker() { return false; }

CLOUD_PROVIDER ExecutionEnvironment::getCloudProvider() {
ExecutionEnvironment::ExecutionEnvironment() {
    if (InitEntryPoints()) {
        BIOSReader reader;
        SystemInformation info = reader.readSystemInfo();

        const char *vmVendors[] = {
            "VMware", "Microsoft Corporation", "Virtual Machine", "innotek GmbH", "PowerVM", "Bochs", "KVM"};

        const int count = _countof(vmVendors);
        for (int i = 0; i != count; ++i) {
            const char *vendor = vmVendors[i];

            if (std::string::npos != info.Manufacturer.find(vendor) ||
                std::string::npos != info.ProductName.find(vendor) ||
                std::string::npos != info.SerialNum.find(vendor)) {
                std::cout << "Inside virual machine!";
                return 1;
            }
        }
    } else {
        return -1;
        sys_vendor = toupper_copy(info.Manufacturer);
        bios_vendor = toupper_copy(info.ProductName);
        bios_description = toupper_copy(info.SysVersion) + toupper_copy(info.family);
    }
}

//TODO
bool ExecutionEnvironment::is_docker() const { return false; }
//TODO
bool ExecutionEnvironment::is_container() const { return is_docker(); }
}  // namespace os
}  // namespace license

 test/functional/CMakeLists.txt

@@ -40,6 +40,7 @@
 test_signature_verifier
 licensecc_static
 license_generator_snippet
 ${EXTERNAL_LIBS}
 Boost::unit_test_framework 
 Boost::filesystem
 Boost::system