test_campaign.cpp

Go to the documentation of this file.

 
/*
Copyright (C) 2002-2023 UFO: Alien Invasion.
 
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
See the GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/
 
#include "test_shared.h"
#include "../client/DateTime.h"
#include "../client/client.h"
#include "../client/cl_lua.h"
#include "../client/cgame/cl_game.h"
#include "../client/renderer/r_state.h" /* r_state */
#include "../client/ui/ui_main.h"
#include "../client/cgame/campaign/cp_campaign.h"
#include "../client/cgame/campaign/cp_geoscape.h"
#include "../client/cgame/campaign/cp_hospital.h"
#include "../client/cgame/campaign/cp_missions.h"
#include "../client/cgame/campaign/cp_nation.h"
#include "../client/cgame/campaign/cp_overlay.h"
#include "../client/cgame/campaign/cp_ufo.h"
#include "../client/cgame/campaign/cp_time.h"
#include "../client/cgame/campaign/cp_alien_interest.h"
#include "../client/cgame/campaign/cp_auto_mission.h"
#include "../client/cgame/campaign/itemcargo.h"
#include "../client/cgame/campaign/missions/cp_mission_intercept.h"
#include "../shared/parse.h"
#include "../shared/images.h"
 
static const int TAG_INVENTORY = 1538;
 
static void FreeInventory (void* data)
{
    Mem_Free(data);
}
 
static void* AllocInventoryMemory (size_t size)
{
    return Mem_PoolAlloc(size, com_genericPool, TAG_INVENTORY);
}
 
static void FreeAllInventory (void)
{
    Mem_FreeTag(com_genericPool, TAG_INVENTORY);
}
 
static const inventoryImport_t inventoryImport = { FreeInventory, FreeAllInventory, AllocInventoryMemory };
 
static inline void ResetInventoryList (void)
{
    cls.i.destroyInventoryInterface();
    cls.i.initInventory("testCampaign", &csi, &inventoryImport);
}
 
static campaign_t* GetCampaign (void)
{
    return CP_GetCampaign("main");
}
 
class CampaignTest: public ::testing::Test {
protected:
    static void SetUpTestCase()
    {
        TEST_Init();
 
        cl_genericPool = Mem_CreatePool("Client: Generic");
        cp_campaignPool = Mem_CreatePool("Client: Local (per game)");
        cp_missiontest = Cvar_Get("cp_missiontest", "0");
        vid_imagePool = Mem_CreatePool("Vid: Image system");
 
        r_state.active_texunit = &r_state.texunits[0];
        R_FontInit();
        CL_InitLua();
        UI_Init();
        GAME_InitStartup();
 
        OBJZERO(cls);
        Com_ParseScripts(false);
 
        Cmd_ExecuteString("game_setmode campaign");
 
        Cmd_AddCommand("msgoptions_set", Cmd_Dummy_f);
 
        CL_SetClientState(ca_disconnected);
        cls.realtime = Sys_Milliseconds();
    }
 
    static void TearDownTestCase()
    {
        CP_ResetCampaignData();
        TEST_Shutdown();
    }
 
    void SetUp()
    {
        campaign_t* campaign;
 
        CP_ResetCampaignData();
        CP_ParseCampaignData();
        campaign = GetCampaign();
        CP_ReadCampaignData(campaign);
 
        ResetInventoryList();
 
        CP_UpdateCredits(MAX_CREDITS);
 
        GEO_Shutdown();
        GEO_Init(campaign->map);
 
        ccs.curCampaign = campaign;
    }
};
 
static installation_t* CreateInstallation (const char* name, const vec2_t pos)
{
    const installationTemplate_t* installationTemplate = INS_GetInstallationTemplateByType(INSTALLATION_UFOYARD);
    installation_t* installation = INS_Build(installationTemplate, pos, name);
 
    /* fake the build time */
    installation->buildStart = ccs.date.getDateAsDays() - installation->installationTemplate->buildTime;
    INS_UpdateInstallationData();
 
    return installation;
}
 
static base_t* CreateBase (const char* name, const vec2_t pos, bool fillBase = false)
{
    const campaign_t* campaign = GetCampaign();
 
    RS_InitTree(campaign, false);
    E_InitialEmployees(campaign);
    base_t* base = B_Build(campaign, pos, name, fillBase);
 
    /* First base */
    if (ccs.campaignStats.basesBuilt == 1)
        B_SetUpFirstBase(campaign, base);
 
    return base;
}
 
