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