Return the identifier of the union as a string.

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

Add a flag to the C compiler invocation. # Examples ```no_run use std::env; use std::path::PathBuf; use ctest::TestGenerator; let mut cfg = TestGe

Configures whether the tests for a constant's value are generated. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(

Set a `-D` flag for the C compiler being called. This can be used to define various global variables to configure how header files are included or wh

Configures whether all tests for a typedef are skipped or not. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); c

Configures whether tests for a function definition are generated. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new()

Create a pointer to a type, specifying constness of the pointer.

Configures how a Rust struct type is translated to a C struct type. # Examples This method can be used to remove the `struct` keyword from types in

Configures whether the tests for a struct are emitted. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); cfg.skip_

Create a named type with a certain constness.

Create an array of some type and optional length.

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

Add a header to be included as part of the generated C file. The generated C test will be compiled by a C compiler, and this can be used to ensure th

Configures whether all tests for a struct field are skipped or not. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new

Configures how a Rust struct field is translated to a C struct field. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::n

Configures whether the tests for a union are emitted. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); cfg.skip_u

Returns the equivalent C/Cpp type of the Rust item.

Set a `--cfg` option with which to expand the Rust FFI crate. By default the Rust code is run through expansion to determine what C APIs are exposed

Translate a Rust type into its equivalent C type.

Add a path to the C compiler header lookup path. This is useful for if the C library is installed to a nonstandard location to ensure that compiling

Configures how a Rust type is translated to a C type. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); cfg.rename

Create a function pointer with the given arguments and return type. By default the function pointer is mutable, with `volatile` and `restrict` keywor

Configures whether the tests for a static definition are generated. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new

Configures whether tests for the type of a field is skipped or not. The closure is given a Rust struct as well as a field within that struct. A flag

Returns the equivalent C/Cpp identifier of the Rust item.

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

Indicate that a type alias is actually a C enum. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new(); cfg.alias_is_c_e

Collect all errors into a single error, reporting them if any.

Determine whether an item is visible to other crates. This function assumes that if the visibility is restricted then it is not meant to be accessed.

Configures whether the ABI roundtrip tests for a type are emitted. The closure is passed the name of a Rust type and returns whether the tests are ge

Create a test generator configured to useful settings. The files will be generated in a unique temporary directory that gets deleted when it goes out

Generate the Rust and C testing files. Returns the path to the generated file.

Configures how a Rust union type is translated to a C union type. # Examples This method can be used to remove the `union` keyword from types in the

Configures whether a type's signededness is tested or not. The closure is given the name of a Rust type, and returns whether the type should be teste

Indicate that a struct field should be marked `volatile`. # Examples ```no_run use ctest::{TestGenerator, VolatileItemKind}; let mut cfg = TestGene

Generate test files for the given header and crate path and compare with pregenerated test files. If LIBC_BLESS is set, it will overwrite the pregene

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

We do this a surprising number of times.

Return a list of all structs found.

Translate a Rust primitive type into its C equivalent.

Return a list of all unions found.

Return a list of all type aliases found.

Create a pointer to a type, specifying the qualifiers of the pointer.

Create a C declaration for a type. Given a type `cty` (e.g. array of pointers to int) and a `name` (e.g. "foo"), turn `name` into a valid declaration

Check that the value returned from the Rust and C side in a certain test is equivalent. Internally it will remember which checks failed and how many

Collect fields in a syn grammar into ctest's equivalent structure.

Return the name of the function to be linked C side with.

Configures the output directory of the generated Rust and C code. # Examples ```no_run use ctest::TestGenerator; let mut cfg = TestGenerator::new()

Construct a CTy and modify the constness of the inner type. Basically, `syn` always gives us the `constness` of the inner type of a pointer. However

Maps Rust identifiers or types to C counterparts, or defaults to the original name.

Return the identifier escaped for Rust source output when needed.

Configures whether tests for a function pointer's value are generated. The closure is given a Rust FFI function and returns whether the test will be

Assert whether the contents of two files match. If the contents do not match and LIBC_BLESS is set, overwrite the test file with the content of the g

Create a command that starts in the `target/debug` or `target/release` directory.