KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_collector.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation, either version 3 of the License, or (at your
9 * option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <https://www.gnu.org/licenses/>.
18 */
19
20#include <boost/test/unit_test.hpp>
21#include <collector.h>
22#include <eda_item.h>
23#include <vector>
24#include <ostream>
25
26// Mock EDA_ITEM for testing
27namespace
28{
29class TEST_EDA_ITEM : public EDA_ITEM
30{
31public:
32 TEST_EDA_ITEM( KICAD_T aType ) : EDA_ITEM( aType ) {}
33
34 wxString GetClass() const override { return wxT("TEST_EDA_ITEM"); }
35
36 // Minimal required implementations for abstract methods
37 EDA_ITEM* Clone() const override { return new TEST_EDA_ITEM( Type() ); }
38};
39} // namespace
40
41// Test collector that implements Inspect
42class TEST_COLLECTOR : public COLLECTOR
43{
44public:
45 TEST_COLLECTOR() : m_inspectCalls( 0 ), m_shouldCollect( true ) {}
46
47 INSPECT_RESULT Inspect( EDA_ITEM* aTestItem, void* aTestData ) override
48 {
49 m_inspectCalls++;
50
51 if( m_shouldCollect && aTestItem )
52 {
53 // Only collect items of specified types if scan types are set
54 if( !m_scanTypes.empty() )
55 {
56 for( KICAD_T type : m_scanTypes )
57 {
58 if( aTestItem->Type() == type )
59 {
60 Append( aTestItem );
61 break;
62 }
63 }
64 }
65 else
66 {
67 Append( aTestItem );
68 }
69 }
70
71 return INSPECT_RESULT::CONTINUE;
72 }
73
74 int GetInspectCalls() const { return m_inspectCalls; }
75 void SetShouldCollect( bool aShouldCollect ) { m_shouldCollect = aShouldCollect; }
76
77private:
78 int m_inspectCalls;
79 bool m_shouldCollect;
80};
81
82// Add this for Boost test output of INSPECT_RESULT
83std::ostream& operator<<( std::ostream& os, const INSPECT_RESULT& result )
84{
85 switch( result )
86 {
87 case INSPECT_RESULT::CONTINUE: os << "CONTINUE"; break;
88 case INSPECT_RESULT::QUIT: os << "QUIT"; break;
89 default: os << "UNKNOWN"; break;
90 }
91 return os;
92}
93
94BOOST_AUTO_TEST_SUITE( CollectorTests )
95
96BOOST_AUTO_TEST_CASE( Constructor_DefaultValues )
97{
98 COLLECTOR collector;
99
100 BOOST_CHECK_EQUAL( collector.GetCount(), 0 );
101 BOOST_CHECK_EQUAL( collector.m_Threshold, 0 );
102 BOOST_CHECK_EQUAL( collector.m_MenuCancelled, false );
103 BOOST_CHECK( !collector.HasAdditionalItems() );
104}
105
106BOOST_AUTO_TEST_CASE( Append_SingleItem )
107{
108 COLLECTOR collector;
109 TEST_EDA_ITEM item( PCB_T );
110
111 collector.Append( &item );
112
113 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
114 BOOST_CHECK_EQUAL( collector[0], &item );
115}
116
117BOOST_AUTO_TEST_CASE( Append_MultipleItems )
118{
119 COLLECTOR collector;
120 TEST_EDA_ITEM item1( PCB_T );
121 TEST_EDA_ITEM item2( PCB_VIA_T );
122 TEST_EDA_ITEM item3( PCB_TRACE_T );
123
124 collector.Append( &item1 );
125 collector.Append( &item2 );
126 collector.Append( &item3 );
127
128 BOOST_CHECK_EQUAL( collector.GetCount(), 3 );
129 BOOST_CHECK_EQUAL( collector[0], &item1 );
130 BOOST_CHECK_EQUAL( collector[1], &item2 );
131 BOOST_CHECK_EQUAL( collector[2], &item3 );
132}
133
134BOOST_AUTO_TEST_CASE( Append_NullItem )
135{
136 COLLECTOR collector;
137
138 collector.Append( nullptr );
139
140 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
141 BOOST_CHECK_EQUAL( collector[0], nullptr );
142}
143
144BOOST_AUTO_TEST_CASE( Empty_ClearsList )
145{
146 COLLECTOR collector;
147 TEST_EDA_ITEM item1( PCB_T );
148 TEST_EDA_ITEM item2( PCB_VIA_T );
149
150 collector.Append( &item1 );
151 collector.Append( &item2 );
152 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
153
154 collector.Empty();
155
156 BOOST_CHECK_EQUAL( collector.GetCount(), 0 );
157}
158
159BOOST_AUTO_TEST_CASE( Remove_ByIndex_ValidIndex )
160{
161 COLLECTOR collector;
162 TEST_EDA_ITEM item1( PCB_T );
163 TEST_EDA_ITEM item2( PCB_VIA_T );
164 TEST_EDA_ITEM item3( PCB_TRACE_T );
165
166 collector.Append( &item1 );
167 collector.Append( &item2 );
168 collector.Append( &item3 );
169
170 collector.Remove( 1 ); // Remove middle item
171
172 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
173 BOOST_CHECK_EQUAL( collector[0], &item1 );
174 BOOST_CHECK_EQUAL( collector[1], &item3 );
175}
176
177BOOST_AUTO_TEST_CASE( Remove_ByIndex_FirstItem )
178{
179 COLLECTOR collector;
180 TEST_EDA_ITEM item1( PCB_T );
181 TEST_EDA_ITEM item2( PCB_VIA_T );
182
183 collector.Append( &item1 );
184 collector.Append( &item2 );
185
186 collector.Remove( 0 );
187
188 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
189 BOOST_CHECK_EQUAL( collector[0], &item2 );
190}
191
192BOOST_AUTO_TEST_CASE( Remove_ByIndex_LastItem )
193{
194 COLLECTOR collector;
195 TEST_EDA_ITEM item1( PCB_T );
196 TEST_EDA_ITEM item2( PCB_VIA_T );
197
198 collector.Append( &item1 );
199 collector.Append( &item2 );
200
201 collector.Remove( 1 );
202
203 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
204 BOOST_CHECK_EQUAL( collector[0], &item1 );
205}
206
207BOOST_AUTO_TEST_CASE( Remove_ByPointer_ExistingItem )
208{
209 COLLECTOR collector;
210 TEST_EDA_ITEM item1( PCB_T );
211 TEST_EDA_ITEM item2( PCB_VIA_T );
212 TEST_EDA_ITEM item3( PCB_TRACE_T );
213
214 collector.Append( &item1 );
215 collector.Append( &item2 );
216 collector.Append( &item3 );
217
218 collector.Remove( &item2 );
219
220 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
221 BOOST_CHECK_EQUAL( collector[0], &item1 );
222 BOOST_CHECK_EQUAL( collector[1], &item3 );
223}
224
225BOOST_AUTO_TEST_CASE( Remove_ByPointer_NonExistingItem )
226{
227 COLLECTOR collector;
228 TEST_EDA_ITEM item1( PCB_T );
229 TEST_EDA_ITEM item2( PCB_VIA_T );
230 TEST_EDA_ITEM item3( PCB_TRACE_T );
231
232 collector.Append( &item1 );
233 collector.Append( &item2 );
234
235 collector.Remove( &item3 ); // Not in collection
236
237 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
238 BOOST_CHECK_EQUAL( collector[0], &item1 );
239 BOOST_CHECK_EQUAL( collector[1], &item2 );
240}
241
242BOOST_AUTO_TEST_CASE( Remove_ByPointer_DuplicateItems )
243{
244 COLLECTOR collector;
245 TEST_EDA_ITEM item1( PCB_T );
246
247 collector.Append( &item1 );
248 collector.Append( &item1 );
249 collector.Append( &item1 );
250
251 collector.Remove( &item1 );
252
253 BOOST_CHECK_EQUAL( collector.GetCount(), 0 ); // All instances should be removed
254}
255
256BOOST_AUTO_TEST_CASE( Transfer_ByIndex_ValidIndex )
257{
258 COLLECTOR collector;
259 TEST_EDA_ITEM item1( PCB_T );
260 TEST_EDA_ITEM item2( PCB_VIA_T );
261 TEST_EDA_ITEM item3( PCB_TRACE_T );
262
263 collector.Append( &item1 );
264 collector.Append( &item2 );
265 collector.Append( &item3 );
266
267 collector.Transfer( 1 );
268
269 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
270 BOOST_CHECK_EQUAL( collector[0], &item1 );
271 BOOST_CHECK_EQUAL( collector[1], &item3 );
272 BOOST_CHECK( collector.HasAdditionalItems() );
273}
274
275BOOST_AUTO_TEST_CASE( Transfer_ByPointer_ExistingItem )
276{
277 COLLECTOR collector;
278 TEST_EDA_ITEM item1( PCB_T );
279 TEST_EDA_ITEM item2( PCB_VIA_T );
280 TEST_EDA_ITEM item3( PCB_TRACE_T );
281
282 collector.Append( &item1 );
283 collector.Append( &item2 );
284 collector.Append( &item3 );
285
286 collector.Transfer( &item2 );
287
288 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
289 BOOST_CHECK_EQUAL( collector[0], &item1 );
290 BOOST_CHECK_EQUAL( collector[1], &item3 );
291 BOOST_CHECK( collector.HasAdditionalItems() );
292}
293
294BOOST_AUTO_TEST_CASE( Transfer_ByPointer_NonExistingItem )
295{
296 COLLECTOR collector;
297 TEST_EDA_ITEM item1( PCB_T );
298 TEST_EDA_ITEM item2( PCB_VIA_T );
299 TEST_EDA_ITEM item3( PCB_TRACE_T );
300
301 collector.Append( &item1 );
302 collector.Append( &item2 );
303
304 collector.Transfer( &item3 ); // Not in collection
305
306 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
307 BOOST_CHECK( !collector.HasAdditionalItems() );
308}
309
310BOOST_AUTO_TEST_CASE( Combine_RestoresBackupItems )
311{
312 COLLECTOR collector;
313 TEST_EDA_ITEM item1( PCB_T );
314 TEST_EDA_ITEM item2( PCB_VIA_T );
315 TEST_EDA_ITEM item3( PCB_TRACE_T );
316
317 collector.Append( &item1 );
318 collector.Append( &item2 );
319 collector.Append( &item3 );
320
321 collector.Transfer( &item2 );
322 collector.Transfer( &item3 );
323
324 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
325 BOOST_CHECK( collector.HasAdditionalItems() );
326
327 collector.Combine();
328
329 BOOST_CHECK_EQUAL( collector.GetCount(), 3 );
330 BOOST_CHECK( !collector.HasAdditionalItems() );
331 BOOST_CHECK_EQUAL( collector[0], &item1 );
332 BOOST_CHECK_EQUAL( collector[1], &item2 );
333 BOOST_CHECK_EQUAL( collector[2], &item3 );
334}
335
336BOOST_AUTO_TEST_CASE( Combine_EmptyBackupList )
337{
338 COLLECTOR collector;
339 TEST_EDA_ITEM item1( PCB_T );
340
341 collector.Append( &item1 );
342
343 BOOST_CHECK( !collector.HasAdditionalItems() );
344
345 collector.Combine();
346
347 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
348 BOOST_CHECK( !collector.HasAdditionalItems() );
349}
350
351BOOST_AUTO_TEST_CASE( OperatorBrackets_ValidIndex )
352{
353 COLLECTOR collector;
354 TEST_EDA_ITEM item1( PCB_T );
355 TEST_EDA_ITEM item2( PCB_VIA_T );
356
357 collector.Append( &item1 );
358 collector.Append( &item2 );
359
360 BOOST_CHECK_EQUAL( collector[0], &item1 );
361 BOOST_CHECK_EQUAL( collector[1], &item2 );
362}
363
364BOOST_AUTO_TEST_CASE( OperatorBrackets_InvalidIndex )
365{
366 COLLECTOR collector;
367 TEST_EDA_ITEM item1( PCB_T );
368
369 collector.Append( &item1 );
370
371 BOOST_CHECK_EQUAL( collector[1], nullptr ); // Out of bounds
372 BOOST_CHECK_EQUAL( collector[-1], nullptr ); // Negative index
373 BOOST_CHECK_EQUAL( collector[100], nullptr ); // Large index
374}
375
376BOOST_AUTO_TEST_CASE( OperatorBrackets_EmptyCollector )
377{
378 COLLECTOR collector;
379
380 BOOST_CHECK_EQUAL( collector[0], nullptr );
381}
382
383BOOST_AUTO_TEST_CASE( HasItem_ExistingItem )
384{
385 COLLECTOR collector;
386 TEST_EDA_ITEM item1( PCB_T );
387 TEST_EDA_ITEM item2( PCB_VIA_T );
388
389 collector.Append( &item1 );
390 collector.Append( &item2 );
391
392 BOOST_CHECK( collector.HasItem( &item1 ) );
393 BOOST_CHECK( collector.HasItem( &item2 ) );
394}
395
396BOOST_AUTO_TEST_CASE( HasItem_NonExistingItem )
397{
398 COLLECTOR collector;
399 TEST_EDA_ITEM item1( PCB_T );
400 TEST_EDA_ITEM item2( PCB_VIA_T );
401 TEST_EDA_ITEM item3( PCB_TRACE_T );
402
403 collector.Append( &item1 );
404 collector.Append( &item2 );
405
406 BOOST_CHECK( !collector.HasItem( &item3 ) );
407}
408
409BOOST_AUTO_TEST_CASE( HasItem_NullItem )
410{
411 COLLECTOR collector;
412 TEST_EDA_ITEM item1( PCB_T );
413
414 collector.Append( &item1 );
415 collector.Append( nullptr );
416
417 BOOST_CHECK( collector.HasItem( nullptr ) );
418}
419
420BOOST_AUTO_TEST_CASE( HasItem_EmptyCollector )
421{
422 COLLECTOR collector;
423 TEST_EDA_ITEM item1( PCB_T );
424
425 BOOST_CHECK( !collector.HasItem( &item1 ) );
426}
427
428BOOST_AUTO_TEST_CASE( CountType_SingleType )
429{
430 COLLECTOR collector;
431 TEST_EDA_ITEM item1( PCB_T );
432 TEST_EDA_ITEM item2( PCB_T );
433 TEST_EDA_ITEM item3( PCB_VIA_T );
434
435 collector.Append( &item1 );
436 collector.Append( &item2 );
437 collector.Append( &item3 );
438
439 BOOST_CHECK_EQUAL( collector.CountType( PCB_T ), 2 );
440 BOOST_CHECK_EQUAL( collector.CountType( PCB_VIA_T ), 1 );
441 BOOST_CHECK_EQUAL( collector.CountType( PCB_TRACE_T ), 0 );
442}
443
444BOOST_AUTO_TEST_CASE( CountType_EmptyCollector )
445{
446 COLLECTOR collector;
447
448 BOOST_CHECK_EQUAL( collector.CountType( PCB_T ), 0 );
449}
450
451BOOST_AUTO_TEST_CASE( SetScanTypes_Basic )
452{
453 COLLECTOR collector;
454 std::vector<KICAD_T> types = { PCB_T, PCB_VIA_T };
455
456 collector.SetScanTypes( types );
457
458 // No direct way to test this, but it should not crash
459 BOOST_CHECK( true );
460}
461
462BOOST_AUTO_TEST_CASE( SetRefPos_Basic )
463{
464 COLLECTOR collector;
465 VECTOR2I refPos( 100, 200 );
466
467 collector.SetRefPos( refPos );
468
469 // No direct way to test this, but it should not crash
470 BOOST_CHECK( true );
471}
472
473BOOST_AUTO_TEST_CASE( Iterator_BeginEnd )
474{
475 COLLECTOR collector;
476 TEST_EDA_ITEM item1( PCB_T );
477 TEST_EDA_ITEM item2( PCB_VIA_T );
478 TEST_EDA_ITEM item3( PCB_TRACE_T );
479
480 collector.Append( &item1 );
481 collector.Append( &item2 );
482 collector.Append( &item3 );
483
484 std::vector<EDA_ITEM*> items;
485 for( auto iter = collector.begin(); iter != collector.end(); ++iter )
486 {
487 items.push_back( *iter );
488 }
489
490 BOOST_CHECK_EQUAL( items.size(), 3 );
491 BOOST_CHECK_EQUAL( items[0], &item1 );
492 BOOST_CHECK_EQUAL( items[1], &item2 );
493 BOOST_CHECK_EQUAL( items[2], &item3 );
494}
495
496BOOST_AUTO_TEST_CASE( Iterator_RangeBasedFor )
497{
498 COLLECTOR collector;
499 TEST_EDA_ITEM item1( PCB_T );
500 TEST_EDA_ITEM item2( PCB_VIA_T );
501
502 collector.Append( &item1 );
503 collector.Append( &item2 );
504
505 std::vector<EDA_ITEM*> items;
506 for( EDA_ITEM* item : collector )
507 {
508 items.push_back( item );
509 }
510
511 BOOST_CHECK_EQUAL( items.size(), 2 );
512 BOOST_CHECK_EQUAL( items[0], &item1 );
513 BOOST_CHECK_EQUAL( items[1], &item2 );
514}
515
516BOOST_AUTO_TEST_CASE( Iterator_ConstIterator )
517{
518 COLLECTOR collector;
519 TEST_EDA_ITEM item1( PCB_T );
520
521 collector.Append( &item1 );
522
523 const COLLECTOR& constCollector = collector;
524 std::vector<const EDA_ITEM*> items;
525
526 for( auto iter = constCollector.begin(); iter != constCollector.end(); ++iter )
527 {
528 items.push_back( *iter );
529 }
530
531 BOOST_CHECK_EQUAL( items.size(), 1 );
532 BOOST_CHECK_EQUAL( items[0], &item1 );
533}
534
535BOOST_AUTO_TEST_CASE( Inspect_BasicFunctionality )
536{
537 TEST_COLLECTOR collector;
538 TEST_EDA_ITEM item1( PCB_T );
539
540 INSPECT_RESULT result = collector.Inspect( &item1, nullptr );
541
542 BOOST_CHECK_EQUAL( result, INSPECT_RESULT::CONTINUE );
543 BOOST_CHECK_EQUAL( collector.GetInspectCalls(), 1 );
544 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
545}
546
547BOOST_AUTO_TEST_CASE( Inspect_WithScanTypes )
548{
549 TEST_COLLECTOR collector;
550 TEST_EDA_ITEM item1( PCB_T );
551 TEST_EDA_ITEM item2( PCB_VIA_T );
552 TEST_EDA_ITEM item3( PCB_TRACE_T );
553
554 std::vector<KICAD_T> scanTypes = { PCB_T, PCB_VIA_T };
555 collector.SetScanTypes( scanTypes );
556
557 collector.Inspect( &item1, nullptr ); // Should be collected
558 collector.Inspect( &item2, nullptr ); // Should be collected
559 collector.Inspect( &item3, nullptr ); // Should NOT be collected
560
561 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
562 BOOST_CHECK( collector.HasItem( &item1 ) );
563 BOOST_CHECK( collector.HasItem( &item2 ) );
564 BOOST_CHECK( !collector.HasItem( &item3 ) );
565}
566
567BOOST_AUTO_TEST_CASE( ComplexWorkflow_TransferAndCombine )
568{
569 COLLECTOR collector;
570 TEST_EDA_ITEM item1( PCB_T );
571 TEST_EDA_ITEM item2( PCB_VIA_T );
572 TEST_EDA_ITEM item3( PCB_TRACE_T );
573 TEST_EDA_ITEM item4( PCB_PAD_T );
574
575 // Add items
576 collector.Append( &item1 );
577 collector.Append( &item2 );
578 collector.Append( &item3 );
579 collector.Append( &item4 );
580 BOOST_CHECK_EQUAL( collector.GetCount(), 4 );
581
582 // Transfer some items
583 collector.Transfer( &item2 );
584 collector.Transfer( &item4 );
585 BOOST_CHECK_EQUAL( collector.GetCount(), 2 );
586 BOOST_CHECK( collector.HasAdditionalItems() );
587
588 // Remove one remaining item
589 collector.Remove( &item1 );
590 BOOST_CHECK_EQUAL( collector.GetCount(), 1 );
591
592 // Combine back
593 collector.Combine();
594 BOOST_CHECK_EQUAL( collector.GetCount(), 3 );
595 BOOST_CHECK( !collector.HasAdditionalItems() );
596
597 // Check final state
598 BOOST_CHECK( !collector.HasItem( &item1 ) ); // Was removed
599 BOOST_CHECK( collector.HasItem( &item2 ) ); // Was transferred back
600 BOOST_CHECK( collector.HasItem( &item3 ) ); // Was never moved
601 BOOST_CHECK( collector.HasItem( &item4 ) ); // Was transferred back
602}
603
604BOOST_AUTO_TEST_SUITE_END()
COLLECTOR
An abstract class that will find and hold all the objects according to an inspection done by the Insp...
Definition collector.h:45
COLLECTOR::Transfer
void Transfer(int aIndex)
Move the item at aIndex (first position is 0) to the backup list.
Definition collector.h:149
COLLECTOR::m_MenuCancelled
bool m_MenuCancelled
Definition collector.h:237
COLLECTOR::Empty
void Empty()
Clear the list.
Definition collector.h:87
COLLECTOR::begin
ITER begin()
Definition collector.h:71
COLLECTOR::GetCount
int GetCount() const
Return the number of objects in the list.
Definition collector.h:79
COLLECTOR::HasItem
bool HasItem(const EDA_ITEM *aItem) const
Tests if aItem has already been collected.
Definition collector.h:193
COLLECTOR::SetScanTypes
void SetScanTypes(const std::vector< KICAD_T > &aTypes)
Record the list of KICAD_T types to consider for collection by the Inspect() function.
Definition collector.h:209
COLLECTOR::SetRefPos
void SetRefPos(const VECTOR2I &aRefPos)
Definition collector.h:213
COLLECTOR::CountType
int CountType(KICAD_T aType)
Count the number of items matching aType.
Definition collector.h:221
COLLECTOR::m_scanTypes
std::vector< KICAD_T > m_scanTypes
Definition collector.h:243
COLLECTOR::Remove
void Remove(int aIndex)
Remove the item at aIndex (first position is 0).
Definition collector.h:107
COLLECTOR::m_Threshold
int m_Threshold
Definition collector.h:234
COLLECTOR::end
ITER end()
Definition collector.h:72
COLLECTOR::HasAdditionalItems
bool HasAdditionalItems()
Test if the collector has heuristic backup items.
Definition collector.h:130
COLLECTOR::Combine
void Combine()
Re-combine the backup list into the main list of the collector.
Definition collector.h:138
COLLECTOR::Append
void Append(EDA_ITEM *item)
Add an item to the end of the list.
Definition collector.h:97
EDA_ITEM
A base class for most all the KiCad significant classes used in schematics and boards.
Definition eda_item.h:98
EDA_ITEM::Type
KICAD_T Type() const
Returns the type of object.
Definition eda_item.h:110
TEST_COLLECTOR
Definition test_collector.cpp:43
TEST_COLLECTOR::Inspect
INSPECT_RESULT Inspect(EDA_ITEM *aTestItem, void *aTestData) override
Definition test_collector.cpp:47
TEST_COLLECTOR::m_inspectCalls
int m_inspectCalls
Definition test_collector.cpp:78
TEST_COLLECTOR::TEST_COLLECTOR
TEST_COLLECTOR()
Definition test_collector.cpp:45
TEST_COLLECTOR::m_shouldCollect
bool m_shouldCollect
Definition test_collector.cpp:79
TEST_COLLECTOR::SetShouldCollect
void SetShouldCollect(bool aShouldCollect)
Definition test_collector.cpp:75
TEST_COLLECTOR::GetInspectCalls
int GetInspectCalls() const
Definition test_collector.cpp:74
eda_item.h
INSPECT_RESULT
INSPECT_RESULT
Definition eda_item.h:44
INSPECT_RESULT::CONTINUE
@ CONTINUE
Definition eda_item.h:46
INSPECT_RESULT::QUIT
@ QUIT
Definition eda_item.h:45
PNS::Clone
std::unique_ptr< typename std::remove_const< T >::type > Clone(const T &aItem)
Definition pns_item.h:348
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
Definition test_api_enums.cpp:80
BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(CadstarPartParser)
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(Constructor_DefaultValues)
Definition test_collector.cpp:96
operator<<
std::ostream & operator<<(std::ostream &os, const INSPECT_RESULT &result)
Definition test_collector.cpp:83
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
result
wxString result
Test unit parsing edge cases and error handling.
Definition test_text_eval_numeric_compat.cpp:600
BOOST_CHECK_EQUAL
BOOST_CHECK_EQUAL(result, "25.4")
KICAD_T
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:70
PCB_T
@ PCB_T
Definition typeinfo.h:74
PCB_VIA_T
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:89
PCB_PAD_T
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:79
PCB_TRACE_T
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:88
VECTOR2I
VECTOR2< int32_t > VECTOR2I
Definition vector2d.h:708