Update to glib 0.14

An intimidating spam of compiler errors at the start, but the
biggest was handling the new convention of `ostree_sys::` => `ffi::`.

This will require a semver bump of course.

rust-bindings/rust/sys/tests/abi.rs

@@ -1,18 +1,16 @@
 // This file was generated by gir (https://github.com/gtk-rs/gir)
-// from gir-files (https://github.com/gtk-rs/gir-files)
+// from gir-files
 // DO NOT EDIT
 
-extern crate ostree_sys;
-extern crate shell_words;
-extern crate tempfile;
+use ostree_sys::*;
 use std::env;
 use std::error::Error;
-use std::path::Path;
+use std::ffi::OsString;
 use std::mem::{align_of, size_of};
+use std::path::Path;
 use std::process::Command;
 use std::str;
 use tempfile::Builder;
-use ostree_sys::*;
 
 static PACKAGES: &[&str] = &["ostree-1"];
 
@@ -22,23 +20,17 @@ struct Compiler {
 }
 
 impl Compiler {
-    pub fn new() -> Result<Compiler, Box<dyn Error>> {
+    pub fn new() -> Result<Self, Box<dyn Error>> {
         let mut args = get_var("CC", "cc")?;
         args.push("-Wno-deprecated-declarations".to_owned());
+        // For _Generic
+        args.push("-std=c11".to_owned());
         // For %z support in printf when using MinGW.
         args.push("-D__USE_MINGW_ANSI_STDIO".to_owned());
         args.extend(get_var("CFLAGS", "")?);
         args.extend(get_var("CPPFLAGS", "")?);
         args.extend(pkg_config_cflags(PACKAGES)?);
-        Ok(Compiler { args })
-    }
-
-    pub fn define<'a, V: Into<Option<&'a str>>>(&mut self, var: &str, val: V) {
-        let arg = match val.into() {
-            None => format!("-D{}", var),
-            Some(val) => format!("-D{}={}", var, val),
-        };
-        self.args.push(arg);
+        Ok(Self { args })
     }
 
     pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box<dyn Error>> {
@@ -48,8 +40,7 @@ impl Compiler {
         cmd.arg(out);
         let status = cmd.spawn()?.wait()?;
         if !status.success() {
-            return Err(format!("compilation command {:?} failed, {}",
-                               &cmd, status).into());
+            return Err(format!("compilation command {:?} failed, {}", &cmd, status).into());
         }
         Ok(())
     }
@@ -73,19 +64,18 @@ fn pkg_config_cflags(packages: &[&str]) -> Result<Vec<String>, Box<dyn Error>> {
     if packages.is_empty() {
         return Ok(Vec::new());
     }
-    let mut cmd = Command::new("pkg-config");
+    let pkg_config = env::var_os("PKG_CONFIG").unwrap_or_else(|| OsString::from("pkg-config"));
+    let mut cmd = Command::new(pkg_config);
     cmd.arg("--cflags");
     cmd.args(packages);
     let out = cmd.output()?;
     if !out.status.success() {
-        return Err(format!("command {:?} returned {}",
-                           &cmd, out.status).into());
+        return Err(format!("command {:?} returned {}", &cmd, out.status).into());
     }
     let stdout = str::from_utf8(&out.stdout)?;
     Ok(shell_words::split(stdout.trim())?)
 }
 
-
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 struct Layout {
     size: usize,
@@ -98,8 +88,6 @@ struct Results {
     passed: usize,
     /// Total number of failed tests (including those that failed to compile).
     failed: usize,
-    /// Number of tests that failed to compile.
-    failed_to_compile: usize,
 }
 
 impl Results {
@@ -109,16 +97,8 @@ impl Results {
     fn record_failed(&mut self) {
         self.failed += 1;
     }
-    fn record_failed_to_compile(&mut self) {
-        self.failed += 1;
-        self.failed_to_compile += 1;
-    }
     fn summary(&self) -> String {
-        format!(
-            "{} passed; {} failed (compilation errors: {})",
-            self.passed,
-            self.failed,
-            self.failed_to_compile)
+        format!("{} passed; {} failed", self.passed, self.failed)
     }
     fn expect_total_success(&self) {
         if self.failed == 0 {
@@ -131,166 +111,469 @@ impl Results {
 
 #[test]
 fn cross_validate_constants_with_c() {
-    let tmpdir = Builder::new().prefix("abi").tempdir().expect("temporary directory");
-    let cc = Compiler::new().expect("configured compiler");
+    let mut c_constants: Vec<(String, String)> = Vec::new();
 
-    assert_eq!("1",
-               get_c_value(tmpdir.path(), &cc, "1").expect("C constant"),
-               "failed to obtain correct constant value for 1");
-
-    let mut results : Results = Default::default();
-    for (i, &(name, rust_value)) in RUST_CONSTANTS.iter().enumerate() {
-        match get_c_value(tmpdir.path(), &cc, name) {
-            Err(e) => {
-                results.record_failed_to_compile();
-                eprintln!("{}", e);
-            },
-            Ok(ref c_value) => {
-                if rust_value == c_value {
-                    results.record_passed();
-                } else {
-                    results.record_failed();
-                    eprintln!("Constant value mismatch for {}\nRust: {:?}\nC:    {:?}",
-                              name, rust_value, c_value);
-                }
-            }
-        };
-        if (i + 1) % 25 == 0 {
-            println!("constants ... {}", results.summary());
-        }
+    for l in get_c_output("constant").unwrap().lines() {
+        let mut words = l.trim().split(';');
+        let name = words.next().expect("Failed to parse name").to_owned();
+        let value = words
+            .next()
+            .and_then(|s| s.parse().ok())
+            .expect("Failed to parse value");
+        c_constants.push((name, value));
     }
+
+    let mut results = Results::default();
+
+    for ((rust_name, rust_value), (c_name, c_value)) in
+        RUST_CONSTANTS.iter().zip(c_constants.iter())
+    {
+        if rust_name != c_name {
+            results.record_failed();
+            eprintln!("Name mismatch:\nRust: {:?}\nC:    {:?}", rust_name, c_name,);
+            continue;
+        }
+
+        if rust_value != c_value {
+            results.record_failed();
+            eprintln!(
+                "Constant value mismatch for {}\nRust: {:?}\nC:    {:?}",
+                rust_name, rust_value, &c_value
+            );
+            continue;
+        }
+
+        results.record_passed();
+    }
+
     results.expect_total_success();
 }
 
 #[test]
 fn cross_validate_layout_with_c() {
-    let tmpdir = Builder::new().prefix("abi").tempdir().expect("temporary directory");
-    let cc = Compiler::new().expect("configured compiler");
+    let mut c_layouts = Vec::new();
 
-    assert_eq!(Layout {size: 1, alignment: 1},
-               get_c_layout(tmpdir.path(), &cc, "char").expect("C layout"),
-               "failed to obtain correct layout for char type");
-
-    let mut results : Results = Default::default();
-    for (i, &(name, rust_layout)) in RUST_LAYOUTS.iter().enumerate() {
-        match get_c_layout(tmpdir.path(), &cc, name) {
-            Err(e) => {
-                results.record_failed_to_compile();
-                eprintln!("{}", e);
-            },
-            Ok(c_layout) => {
-                if rust_layout == c_layout {
-                    results.record_passed();
-                } else {
-                    results.record_failed();
-                    eprintln!("Layout mismatch for {}\nRust: {:?}\nC:    {:?}",
-                              name, rust_layout, &c_layout);
-                }
-            }
-        };
-        if (i + 1) % 25 == 0 {
-            println!("layout    ... {}", results.summary());
-        }
+    for l in get_c_output("layout").unwrap().lines() {
+        let mut words = l.trim().split(';');
+        let name = words.next().expect("Failed to parse name").to_owned();
+        let size = words
+            .next()
+            .and_then(|s| s.parse().ok())
+            .expect("Failed to parse size");
+        let alignment = words
+            .next()
+            .and_then(|s| s.parse().ok())
+            .expect("Failed to parse alignment");
+        c_layouts.push((name, Layout { size, alignment }));
     }
+
+    let mut results = Results::default();
+
+    for ((rust_name, rust_layout), (c_name, c_layout)) in RUST_LAYOUTS.iter().zip(c_layouts.iter())
+    {
+        if rust_name != c_name {
+            results.record_failed();
+            eprintln!("Name mismatch:\nRust: {:?}\nC:    {:?}", rust_name, c_name,);
+            continue;
+        }
+
+        if rust_layout != c_layout {
+            results.record_failed();
+            eprintln!(
+                "Layout mismatch for {}\nRust: {:?}\nC:    {:?}",
+                rust_name, rust_layout, &c_layout
+            );
+            continue;
+        }
+
+        results.record_passed();
+    }
+
     results.expect_total_success();
 }
 
-fn get_c_layout(dir: &Path, cc: &Compiler, name: &str) -> Result<Layout, Box<dyn Error>> {
-    let exe = dir.join("layout");
-    let mut cc = cc.clone();
-    cc.define("ABI_TYPE_NAME", name);
-    cc.compile(Path::new("tests/layout.c"), &exe)?;
+fn get_c_output(name: &str) -> Result<String, Box<dyn Error>> {
+    let tmpdir = Builder::new().prefix("abi").tempdir()?;
+    let exe = tmpdir.path().join(name);
+    let c_file = Path::new("tests").join(name).with_extension("c");
+
+    let cc = Compiler::new().expect("configured compiler");
+    cc.compile(&c_file, &exe)?;
 
     let mut abi_cmd = Command::new(exe);
     let output = abi_cmd.output()?;
     if !output.status.success() {
-        return Err(format!("command {:?} failed, {:?}",
-                           &abi_cmd, &output).into());
+        return Err(format!("command {:?} failed, {:?}", &abi_cmd, &output).into());
     }
 
-    let stdout = str::from_utf8(&output.stdout)?;
-    let mut words = stdout.trim().split_whitespace();
-    let size = words.next().unwrap().parse().unwrap();
-    let alignment = words.next().unwrap().parse().unwrap();
-    Ok(Layout {size, alignment})
-}
-
-fn get_c_value(dir: &Path, cc: &Compiler, name: &str) -> Result<String, Box<dyn Error>> {
-    let exe = dir.join("constant");
-    let mut cc = cc.clone();
-    cc.define("ABI_CONSTANT_NAME", name);
-    cc.compile(Path::new("tests/constant.c"), &exe)?;
-
-    let mut abi_cmd = Command::new(exe);
-    let output = abi_cmd.output()?;
-    if !output.status.success() {
-        return Err(format!("command {:?} failed, {:?}",
-                           &abi_cmd, &output).into());
-    }
-
-    let output = str::from_utf8(&output.stdout)?.trim();
-    if !output.starts_with("###gir test###") ||
-       !output.ends_with("###gir test###") {
-        return Err(format!("command {:?} return invalid output, {:?}",
-                           &abi_cmd, &output).into());
-    }
-
-    Ok(String::from(&output[14..(output.len() - 14)]))
+    Ok(String::from_utf8(output.stdout)?)
 }
 
 const RUST_LAYOUTS: &[(&str, Layout)] = &[
-    ("OstreeAsyncProgressClass", Layout {size: size_of::<OstreeAsyncProgressClass>(), alignment: align_of::<OstreeAsyncProgressClass>()}),
-    ("OstreeChecksumFlags", Layout {size: size_of::<OstreeChecksumFlags>(), alignment: align_of::<OstreeChecksumFlags>()}),
-    ("OstreeCollectionRef", Layout {size: size_of::<OstreeCollectionRef>(), alignment: align_of::<OstreeCollectionRef>()}),
-    ("OstreeCollectionRefv", Layout {size: size_of::<OstreeCollectionRefv>(), alignment: align_of::<OstreeCollectionRefv>()}),
-    ("OstreeCommitSizesEntry", Layout {size: size_of::<OstreeCommitSizesEntry>(), alignment: align_of::<OstreeCommitSizesEntry>()}),
-    ("OstreeContentWriterClass", Layout {size: size_of::<OstreeContentWriterClass>(), alignment: align_of::<OstreeContentWriterClass>()}),
-    ("OstreeDeploymentUnlockedState", Layout {size: size_of::<OstreeDeploymentUnlockedState>(), alignment: align_of::<OstreeDeploymentUnlockedState>()}),
-    ("OstreeDiffDirsOptions", Layout {size: size_of::<OstreeDiffDirsOptions>(), alignment: align_of::<OstreeDiffDirsOptions>()}),
-    ("OstreeDiffFlags", Layout {size: size_of::<OstreeDiffFlags>(), alignment: align_of::<OstreeDiffFlags>()}),
-    ("OstreeDiffItem", Layout {size: size_of::<OstreeDiffItem>(), alignment: align_of::<OstreeDiffItem>()}),
-    ("OstreeGpgError", Layout {size: size_of::<OstreeGpgError>(), alignment: align_of::<OstreeGpgError>()}),
-    ("OstreeGpgSignatureAttr", Layout {size: size_of::<OstreeGpgSignatureAttr>(), alignment: align_of::<OstreeGpgSignatureAttr>()}),
-    ("OstreeGpgSignatureFormatFlags", Layout {size: size_of::<OstreeGpgSignatureFormatFlags>(), alignment: align_of::<OstreeGpgSignatureFormatFlags>()}),
-    ("OstreeMutableTreeClass", Layout {size: size_of::<OstreeMutableTreeClass>(), alignment: align_of::<OstreeMutableTreeClass>()}),
-    ("OstreeMutableTreeIter", Layout {size: size_of::<OstreeMutableTreeIter>(), alignment: align_of::<OstreeMutableTreeIter>()}),
-    ("OstreeObjectType", Layout {size: size_of::<OstreeObjectType>(), alignment: align_of::<OstreeObjectType>()}),
-    ("OstreeRepoCheckoutAtOptions", Layout {size: size_of::<OstreeRepoCheckoutAtOptions>(), alignment: align_of::<OstreeRepoCheckoutAtOptions>()}),
-    ("OstreeRepoCheckoutFilterResult", Layout {size: size_of::<OstreeRepoCheckoutFilterResult>(), alignment: align_of::<OstreeRepoCheckoutFilterResult>()}),
-    ("OstreeRepoCheckoutMode", Layout {size: size_of::<OstreeRepoCheckoutMode>(), alignment: align_of::<OstreeRepoCheckoutMode>()}),
-    ("OstreeRepoCheckoutOverwriteMode", Layout {size: size_of::<OstreeRepoCheckoutOverwriteMode>(), alignment: align_of::<OstreeRepoCheckoutOverwriteMode>()}),
-    ("OstreeRepoCommitFilterResult", Layout {size: size_of::<OstreeRepoCommitFilterResult>(), alignment: align_of::<OstreeRepoCommitFilterResult>()}),
-    ("OstreeRepoCommitIterResult", Layout {size: size_of::<OstreeRepoCommitIterResult>(), alignment: align_of::<OstreeRepoCommitIterResult>()}),
-    ("OstreeRepoCommitModifierFlags", Layout {size: size_of::<OstreeRepoCommitModifierFlags>(), alignment: align_of::<OstreeRepoCommitModifierFlags>()}),
-    ("OstreeRepoCommitState", Layout {size: size_of::<OstreeRepoCommitState>(), alignment: align_of::<OstreeRepoCommitState>()}),
-    ("OstreeRepoCommitTraverseFlags", Layout {size: size_of::<OstreeRepoCommitTraverseFlags>(), alignment: align_of::<OstreeRepoCommitTraverseFlags>()}),
-    ("OstreeRepoCommitTraverseIter", Layout {size: size_of::<OstreeRepoCommitTraverseIter>(), alignment: align_of::<OstreeRepoCommitTraverseIter>()}),
-    ("OstreeRepoFileClass", Layout {size: size_of::<OstreeRepoFileClass>(), alignment: align_of::<OstreeRepoFileClass>()}),
-    ("OstreeRepoFinderAvahiClass", Layout {size: size_of::<OstreeRepoFinderAvahiClass>(), alignment: align_of::<OstreeRepoFinderAvahiClass>()}),
-    ("OstreeRepoFinderConfigClass", Layout {size: size_of::<OstreeRepoFinderConfigClass>(), alignment: align_of::<OstreeRepoFinderConfigClass>()}),
-    ("OstreeRepoFinderInterface", Layout {size: size_of::<OstreeRepoFinderInterface>(), alignment: align_of::<OstreeRepoFinderInterface>()}),
-    ("OstreeRepoFinderMountClass", Layout {size: size_of::<OstreeRepoFinderMountClass>(), alignment: align_of::<OstreeRepoFinderMountClass>()}),
-    ("OstreeRepoFinderOverrideClass", Layout {size: size_of::<OstreeRepoFinderOverrideClass>(), alignment: align_of::<OstreeRepoFinderOverrideClass>()}),
-    ("OstreeRepoFinderResult", Layout {size: size_of::<OstreeRepoFinderResult>(), alignment: align_of::<OstreeRepoFinderResult>()}),
-    ("OstreeRepoFinderResultv", Layout {size: size_of::<OstreeRepoFinderResultv>(), alignment: align_of::<OstreeRepoFinderResultv>()}),
-    ("OstreeRepoListObjectsFlags", Layout {size: size_of::<OstreeRepoListObjectsFlags>(), alignment: align_of::<OstreeRepoListObjectsFlags>()}),
-    ("OstreeRepoListRefsExtFlags", Layout {size: size_of::<OstreeRepoListRefsExtFlags>(), alignment: align_of::<OstreeRepoListRefsExtFlags>()}),
-    ("OstreeRepoMode", Layout {size: size_of::<OstreeRepoMode>(), alignment: align_of::<OstreeRepoMode>()}),
-    ("OstreeRepoPruneFlags", Layout {size: size_of::<OstreeRepoPruneFlags>(), alignment: align_of::<OstreeRepoPruneFlags>()}),
-    ("OstreeRepoPruneOptions", Layout {size: size_of::<OstreeRepoPruneOptions>(), alignment: align_of::<OstreeRepoPruneOptions>()}),
-    ("OstreeRepoPullFlags", Layout {size: size_of::<OstreeRepoPullFlags>(), alignment: align_of::<OstreeRepoPullFlags>()}),
-    ("OstreeRepoRemoteChange", Layout {size: size_of::<OstreeRepoRemoteChange>(), alignment: align_of::<OstreeRepoRemoteChange>()}),
-    ("OstreeRepoResolveRevExtFlags", Layout {size: size_of::<OstreeRepoResolveRevExtFlags>(), alignment: align_of::<OstreeRepoResolveRevExtFlags>()}),
-    ("OstreeRepoTransactionStats", Layout {size: size_of::<OstreeRepoTransactionStats>(), alignment: align_of::<OstreeRepoTransactionStats>()}),
-    ("OstreeSePolicyRestoreconFlags", Layout {size: size_of::<OstreeSePolicyRestoreconFlags>(), alignment: align_of::<OstreeSePolicyRestoreconFlags>()}),
-    ("OstreeSignInterface", Layout {size: size_of::<OstreeSignInterface>(), alignment: align_of::<OstreeSignInterface>()}),
-    ("OstreeStaticDeltaGenerateOpt", Layout {size: size_of::<OstreeStaticDeltaGenerateOpt>(), alignment: align_of::<OstreeStaticDeltaGenerateOpt>()}),
-    ("OstreeStaticDeltaIndexFlags", Layout {size: size_of::<OstreeStaticDeltaIndexFlags>(), alignment: align_of::<OstreeStaticDeltaIndexFlags>()}),
-    ("OstreeSysrootDeployTreeOpts", Layout {size: size_of::<OstreeSysrootDeployTreeOpts>(), alignment: align_of::<OstreeSysrootDeployTreeOpts>()}),
-    ("OstreeSysrootSimpleWriteDeploymentFlags", Layout {size: size_of::<OstreeSysrootSimpleWriteDeploymentFlags>(), alignment: align_of::<OstreeSysrootSimpleWriteDeploymentFlags>()}),
-    ("OstreeSysrootUpgraderFlags", Layout {size: size_of::<OstreeSysrootUpgraderFlags>(), alignment: align_of::<OstreeSysrootUpgraderFlags>()}),
-    ("OstreeSysrootUpgraderPullFlags", Layout {size: size_of::<OstreeSysrootUpgraderPullFlags>(), alignment: align_of::<OstreeSysrootUpgraderPullFlags>()}),
-    ("OstreeSysrootWriteDeploymentsOpts", Layout {size: size_of::<OstreeSysrootWriteDeploymentsOpts>(), alignment: align_of::<OstreeSysrootWriteDeploymentsOpts>()}),
+    (
+        "OstreeAsyncProgressClass",
+        Layout {
+            size: size_of::<OstreeAsyncProgressClass>(),
+            alignment: align_of::<OstreeAsyncProgressClass>(),
+        },
+    ),
+    (
+        "OstreeChecksumFlags",
+        Layout {
+            size: size_of::<OstreeChecksumFlags>(),
+            alignment: align_of::<OstreeChecksumFlags>(),
+        },
+    ),
+    (
+        "OstreeCollectionRef",
+        Layout {
+            size: size_of::<OstreeCollectionRef>(),
+            alignment: align_of::<OstreeCollectionRef>(),
+        },
+    ),
+    (
+        "OstreeCollectionRefv",
+        Layout {
+            size: size_of::<OstreeCollectionRefv>(),
+            alignment: align_of::<OstreeCollectionRefv>(),
+        },
+    ),
+    (
+        "OstreeCommitSizesEntry",
+        Layout {
+            size: size_of::<OstreeCommitSizesEntry>(),
+            alignment: align_of::<OstreeCommitSizesEntry>(),
+        },
+    ),
+    (
+        "OstreeContentWriterClass",
+        Layout {
+            size: size_of::<OstreeContentWriterClass>(),
+            alignment: align_of::<OstreeContentWriterClass>(),
+        },
+    ),
+    (
+        "OstreeDeploymentUnlockedState",
+        Layout {
+            size: size_of::<OstreeDeploymentUnlockedState>(),
+            alignment: align_of::<OstreeDeploymentUnlockedState>(),
+        },
+    ),
+    (
+        "OstreeDiffDirsOptions",
+        Layout {
+            size: size_of::<OstreeDiffDirsOptions>(),
+            alignment: align_of::<OstreeDiffDirsOptions>(),
+        },
+    ),
+    (
+        "OstreeDiffFlags",
+        Layout {
+            size: size_of::<OstreeDiffFlags>(),
+            alignment: align_of::<OstreeDiffFlags>(),
+        },
+    ),
+    (
+        "OstreeDiffItem",
+        Layout {
+            size: size_of::<OstreeDiffItem>(),
+            alignment: align_of::<OstreeDiffItem>(),
+        },
+    ),
+    (
+        "OstreeGpgError",
+        Layout {
+            size: size_of::<OstreeGpgError>(),
+            alignment: align_of::<OstreeGpgError>(),
+        },
+    ),
+    (
+        "OstreeGpgSignatureAttr",
+        Layout {
+            size: size_of::<OstreeGpgSignatureAttr>(),
+            alignment: align_of::<OstreeGpgSignatureAttr>(),
+        },
+    ),
+    (
+        "OstreeGpgSignatureFormatFlags",
+        Layout {
+            size: size_of::<OstreeGpgSignatureFormatFlags>(),
+            alignment: align_of::<OstreeGpgSignatureFormatFlags>(),
+        },
+    ),
+    (
+        "OstreeMutableTreeClass",
+        Layout {
+            size: size_of::<OstreeMutableTreeClass>(),
+            alignment: align_of::<OstreeMutableTreeClass>(),
+        },
+    ),
+    (
+        "OstreeMutableTreeIter",
+        Layout {
+            size: size_of::<OstreeMutableTreeIter>(),
+            alignment: align_of::<OstreeMutableTreeIter>(),
+        },
+    ),
+    (
+        "OstreeObjectType",
+        Layout {
+            size: size_of::<OstreeObjectType>(),
+            alignment: align_of::<OstreeObjectType>(),
+        },
+    ),
+    (
+        "OstreeRepoCheckoutAtOptions",
+        Layout {
+            size: size_of::<OstreeRepoCheckoutAtOptions>(),
+            alignment: align_of::<OstreeRepoCheckoutAtOptions>(),
+        },
+    ),
+    (
+        "OstreeRepoCheckoutFilterResult",
+        Layout {
+            size: size_of::<OstreeRepoCheckoutFilterResult>(),
+            alignment: align_of::<OstreeRepoCheckoutFilterResult>(),
+        },
+    ),
+    (
+        "OstreeRepoCheckoutMode",
+        Layout {
+            size: size_of::<OstreeRepoCheckoutMode>(),
+            alignment: align_of::<OstreeRepoCheckoutMode>(),
+        },
+    ),
+    (
+        "OstreeRepoCheckoutOverwriteMode",
+        Layout {
+            size: size_of::<OstreeRepoCheckoutOverwriteMode>(),
+            alignment: align_of::<OstreeRepoCheckoutOverwriteMode>(),
+        },
+    ),
+    (
+        "OstreeRepoCommitFilterResult",
+        Layout {
+            size: size_of::<OstreeRepoCommitFilterResult>(),
+            alignment: align_of::<OstreeRepoCommitFilterResult>(),
+        },
+    ),
+    (
+        "OstreeRepoCommitIterResult",
+        Layout {
+            size: size_of::<OstreeRepoCommitIterResult>(),
+            alignment: align_of::<OstreeRepoCommitIterResult>(),
+        },
+    ),
+    (
+        "OstreeRepoCommitModifierFlags",
+        Layout {
+            size: size_of::<OstreeRepoCommitModifierFlags>(),
+            alignment: align_of::<OstreeRepoCommitModifierFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoCommitState",
+        Layout {
+            size: size_of::<OstreeRepoCommitState>(),
+            alignment: align_of::<OstreeRepoCommitState>(),
+        },
+    ),
+    (
+        "OstreeRepoCommitTraverseFlags",
+        Layout {
+            size: size_of::<OstreeRepoCommitTraverseFlags>(),
+            alignment: align_of::<OstreeRepoCommitTraverseFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoCommitTraverseIter",
+        Layout {
+            size: size_of::<OstreeRepoCommitTraverseIter>(),
+            alignment: align_of::<OstreeRepoCommitTraverseIter>(),
+        },
+    ),
+    (
+        "OstreeRepoFileClass",
+        Layout {
+            size: size_of::<OstreeRepoFileClass>(),
+            alignment: align_of::<OstreeRepoFileClass>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderAvahiClass",
+        Layout {
+            size: size_of::<OstreeRepoFinderAvahiClass>(),
+            alignment: align_of::<OstreeRepoFinderAvahiClass>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderConfigClass",
+        Layout {
+            size: size_of::<OstreeRepoFinderConfigClass>(),
+            alignment: align_of::<OstreeRepoFinderConfigClass>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderInterface",
+        Layout {
+            size: size_of::<OstreeRepoFinderInterface>(),
+            alignment: align_of::<OstreeRepoFinderInterface>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderMountClass",
+        Layout {
+            size: size_of::<OstreeRepoFinderMountClass>(),
+            alignment: align_of::<OstreeRepoFinderMountClass>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderOverrideClass",
+        Layout {
+            size: size_of::<OstreeRepoFinderOverrideClass>(),
+            alignment: align_of::<OstreeRepoFinderOverrideClass>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderResult",
+        Layout {
+            size: size_of::<OstreeRepoFinderResult>(),
+            alignment: align_of::<OstreeRepoFinderResult>(),
+        },
+    ),
+    (
+        "OstreeRepoFinderResultv",
+        Layout {
+            size: size_of::<OstreeRepoFinderResultv>(),
+            alignment: align_of::<OstreeRepoFinderResultv>(),
+        },
+    ),
+    (
+        "OstreeRepoListObjectsFlags",
+        Layout {
+            size: size_of::<OstreeRepoListObjectsFlags>(),
+            alignment: align_of::<OstreeRepoListObjectsFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoListRefsExtFlags",
+        Layout {
+            size: size_of::<OstreeRepoListRefsExtFlags>(),
+            alignment: align_of::<OstreeRepoListRefsExtFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoMode",
+        Layout {
+            size: size_of::<OstreeRepoMode>(),
+            alignment: align_of::<OstreeRepoMode>(),
+        },
+    ),
+    (
+        "OstreeRepoPruneFlags",
+        Layout {
+            size: size_of::<OstreeRepoPruneFlags>(),
+            alignment: align_of::<OstreeRepoPruneFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoPruneOptions",
+        Layout {
+            size: size_of::<OstreeRepoPruneOptions>(),
+            alignment: align_of::<OstreeRepoPruneOptions>(),
+        },
+    ),
+    (
+        "OstreeRepoPullFlags",
+        Layout {
+            size: size_of::<OstreeRepoPullFlags>(),
+            alignment: align_of::<OstreeRepoPullFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoRemoteChange",
+        Layout {
+            size: size_of::<OstreeRepoRemoteChange>(),
+            alignment: align_of::<OstreeRepoRemoteChange>(),
+        },
+    ),
+    (
+        "OstreeRepoResolveRevExtFlags",
+        Layout {
+            size: size_of::<OstreeRepoResolveRevExtFlags>(),
+            alignment: align_of::<OstreeRepoResolveRevExtFlags>(),
+        },
+    ),
+    (
+        "OstreeRepoTransactionStats",
+        Layout {
+            size: size_of::<OstreeRepoTransactionStats>(),
+            alignment: align_of::<OstreeRepoTransactionStats>(),
+        },
+    ),
+    (
+        "OstreeSePolicyRestoreconFlags",
+        Layout {
+            size: size_of::<OstreeSePolicyRestoreconFlags>(),
+            alignment: align_of::<OstreeSePolicyRestoreconFlags>(),
+        },
+    ),
+    (
+        "OstreeSignInterface",
+        Layout {
+            size: size_of::<OstreeSignInterface>(),
+            alignment: align_of::<OstreeSignInterface>(),
+        },
+    ),
+    (
+        "OstreeStaticDeltaGenerateOpt",
+        Layout {
+            size: size_of::<OstreeStaticDeltaGenerateOpt>(),
+            alignment: align_of::<OstreeStaticDeltaGenerateOpt>(),
+        },
+    ),
+    (
+        "OstreeStaticDeltaIndexFlags",
+        Layout {
+            size: size_of::<OstreeStaticDeltaIndexFlags>(),
+            alignment: align_of::<OstreeStaticDeltaIndexFlags>(),
+        },
+    ),
+    (
+        "OstreeSysrootDeployTreeOpts",
+        Layout {
+            size: size_of::<OstreeSysrootDeployTreeOpts>(),
+            alignment: align_of::<OstreeSysrootDeployTreeOpts>(),
+        },
+    ),
+    (
+        "OstreeSysrootSimpleWriteDeploymentFlags",
+        Layout {
+            size: size_of::<OstreeSysrootSimpleWriteDeploymentFlags>(),
+            alignment: align_of::<OstreeSysrootSimpleWriteDeploymentFlags>(),
+        },
+    ),
+    (
+        "OstreeSysrootUpgraderFlags",
+        Layout {
+            size: size_of::<OstreeSysrootUpgraderFlags>(),
+            alignment: align_of::<OstreeSysrootUpgraderFlags>(),
+        },
+    ),
+    (
+        "OstreeSysrootUpgraderPullFlags",
+        Layout {
+            size: size_of::<OstreeSysrootUpgraderPullFlags>(),
+            alignment: align_of::<OstreeSysrootUpgraderPullFlags>(),
+        },
+    ),
+    (
+        "OstreeSysrootWriteDeploymentsOpts",
+        Layout {
+            size: size_of::<OstreeSysrootWriteDeploymentsOpts>(),
+            alignment: align_of::<OstreeSysrootWriteDeploymentsOpts>(),
+        },
+    ),
 ];
 
 const RUST_CONSTANTS: &[(&str, &str)] = &[
@@ -298,9 +581,15 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("(guint) OSTREE_CHECKSUM_FLAGS_NONE", "0"),
     ("OSTREE_COMMIT_GVARIANT_STRING", "(a{sv}aya(say)sstayay)"),
     ("OSTREE_COMMIT_META_KEY_ARCHITECTURE", "ostree.architecture"),
-    ("OSTREE_COMMIT_META_KEY_COLLECTION_BINDING", "ostree.collection-binding"),
+    (
+        "OSTREE_COMMIT_META_KEY_COLLECTION_BINDING",
+        "ostree.collection-binding",
+    ),
     ("OSTREE_COMMIT_META_KEY_ENDOFLIFE", "ostree.endoflife"),
-    ("OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE", "ostree.endoflife-rebase"),
+    (
+        "OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE",
+        "ostree.endoflife-rebase",
+    ),
     ("OSTREE_COMMIT_META_KEY_REF_BINDING", "ostree.ref-binding"),
     ("OSTREE_COMMIT_META_KEY_SOURCE_TITLE", "ostree.source-title"),
     ("OSTREE_COMMIT_META_KEY_VERSION", "version"),
@@ -324,7 +613,10 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("(gint) OSTREE_GPG_SIGNATURE_ATTR_HASH_ALGO_NAME", "9"),
     ("(gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXPIRED", "2"),
     ("(gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP", "13"),
-    ("(gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY", "14"),
+    (
+        "(gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY",
+        "14",
+    ),
     ("(gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_MISSING", "4"),
     ("(gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_REVOKED", "3"),
     ("(gint) OSTREE_GPG_SIGNATURE_ATTR_PUBKEY_ALGO_NAME", "8"),
@@ -338,7 +630,10 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("OSTREE_MAX_METADATA_WARN_SIZE", "7340032"),
     ("OSTREE_METADATA_KEY_BOOTABLE", "ostree.bootable"),
     ("OSTREE_METADATA_KEY_LINUX", "ostree.linux"),
-    ("OSTREE_META_KEY_DEPLOY_COLLECTION_ID", "ostree.deploy-collection-id"),
+    (
+        "OSTREE_META_KEY_DEPLOY_COLLECTION_ID",
+        "ostree.deploy-collection-id",
+    ),
     ("(gint) OSTREE_OBJECT_TYPE_COMMIT", "4"),
     ("(gint) OSTREE_OBJECT_TYPE_COMMIT_META", "6"),
     ("(gint) OSTREE_OBJECT_TYPE_DIR_META", "3"),
@@ -361,11 +656,23 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("(gint) OSTREE_REPO_COMMIT_ITER_RESULT_END", "1"),
     ("(gint) OSTREE_REPO_COMMIT_ITER_RESULT_ERROR", "0"),
     ("(gint) OSTREE_REPO_COMMIT_ITER_RESULT_FILE", "2"),
-    ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS", "4"),
+    (
+        "(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS",
+        "4",
+    ),
     ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME", "16"),
-    ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL", "32"),
-    ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED", "8"),
-    ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES", "2"),
+    (
+        "(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL",
+        "32",
+    ),
+    (
+        "(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED",
+        "8",
+    ),
+    (
+        "(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES",
+        "2",
+    ),
     ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE", "0"),
     ("(guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS", "1"),
     ("(guint) OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL", "2"),
@@ -402,8 +709,14 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("(gint) OSTREE_REPO_REMOTE_CHANGE_REPLACE", "4"),
     ("(guint) OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY", "1"),
     ("(guint) OSTREE_REPO_RESOLVE_REV_EXT_NONE", "0"),
-    ("(guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL", "1"),
-    ("(guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING", "2"),
+    (
+        "(guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL",
+        "1",
+    ),
+    (
+        "(guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING",
+        "2",
+    ),
     ("(guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE", "0"),
     ("OSTREE_SHA256_DIGEST_LEN", "32"),
     ("OSTREE_SHA256_STRING_LEN", "64"),
@@ -413,18 +726,40 @@ const RUST_CONSTANTS: &[(&str, &str)] = &[
     ("(gint) OSTREE_STATIC_DELTA_INDEX_FLAGS_NONE", "0"),
     ("OSTREE_SUMMARY_GVARIANT_STRING", "(a(s(taya{sv}))a{sv})"),
     ("OSTREE_SUMMARY_SIG_GVARIANT_STRING", "a{sv}"),
-    ("(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE", "0"),
-    ("(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT", "2"),
-    ("(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN", "4"),
-    ("(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN", "1"),
-    ("(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING", "8"),
-    ("(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK", "16"),
-    ("(guint) OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED", "2"),
-    ("(guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER", "1"),
+    (
+        "(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE",
+        "0",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT",
+        "2",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN",
+        "4",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN",
+        "1",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING",
+        "8",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK",
+        "16",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED",
+        "2",
+    ),
+    (
+        "(guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER",
+        "1",
+    ),
     ("(guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE", "0"),
     ("(guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC", "2"),
     ("OSTREE_TIMESTAMP", "0"),
     ("OSTREE_TREE_GVARIANT_STRING", "(a(say)a(sayay))"),
 ];
-
-

rust-bindings/rust/sys/tests/constant.c

@@ -1,27 +1,163 @@
 // This file was generated by gir (https://github.com/gtk-rs/gir)
-// from gir-files (https://github.com/gtk-rs/gir-files)
+// from gir-files
 // DO NOT EDIT
 
 #include "manual.h"
 #include <stdio.h>
 
+#define PRINT_CONSTANT(CONSTANT_NAME) \
+    printf("%s;", #CONSTANT_NAME); \
+    printf(_Generic((CONSTANT_NAME), \
+                    char *: "%s", \
+                    const char *: "%s", \
+                    char: "%c", \
+                    signed char: "%hhd", \
+                    unsigned char: "%hhu", \
+                    short int: "%hd", \
+                    unsigned short int: "%hu", \
+                    int: "%d", \
+                    unsigned int: "%u", \
+                    long: "%ld", \
+                    unsigned long: "%lu", \
+                    long long: "%lld", \
+                    unsigned long long: "%llu", \
+                    float: "%f", \
+                    double: "%f", \
+                    long double: "%ld"), \
+           CONSTANT_NAME); \
+    printf("\n");
+
 int main() {
-    printf(_Generic((ABI_CONSTANT_NAME),
-                    char *: "###gir test###%s###gir test###\n",
-                    const char *: "###gir test###%s###gir test###\n",
-                    char: "###gir test###%c###gir test###\n",
-                    signed char: "###gir test###%hhd###gir test###\n",
-                    unsigned char: "###gir test###%hhu###gir test###\n",
-                    short int: "###gir test###%hd###gir test###\n",
-                    unsigned short int: "###gir test###%hu###gir test###\n",
-                    int: "###gir test###%d###gir test###\n",
-                    unsigned int: "###gir test###%u###gir test###\n",
-                    long: "###gir test###%ld###gir test###\n",
-                    unsigned long: "###gir test###%lu###gir test###\n",
-                    long long: "###gir test###%lld###gir test###\n",
-                    unsigned long long: "###gir test###%llu###gir test###\n",
-                    double: "###gir test###%f###gir test###\n",
-                    long double: "###gir test###%ld###gir test###\n"),
-           ABI_CONSTANT_NAME);
+    PRINT_CONSTANT((guint) OSTREE_CHECKSUM_FLAGS_IGNORE_XATTRS);
+    PRINT_CONSTANT((guint) OSTREE_CHECKSUM_FLAGS_NONE);
+    PRINT_CONSTANT(OSTREE_COMMIT_GVARIANT_STRING);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_ARCHITECTURE);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_COLLECTION_BINDING);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_ENDOFLIFE);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_REF_BINDING);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_SOURCE_TITLE);
+    PRINT_CONSTANT(OSTREE_COMMIT_META_KEY_VERSION);
+    PRINT_CONSTANT((gint) OSTREE_DEPLOYMENT_UNLOCKED_DEVELOPMENT);
+    PRINT_CONSTANT((gint) OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX);
+    PRINT_CONSTANT((gint) OSTREE_DEPLOYMENT_UNLOCKED_NONE);
+    PRINT_CONSTANT((gint) OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT);
+    PRINT_CONSTANT((guint) OSTREE_DIFF_FLAGS_IGNORE_XATTRS);
+    PRINT_CONSTANT((guint) OSTREE_DIFF_FLAGS_NONE);
+    PRINT_CONSTANT(OSTREE_DIRMETA_GVARIANT_STRING);
+    PRINT_CONSTANT(OSTREE_FILEMETA_GVARIANT_STRING);
+    PRINT_CONSTANT((gint) OSTREE_GPG_ERROR_EXPIRED_KEY);
+    PRINT_CONSTANT((gint) OSTREE_GPG_ERROR_EXPIRED_SIGNATURE);
+    PRINT_CONSTANT((gint) OSTREE_GPG_ERROR_INVALID_SIGNATURE);
+    PRINT_CONSTANT((gint) OSTREE_GPG_ERROR_MISSING_KEY);
+    PRINT_CONSTANT((gint) OSTREE_GPG_ERROR_NO_SIGNATURE);
+    PRINT_CONSTANT((gint) OSTREE_GPG_ERROR_REVOKED_KEY);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_EXP_TIMESTAMP);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_HASH_ALGO_NAME);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXPIRED);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_MISSING);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_KEY_REVOKED);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_PUBKEY_ALGO_NAME);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_SIG_EXPIRED);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_TIMESTAMP);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_USER_NAME);
+    PRINT_CONSTANT((gint) OSTREE_GPG_SIGNATURE_ATTR_VALID);
+    PRINT_CONSTANT((guint) OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT);
+    PRINT_CONSTANT(OSTREE_MAX_METADATA_SIZE);
+    PRINT_CONSTANT(OSTREE_MAX_METADATA_WARN_SIZE);
+    PRINT_CONSTANT(OSTREE_METADATA_KEY_BOOTABLE);
+    PRINT_CONSTANT(OSTREE_METADATA_KEY_LINUX);
+    PRINT_CONSTANT(OSTREE_META_KEY_DEPLOY_COLLECTION_ID);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_COMMIT);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_COMMIT_META);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_DIR_META);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_DIR_TREE);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_FILE);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_PAYLOAD_LINK);
+    PRINT_CONSTANT((gint) OSTREE_OBJECT_TYPE_TOMBSTONE_COMMIT);
+    PRINT_CONSTANT(OSTREE_ORIGIN_TRANSIENT_GROUP);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_FILTER_ALLOW);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_FILTER_SKIP);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_MODE_NONE);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_MODE_USER);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_OVERWRITE_NONE);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES);
+    PRINT_CONSTANT((gint) OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL);
+    PRINT_CONSTANT((gint) OSTREE_REPO_COMMIT_FILTER_ALLOW);
+    PRINT_CONSTANT((gint) OSTREE_REPO_COMMIT_FILTER_SKIP);
+    PRINT_CONSTANT((gint) OSTREE_REPO_COMMIT_ITER_RESULT_DIR);
+    PRINT_CONSTANT((gint) OSTREE_REPO_COMMIT_ITER_RESULT_END);
+    PRINT_CONSTANT((gint) OSTREE_REPO_COMMIT_ITER_RESULT_ERROR);
+    PRINT_CONSTANT((gint) OSTREE_REPO_COMMIT_ITER_RESULT_FILE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_STATE_NORMAL);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_STATE_PARTIAL);
+    PRINT_CONSTANT((guint) OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_OBJECTS_ALL);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_OBJECTS_LOOSE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_OBJECTS_NO_PARENTS);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_OBJECTS_PACKED);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_REFS_EXT_ALIASES);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES);
+    PRINT_CONSTANT((guint) OSTREE_REPO_LIST_REFS_EXT_NONE);
+    PRINT_CONSTANT(OSTREE_REPO_METADATA_REF);
+    PRINT_CONSTANT((gint) OSTREE_REPO_MODE_ARCHIVE);
+    PRINT_CONSTANT((gint) OSTREE_REPO_MODE_ARCHIVE_Z2);
+    PRINT_CONSTANT((gint) OSTREE_REPO_MODE_BARE);
+    PRINT_CONSTANT((gint) OSTREE_REPO_MODE_BARE_USER);
+    PRINT_CONSTANT((gint) OSTREE_REPO_MODE_BARE_USER_ONLY);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PRUNE_FLAGS_NONE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PULL_FLAGS_MIRROR);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PULL_FLAGS_NONE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PULL_FLAGS_TRUSTED_HTTP);
+    PRINT_CONSTANT((guint) OSTREE_REPO_PULL_FLAGS_UNTRUSTED);
+    PRINT_CONSTANT((gint) OSTREE_REPO_REMOTE_CHANGE_ADD);
+    PRINT_CONSTANT((gint) OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS);
+    PRINT_CONSTANT((gint) OSTREE_REPO_REMOTE_CHANGE_DELETE);
+    PRINT_CONSTANT((gint) OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS);
+    PRINT_CONSTANT((gint) OSTREE_REPO_REMOTE_CHANGE_REPLACE);
+    PRINT_CONSTANT((guint) OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY);
+    PRINT_CONSTANT((guint) OSTREE_REPO_RESOLVE_REV_EXT_NONE);
+    PRINT_CONSTANT((guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL);
+    PRINT_CONSTANT((guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING);
+    PRINT_CONSTANT((guint) OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE);
+    PRINT_CONSTANT(OSTREE_SHA256_DIGEST_LEN);
+    PRINT_CONSTANT(OSTREE_SHA256_STRING_LEN);
+    PRINT_CONSTANT(OSTREE_SIGN_NAME_ED25519);
+    PRINT_CONSTANT((gint) OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY);
+    PRINT_CONSTANT((gint) OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR);
+    PRINT_CONSTANT((gint) OSTREE_STATIC_DELTA_INDEX_FLAGS_NONE);
+    PRINT_CONSTANT(OSTREE_SUMMARY_GVARIANT_STRING);
+    PRINT_CONSTANT(OSTREE_SUMMARY_SIG_GVARIANT_STRING);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE);
+    PRINT_CONSTANT((guint) OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC);
+    PRINT_CONSTANT(OSTREE_TIMESTAMP);
+    PRINT_CONSTANT(OSTREE_TREE_GVARIANT_STRING);
     return 0;
 }

