15945857949

Committed 22 Jun 2025 09:47PM UTC coverage: 94.151%. Remained the same

Build # 15945857949

Build Type

push

github

Committed by

web-flow

Commit Message

Update commons and simplify (#730)

* Update to draft commons.

* Build fixes.

* Strip redundant conversions to path

* Correct tests for on linux

* Try another folder that's blocked.

* Use draft fronter

* Update to merged

Run Details

315 of 316 new or added lines in 40 files covered. (99.68%)

200 existing lines in 6 files now uncovered.

21826 of 23182 relevant lines covered (94.15%)

57153.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.68

/src/mappers/world/world_mapper_builder_tests.cpp

#include <external/commonItems/external/googletest/googlemock/include/gmock/gmock-matchers.h>
#include <external/commonItems/external/googletest/googletest/include/gtest/gtest.h>
#include <external/fmt/include/fmt/format.h>

#include <string>

#include "src/mappers/world/world_mapper_builder.h"



constexpr float kTolerance = 0.0001F;

namespace mappers
{

TEST(MappersWorldWorldMapperBuilderTests, NullBuilderOutputsNull)
{
   const auto nullMapper = WorldMapperBuilder::CreateNullMapper().Build();

   EXPECT_TRUE(nullMapper.country_mapper.GetCountryMappings().empty());
   EXPECT_TRUE(nullMapper.province_mapper.GetHoi4ToVic3ProvinceMappings().empty());
   EXPECT_TRUE(nullMapper.province_mapper.GetVic3ToHoi4ProvinceMappings().empty());
   EXPECT_TRUE(nullMapper.tech_mapper.empty());
   std::vector<vic3::Building> buildings{
       {"building_iron_mine", 1, 1.0F, 1.0F, {}},
   };
   EXPECT_NEAR(nullMapper.resource_mapper.CalculateScore("steel", buildings), 0.0F, kTolerance);
   EXPECT_NEAR(nullMapper.resource_mapper.CalculateScore("oil", buildings), 0.0F, kTolerance);
}

TEST(MappersWorldWorldMapperBuilderTests, DefaultBuilderOutputsDefaults)
{
   const vic3::World world(vic3::WorldOptions({.countries = {
                                                   {1, vic3::Country({.number = 1, .tag = "Z00"})},
                                               }}));
   const auto worldMapper =
       WorldMapperBuilder::CreateDefaultMapper(commonItems::ModFilesystem("test_files/hoi4_world", {}), world).Build();

   EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(1).value(), "Z00");
   EXPECT_EQ(worldMapper.province_mapper.GetVic3ToHoi4ProvinceMapping("x002000").at(0), 2);
   EXPECT_THAT(worldMapper.tech_mapper.at(0).GetTechs(),
       testing::UnorderedElementsAre("dest_tech_one", "dest_tech_two"));
}

TEST(MappersWorldWorldMapperBuilderTests, LoadResourceMappingWorks)
{
   const vic3::World world(vic3::WorldOptions({.countries = {
                                                   {1, vic3::Country({.number = 1, .tag = "Z00"})},
                                               }}));
   auto builder =
       WorldMapperBuilder::CreateDefaultMapper(commonItems::ModFilesystem("test_files/hoi4_world", {}), world);
   builder.LoadResourceMapper("test_files/configurables/resource_mappings.txt");

   const auto worldMapper = builder.Build();
   std::vector<vic3::Building> buildings{
       {"building_iron_mine", 1, 1.0F, 1.0F, {}},
       {"building_oil_rig", 1, 0.8F, 1.0F, {}},
       {"building_coal_mine", 1, 0.2F, 1.0F, {}},
       {"building_steel_factory", 1, 0.8F, 1.0F, {}},
   };
   EXPECT_NEAR(worldMapper.resource_mapper.CalculateScore("steel", buildings), 1.1F, kTolerance);
   EXPECT_NEAR(worldMapper.resource_mapper.CalculateScore("oil", buildings), 0.48F, kTolerance);
   EXPECT_NEAR(worldMapper.resource_mapper.CalculateScore("tungsten", buildings), 0.0F, kTolerance);
}

TEST(MappersWorldWorldMapperBuilderTests, DefaultCountryWorks)
{
   const vic3::World world(vic3::WorldOptions({.countries = {
                                                   {1, vic3::Country({.number = 1, .tag = "Z00"})},
                                               }}));
   const auto worldMapper = WorldMapperBuilder::CreateNullMapper().DefaultCountryMapper(world).Build();

   EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(1).value(), "Z00");
}

TEST(MappersWorldWorldMapperBuilderTests, AddCountryWorks)
{
   const auto worldMapper =
       WorldMapperBuilder::CreateNullMapper().AddCountries({{1, "ONE"}}).AddCountries({{2, "TWO"}}).Build();

   EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(1).value(), "ONE");
   EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(2).value(), "TWO");
}

