KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_symbol_library_manager.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 (C) 2023 Wayne Stambaugh <[email protected]>
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <https://www.gnu.org/licenses/>.
19 */
20
25
27
28// Code under test
31#include <sch_field.h>
34#include <sch_io/sch_io_mgr.h>
35#include <richio.h>
36
37#include <wx/ffile.h>
38#include <wx/filename.h>
39
47
48
49BOOST_FIXTURE_TEST_SUITE( SymbolLibraryManager, SYMBOL_LIBRARY_MANAGER_TEST_FIXTURE )
50
51
52
55BOOST_AUTO_TEST_CASE( SymbolBuffer )
56{
57 std::unique_ptr<LIB_SYMBOL> symbol = std::make_unique<LIB_SYMBOL>( wxS( "Symbol" ) );
58 std::unique_ptr<SCH_SCREEN> screen = std::make_unique<SCH_SCREEN>();
59
60 LIB_SYMBOL& symbolRef = *symbol;
61
62 SYMBOL_BUFFER buffer( std::move( symbol ), std::move( screen ) );
63
64 BOOST_CHECK( !buffer.IsModified() );
65 BOOST_CHECK( &buffer.GetSymbol() == &symbolRef );
66 BOOST_CHECK( buffer.GetOriginal() == symbolRef );
67
68 buffer.GetScreen()->SetContentModified();
69 BOOST_CHECK( buffer.IsModified() );
70
71 std::unique_ptr<LIB_SYMBOL> originalSymbol =
72 std::make_unique<LIB_SYMBOL>( wxS( "OriginalSymbol" ) );
73 LIB_SYMBOL& originalSymbolRef = *originalSymbol;
74
75 buffer.SetOriginal( std::move( originalSymbol ) );
76
77 BOOST_CHECK( &buffer.GetOriginal() == &originalSymbolRef );
78 BOOST_CHECK( buffer.GetOriginal() == originalSymbolRef );
79 BOOST_CHECK( &buffer.GetSymbol() != &buffer.GetOriginal() );
80}
81
82
87{
88 wxArrayString symbolNames;
89 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
90
91 BOOST_CHECK( !libBuffer.IsModified() );
92 BOOST_CHECK_EQUAL( libBuffer.GetHash(), 1 );
93
94 auto parentSymbol1 = std::make_unique<LIB_SYMBOL>( wxS( "Parent1" ) );
95 // A but clunky, but real code would get symbol from the LIB_BUFFER
96 // via GetSymbol etc, rather than retaining a reference after construction.
97 LIB_SYMBOL& parentSymbol1Ref = *parentSymbol1;
98
99 BOOST_CHECK_EQUAL( libBuffer.GetSymbol( parentSymbol1->GetName() ), nullptr );
100
101 parentSymbol1->GetValueField().SetText( parentSymbol1->GetName() );
102 libBuffer.CreateBuffer( std::move( parentSymbol1 ), std::make_unique<SCH_SCREEN>() );
103 BOOST_CHECK( libBuffer.GetSymbol( parentSymbol1Ref.GetName() ) == &parentSymbol1Ref );
104 BOOST_CHECK( !libBuffer.HasDerivedSymbols( parentSymbol1Ref.GetName() ) );
105 BOOST_CHECK_EQUAL( libBuffer.GetHash(), 2 );
106
107 libBuffer.GetSymbolNames( symbolNames );
108 BOOST_CHECK_EQUAL( symbolNames.GetCount(), 1 );
109 BOOST_CHECK_EQUAL( symbolNames[0], parentSymbol1Ref.GetName() );
110
111 symbolNames.Clear();
112 libBuffer.GetSymbolNames( symbolNames, SYMBOL_NAME_FILTER::ROOT_ONLY );
113 BOOST_CHECK_EQUAL( symbolNames.GetCount(), 1 );
114 BOOST_CHECK_EQUAL( symbolNames[0], parentSymbol1Ref.GetName() );
115
116 symbolNames.Clear();
117 libBuffer.GetSymbolNames( symbolNames, SYMBOL_NAME_FILTER::DERIVED_ONLY );
118 BOOST_CHECK_EQUAL( symbolNames.GetCount(), 0 );
119
120 auto childSymbol1 = std::make_unique<LIB_SYMBOL>( wxS( "Child1" ) );
121 LIB_SYMBOL& childSymbol1Ref = *childSymbol1;
122
123 childSymbol1->SetParent( &parentSymbol1Ref );
124 childSymbol1->GetValueField().SetText( childSymbol1->GetName() );
125 libBuffer.CreateBuffer( std::move( childSymbol1 ), std::make_unique<SCH_SCREEN>() );
126 BOOST_CHECK( libBuffer.GetSymbol( childSymbol1Ref.GetName() ) == &childSymbol1Ref );
127 BOOST_CHECK( libBuffer.HasDerivedSymbols( parentSymbol1Ref.GetName() ) );
128 BOOST_CHECK_EQUAL( libBuffer.GetHash(), 3 );
129
130 symbolNames.Clear();
131 libBuffer.GetSymbolNames( symbolNames );
132 BOOST_CHECK_EQUAL( symbolNames.GetCount(), 2 );
133 BOOST_CHECK_EQUAL( symbolNames[0], parentSymbol1Ref.GetName() );
134 BOOST_CHECK_EQUAL( symbolNames[1], childSymbol1Ref.GetName() );
135
136 symbolNames.Clear();
137 libBuffer.GetSymbolNames( symbolNames, SYMBOL_NAME_FILTER::DERIVED_ONLY );
138 BOOST_CHECK_EQUAL( symbolNames.GetCount(), 1 );
139 BOOST_CHECK_EQUAL( symbolNames[0], childSymbol1Ref.GetName() );
140
141 symbolNames.Clear();
142
143 BOOST_CHECK_EQUAL( libBuffer.GetDerivedSymbolNames( parentSymbol1Ref.GetName(), symbolNames ),
144 1 );
145 BOOST_CHECK_EQUAL( symbolNames[0], childSymbol1Ref.GetName() );
146
147 std::shared_ptr<SYMBOL_BUFFER> buf = libBuffer.GetBuffer( parentSymbol1Ref.GetName() );
148
149 LIB_SYMBOL tmp( parentSymbol1Ref );
150 tmp.GetDescriptionField().SetText( wxS( "Description" ) );
151
152 libBuffer.UpdateBuffer( *buf, tmp );
153 BOOST_CHECK_EQUAL( libBuffer.GetHash(), 4 );
154 BOOST_CHECK( *libBuffer.GetSymbol( parentSymbol1Ref.GetName() ) == tmp );
155
156 const bool deletedOk = libBuffer.DeleteBuffer( *buf );
157 BOOST_CHECK( deletedOk );
158 BOOST_CHECK( libBuffer.GetBuffers().empty() );
159}
160
161
165BOOST_AUTO_TEST_CASE( NewSymbolCreation )
166{
168
169 props.name = wxS( "Standalone" );
170 props.reference = wxS( "U" );
171 props.unitCount = 2;
172 props.pinNameInside = true;
173 props.pinTextPosition = 2;
174 props.powerSymbol = false;
175 props.showPinNumber = true;
176 props.showPinName = true;
177 props.unitsInterchangeable = false;
178 props.includeInBom = true;
179 props.includeOnBoard = true;
180 props.alternateBodyStyle = false;
181
182 std::unique_ptr<LIB_SYMBOL> standalone =
184
185 BOOST_CHECK_EQUAL( standalone->GetReferenceField().GetText(), props.reference );
186 BOOST_CHECK_EQUAL( standalone->GetUnitCount(), props.unitCount );
187 BOOST_CHECK( standalone->GetPinNameOffset() > 0 );
188
189 auto parent = std::make_unique<LIB_SYMBOL>( wxS( "Parent" ) );
190 parent->GetValueField().SetText( parent->GetName() );
191 SCH_FIELD* user = new SCH_FIELD( parent.get(), FIELD_T::USER, wxS( "UF" ) );
192 user->SetText( wxS( "V" ) );
193 parent->AddField( user );
194
195 props.name = wxS( "Child" );
196 props.parentSymbolName = parent->GetName();
197 props.keepFootprint = false;
198 props.keepDatasheet = false;
199 props.transferUserFields = true;
200 props.keepContentUserFields = false;
201
202 std::unique_ptr<LIB_SYMBOL> child =
203 LIB_SYMBOL_LIBRARY_MANAGER::CreateSymbol( props, parent.get() );
204
205 BOOST_CHECK( child->GetParent().lock().get() == parent.get() );
206 BOOST_CHECK( child->GetFootprintField().GetText().IsEmpty() );
207 BOOST_CHECK( child->GetDatasheetField().GetText().IsEmpty() );
208
209 std::vector<SCH_FIELD*> childFields;
210 child->GetFields( childFields );
211
212 bool found = false;
213
214 for( SCH_FIELD* field : childFields )
215 {
216 if( field->GetId() == FIELD_T::USER )
217 {
218 found = true;
219 BOOST_CHECK( field->GetText().IsEmpty() );
220 }
221 }
222
223 BOOST_CHECK( found );
224}
225
226
232BOOST_AUTO_TEST_CASE( NewPowerSymbolSeedsValueFromName )
233{
235
236 props.name = wxS( "+5V" );
237 props.reference = wxS( "#PWR" );
238 props.unitCount = 1;
239 props.pinNameInside = false;
240 props.pinTextPosition = 0;
241 props.powerSymbol = true;
242 props.showPinNumber = false;
243 props.showPinName = false;
244 props.unitsInterchangeable = true;
245 props.includeInBom = false;
246 props.includeOnBoard = false;
247 props.alternateBodyStyle = false;
248
249 std::unique_ptr<LIB_SYMBOL> symbol = LIB_SYMBOL_LIBRARY_MANAGER::CreateSymbol( props, nullptr );
250
251 BOOST_REQUIRE( symbol->IsGlobalPower() );
252 BOOST_CHECK_EQUAL( symbol->GetValueField().GetText(), props.name );
253}
254
255
264BOOST_AUTO_TEST_CASE( DeletedSymbolsAreRemovedFromFile )
265{
266 // Create a temporary directory and library file
267 wxString tempDir = wxFileName::CreateTempFileName( wxS( "kicad_test_" ) );
268 wxRemoveFile( tempDir );
269 wxFileName::Mkdir( tempDir );
270 wxString libPath = wxFileName( tempDir, wxS( "test_lib.kicad_sym" ) ).GetFullPath();
271
272 // Step 1: Create a library with a parent and derived symbol using the plugin directly
273 {
274 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
275 plugin->CreateLibrary( libPath );
276
277 // Create parent symbol
278 std::unique_ptr<LIB_SYMBOL> parentSymbol = std::make_unique<LIB_SYMBOL>( wxS( "Parent" ) );
279 parentSymbol->GetValueField().SetText( wxS( "Parent" ) );
280 parentSymbol->GetReferenceField().SetText( wxS( "U" ) );
281
282 LIB_SYMBOL* parentPtr = parentSymbol.get();
283 plugin->SaveSymbol( libPath, std::make_unique<LIB_SYMBOL>( *parentSymbol ) );
284
285 // Create derived symbol
286 std::unique_ptr<LIB_SYMBOL> derivedSymbol = std::make_unique<LIB_SYMBOL>( wxS( "Derived" ) );
287 derivedSymbol->GetValueField().SetText( wxS( "Derived" ) );
288 derivedSymbol->SetParent( parentPtr );
289
290 plugin->SaveSymbol( libPath, std::make_unique<LIB_SYMBOL>( *derivedSymbol ) );
291 plugin->SaveLibrary( libPath );
292 }
293
294 // Step 2: Verify both symbols exist in the library
295 {
296 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
297 LIB_SYMBOL* parent = plugin->LoadSymbol( libPath, wxS( "Parent" ) );
298 LIB_SYMBOL* derived = plugin->LoadSymbol( libPath, wxS( "Derived" ) );
299
300 BOOST_REQUIRE( parent != nullptr );
301 BOOST_REQUIRE( derived != nullptr );
302 BOOST_CHECK( derived->IsDerived() );
303 }
304
305 // Step 3: Load symbols into LIB_BUFFER and delete the derived symbol
306 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
307
308 {
309 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
310 LIB_SYMBOL* loadedParent = plugin->LoadSymbol( libPath, wxS( "Parent" ) );
311 LIB_SYMBOL* loadedDerived = plugin->LoadSymbol( libPath, wxS( "Derived" ) );
312
313 BOOST_REQUIRE( loadedParent != nullptr );
314 BOOST_REQUIRE( loadedDerived != nullptr );
315
316 // Set up parent relationship
317 loadedDerived->SetParent( loadedParent );
318
319 // Create buffers (parent first, then derived)
320 libBuffer.CreateBuffer( std::make_unique<LIB_SYMBOL>( *loadedParent ),
321 std::make_unique<SCH_SCREEN>() );
322
323 std::unique_ptr<LIB_SYMBOL> derivedCopy = std::make_unique<LIB_SYMBOL>( *loadedDerived );
324 derivedCopy->SetParent( libBuffer.GetSymbol( wxS( "Parent" ) ) );
325 libBuffer.CreateBuffer( std::move( derivedCopy ), std::make_unique<SCH_SCREEN>() );
326 }
327
328 // Verify buffer state before deletion
329 BOOST_CHECK_EQUAL( libBuffer.GetBuffers().size(), 2 );
330 BOOST_CHECK( libBuffer.GetSymbol( wxS( "Parent" ) ) != nullptr );
331 BOOST_CHECK( libBuffer.GetSymbol( wxS( "Derived" ) ) != nullptr );
332
333 // Delete the derived symbol from the buffer
334 std::shared_ptr<SYMBOL_BUFFER> derivedBuf = libBuffer.GetBuffer( wxS( "Derived" ) );
335 BOOST_REQUIRE( derivedBuf != nullptr );
336
337 bool deleteResult = libBuffer.DeleteBuffer( *derivedBuf );
338 BOOST_CHECK( deleteResult );
339
340 // Verify buffer state after deletion
341 BOOST_CHECK_EQUAL( libBuffer.GetBuffers().size(), 1 );
342 BOOST_CHECK( libBuffer.GetSymbol( wxS( "Parent" ) ) != nullptr );
343 BOOST_CHECK( libBuffer.GetSymbol( wxS( "Derived" ) ) == nullptr );
344
345 // Step 4: Save the library using the same pattern as SYMBOL_LIBRARY_MANAGER::SaveLibrary
346 {
347 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
348 std::map<std::string, UTF8> properties;
349 properties.emplace( SCH_IO_KICAD_SEXPR::PropBuffering, "" );
350
351 // Save remaining buffers (just Parent)
352 for( const std::shared_ptr<SYMBOL_BUFFER>& symbolBuf : libBuffer.GetBuffers() )
353 {
354 libBuffer.SaveBuffer( *symbolBuf, libPath, &*plugin, true );
355 }
356
357 // Delete symbols that were removed from the buffer (this is the fix for the bug)
358 for( const std::shared_ptr<SYMBOL_BUFFER>& deletedBuf : libBuffer.GetDeletedBuffers() )
359 {
360 const wxString& originalName = deletedBuf->GetOriginal().GetName();
361
362 if( plugin->LoadSymbol( libPath, originalName ) )
363 plugin->DeleteSymbol( libPath, originalName, &properties );
364 }
365
366 plugin->SaveLibrary( libPath );
368 }
369
370 // Step 5: Reload the library and verify the derived symbol is gone
371 {
372 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
373
374 LIB_SYMBOL* parent = plugin->LoadSymbol( libPath, wxS( "Parent" ) );
375 LIB_SYMBOL* derived = plugin->LoadSymbol( libPath, wxS( "Derived" ) );
376
377 BOOST_CHECK( parent != nullptr );
378 // This is the actual check for the bug - the derived symbol should be deleted
379 BOOST_CHECK_MESSAGE( derived == nullptr,
380 "Derived symbol should have been deleted from the library file" );
381 }
382
383 // Cleanup
384 if( wxFileName::DirExists( tempDir ) )
385 {
386 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
387 }
388}
389
390
402BOOST_AUTO_TEST_CASE( SaveLibraryAsToNewFile )
403{
404 wxString tempDir = wxFileName::CreateTempFileName( wxS( "kicad_test_" ) );
405 wxRemoveFile( tempDir );
406 wxFileName::Mkdir( tempDir );
407
408 wxString srcPath = wxFileName( tempDir, wxS( "source.kicad_sym" ) ).GetFullPath();
409 wxString dstPath = wxFileName( tempDir, wxS( "destination.kicad_sym" ) ).GetFullPath();
410
411 // Create a source library with two symbols (one parent, one derived)
412 {
413 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
414 plugin->CreateLibrary( srcPath );
415
416 auto parent = std::make_unique<LIB_SYMBOL>( wxS( "Parent" ) );
417 parent->GetValueField().SetText( wxS( "Parent" ) );
418 parent->GetReferenceField().SetText( wxS( "U" ) );
419 LIB_SYMBOL* parentPtr = parent.get();
420
421 plugin->SaveSymbol( srcPath, std::make_unique<LIB_SYMBOL>( *parent ) );
422
423 auto derived = std::make_unique<LIB_SYMBOL>( wxS( "Derived" ) );
424 derived->GetValueField().SetText( wxS( "Derived" ) );
425 derived->SetParent( parentPtr );
426
427 plugin->SaveSymbol( srcPath, std::make_unique<LIB_SYMBOL>( *derived ) );
428 plugin->SaveLibrary( srcPath );
429 }
430
431 // Simulate "Save Library As" to a new file that does not exist yet.
432 // This mirrors the else-branch in SYMBOL_LIBRARY_MANAGER::SaveLibrary.
433 {
434 IO_RELEASER<SCH_IO> srcPlugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
435 IO_RELEASER<SCH_IO> dstPlugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
436 std::map<std::string, UTF8> properties;
437 properties.emplace( SCH_IO_KICAD_SEXPR::PropBuffering, "" );
438
439 LIB_SYMBOL* loadedParent = srcPlugin->LoadSymbol( srcPath, wxS( "Parent" ) );
440 LIB_SYMBOL* loadedDerived = srcPlugin->LoadSymbol( srcPath, wxS( "Derived" ) );
441 BOOST_REQUIRE( loadedParent != nullptr );
442 BOOST_REQUIRE( loadedDerived != nullptr );
443
444 // Buffer symbols into the destination plugin using the target path (which
445 // does not exist yet). This must not throw.
446 BOOST_CHECK_NO_THROW(
447 dstPlugin->SaveSymbol( dstPath, std::make_unique<LIB_SYMBOL>( *loadedParent ),
448 &properties ) );
449
450 auto newDerived = std::make_unique<LIB_SYMBOL>( *loadedDerived );
451 LIB_SYMBOL* dstParent = dstPlugin->LoadSymbol( dstPath, wxS( "Parent" ), &properties );
452 BOOST_REQUIRE( dstParent != nullptr );
453 newDerived->SetParent( dstParent );
454
455 BOOST_CHECK_NO_THROW(
456 dstPlugin->SaveSymbol( dstPath, std::move( newDerived ), &properties ) );
457
458 BOOST_CHECK_NO_THROW( dstPlugin->SaveLibrary( dstPath ) );
459 }
460
461 // Reload the destination library and verify both symbols are present
462 {
463 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
464
465 LIB_SYMBOL* parent = plugin->LoadSymbol( dstPath, wxS( "Parent" ) );
466 LIB_SYMBOL* derived = plugin->LoadSymbol( dstPath, wxS( "Derived" ) );
467
468 BOOST_CHECK_MESSAGE( parent != nullptr,
469 "Parent symbol should exist in the saved-as library" );
470 BOOST_CHECK_MESSAGE( derived != nullptr,
471 "Derived symbol should exist in the saved-as library" );
472
473 if( derived )
474 BOOST_CHECK( derived->IsDerived() );
475 }
476
477 if( wxFileName::DirExists( tempDir ) )
478 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
479}
480
481
491BOOST_AUTO_TEST_CASE( SetParentKeepsParentNameInSync )
492{
493 auto parent = std::make_unique<LIB_SYMBOL>( wxS( "BaseSymbol" ) );
494
495 LIB_SYMBOL derived( wxS( "DerivedSymbol" ) );
496 BOOST_CHECK( derived.GetParentName().IsEmpty() );
497
498 derived.SetParent( parent.get() );
499 BOOST_CHECK( derived.IsDerived() );
500 BOOST_CHECK_EQUAL( derived.GetParentName(), wxS( "BaseSymbol" ) );
501
502 // Detaching the live pointer must not erase the recorded name, so a derived symbol whose live
503 // parent has been lost can still be serialized by name.
504 derived.SetParent( static_cast<LIB_SYMBOL*>( nullptr ) );
505 BOOST_CHECK_EQUAL( derived.GetParent().lock(), nullptr );
506 BOOST_CHECK_EQUAL( derived.GetParentName(), wxS( "BaseSymbol" ) );
507}
508
509
522BOOST_AUTO_TEST_CASE( SerializeDerivedSymbolUsesParentName )
523{
524 auto parent = std::make_unique<LIB_SYMBOL>( wxS( "BaseSymbol" ) );
525 parent->GetValueField().SetText( wxS( "BaseSymbol" ) );
526 parent->GetReferenceField().SetText( wxS( "U" ) );
527
528 LIB_SYMBOL derived( wxS( "DerivedSymbol" ) );
529 derived.SetParent( parent.get() );
530 derived.GetValueField().SetText( wxS( "DerivedSymbol" ) );
531
532 BOOST_REQUIRE( derived.IsDerived() );
533
534 // Force the recorded name to differ from the live parent's name. The writer must emit the
535 // recorded name, proving it does not read through the live (potentially dangling) pointer.
536 derived.SetParentName( wxS( "RecordedParent" ) );
537
538 STRING_FORMATTER formatter;
539
540 BOOST_REQUIRE_NO_THROW(
541 SCH_IO_KICAD_SEXPR_LIB_CACHE::SaveSymbol( &derived, formatter, wxEmptyString, true ) );
542
543 const std::string out = formatter.GetString();
544
545 BOOST_CHECK_MESSAGE( out.find( "(extends \"RecordedParent\")" ) != std::string::npos,
546 "Derived symbol should serialize (extends ...) using the recorded parent name" );
547}
548
549
556BOOST_AUTO_TEST_CASE( SaveCopyAsDerivedSymbolToNewLibrary )
557{
558 wxString tempDir = wxFileName::CreateTempFileName( wxS( "kicad_test_" ) );
559 wxRemoveFile( tempDir );
560 wxFileName::Mkdir( tempDir );
561
562 wxString dstPath = wxFileName( tempDir, wxS( "copy_target.kicad_sym" ) ).GetFullPath();
563
564 // Build an in-memory parent/derived pair like the symbol editor holds while editing.
565 auto parent = std::make_unique<LIB_SYMBOL>( wxS( "BaseSymbol" ) );
566 parent->GetValueField().SetText( wxS( "BaseSymbol" ) );
567 parent->GetReferenceField().SetText( wxS( "U" ) );
568
569 auto derived = std::make_unique<LIB_SYMBOL>( wxS( "DerivedSymbol" ) );
570 derived->SetParent( parent.get() );
571 derived->SetParentName( parent->GetName() );
572 derived->GetValueField().SetText( wxS( "DerivedSymbol" ) );
573
574 // Save the parent then the child to a brand new library, mirroring SYMBOL_SAVE_AS_HANDLER.
575 {
576 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
577 std::map<std::string, UTF8> properties;
578 properties.emplace( SCH_IO_KICAD_SEXPR::PropBuffering, "" );
579
580 BOOST_CHECK_NO_THROW(
581 plugin->SaveSymbol( dstPath, std::make_unique<LIB_SYMBOL>( *parent ), &properties ) );
582
583 LIB_SYMBOL* dstParent = plugin->LoadSymbol( dstPath, wxS( "BaseSymbol" ), &properties );
584 BOOST_REQUIRE( dstParent != nullptr );
585
586 auto newChild = std::make_unique<LIB_SYMBOL>( *derived );
587 newChild->SetParent( dstParent );
588 newChild->SetParentName( dstParent->GetName() );
589
590 BOOST_CHECK_NO_THROW( plugin->SaveSymbol( dstPath, std::move( newChild ), &properties ) );
591 BOOST_CHECK_NO_THROW( plugin->SaveLibrary( dstPath ) );
592 }
593
594 // Reload and verify the derived symbol survived with a valid parent.
595 {
596 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
597
598 LIB_SYMBOL* reloadedParent = plugin->LoadSymbol( dstPath, wxS( "BaseSymbol" ) );
599 LIB_SYMBOL* reloadedChild = plugin->LoadSymbol( dstPath, wxS( "DerivedSymbol" ) );
600
601 BOOST_CHECK( reloadedParent != nullptr );
602 BOOST_REQUIRE( reloadedChild != nullptr );
603 BOOST_CHECK( reloadedChild->IsDerived() );
604 BOOST_CHECK_EQUAL( reloadedChild->GetParent().lock().get(), reloadedParent );
605 }
606
607 if( wxFileName::DirExists( tempDir ) )
608 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
609}
610
611
620BOOST_AUTO_TEST_CASE( DerivedSymbolNamesForUnbufferedSymbol )
621{
622 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
623
624 auto parent = std::make_unique<LIB_SYMBOL>( wxS( "Parent" ) );
625 LIB_SYMBOL& parentRef = *parent;
626
627 libBuffer.CreateBuffer( std::move( parent ), std::make_unique<SCH_SCREEN>() );
628
629 auto child = std::make_unique<LIB_SYMBOL>( wxS( "Child" ) );
630 child->SetParent( &parentRef );
631 libBuffer.CreateBuffer( std::move( child ), std::make_unique<SCH_SCREEN>() );
632
633 wxArrayString names;
634
635 BOOST_CHECK_EQUAL( libBuffer.GetDerivedSymbolNames( wxS( "NeverBuffered" ), names ), 0 );
636 BOOST_CHECK( names.IsEmpty() );
637
638 // Deleting a symbol drops it from the buffer while the tree selection and the open symbol can
639 // still name it.
640 std::shared_ptr<SYMBOL_BUFFER> parentBuf = libBuffer.GetBuffer( wxS( "Parent" ) );
641 BOOST_REQUIRE( parentBuf != nullptr );
642 BOOST_CHECK( libBuffer.DeleteBuffer( *parentBuf ) );
643 BOOST_CHECK( libBuffer.GetSymbol( wxS( "Parent" ) ) == nullptr );
644
645 names.Clear();
646 BOOST_CHECK_EQUAL( libBuffer.GetDerivedSymbolNames( wxS( "Parent" ), names ), 0 );
647 BOOST_CHECK( names.IsEmpty() );
648}
649
650
659BOOST_AUTO_TEST_CASE( DerivedSymbolNamesAcrossRebufferedParent )
660{
661 // The originals, as the library adapter owns them. The buffer only ever holds copies.
662 auto originalRoot = std::make_unique<LIB_SYMBOL>( wxS( "Root" ) );
663 auto originalMid = std::make_unique<LIB_SYMBOL>( wxS( "Mid" ) );
664 auto originalLeaf = std::make_unique<LIB_SYMBOL>( wxS( "Leaf" ) );
665
666 originalMid->SetParent( originalRoot.get() );
667 originalLeaf->SetParent( originalMid.get() );
668
669 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
670
671 // Reaching Leaf first buffers a copy of Mid whose parent link still points at the unbuffered
672 // original Root.
673 auto midCopy = std::make_unique<LIB_SYMBOL>( *originalMid );
674 LIB_SYMBOL* midCopyPtr = midCopy.get();
675
676 libBuffer.CreateBuffer( std::move( midCopy ), std::make_unique<SCH_SCREEN>() );
677
678 auto leafCopy = std::make_unique<LIB_SYMBOL>( *originalLeaf );
679 leafCopy->SetParent( midCopyPtr );
680 libBuffer.CreateBuffer( std::move( leafCopy ), std::make_unique<SCH_SCREEN>() );
681
682 auto rootCopy = std::make_unique<LIB_SYMBOL>( *originalRoot );
683 LIB_SYMBOL* rootCopyPtr = rootCopy.get();
684
685 libBuffer.CreateBuffer( std::move( rootCopy ), std::make_unique<SCH_SCREEN>() );
686
687 // Reaching Mid itself then buffers a second copy, this time parented to the buffered Root.
688 // The duplicate entry is a separate getLibraryBuffer() defect; the walk has to tolerate it.
689 auto midDuplicate = std::make_unique<LIB_SYMBOL>( *originalMid );
690 midDuplicate->SetParent( rootCopyPtr );
691 libBuffer.CreateBuffer( std::move( midDuplicate ), std::make_unique<SCH_SCREEN>() );
692
693 wxArrayString names;
694
695 BOOST_CHECK_EQUAL( libBuffer.GetDerivedSymbolNames( wxS( "Root" ), names ), 2 );
696 BOOST_CHECK( names.Index( wxS( "Mid" ) ) != wxNOT_FOUND );
697 BOOST_CHECK( names.Index( wxS( "Leaf" ) ) != wxNOT_FOUND );
698
699 // HasDerivedSymbols() has always matched on the name. The two have to agree or DeleteBuffer()
700 // reports failure and orphans the children it did not remove.
701 BOOST_CHECK( libBuffer.HasDerivedSymbols( wxS( "Root" ) ) );
702 BOOST_CHECK( libBuffer.HasDerivedSymbols( wxS( "Mid" ) ) );
703}
704
705
714BOOST_AUTO_TEST_CASE( DerivedSymbolNamesExcludeRootFromNameCycle )
715{
716 // Unbuffered originals that close the cycle by name
717 auto originalA = std::make_unique<LIB_SYMBOL>( wxS( "A" ) );
718 auto originalB = std::make_unique<LIB_SYMBOL>( wxS( "B" ) );
719
720 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
721
722 auto symbolA = std::make_unique<LIB_SYMBOL>( wxS( "A" ) );
723 symbolA->SetParent( originalB.get() );
724 libBuffer.CreateBuffer( std::move( symbolA ), std::make_unique<SCH_SCREEN>() );
725
726 auto symbolB = std::make_unique<LIB_SYMBOL>( wxS( "B" ) );
727 symbolB->SetParent( originalA.get() );
728 libBuffer.CreateBuffer( std::move( symbolB ), std::make_unique<SCH_SCREEN>() );
729
730 wxArrayString names;
731
732 BOOST_CHECK_EQUAL( libBuffer.GetDerivedSymbolNames( wxS( "A" ), names ), 1 );
733 BOOST_REQUIRE_EQUAL( names.GetCount(), 1 );
734 BOOST_CHECK_EQUAL( names[0], wxS( "B" ) );
735
736 std::shared_ptr<SYMBOL_BUFFER> bufferA = libBuffer.GetBuffer( wxS( "A" ) );
737 BOOST_REQUIRE( bufferA != nullptr );
738 BOOST_CHECK( libBuffer.DeleteBuffer( *bufferA ) );
739 BOOST_CHECK( libBuffer.GetBuffers().empty() );
740}
741
742namespace
743{
744
745wxString makeTempLibrary( const std::vector<wxString>& aNames, wxString& aDir )
746{
747 aDir = wxFileName::CreateTempFileName( wxS( "kicad_test_" ) );
748 wxRemoveFile( aDir );
749 wxFileName::Mkdir( aDir );
750
751 wxString path = wxFileName( aDir, wxS( "lib.kicad_sym" ) ).GetFullPath();
752 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
753
754 plugin->CreateLibrary( path );
755
756 for( const wxString& name : aNames )
757 plugin->SaveSymbol( path, std::make_unique<LIB_SYMBOL>( name ) );
758
759 plugin->SaveLibrary( path );
760 return path;
761}
762
763
764void bufferSymbols( LIB_BUFFER& aBuffer, const wxString& aPath, const std::vector<wxString>& aNames )
765{
766 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
767
768 for( const wxString& name : aNames )
769 {
770 LIB_SYMBOL* loaded = plugin->LoadSymbol( aPath, name );
771 BOOST_REQUIRE( loaded );
772 aBuffer.CreateBuffer( std::make_unique<LIB_SYMBOL>( *loaded ), std::make_unique<SCH_SCREEN>() );
773 }
774}
775
776
777void renameBuffer( LIB_BUFFER& aBuffer, SYMBOL_BUFFER& aSymbolBuf, const wxString& aNewName )
778{
779 LIB_SYMBOL renamed( aSymbolBuf.GetSymbol() );
780 renamed.SetName( aNewName );
781 aBuffer.UpdateBuffer( aSymbolBuf, renamed );
782}
783
784
785void saveLibrary( LIB_BUFFER& aBuffer, const wxString& aPath )
786{
787 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
788
789 for( const std::shared_ptr<SYMBOL_BUFFER>& buf : aBuffer.GetBuffers() )
790 aBuffer.SaveBuffer( *buf, aPath, &*plugin, true );
791
792 plugin->SaveLibrary( aPath );
793}
794
795
796bool inLibrary( const wxString& aPath, const wxString& aName )
797{
798 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
799 return plugin->LoadSymbol( aPath, aName ) != nullptr;
800}
801
802} // namespace
803
804
808BOOST_AUTO_TEST_CASE( SwappedSymbolNamesSurviveSave )
809{
810 wxString dir;
811 wxString path = makeTempLibrary( { wxS( "A" ), wxS( "B" ) }, dir );
812
813 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
814 bufferSymbols( libBuffer, path, { wxS( "A" ), wxS( "B" ) } );
815
816 // Both buffers must be found before either is renamed, or the second lookup returns the
817 // buffer the first rename just moved onto that name
818 std::shared_ptr<SYMBOL_BUFFER> bufA = libBuffer.GetBuffer( wxS( "A" ) );
819 std::shared_ptr<SYMBOL_BUFFER> bufB = libBuffer.GetBuffer( wxS( "B" ) );
820
821 BOOST_REQUIRE( bufA );
822 BOOST_REQUIRE( bufB );
823
824 renameBuffer( libBuffer, *bufA, wxS( "B" ) );
825 renameBuffer( libBuffer, *bufB, wxS( "A" ) );
826 saveLibrary( libBuffer, path );
827
828 BOOST_CHECK( inLibrary( path, wxS( "A" ) ) );
829 BOOST_CHECK( inLibrary( path, wxS( "B" ) ) );
830
831 wxFileName::Rmdir( dir, wxPATH_RMDIR_RECURSIVE );
832}
833
834
838BOOST_AUTO_TEST_CASE( RenamedSymbolLosesItsOldName )
839{
840 wxString dir;
841 wxString path = makeTempLibrary( { wxS( "Old" ) }, dir );
842
843 LIB_BUFFER libBuffer( wxS( "TestLibrary" ) );
844 bufferSymbols( libBuffer, path, { wxS( "Old" ) } );
845
846 std::shared_ptr<SYMBOL_BUFFER> buf = libBuffer.GetBuffer( wxS( "Old" ) );
847
848 BOOST_REQUIRE( buf );
849
850 renameBuffer( libBuffer, *buf, wxS( "New" ) );
851 saveLibrary( libBuffer, path );
852
853 BOOST_CHECK( inLibrary( path, wxS( "New" ) ) );
854 BOOST_CHECK( !inLibrary( path, wxS( "Old" ) ) );
855
856 wxFileName::Rmdir( dir, wxPATH_RMDIR_RECURSIVE );
857}
858
859
860/*
861 * A pull can change a library under the editor's buffers. Saving one edited symbol must keep what the
862 * file now holds for the others, and leave its derived symbols derived.
863 */
864BOOST_AUTO_TEST_CASE( SaveKeepsChangesMadeUnderTheBuffer )
865{
866 wxString tempDir = wxFileName::CreateTempFileName( wxS( "kicad_test_" ) );
867 wxRemoveFile( tempDir );
868 wxFileName::Mkdir( tempDir );
869 wxString libPath = wxFileName( tempDir, wxS( "4xxx.kicad_sym" ) ).GetFullPath();
870
871 BOOST_REQUIRE( wxCopyFile( KI_TEST::GetEeschemaTestDataDir() + "/libs/4xxx.kicad_sym", libPath ) );
872
873 LIB_BUFFER libBuffer( wxS( "4xxx" ) );
874
875 {
876 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
877 std::vector<LIB_SYMBOL*> originals;
878 plugin->EnumerateSymbolLib( originals, libPath );
879
880 for( LIB_SYMBOL* symbol : originals )
881 {
882 if( libBuffer.GetSymbol( symbol->GetName() ) )
883 continue;
884
885 auto copy = std::make_unique<LIB_SYMBOL>( *symbol );
886
887 if( symbol->IsDerived() )
888 {
889 LIB_SYMBOL* parent = libBuffer.GetSymbol( symbol->GetParent().lock()->GetName() );
890
891 if( !parent )
892 {
893 auto newParent = std::make_unique<LIB_SYMBOL>( *symbol->GetParent().lock() );
894 parent = newParent.get();
895 libBuffer.CreateBuffer( std::move( newParent ), std::make_unique<SCH_SCREEN>() );
896 }
897
898 copy->SetParent( parent );
899 }
900
901 libBuffer.CreateBuffer( std::move( copy ), std::make_unique<SCH_SCREEN>() );
902 }
903 }
904
905 {
906 wxFFile file( libPath, wxS( "rb" ) );
907 std::string text( static_cast<size_t>( file.Length() ), '\0' );
908 BOOST_REQUIRE( file.Read( text.data(), text.size() ) == text.size() );
909 file.Close();
910
911 size_t description = text.find( "Dual D FlipFlop, Set & reset" );
912 BOOST_REQUIRE( description != std::string::npos );
913 text.replace( description, 29, "Dual D flip-flop, pulled" );
914
915 wxFFile out( libPath, wxS( "wb" ) );
916 BOOST_REQUIRE( out.Write( text.data(), text.size() ) == text.size() );
917 }
918
919 std::shared_ptr<SYMBOL_BUFFER> edited = libBuffer.GetBuffer( wxS( "4016" ) );
920 BOOST_REQUIRE( edited );
921 edited->GetSymbol().GetDescriptionField().SetText( wxS( "Quad bilateral switch, edited" ) );
922 edited->GetScreen()->SetContentModified();
923
924 // The second save has nothing modified and must leave the file whole
925 for( int ii = 0; ii < 2; ++ii )
926 {
927 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
928 BOOST_CHECK( libBuffer.SaveModifiedBuffers( libPath, &*plugin ) );
929 plugin->SaveLibrary( libPath );
930 edited->GetScreen()->SetContentModified( false );
931 }
932
933 IO_RELEASER<SCH_IO> plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
934 LIB_SYMBOL* pulled = plugin->LoadSymbol( libPath, wxS( "4013" ) );
935 LIB_SYMBOL* parent = plugin->LoadSymbol( libPath, wxS( "4016" ) );
936 LIB_SYMBOL* derived = plugin->LoadSymbol( libPath, wxS( "4066" ) );
937
938 BOOST_REQUIRE( pulled && parent && derived );
939 BOOST_CHECK_EQUAL( pulled->GetDescription(), wxS( "Dual D flip-flop, pulled" ) );
940 BOOST_CHECK_EQUAL( parent->GetDescription(), wxS( "Quad bilateral switch, edited" ) );
941 BOOST_CHECK( derived->IsDerived() );
942
943 wxFileName::Rmdir( tempDir, wxPATH_RMDIR_RECURSIVE );
944}
945
946
const char * name
void SetContentModified(bool aModified=true)
Definition base_screen.h:55
Store a working copy of a library.
void ClearAddedAndDeletedBufferLists()
bool CreateBuffer(std::unique_ptr< LIB_SYMBOL > aCopy, std::unique_ptr< SCH_SCREEN > aScreen, bool aNew=false)
Create a new buffer to store a symbol. LIB_BUFFER takes ownership of aCopy.
bool IsModified() const
bool DeleteBuffer(const SYMBOL_BUFFER &aSymbolBuf)
Delete the given symbol buffer from the library buffer.
bool SaveModifiedBuffers(const wxString &aFileName, SCH_IO *aPlugin)
Save the modified symbols back to the library's own file aFileName.
void GetSymbolNames(wxArrayString &aSymbolNames, SYMBOL_NAME_FILTER aFilter=SYMBOL_NAME_FILTER::ALL)
Fetch a list of root symbols names from the library buffer.
const std::deque< std::shared_ptr< SYMBOL_BUFFER > > & GetDeletedBuffers() const
Return the deleted symbol buffers that need to be removed from the library file.
size_t GetDerivedSymbolNames(const wxString &aSymbolName, wxArrayString &aList) const
Fetch all of the symbols derived from a aSymbolName into aList.
bool SaveBuffer(SYMBOL_BUFFER &aSymbolBuf, const wxString &aFileName, SCH_IO *aPlugin, bool aBuffer)
Save stored modifications using a plugin.
const std::deque< std::shared_ptr< SYMBOL_BUFFER > > & GetBuffers() const
Return all buffered symbols.
std::shared_ptr< SYMBOL_BUFFER > GetBuffer(const wxString &aAlias) const
Return a symbol buffer with LIB_SYMBOL holding a symbolic alias.
LIB_SYMBOL * GetSymbol(const wxString &aAlias) const
Return the working copy of a LIB_SYMBOL root object with specified alias.
bool HasDerivedSymbols(const wxString &aParentName) const
Check to see any symbols in the buffer are derived from a parent named aParentName.
bool UpdateBuffer(SYMBOL_BUFFER &aSymbolBuf, const LIB_SYMBOL &aCopy)
Update the buffered symbol with the contents of aCopy.
static std::unique_ptr< LIB_SYMBOL > CreateSymbol(const NEW_SYMBOL_PROPERTIES &aProps, LIB_SYMBOL *aParent)
Define a library symbol object.
Definition lib_symbol.h:114
SCH_FIELD & GetDescriptionField()
Definition lib_symbol.h:465
wxString GetDescription() const override
Get the Description field text value *‍/.
Definition lib_symbol.h:202
std::weak_ptr< LIB_SYMBOL > & GetParent()
Definition lib_symbol.h:152
bool IsDerived() const
Definition lib_symbol.h:241
void SetParent(LIB_SYMBOL *aParent=nullptr)
wxString GetName() const override
Definition lib_symbol.h:183
SCH_FIELD & GetValueField()
Definition lib_symbol.h:449
const wxString & GetParentName() const
Definition lib_symbol.h:997
void SetParentName(const wxString &aParentName)
Definition lib_symbol.h:996
void SetText(const wxString &aText) override
static void SaveSymbol(LIB_SYMBOL *aSymbol, OUTPUTFORMATTER &aFormatter, const wxString &aLibName=wxEmptyString, bool aIncludeData=true)
static const char * PropBuffering
The property used internally by the plugin to enable cache buffering which prevents the library file ...
Implement an OUTPUTFORMATTER to a memory buffer.
Definition richio.h:430
const std::string & GetString()
Definition richio.h:453
LIB_SYMBOL & GetSymbol() const
SCH_SCREEN * GetScreen() const
LIB_SYMBOL & GetOriginal() const
void SetOriginal(std::unique_ptr< LIB_SYMBOL > aSymbol)
std::unique_ptr< T > IO_RELEASER
Helper to hold and release an IO_BASE object when exceptions are thrown.
Definition io_mgr.h:33
std::string GetEeschemaTestDataDir()
Get the configured location of Eeschema test data.
@ USER
The field ID hasn't been set yet; field is invalid.
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
BOOST_CHECK(res.column_datatype(0)==SQL_NUMERIC||res.column_datatype(0)==SQL_DECIMAL)
BOOST_REQUIRE_EQUAL(rows.size(), 1)
BOOST_CHECK_EQUAL(std::any_cast< std::string >(rows[0].at("val")), "12345678901234567.89")
BOOST_REQUIRE(res.columns()==1)
BOOST_AUTO_TEST_SUITE_END()
std::string path
BOOST_AUTO_TEST_CASE(SymbolBuffer)
Test the SYMBOL_BUFFER object.