v3 means that if it's used (even over a network) by somebody, they can request the code, versus GPLv2 (Wireshark license), which says if you distribute binaries of Wireshark or software based on it, you must provide the source. The difference is that you could theoretically provide a web interface to a GPLv2 project and not need to supply the source, but if you provide such an interface to GPLv3 software, you could receive a request for the code.
EDIT: I'm not entirely correct There are provisions for the network situation ("ASP (application service provider) loophole") I described, but I looks like it's not necessarily the default mode. See [0][1].
The GNU GPL v3 does not contain such a provision. However, a different license, the GNU AGPL v3, does. Your post is entirely incorrect regarding the GPLv3.
As Wikipedia notes, some drafts of the GPLv3 contained such a provision, but this did not make it into the final version.
This is because wssdl is still within the boundaries of the lua grammar: the file you provide is still lua, so you have to abide by its rule.
I experimented with a key/value approach on the syntax itself (something like `{ src_port = u16 }` or `{ src_port = 16 }`), which was nicer, but the problem was that, in lua, table literals are unordered. The current approach uses the method syntax (`a:b()`) as a nice workaround, but this mandates the use of parenthesis after the type and other specifiers. This is fine though since a lot of the provided types are parameterized (e.g. `bytes(n)` which takes a number of octets)
Man pages are their own thing -- although the end result could be the same with some aesthetic differences (man pages does not support colors per-se, though with a config you could style your titles or emphasis).
rst2ansi is a more generic document renderer, that may be used in another program to render document parts. It doesn't convert the document to an intermediate man page, nor specifically formats the document as, well, documentation.
The closest thing I think of given your example is how the --help flag in git displays the manpage instead of an option summary. Is that the sort of thing you have in mind?
I originally made this for an interactive index where you can query some document parts, and these parts are written in rst -- in essence, it's almost the same: rendering an arbitrary document into a string, that you may or may not manipulate later.
By default, if the test raises any signal or exits with anything other than 0, the test fails.
Otherwise, you can't (yet!) test if the code exits with a specific value nor simply redirect input/output, but I'll be sure to take these suggestions into account, thanks!
I'm having a little trouble imagining a situation where unit tests for a C codebase are appropriate that would be stymied by having to write the tests in C++. (Maybe relying on struct layout?)
Because C hasn't been a subset of C++ since C99, there are plenty of case where trying to do C in C++ is awkward or just not possible with standard C++:
First, you'd have to wrap your header inclusions in `extern "C"` to disable mangling, then you would have to make sure you static_cast all your pointers where normally `void*` conversions would have done its job.
Furthermore, all interfaces relying on designated initializers and compound literals are broken unless you decide to compile in nonstandard GNU C++.
And there are more incompatibilities, such as using `static` or `const` in array parameter declarations or using VLA in macros which are not recognized by C++.
It's all about using the right tool for the right job, ultimately.
Actually, I didn't know about it until now! The project uses a similar approach to mine, by parsing the DIE tree produced by dwarf, which means that it won't work if you're not compiling with -g.
It also uses some very platform specific stuff, so windows & os x are out, too.
Developer here. If you have any suggestion/criticism on the project, I'd be happy to know.
What this brings on the table compared to other frameworks is a very simple way to write tests, while giving the programmer enough liberty to do what he wants.
Criterion achieves that by implementing a xUnit structure with automatic test registration using a declarative syntax -- which means you can be very expressive with the way you declare your tests and suite in a few lines of code. The rest is handled by criterion itself and the default main it provides.
This is nothing new though: all wireshark plugins must be GPL, since the API itself they rely on is GPL.