TEST_F(CampaignTest, testAircraftHandling)
{
    const vec2_t destination = { 10, 10 };
    base_t* base;
    aircraft_t* aircraft;
    aircraft_t* newAircraft;
    aircraft_t* aircraftTemplate;
    int firstIdx;
    int initialCount;
    int count;
    int newFound;
 
    base = CreateBase("unittestaircraft", destination);
    ASSERT_TRUE(nullptr != base);
 
    aircraft = AIR_GetFirstFromBase(base);
    ASSERT_TRUE(nullptr != aircraft);
 
    /* aircraft should have a template */
    aircraftTemplate = aircraft->tpl;
    ASSERT_TRUE(nullptr != aircraftTemplate);
 
    firstIdx = aircraft->idx;
    initialCount = AIR_BaseCountAircraft(base);
 
    /* test deletion (part 1) */
    AIR_DeleteAircraft(aircraft);
    count = AIR_BaseCountAircraft(base);
    ASSERT_EQ(count, initialCount - 1);
 
    /* test addition (part 1) */
    newAircraft = AIR_NewAircraft(base, aircraftTemplate);
    ASSERT_TRUE(nullptr != newAircraft);
    count = AIR_BaseCountAircraft(base);
    ASSERT_EQ(count, initialCount);
 
    /* new aircraft assigned to the right base */
    ASSERT_EQ(newAircraft->homebase, base);
 
    newFound = 0;
    AIR_Foreach(a) {
        /* test deletion (part 2) */
        ASSERT_NE(firstIdx, a->idx);
        /* for test addition (part 2) */
        if (a->idx == newAircraft->idx)
            newFound++;
    }
    /* test addition (part 2) */
    ASSERT_EQ(newFound, 1);
 
    /* check if AIR_Foreach iterates through all aircraft */
    AIR_Foreach(a) {
        AIR_DeleteAircraft(a);
    }
    aircraft = AIR_GetFirstFromBase(base);
    ASSERT_TRUE(nullptr == aircraft);
    count = AIR_BaseCountAircraft(base);
    ASSERT_EQ(count, 0);
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testEmployeeHandling)
{
    int i;
 
    for (i = 0; i < MAX_EMPL; i++) {
        employeeType_t type = (employeeType_t)i;
        if (type != EMPL_ROBOT) {
            int cnt;
            Employee* e = E_CreateEmployee(type, nullptr, nullptr);
            ASSERT_TRUE(nullptr != e);
 
            cnt = E_CountUnhired(type);
            ASSERT_EQ(cnt, 1);
 
            E_DeleteEmployee(e);
 
            cnt = E_CountUnhired(type);
            ASSERT_EQ(cnt, 0);
        }
    }
 
    {
        const int amount = 3;
        for (i = 0; i < amount; i++) {
            Employee* e = E_CreateEmployee(EMPL_SOLDIER, nullptr, nullptr);
            ASSERT_TRUE(nullptr != e);
        }
        {
            int cnt = 0;
            E_Foreach(EMPL_SOLDIER, e) {
                (void)e;
                cnt++;
            }
 
            ASSERT_EQ(cnt, amount);
 
            E_Foreach(EMPL_SOLDIER, e) {
                ASSERT_TRUE(E_DeleteEmployee(e));
            }
 
            cnt = E_CountUnhired(EMPL_SOLDIER);
            ASSERT_EQ(cnt, 0);
        }
    }
 
    {
        const ugv_t* ugvType = Com_GetUGVByID("ugv_ares_w");
        Employee* e = E_CreateEmployee(EMPL_ROBOT, nullptr, ugvType);
        ASSERT_TRUE(nullptr != e);
        ASSERT_TRUE(E_DeleteEmployee(e));
    }
 
    {
        int i, cnt;
        for (i = 0; i < 512; i++) {
            Employee* e = E_CreateEmployee(EMPL_SOLDIER, nullptr, nullptr);
            ASSERT_TRUE(nullptr != e);
 
            cnt = E_CountUnhired(EMPL_SOLDIER);
            ASSERT_EQ(cnt, i + 1);
        }
        E_DeleteAllEmployees(nullptr);
 
        cnt = E_CountUnhired(EMPL_SOLDIER);
        ASSERT_EQ(cnt, 0);
    }
}
 
TEST_F(CampaignTest, testBaseBuilding)
{
    ccs.credits = 10000000;
 
    vec2_t pos = {0, 0};
    base_t* base = CreateBase("unittestcreatebase", pos);
 
    ASSERT_EQ(B_GetInstallationLimit(), MAX_INSTALLATIONS_PER_BASE);
 
    B_Destroy(base);
 
    for (int i = 0; i < MAX_EMPL; i++) {
        employeeType_t type = (employeeType_t)i;
        ASSERT_EQ(E_CountHired(base, type), 0);
    }
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testAutoMissions)
{
    const vec2_t pos = {-73.2, 18.5};
    base_t* base;
    missionResults_t result;
    battleParam_t battleParameters;
    aircraft_t* aircraft;
    mission_t* mission;
    campaign_t* campaign;
 
    campaign = GetCampaign();
    ASSERT_TRUE(campaign != nullptr);
 
    OBJZERO(result);
    OBJZERO(battleParameters);
 
    ccs.overallInterest = 36;
    INT_ResetAlienInterest();
 
    base = CreateBase("unittestautomission", pos);
    ASSERT_TRUE(nullptr != base);
 
    aircraft = nullptr;
    AIR_ForeachFromBase(a, base) {
        if (AIR_GetTeamSize(a) > 0) {
            aircraft = a;
            break;
        }
    }
    ASSERT_TRUE(nullptr != aircraft);
    ASSERT_TRUE(AIR_GetTeamSize(aircraft) > 0);
 
    mission = CP_CreateNewMission(INTERESTCATEGORY_RECON, false);
    Vector2Copy(pos, mission->pos);
    mission->posAssigned = true;
    mission->mapDef = Com_GetMapDefinitionByID("farm2");
    ASSERT_TRUE(nullptr != mission);
 
    CP_CreateBattleParameters(mission, &battleParameters, aircraft);
    AM_Go(mission, aircraft, campaign, &battleParameters, &result);
 
    ASSERT_TRUE(result.state == WON);
}
 
