KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_drc_rule_editor.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) 2024 KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU 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 <wx/ffile.h>
22#include <board.h>
23#include <core/typeinfo.h>
35#include <drc/drc_rule.h>
43#include <drc/drc_engine.h>
45#include <drc/drc_rule_parser.h>
48#include <reporter.h>
49#include <footprint.h>
51
52BOOST_AUTO_TEST_SUITE( DRC_RULE_EDITOR )
53
54BOOST_AUTO_TEST_CASE( RoundTripViaStyle )
55{
56 DRC_RE_VIA_STYLE_CONSTRAINT_DATA original( 0, "My_Via_Rule", 0.5, 0.8, 0.2, 0.4 );
57 original.SetConstraintCode( "via_style" );
58 original.SetRuleCondition( "A.NetClass == 'Power'" );
59
61 ctx.ruleName = original.GetRuleName();
63 ctx.constraintCode = original.GetConstraintCode();
64
65 wxString ruleText = original.GenerateRule( ctx );
66
67 auto parsedRules = DRC_RULE_EDITOR_UTILS::ParseRules( ruleText );
68
69 BOOST_REQUIRE_EQUAL( parsedRules.size(), 1 );
70 auto parsed = std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( parsedRules[0] );
71 BOOST_REQUIRE( parsed );
72
73 BOOST_CHECK_EQUAL( parsed->GetRuleName(), original.GetRuleName() );
74 BOOST_CHECK_EQUAL( parsed->GetRuleCondition(), original.GetRuleCondition() );
75 BOOST_CHECK_CLOSE( parsed->GetMinViaDiameter(), original.GetMinViaDiameter(), 0.0001 );
76 BOOST_CHECK_CLOSE( parsed->GetMaxViaDiameter(), original.GetMaxViaDiameter(), 0.0001 );
77 BOOST_CHECK_CLOSE( parsed->GetMinViaHoleSize(), original.GetMinViaHoleSize(), 0.0001 );
78 BOOST_CHECK_CLOSE( parsed->GetMaxViaHoleSize(), original.GetMaxViaHoleSize(), 0.0001 );
79}
80
81
82BOOST_AUTO_TEST_CASE( ShowMatchesIgnoresPairTokensInStringLiterals )
83{
84 BOARD board;
85
86 FOOTPRINT* footprint = new FOOTPRINT( &board );
87 footprint->SetReference( wxT( "B.Width" ) );
88 board.Add( footprint );
89
90 auto rule = std::make_shared<DRC_RULE>( wxT( "String literal" ) );
91 rule->m_Condition = new DRC_RULE_CONDITION( wxT( "A.Reference == 'B.Width'" ) );
92 BOOST_REQUIRE( rule->m_Condition->Compile( nullptr ) );
93
95 rule->AddConstraint( constraint );
96
97 DRC_ENGINE engine( &board, &board.GetDesignSettings() );
98 std::vector<BOARD_ITEM*> matches = engine.GetItemsMatchingRule( rule, nullptr );
99
100 BOOST_REQUIRE_EQUAL( matches.size(), 1u );
101 BOOST_CHECK_EQUAL( matches.front(), footprint );
102}
103
104
105BOOST_AUTO_TEST_CASE( RoundTripRoutingWidth )
106{
107 DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA original( 0, "My_Track_Rule", 0.3, 0.1 );
108 original.SetConstraintCode( "track_width" );
109 original.SetRuleCondition( "A.NetClass == 'Signal'" );
110
112 ctx.ruleName = original.GetRuleName();
113 ctx.conditionExpression = original.GetRuleCondition();
114 ctx.constraintCode = original.GetConstraintCode();
115
116 wxString ruleText = original.GenerateRule( ctx );
117
118 auto parsedRules = DRC_RULE_EDITOR_UTILS::ParseRules( ruleText );
119
120 BOOST_REQUIRE_EQUAL( parsedRules.size(), 1 );
121 auto parsed = std::dynamic_pointer_cast<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>( parsedRules[0] );
122 BOOST_REQUIRE( parsed );
123
124 BOOST_CHECK_EQUAL( parsed->GetRuleName(), original.GetRuleName() );
125 BOOST_CHECK_EQUAL( parsed->GetRuleCondition(), original.GetRuleCondition() );
126 BOOST_CHECK_CLOSE( parsed->GetOptWidth(), original.GetOptWidth(), 0.0001 );
127 BOOST_CHECK_CLOSE( parsed->GetWidthTolerance(), original.GetWidthTolerance(), 0.0001 );
128}
129
131{
132 std::vector<std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>> rules;
133
134 auto rule1 = std::make_shared<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( 0, "ViaRule", 0.5, 0.8, 0.2, 0.4 );
135 rule1->SetConstraintCode( "via_style" );
136 rule1->SetRuleCondition( "A.NetClass == 'Power'" );
137 rules.push_back( rule1 );
138
139 auto rule2 = std::make_shared<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>( 0, "TrackRule", 0.3, 0.1 );
140 rule2->SetConstraintCode( "track_width" );
141 rule2->SetRuleCondition( "A.NetClass == 'Signal'" );
142 rules.push_back( rule2 );
143
144 wxString filename = "test_rules.dru";
145
146 // We pass nullptr for board, so layers won't be saved, which is fine for this test
147 bool result = DRC_RULE_EDITOR_UTILS::SaveRules( filename, rules, nullptr );
149
150 wxFFile file( filename );
151 BOOST_REQUIRE( file.IsOpened() );
152 wxString content;
153 file.ReadAll( &content );
154 file.Close();
155
156 // Verify content
157 BOOST_CHECK( content.Contains( "(version 2)" ) );
158 BOOST_CHECK( content.Contains( "(rule ViaRule" ) );
159 BOOST_CHECK( content.Contains( "(constraint via_diameter" ) );
160 BOOST_CHECK( content.Contains( "(constraint hole_size" ) );
161 BOOST_CHECK( content.Contains( "(rule TrackRule" ) );
162 BOOST_CHECK( content.Contains( "(constraint track_width" ) );
163
164 // Clean up
165 wxRemoveFile( filename );
166}
167
168BOOST_AUTO_TEST_CASE( RoundTripPreservesUneditedRuleWithCommentParens )
169{
170 // The parens inside the comment must not move the rule boundary.
171 wxString input = "(version 2)\n"
172 "(rule MyRule\n"
173 "\t(constraint clearance (min 0.2mm))\n"
174 "\t# old: (condition \"A.x\"))\n"
175 "\t(severity error))\n";
176
177 DRC_RULE_LOADER loader;
178 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( input );
179
180 BOOST_REQUIRE( !entries.empty() );
181
182 BOOST_CHECK( entries[0].originalRuleText.Contains( "(severity error)" ) );
183 BOOST_CHECK( entries[0].originalRuleText.Contains( "# old:" ) );
184 BOOST_CHECK( !entries[0].wasEdited );
185
186 DRC_RULE_SAVER saver;
187 wxString output = saver.GenerateRulesText( entries, nullptr );
188
189 BOOST_CHECK( output.Contains( "(rule MyRule" ) );
190 BOOST_CHECK( output.Contains( "# old: (condition \"A.x\"))" ) );
191 BOOST_CHECK( output.Contains( "(severity error))" ) );
192
193 DRC_RULE_LOADER loader2;
194 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reparsed = loader2.LoadFromString( output );
195 BOOST_CHECK( !reparsed.empty() );
196}
197
198BOOST_AUTO_TEST_CASE( SaveNumericRules )
199{
200 auto rule = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( 0, 0.2, "ClearanceRule" );
201 rule->SetConstraintCode( "clearance" );
202
204 ctx.ruleName = rule->GetRuleName();
205 ctx.constraintCode = rule->GetConstraintCode();
206
207 wxString ruleText = rule->GenerateRule( ctx );
208
209 BOOST_CHECK( ruleText.Contains( "(constraint clearance (min 0.2mm))" ) );
210
211 // Test via_count (max, unitless)
212 auto rule2 = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( 0, 10, "ViaCountRule" );
213 rule2->SetConstraintCode( "via_count" );
214 ctx.ruleName = rule2->GetRuleName();
215 ctx.constraintCode = rule2->GetConstraintCode();
216
217 ruleText = rule2->GenerateRule( ctx );
218 BOOST_CHECK( ruleText.Contains( "(constraint via_count (max 10))" ) );
219
220 // Test track_angle (min, deg)
221 auto rule3 = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( 0, 45, "AngleRule" );
222 rule3->SetConstraintCode( "track_angle" );
223 ctx.ruleName = rule3->GetRuleName();
224 ctx.constraintCode = rule3->GetConstraintCode();
225
226 ruleText = rule3->GenerateRule( ctx );
227 BOOST_CHECK( ruleText.Contains( "(constraint track_angle (min 45deg))" ) );
228}
229
230BOOST_AUTO_TEST_CASE( SaveBoolRules )
231{
232 auto rule = std::make_shared<DRC_RE_BOOL_INPUT_CONSTRAINT_DATA>( 0, true, "DisallowTestRule" );
233 rule->SetConstraintCode( "disallow" );
234
236 ctx.ruleName = rule->GetRuleName();
237 ctx.constraintCode = rule->GetConstraintCode();
238
239 wxString ruleText = rule->GenerateRule( ctx );
240
241 BOOST_CHECK( ruleText.Contains( "(constraint disallow)" ) );
242
243 // Test false value (should not generate constraint)
244 auto rule2 = std::make_shared<DRC_RE_BOOL_INPUT_CONSTRAINT_DATA>( 0, false, "NoDisallowTestRule" );
245 rule2->SetConstraintCode( "disallow" );
246 ctx.ruleName = rule2->GetRuleName();
247 ctx.constraintCode = rule2->GetConstraintCode();
248
249 ruleText = rule2->GenerateRule( ctx );
250 BOOST_CHECK( ruleText.IsEmpty() );
251}
252
253BOOST_AUTO_TEST_CASE( ParseRulesCategories )
254{
255 wxString rules =
256 "(version 1)\n"
257 "(rule \"Clearance Rule\"\n"
258 "\t(constraint clearance (min 0.2mm))\n"
259 "\t(condition \"A.NetClass == 'Power'\"))\n"
260 "(rule \"Via Style Rule\"\n"
261 "\t(constraint via_diameter (min 0.5mm))\n"
262 "\t(constraint hole_size (min 0.3mm))\n"
263 "\t(condition \"A.NetClass == 'Power'\"))\n";
264
265 auto parsedRules = DRC_RULE_EDITOR_UTILS::ParseRules( rules );
266
267 BOOST_REQUIRE_EQUAL( parsedRules.size(), 2 );
268
269 // Check Clearance Rule
270 auto clearanceRule = parsedRules[0];
271 BOOST_CHECK_EQUAL( clearanceRule->GetRuleName(), "Clearance Rule" );
272 BOOST_CHECK_EQUAL( clearanceRule->GetConstraintCode(), "clearance" );
273
274 // Verify it is a numeric constraint data
275 auto numericData = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( clearanceRule );
276 BOOST_REQUIRE( numericData );
277 BOOST_CHECK_CLOSE( numericData->GetNumericInputValue(), 0.2, 0.0001 );
278
279 // Check Via Style Rule
280 auto viaStyleRule = parsedRules[1];
281 BOOST_CHECK_EQUAL( viaStyleRule->GetRuleName(), "Via Style Rule" );
282 BOOST_CHECK_EQUAL( viaStyleRule->GetConstraintCode(), "via_style" );
283
284 auto viaData = std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( viaStyleRule );
285 BOOST_REQUIRE( viaData );
286 BOOST_CHECK_CLOSE( viaData->GetMinViaDiameter(), 0.5, 0.0001 );
287 BOOST_CHECK_CLOSE( viaData->GetMinViaHoleSize(), 0.3, 0.0001 );
288}
289
290BOOST_AUTO_TEST_CASE( FactoryRegistration )
291{
292 // Register a custom parser for 'clearance' to override default
293 bool parserCalled = false;
295 [&]( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA>
296 {
297 if( aRule->FindConstraint( CLEARANCE_CONSTRAINT ) )
298 {
299 parserCalled = true;
300 auto data = std::make_shared<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( 0, aRule->m_Name );
301 data->SetConstraintCode( "custom_clearance" );
302 return data;
303 }
304 return nullptr;
305 } );
306
307 wxString ruleText = "(version 1) (rule \"Test Rule\" (constraint clearance (min 1.0mm)) (condition \"A.Type == 'Pad'\"))";
308 auto parsedRules = DRC_RULE_EDITOR_UTILS::ParseRules( ruleText );
309
310 BOOST_CHECK( parserCalled );
311 BOOST_REQUIRE_EQUAL( parsedRules.size(), 1 );
312 BOOST_CHECK_EQUAL( parsedRules[0]->GetConstraintCode(), "custom_clearance" );
313}
314
315BOOST_AUTO_TEST_CASE( ValidateViaStyleValid )
316{
317 DRC_RE_VIA_STYLE_CONSTRAINT_DATA data( 0, "ValidRule", 0.5, 0.8, 0.2, 0.4 );
318
320
321 BOOST_CHECK( result.isValid );
322 BOOST_CHECK( result.errors.empty() );
323}
324
325BOOST_AUTO_TEST_CASE( ValidateViaStyleInvalidMinGreaterThanMax )
326{
327 // min > max for via diameter
328 DRC_RE_VIA_STYLE_CONSTRAINT_DATA data( 0, "InvalidRule", 0.9, 0.5, 0.2, 0.4 );
329
331
332 BOOST_CHECK( !result.isValid );
333 BOOST_CHECK( !result.errors.empty() );
334
335 // Should have error about min > max
336 bool foundMinMaxError = false;
337 for( const auto& error : result.errors )
338 {
339 if( error.find( "Minimum Via Diameter cannot be greater than Maximum Via Diameter" ) != std::string::npos )
340 foundMinMaxError = true;
341 }
342 BOOST_CHECK( foundMinMaxError );
343}
344
345BOOST_AUTO_TEST_CASE( ValidateViaStyleInvalidNegativeValues )
346{
347 // Negative values
348 DRC_RE_VIA_STYLE_CONSTRAINT_DATA data( 0, "NegativeRule", -0.5, 0.8, 0.2, 0.4 );
349
351
352 BOOST_CHECK( !result.isValid );
353 BOOST_CHECK( !result.errors.empty() );
354
355 // Should have error about negative value
356 bool foundNegativeError = false;
357 for( const auto& error : result.errors )
358 {
359 if( error.find( "cannot be negative" ) != std::string::npos )
360 foundNegativeError = true;
361 }
362 BOOST_CHECK( foundNegativeError );
363}
364
365// Deleting one entry of a rule the loader split must not bring it back on save.
366BOOST_AUTO_TEST_CASE( DeletedSplitEntryStaysDeleted )
367{
368 wxString rules = wxS( "(version 1)\n"
369 "(rule \"Combo\"\n"
370 " (condition \"A.NetClass == 'HV'\")\n"
371 " (constraint clearance (min 0.5mm))\n"
372 " (constraint track_width (min 0.25mm) (opt 0.3mm) (max 0.35mm)))\n" );
373
374 DRC_RULE_LOADER loader;
375
376 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( rules );
377
378 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
379
380 // The user deletes the sibling that does not hold the original rule text.
381 auto deleted = std::find_if( entries.begin(), entries.end(),
382 []( const DRC_RE_LOADED_PANEL_ENTRY& aEntry )
383 {
384 return aEntry.originalRuleText.IsEmpty();
385 } );
386
387 BOOST_REQUIRE( deleted != entries.end() );
388 entries.erase( deleted );
389
390 DRC_RULE_SAVER saver;
391 wxString saved = saver.GenerateRulesText( entries, nullptr );
392
393 int constraints = 0;
394
395 for( size_t pos = saved.find( wxS( "(constraint" ) ); pos != wxString::npos;
396 pos = saved.find( wxS( "(constraint" ), pos + 1 ) )
397 {
398 constraints++;
399 }
400
401 BOOST_CHECK_EQUAL( constraints, 1 );
402}
403
404
405// Regenerated rules must keep their layers on a board with user layer names
406BOOST_AUTO_TEST_CASE( EditedRulesKeepTheirLayers )
407{
408 const std::string path = KI_TEST::GetPcbnewTestDataDir() + "issue24211/issue24211";
409
410 PCB_IO_KICAD_SEXPR plugin;
411 std::unique_ptr<BOARD> board = plugin.LoadBoard( path + ".kicad_pcb" );
412
413 BOOST_REQUIRE( board );
414 BOOST_REQUIRE( board->GetLayerName( F_Cu ) == wxS( "top_layer" ) );
415
416 auto layersByRule =
417 []( const wxString& aText )
418 {
419 DRC_RULES_PARSER parser( aText, wxS( "issue24211" ) );
421 std::vector<std::shared_ptr<DRC_RULE>> rules;
422
423 parser.Parse( rules, &reporter );
424
425 BOOST_CHECK_MESSAGE( !reporter.HasMessageOfSeverity( RPT_SEVERITY_ERROR ),
426 reporter.GetMessages().ToStdString() << aText.ToStdString() );
427
428 std::map<wxString, LSET> layers;
429
430 for( const std::shared_ptr<DRC_RULE>& rule : rules )
431 layers[rule->m_Name] = rule->m_LayerCondition;
432
433 return layers;
434 };
435
436 wxString original;
437 wxFFile file( path + ".kicad_dru", "r" );
438
439 BOOST_REQUIRE( file.ReadAll( &original ) );
440
441 DRC_RULE_LOADER loader;
442 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFile( path + ".kicad_dru" );
443
444 BOOST_REQUIRE( !entries.empty() );
445
446 for( DRC_RE_LOADED_PANEL_ENTRY& entry : entries )
447 entry.wasEdited = true;
448
449 DRC_RULE_SAVER saver;
450
451 BOOST_CHECK( layersByRule( saver.GenerateRulesText( entries, board.get() ) ) == layersByRule( original ) );
452
453 // A layer set without source text, as a caller other than the loader builds it
454 entries.resize( 1 );
455 entries[0].layerCondition = LSET( { F_Cu } );
456
457 std::map<wxString, LSET> single = layersByRule( saver.GenerateRulesText( entries, board.get() ) );
458
459 BOOST_CHECK( single[entries[0].ruleName] == LSET( { F_Cu } ) );
460}
461
462
463// A negative optimum is an error, not an absent field.
464BOOST_AUTO_TEST_CASE( ValidateDiffPairRejectsNegativeOptimums )
465{
466 DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA negWidth( 0, "NegWidth", -0.2, 0.0, 0.2, 0.02, 0.0 );
467
468 BOOST_CHECK( !negWidth.Validate().isValid );
469
470 DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA negGap( 0, "NegGap", 0.2, 0.02, -0.2, 0.0, 0.0 );
471
472 BOOST_CHECK( !negGap.Validate().isValid );
473
474 // Zero still means the field was left empty.
475 DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA gapOnly( 0, "GapOnly", 0.0, 0.0, 0.2, 0.02, 0.0 );
476
477 BOOST_CHECK( gapOnly.Validate().isValid );
478}
479
480BOOST_AUTO_TEST_CASE( FactoryOverwrite )
481{
482 // Register a parser
484 []( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA> {
485 if( aRule->m_Name == "Test" )
486 return std::make_shared<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( 0, aRule->m_Name + "_1" );
487 return nullptr;
488 } );
489
490 // Overwrite it (prepend)
492 []( const std::shared_ptr<DRC_RULE>& aRule ) -> std::shared_ptr<DRC_RE_BASE_CONSTRAINT_DATA> {
493 if( aRule->m_Name == "Test" )
494 return std::make_shared<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( 0, aRule->m_Name + "_2" );
495 return nullptr;
496 } );
497
498 wxString ruleText = "(version 1) (rule \"Test\" (constraint clearance (min 1.0mm)))";
499 auto parsedRules = DRC_RULE_EDITOR_UTILS::ParseRules( ruleText );
500
501 BOOST_REQUIRE_EQUAL( parsedRules.size(), 1 );
502 BOOST_CHECK_EQUAL( parsedRules[0]->GetRuleName(), "Test_2" );
503}
504
505// Editing a via style rule must not delete the optimum the panel cannot show.
506BOOST_AUTO_TEST_CASE( EditedViaStyleRuleKeepsOptimums )
507{
508 wxString rules = wxS( "(version 1)\n"
509 "(rule ViaOpt\n"
510 " (constraint via_diameter (min 0.4mm) (opt 0.8mm) (max 1.2mm))\n"
511 " (constraint hole_size (min 0.2mm) (opt 0.4mm) (max 0.6mm)))\n" );
512
513 DRC_RULE_LOADER loader;
514
515 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( rules );
516
517 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
518
519 entries[0].wasEdited = true;
520
521 DRC_RULE_SAVER saver;
522 wxString saved = saver.GenerateRulesText( entries, nullptr );
523
524 BOOST_CHECK_MESSAGE( saved.find( wxS( "(opt 0.8mm)" ) ) != wxString::npos,
525 "the via diameter optimum was dropped: " << saved.ToStdString() );
526 BOOST_CHECK_MESSAGE( saved.find( wxS( "(opt 0.4mm)" ) ) != wxString::npos,
527 "the hole size optimum was dropped: " << saved.ToStdString() );
528
529 auto data = std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( entries[0].constraintData );
530
531 BOOST_REQUIRE( data );
532 data->SetMinViaDiameter( 0.9 );
533
534 BOOST_CHECK( data->Validate().isValid );
535
536 saved = saver.GenerateRulesText( entries, nullptr );
537
538 BOOST_CHECK_MESSAGE( saved.find( wxS( "(constraint via_diameter (min 0.9mm) (max 1.2mm))" ) ) != wxString::npos,
539 "the voided optimum was not dropped from the clause: " << saved.ToStdString() );
540 BOOST_CHECK_MESSAGE( saved.find( wxS( "(opt 0.4mm)" ) ) != wxString::npos,
541 "the untouched hole size optimum must survive: " << saved.ToStdString() );
542}
543
544
545BOOST_AUTO_TEST_CASE( RegeneratedRuleWithoutLayerClauseStaysOnAllLayers )
546{
547 wxString rules = wxS( "(version 2)\n"
548 "(rule \"under_fpga\"\n"
549 "\t(constraint clearance (min 0.1mm))\n"
550 "\t(constraint hole_size (min 0.2mm) (max 0.5mm))\n"
551 "\t(constraint via_diameter (min 0.4mm) (max 0.9mm))\n"
552 "\t(condition \"A.intersectsArea('underFPGA')\"))\n" );
553
554 BOARD board;
555 DRC_RULE_LOADER loader;
556
557 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( rules );
558
559 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
560
561 for( DRC_RE_LOADED_PANEL_ENTRY& entry : entries )
562 {
563 if( entry.panelType == MINIMUM_CLEARANCE )
564 entry.wasEdited = true;
565 }
566
567 DRC_RULE_SAVER saver;
568 wxString saved = saver.GenerateRulesText( entries, &board );
569
570 BOOST_CHECK_MESSAGE( saved.find( wxS( "(layer" ) ) == wxString::npos,
571 "a rule without a layer clause gained one: " << saved.ToStdString() );
572}
573
574
575BOOST_AUTO_TEST_CASE( MovedRuleKeepsItsOwnComment )
576{
577 wxString rules = wxS( "(version 2)\n"
578 "# file header\n"
579 "\n"
580 "(rule \"a\"\n"
581 "\t(constraint clearance (min 0.1mm)))\n"
582 "\n"
583 "# b is special\n"
584 "(rule \"b\"\n"
585 "\t(constraint clearance (min 0.2mm)))\n" );
586
587 DRC_RULE_LOADER loader;
588
589 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( rules );
590
591 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
592
593 std::swap( entries[0], entries[1] );
594
595 DRC_RULE_SAVER saver;
596 wxString saved = saver.GenerateRulesText( entries, nullptr, loader.GetFileTrivia() );
597
598 BOOST_CHECK_MESSAGE( saved.find( wxS( "# b is special\n(rule \"b\"" ) ) != wxString::npos,
599 "the comment did not move with its rule: " << saved.ToStdString() );
600 BOOST_CHECK_MESSAGE( saved.find( wxS( "# file header" ) ) < saved.find( wxS( "(rule" ) ),
601 "the file header did not stay first: " << saved.ToStdString() );
602 BOOST_CHECK_EQUAL( saved.Freq( '#' ), 2 );
603 BOOST_CHECK( saved.find( wxS( "(rule \"b\"" ) ) < saved.find( wxS( "(rule \"a\"" ) ) );
604}
605
606
607BOOST_AUTO_TEST_CASE( ViaStyleWithoutMaximumRoundTrips )
608{
609 wxString rules = wxS( "(version 2)\n"
610 "(rule \"small_vias\"\n"
611 "\t(constraint hole_size (min 0.2mm))\n"
612 "\t(constraint via_diameter (min 0.4mm)))\n" );
613
614 DRC_RULE_LOADER loader;
615
616 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( rules );
617
618 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
619 BOOST_REQUIRE_EQUAL( entries[0].panelType, VIA_STYLE );
620
621 entries[0].wasEdited = true;
622
623 BOOST_CHECK( entries[0].constraintData->Validate().isValid );
624
625 DRC_RULE_SAVER saver;
626 wxString saved = saver.GenerateRulesText( entries, nullptr );
627
628 BOOST_CHECK_MESSAGE( saved.find( wxS( "(max" ) ) == wxString::npos,
629 "an open upper limit was written as a number: " << saved.ToStdString() );
630 BOOST_CHECK_MESSAGE( saved.find( wxS( "(constraint via_diameter (min 0.4mm))" ) ) != wxString::npos,
631 "the via diameter minimum was lost: " << saved.ToStdString() );
632 BOOST_CHECK_MESSAGE( saved.find( wxS( "(constraint hole_size (min 0.2mm))" ) ) != wxString::npos,
633 "the hole size minimum was lost: " << saved.ToStdString() );
634}
635
636
637// A pair with both ends negative is an error, not an empty pair.
638BOOST_AUTO_TEST_CASE( ValidateViaStyleBothNegative )
639{
640 DRC_RE_VIA_STYLE_CONSTRAINT_DATA data( 0, "BothNegative", -0.5, -0.2, 0.2, 0.4 );
641
642 BOOST_CHECK( !data.Validate().isValid );
643}
644
645
646BOOST_AUTO_TEST_CASE( ValidateAbsLengthTwoValid )
647{
648 // Valid: min < opt < max, all positive
649 DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA data( 0, 3.0, 2.0, "ValidLengthRule" );
650
652
653 BOOST_CHECK( result.isValid );
654 BOOST_CHECK( result.errors.empty() );
655}
656
657BOOST_AUTO_TEST_CASE( ValidateAbsLengthTwoInvalid )
658{
659 // Invalid: tolerance too large, resulting minimum length is not positive
660 DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA data1( 0, 2.0, 5.0, "InvalidToleranceRule" );
661
662 VALIDATION_RESULT result1 = data1.Validate();
663
664 BOOST_CHECK( !result1.isValid );
665 BOOST_CHECK( !result1.errors.empty() );
666
667 bool foundToleranceError = false;
668
669 for( const auto& error : result1.errors )
670 {
671 if( error.find( "Tolerance is too large" ) != std::string::npos )
672 foundToleranceError = true;
673 }
674
675 BOOST_CHECK( foundToleranceError );
676
677 // Invalid: negative tolerance
678 DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA data2( 0, 3.0, -1.0, "NegativeToleranceRule" );
679
680 VALIDATION_RESULT result2 = data2.Validate();
681
682 BOOST_CHECK( !result2.isValid );
683
684 bool foundNegativeError = false;
685
686 for( const auto& error : result2.errors )
687 {
688 if( error.find( "Tolerance must be greater than or equal to 0" ) != std::string::npos )
689 foundNegativeError = true;
690 }
691
692 BOOST_CHECK( foundNegativeError );
693}
694
695BOOST_AUTO_TEST_CASE( ValidateDiffPairValid )
696{
697 // Valid: all positive, min <= preferred <= max for width and gap
698 // Constructor: id, parentId, ruleName, optWidth, widthTolerance, optGap, gapTolerance, maxUncoupledLength, maxSkew
699 DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA data( 0, "ValidDiffPairRule", 0.3, 0.1, 0.15, 0.05, 10.0 );
700
702
703 BOOST_CHECK( result.isValid );
704 BOOST_CHECK( result.errors.empty() );
705}
706
707BOOST_AUTO_TEST_CASE( ValidateDiffPairInvalid )
708{
709 // Invalid: min width > max width
710 DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA data1( 0, "InvalidWidthRule", 0.3, 0.5, 0.15, 0.05, 10.0 );
711
712 VALIDATION_RESULT result1 = data1.Validate();
713
714 BOOST_CHECK( !result1.isValid );
715 BOOST_CHECK( !result1.errors.empty() );
716
717 bool foundWidthError = false;
718 for( const auto& error : result1.errors )
719 {
720 if( error.find( "Width Tolerance must be less than Optimum Width" ) != std::string::npos )
721 foundWidthError = true;
722 }
723 BOOST_CHECK( foundWidthError );
724
725 // Invalid: negative gap
726 DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA data2( 0, "NegativeGapRule", 0.3, 0.1, 0.15, -0.1, 10.0 );
727
728 VALIDATION_RESULT result2 = data2.Validate();
729
730 BOOST_CHECK( !result2.isValid );
731
732 bool foundNegativeError = false;
733 for( const auto& error : result2.errors )
734 {
735 if( error.find( "must be greater than or equal to 0" ) != std::string::npos )
736 foundNegativeError = true;
737 }
738 BOOST_CHECK( foundNegativeError );
739}
740
741BOOST_AUTO_TEST_CASE( ValidatePermittedLayersValid )
742{
743 // Valid: at least one layer is selected (top layer enabled)
744 DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA data1( 0, "ValidTopLayerRule", true, false );
745
746 VALIDATION_RESULT result1 = data1.Validate();
747
748 BOOST_CHECK( result1.isValid );
749 BOOST_CHECK( result1.errors.empty() );
750
751 // Valid: at least one layer is selected (bottom layer enabled)
752 DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA data2( 0, "ValidBottomLayerRule", false, true );
753
754 VALIDATION_RESULT result2 = data2.Validate();
755
756 BOOST_CHECK( result2.isValid );
757 BOOST_CHECK( result2.errors.empty() );
758
759 // Valid: both layers enabled
760 DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA data3( 0, "ValidBothLayersRule", true, true );
761
762 VALIDATION_RESULT result3 = data3.Validate();
763
764 BOOST_CHECK( result3.isValid );
765 BOOST_CHECK( result3.errors.empty() );
766}
767
768BOOST_AUTO_TEST_CASE( ValidatePermittedLayersInvalid )
769{
770 // Invalid: no layers selected
771 DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA data( 0, "NoLayersRule", false, false );
772
774
775 BOOST_CHECK( !result.isValid );
776 BOOST_CHECK( !result.errors.empty() );
777
778 bool foundLayerError = false;
779 for( const auto& error : result.errors )
780 {
781 if( error.find( "At least one layer must be selected" ) != std::string::npos )
782 foundLayerError = true;
783 }
784 BOOST_CHECK( foundLayerError );
785}
786
787BOOST_AUTO_TEST_CASE( ValidateNumericInputValid )
788{
789 DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA data( 0, 0.5, "ValidRule" );
790
792
793 BOOST_CHECK( result.isValid );
794 BOOST_CHECK( result.errors.empty() );
795}
796
797BOOST_AUTO_TEST_CASE( ValidateNumericInputInvalidNegative )
798{
799 DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA data( 0, -0.5, "InvalidRule" );
800
802
803 BOOST_CHECK( !result.isValid );
804 BOOST_CHECK( !result.errors.empty() );
805
806 // Should have error about value not being greater than 0
807 bool foundError = false;
808 for( const auto& error : result.errors )
809 {
810 if( error.find( "must be greater than 0" ) != std::string::npos )
811 foundError = true;
812 }
813 BOOST_CHECK( foundError );
814}
815
816BOOST_AUTO_TEST_CASE( ValidateRoutingWidthValid )
817{
818 DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA data( 0, "ValidRule", 0.3, 0.1 );
819
821
822 BOOST_CHECK( result.isValid );
823 BOOST_CHECK( result.errors.empty() );
824}
825
826BOOST_AUTO_TEST_CASE( ValidateRoutingWidthInvalidToleranceTooLarge )
827{
828 // tolerance >= opt width
829 DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA data( 0, "InvalidRule", 0.3, 0.5 );
830
832
833 BOOST_CHECK( !result.isValid );
834 BOOST_CHECK( !result.errors.empty() );
835
836 bool foundError = false;
837 for( const auto& error : result.errors )
838 {
839 if( error.find( "Width Tolerance must be less than Optimum Width" ) != std::string::npos )
840 foundError = true;
841 }
842 BOOST_CHECK( foundError );
843}
844
845BOOST_AUTO_TEST_CASE( ValidateAllowedOrientationValid )
846{
847 // Valid: at least one orientation is selected (0 degrees)
848 DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA data1( 0, true, false, false, false, false, "ValidZeroDegRule" );
849
850 VALIDATION_RESULT result1 = data1.Validate();
851
852 BOOST_CHECK( result1.isValid );
853 BOOST_CHECK( result1.errors.empty() );
854
855 // Valid: 90 degrees selected
856 DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA data2( 0, false, true, false, false, false, "ValidNinetyDegRule" );
857
858 VALIDATION_RESULT result2 = data2.Validate();
859
860 BOOST_CHECK( result2.isValid );
861 BOOST_CHECK( result2.errors.empty() );
862
863 // Valid: all degrees selected
864 DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA data3( 0, false, false, false, false, true, "ValidAllDegreesRule" );
865
866 VALIDATION_RESULT result3 = data3.Validate();
867
868 BOOST_CHECK( result3.isValid );
869 BOOST_CHECK( result3.errors.empty() );
870
871 // Valid: multiple orientations selected
872 DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA data4( 0, true, true, false, false, false, "ValidMultipleRule" );
873
874 VALIDATION_RESULT result4 = data4.Validate();
875
876 BOOST_CHECK( result4.isValid );
877 BOOST_CHECK( result4.errors.empty() );
878}
879
880BOOST_AUTO_TEST_CASE( ValidateAllowedOrientationInvalid )
881{
882 // Invalid: no orientation selected
883 DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA data( 0, false, false, false, false, false, "NoOrientationRule" );
884
886
887 BOOST_CHECK( !result.isValid );
888 BOOST_CHECK( !result.errors.empty() );
889
890 bool foundOrientationError = false;
891 for( const auto& error : result.errors )
892 {
893 if( error.find( "At least one orientation must be selected" ) != std::string::npos )
894 foundOrientationError = true;
895 }
896 BOOST_CHECK( foundOrientationError );
897}
898
899BOOST_AUTO_TEST_CASE( ValidateBoolInputValid )
900{
901 // Test with true value
902 DRC_RE_BOOL_INPUT_CONSTRAINT_DATA dataTrue( 0, true, "BoolRuleTrue" );
903
904 VALIDATION_RESULT resultTrue = dataTrue.Validate();
905
906 BOOST_CHECK( resultTrue.isValid );
907 BOOST_CHECK( resultTrue.errors.empty() );
908
909 // Test with false value
910 DRC_RE_BOOL_INPUT_CONSTRAINT_DATA dataFalse( 0, false, "BoolRuleFalse" );
911
912 VALIDATION_RESULT resultFalse = dataFalse.Validate();
913
914 BOOST_CHECK( resultFalse.isValid );
915 BOOST_CHECK( resultFalse.errors.empty() );
916}
917
918BOOST_AUTO_TEST_CASE( ValidateMinTxtHtThValid )
919{
920 // Valid: both text height and thickness are positive
921 DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA data( 0, "ValidTextRule", 1.0, 0.15 );
922
924
925 BOOST_CHECK( result.isValid );
926 BOOST_CHECK( result.errors.empty() );
927}
928
929BOOST_AUTO_TEST_CASE( ValidateMinTxtHtThInvalid )
930{
931 // Invalid: negative text height
932 DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA data1( 0, "NegativeHeightRule", -1.0, 0.15 );
933
934 VALIDATION_RESULT result1 = data1.Validate();
935
936 BOOST_CHECK( !result1.isValid );
937 BOOST_CHECK( !result1.errors.empty() );
938
939 bool foundHeightError = false;
940 for( const auto& error : result1.errors )
941 {
942 if( error.find( "Minimum Text Height must be greater than 0" ) != std::string::npos )
943 foundHeightError = true;
944 }
945 BOOST_CHECK( foundHeightError );
946
947 // Invalid: negative text thickness
948 DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA data2( 0, "NegativeThicknessRule", 1.0, -0.15 );
949
950 VALIDATION_RESULT result2 = data2.Validate();
951
952 BOOST_CHECK( !result2.isValid );
953
954 bool foundThicknessError = false;
955 for( const auto& error : result2.errors )
956 {
957 if( error.find( "Minimum Text Thickness must be greater than 0" ) != std::string::npos )
958 foundThicknessError = true;
959 }
960 BOOST_CHECK( foundThicknessError );
961
962 // Invalid: both zero (default values)
964
965 VALIDATION_RESULT result3 = data3.Validate();
966
967 BOOST_CHECK( !result3.isValid );
968 BOOST_CHECK_EQUAL( result3.errors.size(), 2 );
969}
970
971BOOST_AUTO_TEST_CASE( ValidateCustomRuleValid )
972{
973 DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA data( 0, "ValidCustomRule" );
974 data.SetRuleText( "(constraint clearance (min 0.2mm))" );
975
977
978 BOOST_CHECK( result.isValid );
979 BOOST_CHECK( result.errors.empty() );
980}
981
982BOOST_AUTO_TEST_CASE( ValidateCustomRuleInvalid )
983{
984 DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA data( 0, "InvalidCustomRule" );
985 data.SetRuleText( "" );
986
988
989 BOOST_CHECK( !result.isValid );
990 BOOST_CHECK( !result.errors.empty() );
991
992 // Should have error about empty rule text
993 bool foundEmptyError = false;
994 for( const auto& error : result.errors )
995 {
996 if( error.find( "Rule text cannot be empty" ) != std::string::npos )
997 foundEmptyError = true;
998 }
999 BOOST_CHECK( foundEmptyError );
1000}
1001
1002
1003// ============================================================================
1004// Panel Matcher Tests (Phase 5.1)
1005// ============================================================================
1006
1007BOOST_AUTO_TEST_CASE( PanelMatcherExactMatchViaStyle )
1008{
1009 // Test: Rule with via_diameter + hole_size → VIA_STYLE panel
1010 DRC_RULE rule( "ViaStyleRule" );
1011
1013 viaDia.Value().SetMin( 500000 );
1014 viaDia.Value().SetOpt( 600000 );
1015 viaDia.Value().SetMax( 800000 );
1016 rule.AddConstraint( viaDia );
1017
1019 holeSize.Value().SetMin( 200000 );
1020 holeSize.Value().SetOpt( 300000 );
1021 holeSize.Value().SetMax( 400000 );
1022 rule.AddConstraint( holeSize );
1023
1024 DRC_PANEL_MATCHER matcher;
1025 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1026
1027 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1028 BOOST_CHECK_EQUAL( matches[0].panelType, VIA_STYLE );
1029 BOOST_CHECK_EQUAL( matches[0].claimedConstraints.size(), 2 );
1030 BOOST_CHECK( matches[0].claimedConstraints.count( VIA_DIAMETER_CONSTRAINT ) > 0 );
1031 BOOST_CHECK( matches[0].claimedConstraints.count( HOLE_SIZE_CONSTRAINT ) > 0 );
1032}
1033
1034BOOST_AUTO_TEST_CASE( PanelMatcherPartialMatchViaDiameter )
1035{
1036 // Test: Rule with only via_diameter → MINIMUM_VIA_DIAMETER panel
1037 DRC_RULE rule( "ViaDiameterOnlyRule" );
1038
1040 viaDia.Value().SetMin( 500000 );
1041 rule.AddConstraint( viaDia );
1042
1043 DRC_PANEL_MATCHER matcher;
1044 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1045
1046 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1047 BOOST_CHECK_EQUAL( matches[0].panelType, MINIMUM_VIA_DIAMETER );
1048 BOOST_CHECK_EQUAL( matches[0].claimedConstraints.size(), 1 );
1049 BOOST_CHECK( matches[0].claimedConstraints.count( VIA_DIAMETER_CONSTRAINT ) > 0 );
1050}
1051
1052BOOST_AUTO_TEST_CASE( PanelMatcherSplitRule )
1053{
1054 // Test: Rule with via_diameter + hole_size + clearance → 2 panels
1055 DRC_RULE rule( "SplitRule" );
1056
1058 viaDia.Value().SetMin( 500000 );
1059 rule.AddConstraint( viaDia );
1060
1062 holeSize.Value().SetMin( 200000 );
1063 rule.AddConstraint( holeSize );
1064
1066 clearance.Value().SetMin( 150000 );
1067 rule.AddConstraint( clearance );
1068
1069 DRC_PANEL_MATCHER matcher;
1070 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1071
1072 BOOST_REQUIRE_EQUAL( matches.size(), 2 );
1073
1074 // VIA_STYLE should claim via_diameter + hole_size
1075 BOOST_CHECK_EQUAL( matches[0].panelType, VIA_STYLE );
1076 BOOST_CHECK_EQUAL( matches[0].claimedConstraints.size(), 2 );
1077
1078 // MINIMUM_CLEARANCE should claim clearance
1079 BOOST_CHECK_EQUAL( matches[1].panelType, MINIMUM_CLEARANCE );
1080 BOOST_CHECK_EQUAL( matches[1].claimedConstraints.size(), 1 );
1081 BOOST_CHECK( matches[1].claimedConstraints.count( CLEARANCE_CONSTRAINT ) > 0 );
1082}
1083
1084BOOST_AUTO_TEST_CASE( PanelMatcherPriorityDiffPairOverRoutingWidth )
1085{
1086 // Test: Rule with track_width + diff_pair_gap → ROUTING_DIFF_PAIR (not ROUTING_WIDTH)
1087 DRC_RULE rule( "DiffPairRule" );
1088
1090 trackWidth.Value().SetMin( 200000 );
1091 trackWidth.Value().SetOpt( 250000 );
1092 trackWidth.Value().SetMax( 300000 );
1093 rule.AddConstraint( trackWidth );
1094
1096 diffGap.Value().SetMin( 100000 );
1097 diffGap.Value().SetOpt( 150000 );
1098 diffGap.Value().SetMax( 200000 );
1099 rule.AddConstraint( diffGap );
1100
1101 DRC_PANEL_MATCHER matcher;
1102 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1103
1104 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1105 BOOST_CHECK_EQUAL( matches[0].panelType, ROUTING_DIFF_PAIR );
1106 BOOST_CHECK( matches[0].claimedConstraints.count( TRACK_WIDTH_CONSTRAINT ) > 0 );
1107 BOOST_CHECK( matches[0].claimedConstraints.count( DIFF_PAIR_GAP_CONSTRAINT ) > 0 );
1108}
1109
1110BOOST_AUTO_TEST_CASE( PanelMatcherDiffPairWithOptionalUncoupled )
1111{
1112 // Test: Rule with track_width + diff_pair_gap + uncoupled → ROUTING_DIFF_PAIR claims all three
1113 DRC_RULE rule( "DiffPairWithUncoupledRule" );
1114
1116 trackWidth.Value().SetMin( 200000 );
1117 rule.AddConstraint( trackWidth );
1118
1120 diffGap.Value().SetMin( 100000 );
1121 rule.AddConstraint( diffGap );
1122
1124 uncoupled.Value().SetMax( 5000000 );
1125 rule.AddConstraint( uncoupled );
1126
1127 DRC_PANEL_MATCHER matcher;
1128 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1129
1130 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1131 BOOST_CHECK_EQUAL( matches[0].panelType, ROUTING_DIFF_PAIR );
1132 BOOST_CHECK_EQUAL( matches[0].claimedConstraints.size(), 3 );
1133 BOOST_CHECK( matches[0].claimedConstraints.count( TRACK_WIDTH_CONSTRAINT ) > 0 );
1134 BOOST_CHECK( matches[0].claimedConstraints.count( DIFF_PAIR_GAP_CONSTRAINT ) > 0 );
1135 BOOST_CHECK( matches[0].claimedConstraints.count( MAX_UNCOUPLED_CONSTRAINT ) > 0 );
1136}
1137
1138BOOST_AUTO_TEST_CASE( PanelMatcherTrackWidthOnly )
1139{
1140 // Test: Rule with only track_width → ROUTING_WIDTH (not ROUTING_DIFF_PAIR)
1141 DRC_RULE rule( "TrackWidthOnlyRule" );
1142
1144 trackWidth.Value().SetMin( 200000 );
1145 trackWidth.Value().SetOpt( 250000 );
1146 trackWidth.Value().SetMax( 300000 );
1147 rule.AddConstraint( trackWidth );
1148
1149 DRC_PANEL_MATCHER matcher;
1150 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1151
1152 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1153 BOOST_CHECK_EQUAL( matches[0].panelType, ROUTING_WIDTH );
1154 BOOST_CHECK( matches[0].claimedConstraints.count( TRACK_WIDTH_CONSTRAINT ) > 0 );
1155}
1156
1157BOOST_AUTO_TEST_CASE( PanelMatcherTextHeightAndThickness )
1158{
1159 // Test: Rule with text_height + text_thickness → MINIMUM_TEXT_HEIGHT_AND_THICKNESS
1160 DRC_RULE rule( "TextRule" );
1161
1163 textHeight.Value().SetMin( 1000000 );
1164 rule.AddConstraint( textHeight );
1165
1166 DRC_CONSTRAINT textThickness( LINE_WIDTH_CONSTRAINT );
1167 textThickness.Value().SetMin( 150000 );
1168 rule.AddConstraint( textThickness );
1169
1170 DRC_PANEL_MATCHER matcher;
1171 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1172
1173 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1175 BOOST_CHECK_EQUAL( matches[0].claimedConstraints.size(), 2 );
1176}
1177
1178BOOST_AUTO_TEST_CASE( PanelMatcherLengthConstraint )
1179{
1180 // Test: Rule with length constraint matches ABSOLUTE_LENGTH panel
1181 DRC_RULE rule( "LengthRule" );
1182
1184 length.Value().SetMin( 10000000 );
1185 length.Value().SetOpt( 30000000 );
1186 length.Value().SetMax( 50000000 );
1187 rule.AddConstraint( length );
1188
1189 DRC_PANEL_MATCHER matcher;
1190 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1191
1192 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1193 BOOST_CHECK_EQUAL( matches[0].panelType, ABSOLUTE_LENGTH );
1194 BOOST_CHECK( matches[0].claimedConstraints.count( LENGTH_CONSTRAINT ) > 0 );
1195}
1196
1197BOOST_AUTO_TEST_CASE( PanelMatcherLengthAndSkewConstraint )
1198{
1199 // Rule with length + skew should match MATCHED_LENGTH_DIFF_PAIR, not ABSOLUTE_LENGTH
1200 DRC_RULE rule( "MatchedLengthRule" );
1201
1203 length.Value().SetMin( 10000000 );
1204 length.Value().SetOpt( 30000000 );
1205 length.Value().SetMax( 50000000 );
1206 rule.AddConstraint( length );
1207
1209 skew.Value().SetMax( 1000000 );
1210 rule.AddConstraint( skew );
1211
1212 DRC_PANEL_MATCHER matcher;
1213 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1214
1215 BOOST_REQUIRE_EQUAL( matches.size(), 1 );
1216 BOOST_CHECK_EQUAL( matches[0].panelType, MATCHED_LENGTH_DIFF_PAIR );
1217 BOOST_CHECK( matches[0].claimedConstraints.count( LENGTH_CONSTRAINT ) > 0 );
1218 BOOST_CHECK( matches[0].claimedConstraints.count( SKEW_CONSTRAINT ) > 0 );
1219}
1220
1221BOOST_AUTO_TEST_CASE( PanelMatcherEmptyRule )
1222{
1223 // Test: Rule with no constraints → no matches
1224 DRC_RULE rule( "EmptyRule" );
1225
1226 DRC_PANEL_MATCHER matcher;
1227 std::vector<DRC_PANEL_MATCH> matches = matcher.MatchRule( rule );
1228
1229 BOOST_CHECK_EQUAL( matches.size(), 0 );
1230}
1231
1232BOOST_AUTO_TEST_CASE( PanelMatcherCanPanelLoad )
1233{
1234 DRC_PANEL_MATCHER matcher;
1235
1236 // VIA_STYLE can load via_diameter + hole_size
1237 std::set<DRC_CONSTRAINT_T> viaStyleConstraints = { VIA_DIAMETER_CONSTRAINT, HOLE_SIZE_CONSTRAINT };
1238 BOOST_CHECK( matcher.CanPanelLoad( VIA_STYLE, viaStyleConstraints ) );
1239
1240 // VIA_STYLE cannot load clearance
1241 std::set<DRC_CONSTRAINT_T> clearanceConstraint = { CLEARANCE_CONSTRAINT };
1242 BOOST_CHECK( !matcher.CanPanelLoad( VIA_STYLE, clearanceConstraint ) );
1243
1244 // CUSTOM_RULE can load anything
1245 BOOST_CHECK( matcher.CanPanelLoad( CUSTOM_RULE, viaStyleConstraints ) );
1246 BOOST_CHECK( matcher.CanPanelLoad( CUSTOM_RULE, clearanceConstraint ) );
1247}
1248
1261
1262
1263// ============================================================================
1264// Rule Loader Tests (Phase 5.1)
1265// ============================================================================
1266
1267BOOST_AUTO_TEST_CASE( RuleLoaderViaStyleFromText )
1268{
1269 // Test: Load a via style rule from text and verify values
1270 wxString ruleText =
1271 "(version 1)\n"
1272 "(rule \"Via Test\"\n"
1273 " (constraint via_diameter (min 0.5mm) (opt 0.6mm) (max 0.8mm))\n"
1274 " (constraint hole_size (min 0.2mm) (opt 0.3mm) (max 0.4mm)))";
1275
1276 DRC_RULE_LOADER loader;
1277 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1278
1279 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1280 BOOST_CHECK_EQUAL( entries[0].panelType, VIA_STYLE );
1281 BOOST_CHECK_EQUAL( entries[0].ruleName, "Via Test" );
1282
1283 auto viaData = std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( entries[0].constraintData );
1284 BOOST_REQUIRE( viaData );
1285
1286 BOOST_CHECK_CLOSE( viaData->GetMinViaDiameter(), 0.5, 0.0001 );
1287 BOOST_CHECK_CLOSE( viaData->GetMaxViaDiameter(), 0.8, 0.0001 );
1288 BOOST_CHECK_CLOSE( viaData->GetMinViaHoleSize(), 0.2, 0.0001 );
1289 BOOST_CHECK_CLOSE( viaData->GetMaxViaHoleSize(), 0.4, 0.0001 );
1290}
1291
1292BOOST_AUTO_TEST_CASE( RuleLoaderRoutingWidthFromText )
1293{
1294 // Test: Load a routing width rule from text
1295 wxString ruleText =
1296 "(version 1)\n"
1297 "(rule \"Track Test\"\n"
1298 " (constraint track_width (min 0.2mm) (opt 0.25mm) (max 0.3mm)))";
1299
1300 DRC_RULE_LOADER loader;
1301 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1302
1303 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1304 BOOST_CHECK_EQUAL( entries[0].panelType, ROUTING_WIDTH );
1305 BOOST_CHECK_EQUAL( entries[0].ruleName, "Track Test" );
1306
1307 auto trackData = std::dynamic_pointer_cast<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>( entries[0].constraintData );
1308 BOOST_REQUIRE( trackData );
1309
1310 BOOST_CHECK_CLOSE( trackData->GetOptWidth(), 0.25, 0.0001 );
1311 BOOST_CHECK_CLOSE( trackData->GetWidthTolerance(), 0.05, 0.0001 );
1312}
1313
1314BOOST_AUTO_TEST_CASE( RuleLoaderDiffPairFromText )
1315{
1316 // Test: Load a diff pair rule from text
1317 wxString ruleText =
1318 "(version 1)\n"
1319 "(rule \"Diff Pair Test\"\n"
1320 " (constraint track_width (min 0.2mm) (opt 0.25mm) (max 0.3mm))\n"
1321 " (constraint diff_pair_gap (min 0.1mm) (opt 0.15mm) (max 0.2mm))\n"
1322 " (constraint diff_pair_uncoupled (max 5mm)))";
1323
1324 DRC_RULE_LOADER loader;
1325 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1326
1327 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1328 BOOST_CHECK_EQUAL( entries[0].panelType, ROUTING_DIFF_PAIR );
1329
1330 auto dpData = std::dynamic_pointer_cast<DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA>( entries[0].constraintData );
1331 BOOST_REQUIRE( dpData );
1332
1333 BOOST_CHECK_CLOSE( dpData->GetOptWidth(), 0.25, 0.0001 );
1334 BOOST_CHECK_CLOSE( dpData->GetWidthTolerance(), 0.05, 0.0001 );
1335 BOOST_CHECK_CLOSE( dpData->GetOptGap(), 0.15, 0.0001 );
1336 BOOST_CHECK_CLOSE( dpData->GetGapTolerance(), 0.05, 0.0001 );
1337 BOOST_CHECK_CLOSE( dpData->GetMaxUncoupledLength(), 5.0, 0.0001 );
1338}
1339
1340BOOST_AUTO_TEST_CASE( RuleLoaderSplitRuleFromText )
1341{
1342 // Test: Load a rule that splits into multiple panels
1343 wxString ruleText =
1344 "(version 1)\n"
1345 "(rule \"Split Test\"\n"
1346 " (constraint via_diameter (min 0.5mm))\n"
1347 " (constraint hole_size (min 0.2mm))\n"
1348 " (constraint clearance (min 0.15mm)))";
1349
1350 DRC_RULE_LOADER loader;
1351 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1352
1353 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
1354
1355 // First entry should be VIA_STYLE
1356 BOOST_CHECK_EQUAL( entries[0].panelType, VIA_STYLE );
1357 BOOST_CHECK_EQUAL( entries[0].ruleName, "Split Test" );
1358
1359 // Second entry should be MINIMUM_CLEARANCE
1360 BOOST_CHECK_EQUAL( entries[1].panelType, MINIMUM_CLEARANCE );
1361 BOOST_CHECK_EQUAL( entries[1].ruleName, "Split Test" );
1362
1363 auto numericData = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( entries[1].constraintData );
1364 BOOST_REQUIRE( numericData );
1365 BOOST_CHECK_CLOSE( numericData->GetNumericInputValue(), 0.15, 0.0001 );
1366}
1367
1368BOOST_AUTO_TEST_CASE( RuleLoaderVmeWrenClearanceUnderFpga )
1369{
1370 // Test: Load the clearance_under_fpga rule from vme-wren demo which should split
1371 // This rule has: clearance, hole_size, via_diameter
1372 // Should split into: VIA_STYLE (hole_size + via_diameter) + MINIMUM_CLEARANCE (clearance)
1373 wxString ruleText =
1374 "(version 1)\n"
1375 "(rule \"clearance_under_fpga\"\n"
1376 " (constraint clearance (min 0.1mm))\n"
1377 " (constraint hole_size (min 0.2mm))\n"
1378 " (constraint via_diameter (min 0.4mm))\n"
1379 " (condition \"A.intersectsArea('underFPGA') || A.intersectsArea('underDDR')\"))";
1380
1381 DRC_RULE_LOADER loader;
1382 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1383
1384 // Should produce 2 entries from the split
1385 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
1386
1387 // First entry should be VIA_STYLE (claims via_diameter + hole_size at priority 90)
1388 BOOST_CHECK_EQUAL( entries[0].panelType, VIA_STYLE );
1389 BOOST_CHECK_EQUAL( entries[0].ruleName, "clearance_under_fpga" );
1390 BOOST_CHECK_EQUAL( entries[0].condition, "A.intersectsArea('underFPGA') || A.intersectsArea('underDDR')" );
1391
1392 // Second entry should be MINIMUM_CLEARANCE (claims clearance at priority 30)
1393 BOOST_CHECK_EQUAL( entries[1].panelType, MINIMUM_CLEARANCE );
1394 BOOST_CHECK_EQUAL( entries[1].ruleName, "clearance_under_fpga" );
1395 BOOST_CHECK_EQUAL( entries[1].condition, "A.intersectsArea('underFPGA') || A.intersectsArea('underDDR')" );
1396
1397 // Verify VIA_STYLE has correct values
1398 auto viaData = std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( entries[0].constraintData );
1399 BOOST_REQUIRE( viaData );
1400 BOOST_CHECK_CLOSE( viaData->GetMinViaDiameter(), 0.4, 0.0001 );
1401 BOOST_CHECK_CLOSE( viaData->GetMinViaHoleSize(), 0.2, 0.0001 );
1402
1403 // Verify MINIMUM_CLEARANCE has correct value
1404 auto clearanceData = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( entries[1].constraintData );
1405 BOOST_REQUIRE( clearanceData );
1406 BOOST_CHECK_CLOSE( clearanceData->GetNumericInputValue(), 0.1, 0.0001 );
1407}
1408
1409BOOST_AUTO_TEST_CASE( RuleLoaderTextHeightThicknessFromText )
1410{
1411 // Test: Load text height and thickness rule
1412 wxString ruleText =
1413 "(version 1)\n"
1414 "(rule \"Text Test\"\n"
1415 " (constraint text_height (min 1mm))\n"
1416 " (constraint line_width (min 0.15mm)))";
1417
1418 DRC_RULE_LOADER loader;
1419 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1420
1421 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1423
1424 auto textData = std::dynamic_pointer_cast<DRC_RE_MINIMUM_TEXT_HEIGHT_THICKNESS_CONSTRAINT_DATA>( entries[0].constraintData );
1425 BOOST_REQUIRE( textData );
1426
1427 BOOST_CHECK_CLOSE( textData->GetMinTextHeight(), 1.0, 0.0001 );
1428 BOOST_CHECK_CLOSE( textData->GetMinTextThickness(), 0.15, 0.0001 );
1429}
1430
1431BOOST_AUTO_TEST_CASE( RuleLoaderTextLineWidthWithMaxFallsBackToCustom )
1432{
1433 // The text panel saves only minimums, so the max must not be dropped on edit
1434 wxString ruleText =
1435 "(version 1)\n"
1436 "(rule \"Text Test\"\n"
1437 " (constraint text_height (min 1mm))\n"
1438 " (constraint line_width (min 0.15mm) (max 0.3mm)))";
1439
1440 DRC_RULE_LOADER loader;
1441 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1442
1443 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1444 BOOST_CHECK_EQUAL( entries[0].panelType, CUSTOM_RULE );
1445}
1446
1447BOOST_AUTO_TEST_CASE( RuleLoaderAbsoluteLengthFromText )
1448{
1449 // Test: Load absolute length rule with min/opt/max
1450 wxString ruleText =
1451 "(version 1)\n"
1452 "(rule \"Length Test\"\n"
1453 " (constraint length (min 10mm) (opt 30mm) (max 50mm)))";
1454
1455 DRC_RULE_LOADER loader;
1456 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1457
1458 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1459 BOOST_CHECK_EQUAL( entries[0].panelType, ABSOLUTE_LENGTH );
1460 BOOST_CHECK_EQUAL( entries[0].ruleName, "Length Test" );
1461
1462 auto lengthData = dynamic_pointer_cast<DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA>( entries[0].constraintData );
1463 BOOST_REQUIRE( lengthData );
1464 BOOST_CHECK_CLOSE( lengthData->GetMinimumLength(), 10.0, 0.0001 );
1465 BOOST_CHECK_CLOSE( lengthData->GetOptimumLength(), 30.0, 0.0001 );
1466 BOOST_CHECK_CLOSE( lengthData->GetMaximumLength(), 50.0, 0.0001 );
1467}
1468
1469BOOST_AUTO_TEST_CASE( RuleLoaderMatchedLengthWithSkew )
1470{
1471 // Rule with length + skew should load as MATCHED_LENGTH_DIFF_PAIR and preserve skew
1472 wxString ruleText =
1473 "(version 1)\n"
1474 "(rule \"DP Length Match\"\n"
1475 " (constraint length (min 10mm) (opt 30mm) (max 50mm))\n"
1476 " (constraint skew (max 1mm)))";
1477
1478 DRC_RULE_LOADER loader;
1479 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1480
1481 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1482 BOOST_CHECK_EQUAL( entries[0].panelType, MATCHED_LENGTH_DIFF_PAIR );
1483 BOOST_CHECK_EQUAL( entries[0].ruleName, "DP Length Match" );
1484
1485 auto matchedData =
1486 std::dynamic_pointer_cast<DRC_RE_MATCHED_LENGTH_DIFF_PAIR_CONSTRAINT_DATA>( entries[0].constraintData );
1487 BOOST_REQUIRE( matchedData );
1488
1489 BOOST_CHECK_CLOSE( matchedData->GetMinimumLength(), 10.0, 0.0001 );
1490 BOOST_CHECK_CLOSE( matchedData->GetOptimumLength(), 30.0, 0.0001 );
1491 BOOST_CHECK_CLOSE( matchedData->GetMaximumLength(), 50.0, 0.0001 );
1492 BOOST_CHECK_CLOSE( matchedData->GetMaxSkew(), 1.0, 0.0001 );
1493}
1494
1495BOOST_AUTO_TEST_CASE( RuleLoaderMatchedLengthRoundTrip )
1496{
1497 // Verify length+skew rule round-trips without losing skew
1498 wxString ruleText =
1499 "(version 1)\n"
1500 "(rule \"DP Match RT\"\n"
1501 " (constraint length (min 10mm) (opt 30mm) (max 50mm))\n"
1502 " (constraint skew (max 2.5mm)))";
1503
1504 DRC_RULE_LOADER loader;
1505 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1506
1507 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1508 entries[0].wasEdited = true;
1509
1510 DRC_RULE_SAVER saver;
1511 wxString savedText = saver.GenerateRulesText( entries, nullptr );
1512
1513 BOOST_CHECK( savedText.Contains( "length" ) );
1514 BOOST_CHECK( savedText.Contains( "skew" ) );
1515 BOOST_CHECK( savedText.Contains( "2.5mm" ) );
1516
1517 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloaded = loader.LoadFromString( savedText );
1518
1519 BOOST_REQUIRE_EQUAL( reloaded.size(), 1 );
1520 BOOST_CHECK_EQUAL( reloaded[0].panelType, MATCHED_LENGTH_DIFF_PAIR );
1521
1522 auto reloadedData =
1523 std::dynamic_pointer_cast<DRC_RE_MATCHED_LENGTH_DIFF_PAIR_CONSTRAINT_DATA>( reloaded[0].constraintData );
1524 BOOST_REQUIRE( reloadedData );
1525
1526 BOOST_CHECK_CLOSE( reloadedData->GetMaxSkew(), 2.5, 0.0001 );
1527 BOOST_CHECK_CLOSE( reloadedData->GetMinimumLength(), 10.0, 0.0001 );
1528 BOOST_CHECK_CLOSE( reloadedData->GetOptimumLength(), 30.0, 0.0001 );
1529 BOOST_CHECK_CLOSE( reloadedData->GetMaximumLength(), 50.0, 0.0001 );
1530}
1531
1532BOOST_AUTO_TEST_CASE( RuleLoaderMatchedLengthWithinDiffPairs )
1533{
1534 // Rule with skew + within_diff_pairs should load and preserve the option
1535 wxString ruleText = "(version 1)\n"
1536 "(rule \"DP Skew Within\"\n"
1537 " (constraint length (min 10mm) (opt 30mm) (max 50mm))\n"
1538 " (constraint skew (max 1mm) (within_diff_pairs)))";
1539
1540 DRC_RULE_LOADER loader;
1541 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1542
1543 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1544 BOOST_CHECK_EQUAL( entries[0].panelType, MATCHED_LENGTH_DIFF_PAIR );
1545
1546 auto matchedData =
1547 std::dynamic_pointer_cast<DRC_RE_MATCHED_LENGTH_DIFF_PAIR_CONSTRAINT_DATA>( entries[0].constraintData );
1548 BOOST_REQUIRE( matchedData );
1549
1550 BOOST_CHECK_CLOSE( matchedData->GetMaxSkew(), 1.0, 0.0001 );
1551 BOOST_CHECK( matchedData->GetWithinDiffPairs() );
1552
1553 // Round-trip: save and reload
1554 entries[0].wasEdited = true;
1555
1556 DRC_RULE_SAVER saver;
1557 wxString savedText = saver.GenerateRulesText( entries, nullptr );
1558
1559 BOOST_CHECK( savedText.Contains( "within_diff_pairs" ) );
1560
1561 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloaded = loader.LoadFromString( savedText );
1562
1563 BOOST_REQUIRE_EQUAL( reloaded.size(), 1 );
1564
1565 auto reloadedData =
1566 std::dynamic_pointer_cast<DRC_RE_MATCHED_LENGTH_DIFF_PAIR_CONSTRAINT_DATA>( reloaded[0].constraintData );
1567 BOOST_REQUIRE( reloadedData );
1568
1569 BOOST_CHECK_CLOSE( reloadedData->GetMaxSkew(), 1.0, 0.0001 );
1570 BOOST_CHECK( reloadedData->GetWithinDiffPairs() );
1571}
1572
1573BOOST_AUTO_TEST_CASE( RuleLoaderMatchedLengthWithoutWithinDiffPairs )
1574{
1575 // Rule without within_diff_pairs should default to false
1576 wxString ruleText = "(version 1)\n"
1577 "(rule \"DP Skew Bus\"\n"
1578 " (constraint length (min 10mm) (opt 30mm) (max 50mm))\n"
1579 " (constraint skew (max 2mm)))";
1580
1581 DRC_RULE_LOADER loader;
1582 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1583
1584 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1585
1586 auto matchedData =
1587 std::dynamic_pointer_cast<DRC_RE_MATCHED_LENGTH_DIFF_PAIR_CONSTRAINT_DATA>( entries[0].constraintData );
1588 BOOST_REQUIRE( matchedData );
1589
1590 BOOST_CHECK( !matchedData->GetWithinDiffPairs() );
1591
1592 // Round-trip should NOT contain within_diff_pairs
1593 entries[0].wasEdited = true;
1594
1595 DRC_RULE_SAVER saver;
1596 wxString savedText = saver.GenerateRulesText( entries, nullptr );
1597
1598 BOOST_CHECK( !savedText.Contains( "within_diff_pairs" ) );
1599}
1600
1601BOOST_AUTO_TEST_CASE( RuleLoaderWithCondition )
1602{
1603 // Test: Load rule with condition
1604 wxString ruleText =
1605 "(version 1)\n"
1606 "(rule \"Conditional Test\"\n"
1607 " (condition \"A.NetClass == 'Power'\")\n"
1608 " (constraint clearance (min 0.3mm)))";
1609
1610 DRC_RULE_LOADER loader;
1611 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1612
1613 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1614 BOOST_CHECK_EQUAL( entries[0].ruleName, "Conditional Test" );
1615 BOOST_CHECK_EQUAL( entries[0].condition, "A.NetClass == 'Power'" );
1616 BOOST_CHECK_EQUAL( entries[0].constraintData->GetRuleCondition(), "A.NetClass == 'Power'" );
1617}
1618
1619BOOST_AUTO_TEST_CASE( RuleLoaderMultipleRules )
1620{
1621 // Test: Load multiple rules and verify order preservation
1622 wxString ruleText = "(version 1)\n"
1623 "(rule \"Rule A\"\n"
1624 " (constraint clearance (min 0.2mm)))\n"
1625 "(rule \"Rule B\"\n"
1626 " (constraint track_width (min 0.15mm) (opt 0.2mm) (max 0.25mm)))\n"
1627 "(rule \"Rule C\"\n"
1628 " (constraint via_diameter (min 0.5mm))\n"
1629 " (constraint hole_size (min 0.3mm)))";
1630
1631 DRC_RULE_LOADER loader;
1632 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1633
1634 BOOST_REQUIRE_EQUAL( entries.size(), 3 );
1635
1636 BOOST_CHECK_EQUAL( entries[0].ruleName, "Rule A" );
1637 BOOST_CHECK_EQUAL( entries[0].panelType, MINIMUM_CLEARANCE );
1638
1639 BOOST_CHECK_EQUAL( entries[1].ruleName, "Rule B" );
1640 BOOST_CHECK_EQUAL( entries[1].panelType, ROUTING_WIDTH );
1641
1642 BOOST_CHECK_EQUAL( entries[2].ruleName, "Rule C" );
1643 BOOST_CHECK_EQUAL( entries[2].panelType, VIA_STYLE );
1644}
1645
1646BOOST_AUTO_TEST_CASE( RuleLoaderEmptyRule )
1647{
1648 // Test: Rule with no constraints creates custom rule fallback
1649 wxString ruleText =
1650 "(version 1)\n"
1651 "(rule \"Empty Rule\")";
1652
1653 DRC_RULE_LOADER loader;
1654 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1655
1656 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1657 BOOST_CHECK_EQUAL( entries[0].panelType, CUSTOM_RULE );
1658 BOOST_CHECK_EQUAL( entries[0].ruleName, "Empty Rule" );
1659}
1660
1661BOOST_AUTO_TEST_CASE( RuleLoaderInvalidText )
1662{
1663 // Test: Invalid rule text returns empty vector
1664 wxString ruleText = "not valid rule text at all";
1665
1666 DRC_RULE_LOADER loader;
1667 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1668
1669 BOOST_CHECK_EQUAL( entries.size(), 0 );
1670}
1671
1672BOOST_AUTO_TEST_CASE( RuleLoaderNumericConstraints )
1673{
1674 // Test various numeric constraints map to correct panels
1675 wxString ruleText =
1676 "(version 1)\n"
1677 "(rule \"Edge Clearance\"\n"
1678 " (constraint edge_clearance (min 0.5mm)))\n"
1679 "(rule \"Hole Clearance\"\n"
1680 " (constraint hole_clearance (min 0.3mm)))\n"
1681 "(rule \"Courtyard\"\n"
1682 " (constraint courtyard_clearance (min 0.25mm)))";
1683
1684 DRC_RULE_LOADER loader;
1685 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1686
1687 BOOST_REQUIRE_EQUAL( entries.size(), 3 );
1688
1689 BOOST_CHECK_EQUAL( entries[0].panelType, COPPER_TO_EDGE_CLEARANCE );
1690 BOOST_CHECK_EQUAL( entries[1].panelType, COPPER_TO_HOLE_CLEARANCE );
1691 BOOST_CHECK_EQUAL( entries[2].panelType, COURTYARD_CLEARANCE );
1692}
1693
1694
1695// A ratio is stored scaled by 1000, so the editor has to scale it back. The depth beside it is
1696// a plain count and must come through untouched.
1697BOOST_AUTO_TEST_CASE( RuleLoaderHoleRatioRoundTrip )
1698{
1699 wxString ruleText = "(version 1)\n"
1700 "(rule \"Ratio\"\n"
1701 " (constraint hole_aspect_ratio (max 1.0))\n"
1702 " (condition \"A.Via_Type == 'Micro'\"))\n"
1703 "(rule \"HoleRatio\"\n"
1704 " (constraint hole_aspect_ratio (max 8.0)))\n"
1705 "(rule \"Depth\"\n"
1706 " (constraint microvia_stack_depth (max 3)))";
1707
1708 DRC_RULE_LOADER loader;
1709 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
1710
1711 // One panel owns the constraint. Scoping it to microvias is a condition, not another panel.
1712 BOOST_REQUIRE_EQUAL( entries.size(), 3 );
1713 BOOST_CHECK_EQUAL( entries[0].panelType, HOLE_ASPECT_RATIO );
1714 BOOST_CHECK_EQUAL( entries[1].panelType, HOLE_ASPECT_RATIO );
1715 BOOST_CHECK_EQUAL( entries[2].panelType, MICROVIA_STACK_DEPTH );
1716
1717 auto scoped = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( entries[0].constraintData );
1718 auto plain = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( entries[1].constraintData );
1719 auto depth = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( entries[2].constraintData );
1720
1721 BOOST_REQUIRE( scoped );
1722 BOOST_REQUIRE( plain );
1723 BOOST_REQUIRE( depth );
1724 BOOST_CHECK_CLOSE( scoped->GetNumericInputValue(), 1.0, 0.0001 );
1725 BOOST_CHECK_CLOSE( plain->GetNumericInputValue(), 8.0, 0.0001 );
1726 BOOST_CHECK_CLOSE( depth->GetNumericInputValue(), 3.0, 0.0001 );
1727
1728 BOOST_CHECK_EQUAL( scoped->GetRuleCondition(), wxString( wxS( "A.Via_Type == 'Micro'" ) ) );
1729 BOOST_CHECK( plain->GetRuleCondition().IsEmpty() );
1730
1731 entries[0].wasEdited = true;
1732 entries[1].wasEdited = true;
1733 entries[2].wasEdited = true;
1734
1735 DRC_RULE_SAVER saver;
1736 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloaded =
1737 loader.LoadFromString( saver.GenerateRulesText( entries, nullptr ) );
1738
1739 BOOST_REQUIRE_EQUAL( reloaded.size(), 3 );
1740 BOOST_CHECK_EQUAL( reloaded[0].panelType, HOLE_ASPECT_RATIO );
1741 BOOST_CHECK_EQUAL( reloaded[1].panelType, HOLE_ASPECT_RATIO );
1742 BOOST_CHECK_EQUAL( reloaded[2].panelType, MICROVIA_STACK_DEPTH );
1743
1744 auto scopedAgain = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( reloaded[0].constraintData );
1745 auto plainAgain = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( reloaded[1].constraintData );
1746 auto depthAgain = std::dynamic_pointer_cast<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>( reloaded[2].constraintData );
1747
1748 BOOST_REQUIRE( scopedAgain );
1749 BOOST_REQUIRE( plainAgain );
1750 BOOST_REQUIRE( depthAgain );
1751 BOOST_CHECK_CLOSE( scopedAgain->GetNumericInputValue(), 1.0, 0.0001 );
1752 BOOST_CHECK_CLOSE( plainAgain->GetNumericInputValue(), 8.0, 0.0001 );
1753 BOOST_CHECK_CLOSE( depthAgain->GetNumericInputValue(), 3.0, 0.0001 );
1754
1755 // The scoping survives the trip, which is what keeps the two rules distinct.
1756 BOOST_CHECK_EQUAL( scopedAgain->GetRuleCondition(), wxString( wxS( "A.Via_Type == 'Micro'" ) ) );
1757 BOOST_CHECK( plainAgain->GetRuleCondition().IsEmpty() );
1758}
1759
1760
1761// ============================================================================
1762// Rule Saver Tests (Phase 3)
1763// ============================================================================
1764
1765BOOST_AUTO_TEST_CASE( RuleSaverBasicGeneration )
1766{
1767 // Test: Basic rule text generation from panel entry
1770 entry.ruleName = "TestClearance";
1771 entry.wasEdited = true;
1772
1773 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
1774 numericData->SetRuleName( "TestClearance" );
1775 numericData->SetConstraintCode( "clearance" );
1776 numericData->SetNumericInputValue( 0.2 );
1777 entry.constraintData = numericData;
1778
1779 DRC_RULE_SAVER saver;
1780 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
1781 wxString result = saver.GenerateRulesText( entries, nullptr );
1782
1783 BOOST_CHECK( result.Contains( "(version 2)" ) );
1784 BOOST_CHECK( result.Contains( "TestClearance" ) );
1785 BOOST_CHECK( result.Contains( "clearance" ) );
1786}
1787
1788BOOST_AUTO_TEST_CASE( RuleSaverRoundTripPreservation )
1789{
1790 // Test: Original text preserved when not edited
1793 entry.ruleName = "Preserved Rule";
1794 entry.originalRuleText = "(rule \"Preserved Rule\"\n\t(constraint clearance (min 0.5mm)))";
1795 entry.wasEdited = false;
1796
1797 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
1798 numericData->SetRuleName( "Preserved Rule" );
1799 numericData->SetConstraintCode( "clearance" );
1800 numericData->SetNumericInputValue( 0.5 );
1801 entry.constraintData = numericData;
1802
1803 DRC_RULE_SAVER saver;
1804 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
1805 wxString result = saver.GenerateRulesText( entries, nullptr );
1806
1807 BOOST_CHECK( result.Contains( entry.originalRuleText ) );
1808}
1809
1810BOOST_AUTO_TEST_CASE( RuleSaverEditedRuleRegenerated )
1811{
1812 // Test: Edited rules regenerate from panel data
1815 entry.ruleName = "EditedRule";
1816 entry.originalRuleText = "(rule \"EditedRule\"\n\t(constraint clearance (min 0.5mm)))";
1817 entry.wasEdited = true;
1818
1819 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
1820 numericData->SetRuleName( "EditedRule" );
1821 numericData->SetConstraintCode( "clearance" );
1822 numericData->SetNumericInputValue( 0.3 );
1823 entry.constraintData = numericData;
1824
1825 DRC_RULE_SAVER saver;
1826 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
1827 wxString result = saver.GenerateRulesText( entries, nullptr );
1828
1829 // Original text should NOT be preserved since wasEdited is true
1830 BOOST_CHECK( !result.Contains( "0.5mm" ) );
1831 BOOST_CHECK( result.Contains( "EditedRule" ) );
1832}
1833
1834BOOST_AUTO_TEST_CASE( RuleSaverViaStyleRule )
1835{
1836 // Test: Via style rule generation
1838 entry.panelType = VIA_STYLE;
1839 entry.ruleName = "ViaTest";
1840
1841 auto viaData = std::make_shared<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>();
1842 viaData->SetRuleName( "ViaTest" );
1843 viaData->SetMinViaDiameter( 0.5 );
1844 viaData->SetMaxViaDiameter( 0.8 );
1845 viaData->SetMinViaHoleSize( 0.2 );
1846 viaData->SetMaxViaHoleSize( 0.4 );
1847 entry.constraintData = viaData;
1848 entry.wasEdited = true;
1849
1850 DRC_RULE_SAVER saver;
1851 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
1852 wxString result = saver.GenerateRulesText( entries, nullptr );
1853
1854 BOOST_CHECK( result.Contains( "ViaTest" ) );
1855 BOOST_CHECK( result.Contains( "via_diameter" ) );
1856 BOOST_CHECK( result.Contains( "hole_size" ) );
1857}
1858
1859BOOST_AUTO_TEST_CASE( RuleSaverMultipleEntries )
1860{
1861 // Test: Multiple entries saved in order
1862 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries;
1863
1866 entry1.ruleName = "RuleA";
1867 auto data1 = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
1868 data1->SetRuleName( "RuleA" );
1869 data1->SetConstraintCode( "clearance" );
1870 data1->SetNumericInputValue( 0.2 );
1871 entry1.constraintData = data1;
1872 entry1.wasEdited = true;
1873 entries.push_back( entry1 );
1874
1876 entry2.panelType = ROUTING_WIDTH;
1877 entry2.ruleName = "RuleB";
1878 auto data2 = std::make_shared<DRC_RE_ROUTING_WIDTH_CONSTRAINT_DATA>();
1879 data2->SetRuleName( "RuleB" );
1880 data2->SetOptWidth( 0.2 );
1881 data2->SetWidthTolerance( 0.1 );
1882 entry2.constraintData = data2;
1883 entry2.wasEdited = true;
1884 entries.push_back( entry2 );
1885
1886 DRC_RULE_SAVER saver;
1887 wxString result = saver.GenerateRulesText( entries, nullptr );
1888
1889 // Both rules should appear
1890 BOOST_CHECK( result.Contains( "RuleA" ) );
1891 BOOST_CHECK( result.Contains( "RuleB" ) );
1892
1893 // Check order: RuleA should appear before RuleB
1894 size_t posA = result.Find( "RuleA" );
1895 size_t posB = result.Find( "RuleB" );
1896 BOOST_CHECK( posA < posB );
1897}
1898
1899BOOST_AUTO_TEST_CASE( RuleSaverWithCondition )
1900{
1901 // Test: Rule with condition
1904 entry.ruleName = "ConditionalRule";
1905 entry.condition = "A.NetClass == 'Power'";
1906
1907 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
1908 numericData->SetRuleName( "ConditionalRule" );
1909 numericData->SetConstraintCode( "clearance" );
1910 numericData->SetRuleCondition( "A.NetClass == 'Power'" );
1911 numericData->SetNumericInputValue( 0.3 );
1912 entry.constraintData = numericData;
1913 entry.wasEdited = true;
1914
1915 DRC_RULE_SAVER saver;
1916 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
1917 wxString result = saver.GenerateRulesText( entries, nullptr );
1918
1919 BOOST_CHECK( result.Contains( "ConditionalRule" ) );
1920 BOOST_CHECK( result.Contains( "condition" ) );
1921 BOOST_CHECK( result.Contains( "Power" ) );
1922}
1923
1924BOOST_AUTO_TEST_CASE( RuleSaverEmptyEntries )
1925{
1926 // Test: Empty entries vector
1927 DRC_RULE_SAVER saver;
1928 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries;
1929 wxString result = saver.GenerateRulesText( entries, nullptr );
1930
1931 BOOST_CHECK( result.Contains( "(version 2)" ) );
1932 // Should have version header but nothing else
1933 BOOST_CHECK_EQUAL( result.Trim(), "(version 2)" );
1934}
1935
1936BOOST_AUTO_TEST_CASE( RuleSaverNullConstraintData )
1937{
1938 // Test: Entry with null constraint data is skipped
1941 entry.ruleName = "Null Data Rule";
1942 entry.constraintData = nullptr;
1943 entry.wasEdited = true;
1944
1945 DRC_RULE_SAVER saver;
1946 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
1947 wxString result = saver.GenerateRulesText( entries, nullptr );
1948
1949 // Should have version header but rule text is skipped
1950 BOOST_CHECK( result.Contains( "(version 2)" ) );
1951 BOOST_CHECK( !result.Contains( "Null Data Rule" ) );
1952}
1953
1954BOOST_AUTO_TEST_CASE( RuleSaverLoadSaveRoundTrip )
1955{
1956 // Test: Full round-trip: Load → mark edited → Save → Load produces equivalent data
1957 wxString originalText =
1958 "(version 1)\n"
1959 "(rule \"RoundTripTest\"\n"
1960 " (constraint clearance (min 0.25mm)))";
1961
1962 DRC_RULE_LOADER loader;
1963 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( originalText );
1964
1965 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
1966 BOOST_CHECK_EQUAL( entries[0].ruleName, "RoundTripTest" );
1967
1968 // Mark as edited so it regenerates from data (loader doesn't preserve exact original text)
1969 entries[0].wasEdited = true;
1970
1971 // Save
1972 DRC_RULE_SAVER saver;
1973 wxString savedText = saver.GenerateRulesText( entries, nullptr );
1974
1975 // Verify saved text is valid by reloading
1976 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloadedEntries = loader.LoadFromString( savedText );
1977
1978 BOOST_REQUIRE_EQUAL( reloadedEntries.size(), 1 );
1979 BOOST_CHECK_EQUAL( reloadedEntries[0].ruleName, "RoundTripTest" );
1980 BOOST_CHECK_EQUAL( reloadedEntries[0].panelType, entries[0].panelType );
1981}
1982
1983BOOST_AUTO_TEST_CASE( RuleSaverKeepsUneditedFileIntact )
1984{
1985 // issue16182 comments each rule outside it, and issue20480 has two rules sharing name and condition
1986 for( const char* name : { "issue16182.kicad_dru", "issue20480/issue20480.kicad_dru" } )
1987 {
1989 {
1991 wxString content;
1992 wxFFile file( path, "r" );
1993
1994 BOOST_REQUIRE( file.IsOpened() );
1995 file.ReadAll( &content );
1996
1997 DRC_RULE_LOADER loader;
1998 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFile( path );
1999 DRC_RULE_SAVER saver;
2000
2001 BOOST_REQUIRE( !entries.empty() );
2002 BOOST_CHECK_EQUAL( saver.GenerateRulesText( entries, nullptr, loader.GetFileTrivia() ), content );
2003 }
2004 }
2005}
2006
2007BOOST_AUTO_TEST_CASE( RuleSaverPreservesQuotedNameWithSpaces )
2008{
2009 // Issue 23852: editing a rule named like "Annular width: LEDs" must not rewrite
2010 // the name to Annular_width__LEDs. Names with whitespace or other characters
2011 // that require quoting must be emitted as a quoted string and round-trip intact.
2012 const wxString originalName = wxS( "Annular width: LEDs" );
2013
2016 entry.ruleName = originalName;
2017 entry.wasEdited = true;
2018
2019 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
2020 numericData->SetRuleName( originalName );
2021 numericData->SetConstraintCode( "annular_width" );
2022 numericData->SetNumericInputValue( 0.085 );
2023 entry.constraintData = numericData;
2024
2025 DRC_RULE_SAVER saver;
2026 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2027 wxString result = saver.GenerateRulesText( entries, nullptr );
2028
2029 // The saver must emit the name in quotes, not mangle it with underscores.
2030 BOOST_CHECK( result.Contains( wxS( "\"Annular width: LEDs\"" ) ) );
2031 BOOST_CHECK( !result.Contains( wxS( "Annular_width__LEDs" ) ) );
2032
2033 // Reload the saved text and verify the rule name survives unchanged.
2034 DRC_RULE_LOADER loader;
2035 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloaded = loader.LoadFromString( result );
2036
2037 BOOST_REQUIRE_EQUAL( reloaded.size(), 1 );
2038 BOOST_CHECK_EQUAL( reloaded[0].ruleName, originalName );
2039}
2040
2041
2042BOOST_AUTO_TEST_CASE( RuleSaverPreservesBareSymbolNameUnquoted )
2043{
2044 // A bare symbol rule name should still be emitted without quotes.
2047 entry.ruleName = wxS( "My_Bare_Rule-1.0" );
2048 entry.wasEdited = true;
2049
2050 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
2051 numericData->SetRuleName( entry.ruleName );
2052 numericData->SetConstraintCode( "clearance" );
2053 numericData->SetNumericInputValue( 0.2 );
2054 entry.constraintData = numericData;
2055
2056 DRC_RULE_SAVER saver;
2057 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2058 wxString result = saver.GenerateRulesText( entries, nullptr );
2059
2060 BOOST_CHECK( result.Contains( wxS( "(rule My_Bare_Rule-1.0\n" ) ) );
2061 BOOST_CHECK( !result.Contains( wxS( "\"My_Bare_Rule-1.0\"" ) ) );
2062}
2063
2064
2065BOOST_AUTO_TEST_CASE( RuleSaverQuotesNameStartingWithDigit )
2066{
2067 // Names that pass DSNLEXER's isNumber() test must be quoted so S-expression parsers treat them
2068 // as a symbol rather than a numeric literal.
2071 entry.ruleName = wxS( "3.3" );
2072 entry.wasEdited = true;
2073
2074 auto numericData = std::make_shared<DRC_RE_NUMERIC_INPUT_CONSTRAINT_DATA>();
2075 numericData->SetRuleName( entry.ruleName );
2076 numericData->SetConstraintCode( "clearance" );
2077 numericData->SetNumericInputValue( 0.2 );
2078 entry.constraintData = numericData;
2079
2080 DRC_RULE_SAVER saver;
2081 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2082 wxString result = saver.GenerateRulesText( entries, nullptr );
2083
2084 BOOST_CHECK( result.Contains( wxS( "\"3.3\"" ) ) );
2085
2086 DRC_RULE_LOADER loader;
2087 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloaded = loader.LoadFromString( result );
2088 BOOST_REQUIRE_EQUAL( reloaded.size(), 1 );
2089 BOOST_CHECK_EQUAL( reloaded[0].ruleName, "3.3" );
2090}
2091
2092
2093BOOST_AUTO_TEST_CASE( RuleSaverDiffPairRule )
2094{
2095 // Test: Diff pair rule generation
2098 entry.ruleName = "DiffPairTest";
2099
2100 auto dpData = std::make_shared<DRC_RE_ROUTING_DIFF_PAIR_CONSTRAINT_DATA>();
2101 dpData->SetRuleName( "DiffPairTest" );
2102 dpData->SetOptWidth( 0.25 );
2103 dpData->SetWidthTolerance( 0.05 );
2104 dpData->SetOptGap( 0.15 );
2105 dpData->SetGapTolerance( 0.05 );
2106 dpData->SetMaxUncoupledLength( 5.0 );
2107 entry.constraintData = dpData;
2108 entry.wasEdited = true;
2109
2110 DRC_RULE_SAVER saver;
2111 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2112 wxString result = saver.GenerateRulesText( entries, nullptr );
2113
2114 BOOST_CHECK( result.Contains( "DiffPairTest" ) );
2115 BOOST_CHECK( result.Contains( "track_width" ) );
2116 BOOST_CHECK( result.Contains( "diff_pair_gap" ) );
2117}
2118
2119
2120// ============================================================================
2121// Integration Tests (Phase 5.2)
2122// ============================================================================
2123
2124BOOST_AUTO_TEST_CASE( IntegrationLoadHoleClearanceRules )
2125{
2126 // Test: Load issue6879.kicad_dru which has hole_clearance and hole constraints
2127 wxString ruleText =
2128 "(version 1)\n"
2129 "(rule \"PTH to Track Clearance\"\n"
2130 " (constraint hole_clearance (min 1.0mm))\n"
2131 " (condition \"A.Type == 'Pad' && A.Pad_Type == 'Through-hole' && B.Type =='Track'\"))\n"
2132 "(rule \"Max Drill Hole Size Mechanical\"\n"
2133 " (constraint hole (max 2.0mm))\n"
2134 " (condition \"A.Type == 'Pad'\"))";
2135
2136 DRC_RULE_LOADER loader;
2137 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2138
2139 BOOST_REQUIRE_GE( entries.size(), 2 );
2140
2141 // First rule should be COPPER_TO_HOLE_CLEARANCE
2142 BOOST_CHECK_EQUAL( entries[0].panelType, COPPER_TO_HOLE_CLEARANCE );
2143 BOOST_CHECK_EQUAL( entries[0].ruleName, "PTH to Track Clearance" );
2144 BOOST_CHECK( !entries[0].condition.IsEmpty() );
2145
2146 // Second rule should be HOLE_SIZE
2147 BOOST_CHECK_EQUAL( entries[1].panelType, HOLE_SIZE );
2148 BOOST_CHECK_EQUAL( entries[1].ruleName, "Max Drill Hole Size Mechanical" );
2149}
2150
2151BOOST_AUTO_TEST_CASE( IntegrationLoadEdgeClearanceWithSeverity )
2152{
2153 // Test: Load severities.kicad_dru which has severity clause
2154 wxString ruleText =
2155 "(version 1)\n"
2156 "(rule board_edge\n"
2157 " (constraint edge_clearance (min 1mm))\n"
2158 " (condition \"A.memberOf('board_edge')\")\n"
2159 " (severity ignore))";
2160
2161 DRC_RULE_LOADER loader;
2162 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2163
2164 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2165 BOOST_CHECK_EQUAL( entries[0].panelType, COPPER_TO_EDGE_CLEARANCE );
2166 BOOST_CHECK_EQUAL( entries[0].ruleName, "board_edge" );
2167 BOOST_CHECK_EQUAL( entries[0].severity, RPT_SEVERITY_IGNORE );
2168}
2169
2170BOOST_AUTO_TEST_CASE( IntegrationLoadConnectionWidthRules )
2171{
2172 // Test: Load connection_width_rules.kicad_dru
2173 wxString ruleText =
2174 "(version 1)\n"
2175 "(rule high_current_netclass\n"
2176 " (constraint connection_width (min 0.16mm))\n"
2177 " (condition \"A.NetClass == 'High_current'\"))\n"
2178 "(rule high_current_area\n"
2179 " (constraint connection_width (min 0.16mm))\n"
2180 " (condition \"A.insideArea('high_current')\"))";
2181
2182 DRC_RULE_LOADER loader;
2183 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2184
2185 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
2186
2187 // Both should be MINIMUM_CONNECTION_WIDTH
2188 BOOST_CHECK_EQUAL( entries[0].panelType, MINIMUM_CONNECTION_WIDTH );
2189 BOOST_CHECK_EQUAL( entries[1].panelType, MINIMUM_CONNECTION_WIDTH );
2190
2191 // Both should have conditions
2192 BOOST_CHECK( !entries[0].condition.IsEmpty() );
2193 BOOST_CHECK( !entries[1].condition.IsEmpty() );
2194}
2195
2196BOOST_AUTO_TEST_CASE( IntegrationSaveLoadRoundTripMultipleRules )
2197{
2198 // Test: Load multiple rules, save, reload - verify equivalent data
2199 // Use rule names without spaces to avoid sanitization differences
2200 wxString originalText =
2201 "(version 1)\n"
2202 "(rule ClearanceRule\n"
2203 " (constraint clearance (min 0.2mm))\n"
2204 " (condition \"A.NetClass == 'Power'\"))\n"
2205 "(rule TrackWidthRule\n"
2206 " (constraint track_width (min 0.15mm) (opt 0.2mm) (max 0.3mm)))";
2207
2208 DRC_RULE_LOADER loader;
2209 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( originalText );
2210
2211 BOOST_REQUIRE_EQUAL( entries.size(), 2 );
2212
2213 // Mark as edited to force regeneration
2214 for( auto& entry : entries )
2215 entry.wasEdited = true;
2216
2217 // Save
2218 DRC_RULE_SAVER saver;
2219 wxString savedText = saver.GenerateRulesText( entries, nullptr );
2220
2221 // Reload
2222 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloadedEntries = loader.LoadFromString( savedText );
2223
2224 BOOST_REQUIRE_EQUAL( reloadedEntries.size(), 2 );
2225
2226 // Verify panel types preserved correctly
2227 BOOST_CHECK_EQUAL( reloadedEntries[0].panelType, entries[0].panelType );
2228 BOOST_CHECK_EQUAL( reloadedEntries[1].panelType, entries[1].panelType );
2229
2230 // Verify rule names preserved
2231 BOOST_CHECK_EQUAL( reloadedEntries[0].ruleName, "ClearanceRule" );
2232 BOOST_CHECK_EQUAL( reloadedEntries[1].ruleName, "TrackWidthRule" );
2233}
2234
2235BOOST_AUTO_TEST_CASE( IntegrationSaveLoadViaStyleRoundTrip )
2236{
2237 // Test: Via style rules round-trip correctly
2238 wxString originalText =
2239 "(version 1)\n"
2240 "(rule \"Via Style\"\n"
2241 " (constraint via_diameter (min 0.5mm) (opt 0.6mm) (max 0.8mm))\n"
2242 " (constraint hole_size (min 0.2mm) (opt 0.3mm) (max 0.4mm)))";
2243
2244 DRC_RULE_LOADER loader;
2245 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( originalText );
2246
2247 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2248 BOOST_CHECK_EQUAL( entries[0].panelType, VIA_STYLE );
2249
2250 auto viaData = std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( entries[0].constraintData );
2251 BOOST_REQUIRE( viaData );
2252
2253 double originalMinDia = viaData->GetMinViaDiameter();
2254 double originalMinHole = viaData->GetMinViaHoleSize();
2255
2256 // Mark as edited and save
2257 entries[0].wasEdited = true;
2258 DRC_RULE_SAVER saver;
2259 wxString savedText = saver.GenerateRulesText( entries, nullptr );
2260
2261 // Reload and verify values preserved
2262 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloadedEntries = loader.LoadFromString( savedText );
2263
2264 BOOST_REQUIRE_EQUAL( reloadedEntries.size(), 1 );
2265 BOOST_CHECK_EQUAL( reloadedEntries[0].panelType, VIA_STYLE );
2266
2267 auto reloadedViaData =
2268 std::dynamic_pointer_cast<DRC_RE_VIA_STYLE_CONSTRAINT_DATA>( reloadedEntries[0].constraintData );
2269 BOOST_REQUIRE( reloadedViaData );
2270
2271 BOOST_CHECK_CLOSE( reloadedViaData->GetMinViaDiameter(), originalMinDia, 0.0001 );
2272 BOOST_CHECK_CLOSE( reloadedViaData->GetMinViaHoleSize(), originalMinHole, 0.0001 );
2273}
2274
2275BOOST_AUTO_TEST_CASE( IntegrationSplitRulePreservesOrder )
2276{
2277 // Test: A rule with multiple constraint types splits and preserves order
2278 wxString ruleText = "(version 1)\n"
2279 "(rule \"Rule A\"\n"
2280 " (constraint clearance (min 0.2mm)))\n"
2281 "(rule \"Rule B\"\n"
2282 " (constraint via_diameter (min 0.5mm))\n"
2283 " (constraint hole_size (min 0.2mm))\n"
2284 " (constraint track_width (min 0.15mm) (opt 0.2mm) (max 0.25mm)))\n"
2285 "(rule \"Rule C\"\n"
2286 " (constraint edge_clearance (min 0.3mm)))";
2287
2288 DRC_RULE_LOADER loader;
2289 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2290
2291 // Rule B splits into VIA_STYLE and ROUTING_WIDTH
2292 BOOST_REQUIRE_GE( entries.size(), 4 );
2293
2294 // Find entries by rule name
2295 int ruleACount = 0, ruleBCount = 0, ruleCCount = 0;
2296
2297 for( const auto& entry : entries )
2298 {
2299 if( entry.ruleName == "Rule A" )
2300 ruleACount++;
2301 else if( entry.ruleName == "Rule B" )
2302 ruleBCount++;
2303 else if( entry.ruleName == "Rule C" )
2304 ruleCCount++;
2305 }
2306
2307 BOOST_CHECK_EQUAL( ruleACount, 1 );
2308 BOOST_CHECK_GE( ruleBCount, 2 );
2309 BOOST_CHECK_EQUAL( ruleCCount, 1 );
2310
2311 // Verify original order: all Rule A entries before Rule B, Rule B before Rule C
2312 int lastAIndex = -1, firstBIndex = entries.size(), lastBIndex = -1, firstCIndex = entries.size();
2313
2314 for( size_t i = 0; i < entries.size(); i++ )
2315 {
2316 if( entries[i].ruleName == "Rule A" )
2317 lastAIndex = i;
2318 else if( entries[i].ruleName == "Rule B" )
2319 {
2320 if( (int)i < firstBIndex )
2321 firstBIndex = i;
2322
2323 lastBIndex = i;
2324 }
2325 else if( entries[i].ruleName == "Rule C" )
2326 {
2327 if( (int)i < firstCIndex )
2328 firstCIndex = i;
2329 }
2330 }
2331
2332 BOOST_CHECK( lastAIndex < firstBIndex );
2333 BOOST_CHECK( lastBIndex < firstCIndex );
2334}
2335
2336
2337// A selector rebuilds only its own test, so anything more must stay a custom query
2338BOOST_AUTO_TEST_CASE( SelectorConditionKeepsWholeTest )
2339{
2341
2342 BOOST_CHECK( !DRC_RULE_EDITOR_UTILS::ParseSelectorCondition( wxS( "hasNetclass('N') == 0" ) ) );
2343 BOOST_CHECK( DRC_RULE_EDITOR_UTILS::ParseSelectorCondition( wxS( "enclosedByArea('R')" ) )->kind
2344 == KIND::ENCLOSED_BY_AREA );
2345}
2346
2347// ============================================================================
2348// Condition Group Panel Tests
2349// ============================================================================
2350
2351BOOST_AUTO_TEST_CASE( ConditionGroupBuildSingleCondition )
2352{
2353 // Test: Single condition builds correctly
2354 // This tests the expression building logic used by DRC_RE_CONDITION_GROUP_PANEL
2355 wxString expr = "A.NetName == 'VCC'";
2356
2357 // When parsed and rebuilt, the result should be equivalent
2358 BOOST_CHECK( !expr.IsEmpty() );
2359 BOOST_CHECK( expr.Contains( "NetName" ) );
2360 BOOST_CHECK( expr.Contains( "VCC" ) );
2361}
2362
2363BOOST_AUTO_TEST_CASE( ConditionGroupTokenizeAndOperator )
2364{
2365 // Test: Tokenizing conditions with AND operator
2366 wxString expr = "A.NetName == 'VCC' && B.NetClass == 'Power'";
2367
2368 // Verify the expression contains expected operators
2369 BOOST_CHECK( expr.Contains( "&&" ) );
2370 BOOST_CHECK( expr.Contains( "NetName" ) );
2371 BOOST_CHECK( expr.Contains( "NetClass" ) );
2372}
2373
2374BOOST_AUTO_TEST_CASE( ConditionGroupTokenizeOrOperator )
2375{
2376 // Test: Tokenizing conditions with OR operator
2377 wxString expr = "A.intersectsArea('underFPGA') || A.intersectsArea('underDDR')";
2378
2379 // Verify the expression contains expected operators
2380 BOOST_CHECK( expr.Contains( "||" ) );
2381 BOOST_CHECK( expr.Contains( "intersectsArea" ) );
2382}
2383
2384BOOST_AUTO_TEST_CASE( ConditionGroupTokenizeAndNotOperator )
2385{
2386 // Test: Tokenizing conditions with AND NOT operator
2387 wxString expr = "A.NetClass == 'Power' && !A.intersectsArea('NoRouting')";
2388
2389 // Verify the expression contains expected operators and negation
2390 BOOST_CHECK( expr.Contains( "&&" ) );
2391 BOOST_CHECK( expr.Contains( "!" ) );
2392}
2393
2394BOOST_AUTO_TEST_CASE( ConditionGroupTokenizeComplexExpression )
2395{
2396 // Test: Complex expression from vme-wren.kicad_dru
2397 wxString expr = "A.intersectsArea('underFPGA') || A.intersectsArea('underDDR')";
2398
2399 // The expression should contain the expected patterns
2400 BOOST_CHECK( expr.Contains( "||" ) );
2401 BOOST_CHECK( expr.Contains( "underFPGA" ) );
2402 BOOST_CHECK( expr.Contains( "underDDR" ) );
2403
2404 // Count number of conditions (2 in this case)
2405 size_t orCount = 0;
2406 size_t pos = 0;
2407
2408 while( ( pos = expr.find( "||", pos ) ) != wxString::npos )
2409 {
2410 orCount++;
2411 pos += 2;
2412 }
2413
2414 BOOST_CHECK_EQUAL( orCount, 1 );
2415}
2416
2417
2418// ============================================================================
2419// DRC Engine Item Filtering Tests
2420// ============================================================================
2421
2422BOOST_AUTO_TEST_CASE( ItemFilterExcludesNetInfoAndGenerator )
2423{
2424 // Test: Verify the item type filter logic matches expected exclusions
2425 // This is a unit test for the switch statement in GetItemsMatchingCondition
2426
2427 std::vector<KICAD_T> excludedTypes = { PCB_NETINFO_T, PCB_GENERATOR_T, PCB_GROUP_T };
2428 std::vector<KICAD_T> includedTypes = { PCB_TRACE_T, PCB_VIA_T, PCB_PAD_T, PCB_FOOTPRINT_T,
2430
2431 for( KICAD_T type : excludedTypes )
2432 {
2433 switch( type )
2434 {
2435 case PCB_NETINFO_T:
2436 case PCB_GENERATOR_T:
2437 case PCB_GROUP_T:
2438 BOOST_CHECK( true ); // These should be excluded (continue in real code)
2439 break;
2440
2441 default:
2442 BOOST_FAIL( "Excluded type not handled in filter" );
2443 break;
2444 }
2445 }
2446
2447 for( KICAD_T type : includedTypes )
2448 {
2449 switch( type )
2450 {
2451 case PCB_NETINFO_T:
2452 case PCB_GENERATOR_T:
2453 case PCB_GROUP_T:
2454 BOOST_FAIL( "Included type incorrectly matched by filter" );
2455 break;
2456
2457 default:
2458 BOOST_CHECK( true ); // These should be included
2459 break;
2460 }
2461 }
2462}
2463
2464BOOST_AUTO_TEST_CASE( RuleSaverSilkToSoldermaskWithCondition )
2465{
2466 // Test: Silk-to-soldermask merges layer condition with user condition
2467 // into a single (condition ...) clause, not two separate ones.
2470 entry.ruleName = "SilkMaskTest";
2471 entry.condition = "A.NetClass == 'Power'";
2472 entry.wasEdited = true;
2473 entry.layerCondition = LSET( { F_SilkS } );
2474
2475 auto data = std::make_shared<DRC_RE_SILK_TO_SOLDERMASK_CLEARANCE_CONSTRAINT_DATA>();
2476 data->SetRuleName( "SilkMaskTest" );
2477 data->SetConstraintCode( "silk_clearance" );
2478 data->SetRuleCondition( "A.NetClass == 'Power'" );
2479 data->SetNumericInputValue( 0.15 );
2480 entry.constraintData = data;
2481
2482 DRC_RULE_SAVER saver;
2483 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2484 wxString result = saver.GenerateRulesText( entries, nullptr );
2485
2486 // Should have a single merged condition, not two (condition ...) lines
2487 BOOST_CHECK( result.Contains( "L == 'F.Mask'" ) );
2488 BOOST_CHECK( result.Contains( "Power" ) );
2489 BOOST_CHECK( !result.Contains( "(layer" ) );
2490
2491 // Count occurrences of "(condition" — must be exactly one
2492 int condCount = 0;
2493 size_t pos = 0;
2494 while( ( pos = result.find( "(condition", pos ) ) != wxString::npos )
2495 {
2496 condCount++;
2497 pos++;
2498 }
2499 BOOST_CHECK_EQUAL( condCount, 1 );
2500}
2501
2502BOOST_AUTO_TEST_CASE( RuleSaverSilkToSoldermaskNoExtraCondition )
2503{
2504 // Test: Silk-to-soldermask without extra condition still produces
2505 // a condition clause, not a (layer ...) clause.
2508 entry.ruleName = "SilkMaskSimple";
2509 entry.wasEdited = true;
2510 entry.layerCondition = LSET( { B_SilkS } );
2511
2512 auto data = std::make_shared<DRC_RE_SILK_TO_SOLDERMASK_CLEARANCE_CONSTRAINT_DATA>();
2513 data->SetRuleName( "SilkMaskSimple" );
2514 data->SetConstraintCode( "silk_clearance" );
2515 data->SetNumericInputValue( 0.1 );
2516 entry.constraintData = data;
2517
2518 DRC_RULE_SAVER saver;
2519 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2520 wxString result = saver.GenerateRulesText( entries, nullptr );
2521
2522 BOOST_CHECK( result.Contains( "L == 'B.Mask'" ) );
2523 BOOST_CHECK( result.Contains( "(condition" ) );
2524 BOOST_CHECK( !result.Contains( "(layer" ) );
2525}
2526
2527BOOST_AUTO_TEST_CASE( RuleSaverSilkToSilkBothLayers )
2528{
2529 // Silk-to-silk with both layers generates L == 'F.SilkS' || L == 'B.SilkS'
2532 entry.ruleName = "SilkSilkBoth";
2533 entry.wasEdited = true;
2534 entry.layerCondition = LSET( { F_SilkS, B_SilkS } );
2535
2536 auto data = std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>();
2537 data->SetRuleName( "SilkSilkBoth" );
2538 data->SetConstraintCode( "silk_clearance" );
2539 data->SetNumericInputValue( 0.2 );
2540 entry.constraintData = data;
2541
2542 DRC_RULE_SAVER saver;
2543 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2544 wxString result = saver.GenerateRulesText( entries, nullptr );
2545
2546 BOOST_CHECK( result.Contains( "L == 'F.SilkS' || L == 'B.SilkS'" ) );
2547 BOOST_CHECK( result.Contains( "(condition" ) );
2548 BOOST_CHECK( !result.Contains( "(layer" ) );
2549}
2550
2551BOOST_AUTO_TEST_CASE( RuleSaverSilkToSilkFrontOnly )
2552{
2553 // Silk-to-silk front only generates L == 'F.SilkS'
2556 entry.ruleName = "SilkSilkFront";
2557 entry.wasEdited = true;
2558 entry.layerCondition = LSET( { F_SilkS } );
2559
2560 auto data = std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>();
2561 data->SetRuleName( "SilkSilkFront" );
2562 data->SetConstraintCode( "silk_clearance" );
2563 data->SetNumericInputValue( 0.2 );
2564 entry.constraintData = data;
2565
2566 DRC_RULE_SAVER saver;
2567 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2568 wxString result = saver.GenerateRulesText( entries, nullptr );
2569
2570 BOOST_CHECK( result.Contains( "L == 'F.SilkS'" ) );
2571 BOOST_CHECK( !result.Contains( "B.SilkS" ) );
2572 BOOST_CHECK( result.Contains( "(condition" ) );
2573 BOOST_CHECK( !result.Contains( "(layer" ) );
2574}
2575
2576BOOST_AUTO_TEST_CASE( RuleSaverSilkToSilkWithCondition )
2577{
2578 // Silk-to-silk merges layer condition with user condition
2581 entry.ruleName = "SilkSilkCond";
2582 entry.condition = "A.NetClass == 'Signal'";
2583 entry.wasEdited = true;
2584 entry.layerCondition = LSET( { F_SilkS } );
2585
2586 auto data = std::make_shared<DRC_RE_SILK_TO_SILK_CLEARANCE_CONSTRAINT_DATA>();
2587 data->SetRuleName( "SilkSilkCond" );
2588 data->SetConstraintCode( "silk_clearance" );
2589 data->SetRuleCondition( "A.NetClass == 'Signal'" );
2590 data->SetNumericInputValue( 0.2 );
2591 entry.constraintData = data;
2592
2593 DRC_RULE_SAVER saver;
2594 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = { entry };
2595 wxString result = saver.GenerateRulesText( entries, nullptr );
2596
2597 BOOST_CHECK( result.Contains( "L == 'F.SilkS'" ) );
2598 BOOST_CHECK( result.Contains( "Signal" ) );
2599
2600 // Single merged condition
2601 int condCount = 0;
2602 size_t pos = 0;
2603 while( ( pos = result.find( "(condition", pos ) ) != wxString::npos )
2604 {
2605 condCount++;
2606 pos++;
2607 }
2608 BOOST_CHECK_EQUAL( condCount, 1 );
2609}
2610
2611BOOST_AUTO_TEST_CASE( ValidateViasUnderSmdValid )
2612{
2613 // Valid: at least one via type is selected
2614 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA data1( 0, "OnlyMicro", false, true, false, false );
2615 VALIDATION_RESULT result1 = data1.Validate();
2616 BOOST_CHECK( result1.isValid );
2617 BOOST_CHECK( result1.errors.empty() );
2618
2619 // Valid: all selected
2620 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA data2( 0, "AllVias", true, true, true, true );
2621 VALIDATION_RESULT result2 = data2.Validate();
2622 BOOST_CHECK( result2.isValid );
2623 BOOST_CHECK( result2.errors.empty() );
2624}
2625
2626BOOST_AUTO_TEST_CASE( ValidateViasUnderSmdInvalid )
2627{
2628 // Invalid: no via type selected
2629 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA data( 0, "NoneSelected", false, false, false, false );
2631 BOOST_CHECK( !result.isValid );
2632 BOOST_CHECK( !result.errors.empty() );
2633
2634 bool foundError = false;
2635 for( const auto& error : result.errors )
2636 {
2637 if( error.find( "At least one via type must be selected" ) != std::string::npos )
2638 foundError = true;
2639 }
2640 BOOST_CHECK( foundError );
2641}
2642
2643BOOST_AUTO_TEST_CASE( ViasUnderSmdClauseGeneration )
2644{
2646 ctx.ruleName = "TestRule";
2647 ctx.constraintCode = "disallow_via";
2648
2649 // All four selected - shorthand "via" used
2650 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA allData( 0, "AllRule", true, true, true, true );
2651 auto clauses = allData.GetConstraintClauses( ctx );
2652 BOOST_REQUIRE_EQUAL( clauses.size(), 1 );
2653 BOOST_CHECK( clauses[0].Contains( "disallow via" ) );
2654 BOOST_CHECK( !clauses[0].Contains( "through_via" ) );
2655
2656 // Only micro_via selected - specific token
2657 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA microOnly( 0, "MicroRule", false, true, false, false );
2658 clauses = microOnly.GetConstraintClauses( ctx );
2659 BOOST_REQUIRE_EQUAL( clauses.size(), 1 );
2660 BOOST_CHECK( clauses[0].Contains( "micro_via" ) );
2661 BOOST_CHECK( !clauses[0].Contains( "through_via" ) );
2662 BOOST_CHECK( !clauses[0].Contains( "blind_via" ) );
2663 BOOST_CHECK( !clauses[0].Contains( "buried_via" ) );
2664
2665 // Through + blind selected - both tokens, no shorthand
2666 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA twoTypes( 0, "TwoRule", true, false, true, false );
2667 clauses = twoTypes.GetConstraintClauses( ctx );
2668 BOOST_REQUIRE_EQUAL( clauses.size(), 1 );
2669 BOOST_CHECK( clauses[0].Contains( "through_via" ) );
2670 BOOST_CHECK( clauses[0].Contains( "blind_via" ) );
2671 BOOST_CHECK( !clauses[0].Contains( "micro_via" ) );
2672 BOOST_CHECK( !clauses[0].Contains( "buried_via" ) );
2673
2674 // None selected - empty
2675 DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA noneData( 0, "NoneRule", false, false, false, false );
2676 clauses = noneData.GetConstraintClauses( ctx );
2677 BOOST_CHECK( clauses.empty() );
2678}
2679
2680BOOST_AUTO_TEST_CASE( IntegrationViasUnderSmdRoundTrip )
2681{
2682 // Load a rule with only micro_via disallowed
2683 wxString originalText = "(version 1)\n"
2684 "(rule \"ViasUnderSmdTest\"\n"
2685 " (constraint disallow micro_via)\n"
2686 " (condition \"A.Pad_Type == 'SMD' && A.insideArea('BGA*')\"))";
2687
2688 DRC_RULE_LOADER loader;
2689 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( originalText );
2690
2691 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2692 BOOST_CHECK_EQUAL( entries[0].panelType, VIAS_UNDER_SMD );
2693
2694 auto viaData = std::dynamic_pointer_cast<DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA>( entries[0].constraintData );
2695 BOOST_REQUIRE( viaData );
2696
2697 // Only micro_via should be checked
2698 BOOST_CHECK( !viaData->GetDisallowThroughVias() );
2699 BOOST_CHECK( viaData->GetDisallowMicroVias() );
2700 BOOST_CHECK( !viaData->GetDisallowBlindVias() );
2701 BOOST_CHECK( !viaData->GetDisallowBuriedVias() );
2702
2703 // Mark as edited and save
2704 entries[0].wasEdited = true;
2705 DRC_RULE_SAVER saver;
2706 wxString savedText = saver.GenerateRulesText( entries, nullptr );
2707
2708 // Verify saved text preserves specific via type (not blanket "via")
2709 BOOST_CHECK( savedText.Contains( "micro_via" ) );
2710 BOOST_CHECK( !savedText.Contains( "through_via" ) );
2711 BOOST_CHECK( !savedText.Contains( "blind_via" ) );
2712 BOOST_CHECK( !savedText.Contains( "buried_via" ) );
2713
2714 // Reload and verify roundtrip
2715 std::vector<DRC_RE_LOADED_PANEL_ENTRY> reloadedEntries = loader.LoadFromString( savedText );
2716 BOOST_REQUIRE_EQUAL( reloadedEntries.size(), 1 );
2717
2718 auto reloadedData =
2719 std::dynamic_pointer_cast<DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA>( reloadedEntries[0].constraintData );
2720 BOOST_REQUIRE( reloadedData );
2721
2722 BOOST_CHECK( !reloadedData->GetDisallowThroughVias() );
2723 BOOST_CHECK( reloadedData->GetDisallowMicroVias() );
2724 BOOST_CHECK( !reloadedData->GetDisallowBlindVias() );
2725 BOOST_CHECK( !reloadedData->GetDisallowBuriedVias() );
2726
2727 // Test blanket "via" sets all four flags
2728 wxString blanketText = "(version 1)\n"
2729 "(rule \"BlanketVia\"\n"
2730 " (constraint disallow via)\n"
2731 " (condition \"A.Pad_Type == 'SMD' && A.insideArea('BGA*')\"))";
2732
2733 entries = loader.LoadFromString( blanketText );
2734 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2735
2736 auto blanketData = std::dynamic_pointer_cast<DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA>( entries[0].constraintData );
2737 BOOST_REQUIRE( blanketData );
2738
2739 BOOST_CHECK( blanketData->GetDisallowThroughVias() );
2740 BOOST_CHECK( blanketData->GetDisallowMicroVias() );
2741 BOOST_CHECK( blanketData->GetDisallowBlindVias() );
2742 BOOST_CHECK( blanketData->GetDisallowBuriedVias() );
2743
2744 // Test multiple specific types roundtrip
2745 wxString multiText = "(version 1)\n"
2746 "(rule \"TwoVias\"\n"
2747 " (constraint disallow through_via blind_via)\n"
2748 " (condition \"A.Pad_Type == 'SMD' && A.insideArea('BGA*')\"))";
2749
2750 entries = loader.LoadFromString( multiText );
2751 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2752
2753 auto multiData = std::dynamic_pointer_cast<DRC_RE_VIAS_UNDER_SMD_CONSTRAINT_DATA>( entries[0].constraintData );
2754 BOOST_REQUIRE( multiData );
2755
2756 BOOST_CHECK( multiData->GetDisallowThroughVias() );
2757 BOOST_CHECK( !multiData->GetDisallowMicroVias() );
2758 BOOST_CHECK( multiData->GetDisallowBlindVias() );
2759 BOOST_CHECK( !multiData->GetDisallowBuriedVias() );
2760
2761 entries[0].wasEdited = true;
2762 savedText = saver.GenerateRulesText( entries, nullptr );
2763
2764 BOOST_CHECK( savedText.Contains( "through_via" ) );
2765 BOOST_CHECK( savedText.Contains( "blind_via" ) );
2766 BOOST_CHECK( !savedText.Contains( "micro_via" ) );
2767 BOOST_CHECK( !savedText.Contains( "buried_via" ) );
2768}
2769
2770BOOST_AUTO_TEST_CASE( RuleLoaderNonStandardOrientationFallsBackToCustom )
2771{
2772 // Quoted name
2773 wxString ruleText = "(version 1)\n"
2774 "(rule \"Angled\"\n"
2775 " (constraint assertion \"A.Orientation == 46 deg\")\n"
2776 ")";
2777
2778 DRC_RULE_LOADER loader;
2779 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2780
2781 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2782 BOOST_CHECK_EQUAL( entries[0].panelType, CUSTOM_RULE );
2783
2784 auto customData = std::dynamic_pointer_cast<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( entries[0].constraintData );
2785 BOOST_REQUIRE( customData );
2786 BOOST_CHECK( customData->GetRuleText().Contains( wxS( "46 deg" ) ) );
2787 BOOST_CHECK( !customData->GetRuleText().Contains( wxS( "Angled" ) ) );
2788
2789 // Unquoted name
2790 wxString ruleTextUnquoted = "(version 1)\n"
2791 "(rule Angled\n"
2792 " (constraint assertion \"A.Orientation == 46 deg\")\n"
2793 ")";
2794
2795 entries = loader.LoadFromString( ruleTextUnquoted );
2796
2797 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2798 BOOST_CHECK_EQUAL( entries[0].panelType, CUSTOM_RULE );
2799
2800 auto customDataUnquoted =
2801 std::dynamic_pointer_cast<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( entries[0].constraintData );
2802 BOOST_REQUIRE( customDataUnquoted );
2803 BOOST_CHECK( customDataUnquoted->GetRuleText().Contains( wxS( "46 deg" ) ) );
2804 BOOST_CHECK( !customDataUnquoted->GetRuleText().Contains( wxS( "Angled" ) ) );
2805}
2806
2807BOOST_AUTO_TEST_CASE( RuleLoaderStandardOrientationLoadsStructured )
2808{
2809 wxString ruleText = "(version 1)\n"
2810 "(rule \"Standard\"\n"
2811 " (constraint assertion \"A.Orientation == 0 deg || A.Orientation == 90 deg\")\n"
2812 ")";
2813
2814 DRC_RULE_LOADER loader;
2815 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2816
2817 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2818 BOOST_CHECK_EQUAL( entries[0].panelType, ALLOWED_ORIENTATION );
2819
2820 auto orientData =
2821 std::dynamic_pointer_cast<DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA>( entries[0].constraintData );
2822 BOOST_REQUIRE( orientData );
2823 BOOST_CHECK( orientData->GetIsZeroDegreesAllowed() );
2824 BOOST_CHECK( orientData->GetIsNinetyDegreesAllowed() );
2825 BOOST_CHECK( !orientData->GetIsOneEightyDegreesAllowed() );
2826 BOOST_CHECK( !orientData->GetIsAllDegreesAllowed() );
2827
2828 // Single-line variant
2829 wxString singleLine = "(version 1) (rule \"SingleLine\" (constraint assertion \"A.Orientation == 0 deg || "
2830 "A.Orientation == 90 deg\"))";
2831
2832 entries = loader.LoadFromString( singleLine );
2833
2834 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2835 BOOST_CHECK_EQUAL( entries[0].panelType, ALLOWED_ORIENTATION );
2836
2837 auto singleLineData =
2838 std::dynamic_pointer_cast<DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA>( entries[0].constraintData );
2839 BOOST_REQUIRE( singleLineData );
2840 BOOST_CHECK( singleLineData->GetIsZeroDegreesAllowed() );
2841 BOOST_CHECK( singleLineData->GetIsNinetyDegreesAllowed() );
2842 BOOST_CHECK( !singleLineData->GetIsOneEightyDegreesAllowed() );
2843 BOOST_CHECK( !singleLineData->GetIsAllDegreesAllowed() );
2844}
2845
2846BOOST_AUTO_TEST_CASE( RuleLoaderAllowAllOrientationLoadsStructured )
2847{
2848 wxString ruleText = "(version 1)\n"
2849 "(rule \"AllAngles\"\n"
2850 " (constraint assertion \"A.Orientation == 0 deg || A.Orientation == 90 deg || "
2851 "A.Orientation == 180 deg || A.Orientation == 270 deg\")\n"
2852 ")";
2853
2854 DRC_RULE_LOADER loader;
2855 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2856
2857 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2858 BOOST_CHECK_EQUAL( entries[0].panelType, ALLOWED_ORIENTATION );
2859
2860 auto orientData =
2861 std::dynamic_pointer_cast<DRC_RE_ALLOWED_ORIENTATION_CONSTRAINT_DATA>( entries[0].constraintData );
2862 BOOST_REQUIRE( orientData );
2863 BOOST_CHECK( orientData->GetIsAllDegreesAllowed() );
2864 BOOST_CHECK( orientData->GetIsZeroDegreesAllowed() );
2865 BOOST_CHECK( orientData->GetIsNinetyDegreesAllowed() );
2866 BOOST_CHECK( orientData->GetIsOneEightyDegreesAllowed() );
2867 BOOST_CHECK( orientData->GetIsTwoSeventyDegreesAllowed() );
2868}
2869
2870BOOST_AUTO_TEST_CASE( RuleLoaderPermittedLayersInnerLayerFallsBackToCustom )
2871{
2872 wxString ruleText = "(version 1)\n"
2873 "(rule \"InnerLayers\"\n"
2874 " (constraint assertion \"A.Layer == 'F.Cu' || A.Layer == 'In1.Cu'\")\n"
2875 ")";
2876
2877 DRC_RULE_LOADER loader;
2878 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2879
2880 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2881 BOOST_CHECK_EQUAL( entries[0].panelType, CUSTOM_RULE );
2882
2883 auto customData = std::dynamic_pointer_cast<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( entries[0].constraintData );
2884 BOOST_REQUIRE( customData );
2885 BOOST_CHECK( customData->GetRuleText().Contains( wxS( "In1.Cu" ) ) );
2886}
2887
2888BOOST_AUTO_TEST_CASE( RuleLoaderPermittedLayersStandardLoadsStructured )
2889{
2890 wxString ruleText = "(version 1)\n"
2891 "(rule \"StandardLayers\"\n"
2892 " (constraint assertion \"A.Layer == 'F.Cu' || A.Layer == 'B.Cu'\")\n"
2893 ")";
2894
2895 DRC_RULE_LOADER loader;
2896 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2897
2898 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2899 BOOST_CHECK_EQUAL( entries[0].panelType, PERMITTED_LAYERS );
2900
2901 auto layerData = std::dynamic_pointer_cast<DRC_RE_PERMITTED_LAYERS_CONSTRAINT_DATA>( entries[0].constraintData );
2902 BOOST_REQUIRE( layerData );
2903 BOOST_CHECK( layerData->GetTopLayerEnabled() );
2904 BOOST_CHECK( layerData->GetBottomLayerEnabled() );
2905}
2906
2907
2908BOOST_AUTO_TEST_CASE( CustomPropertyHelperMatches )
2909{
2910 BOARD board;
2911
2912 FOOTPRINT* vendorFp = new FOOTPRINT( &board );
2913 vendorFp->SetReference( wxT( "U1" ) );
2914 vendorFp->SetCustomProperty( wxT( "Vendor" ), wxT( "ACME" ) );
2915 board.Add( vendorFp );
2916
2917 FOOTPRINT* otherFp = new FOOTPRINT( &board );
2918 otherFp->SetReference( wxT( "U2" ) );
2919 board.Add( otherFp );
2920
2921 auto rule = std::make_shared<DRC_RULE>( wxT( "Custom property" ) );
2922 rule->m_Condition = new DRC_RULE_CONDITION( wxT( "A.customProperty('Vendor') == 'ACME'" ) );
2923 BOOST_REQUIRE( rule->m_Condition->Compile( nullptr ) );
2924
2926 rule->AddConstraint( constraint );
2927
2928 DRC_ENGINE engine( &board, &board.GetDesignSettings() );
2929
2930 std::vector<BOARD_ITEM*> matches = engine.GetItemsMatchingRule( rule, nullptr );
2931
2932 BOOST_REQUIRE_EQUAL( matches.size(), 1u );
2933 BOOST_CHECK( matches.front() == vendorFp );
2934}
2935
2936
2937BOOST_AUTO_TEST_CASE( HasCustomPropertyHelperMatches )
2938{
2939 BOARD board;
2940
2941 FOOTPRINT* vendorFp = new FOOTPRINT( &board );
2942 vendorFp->SetReference( wxT( "U1" ) );
2943 vendorFp->SetCustomProperty( wxT( "Vendor" ), wxT( "ACME" ) );
2944 board.Add( vendorFp );
2945
2946 FOOTPRINT* otherFp = new FOOTPRINT( &board );
2947 otherFp->SetReference( wxT( "U2" ) );
2948 board.Add( otherFp );
2949
2950 auto rule = std::make_shared<DRC_RULE>( wxT( "Has custom property" ) );
2951 rule->m_Condition = new DRC_RULE_CONDITION( wxT( "A.hasCustomProperty('Vendor')" ) );
2952 BOOST_REQUIRE( rule->m_Condition->Compile( nullptr ) );
2953
2955 rule->AddConstraint( constraint );
2956
2957 DRC_ENGINE engine( &board, &board.GetDesignSettings() );
2958
2959 std::vector<BOARD_ITEM*> matches = engine.GetItemsMatchingRule( rule, nullptr );
2960
2961 BOOST_REQUIRE_EQUAL( matches.size(), 1u );
2962 BOOST_CHECK( matches.front() == vendorFp );
2963}
2964
2965
2966// A time domain length rule loads into the length panel with its values in ps.
2967BOOST_AUTO_TEST_CASE( RuleLoaderTimeDomainLengthLoadsStructured )
2968{
2969 wxString ruleText = "(version 1)\n"
2970 "(rule \"clk_delay\"\n"
2971 " (constraint length (min 210ps) (max 230ps))\n"
2972 ")";
2973
2974 DRC_RULE_LOADER loader;
2975 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
2976
2977 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
2978 BOOST_CHECK_EQUAL( entries[0].panelType, ABSOLUTE_LENGTH );
2979
2980 auto data = std::dynamic_pointer_cast<DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA>( entries[0].constraintData );
2981 BOOST_REQUIRE( data );
2982 BOOST_CHECK( data->IsTimeDomain() );
2983 BOOST_CHECK_CLOSE( data->GetOptimumLength(), 220.0, 0.0001 );
2984 BOOST_CHECK_CLOSE( data->GetTolerance(), 10.0, 0.0001 );
2985}
2986
2987
2988BOOST_AUTO_TEST_CASE( RoundTripTimeDomainLength )
2989{
2990 DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA original( 0, 220.0, 10.0, "clk_delay" );
2991 original.SetConstraintCode( "length" );
2992 original.SetTimeDomain( true );
2993
2995 ctx.ruleName = original.GetRuleName();
2996 ctx.constraintCode = original.GetConstraintCode();
2997
2998 wxString ruleText = original.GenerateRule( ctx );
2999
3000 BOOST_CHECK( ruleText.Contains( wxS( "210ps" ) ) );
3001 BOOST_CHECK( ruleText.Contains( wxS( "220ps" ) ) );
3002 BOOST_CHECK( ruleText.Contains( wxS( "230ps" ) ) );
3003
3004 DRC_RULE_LOADER loader;
3005 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
3006
3007 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
3008
3009 auto parsed = std::dynamic_pointer_cast<DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA>( entries[0].constraintData );
3010 BOOST_REQUIRE( parsed );
3011 BOOST_CHECK( parsed->IsTimeDomain() );
3012 BOOST_CHECK_CLOSE( parsed->GetOptimumLength(), 220.0, 0.0001 );
3013 BOOST_CHECK_CLOSE( parsed->GetTolerance(), 10.0, 0.0001 );
3014}
3015
3016
3017// A rule with no optimum must keep its min and max through an open and save cycle.
3018BOOST_AUTO_TEST_CASE( RoundTripLengthWithoutOpt )
3019{
3020 wxString ruleText = "(version 1)\n"
3021 "(rule \"len_window\"\n"
3022 " (constraint length (min 30mm) (max 50mm))\n"
3023 ")";
3024
3025 DRC_RULE_LOADER loader;
3026 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
3027
3028 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
3029 BOOST_CHECK_EQUAL( entries[0].panelType, ABSOLUTE_LENGTH );
3030
3031 auto data = std::dynamic_pointer_cast<DRC_RE_ABSOLUTE_LENGTH_TWO_CONSTRAINT_DATA>( entries[0].constraintData );
3032 BOOST_REQUIRE( data );
3033 BOOST_CHECK_CLOSE( data->GetOptimumLength(), 40.0, 0.0001 );
3034 BOOST_CHECK_CLOSE( data->GetTolerance(), 10.0, 0.0001 );
3035
3037 ctx.ruleName = entries[0].ruleName;
3038 ctx.constraintCode = data->GetConstraintCode();
3039
3040 wxString saved = data->GenerateRule( ctx );
3041
3042 BOOST_CHECK( saved.Contains( wxS( "30mm" ) ) );
3043 BOOST_CHECK( saved.Contains( wxS( "40mm" ) ) );
3044 BOOST_CHECK( saved.Contains( wxS( "50mm" ) ) );
3045}
3046
3047
3048// A commented out constraint must not appear in the body as active rule text.
3049BOOST_AUTO_TEST_CASE( RuleBodyExcludesCommentLines )
3050{
3051 wxString ruleText = "(rule \"length_DDR_Byte0\"\n"
3052 "\t# byte lane 0\n"
3053 "\t# (constraint length (min 29.5mm) (max 30.5mm) (opt 30mm))\n"
3054 "(constraint length (min 210ps) (max 230ps) (opt 223ps))\n"
3055 "\t# tightened after bring-up\n"
3056 "\t(condition \"A.NetClass == 'DDR4_BYTE0'\"))";
3057
3058 wxString body = DRC_RULE_LOADER::ExtractRuleBody( ruleText );
3059
3060 BOOST_CHECK( body.StartsWith( wxS( "(constraint length (min 210ps)" ) ) );
3061 BOOST_CHECK( !body.Contains( wxS( "29.5mm" ) ) );
3062 BOOST_CHECK( !body.Contains( wxS( "byte lane" ) ) );
3063 BOOST_CHECK( !body.Contains( wxS( "bring-up" ) ) );
3064 BOOST_CHECK( body.Contains( wxS( "condition" ) ) );
3065
3066 wxString comment = DRC_RULE_LOADER::ExtractRuleComment( ruleText );
3067
3068 BOOST_CHECK( comment.Contains( wxS( "byte lane 0" ) ) );
3069 BOOST_CHECK( comment.Contains( wxS( "29.5mm" ) ) );
3070 BOOST_CHECK( comment.Contains( wxS( "bring-up" ) ) );
3071}
3072
3073
3074// The matched length pair panel still cannot hold time, so a ps skew stays as text.
3075BOOST_AUTO_TEST_CASE( RuleLoaderTimeDomainSkewStillFallsBackToCustom )
3076{
3077 wxString ruleText = "(version 1)\n"
3078 "(rule \"pair_ps\"\n"
3079 " (constraint length (min 10mm) (opt 11mm) (max 12mm))\n"
3080 " (constraint skew (max 5ps))\n"
3081 ")";
3082
3083 DRC_RULE_LOADER loader;
3084 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
3085
3086 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
3087 BOOST_CHECK_EQUAL( entries[0].panelType, CUSTOM_RULE );
3088
3089 auto customData = std::dynamic_pointer_cast<DRC_RE_CUSTOM_RULE_CONSTRAINT_DATA>( entries[0].constraintData );
3090 BOOST_REQUIRE( customData );
3091 BOOST_CHECK( customData->GetRuleText().Contains( wxS( "5ps" ) ) );
3092}
3093
3094
3095BOOST_AUTO_TEST_CASE( RuleLoaderSpatialLengthStaysStructured )
3096{
3097 wxString ruleText = "(version 1)\n"
3098 "(rule \"len_mm\"\n"
3099 " (constraint length (min 30mm) (opt 40mm) (max 50mm))\n"
3100 ")";
3101
3102 DRC_RULE_LOADER loader;
3103 std::vector<DRC_RE_LOADED_PANEL_ENTRY> entries = loader.LoadFromString( ruleText );
3104
3105 BOOST_REQUIRE_EQUAL( entries.size(), 1 );
3106 BOOST_CHECK_EQUAL( entries[0].panelType, ABSOLUTE_LENGTH );
3107}
3108
const char * name
General utilities for PCB file IO for QA programs.
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:411
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_MODE::INSERT, bool aSkipConnectivity=false) override
Removes an item from the container.
Definition board.cpp:1548
BOARD_DESIGN_SETTINGS & GetDesignSettings()
Definition board.cpp:1318
MINOPTMAX< int > & Value()
Definition drc_rule.h:130
Design Rule Checker object that performs all the DRC tests.
Definition drc_engine.h:129
std::vector< BOARD_ITEM * > GetItemsMatchingRule(const std::shared_ptr< DRC_RULE > &aRule, REPORTER *aReporter=nullptr)
Maps DRC rule constraints to appropriate editor panels.
DRC_RULE_EDITOR_CONSTRAINT_NAME GetPanelForConstraint(DRC_CONSTRAINT_T aConstraintType)
Get the panel type for a single constraint.
bool CanPanelLoad(DRC_RULE_EDITOR_CONSTRAINT_NAME aPanel, const std::set< DRC_CONSTRAINT_T > &aConstraints)
Check if a specific panel type can load a set of constraints.
std::vector< DRC_PANEL_MATCH > MatchRule(const DRC_RULE &aRule)
Match a DRC rule to one or more panel types.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
wxString GenerateRule(const RULE_GENERATION_CONTEXT &aContext) override
VALIDATION_RESULT Validate() const override
Validates the constraint data.
void SetConstraintCode(const wxString &aCode)
void SetRuleCondition(const wxString &aRuleCondition)
VALIDATION_RESULT Validate() const override
Validates the constraint data.
Simple constraint data object used by custom rules.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
wxString GenerateRule(const RULE_GENERATION_CONTEXT &aContext) override
VALIDATION_RESULT Validate() const override
Validates the constraint data.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
std::vector< wxString > GetConstraintClauses(const RULE_GENERATION_CONTEXT &aContext) const override
Returns just the constraint clauses without the rule wrapper.
VALIDATION_RESULT Validate() const override
Validates the constraint data.
wxString GenerateRule(const RULE_GENERATION_CONTEXT &aContext) override
void Parse(std::vector< std::shared_ptr< DRC_RULE > > &aRules, REPORTER *aReporter)
static bool SaveRules(const wxString &aFilename, const std::vector< std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA > > &aRules, const BOARD *aBoard)
static void RegisterRuleConverter(RuleConverter aConverter)
static std::optional< SELECTOR_CONDITION > ParseSelectorCondition(const wxString &aExpr)
Match a condition that a net, netclass or area selector can show.
static std::vector< std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA > > ParseRules(const wxString &aRules)
Loads DRC rules from .kicad_dru files and converts them to panel entries.
const DRC_RE_FILE_TRIVIA & GetFileTrivia() const
std::vector< DRC_RE_LOADED_PANEL_ENTRY > LoadFromString(const wxString &aRulesText, bool *aParsed=nullptr)
Load rules from a text string.
static wxString ExtractRuleComment(const wxString &aOriginalText)
Extract comment lines from a rule.
static wxString ExtractRuleBody(const wxString &aOriginalText)
Extract the body of a rule from its original text, stripping the (rule "name" ...) wrapper.
std::vector< DRC_RE_LOADED_PANEL_ENTRY > LoadFile(const wxString &aPath)
Load all rules from a .kicad_dru file.
Saves DRC panel entries back to .kicad_dru files.
wxString GenerateRulesText(const std::vector< DRC_RE_LOADED_PANEL_ENTRY > &aEntries, const BOARD *aBoard=nullptr, const DRC_RE_FILE_TRIVIA &aTrivia={})
Generate rule text from panel entries.
void AddConstraint(DRC_CONSTRAINT &aConstraint)
Definition drc_rule.cpp:69
void SetCustomProperty(const wxString &aKey, const wxString &aValue)
Definition eda_item.h:255
void SetReference(const wxString &aReference)
Definition footprint.h:799
LSET is a set of PCB_LAYER_IDs.
Definition lset.h:37
void SetMin(T v)
Definition minoptmax.h:41
void SetOpt(T v)
Definition minoptmax.h:43
void SetMax(T v)
Definition minoptmax.h:42
A PCB_IO derivation for saving and loading Pcbnew s-expression formatted files.
std::unique_ptr< BOARD > LoadBoard(const wxString &aFileName, const std::map< std::string, UTF8 > *aProperties=nullptr, PROJECT *aProject=nullptr)
Load information from some input file format that this PCB_IO implementation knows about into new BOA...
Definition pcb_io.cpp:72
wxString GetRuleName() const
Get the name of the rule.
A wrapper for reporting to a wxString object.
Definition reporter.h:242
@ COURTYARD_CLEARANCE_CONSTRAINT
@ VIA_DIAMETER_CONSTRAINT
@ DIFF_PAIR_GAP_CONSTRAINT
@ TRACK_WIDTH_CONSTRAINT
@ SILK_CLEARANCE_CONSTRAINT
@ EDGE_CLEARANCE_CONSTRAINT
@ LENGTH_CONSTRAINT
@ CLEARANCE_CONSTRAINT
@ MAX_UNCOUPLED_CONSTRAINT
@ SKEW_CONSTRAINT
@ LINE_WIDTH_CONSTRAINT
@ HOLE_CLEARANCE_CONSTRAINT
@ HOLE_SIZE_CONSTRAINT
@ TEXT_HEIGHT_CONSTRAINT
@ HOLE_TO_HOLE_CONSTRAINT
@ HOLE_ASPECT_RATIO
@ ALLOWED_ORIENTATION
@ SILK_TO_SILK_CLEARANCE
@ ROUTING_DIFF_PAIR
@ SILK_TO_SOLDERMASK_CLEARANCE
@ VIAS_UNDER_SMD
@ COURTYARD_CLEARANCE
@ MINIMUM_CONNECTION_WIDTH
@ ABSOLUTE_LENGTH
@ MINIMUM_CLEARANCE
@ PERMITTED_LAYERS
@ MICROVIA_STACK_DEPTH
@ MINIMUM_TEXT_HEIGHT_AND_THICKNESS
@ COPPER_TO_HOLE_CLEARANCE
@ HOLE_TO_HOLE_DISTANCE
@ ROUTING_WIDTH
@ MATCHED_LENGTH_DIFF_PAIR
@ COPPER_TO_EDGE_CLEARANCE
@ MINIMUM_VIA_DIAMETER
@ F_SilkS
Definition layer_ids.h:96
@ B_SilkS
Definition layer_ids.h:97
@ F_Cu
Definition layer_ids.h:60
std::string GetPcbnewTestDataDir()
Utility which returns a path to the data directory where the test board files are stored.
@ RPT_SEVERITY_ERROR
@ RPT_SEVERITY_IGNORE
Represents a rule loaded from a .kicad_dru file and mapped to a panel.
wxString ruleName
wxString originalRuleText
wxString condition
bool wasEdited
LSET layerCondition
std::shared_ptr< DRC_RE_BASE_CONSTRAINT_DATA > constraintData
DRC_RULE_EDITOR_CONSTRAINT_NAME panelType
Result of a validation operation.
std::vector< wxString > errors
BOOST_AUTO_TEST_CASE(HorizontalAlignment)
BOOST_AUTO_TEST_SUITE(CadstarPartParser)
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_CASE(RoundTripViaStyle)
BOOST_AUTO_TEST_SUITE_END()
std::string path
IbisParser parser & reporter
BOOST_TEST_CONTEXT("Test Clearance")
int clearance
wxString result
Test unit parsing edge cases and error handling.
KICAD_T
The set of class identification values stored in EDA_ITEM::m_structType.
Definition typeinfo.h:70
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:80
@ PCB_GENERATOR_T
class PCB_GENERATOR, generator on a layer
Definition typeinfo.h:83
@ PCB_VIA_T
class PCB_VIA, a via (like a track segment on a copper layer)
Definition typeinfo.h:89
@ PCB_GROUP_T
class PCB_GROUP, a set of BOARD_ITEMs
Definition typeinfo.h:103
@ PCB_ZONE_T
class ZONE, a copper pour area
Definition typeinfo.h:100
@ PCB_TEXT_T
class PCB_TEXT, text on a layer
Definition typeinfo.h:84
@ PCB_FOOTPRINT_T
class FOOTPRINT, a footprint
Definition typeinfo.h:78
@ PCB_PAD_T
class PAD, a pad in a footprint
Definition typeinfo.h:79
@ PCB_NETINFO_T
class NETINFO_ITEM, a description of a net
Definition typeinfo.h:102
@ PCB_TRACE_T
class PCB_TRACK, a track segment (segment on a copper layer)
Definition typeinfo.h:88