25918451630

Committed 15 May 2026 12:43PM UTC coverage: 60.929% (+2.1%) from 58.859%

Build # 25918451630

Build Type

push

github

Committed by

turleypol

Commit Message

added dynamic property which returns a pointer of the object instead of
a copy like the current imp.
needed to be able to eg store a vector

Coverage Stats

43 of 61 new or added lines in 2 files covered. (70.49%)

14455 existing lines in 345 files now uncovered.

44695 of 73356 relevant lines covered (60.93%)

449621.59 hits per line

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

92.86

/pol-core/pol/testing/testrange.cpp


#include "clib/logfacility.h"
#include "clib/rawtypes.h"

#include "base/position.h"
#include "base/range.h"
#include "base/vector.h"
#include "globals/uvars.h"
#include "realms/realm.h"
#include "testenv.h"


namespace Pol::Testing
{
using namespace Core;

void range2d_test()
{
  const Pos2d p1( 1, 2 );
  const Pos2d p2( 3, 4 );
  auto* r = gamestate.main_realm;
  UnitTest(
      [&]()
      {
        Range2d a( p1, p2, r );
        return a.nw() == p1 && a.se() == p2;
      },
      true, "range(1,2,3,4)" );
  UnitTest( [&]() { return Range2d( p1, p2, r ); }, Range2d( p1, p2, r ),
            "range(1,2,3,4)==(1,2,3,4)" );
  UnitTest( [&]() { return Range2d( p2, p1, r ); }, Range2d( p1, p2, r ),
            "range(3,4,1,2)==(1,2,3,4)" );
  UnitTest( [&]() { return Range2d( Pos4d( p1, 0, r ), Pos4d( p2, 0, r ) ); }, Range2d( p1, p2, r ),
            "range(p4(1,2,3,4))==(1,2,3,4)" );
  UnitTest( [&]() { return Range2d( p2, p1, r ) != Range2d( p1, p2, r ); }, false,
            "range(3,4,1,2)!=(1,2,3,4)" );

  UnitTest( [&]() { return Range2d( p2, p1, r ).contains( Pos2d( 1, 2 ) ); }, true,
            "contains(1,2)" );
  UnitTest( [&]() { return Range2d( p2, p1, r ).contains( Pos2d( 3, 5 ) ); }, false,
            "contains(3,5)" );
  UnitTest( [&]()
            { return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 1, 0 ) ); },
            false, "1,1,2,2.contains(1,0)" );
  UnitTest( [&]()
            { return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 0, 1 ) ); },
            false, "1,1,2,2.contains(0,1)" );
  UnitTest( [&]()
            { return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 2, 0 ) ); },
            false, "1,1,2,2.contains(2,0)" );
  UnitTest( [&]()
            { return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 2, 3 ) ); },
            false, "1,1,2,2.contains(2,3)" );
  UnitTest( [&]()
            { return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 3, 1 ) ); },
            false, "1,1,2,2.contains(3,1)" );

  UnitTest(
      [&]()
      { return Range2d( p2, p1, r ).intersect( Range2d( Pos2d( 0, 0 ), Pos2d( 2, 2 ), r ) ); },
      true, "intersect(0,0,2,2)" );
  UnitTest(
      [&]()
      { return Range2d( p2, p1, r ).intersect( Range2d( Pos2d( 3, 3 ), Pos2d( 4, 4 ), r ) ); },
      true, "intersect(3,3,4,4)" );
  UnitTest(
      [&]()
      { return Range2d( p2, p1, r ).intersect( Range2d( Pos2d( 4, 3 ), Pos2d( 4, 4 ), r ) ); },
      false, "intersect(4,3,4,4)" );
  UnitTest(
      [&]()
      {
        Range2d a( p1, p2, r );
        std::vector<Pos2d> rangeres;
        rangeres.assign( a.begin(), a.end() );
        std::vector<Pos2d> res{ { { 1, 2 },
                                  { 2, 2 },
                                  { 3, 2 },
                                  { 1, 3 },
                                  { 2, 3 },
                                  { 3, 3 },
                                  { 1, 4 },
                                  { 2, 4 },
                                  { 3, 4 } } };
        if ( rangeres != res )
        {
          INFO_PRINTLN( "size: {} {}", rangeres.size(), res.size() );
          for ( size_t i = 0; i < res.size(); ++i )
          {
            INFO_PRINTLN( "{} {}", res[i], rangeres[i] );
          }
          return false;
        }
        return true;
      },
      true, "++itr" );

  UnitTest( [&]() { return fmt::format( "{:->25}", Range2d( p1, p2, r ) ); },
            "--( ( 1, 2 ) - ( 3, 4 ) )", "format padding" );

  UnitTest( [&]() { return Range2d( Pos4d( 2, 2, 0, r ), 1 ); },
            Range2d( Pos4d( 1, 1, 0, r ), Pos4d( 3, 3, 0, r ) ), "range(1,1,3,3)" );
  UnitTest( [&]() { return Range2d( Pos4d( 2, 2, 0, r ), 0 ); },
            Range2d( Pos4d( 2, 2, 0, r ), Pos4d( 2, 2, 0, r ) ), "range(2,2,2,2)" );

  UnitTest(
      [&]()
      {
        auto r1 = Range2d( Pos4d( 2, 2, 0, r ), 0 );
        auto r2 = Range2d( Pos4d( 2, 2, 0, r ), Pos4d( 5, 5, 0, r ) );
        return r1.intersect( r2 );
      },
      true, "(2,2,2,2).intersect(3,3,5,5)" );

  UnitTest(
      [&]()
      {
        Range2d a( p1, p2, r );
        std::vector<Pos2d> rangeres;
        auto itr = a.end();
        do
          rangeres.push_back( *( --itr ) );
        while ( itr != a.begin() );
        std::vector<Pos2d> res{ { { 3, 4 },
                                  { 2, 4 },
                                  { 1, 4 },
                                  { 3, 3 },
                                  { 2, 3 },
                                  { 1, 3 },
                                  { 3, 2 },
                                  { 2, 2 },
                                  { 1, 2 } } };
        if ( rangeres == res )
          return true;
        INFO_PRINTLN( "size: {} {}", rangeres.size(), res.size() );
        for ( size_t i = 0; i < res.size(); ++i )
          INFO_PRINTLN( "{} {}", res[i], rangeres[i] );
        return false;
      },
      true, "--itr" );
}