TEST_F(CampaignTest, testTransferItem)
{
    const campaign_t* campaign = GetCampaign();
    const vec2_t pos = {0, 0};
    const vec2_t posTarget = {51, 0};
    transfer_t tr;
 
    base_t* base = CreateBase("unittesttransferitem", pos);
    ASSERT_TRUE(nullptr != base);
    base_t* targetBase = CreateBase("unittesttransferitemtargetbase", posTarget, true);
    ASSERT_TRUE(nullptr != targetBase);
    B_SetUpFirstBase(campaign, targetBase);
 
    const objDef_t* od = INVSH_GetItemByID("assault");
    ASSERT_TRUE(nullptr != od);
 
    OBJZERO(tr);
    tr.itemCargo = new ItemCargo();
    tr.itemCargo->add(od, 1, 0);
    tr.destBase = targetBase;
    tr.itemCargo->add(od, 1, 0);
 
    transfer_t* transfer = TR_TransferStart(base, tr);
    ASSERT_TRUE(nullptr != transfer);
 
    ASSERT_EQ(LIST_Count(ccs.transfers), 1);
 
    transfer->event = ccs.date + DateTime(1, 0);
 
    /* check if it's arrived immediately */
    TR_TransferRun();
    ASSERT_FALSE(LIST_IsEmpty(ccs.transfers));
 
    /* check if it arrives (even a second) before it should */
    ccs.date += DateTime(1, -1);
    TR_TransferRun();
    ASSERT_FALSE(LIST_IsEmpty(ccs.transfers));
 
    /* check if it arrived right when it should */
    ccs.date += DateTime(0, 1);
    TR_TransferRun();
    ASSERT_TRUE(LIST_IsEmpty(ccs.transfers));
 
    /* Start another transfer to check higher time lapse */
    transfer = TR_TransferStart(base, tr);
    ASSERT_TRUE(nullptr != transfer);
    ASSERT_EQ(LIST_Count(ccs.transfers), 1);
 
    transfer->event = ccs.date + DateTime(1, 0);
 
    /* check if it arrived when time passed the deadline by days already */
    ccs.date += DateTime(2, 0);
    TR_TransferRun();
    ASSERT_TRUE(LIST_IsEmpty(ccs.transfers));
 
    /* Start another transfer to check higher time lapse */
    transfer = TR_TransferStart(base, tr);
    ASSERT_TRUE(nullptr != transfer);
    ASSERT_EQ(LIST_Count(ccs.transfers), 1);
 
    transfer->event = ccs.date + DateTime(1, 0);
 
    /* check if it arrived when time passed the deadline by days already */
    ccs.date += DateTime(1, 1);
    TR_TransferRun();
    ASSERT_TRUE(LIST_IsEmpty(ccs.transfers));
 
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
    delete tr.itemCargo;
    tr.itemCargo = nullptr;
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testUFORecovery)
{
    const vec2_t pos = {0, 0};
    const aircraft_t* ufo;
    storedUFO_t* storedUFO;
    installation_t* installation;
    DateTime date(ccs.date);
 
    ufo = AIR_GetAircraft("craft_ufo_fighter");
    ASSERT_TRUE(nullptr != ufo);
 
    CreateBase("unittestproduction", pos);
 
    installation = CreateInstallation("unittestuforecovery", pos);
 
    date += DateTime(1, 0);
    storedUFO = US_StoreUFO(ufo, installation, date, 1.0);
    ASSERT_TRUE(nullptr != storedUFO);
    ASSERT_EQ(storedUFO->status, SUFO_RECOVERED);
 
    UR_ProcessActive();
 
    ASSERT_EQ(storedUFO->status, SUFO_RECOVERED);
 
    ccs.date += DateTime(1, 0);
 
    UR_ProcessActive();
 
    ASSERT_EQ(storedUFO->status, SUFO_STORED);
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
}
 
TEST_F(CampaignTest, testAlienPSIDevice)
{
    RS_MarkResearchable(nullptr, true);
 
    technology_t* alienPsiDevice = RS_GetTechByID("rs_alien_psi_device");
    RS_MarkOneResearchable(alienPsiDevice);
    ASSERT_TRUE(alienPsiDevice->statusResearchable);
}
 
