Curring magic

tests/model/Factory.h

@@ -0,0 +1,104 @@
+//
+// Created by stani on 3/10/2025.
+//
+
+#ifndef FACTORY_H
+#define FACTORY_H
+#include <memory>
+#include "../../src/model/Building.h"
+#include "../../src/model/Community.h"
+#include "../../src/model/Energy_Tariff.h"
+
+namespace Building
+{
+    class Cost;
+}
+
+class Factory {
+    public:
+    std::unique_ptr<Building::Cost> static create_test_cost() {
+        auto cost = std::make_unique<Building::Cost>();
+        cost->set_special_rate_consumption(0.15f);
+        cost->set_special_rate_generation(0.10f);
+        return cost;
+    }
+
+    std::unique_ptr<Building::Simulation_Values> static create_test_simulation_values() {
+        auto values = std::make_unique<Building::Simulation_Values>();
+
+        auto communityCoverage = std::vector<std::unique_ptr<float>>();
+        auto ownUsage = std::vector<std::unique_ptr<float>>();
+        auto neededCon = std::vector<std::unique_ptr<float>>();
+        auto neededGen = std::vector<std::unique_ptr<float>>();
+
+        for (int i = 0; i < 5; i++) { // Populate with test values
+            communityCoverage.push_back(std::make_unique<float>(i * 10.0f));
+            ownUsage.push_back(std::make_unique<float>(i * 5.0f));
+            neededCon.push_back(std::make_unique<float>(i * 3.0f));
+            neededGen.push_back(std::make_unique<float>(i * 2.0f));
+        }
+
+        values->set_community_coverage(std::move(communityCoverage));
+        values->set_own_usage(std::move(ownUsage));
+        values->set_needed_con(std::move(neededCon));
+        values->set_needed_gen(std::move(neededGen));
+
+        return values;
+    }
+
+    std::unique_ptr<Building::Metadata> static create_test_metadata() {
+        auto metadata = std::make_unique<Building::Metadata>();
+        metadata->set_name("Test Building");
+        metadata->set_annual_consumption(12000.0f);
+        metadata->set_annual_generation(5000.0f);
+        metadata->set_consumption_profile_name("Profile_1");
+        metadata->set_generation_profile_name("Profile_2");
+        metadata->set_connection_power(100);
+        metadata->set_grid_power(50);
+
+        auto consumptionProfile = std::vector<std::unique_ptr<float>>();
+        auto generationProfile = std::vector<std::unique_ptr<float>>();
+
+        for (int i = 0; i < 5; i++) { // Populate with test values
+            consumptionProfile.push_back(std::make_unique<float>(i * 100.0f));
+            generationProfile.push_back(std::make_unique<float>(i * 50.0f));
+        }
+
+        metadata->set_consumption_profile(std::move(consumptionProfile));
+        metadata->set_generation_profile(std::move(generationProfile));
+
+        return metadata;
+    }
+
+     std::unique_ptr<Building::Base> static create_test_building() {
+        auto building = std::make_unique<Building::Base>();
+
+        building->set_cost( create_test_cost());
+        building->set_values(create_test_simulation_values());
+        building->set_metadata(create_test_metadata());
+
+        return building;
+    }
+    Energy_Tariff static create_test_energy_tariff() {
+        return {};
+    }
+    std::unique_ptr<Community> static create_test_community() {
+        auto community = std::make_unique<Community>();
+        community->set_name("Test Community");
+
+        std::vector<std::unique_ptr<Building::Base>> buildings;
+        for (int i = 0; i < 3; i++) {
+            buildings.push_back(create_test_building());
+        }
+
+        community->set_buildings(std::move(buildings));
+        community->set_energy_tariff(create_test_energy_tariff());
+
+        return community;
+    }
+
+};
+
+
+
+#endif //FACTORY_H

tests/services/test_Surplus.cpp

@@ -2,8 +2,13 @@
 // Created by StanislausCichocki on 10.03.2025.
 //
 #define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
+#include "../../src/services/Surplus.h"
 #include "doctest/doctest.h"
+#include "../model/Factory.h"
 
 TEST_CASE("Testing add function") {
+ std::vector<std::unique_ptr<Community>> communities;
+ communities.push_back(Factory::create_test_community());
+ Surplus::CalculateSurplus(communities);
  CHECK(true);
 }