void range3d_test()
{
  const Pos3d p1( 1, 2, -5 );
  const Pos3d p2( 3, 4, 5 );
  auto* r = gamestate.main_realm;
  UnitTest(
      [&]()
      {
        Range3d a( p1, p2, r );
        return a.nw() == p1.xy() && a.se() == p2.xy() && a.nw_b() == p1 && a.se_t() == p2;
      },
      true, "range(1,2,3,4)" );
  UnitTest( [&]() { return Range3d( p1, p2, r ); }, Range3d( p1, p2, r ),
            "range(1,2,3,4)==(1,2,3,4)" );
  UnitTest( [&]() { return Range3d( p2, p1, r ); }, Range3d( p1, p2, r ),
            "range(3,4,1,2)==(1,2,3,4)" );
  UnitTest( [&]() { return Range3d( Pos4d( p1, r ), Pos4d( p2, r ) ); }, Range3d( p1, p2, r ),
            "range(p4(1,2,3,4))==(1,2,3,4)" );
  UnitTest( [&]() { return Range3d( p1, p2, r ).range(); }, Range2d( p1.xy(), p2.xy(), r ),
            "range(1,2,3,4)==2d(1,2,3,4)" );
  UnitTest( [&]() { return Range3d( p2, p1, r ) != Range3d( p1, p2, r ); }, false,
            "range(3,4,1,2)!=(1,2,3,4)" );

  UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos2d( 1, 2 ) ); }, true,
            "contains(1,2)" );
  UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos2d( 3, 5 ) ); }, false,
            "contains(3,5)" );
  UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos3d( 1, 2, 3 ) ); }, true,
            "contains(1,2,3)" );
  UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos3d( 1, 2, 10 ) ); }, false,
            "contains(1,2,10)" );

  UnitTest(
      [&]()
      { return Range3d( p2, p1, r ).intersect( Range2d( Pos2d( 0, 0 ), Pos2d( 2, 2 ), r ) ); },
      true, "intersect(0,0,2,2)" );
  UnitTest(
      [&]()
      { return Range3d( p2, p1, r ).intersect( Range2d( Pos2d( 3, 3 ), Pos2d( 4, 4 ), r ) ); },
      true, "intersect(3,3,4,4)" );
  UnitTest(
      [&]()
      { return Range3d( p2, p1, r ).intersect( Range2d( Pos2d( 4, 3 ), Pos2d( 4, 4 ), r ) ); },
      false, "intersect(4,3,4,4)" );
  UnitTest(
      [&]() {
        return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 0, 0, 0 ), Pos3d( 2, 2, 2 ), r ) );
      },
      true, "intersect(0,0,0,2,2,2)" );
  UnitTest(
      [&]() {
        return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 3, 3, -10 ), Pos3d( 4, 4, 4 ), r ) );
      },
      true, "intersect(3,3,-10,4,4,4)" );
  UnitTest(
      [&]() {
        return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 3, 3, 4 ), Pos3d( 4, 4, 40 ), r ) );
      },
      true, "intersect(3,3,4,4,4,40)" );
  UnitTest(
      [&]() {
        return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 4, 3, 0 ), Pos3d( 4, 4, 4 ), r ) );
      },
      false, "intersect(4,3,0,4,4,4)" );

  UnitTest( [&]() { return fmt::format( "{:->32}", Range3d( p1, p2, r ) ); },
            "--( ( 1, 2, -5 ) - ( 3, 4, 5 ) )", "format padding" );
}
}  // namespace Pol::Testing