TEST_F(CampaignTest, testResearch)
{
    RS_MarkResearchable(nullptr, true);
 
    technology_t* laserTech = RS_GetTechByID("rs_laser");
    ASSERT_TRUE(nullptr != laserTech);
    technology_t* otherLaserTech = RS_GetTechByID("rs_baselaser");
    ASSERT_TRUE(nullptr != otherLaserTech);
 
    const vec2_t pos = {0, 0};
    base_t* base = CreateBase("unittestbase", pos);
 
    ASSERT_TRUE(laserTech->statusResearchable);
 
    RS_AssignScientist(laserTech, base);
 
    ASSERT_EQ(laserTech->base, base);
    ASSERT_EQ(laserTech->scientists, 1);
    ASSERT_EQ(laserTech->statusResearch, RS_RUNNING);
 
    ASSERT_FALSE(otherLaserTech->statusResearchable);
 
    const int n = laserTech->time * (1.0f / ccs.curCampaign->researchRate);
    for (int i = 0; i < n; i++) {
        const int finished = RS_ResearchRun();
        ASSERT_EQ(finished, 0) << "Did not expect to finish a research (#" << finished << ", i:" << i << ")";
    }
 
    ASSERT_EQ(laserTech->statusResearch, RS_RUNNING);
    ASSERT_EQ(RS_ResearchRun(), 1);
    ASSERT_EQ(laserTech->statusResearch, RS_FINISH);
 
    ASSERT_TRUE(otherLaserTech->statusResearchable);
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testProductionItem)
{
    const vec2_t pos = {0, 0};
    base_t* base;
    const objDef_t* od;
    const technology_t* tech;
    int old;
    int i, n;
    productionData_t data;
    production_t* prod;
 
    base = CreateBase("unittestproduction", pos);
 
    ASSERT_TRUE(B_AtLeastOneExists());
    ASSERT_TRUE(B_GetBuildingStatus(base, B_WORKSHOP));
    ASSERT_TRUE(E_CountHired(base, EMPL_WORKER) > 0);
    ASSERT_TRUE(PR_ProductionAllowed(base));
 
    od = INVSH_GetItemByID("assault");
    ASSERT_TRUE(nullptr != od);
 
    PR_SetData(&data, PRODUCTION_TYPE_ITEM, od);
    old = base->storage.numItems[od->idx];
    prod = PR_QueueNew(base, &data, 1);
    ASSERT_TRUE(nullptr != prod);
    tech = RS_GetTechForItem(od);
    n = PR_GetRemainingMinutes(prod);
    i = tech->produceTime / PR_WorkersAvailable(base);
    ASSERT_EQ(i, PR_GetRemainingHours(prod));
    for (i = 0; i < n; i++) {
        PR_ProductionRun();
    }
 
    ASSERT_EQ(old, base->storage.numItems[od->idx]);
    PR_ProductionRun();
    ASSERT_EQ(old + 1, base->storage.numItems[od->idx]);
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testProductionAircraft)
{
    const vec2_t pos = {0, 0};
    base_t* base;
    const aircraft_t* aircraft;
    int old;
    int i, n;
    productionData_t data;
    production_t* prod;
 
    base = CreateBase("unittestproduction", pos);
 
    ASSERT_TRUE(B_AtLeastOneExists());
    ASSERT_TRUE(B_GetBuildingStatus(base, B_WORKSHOP));
    ASSERT_TRUE(E_CountHired(base, EMPL_WORKER) > 0);
    ASSERT_TRUE(PR_ProductionAllowed(base));
 
    /* Check for production requirements */
    aircraft = AIR_GetAircraft("craft_inter_stingray");
    ASSERT_TRUE(nullptr != aircraft);
    PR_SetData(&data, PRODUCTION_TYPE_AIRCRAFT, aircraft);
    /* no antimatter */
    ASSERT_TRUE(nullptr == PR_QueueNew(base, &data, 1));
 
    old = CAP_GetCurrent(base, CAP_AIRCRAFT_SMALL);
    aircraft = AIR_GetAircraft("craft_inter_stiletto");
    ASSERT_TRUE(nullptr != aircraft);
    PR_SetData(&data, PRODUCTION_TYPE_AIRCRAFT, aircraft);
    prod = PR_QueueNew(base, &data, 1);
    ASSERT_TRUE(nullptr != prod);
 
    n = PR_GetRemainingMinutes(prod);
    i = aircraft->tech->produceTime / PR_WorkersAvailable(base);
    ASSERT_EQ(i, PR_GetRemainingHours(prod));
    for (i = 0; i < n; i++) {
        PR_ProductionRun();
    }
 
    ASSERT_EQ(old, CAP_GetCurrent(base, CAP_AIRCRAFT_SMALL));
    PR_ProductionRun();
    ASSERT_EQ(old + 1, CAP_GetCurrent(base, CAP_AIRCRAFT_SMALL));
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testDisassembly)
{
    const vec2_t pos = {0, 0};
    base_t* base;
    const aircraft_t* ufo;
    int old;
    int i, n;
    storedUFO_t* storedUFO;
    productionData_t data;
    installation_t* installation;
    production_t* prod;
 
    base = CreateBase("unittestproduction", pos);
 
    ASSERT_TRUE(B_AtLeastOneExists());
    ASSERT_TRUE(B_GetBuildingStatus(base, B_WORKSHOP));
    ASSERT_TRUE(E_CountHired(base, EMPL_WORKER) > 0);
    ASSERT_TRUE(PR_ProductionAllowed(base));
 
    ufo = AIR_GetAircraft("craft_ufo_fighter");
    ASSERT_TRUE(nullptr != ufo);
 
    installation = CreateInstallation("unittestproduction", pos);
 
    storedUFO = US_StoreUFO(ufo, installation, ccs.date, 1.0);
    ASSERT_TRUE(nullptr != storedUFO);
    ASSERT_EQ(storedUFO->status, SUFO_RECOVERED);
    PR_SetData(&data, PRODUCTION_TYPE_DISASSEMBLY, storedUFO);
    prod = PR_QueueNew(base, &data, 1);
    ASSERT_TRUE(nullptr != prod);
 
    old = CAP_GetCurrent(base, CAP_ITEMS);
    n = PR_GetRemainingMinutes(prod);
    i = storedUFO->comp->time / PR_WorkersAvailable(base);
    ASSERT_EQ(i, PR_GetRemainingHours(prod));
    for (i = 0; i < n; i++) {
        PR_ProductionRun();
    }
 
    ASSERT_EQ(old, CAP_GetCurrent(base, CAP_ITEMS));
    PR_ProductionRun();
    ASSERT_NE(old, CAP_GetCurrent(base, CAP_ITEMS));
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testMap)
{
    vec2_t pos;
    bool coast = false;
 
    Vector2Set(pos, -51, 0);
    ASSERT_TRUE(MapIsWater(GEO_GetColor(pos, MAPTYPE_TERRAIN, nullptr)));
 
    Vector2Set(pos, 51, 0);
    ASSERT_TRUE(!MapIsWater(GEO_GetColor(pos, MAPTYPE_TERRAIN, nullptr)));
 
    Vector2Set(pos, 20, 20);
    ASSERT_TRUE(MapIsWater(GEO_GetColor(pos, MAPTYPE_TERRAIN, nullptr)));
 
    Vector2Set(pos, -45, 2.5);
    ASSERT_TRUE(!MapIsWater(GEO_GetColor(pos, MAPTYPE_TERRAIN, &coast)));
    ASSERT_TRUE(coast);
}
 