rust-bindings/rust/sys/tests/layout.c

@@ -1,5 +1,5 @@
 // This file was generated by gir (https://github.com/gtk-rs/gir)
-// from gir-files (https://github.com/gtk-rs/gir-files)
+// from gir-files
 // DO NOT EDIT
 
 #include "manual.h"
@@ -7,6 +7,57 @@
 #include <stdio.h>
 
 int main() {
-    printf("%zu\n%zu", sizeof(ABI_TYPE_NAME), alignof(ABI_TYPE_NAME));
+    printf("%s;%zu;%zu\n", "OstreeAsyncProgressClass", sizeof(OstreeAsyncProgressClass), alignof(OstreeAsyncProgressClass));
+    printf("%s;%zu;%zu\n", "OstreeChecksumFlags", sizeof(OstreeChecksumFlags), alignof(OstreeChecksumFlags));
+    printf("%s;%zu;%zu\n", "OstreeCollectionRef", sizeof(OstreeCollectionRef), alignof(OstreeCollectionRef));
+    printf("%s;%zu;%zu\n", "OstreeCollectionRefv", sizeof(OstreeCollectionRefv), alignof(OstreeCollectionRefv));
+    printf("%s;%zu;%zu\n", "OstreeCommitSizesEntry", sizeof(OstreeCommitSizesEntry), alignof(OstreeCommitSizesEntry));
+    printf("%s;%zu;%zu\n", "OstreeContentWriterClass", sizeof(OstreeContentWriterClass), alignof(OstreeContentWriterClass));
+    printf("%s;%zu;%zu\n", "OstreeDeploymentUnlockedState", sizeof(OstreeDeploymentUnlockedState), alignof(OstreeDeploymentUnlockedState));
+    printf("%s;%zu;%zu\n", "OstreeDiffDirsOptions", sizeof(OstreeDiffDirsOptions), alignof(OstreeDiffDirsOptions));
+    printf("%s;%zu;%zu\n", "OstreeDiffFlags", sizeof(OstreeDiffFlags), alignof(OstreeDiffFlags));
+    printf("%s;%zu;%zu\n", "OstreeDiffItem", sizeof(OstreeDiffItem), alignof(OstreeDiffItem));
+    printf("%s;%zu;%zu\n", "OstreeGpgError", sizeof(OstreeGpgError), alignof(OstreeGpgError));
+    printf("%s;%zu;%zu\n", "OstreeGpgSignatureAttr", sizeof(OstreeGpgSignatureAttr), alignof(OstreeGpgSignatureAttr));
+    printf("%s;%zu;%zu\n", "OstreeGpgSignatureFormatFlags", sizeof(OstreeGpgSignatureFormatFlags), alignof(OstreeGpgSignatureFormatFlags));
+    printf("%s;%zu;%zu\n", "OstreeMutableTreeClass", sizeof(OstreeMutableTreeClass), alignof(OstreeMutableTreeClass));
+    printf("%s;%zu;%zu\n", "OstreeMutableTreeIter", sizeof(OstreeMutableTreeIter), alignof(OstreeMutableTreeIter));
+    printf("%s;%zu;%zu\n", "OstreeObjectType", sizeof(OstreeObjectType), alignof(OstreeObjectType));
+    printf("%s;%zu;%zu\n", "OstreeRepoCheckoutAtOptions", sizeof(OstreeRepoCheckoutAtOptions), alignof(OstreeRepoCheckoutAtOptions));
+    printf("%s;%zu;%zu\n", "OstreeRepoCheckoutFilterResult", sizeof(OstreeRepoCheckoutFilterResult), alignof(OstreeRepoCheckoutFilterResult));
+    printf("%s;%zu;%zu\n", "OstreeRepoCheckoutMode", sizeof(OstreeRepoCheckoutMode), alignof(OstreeRepoCheckoutMode));
+    printf("%s;%zu;%zu\n", "OstreeRepoCheckoutOverwriteMode", sizeof(OstreeRepoCheckoutOverwriteMode), alignof(OstreeRepoCheckoutOverwriteMode));
+    printf("%s;%zu;%zu\n", "OstreeRepoCommitFilterResult", sizeof(OstreeRepoCommitFilterResult), alignof(OstreeRepoCommitFilterResult));
+    printf("%s;%zu;%zu\n", "OstreeRepoCommitIterResult", sizeof(OstreeRepoCommitIterResult), alignof(OstreeRepoCommitIterResult));
+    printf("%s;%zu;%zu\n", "OstreeRepoCommitModifierFlags", sizeof(OstreeRepoCommitModifierFlags), alignof(OstreeRepoCommitModifierFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoCommitState", sizeof(OstreeRepoCommitState), alignof(OstreeRepoCommitState));
+    printf("%s;%zu;%zu\n", "OstreeRepoCommitTraverseFlags", sizeof(OstreeRepoCommitTraverseFlags), alignof(OstreeRepoCommitTraverseFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoCommitTraverseIter", sizeof(OstreeRepoCommitTraverseIter), alignof(OstreeRepoCommitTraverseIter));
+    printf("%s;%zu;%zu\n", "OstreeRepoFileClass", sizeof(OstreeRepoFileClass), alignof(OstreeRepoFileClass));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderAvahiClass", sizeof(OstreeRepoFinderAvahiClass), alignof(OstreeRepoFinderAvahiClass));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderConfigClass", sizeof(OstreeRepoFinderConfigClass), alignof(OstreeRepoFinderConfigClass));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderInterface", sizeof(OstreeRepoFinderInterface), alignof(OstreeRepoFinderInterface));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderMountClass", sizeof(OstreeRepoFinderMountClass), alignof(OstreeRepoFinderMountClass));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderOverrideClass", sizeof(OstreeRepoFinderOverrideClass), alignof(OstreeRepoFinderOverrideClass));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderResult", sizeof(OstreeRepoFinderResult), alignof(OstreeRepoFinderResult));
+    printf("%s;%zu;%zu\n", "OstreeRepoFinderResultv", sizeof(OstreeRepoFinderResultv), alignof(OstreeRepoFinderResultv));
+    printf("%s;%zu;%zu\n", "OstreeRepoListObjectsFlags", sizeof(OstreeRepoListObjectsFlags), alignof(OstreeRepoListObjectsFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoListRefsExtFlags", sizeof(OstreeRepoListRefsExtFlags), alignof(OstreeRepoListRefsExtFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoMode", sizeof(OstreeRepoMode), alignof(OstreeRepoMode));
+    printf("%s;%zu;%zu\n", "OstreeRepoPruneFlags", sizeof(OstreeRepoPruneFlags), alignof(OstreeRepoPruneFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoPruneOptions", sizeof(OstreeRepoPruneOptions), alignof(OstreeRepoPruneOptions));
+    printf("%s;%zu;%zu\n", "OstreeRepoPullFlags", sizeof(OstreeRepoPullFlags), alignof(OstreeRepoPullFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoRemoteChange", sizeof(OstreeRepoRemoteChange), alignof(OstreeRepoRemoteChange));
+    printf("%s;%zu;%zu\n", "OstreeRepoResolveRevExtFlags", sizeof(OstreeRepoResolveRevExtFlags), alignof(OstreeRepoResolveRevExtFlags));
+    printf("%s;%zu;%zu\n", "OstreeRepoTransactionStats", sizeof(OstreeRepoTransactionStats), alignof(OstreeRepoTransactionStats));
+    printf("%s;%zu;%zu\n", "OstreeSePolicyRestoreconFlags", sizeof(OstreeSePolicyRestoreconFlags), alignof(OstreeSePolicyRestoreconFlags));
+    printf("%s;%zu;%zu\n", "OstreeSignInterface", sizeof(OstreeSignInterface), alignof(OstreeSignInterface));
+    printf("%s;%zu;%zu\n", "OstreeStaticDeltaGenerateOpt", sizeof(OstreeStaticDeltaGenerateOpt), alignof(OstreeStaticDeltaGenerateOpt));
+    printf("%s;%zu;%zu\n", "OstreeStaticDeltaIndexFlags", sizeof(OstreeStaticDeltaIndexFlags), alignof(OstreeStaticDeltaIndexFlags));
+    printf("%s;%zu;%zu\n", "OstreeSysrootDeployTreeOpts", sizeof(OstreeSysrootDeployTreeOpts), alignof(OstreeSysrootDeployTreeOpts));
+    printf("%s;%zu;%zu\n", "OstreeSysrootSimpleWriteDeploymentFlags", sizeof(OstreeSysrootSimpleWriteDeploymentFlags), alignof(OstreeSysrootSimpleWriteDeploymentFlags));
+    printf("%s;%zu;%zu\n", "OstreeSysrootUpgraderFlags", sizeof(OstreeSysrootUpgraderFlags), alignof(OstreeSysrootUpgraderFlags));
+    printf("%s;%zu;%zu\n", "OstreeSysrootUpgraderPullFlags", sizeof(OstreeSysrootUpgraderPullFlags), alignof(OstreeSysrootUpgraderPullFlags));
+    printf("%s;%zu;%zu\n", "OstreeSysrootWriteDeploymentsOpts", sizeof(OstreeSysrootWriteDeploymentsOpts), alignof(OstreeSysrootWriteDeploymentsOpts));
     return 0;
 }