Age | Commit message (Collapse) | Author | Files | Lines |
|
There hasn't been any such package since the original addition of a
gtk3 version of wxgtk... back in 2017. The "new" wxgtk2 package provided
a virtual provides ever since, so people still depending on "wxgtk"
would get the old gtk2 version. This virtual provides got dropped today,
resulting in the package being uninstallable.
Resolve the provides to its canonical name, thus making it installable
again.
|
|
they're really not public methods, they'r only meant to be called from
the initializer. Let's mark them as such.
|
|
This function returns both the name and the value, but we never actually
use the name, just the value. Also make this module private. We really
want to keep all environment variable reading in the Environment class
so it's done once up front. This should help with that goal.
|
|
This is only used in environment, so it should live there too.
|
|
This both moves the env reading to configuration time, which is useful,
and also simplifies the implementation of the boost dependency. The
simplification comes from being able to delete basically duplicated code
since the values will be in the Properties if they exist at all.
|
|
This means that all the env lookups are done once, at initial configure
time. This has all of the expected advantages.
|
|
These really aren't pivotal to that class, and they're used outside of
it. In a follow up patch they're not going to be used inside it at all.
|
|
This has a bunch of nice features. It obviously centralizes everything,
which is nice. It also means that env is only re-read at `meson --wipe`,
not `meson --reconfigure`. And it's going to allow more cleanups.
|
|
|
|
This is PEP8 convention for a const variable. Also, make the type
Mapping, which doesn't have mutation methods. This means mypy will warn
us if someone tries to change this.
|
|
We already read this in, don't read it again. Just rely on the value we
have stored.
|
|
This causes the variable to be read up front and stored, rather than be
re-read on each invocation of meson.
This does have two slight behavioral changes. First is the obvious one
that changing the variable between `meson --reconfigure` invocations has
no effect. This is the way PKG_CONFIG_PATH already works. The second
change is that CMAKE_PREFIX_PATH the env var is no longer appended to
the values set in the machine file or on the command line, and is
instead replaced by them. CMAKE_PREFIX_PATH is the only env var in meson
that works this way, every other one is replaced not appended, so while
this is a behavioral change, I also think its a bug fix.
|
|
Some change in this series causes mypy to notice that this isn't
annotated, and it makes a wrong assumption.
|
|
there are a couple of places importing it from envconfig, which is not
correct. It's defined in mesonlib, and then imported into envconfig.
|
|
it generally uses the ld style linkers with msys2 and link.exe style
linkers otherwise, but anything's possible.
|
|
It requires at least one option argument, and the one that provides
"basic information" about the project is --projectinfo, so let's use
that to demo the command.
Fixes #8182
|
|
|
|
|
|
mtest: asynchronous TAP parsing, improved progress report
|
|
(#8154)
* doc: fix hotdoc misuse for dynamically generated content
hotdoc has a native include feature for including files inline. Use this
to generate one file for each dynamically generated code block, and
include that file in Commands.md; see:
https://hotdoc.github.io/syntax-extensions.html#smart-file-inclusion-syntax
This permits us to move back to using the in-tree version of the hotdoc
*.md sources, thus fixing the incorrect inclusion of "builddir/" in the
"Edit on github" links which resulted from using copies as the source.
Fixes #8061
* doc: call the dummy file a "stamp" as it is a better known term
|
|
|
|
Python3 in Cygwin is now Python 3.8
|
|
The parentheses look ugly in the progress report. To keep it aligned
with the test outcomes, remove them from the outcomes as well.
|
|
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
|
|
Compute all options in advance so that we can compute the maximum
timeout.
|
|
This adds a point where to call the progress report flush() method.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
This will be useful when printing the progress report.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
Allow leaving extra space in the left column, as well as customizing parts of
the printed line.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
This correctly formats tests with CJK names or, well, emoji. It is not perfect
(for example it does not correctly format emoji that are variations of 1-wide
characters), but it is as good as most terminal emulators.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
Instead of slurping in the entire stream, build the TestResult along
the way. This allows reporting the results of TAP and Rust subtests as
they come in, either as part of the progress report or (in the future)
as individual lines of the output.
|
|
Make the code look like the TAP parser. This simplifies the introduction of
asynchronous parsing.
|
|
Instead of creating temporary files, get the StreamReaders from
_run_subprocess's returned object. Through asyncio magic, their
contents will be read as it becomes ready and then returned when
the StreamReader.read future is awaited.
Because of this change, the stdout and stderr can be easily
preserved when TestSubprocess returns an additional_error.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
We would like SingleTestRunner to run code before waiting on the process,
for example starting tasks to read stdout and stderr.
Return a new object that is able to complete _run_subprocess's task.
In the next patch, SingleTestRunner will also use the object to get hold
of the stdout and stderr StreamReaders.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
This is common to all protocols, place the code in a single
place.
|
|
Put them in the same order as complete_*.
|
|
Include the names from the TAP output and the SKIP/TODO explanations
if present. Omit the classname attribute, it is optional.
In order to enable this, TestRun.results becomes a list of TAPParser.Test
objects. If in the future there are other kinds of subtest results a
new class can be introduced, but for now it is enough.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
Omit the classname attribute, as it is optional, and add the duration.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
For now this is just a refactoring that simplifies the next patch. However,
it will also come in handy when we will make the parsing asynchronous, because
it will make it possible to access subtest results while the test runs.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
It is cleaner than collections.namedtuple. It also catches that "count()" is
a method on tuple, so rename the field to num_tests.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
Pass the StringIO object to the parse method instead, because
there will be no T.Iterator[str] to use in the asynchronous
case.
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
This is the first step towards asynchronous parsing of the TAP output.
We will need to call the same code from both a "for" loop (for unit
tests) and an "async for" loop (for mtest itself). Because the same
function cannot be both a generator and an asynchronous generator, we
need to build both on a common core. This commit therefore introduces
a parse_line function that "parse" can call in a loop. All the local
variables of TAPParser.parse move into "self".
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
|
|
Add a rust module
|
|
|
|
Like other language specific modules this module is module for holding
rust specific helpers. This commit adds a test() function, which
simplifies using rust's internal unittest mechanism.
Rust tests are generally placed in the same code files as they are
testing, in contrast to languages like C/C++ and python which generally
place the tests in separate translation units. For meson this is
somewhat problematic from a repetition point of view, as the only
changes are generally adding --test, and possibly some dependencies.
The rustmod.test() method provides a mechanism to remove the repatition:
it takes a rust target, copies it, and then addes the `--test` option,
then creates a Test() target with the `rust` protocol. You can pass
additional dependencies via the `dependencies` keyword. This all makes
for a nice, DRY, test definition.
|
|
|
|
For modules to make use of, as they're not allowed to modify the Build
instance directly.
|
|
|
|
Rust has it's own built in unit test format, which is invoked by
compiling a rust executable with the `--test` flag to rustc. The tests
are then run by simply invoking that binary. They output a custom test
format, which this patch adds parsing support for. This means that we
can report each subtest in the junit we generate correctly, which should
be helpful for orchestration systems like gitlab and jenkins which can
parse junit XML.
|
|
for non tap tests we want to associate names with the tests, to that end
store them as a dict. For TAP tests, we'll store the "name" as an
integer string that coresponds to the order that the tests were run in.
|