TEST_F(CampaignTest, testAirFight)
{
    const vec2_t destination = { 10, 10 };
    /* just some random delta time value that is high enough
     * to ensure that all the weapons are reloaded */
    const int deltaTime = 1000;
 
    campaign_t* campaign = GetCampaign();
 
    base_t* base = CreateBase("unittestairfight", destination);
    ASSERT_TRUE(nullptr != base);
 
    int cnt = AIR_BaseCountAircraft(base);
    int i = 0;
    AIR_ForeachFromBase(a, base)
        i++;
    ASSERT_EQ(i, cnt);
 
    aircraft_t* aircraft = AIR_GetFirstFromBase(base);
    ASSERT_TRUE(nullptr != aircraft);
    aircraft->status = AIR_IDLE;
    ASSERT_TRUE(AIR_IsAircraftOnGeoscape(aircraft));
 
    /* ensure that a FIGHTER can spawn */
    ufoType_t ufoTypes[UFO_MAX];
    ASSERT_NE(0, UFO_GetAvailableUFOsForMission(INTERESTCATEGORY_INTERCEPT, ufoTypes, false));
    const aircraft_t* ufoTemplate = UFO_GetByType(ufoTypes[0]);     /* the first interceptor will do */
    ASSERT_TRUE(nullptr != ufoTemplate);
    ccs.overallInterest = ufoTemplate->ufoInterestOnGeoscape + 1;
 
    /* prepare the mission */
    mission_t* mission = CP_CreateNewMission(INTERESTCATEGORY_INTERCEPT, true);
    ASSERT_TRUE(nullptr != mission);
    ASSERT_EQ(mission->stage, STAGE_NOT_ACTIVE);
    CP_InterceptNextStage(mission);
    ASSERT_EQ(mission->stage, STAGE_COME_FROM_ORBIT);
    CP_InterceptNextStage(mission);
    ASSERT_EQ(mission->stage, STAGE_INTERCEPT);
    aircraft_t* ufo = mission->ufo;
    ASSERT_TRUE(nullptr != ufo);
    ufo->ufotype = ufoTypes[0];
    /* we have to update the routing data here to be sure that the ufo is
     * not spawned on the other side of the globe */
    Vector2Copy(destination, ufo->pos);
    UFO_SendToDestination(ufo, destination);
    ASSERT_TRUE(VectorEqual(ufo->pos, base->pos));
    ASSERT_TRUE(VectorEqual(ufo->pos, aircraft->pos));
 
    ASSERT_TRUE(aircraft->maxWeapons > 0);
    for (i = 0; i < aircraft->maxWeapons; i++)
        ASSERT_TRUE(aircraft->weapons[i].delayNextShot == 0);
 
    /* search a target */
    UFO_CampaignRunUFOs(campaign, deltaTime);
    ASSERT_TRUE(nullptr != ufo->aircraftTarget);
 
    /* ensure that one hit will destroy the craft */
    ufo->aircraftTarget->damage = 1;
    srand(1);
    /* don't take any pilot skill into account here */
    OBJZERO(ufo->aircraftTarget->pilot->chr.score.skills);
    UFO_CheckShootBack(campaign, ufo, ufo->aircraftTarget);
 
    /* one projectile should be spawned */
    ASSERT_EQ(ccs.numProjectiles, 1);
    AIRFIGHT_CampaignRunProjectiles(campaign, deltaTime);
    /* don't use mission pointer from here it might been removed */
 
    /* target is destroyed */
    ASSERT_TRUE(nullptr == ufo->aircraftTarget);
 
    /* one aircraft less */
    ASSERT_EQ(cnt - 1, AIR_BaseCountAircraft(base));
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testRadar)
{
    const vec2_t destination = { 10, 10 };
    ufoType_t ufoTypes[UFO_MAX];
    ASSERT_NE(0, UFO_GetAvailableUFOsForMission(INTERESTCATEGORY_INTERCEPT, ufoTypes, false));
 
    base_t* base = CreateBase("unittestradar", destination);
    mission_t* mission = CP_CreateNewMission(INTERESTCATEGORY_INTERCEPT, true);
    aircraft_t* ufo = UFO_AddToGeoscape(ufoTypes[0], destination, mission);
    Vector2Copy(destination, ufo->pos);
    UFO_SendToDestination(ufo, destination);
    ASSERT_TRUE(VectorEqual(ufo->pos, base->pos));
    ASSERT_TRUE(VectorEqual(ufo->pos, ufo->pos));
    /* to ensure that the UFOs are really detected when they are in range */
    base->radar.ufoDetectionProbability = 1.0;
    ASSERT_TRUE(RADAR_CheckUFOSensored(&base->radar, base->pos, ufo, false));
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testNation)
{
    const nation_t* nation;
    campaign_t* campaign;
 
    nation = NAT_GetNationByID("europe");
    ASSERT_TRUE(nullptr != nation);
 
    campaign = GetCampaign();
 
    NAT_HandleBudget(campaign);
}
 
TEST_F(CampaignTest, testMarket)
{
    campaign_t* campaign;
 
    campaign = GetCampaign();
 
    RS_InitTree(campaign, false);
 
    BS_InitMarket(campaign);
 
    CP_CampaignRunMarket(campaign);
}
 
TEST_F(CampaignTest, testSaveLoad)
{
    const vec2_t pos = {0, 0};
    base_t* base;
    campaign_t* campaign;
 
    campaign = GetCampaign();
 
    SAV_Init();
 
    ccs.curCampaign = campaign;
 
    Cvar_Set("save_compressed", "0");
 
    base = CreateBase("unittestbase", pos);
 
    {
        ASSERT_TRUE(base->founded);
        ASSERT_EQ(base->baseStatus, BASE_WORKING);
 
        Cmd_ExecuteString("game_quicksave");
    }
    {
        B_Destroy(base);
 
        ASSERT_EQ(base->baseStatus, BASE_DESTROYED);
 
        E_DeleteAllEmployees(nullptr);
 
        B_SetName(base, "unittestbase2");
    }
#if 0
    {
        ResetCampaignData();
 
        Cmd_ExecuteString("game_quickload");
 
        ASSERT_EQ(base->baseStatus, BASE_WORKING);
        ASSERT_STREQ(base->name, "unittestbase");
 
        B_Destroy(base);
 
        E_DeleteAllEmployees(nullptr);
    }
#endif
    base->founded = false;
}
 
