KiCad PCB EDA Suite
Loading...
Searching...
No Matches
test_job_export_pcb_variants.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
5 *
6 * This program is free software; you can redistribute it and/or
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>
28#include <jobs/job_pcb_render.h>
29#include <json_common.h>
31#include <string_utils.h>
32
33#include <filesystem>
34#include <fstream>
35#include <clocale>
36
37
38// Regression coverage for issue #24092: variant fields on JOBSET-resident jobs
39// must round-trip through ToJson/FromJson.
40
41BOOST_AUTO_TEST_SUITE( JobExportPcbVariants )
42
43BOOST_AUTO_TEST_CASE( OdbVariantFileTokenKeepsNamesAndRemovesSeparators )
44{
45 BOOST_CHECK_EQUAL( GetVariantFileToken( wxS( "Variant A" ) ), wxString( wxS( "Variant A" ) ) );
46 BOOST_CHECK_EQUAL( GetVariantFileToken( wxS( "A/B" ) ), wxString( wxS( "A_B" ) ) );
48 BOOST_CHECK_EQUAL( ExpandVariantOutputPath( wxS( "bom-${VARIANT}.csv" ), wxString() ),
49 wxString( wxS( "bom-.csv" ) ) );
50 BOOST_CHECK_EQUAL( ExpandVariantOutputPath( wxS( "out-${VARIANT}.zip" ),
51 GetVariantFileToken( wxS( "A/B" ) ) ),
52 wxString( wxS( "out-A_B.zip" ) ) );
53 BOOST_CHECK_EQUAL( ExpandVariantOutputPath( wxS( "bom-${VARIANT}.csv" ), wxS( "A/B" ) ),
54 wxString( wxS( "bom-A/B.csv" ) ) );
55}
56
57BOOST_AUTO_TEST_CASE( OdbLegacyVariantKeyStillLoads )
58{
60 job.FromJson( nlohmann::json{ { "variant", "Variant A" } } );
61 BOOST_REQUIRE_EQUAL( job.m_variantNames.size(), 1u );
62 BOOST_CHECK_EQUAL( job.m_variantNames.front(), wxString( wxS( "Variant A" ) ) );
64
66 nlohmann::json json;
67 job.ToJson( json );
68 BOOST_CHECK_EQUAL( json.at( "variant_packaging" ).get<std::string>(), "combined" );
69
70 JOB_EXPORT_PCB_ODB loaded;
71 loaded.FromJson( json );
73}
74
75
76BOOST_AUTO_TEST_CASE( FabJobMissingKeysKeepDefaults )
77{
78 nlohmann::json missingKeys = nlohmann::json::object();
79
81 odb.FromJson( missingKeys );
82 nlohmann::json odbJson;
83 odb.ToJson( odbJson );
84 BOOST_CHECK_EQUAL( odbJson.at( "precision" ).get<int>(), 6 );
85 BOOST_CHECK_EQUAL( odbJson.at( "units" ).get<std::string>(), "mm" );
86 BOOST_CHECK( !odbJson.at( "check_zones" ).get<bool>() );
87 BOOST_CHECK( odbJson.at( "board_metadata" ).get<bool>() );
88 BOOST_CHECK_EQUAL( odbJson.at( "variant" ).get<std::string>(), "" );
89
91 ipc.FromJson( missingKeys );
92 nlohmann::json ipcJson;
93 ipc.ToJson( ipcJson );
94 BOOST_CHECK_EQUAL( ipcJson.at( "precision" ).get<int>(), 6 );
95 BOOST_CHECK_EQUAL( ipcJson.at( "units" ).get<std::string>(), "mm" );
96 BOOST_CHECK( !ipcJson.value( "check_zones", true ) );
97
98 BOOST_CHECK_EQUAL( ipcJson.at( "variant" ).get<std::string>(), "" );
99
100 nlohmann::json emptyVariant = { { "variant", "" } };
101 JOB_EXPORT_PCB_ODB legacyOdb;
102 JOB_EXPORT_PCB_IPC2581 legacyIpc;
103 legacyOdb.FromJson( emptyVariant );
104 legacyIpc.FromJson( emptyVariant );
105 BOOST_CHECK( legacyOdb.m_variantNames.empty() );
106 BOOST_CHECK( legacyIpc.m_variantNames.empty() );
107}
108
109
110BOOST_AUTO_TEST_CASE( FabV10JobsLoadUnchanged )
111{
112 std::filesystem::path fixtureDir = std::filesystem::path( KI_TEST::GetTestDataRootDir() ) / "common" / "jobs";
113 std::ifstream odbFile( fixtureDir / "odb_job_v10.json" );
114 std::ifstream ipcFile( fixtureDir / "ipc2581_job_v10.json" );
115 BOOST_REQUIRE( odbFile );
116 BOOST_REQUIRE( ipcFile );
117 nlohmann::json odbV10 = nlohmann::json::parse( odbFile );
118 nlohmann::json ipcV10 = nlohmann::json::parse( ipcFile );
119
121 odb.FromJson( odbV10 );
122 nlohmann::json odbRoundTrip;
123 odb.ToJson( odbRoundTrip );
124
125 for( auto it = odbV10.begin(); it != odbV10.end(); ++it )
126 {
127 BOOST_CHECK_MESSAGE( odbRoundTrip.at( it.key() ) == it.value(), "ODB key " << it.key() );
128 }
129
131 ipc.FromJson( ipcV10 );
132 nlohmann::json ipcRoundTrip;
133 ipc.ToJson( ipcRoundTrip );
134
135 for( auto it = ipcV10.begin(); it != ipcV10.end(); ++it )
136 {
137 BOOST_CHECK_MESSAGE( ipcRoundTrip.at( it.key() ) == it.value(), "IPC key " << it.key() );
138 }
139
140 BOOST_CHECK( odbRoundTrip.contains( "variant_names" ) );
141 BOOST_CHECK( ipcRoundTrip.contains( "variant_names" ) );
142 BOOST_CHECK( odb.m_colMfgPn.IsEmpty() );
143 BOOST_CHECK( ipc.m_colMfgPn.IsEmpty() );
145 BOOST_CHECK( odb.m_productName.IsEmpty() );
147 BOOST_CHECK( !odb.m_sections );
149 BOOST_CHECK( odb.m_layerOverrides.empty() );
153}
154
155
156// Nightlies kept the IPC-2581 function mode under "mode" and wrote empty strings by default
157BOOST_AUTO_TEST_CASE( Ipc2581NightlyContentKeysStillLoad )
158{
159 using DATA_SET = JOB_EXPORT_PCB_FAB::DATA_SET;
160
162 job.FromJson( nlohmann::json{ { "mode", "FABRICATION" },
163 { "sections", "KE" },
164 { "net_names", "anonymize" },
165 { "ref_des", "omit" } } );
166 BOOST_CHECK( job.m_dataSet == DATA_SET::FABRICATION );
168 BOOST_CHECK_EQUAL( *job.m_sections, wxString( wxS( "KE" ) ) );
171
172 nlohmann::json json;
173 job.ToJson( json );
174 BOOST_CHECK_EQUAL( json.at( "data_set" ).get<std::string>(), "fabrication" );
175 BOOST_CHECK( !json.contains( "mode" ) );
176
177 JOB_EXPORT_PCB_IPC2581 reloaded;
178 reloaded.FromJson( json );
179 BOOST_CHECK( reloaded.m_dataSet == DATA_SET::FABRICATION );
180
182 unset.FromJson( nlohmann::json{ { "mode", "" }, { "net_names", "" }, { "ref_des", "" } } );
183 BOOST_CHECK( unset.m_dataSet == DATA_SET::USERDEF );
186
187 // An unknown token must not turn into the broadest data set
189 bogus.FromJson( nlohmann::json{ { "mode", "bogus" } } );
190 BOOST_CHECK( bogus.m_dataSet == DATA_SET::COUNT );
191
192 BOOST_CHECK( JOB_EXPORT_PCB_FAB::DataSetToken( DATA_SET::COUNT ).empty() );
193 BOOST_CHECK_EQUAL( JOB_EXPORT_PCB_FAB::DataSetToken( DATA_SET::FABRICATION ), "fabrication" );
194
195 JOB_EXPORT_PCB_ODB bogusOdb;
196 bogusOdb.FromJson( nlohmann::json{ { "data_set", "bogus" } } );
197 BOOST_CHECK( bogusOdb.m_dataSet == DATA_SET::COUNT );
198}
199
200
201BOOST_AUTO_TEST_CASE( OdbMappedMpnFieldRoundTrips )
202{
204 job.m_colMfgPn = wxS( "MPN" );
205 nlohmann::json json;
206 job.ToJson( json );
207 BOOST_CHECK_EQUAL( json.at( "field_bom_map.mfg_pn" ).get<std::string>(), "MPN" );
208
209 JOB_EXPORT_PCB_ODB loaded;
210 loaded.FromJson( json );
211 BOOST_CHECK_EQUAL( loaded.m_colMfgPn, wxString( wxS( "MPN" ) ) );
212
214 ipc.FromJson( nlohmann::json{ { "field_bom_map.mfg_pn", "IPC-MPN" } } );
215 nlohmann::json ipcJson;
216 ipc.ToJson( ipcJson );
217 BOOST_CHECK_EQUAL( ipcJson.at( "field_bom_map.mfg_pn" ).get<std::string>(), "IPC-MPN" );
218}
219
220
221BOOST_AUTO_TEST_CASE( OdbExportOptionsRoundTrip )
222{
223 nlohmann::json options = { { "origin", "aux" },
224 { "product_name", "Fab Rev A" },
225 { "data_set", "assembly" },
226 { "sections", "ACOP" },
227 { "board_metadata", false },
228 { "net_names", "anonymize" },
229 { "layers", nlohmann::json::array( { { { "layer", "F.Cu" },
230 { "include", false },
231 { "odb_name", "front_copper" },
232 { "odb_type", "SIGNAL" } } } ) } };
234 job.FromJson( options );
235 nlohmann::json roundTrip;
236 job.ToJson( roundTrip );
237
238 for( auto it = options.begin(); it != options.end(); ++it )
239 BOOST_CHECK_MESSAGE( roundTrip.contains( it.key() ) && roundTrip[it.key()] == it.value(), it.key() );
240
241 JOB_EXPORT_PCB_ODB loaded;
242 loaded.FromJson( roundTrip );
243 nlohmann::json again;
244 loaded.ToJson( again );
245 BOOST_CHECK( roundTrip == again );
246}
247
248
249BOOST_AUTO_TEST_CASE( OdbInvalidLayerOverrideRetainsAutomaticMetadata )
250{
252 job.FromJson( nlohmann::json{
253 { "layers", nlohmann::json::array( { { { "layer", "F.Cu" }, { "include", "not-a-boolean" } },
254 { { "layer", "B.Cu" }, { "odb_name", 12 } },
255 { { "layer", "In1.Cu" }, { "odb_type", false } } } ) } } );
256
257 BOOST_REQUIRE_EQUAL( job.m_layerOverrides.size(), 3u );
258
259 for( const ODB_LAYER_OVERRIDE& override : job.m_layerOverrides )
260 BOOST_CHECK( override.m_layer == UNDEFINED_LAYER );
261}
262
263
264BOOST_AUTO_TEST_CASE( OdbLayerOverrideUtf8IgnoresProcessLocale )
265{
267 job.m_layerOverrides.push_back( { F_Cu, true, wxString::FromUTF8( "Résumé_日本" ), wxS( "SIGNAL" ) } );
268 nlohmann::json json;
269
270 {
271 struct RESTORE_LOCALE
272 {
273 std::string m_previous = std::setlocale( LC_CTYPE, nullptr );
274 ~RESTORE_LOCALE() { std::setlocale( LC_CTYPE, m_previous.c_str() ); }
275 } restoreLocale;
276
277 BOOST_REQUIRE( std::setlocale( LC_CTYPE, "C" ) );
278 job.ToJson( json );
279 }
280
281 BOOST_CHECK_EQUAL( json.at( "layers" ).at( 0 ).at( "odb_name" ).get<std::string>(), "Résumé_日本" );
282}
283
284
285BOOST_AUTO_TEST_CASE( Ipc2581CheckZonesOptionExists )
286{
288 nlohmann::json options = { { "check_zones", true } };
289 ipc.FromJson( options );
290 nlohmann::json roundTrip;
291 ipc.ToJson( roundTrip );
292 BOOST_CHECK( roundTrip.value( "check_zones", false ) );
293}
294
295
296BOOST_AUTO_TEST_CASE( Pcb3dVariantRoundTrip )
297{
299 job.m_variant = wxS( "var-A" );
300
301 nlohmann::json j;
302 job.ToJson( j );
303
304 BOOST_CHECK_EQUAL( j.value( "variant", "" ), "var-A" );
305
306 JOB_EXPORT_PCB_3D loaded;
307 loaded.FromJson( j );
308
309 BOOST_CHECK( loaded.m_variant == wxS( "var-A" ) );
310}
311
312
313BOOST_AUTO_TEST_CASE( PcbPlotVariantRoundTrip )
314{
316 job.m_variant = wxS( "VarPlot" );
317
318 nlohmann::json j;
319 job.ToJson( j );
320
321 BOOST_CHECK_EQUAL( j.value( "variant", "" ), "VarPlot" );
322
324 loaded.FromJson( j );
325
326 BOOST_CHECK( loaded.m_variant == wxS( "VarPlot" ) );
327}
328
329
330BOOST_AUTO_TEST_CASE( PcbPngColorThemeRoundTrip )
331{
333 job.m_colorTheme = wxS( "_builtin_classic" );
334
335 nlohmann::json j;
336 job.ToJson( j );
337
338 BOOST_CHECK_EQUAL( j.value( "color_theme", "" ), "_builtin_classic" );
339
340 JOB_EXPORT_PCB_PNG loaded;
341 loaded.FromJson( j );
342
343 BOOST_CHECK( loaded.m_colorTheme == wxS( "_builtin_classic" ) );
344}
345
346
347BOOST_AUTO_TEST_CASE( PcbOdbVariantRoundTrip )
348{
350 job.m_variantNames = { wxS( "VarOdb" ) };
351
352 nlohmann::json j;
353 job.ToJson( j );
354
355 BOOST_CHECK_EQUAL( j.value( "variant", "" ), "VarOdb" );
356
357 JOB_EXPORT_PCB_ODB loaded;
358 loaded.FromJson( j );
359
360 BOOST_REQUIRE_EQUAL( loaded.m_variantNames.size(), 1u );
361 BOOST_CHECK( loaded.m_variantNames.front() == wxS( "VarOdb" ) );
362}
363
364
365BOOST_AUTO_TEST_CASE( PcbIpc2581VariantRoundTrip )
366{
368 job.m_variantNames = { wxS( "VarIpc" ) };
369
370 nlohmann::json j;
371 job.ToJson( j );
372
373 BOOST_CHECK_EQUAL( j.value( "variant", "" ), "VarIpc" );
374
376 loaded.FromJson( j );
377
378 BOOST_REQUIRE_EQUAL( loaded.m_variantNames.size(), 1u );
379 BOOST_CHECK( loaded.m_variantNames.front() == wxS( "VarIpc" ) );
380}
381
382
383BOOST_AUTO_TEST_CASE( Ipc2581ExplicitEmptySectionsRoundTrip )
384{
386 job.FromJson( nlohmann::json{ { "mode", "USERDEF" }, { "sections", "" }, { "custom_sections", true } } );
387
388 nlohmann::json saved;
389 job.ToJson( saved );
390 BOOST_CHECK( saved.value( "custom_sections", false ) );
391 BOOST_CHECK_EQUAL( saved.at( "sections" ).get<std::string>(), "" );
392
394 loaded.FromJson( saved );
395 nlohmann::json roundTrip;
396 loaded.ToJson( roundTrip );
397 BOOST_CHECK( roundTrip.value( "custom_sections", false ) );
398
400 legacy.FromJson( nlohmann::json{ { "sections", "" } } );
401 nlohmann::json legacyJson;
402 legacy.ToJson( legacyJson );
403 BOOST_CHECK( !legacyJson.value( "custom_sections", false ) );
404 BOOST_CHECK( !legacy.m_sections );
405
406 JOB_EXPORT_PCB_IPC2581 legacyNonempty;
407 legacyNonempty.FromJson( nlohmann::json{ { "sections", "K" } } );
408 BOOST_CHECK( legacyNonempty.m_sections );
409}
410
411
412BOOST_AUTO_TEST_CASE( PcbRenderVariantRoundTrip )
413{
414 JOB_PCB_RENDER job;
415 job.m_variant = wxS( "VarRender" );
416
417 nlohmann::json j;
418 job.ToJson( j );
419
420 BOOST_CHECK_EQUAL( j.value( "variant", "" ), "VarRender" );
421
422 JOB_PCB_RENDER loaded;
423 loaded.FromJson( j );
424
425 BOOST_CHECK( loaded.m_variant == wxS( "VarRender" ) );
426}
427
428
429BOOST_AUTO_TEST_CASE( SchNetlistVariantNamesRoundTrip )
430{
432 job.m_variantNames = { wxS( "var1" ), wxS( "var2" ) };
433
434 nlohmann::json j;
435 job.ToJson( j );
436
437 BOOST_REQUIRE( j.contains( "variant_names" ) );
438 BOOST_REQUIRE( j.at( "variant_names" ).is_array() );
439 BOOST_CHECK_EQUAL( j.at( "variant_names" ).size(), 2u );
440
442 loaded.FromJson( j );
443
444 BOOST_REQUIRE_EQUAL( loaded.m_variantNames.size(), 2u );
445 BOOST_CHECK( loaded.m_variantNames[0] == wxS( "var1" ) );
446 BOOST_CHECK( loaded.m_variantNames[1] == wxS( "var2" ) );
447}
448
449
450BOOST_AUTO_TEST_CASE( SchPlotVariantNamesRoundTrip )
451{
452 JOB_EXPORT_SCH_PLOT job( false );
453 job.m_variantNames = { wxS( "var1" ), wxS( "var2" ) };
454
455 nlohmann::json j;
456 job.ToJson( j );
457
458 BOOST_REQUIRE( j.contains( "variant_names" ) );
459 BOOST_REQUIRE( j.at( "variant_names" ).is_array() );
460 BOOST_CHECK_EQUAL( j.at( "variant_names" ).size(), 2u );
461
462 JOB_EXPORT_SCH_PLOT loaded( false );
463 loaded.FromJson( j );
464
465 BOOST_REQUIRE_EQUAL( loaded.m_variantNames.size(), 2u );
466 BOOST_CHECK( loaded.m_variantNames[0] == wxS( "var1" ) );
467 BOOST_CHECK( loaded.m_variantNames[1] == wxS( "var2" ) );
468}
469
470
void FromJson(const nlohmann::json &aJson) override
DATA_SET
Columns of the IPC-2581C function mode table, Table 4 p 80.
static std::string DataSetToken(DATA_SET aDataSet)
Lower case token that the job file and the CLI use for aDataSet Empty when it has none.
void ToJson(nlohmann::json &aJson) const override
std::optional< wxString > m_sections
Section key that replaces the optional sections of the data set Unset lets the data set select them a...
std::vector< wxString > m_variantNames
void FromJson(const nlohmann::json &aJson) override
VARIANT_PACKAGING m_variantPackaging
std::vector< ODB_LAYER_OVERRIDE > m_layerOverrides
void FromJson(const nlohmann::json &aJson) override
std::vector< wxString > m_variantNames
std::vector< wxString > m_variantNames
virtual void FromJson(const nlohmann::json &j)
Definition job.cpp:60
virtual void ToJson(nlohmann::json &j) const
Definition job.cpp:67
static bool empty(const wxTextEntryBase *aCtrl)
nlohmann::json json
Definition gerbview.cpp:50
@ UNDEFINED_LAYER
Definition layer_ids.h:57
@ F_Cu
Definition layer_ids.h:60
std::string GetTestDataRootDir()
wxString GetDefaultVariantName()
wxString ExpandVariantOutputPath(const wxString &aPath, const wxString &aVariantToken)
wxString GetVariantFileToken(const wxString &aVariantName)
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)
static void roundTrip(const DIFF_VALUE &aValue)
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_CASE(OdbVariantFileTokenKeepsNamesAndRemovesSeparators)