TEST(MappersWorldWorldMapperBuilderTests, AddProvincesWorks)
{
   const auto worldMapper =
       WorldMapperBuilder::CreateNullMapper().AddProvinces({{"x00000001", 10}, {"x00000002", 20}}).Build();

   EXPECT_THAT(worldMapper.province_mapper.GetVic3ToHoi4ProvinceMapping("x00000002"), testing::ElementsAre(20));
   EXPECT_THAT(worldMapper.province_mapper.GetHoi4ToVic3ProvinceMapping(10), testing::ElementsAre("x00000001"));
}

TEST(MappersWorldWorldMapperBuilderTests, AddTestProvincesWorks)
{
   const auto worldMapper = WorldMapperBuilder::CreateNullMapper().AddTestProvinces(2).Build();

   EXPECT_THAT(worldMapper.province_mapper.GetVic3ToHoi4ProvinceMapping("x000001"), testing::ElementsAre(10));
   EXPECT_THAT(worldMapper.province_mapper.GetHoi4ToVic3ProvinceMapping(20), testing::ElementsAre("x000002"));
}

TEST(MappersWorldWorldMapperBuilderTests, AddTechsWorks)
{
   const auto worldMapper = WorldMapperBuilder::CreateNullMapper()
                                .AddTechs({{{"vicTech1"}, std::nullopt, {"hoiTech1", "hoiTech2"}}})
                                .Build();

   EXPECT_THAT(worldMapper.tech_mapper.at(0).GetTechs(), testing::UnorderedElementsAre("hoiTech1", "hoiTech2"));
   EXPECT_THAT(worldMapper.tech_mapper.at(0).GetVic3Requirements(), testing::UnorderedElementsAre("vicTech1"));
}

TEST(MappersWorldWorldMapperBuilderTests, DefaultTechsWorks)
{
   const auto worldMapper = WorldMapperBuilder::CreateNullMapper().DefaultTechMapper().Build();

   EXPECT_THAT(worldMapper.tech_mapper.at(0).GetTechs(),
       testing::UnorderedElementsAre("dest_tech_one", "dest_tech_two"));
   EXPECT_THAT(worldMapper.tech_mapper.at(0).GetVic3Requirements(), testing::UnorderedElementsAre("source_tech"));
}

TEST(MappersWorldWorldMapperBuilderTests, AddCultureGraphicsMapperWorks)
{
   vic3::CultureDefinition culture = vic3::CultureDefinition("culture_a", {}, {}, {});
   mappers::GraphicsBlock graphics{.graphical_culture = "graphical_culture_a"};
   mappers::CultureGraphicsMapping mapping{
       .cultures = {culture.GetName()},
       .graphics_block = graphics,
   };
   CultureGraphicsMapper cultureGraphicsMapper = CultureGraphicsMapper({mapping});
   const auto worldMapper =
       WorldMapperBuilder::CreateNullMapper().SetCultureGraphicsMapper(cultureGraphicsMapper).Build();

   EXPECT_EQ(worldMapper.culture_graphics_mapper.MatchCultureToGraphics(culture).graphical_culture,
       "graphical_culture_a");
}

TEST(MappersWorldWorldMapperBuilderTests, DefaultCultureGraphicsMapperWorks)
{
   vic3::CultureDefinition culture = vic3::CultureDefinition("culture_1", {}, {}, {});
   const auto worldMapper = WorldMapperBuilder::CreateNullMapper().DefaultCultureGraphicsMapper().Build();

   EXPECT_EQ(worldMapper.culture_graphics_mapper.MatchCultureToGraphics(culture).graphical_culture, "asian_gfx");
}

TEST(MappersWorldWorldMapperBuilderTests, CopyToVicWorldCopiesProvinces)
{
   auto worldMapper = std::move(WorldMapperBuilder::CreateNullMapper().AddTestProvinces(3));
   auto worldBuilder = vic3::WorldBuilder::CreateNullWorld();
   worldMapper.CopyToVicWorld(worldBuilder);
   auto world = worldBuilder.Build();
   EXPECT_EQ(world.GetProvinceDefinitions().GetProvinceDefinitions().size(), 3);
}

}  // namespace mappers