TEST_F(CampaignTest, testSaveMassEmployees)
{
    campaign_t* campaign = GetCampaign();
 
    SAV_Init();
 
    ccs.curCampaign = campaign;
 
    Cvar_Set("save_compressed", "0");
 
    const vec2_t pos = {0, 0};
    base_t* base = CreateBase("unittestmassemployees", pos);
 
    nation_t* nation = NAT_GetNationByID("europe");
    ASSERT_TRUE(nullptr != nation);
 
    const int employees = 10000;
    for (int i = 0; i < employees; i++) {
        Employee* e = E_CreateEmployee(EMPL_SOLDIER, nation);
        if (CAP_GetFreeCapacity(base, CAP_EMPLOYEES) > 0) {
            ASSERT_TRUE(E_HireEmployee(base, e));
        }
    }
 
    Cmd_ExecuteString("game_quicksave");
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testLoadMassEmployees)
{
    Cmd_ExecuteString("game_quickload");
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
}
 
TEST_F(CampaignTest, testCampaignRun)
{
    const vec2_t destination = { 10, 10 };
    const int days = 10;
    const int seconds = days * DateTime::SECONDS_PER_DAY;
 
    base_t* base = CreateBase("unittestcampaignrun", destination);
 
    campaign_t* campaign = GetCampaign();
 
    RS_InitTree(campaign, false);
 
    BS_InitMarket(campaign);
 
    int startDay = ccs.date.getDateAsDays();
    for (int i = 0; i < seconds; i++) {
        ccs.gameTimeScale = 1;
        CP_CampaignRun(campaign, 1);
    }
    ASSERT_EQ(ccs.date.getDateAsDays() - startDay, days);
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testLoad)
{
    int i;
    aircraft_t* ufo;
    const char* error;
 
    ccs.curCampaign = nullptr;
    ASSERT_TRUE(SAV_GameLoad("unittest1", &error));
    ASSERT_TRUE(nullptr != ccs.curCampaign);
 
    i = 0;
    ufo = nullptr;
    while ((ufo = UFO_GetNextOnGeoscape(ufo)) != nullptr)
        i++;
 
    /* there should be one ufo on the geoscape */
    ASSERT_EQ(i, 1);
}
 
TEST_F(CampaignTest, testDateHandling)
{
    DateTime date = DateTime(300, 300);
 
    ccs.date = date;
 
    ASSERT_TRUE(date <= ccs.date);
    ASSERT_FALSE(ccs.date > date);
 
    date = DateTime(299, 310);
 
    ASSERT_TRUE(date <= ccs.date);
    ASSERT_TRUE(ccs.date > date);
 
    date = DateTime(301, 0);
 
    ASSERT_FALSE(date <= ccs.date);
    ASSERT_FALSE(ccs.date > date);
 
    date = DateTime(300, 299);
 
    ASSERT_TRUE(date <= ccs.date);
    ASSERT_TRUE(ccs.date > date);
 
    date = DateTime(300, 301);
 
    ASSERT_FALSE(date <= ccs.date);
    ASSERT_FALSE(ccs.date > date);
}
 