1
2	#include "clib/logfacility.h"
3	#include "clib/rawtypes.h"
4
5	#include "base/position.h"
6	#include "base/range.h"
7	#include "base/vector.h"
8	#include "globals/uvars.h"
9	#include "realms/realm.h"
10	#include "testenv.h"
11
12
13	namespace Pol::Testing
14	{
15	using namespace Core;
16
17	void range2d_test()	1✔
18	{
19	const Pos2d p1( 1, 2 );	1✔
20	const Pos2d p2( 3, 4 );	1✔
21	auto* r = gamestate.main_realm;	1✔
22	UnitTest(	1✔
23	[&]()	1✔
24	{
25	Range2d a( p1, p2, r );	1✔
26	return a.nw() == p1 && a.se() == p2;	1✔
27	},
28	true, "range(1,2,3,4)" );
29	UnitTest( [&]() { return Range2d( p1, p2, r ); }, Range2d( p1, p2, r ),	2✔
30	"range(1,2,3,4)==(1,2,3,4)" );
31	UnitTest( [&]() { return Range2d( p2, p1, r ); }, Range2d( p1, p2, r ),	2✔
32	"range(3,4,1,2)==(1,2,3,4)" );
33	UnitTest( [&]() { return Range2d( Pos4d( p1, 0, r ), Pos4d( p2, 0, r ) ); }, Range2d( p1, p2, r ),	2✔
34	"range(p4(1,2,3,4))==(1,2,3,4)" );
35	UnitTest( [&]() { return Range2d( p2, p1, r ) != Range2d( p1, p2, r ); }, false,	2✔
36	"range(3,4,1,2)!=(1,2,3,4)" );
37
38	UnitTest( [&]() { return Range2d( p2, p1, r ).contains( Pos2d( 1, 2 ) ); }, true,	2✔
39	"contains(1,2)" );
40	UnitTest( [&]() { return Range2d( p2, p1, r ).contains( Pos2d( 3, 5 ) ); }, false,	2✔
41	"contains(3,5)" );
42	UnitTest( [&]()	1✔
43	{ return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 1, 0 ) ); },	1✔
44	false, "1,1,2,2.contains(1,0)" );
45	UnitTest( [&]()	1✔
46	{ return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 0, 1 ) ); },	1✔
47	false, "1,1,2,2.contains(0,1)" );
48	UnitTest( [&]()	1✔
49	{ return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 2, 0 ) ); },	1✔
50	false, "1,1,2,2.contains(2,0)" );
51	UnitTest( [&]()	1✔
52	{ return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 2, 3 ) ); },	1✔
53	false, "1,1,2,2.contains(2,3)" );
54	UnitTest( [&]()	1✔
55	{ return Range2d( Pos2d( 1, 1 ), Pos2d( 2, 2 ), nullptr ).contains( Pos2d( 3, 1 ) ); },	1✔
56	false, "1,1,2,2.contains(3,1)" );
57
58	UnitTest(	1✔
59	[&]()	1✔
60	{ return Range2d( p2, p1, r ).intersect( Range2d( Pos2d( 0, 0 ), Pos2d( 2, 2 ), r ) ); },	1✔
61	true, "intersect(0,0,2,2)" );
62	UnitTest(	1✔
63	[&]()	1✔
64	{ return Range2d( p2, p1, r ).intersect( Range2d( Pos2d( 3, 3 ), Pos2d( 4, 4 ), r ) ); },	1✔
65	true, "intersect(3,3,4,4)" );
66	UnitTest(	1✔
67	[&]()	1✔
68	{ return Range2d( p2, p1, r ).intersect( Range2d( Pos2d( 4, 3 ), Pos2d( 4, 4 ), r ) ); },	1✔
69	false, "intersect(4,3,4,4)" );
70	UnitTest(	1✔
71	[&]()	1✔
72	{
73	Range2d a( p1, p2, r );	1✔
74	std::vector<Pos2d> rangeres;	1✔
75	rangeres.assign( a.begin(), a.end() );	1✔
76	std::vector<Pos2d> res{ { { 1, 2 },
77	{ 2, 2 },
78	{ 3, 2 },
79	{ 1, 3 },
80	{ 2, 3 },
81	{ 3, 3 },
82	{ 1, 4 },
83	{ 2, 4 },
84	{ 3, 4 } } };	1✔
85	if ( rangeres != res )	1✔
86	{
UNCOV 87	INFO_PRINTLN( "size: {} {}", rangeres.size(), res.size() );	×
88	for ( size_t i = 0; i < res.size(); ++i )	×
89	{
UNCOV 90	INFO_PRINTLN( "{} {}", res[i], rangeres[i] );	×
91	}
UNCOV 92	return false;	×
93	}
94	return true;	1✔
95	},	1✔
96	true, "++itr" );
97
98	UnitTest( [&]() { return fmt::format( "{:->25}", Range2d( p1, p2, r ) ); },	3✔
99	"--( ( 1, 2 ) - ( 3, 4 ) )", "format padding" );
100
101	UnitTest( [&]() { return Range2d( Pos4d( 2, 2, 0, r ), 1 ); },	4✔
102	Range2d( Pos4d( 1, 1, 0, r ), Pos4d( 3, 3, 0, r ) ), "range(1,1,3,3)" );	2✔
103	UnitTest( [&]() { return Range2d( Pos4d( 2, 2, 0, r ), 0 ); },	4✔
104	Range2d( Pos4d( 2, 2, 0, r ), Pos4d( 2, 2, 0, r ) ), "range(2,2,2,2)" );	2✔
105
106	UnitTest(	1✔
107	[&]()	1✔
108	{
109	auto r1 = Range2d( Pos4d( 2, 2, 0, r ), 0 );	1✔
110	auto r2 = Range2d( Pos4d( 2, 2, 0, r ), Pos4d( 5, 5, 0, r ) );	1✔
111	return r1.intersect( r2 );	2✔
112	},
113	true, "(2,2,2,2).intersect(3,3,5,5)" );
114
115	UnitTest(	1✔
116	[&]()	1✔
117	{
118	Range2d a( p1, p2, r );	1✔
119	std::vector<Pos2d> rangeres;	1✔
120	auto itr = a.end();	1✔
121	do
122	rangeres.push_back( *( --itr ) );	9✔
123	while ( itr != a.begin() );	9✔
124	std::vector<Pos2d> res{ { { 3, 4 },
125	{ 2, 4 },
126	{ 1, 4 },
127	{ 3, 3 },
128	{ 2, 3 },
129	{ 1, 3 },
130	{ 3, 2 },
131	{ 2, 2 },
132	{ 1, 2 } } };	1✔
133	if ( rangeres == res )	1✔
134	return true;	1✔
UNCOV 135	INFO_PRINTLN( "size: {} {}", rangeres.size(), res.size() );	×
136	for ( size_t i = 0; i < res.size(); ++i )	×
137	INFO_PRINTLN( "{} {}", res[i], rangeres[i] );	×
138	return false;	×
139	},	1✔
140	true, "--itr" );
141	}	1✔
142
143	void range3d_test()	1✔
144	{
145	const Pos3d p1( 1, 2, -5 );	1✔
146	const Pos3d p2( 3, 4, 5 );	1✔
147	auto* r = gamestate.main_realm;	1✔
148	UnitTest(	1✔
149	[&]()	1✔
150	{
151	Range3d a( p1, p2, r );	1✔
152	return a.nw() == p1.xy() && a.se() == p2.xy() && a.nw_b() == p1 && a.se_t() == p2;	1✔
153	},
154	true, "range(1,2,3,4)" );
155	UnitTest( [&]() { return Range3d( p1, p2, r ); }, Range3d( p1, p2, r ),	2✔
156	"range(1,2,3,4)==(1,2,3,4)" );
157	UnitTest( [&]() { return Range3d( p2, p1, r ); }, Range3d( p1, p2, r ),	2✔
158	"range(3,4,1,2)==(1,2,3,4)" );
159	UnitTest( [&]() { return Range3d( Pos4d( p1, r ), Pos4d( p2, r ) ); }, Range3d( p1, p2, r ),	2✔
160	"range(p4(1,2,3,4))==(1,2,3,4)" );
161	UnitTest( [&]() { return Range3d( p1, p2, r ).range(); }, Range2d( p1.xy(), p2.xy(), r ),	2✔
162	"range(1,2,3,4)==2d(1,2,3,4)" );
163	UnitTest( [&]() { return Range3d( p2, p1, r ) != Range3d( p1, p2, r ); }, false,	2✔
164	"range(3,4,1,2)!=(1,2,3,4)" );
165
166	UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos2d( 1, 2 ) ); }, true,	2✔
167	"contains(1,2)" );
168	UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos2d( 3, 5 ) ); }, false,	2✔
169	"contains(3,5)" );
170	UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos3d( 1, 2, 3 ) ); }, true,	2✔
171	"contains(1,2,3)" );
172	UnitTest( [&]() { return Range3d( p2, p1, r ).contains( Pos3d( 1, 2, 10 ) ); }, false,	2✔
173	"contains(1,2,10)" );
174
175	UnitTest(	1✔
176	[&]()	1✔
177	{ return Range3d( p2, p1, r ).intersect( Range2d( Pos2d( 0, 0 ), Pos2d( 2, 2 ), r ) ); },	1✔
178	true, "intersect(0,0,2,2)" );
179	UnitTest(	1✔
180	[&]()	1✔
181	{ return Range3d( p2, p1, r ).intersect( Range2d( Pos2d( 3, 3 ), Pos2d( 4, 4 ), r ) ); },	1✔
182	true, "intersect(3,3,4,4)" );
183	UnitTest(	1✔
184	[&]()	1✔
185	{ return Range3d( p2, p1, r ).intersect( Range2d( Pos2d( 4, 3 ), Pos2d( 4, 4 ), r ) ); },	1✔
186	false, "intersect(4,3,4,4)" );
187	UnitTest(	1✔
188	[&]() {	1✔
189	return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 0, 0, 0 ), Pos3d( 2, 2, 2 ), r ) );	1✔
190	},
191	true, "intersect(0,0,0,2,2,2)" );
192	UnitTest(	1✔
193	[&]() {	1✔
194	return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 3, 3, -10 ), Pos3d( 4, 4, 4 ), r ) );	1✔
195	},
196	true, "intersect(3,3,-10,4,4,4)" );
197	UnitTest(	1✔
198	[&]() {	1✔
199	return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 3, 3, 4 ), Pos3d( 4, 4, 40 ), r ) );	1✔
200	},
201	true, "intersect(3,3,4,4,4,40)" );
202	UnitTest(	1✔
203	[&]() {	1✔
204	return Range3d( p2, p1, r ).intersect( Range3d( Pos3d( 4, 3, 0 ), Pos3d( 4, 4, 4 ), r ) );	1✔
205	},
206	false, "intersect(4,3,0,4,4,4)" );
207
208	UnitTest( [&]() { return fmt::format( "{:->32}", Range3d( p1, p2, r ) ); },	3✔
209	"--( ( 1, 2, -5 ) - ( 3, 4, 5 ) )", "format padding" );
210	}	1✔
211	} // namespace Pol::Testing

polserver / polserver / 25918451630

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