1	#include <external/commonItems/external/googletest/googlemock/include/gmock/gmock-matchers.h>
2	#include <external/commonItems/external/googletest/googletest/include/gtest/gtest.h>
3	#include <external/fmt/include/fmt/format.h>
4
5	#include <string>
6
7	#include "src/mappers/world/world_mapper_builder.h"
8
9
10
11	constexpr float kTolerance = 0.0001F;
12
13	namespace mappers
14	{
15
16	TEST(MappersWorldWorldMapperBuilderTests, NullBuilderOutputsNull)	4✔
17	{
18	const auto nullMapper = WorldMapperBuilder::CreateNullMapper().Build();	1✔
19
20	EXPECT_TRUE(nullMapper.country_mapper.GetCountryMappings().empty());	1✔
21	EXPECT_TRUE(nullMapper.province_mapper.GetHoi4ToVic3ProvinceMappings().empty());	1✔
22	EXPECT_TRUE(nullMapper.province_mapper.GetVic3ToHoi4ProvinceMappings().empty());	1✔
23	EXPECT_TRUE(nullMapper.tech_mapper.empty());	1✔
24	std::vector<vic3::Building> buildings{
UNCOV 25	{"building_iron_mine", 1, 1.0F, 1.0F, {}},	×
26	};	3✔
27	EXPECT_NEAR(nullMapper.resource_mapper.CalculateScore("steel", buildings), 0.0F, kTolerance);	1✔
28	EXPECT_NEAR(nullMapper.resource_mapper.CalculateScore("oil", buildings), 0.0F, kTolerance);	1✔
29	}	3✔
30
31	TEST(MappersWorldWorldMapperBuilderTests, DefaultBuilderOutputsDefaults)	4✔
32	{
33	const vic3::World world(vic3::WorldOptions({.countries = {	1✔
34	{1, vic3::Country({.number = 1, .tag = "Z00"})},	1✔
35	}}));	1✔
36	const auto worldMapper =
37	WorldMapperBuilder::CreateDefaultMapper(commonItems::ModFilesystem("test_files/hoi4_world", {}), world).Build();	1✔
38
39	EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(1).value(), "Z00");	1✔
40	EXPECT_EQ(worldMapper.province_mapper.GetVic3ToHoi4ProvinceMapping("x002000").at(0), 2);	1✔
41	EXPECT_THAT(worldMapper.tech_mapper.at(0).GetTechs(),	1✔
42	testing::UnorderedElementsAre("dest_tech_one", "dest_tech_two"));	1✔
43	}	5✔
44
45	TEST(MappersWorldWorldMapperBuilderTests, LoadResourceMappingWorks)	4✔
46	{
47	const vic3::World world(vic3::WorldOptions({.countries = {	1✔
48	{1, vic3::Country({.number = 1, .tag = "Z00"})},	1✔
49	}}));	1✔
50	auto builder =
51	WorldMapperBuilder::CreateDefaultMapper(commonItems::ModFilesystem("test_files/hoi4_world", {}), world);	1✔
52	builder.LoadResourceMapper("test_files/configurables/resource_mappings.txt");	1✔
53
54	const auto worldMapper = builder.Build();	1✔
55	std::vector<vic3::Building> buildings{
UNCOV 56	{"building_iron_mine", 1, 1.0F, 1.0F, {}},	×
UNCOV 57	{"building_oil_rig", 1, 0.8F, 1.0F, {}},	×
UNCOV 58	{"building_coal_mine", 1, 0.2F, 1.0F, {}},	×
UNCOV 59	{"building_steel_factory", 1, 0.8F, 1.0F, {}},	×
60	};	5✔
61	EXPECT_NEAR(worldMapper.resource_mapper.CalculateScore("steel", buildings), 1.1F, kTolerance);	1✔
62	EXPECT_NEAR(worldMapper.resource_mapper.CalculateScore("oil", buildings), 0.48F, kTolerance);	1✔
63	EXPECT_NEAR(worldMapper.resource_mapper.CalculateScore("tungsten", buildings), 0.0F, kTolerance);	1✔
64	}	7✔
65
66	TEST(MappersWorldWorldMapperBuilderTests, DefaultCountryWorks)	4✔
67	{
68	const vic3::World world(vic3::WorldOptions({.countries = {	1✔
69	{1, vic3::Country({.number = 1, .tag = "Z00"})},	1✔
70	}}));	1✔
71	const auto worldMapper = WorldMapperBuilder::CreateNullMapper().DefaultCountryMapper(world).Build();	1✔
72
73	EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(1).value(), "Z00");	1✔
74	}	5✔
75
76	TEST(MappersWorldWorldMapperBuilderTests, AddCountryWorks)	4✔
77	{
78	const auto worldMapper =
79	WorldMapperBuilder::CreateNullMapper().AddCountries({{1, "ONE"}}).AddCountries({{2, "TWO"}}).Build();	5✔
80
81	EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(1).value(), "ONE");	1✔
82	EXPECT_EQ(worldMapper.country_mapper.GetHoiTag(2).value(), "TWO");	1✔
83	}	3✔
84
85	TEST(MappersWorldWorldMapperBuilderTests, AddProvincesWorks)	4✔
86	{
87	const auto worldMapper =
88	WorldMapperBuilder::CreateNullMapper().AddProvinces({{"x00000001", 10}, {"x00000002", 20}}).Build();	4✔
89
90	EXPECT_THAT(worldMapper.province_mapper.GetVic3ToHoi4ProvinceMapping("x00000002"), testing::ElementsAre(20));	1✔
91	EXPECT_THAT(worldMapper.province_mapper.GetHoi4ToVic3ProvinceMapping(10), testing::ElementsAre("x00000001"));	1✔
92	}	2✔
93
94	TEST(MappersWorldWorldMapperBuilderTests, AddTestProvincesWorks)	4✔
95	{
96	const auto worldMapper = WorldMapperBuilder::CreateNullMapper().AddTestProvinces(2).Build();	1✔
97
98	EXPECT_THAT(worldMapper.province_mapper.GetVic3ToHoi4ProvinceMapping("x000001"), testing::ElementsAre(10));	1✔
99	EXPECT_THAT(worldMapper.province_mapper.GetHoi4ToVic3ProvinceMapping(20), testing::ElementsAre("x000002"));	1✔
100	}	1✔
101
102	TEST(MappersWorldWorldMapperBuilderTests, AddTechsWorks)	4✔
103	{
104	const auto worldMapper = WorldMapperBuilder::CreateNullMapper()	1✔
105	.AddTechs({{{"vicTech1"}, std::nullopt, {"hoiTech1", "hoiTech2"}}})	6✔
106	.Build();	1✔
107
108	EXPECT_THAT(worldMapper.tech_mapper.at(0).GetTechs(), testing::UnorderedElementsAre("hoiTech1", "hoiTech2"));	1✔
109	EXPECT_THAT(worldMapper.tech_mapper.at(0).GetVic3Requirements(), testing::UnorderedElementsAre("vicTech1"));	1✔
110	}	6✔
111
112	TEST(MappersWorldWorldMapperBuilderTests, DefaultTechsWorks)	4✔
113	{
114	const auto worldMapper = WorldMapperBuilder::CreateNullMapper().DefaultTechMapper().Build();	1✔
115
116	EXPECT_THAT(worldMapper.tech_mapper.at(0).GetTechs(),	1✔
117	testing::UnorderedElementsAre("dest_tech_one", "dest_tech_two"));	1✔
118	EXPECT_THAT(worldMapper.tech_mapper.at(0).GetVic3Requirements(), testing::UnorderedElementsAre("source_tech"));	1✔
119	}	1✔
120
121	TEST(MappersWorldWorldMapperBuilderTests, AddCultureGraphicsMapperWorks)	4✔
122	{
123	vic3::CultureDefinition culture = vic3::CultureDefinition("culture_a", {}, {}, {});	2✔
124	mappers::GraphicsBlock graphics{.graphical_culture = "graphical_culture_a"};	1✔
125	mappers::CultureGraphicsMapping mapping{
126	.cultures = {culture.GetName()},	1✔
127	.graphics_block = graphics,
128	};	2✔
129	CultureGraphicsMapper cultureGraphicsMapper = CultureGraphicsMapper({mapping});	2✔
130	const auto worldMapper =
131	WorldMapperBuilder::CreateNullMapper().SetCultureGraphicsMapper(cultureGraphicsMapper).Build();	1✔
132
133	EXPECT_EQ(worldMapper.culture_graphics_mapper.MatchCultureToGraphics(culture).graphical_culture,	1✔
134	"graphical_culture_a");	1✔
135	}	4✔
136
137	TEST(MappersWorldWorldMapperBuilderTests, DefaultCultureGraphicsMapperWorks)	4✔
138	{
139	vic3::CultureDefinition culture = vic3::CultureDefinition("culture_1", {}, {}, {});	2✔
140	const auto worldMapper = WorldMapperBuilder::CreateNullMapper().DefaultCultureGraphicsMapper().Build();	1✔
141
142	EXPECT_EQ(worldMapper.culture_graphics_mapper.MatchCultureToGraphics(culture).graphical_culture, "asian_gfx");	1✔
143	}	2✔
144
145	TEST(MappersWorldWorldMapperBuilderTests, CopyToVicWorldCopiesProvinces)	4✔
146	{
147	auto worldMapper = std::move(WorldMapperBuilder::CreateNullMapper().AddTestProvinces(3));	1✔
148	auto worldBuilder = vic3::WorldBuilder::CreateNullWorld();	1✔
149	worldMapper.CopyToVicWorld(worldBuilder);	1✔
150	auto world = worldBuilder.Build();	1✔
151	EXPECT_EQ(world.GetProvinceDefinitions().GetProvinceDefinitions().size(), 3);	1✔
152	}	1✔
153
154	} // namespace mappers

ParadoxGameConverters / Vic3ToHoI4 / 15945857949

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous