Also provide a utility function to get this path, and
a way to override at run time to quickly sub in alternative
data.
The test itself is still broken, as this plugin won't accept
a call to Load() without a KiWay.
Redesignate the eagle test as eeschema tests and build
more like the other unit tests.
Enable as a test in Ctest now that the test executes without
crashing.
The loading of the file with the hardocded part is still
not enabled, as this needs more infrastructure to support it.
Before Boost 1.64, there was no test logging function
for std::nullptr_t.
Add a logging struct to Boost to deal with this, and some
macros to assist in similar cases. These macros are bit
untidy-looking, but due to GCC bug #56480, we can't use
namespace aliasing to solve this. From Boost 1.64 onwards,
these namespaces are not needed at all.
Remove some code added to work around lack of nullptr printing
in the past.
These macros, and the nullptr printer, can be removed when
the Boost min version is 1.64 or greater.
Added checks to StrCmpNum() function in common/sting.cpp to prevent
iterating past the end of the sting. Also removed length of string
parameter since it did not seem to be used anywhere.
Fixes lp:1818157
https://bugs.launchpad.net/kicad/+bug/1818157
Add some tests of the filename splitting of WX_FILENAME objects.
Interestingly, the result of GetFuillPath on an empty path is
likely wrong as it will imply an absolute path from /. But this is
probably not a used code path. Document the current behaviour as passing
the test.
This unit tests covers the code reported by Coverity 183884 and 183894
(improper use of negative). The find_last_of can return "npos" (-1), but
it's stored as a size_t. This is correct according the WX docs,
and the substr() method it is passed to can handle npos too.
gal: pixel alignment for Cairo.
gal: pixel alignment for OpenGL
Cleanup of pixel alignment patches
gal/opengl: more pixel alignment patches:
- works on Retina displays now
- pixel alignment for circles
- correct 1-pixel strokes
- fixed unfinished 1-pixel line ends
GAL: Restore antialiasing options in Cairo
GAL: Fix arc drawing
Removes DrawArcSegment, which drew arcs whose edge was optionally
stroked (a feature that we did not use). Fixes Cairo arc drawing issue
where arcs were not visible in pcbnew.
gal: further cleanup
gal: removed unused shader parameter
When adding colors to length tuner, we depend on the window background
color, which can be set by the user, resulting in an unreadable text.
This uses the HSL conversion to detect which shade it should use for the
coloring.
Also adds test cases for round-trip HSL and HSV conversion
Fixes: lp:1814530
* https://bugs.launchpad.net/kicad/+bug/1814530
The using the "first available" numbering option, force an
artifical linear numbering scheme starting at '1'.
Start the pad name provider at the 0'th pad index.
Also adds a few related tests and adjusts tests affected by
this change to reflect that the offset still applies.
This can be expanded in future to be more general by skipping
pad (which would allow a custom start and numbering scheme
while still avoiding duplication), but for now,
this does what the UI says and avoids string changes in 5.1rc.
Fixes: lp:1814918
* https://bugs.launchpad.net/kicad/+bug/1814918
Fixes: lp:1814917
* https://bugs.launchpad.net/kicad/+bug/1814917
* Make LIB_TABLE_BASE::GetCount() return unsigned. This is more
consistent with the behaviour of STL containers (especially the
boost::ptr_vector this is really accessing). Sadly
wxGridTableBase() forces an int, so a cast is still required
at the WX interface.
* Make LIB_TABLE_BASE::At() return a reference. First, this is more
consistent with normal STL indexing operator[]'s, and secondly, it
allows an idiomatic const index method (so you can access const
LIB_TABLE_ROWs from a const LIB_TABLE_BASE).
The motivation is to allow use of this class and LIB_TABLE_ROW
in a test program, where the LIB_TABLE_BASE is const.
Some basic tests on LIB_TABLE and LIB_TABLE_ROW that demonstrate
the behaviour of fallbacks and various access methods.
Also add a few LIB_TABLE_BASE comments and changed some NULLs to
nullptr.
Libpolygon can provide its own includes via target_include_dirs PUBLIC.
This means any linking targets do not need to specifiy them manually.
As common requires polygon, the polygon dep is also now no longer
required downstream of libcommon, as it's transisitvely implied
by libcommon's target_link_libraries.
This resolves a circular dependency previously detected and also
simplifies CMakeLists.
The bitmap definitions (BITMAP_DEF and so on) do not
have any dependencies on other libs, including WX. This
means the bitmaps library can be isolated from the other
dependencies.
Common now depends on bitmaps, and libraries that depend
on common can pick it up from the common target_link_libraries,
as it is PUBLIC. This means a lot of targets no longer
need manual bitmap linkage.
This avoids a circular dependency that was previously reported
by static analysis.
Avoiding pulling in WX and other headers into the include
tree of each bitmap .cpp is a huge speed up (around 10x) in
compilation, and the generated static library is also 10x
smaller (20MB vs 200MB)
Add common as a link library to pnsrouter,connectivity.
THese library do still use common code (including bitmaps,
via base_screen.h) and this allows them to pick up the libcommon
includes correctly.
SEG collisions and distances are a fundamental part of SHAPE collision testing
and are therefore critical for DRC correctness.
Also a few Collinear tests.
This function was incorrectly processing refdeses like "U1000".
Change the algorithm to a simpler STL-compatible one and
update the tests.
Fixes: lp:1813669
* https://bugs.launchpad.net/kicad/+bug/1813669
This breaks the following functions out to a general-purposed refdes utils
header:
* MODULE::GetReferencePrefix()
* kicad_string.h RefDesStringCompare()
This acheives:
* Slimming of MODULE interface
* Placement of refdes code in common rather than pcbnew
** Testing of this code in qa_common
* Tighter and smaller includes for code that only needed refdes functions
Note: there are failing tests commited (as expected failures). These
are the cause of lp:1813669 and will be fixed as a follow-up commit.
This is not logic specific to MODULE. Breaking it out to
kicad_string.h acheives:
* Slimming of the MODULE interface
* Enables reuse of the function
* Enables testing of the function
Also add a test under qa_common for this function.
The current module cannot be queried for existing pads as we
add them (because we never commit, until we finish the whole array).
Instead, pre-gather the names and check as we add, skipping any existing
names.
Note: this will not prevent arrays becoming "mis-ordered", but there
is not a lot we can do to prevent all possible errors.
Fixes: 1808706
* https://bugs.launchpad.net/kicad/+bug/1808706
The same principle could be used to skip existing ref-des'es on PCBs.
The geometry and numbering logic is separate to the dialog, and
can be separated for clearer logic and better testability.
Moreover, refactor it to avoid any dependency on pcbnew
classes, so it can be move to common for potential re-use in
eeschema and friends in future.
Also convert all wxPoint logic in these classes to VECTOR2I and
fix some function visibilities.
Add some unit tests of the ARRAY_OPTIONS geometry and numbering.
Move into own include directory for clarity. Also allows qa_utils
to use its own private headers in qa/qa_utils without exposing them
through the target_include_directories directive.
This test assumed points on a edge are counted as colliding.
This is not true: points on an edge are NOT counted at inside
the poly_set.
THe test does still consider points on a *hole* edge as collisions.
The API to SHAPE_POLY_SET is unclear on if this is correct.
Several pcbnew_tools utilities read a file from the command line.
Instead of replicating this code, centralise the code in
qa_pcbnew_utils, which allows simpler reuse.
THe utilities are:
* polygon_triangulation
* polygon_generator
* drc_tool
pcb_parser keeps its own function, as that is the focus of the tool,
and its likely to have its own instrumention.
This also adds the ability to read from stdin for the above tools,
which means fuzz testers could theoretically work with them, and it
also can make life easier if you can pipe a board to the executable
directly.
The "refactor" element of qa_shape_poly_set_refactor has been
previously removed, so these tests are now just regular tests on
libcommon classes. These can therefore be moved to qa_common
and the qa_shape_poly_set_refactor unit test suit can finally be
totally removed.
This adds a simple unit test to qa_common to check coroutines
produce expected events in the right order.
This is an automated analogue to the user-facing tool in
qa/common_tools.
This program has been disabled for some time, but it's not
broken (even if the CMake was!).
Merging into the pcbnew_tools QA program reduces the CMake burden
and puts this tool in the same place as the others.
This means all the current Pcbnew utilities are all in a single
executable.
The tool is now run by:
$ qa/pcbnew_tools/qa_pcbnew_tools pcb_parser <same arguments as before>
Add a tool that allows a user to run DRC functions
on a given KiCad PCB file.
The first available functions are the courtyard functions.
Also move most of the utility program logic into qa_util for
better reusability.
Introduce the concept of a DRC_PROVIDER which allows
to separate the various DRC functions to their own
areas. This allows, amongst other things, a slimmer core
DRC class, and allows DRC functions to be separately testable.
The courtyard DRCs (overlap, missing and malformed)
are the first victims, so instrumentation can be added to this function.
Add some unit tests on this DRC function, as well a few re-usable PCB-based
utility functions in a library (qa_pcbnew_utils) that could be shared between
unit tests and other utilities.
The intention here is to make it possible to wrap up many of the
KiCad utility tools into a single executable. This reduces link times
as well as the duplication of CMake files needed to build very
similar tools.
This particular tool should be suitable for any code in common,
code in pcbnew and other end-executables probalby will need an
analagous version linked to the relevant kiface.
The first tool is the coroutine_example.cpp test case, which
can be useful when learning, debugging or porting the coroutine
infrastructure.
This reverts commit decc7ed888.
This compilation options (-fpermissive) is no longer needed,
as the code that caused the warnings on GCC <7 is no longer
present.
The reason this error was GCC bug #56480 [1], which disallowed
the following (valid, in C++11) syntax:
template<> struct namespace_a::namespace_b::a_struct<TYPE>
{...}
And instead insisted on:
namespace namespace_a {
namespace namespace_b {
template<> struct a_struct<TYPE>
{...}
}
}
[1]: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
An unhappy conjunction of GCC bug #56480 [1] and Boost having
different namespaces for the print_log_value make it quite
ugly to support this method.
For the limited purposes of the unit tests, a free function in
the unit_test_utils header (in the absence of any implementation
in the main libraries) will do, even if it is a little intrusive.
From Boost 1.64 onwards, the customisation point boost_test_print_type
is avaiable, and anyt print functions should be transitioned over to
that method when the minimum Boost version is 1.64 or higher.
[1] https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480
Test a few "centre-point-angle" cases and add some
generic geom code for testing vectors and boxes are within
tolerance (since rounding often creeps in).
Much of the arc-checking code will be useful to other
construction methods (e.g. point-point-point).
There are expected failures for the bbox code when
the arc passes though, but does not end on, a quadrant point
(0, 90, 180, 270). This is due to a defective
implementation of SHAPE_ARC::BBox() that does not take
into account the quadrant points. This will be fixed
as a follow-up.
Use the AddFileExtListToFilter() to also generate the
wildcard for "all files". This is because:
* Users can use AddFileExtListToFilter for the all files WC
with the same interface as for any other extensions.
* Users do not need to worry about wxGetTranslation, as the
_() is applied in the same way as the other *Wildcard() helpers,
and it is a function just like the others, so it is consistent
* There is a testable interface to document the expected result.
The test is added.
Varargs make it very hard to pass strings in flexibly
when they (and the number of them) are not known
at compile time.
For example, this allows up to now amalgamate the "single
ext" and "multiple ext" unit tests.
This adds a unit test for the recent AddFileExtListToFilter
to demonstrate how to use it and the expected output.
The unit tests are a bit clunky, as the vararg approach cannot
work winth strings passed at runtime.
It was added when refactoring the SHAPE_POLY_SET class, ande replace any use of CPolyLine class inside Kicad code.
the CPolyLine related code is now not used.
So this test nowadays makes no longer sense.
Also modify the linkage of kiface objects, as this is not
supported by older CMake versions.
This was accidentally removed with the reversion of the application
of the wrong patch (8f11a2133).
QA: fix object files
Some functions aren't defined on Boost < 1.59, which is
sadly inclusive of the Ubuntu LTSs.
Make some guards so you can still use these on the newer
Boosts with some useful fallback where possible.
Devolve the logic as to whether a pad should be numbered or not
to a pad utility function. Add a very simplistic test for this
function (demonstrating how to test BOARD_ITEMs in general).
Fixes: lp:1804787
* https://bugs.launchpad.net/kicad/+bug/1804787
The intention here is to make it possible to wrap up many of the
KiCad utility tools into a single executable. This reduces link times
as well as the duplication of CMake files needed to build very
similar tools.
This particular tool should be suitable for any code in common,
code in pcbnew and other end-executables probalby will need an
analagous version linked to the relevant kiface.
The first tool is the coroutine_example.cpp test case, which
can be useful when learning, debugging or porting the coroutine
infrastructure.
The reduces a little bit of WX dependency, and makes
the timing code a bit more type-safe.
Also adds a more testable interface for the accelerated
zoom controller.
This is done to avoid a big chunk of conditionally-compiled code
in the middle of the event function.
Also separates the zoom logic from the WX_VIEW_CONTROLS object
and isolates it in a separate class behind a clearer interface.
Add some simple tests for sane steps on GTK+3-sized scroll
steps.
Due to the implicit floor of the cast from double to unsigned char,
there was a small rounding error in COLOUR4D's WX conversion function.
This fixes the failing tests.
Also make the cast to unsigned char explicit.
This includes:
* Linkage against the Boost unit test libs
* Configuration of the Boost libs
* A place for common generics "extras" for unit test harnesses
including
* A simple way to allow "expected-failure" tests (without
breaking Boost < 1.58, e.g. Ubuntu LTS)
* Moving some simple numeric predicates from the geom tests
to the utils library.
Expand unit test docs to describe the expected failures macro.
Add a few COLOR4D tests, including one with expected failures due
to a pre-existing bug. This will be fixed in a follow-up commit.
Add some unit tests on TITLE_BLOCK
This commit also requires some mocks so the libcommon stuff
can work:
* Needs a Kiface() function to be linkable
* Needs some stuff from common to be build specially
* Needs to define itself as one of the unit-having programs
to appease the units defines.
If qa_utils is not explicitly declared with STATIC, the build
fails in environments where the BUILD_SHARED_LIBS CMake option is
present and set to "ON". An example of this is Fedora COPR.
This adds an io-benchmark case of the STRING_LINE_READER
class, which reads a file into a std::string, *then*
reads it line by line.
As expected, due to it all being in memory, this is very fast.
Also fixes an issue in io_benchmark where the input file
must be in the current dir.
This adds a test program which can be used to test the
parsing of a given KiCad PCB file. This interface is
useful for both manual or automated debugging of given
files, as well as providing an interface suitable for
fuzz-testing tools.
Also adds to the testing docs to detail how fuzzing can
be used.
Also moves some useful re-usable code from io-benchmark
to a new library qa_utils, which can contain code that
isn't need in the actual KiCad libs.
Previous test strings did not utilize extended table unicode, so some
cases slipped through testing. When initializing wxString, we need to
be careful to specify that we are initializing from a UTF-8 string
otherwise the system will utilize a locale-specific initialization.
CPolyLine::Chamfer returns a newly allocated object. The current
test of this doesn't take ownership, leading to memory leaks.
Use a std::unique_ptr to:
* Fix the leak, and
* Document the expected semantics of the interface in the test
Fixes coverity:183869
* Renames /qa/common to /qa/qa_utils, as it is not to do with /common
* Renames /qa/geometry to /qa/common
* Put existing geometry tests into a subdirectory of /qa/common, to
echo the layout of the main tree.
The intention is to provide a place to put tests of other libcommon
code in the /qa/common suite.
When editing the pcb, Ctrl-Click will highlight a net. This allows
de-highlight with the ESC/cancel action from the selection tool. Inside
the highlight tool, ESC reverts to the selection tool while keeping the
net highlighted.
Fixes: lp:1793842
* https://bugs.launchpad.net/kicad/+bug/1793842
This commit finishes the removal of OpenMP from the KiCad codebase.
Removed in this commit are the OpenMP calls in 3d-viewer and
qa/polygon_triangulation as well as all references in CMakeLists.txt
std::thread is used instead for multithreaded computation
OpenMP is not available for macos, so moving to a std::threads
implementation brings platforms into shared code.
This also reduces the OpenMP overhead when computing connectivity and
ratsnests.
Fixes: lp:1780130
* https://bugs.launchpad.net/kicad/+bug/1780130
These tests are fundamentally broken as they test two fillet
implementations against each other, but the two implementations
no longer have the same interface or meaning (one has a fixed
segment count, one has a fixed error).
This also allows the tests to run on Boost <1.59, which do not
provide the !-syntax for excluding tests. Ubuntu 16 uses
Boost 1.58, so this causes build failures.
Fixes: 1785377
https://bugs.launchpad.net/kicad/+bug/1785377
This is the first test for a generic test suite for geometric functions.
The tests run are for fillet corners of SHAPE_POLY_SETS.
Previously, SHAPE_POLY_SET::Fillet was tested against CPolyLine::Fillet
to ensure compatibility. However, thse two functions now have different
interfaces and are not directly comparable. Also, this depended on
CPolyLine::Fillet being correct, which was not tested.
Instead, test SHAPE_POLY_SET::Fillet using tests against geometric
constraints, independent of any other fillet implementation.
This test is not really concerned with generic geometric code testing,
but rather the correctness of a refactoring effort.
Rename it make this clearer, and also to make way for generic geometry tests.
* Refresh the view only when changes are made in the caller frame.
* Allows recreate a new instances when try to open the 3D view from a frame taht is not the initial caller
* Remove duplicate code in kicad frames.
John Beard
Michael Kavanagh
Wayne Stambaugh
Seth Hillbrand
jean-pierre charras
Tomasz Włostowski
Jeff Young
Thomas Pointhuber
Andrzej Wolski