TEST_F(CampaignTest, testCampaignDateHandling)
{
    campaign_t* campaign;
    base_t* base;
    const vec2_t destination = { 10, 10 };
 
    base = CreateBase("unittestcampaigntime", destination);
 
    campaign = GetCampaign();
 
    RS_InitTree(campaign, false);
 
    BS_InitMarket(campaign);
 
    /* one hour till month change */
    ccs.date = DateTime(30, 23 * 60 * 60);
    ccs.gameLapse = 7;
    ccs.paid = true;
    CP_UpdateTime();
    CP_CampaignRun(campaign, 1);
    ASSERT_FALSE(ccs.paid);
    ASSERT_TRUE(CP_IsTimeStopped());
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testHospital)
{
    base_t* base;
    const vec2_t destination = { 10, 10 };
    int i, n;
 
    base = CreateBase("unittesthospital", destination);
 
    n = 0;
    /* hurt all employees */
    for (i = 0; i < MAX_EMPL; i++) {
        employeeType_t type = (employeeType_t)i;
        E_Foreach(type, employee) {
            if (!employee->isHired())
                continue;
            employee->chr.HP = employee->chr.maxHP - 10;
            n++;
        }
    }
    ASSERT_NE(n, 0);
 
    HOS_HospitalRun();
 
    for (i = 0; i < MAX_EMPL; i++) {
        employeeType_t type = (employeeType_t)i;
        E_Foreach(type, employee) {
            if (!employee->isHired())
                continue;
            ASSERT_NE(employee->chr.HP, employee->chr.maxHP - 10) << employee->chr.HP << "/" << employee->chr.maxHP;
        }
    }
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
TEST_F(CampaignTest, testBuildingConstruction)
{
    const vec2_t pos = {0, 0};
    int x, y;
    base_t* base;
    const building_t* buildingTemplate;
    building_t* entrance, *building1, *building2;
 
    /* day 0 has special meaning! */
    /* if building->startTime is 0 no buildTime checks done! */
    ccs.date += DateTime(1, 0);
    base = CreateBase("unittestbuildingconstruction1", pos);
    ASSERT_TRUE(nullptr != base);
    base = CreateBase("unittestbuildingconstruction2", pos);
    ASSERT_TRUE(nullptr != base);
 
    /* base should have exactly one building: entrance */
    ASSERT_EQ(ccs.numBuildings[base->idx], 1);
    entrance = &ccs.buildings[base->idx][0];
 
    /* try to build powerplant that is not connected */
    buildingTemplate = B_GetBuildingTemplate("building_powerplant");
    ASSERT_TRUE(nullptr != buildingTemplate);
 
    /* select position */
    x = entrance->pos[0];
    y = entrance->pos[1];
    ASSERT_EQ(entrance, base->map[y][x].building);
    if (x >= 2)
        x -= 2;
    else
        x += 2;
    /* reset blocked status if set */
    base->map[y][x].blocked = false;
    /* try to build (should fail) */
    building1 = B_BuildBuilding(base, buildingTemplate, x, y);
    ASSERT_TRUE(nullptr == building1);
 
    /* next to the entrance it should succeed */
    x = (x + entrance->pos[0]) /2;
    base->map[y][x].blocked = false;
    building1 = B_BuildBuilding(base, buildingTemplate, x, y);
    ASSERT_TRUE(nullptr != building1);
 
    /* try to build to first pos again (still fail, conecting building not ready) */
    if (x < entrance->pos[0])
        x--;
    else
        x++;
    building2 = B_BuildBuilding(base, buildingTemplate, x, y);
    ASSERT_TRUE(nullptr == building2);
    /* roll time one day before building finishes */
    ccs.date += DateTime(building1->buildTime - 1, 0);
    B_UpdateBuildingConstructions();
    /* building should be under construction */
    ASSERT_EQ(building1->buildingStatus, B_STATUS_UNDER_CONSTRUCTION);
    /* step a day */
    ccs.date += DateTime(1, 0);
    B_UpdateBuildingConstructions();
    /* building should be ready */
    ASSERT_EQ(building1->buildingStatus, B_STATUS_WORKING);
 
    /* try build other building (now it should succeed) */
    building2 = B_BuildBuilding(base, buildingTemplate, x, y);
    ASSERT_TRUE(nullptr != building2);
 
    /* try to destroy the second (should success) */
    ASSERT_TRUE(B_BuildingDestroy(building2));
    /* rebuild */
    building2 = B_BuildBuilding(base, buildingTemplate, x, y);
    ASSERT_TRUE(nullptr != building2);
 
    /* try to destroy the first (should fail) */
    ASSERT_FALSE(B_BuildingDestroy(building1));
    /* build up the second */
    ccs.date += DateTime(building2->buildTime, 0);
    B_UpdateBuildingConstructions();
    /* try to destroy the first (should fail) */
    ASSERT_FALSE(B_BuildingDestroy(building1));
    /* try to destroy the second (should succeess) */
    ASSERT_TRUE(B_BuildingDestroy(building2));
    /* try to destroy the first (should succeed) */
    ASSERT_TRUE(B_BuildingDestroy(building1));
 
    /* cleanup for the following tests */
    E_DeleteAllEmployees(nullptr);
 
    base->founded = false;
}
 
/* https://sourceforge.net/tracker/index.php?func=detail&aid=3090011&group_id=157793&atid=805242 */
TEST_F(CampaignTest, test3090011)
{
    const char* error = nullptr;
    bool success;
 
    success = SAV_GameLoad("3090011", &error);
    ASSERT_TRUE(success) << error;
}
 
static bool skipTest (const mapDef_t* md)
{
    const char* map = md->id;
    return Q_streq(map, "baseattack") || Q_streq(map, "rescue") || Q_streq(map, "alienbase");
}
 
TEST_F(CampaignTest, testTerrorMissions)
{
    int numUfoTypes;
    ufoType_t ufoTypes[UFO_MAX];
    mapDef_t* md;
    int i;
 
    /* Set overall interest level so every UFO can be used for missions */
    const short ufoIdsNum = Com_GetUfoIdsNum();
    for (i = 0; i < ufoIdsNum; i++) {
        ufoType_t ufoType = i;
        const aircraft_t* ufo = UFO_GetByType(ufoType);
 
        if (!ufo)
            continue;
 
        ccs.overallInterest = std::max(ccs.overallInterest, ufo->ufoInterestOnGeoscape);
    }
 
    /* Search without UFO */
    LIST_Foreach(ccs.cities, city_t, city) {
        mission_t mission;
        OBJZERO(mission);
        ASSERT_TRUE(CP_ChooseMap(&mission, city->pos)) << "could not find a map for city " << city->id;
    }
 
    /* Search with UFOs available for Terror missions */
    numUfoTypes = UFO_GetAvailableUFOsForMission(INTERESTCATEGORY_TERROR_ATTACK, ufoTypes, false);
    ASSERT_NE(0, numUfoTypes);
    for (i = 0; i < numUfoTypes; i++) {
        ufoType_t ufoType = i;
        mission_t mission;
        aircraft_t* ufo = UFO_AddToGeoscape(ufoTypes[ufoType], nullptr, &mission);
 
        OBJZERO(mission);
        mission.ufo = ufo;
        ASSERT_TRUE(nullptr != ufo);
        ufo->mission = &mission;
 
        LIST_Foreach(ccs.cities, city_t, city) {
            mission.mapDef = nullptr;
#ifdef TEST_BIGUFOS
            ASSERT_TRUE(CP_ChooseMap(&mission, city->pos)) << "could not find map for city " << city->id << " with ufo: " << ufo->id;
#else
            CP_ChooseMap(&mission, city->pos);
#endif
        }
 
        UFO_RemoveFromGeoscape(ufo);
    }
 
    MapDef_ForeachSingleplayerCampaign(md) {
        /* skip mapDefs that were used */
        if (md->timesAlreadyUsed > 0)
            continue;
        /* skip special mapDefs */
        if (skipTest(md))
            continue;
        /* skip mapDefs which don't support UFO types that do terror missions */
        if (!LIST_IsEmpty(md->ufos)) {
            bool found = false;
            for (i = 0; i < numUfoTypes; i++) {
                ufoType_t ufoType = i;
                const aircraft_t* ufo = UFO_GetByType(ufoTypes[ufoType]);
 
                if (!ufo)
                    continue;
 
                if (LIST_ContainsString(md->ufos, ufo->id)) {
                    found = true;
                    break;
                }
            }
            if (!found)
                continue;
        }
        ASSERT_TRUE(va("%s wasn't used", md->id));
    }
}
 
TEST_F(CampaignTest, testRandomPosMissions)
{
    const mapDef_t* md;
 
    MapDef_ForeachSingleplayerCampaign(md) {
        if (!skipTest(md)) {
            mission_t mission;
            bool result;
            OBJZERO(mission);
            result = CP_GetRandomPosOnGeoscapeWithParameters(mission.pos, md->terrains, md->cultures, md->populations, nullptr);
            ASSERT_TRUE(result) << "could not find a mission for mapdef " << md->id;
        }
    }
}
 
static bool testEventTriggerCalled;
static void testEventTrigger_f (void)
{
    testEventTriggerCalled = true;
}
 
TEST_F(CampaignTest, testEventTrigger)
{
    testEventTriggerCalled = false;
    for (int i = 0; i < 60; i++) {
        CP_TriggerEvent(NEW_DAY);
        ccs.date += DateTime(1, 0);
    }
    Cmd_AddCommand("test_eventtrigger", testEventTrigger_f);
    campaignTriggerEvent_t* event = &ccs.campaignTriggerEvents[ccs.numCampaignTriggerEvents++];
    OBJZERO(*event);
    event->active = true;
    event->type = UFO_DETECTION;
    event->id = Mem_StrDup("test_eventtrigger");
    event->command = Mem_StrDup("test_eventtrigger");
    event->require = Mem_StrDup("ufo[craft_ufo_harvester]");
    CP_TriggerEvent(UFO_DETECTION, "craft_ufo_harvester");
    ASSERT_TRUE(testEventTriggerCalled);
    testEventTriggerCalled = false;
    CP_TriggerEvent(UFO_DETECTION, "xxx");
    ASSERT_FALSE(testEventTriggerCalled);
    event->once = true;
    CP_TriggerEvent(UFO_DETECTION, "craft_ufo_harvester");
    ASSERT_TRUE(testEventTriggerCalled);
    testEventTriggerCalled = false;
    CP_TriggerEvent(UFO_DETECTION, "craft_ufo_harvester");
    ASSERT_FALSE(testEventTriggerCalled);
    --ccs.numCampaignTriggerEvents;
    Cmd_RemoveCommand("test_eventtrigger");
}
 
TEST_F(CampaignTest, testAssembleMap)
{
    const int expected = 22;
    const int maxSize = BASE_SIZE * BASE_SIZE;
    ASSERT_TRUE(maxSize >= expected);
 
    const vec2_t destination = { 10, 10 };
    base_t* base = CreateBase("unittestassemble", destination);
    ASSERT_TRUE(nullptr != base);
    char maps[2048];
    char coords[2048];
 
    ASSERT_TRUE(B_AssembleMap(maps, sizeof(maps), coords, sizeof(coords), base));
    const char* str = coords;
    int coordsAmount = 0;
    do {
        Com_Parse(&str);
        if (str != nullptr)
            ++coordsAmount;
    } while (str != nullptr);
 
    str = maps;
    int mapsAmount = 0;
    do {
        Com_Parse(&str);
        if (str != nullptr)
            ++mapsAmount;
    } while (str != nullptr);
 
    /* we have three components, x, y and z for the coordinates */
    ASSERT_EQ(coordsAmount / 3, expected) << "coords have " << coordsAmount << " entries: '" << coords << "'";
    ASSERT_EQ(mapsAmount, expected) << "maps have " << mapsAmount << " entries: '"<< maps << "'";
}
 
TEST_F(CampaignTest, testGeoscapeMaps)
{
    const char* types[] = {"terrain", "culture", "population", "nations", nullptr};
    for (int i = 0; i < ccs.numCampaigns; i++) {
        const campaign_t& c = ccs.campaigns[i];
        int refW = -1;
        int refH = -1;
 
        for (const char **t = types; *t; ++t) {
            const char *image = va("pics/geoscape/%s_%s", c.map, *t);
            SDL_Surface *surf = Img_LoadImage(image);
            ASSERT_TRUE(surf != nullptr);
            const int w = surf->w;
            const int h = surf->h;
            if (refH == -1) {
                refH = h;
                refW = w;
            }
            SDL_FreeSurface(surf);
            ASSERT_EQ(refH, h);
            ASSERT_EQ(refW, w);
        }
    }
}
 
TEST_F(CampaignTest, testAlienBaseAtStart)
{
    bool exists = AB_Exists();
    int count = AB_GetAlienBaseNumber();
    ASSERT_FALSE(exists);
    ASSERT_EQ(0, count);
}
 
TEST_F(CampaignTest, testAlienBaseBuild)
{
    const vec2_t pos = {1, -89};
 
    alienBase_t* alienBase = AB_BuildBase(pos);
 
    ASSERT_NE(nullptr, alienBase);
    ASSERT_TRUE(AB_Exists());
    ASSERT_EQ(1, AB_GetAlienBaseNumber());
    ASSERT_EQ(50.f, alienBase->stealth);
    ASSERT_EQ(0, alienBase->supply);
    ASSERT_EQ(1, alienBase->pos[0]);
    ASSERT_EQ(-89, alienBase->pos[1]);
}
 
TEST_F(CampaignTest, testAlienBaseSearchedByNationsFindBase)
{
    const vec2_t phalanxPos = {0, 0};
    base_t* base= CreateBase("PHALANX", phalanxPos, true);
    /* @TODO: We need a function to return a position within a particular nation that can
    be nullptr nation. For now this position should be around Antartica with no nation */
    const vec2_t alienPos = {0, -89};
    alienBase_t* alienBase = AB_BuildBase(alienPos);
    alienBase->stealth = 1.0f;
    alienBase->supply = 2;
 
    AB_BaseSearchedByNations();
 
    ASSERT_NE(nullptr, alienBase);
    ASSERT_GT(0.0f, alienBase->stealth);
    mission_t* mission = MIS_GetByIdx(1);
    ASSERT_NE(nullptr, mission);
    ASSERT_EQ(alienBase, mission->data.alienBase);
}