diff --git a/helpers/README.md b/helpers/README.md new file mode 100644 index 0000000..b451b0a --- /dev/null +++ b/helpers/README.md @@ -0,0 +1,33 @@ +# Helpers & Utilities + +Outils et utilitaires partagés pour le développement Warfactory. + +## Build & Development +- **CMake helpers** : Scripts pour configuration build multi-platform +- **Build scripts** : Automatisation compilation engines +- **Dependencies** : Gestion librairies externes (OpenGL, networking, etc.) + +## Testing & Debug +- **Test utilities** : Helpers pour tests unitaires engines +- **Debug tools** : Profiling, monitoring performance +- **Mock engines** : Engines factices pour tests + +## Data & Configuration +- **Config generators** : Scripts génération configurations +- **Data converters** : Outils conversion formats données +- **Migration scripts** : Scripts migration database/formats + +## Engine Utilities +- **Communication helpers** : Utilities inter-engine communication +- **Redis helpers** : Wrappers Redis pour patterns communs +- **Performance monitoring** : Tools mesure performance engines + +## Documentation +- **Doc generators** : Scripts génération documentation +- **Architecture validators** : Vérification cohérence architecture +- **Metrics calculators** : Calculs métriques projet + +## Deployment +- **Docker configs** : Containerisation engines +- **CI/CD scripts** : Automation deployment +- **Environment setup** : Scripts setup dev environment \ No newline at end of file diff --git a/tests/README.md b/tests/README.md new file mode 100644 index 0000000..a89daaa --- /dev/null +++ b/tests/README.md @@ -0,0 +1,66 @@ +# Engine API Tests + +Tests API pour chaque engine autonome de Warfactory. + +## Structure +Chaque engine a son dossier de tests pour validation de l'API et communication inter-engine. + +### Factory Engine Tests +- **Production API** : Tests cycles production, belts, assemblers +- **Input/Output** : Validation flux materials +- **Performance** : Tests 60fps, optimisation +- **Integration** : Communication avec Logistic/Economy Engines + +### Economy Engine Tests +- **Market API** : Tests pricing, supply/demand +- **Geopolitical** : Impact événements sur marchés +- **Multi-region** : Tests marchés segmentés +- **Integration** : Communication avec Factory/MacroEntity Engines + +### War Engine Tests +- **Combat API** : Tests auto-battler, multi-chunk battles +- **Thermics** : Validation gestion température/munitions +- **Frontlines** : Tests frontlines persistantes +- **Integration** : Communication avec Operation/Intelligence Engines + +### Designer Engine Tests +- **Design API** : Tests création véhicules (1-2/tick globally) +- **Blueprints** : Tests cultural blueprints, évolution designs +- **Validation** : Tests contraintes, composants +- **Integration** : Communication avec Economy/War Engines + +### MacroEntity Engine Tests +- **Company API** : Tests features companies, administration points +- **Diplomacy** : Tests relations, sanctions, embargos +- **Administration** : Tests pool quotidien (1000 pts/jour) +- **Integration** : Communication avec Economy/Operation Engines + +### Map Engine Tests +- **Generation API** : Tests génération procédurale (218 éléments) +- **Chunks** : Tests streaming 64x64, FOW granularité +- **Discovery** : Tests système découverte stratifié +- **Integration** : Communication avec War/Intelligence Engines + +### Intelligence Engine Tests +- **Metrics API** : Tests collecte 3.1GB adaptive, scaling multiplayer +- **Reconnaissance** : Tests satellite intelligence, FOW +- **Analytics** : Tests analyse rapports combat +- **Integration** : Communication avec tous engines + +### Operation Engine Tests +- **Strategy API** : Tests AI generals, planning opérations +- **Learning** : Tests adaptation ML, évolution doctrines +- **Decision** : Tests analyse situation complexe +- **Integration** : Communication avec War/Intelligence Engines + +### Logistic Engine Tests +- **Transport API** : Tests convois, routes, supply chains +- **Infrastructure** : Tests vulnérabilités, sécurisation +- **Optimization** : Tests optimisation routes +- **Integration** : Communication avec Factory/Economy Engines + +### Event Engine Tests +- **Events API** : Tests breakthrough system, événements globaux +- **Breakthrough** : Tests scrap analysis, déclenchement techs +- **Scheduling** : Tests event queue, timing +- **Integration** : Communication avec tous engines (dispatch) \ No newline at end of file diff --git a/tests/designer/test_design_api.cpp b/tests/designer/test_design_api.cpp new file mode 100644 index 0000000..5faf83c --- /dev/null +++ b/tests/designer/test_design_api.cpp @@ -0,0 +1,53 @@ +#include +#include "designer-engine/DesignerEngine.h" + +using namespace Warfactory::Designer; + +class DesignerEngineAPITest : public ::testing::Test { +protected: + void SetUp() override { + engine = std::make_unique(); + ASSERT_TRUE(engine->initialize()); + } + + void TearDown() override { + engine->shutdown(); + } + + std::unique_ptr engine; +}; + +TEST_F(DesignerEngineAPITest, GlobalDesignRate) { + // Test 1-2 designs globally per tick (not per company) + auto design1 = engine->createDesign("tank"); + auto design2 = engine->createDesign("apc"); + + // Should not exceed global rate limit + EXPECT_LE(engine->getDesignRate(), 2.0); +} + +TEST_F(DesignerEngineAPITest, DesignEvolution) { + // Test evolution vs creation from scratch (T-72 → T-80 → T-90) + auto baseDesign = engine->createDesign("T-72"); + ASSERT_NE(baseDesign, nullptr); + + // TODO: Test evolution to T-80 based on T-72 + // TODO: Verify evolved design inherits base characteristics +} + +TEST_F(DesignerEngineAPITest, ComponentValidation) { + // Test design validation with constraints + auto design = engine->createDesign("custom_tank"); + + // TODO: Add components to grid + // TODO: Test validation fails for invalid configurations + // TODO: Test validation passes for valid configurations + + engine->validateDesign(*design); +} + +TEST_F(DesignerEngineAPITest, CulturalBlueprints) { + // Test cultural blueprints influence design generation + // TODO: Set cultural preferences (Soviet, NATO, etc.) + // TODO: Verify designs match cultural characteristics +} \ No newline at end of file diff --git a/tests/factory/test_production_api.cpp b/tests/factory/test_production_api.cpp new file mode 100644 index 0000000..a58bd14 --- /dev/null +++ b/tests/factory/test_production_api.cpp @@ -0,0 +1,47 @@ +#include +#include "factory/FactoryEngine.h" + +using namespace Warfactory::Factory; + +class FactoryEngineAPITest : public ::testing::Test { +protected: + void SetUp() override { + engine = std::make_unique(); + ASSERT_TRUE(engine->initialize()); + } + + void TearDown() override { + engine->shutdown(); + } + + std::unique_ptr engine; +}; + +TEST_F(FactoryEngineAPITest, ProductionLineCreation) { + // Test creation of production line + engine->startProduction(); + + // Verify production starts correctly + EXPECT_GT(engine->getTickRate(), 0.0); + EXPECT_EQ(engine->getActiveLines(), 0); // No lines added yet +} + +TEST_F(FactoryEngineAPITest, PerformanceTargets) { + // Test 60fps target + engine->startProduction(); + + // Should maintain target tick rate + EXPECT_NEAR(engine->getTickRate(), 60.0, 5.0); +} + +TEST_F(FactoryEngineAPITest, InputOutputFlow) { + // Test material flow between production stages + // TODO: Implement production line with inputs/outputs + // TODO: Verify materials flow correctly through belts +} + +TEST_F(FactoryEngineAPITest, IntegrationWithLogistic) { + // Test communication with Logistic Engine + // TODO: Mock logistic engine + // TODO: Test material requests/deliveries +} \ No newline at end of file diff --git a/tests/intelligence/test_metrics_api.cpp b/tests/intelligence/test_metrics_api.cpp new file mode 100644 index 0000000..aa2fe2f --- /dev/null +++ b/tests/intelligence/test_metrics_api.cpp @@ -0,0 +1,68 @@ +#include +#include "intelligence-engine/IntelligenceEngine.h" + +using namespace Warfactory::Intelligence; + +class IntelligenceEngineAPITest : public ::testing::Test { +protected: + void SetUp() override { + engine = std::make_unique(); + ASSERT_TRUE(engine->initialize()); + } + + void TearDown() override { + engine->shutdown(); + } + + std::unique_ptr engine; +}; + +TEST_F(IntelligenceEngineAPITest, AdaptiveMetricsScaling) { + // Test adaptive scaling: 2 pts/min (1 company) → 0.4 pts/min (5 companies) + + // Single company: full metrics + engine->adjustScalingForMultiplayer(1); + // TODO: Verify high granularity metrics collection + + // Multiple companies: scaled down metrics + engine->adjustScalingForMultiplayer(5); + // TODO: Verify reduced granularity but same total volume +} + +TEST_F(IntelligenceEngineAPITest, MetricsVolume) { + // Test 3.1GB metrics per game with database storage (not RAM) + int companyId = 1; + std::string testData = "production_data_sample"; + + engine->collectMetrics(companyId, testData); + engine->pushMetricsToDatabase(); + + // TODO: Verify data pushed to database, not held in RAM + // TODO: Verify total volume tracking toward 3.1GB target +} + +TEST_F(IntelligenceEngineAPITest, SatelliteIntelligence) { + // Test progressive satellite reconnaissance levels + int x = 100, y = 100; + + // Basic level: buildings detection + engine->updateSatelliteIntel(x, y, "buildings"); + auto intel1 = engine->getIntelligence(1, x, y); + + // Advanced level: company-specific factories + engine->updateSatelliteIntel(x, y, "company_specific"); + auto intel2 = engine->getIntelligence(1, x, y); + + // TODO: Verify intel2 contains more detailed information than intel1 +} + +TEST_F(IntelligenceEngineAPITest, FOWChunkGranularity) { + // Test FOW at chunk level (ultra-light implementation) + int companyId = 1; + int chunkX = 5, chunkY = 7; + + engine->setChunkVisibility(companyId, chunkX, chunkY, true); + + // TODO: Verify visibility stored efficiently (~1 bit per chunk) + // TODO: Test memory footprint is minimal +} \ No newline at end of file diff --git a/tests/map/test_generation_api.cpp b/tests/map/test_generation_api.cpp new file mode 100644 index 0000000..f06163f --- /dev/null +++ b/tests/map/test_generation_api.cpp @@ -0,0 +1,56 @@ +#include +#include "map-engine/MapEngine.h" + +using namespace Warfactory::Map; + +class MapEngineAPITest : public ::testing::Test { +protected: + void SetUp() override { + engine = std::make_unique(); + ASSERT_TRUE(engine->initialize()); + } + + void TearDown() override { + engine->shutdown(); + } + + std::unique_ptr engine; +}; + +TEST_F(MapEngineAPITest, ChunkGeneration) { + // Test 64x64 chunk generation with 1m×1m tiles + auto chunk = engine->getChunk(0, 0); + ASSERT_NE(chunk, nullptr); + + // TODO: Verify chunk size 64x64 + // TODO: Verify tile resolution 1m×1m +} + +TEST_F(MapEngineAPITest, ProceduralElements) { + // Test 218 procedural elements with budget -10 to +10 + engine->generateTerrain(0, 0); + + // TODO: Verify terrain contains elements from the 218 available + // TODO: Verify budget calculation within -10 to +10 range + // TODO: Test distribution follows bell curve (30% neutral, 40% ±1-3, etc.) +} + +TEST_F(MapEngineAPITest, FOWGranularity) { + // Test FOW at chunk granularity (ultra-light ~1 bit per chunk) + int companyId = 1; + std::vector> visibleChunks = {{0,0}, {1,0}, {0,1}}; + + engine->updateFOW(companyId, visibleChunks); + + EXPECT_TRUE(engine->isChunkVisible(companyId, 0, 0)); + EXPECT_FALSE(engine->isChunkVisible(companyId, 5, 5)); // Not in visible list +} + +TEST_F(MapEngineAPITest, MemoryOptimization) { + // Test automatic chunk unloading for memory optimization + auto chunk1 = engine->getChunk(0, 0); + auto chunk2 = engine->getChunk(10, 10); + + // TODO: Trigger memory optimization + // TODO: Verify unused chunks are unloaded +} \ No newline at end of file diff --git a/tests/war/test_combat_api.cpp b/tests/war/test_combat_api.cpp new file mode 100644 index 0000000..5d90617 --- /dev/null +++ b/tests/war/test_combat_api.cpp @@ -0,0 +1,55 @@ +#include +#include "war/WarEngine.h" + +using namespace Warfactory::War; + +class WarEngineAPITest : public ::testing::Test { +protected: + void SetUp() override { + engine = std::make_unique(); + ASSERT_TRUE(engine->initialize()); + } + + void TearDown() override { + engine->shutdown(); + } + + std::unique_ptr engine; +}; + +TEST_F(WarEngineAPITest, BattleCreation) { + // Test multi-chunk battle creation + std::vector chunks = {1, 2, 3, 4}; // Multi-chunk battle + engine->createBattle("test_battle", chunks); + + EXPECT_EQ(engine->getActiveBattles(), 1); +} + +TEST_F(WarEngineAPITest, AutoBattlerControl) { + // Test auto-battler functionality + std::vector chunks = {1}; + engine->createBattle("auto_battle", chunks); + + engine->enableAutoBattler("auto_battle"); + engine->setPlayerOversight("auto_battle", true); + + // Should allow player oversight while auto-battling + EXPECT_EQ(engine->getActiveBattles(), 1); +} + +TEST_F(WarEngineAPITest, ThermalManagement) { + // Test automatic thermal management (fire & scoot) + // TODO: Create units with thermal properties + // TODO: Verify automatic retreat/advance on overheating +} + +TEST_F(WarEngineAPITest, PerformanceWith500Units) { + // Test performance target: 500 units simultaneous + std::vector chunks = {1, 2, 3}; + engine->createBattle("large_battle", chunks); + + // TODO: Add 500 units to battle + // TODO: Verify 60fps maintained + + EXPECT_GE(engine->getTickRate(), 55.0); // Allow some tolerance +} \ No newline at end of file