// This file was generated by gir (https://github.com/gtk-rs/gir @ 0ab7700)
// from gir-files (https://github.com/gtk-rs/gir-files @ ???)
// DO NOT EDIT

extern crate goa_sys;
extern crate shell_words;
extern crate tempdir;
use std::env;
use std::error::Error;
use std::path::Path;
use std::mem::{align_of, size_of};
use std::process::Command;
use std::str;
use goa_sys::*;

static PACKAGES: &[&str] = &["goa-1.0"];

#[derive(Clone, Debug)]
struct Compiler {
    pub args: Vec<String>,
}

impl Compiler {
    pub fn new() -> Result<Compiler, Box<Error>> {
        let mut args = get_var("CC", "cc")?;
        args.push("-Wno-deprecated-declarations".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);
    }

    pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box<Error>> {
        let mut cmd = self.to_command();
        cmd.arg(src);
        cmd.arg("-o");
        cmd.arg(out);
        let status = cmd.spawn()?.wait()?;
        if !status.success() {
            return Err(format!("compilation command {:?} failed, {}",
                               &cmd, status).into());
        }
        Ok(())
    }

    fn to_command(&self) -> Command {
        let mut cmd = Command::new(&self.args[0]);
        cmd.args(&self.args[1..]);
        cmd
    }
}

fn get_var(name: &str, default: &str) -> Result<Vec<String>, Box<Error>> {
    match env::var(name) {
        Ok(value) => Ok(shell_words::split(&value)?),
        Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?),
        Err(err) => Err(format!("{} {}", name, err).into()),
    }
}

fn pkg_config_cflags(packages: &[&str]) -> Result<Vec<String>, Box<Error>> {
    if packages.is_empty() {
        return Ok(Vec::new());
    }
    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());
    }
    let stdout = str::from_utf8(&out.stdout)?;
    Ok(shell_words::split(stdout.trim())?)
}


#[derive(Copy, Clone, Debug, Eq, PartialEq)]
struct Layout {
    size: usize,
    alignment: usize,
}

#[derive(Copy, Clone, Debug, Default, Eq, PartialEq)]
struct Results {
    /// Number of successfully completed tests.
    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 {
    fn record_passed(&mut self) {
        self.passed += 1;
    }
    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)
    }
    fn expect_total_success(&self) {
        if self.failed == 0 {
            println!("OK: {}", self.summary());
        } else {
            panic!("FAILED: {}", self.summary());
        };
    }
}

#[test]
fn cross_validate_constants_with_c() {
    let tmpdir = tempdir::TempDir::new("abi").expect("temporary directory");
    let cc = Compiler::new().expect("configured compiler");

    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());
        }
    }
    results.expect_total_success();
}

#[test]
fn cross_validate_layout_with_c() {
    let tmpdir = tempdir::TempDir::new("abi").expect("temporary directory");
    let cc = Compiler::new().expect("configured compiler");

    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());
        }
    }
    results.expect_total_success();
}

fn get_c_layout(dir: &Path, cc: &Compiler, name: &str) -> Result<Layout, Box<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)?;

    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 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<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)]))
}

const RUST_LAYOUTS: &[(&str, Layout)] = &[
    ("GoaAccountIface", Layout {size: size_of::<GoaAccountIface>(), alignment: align_of::<GoaAccountIface>()}),
    ("GoaAccountProxy", Layout {size: size_of::<GoaAccountProxy>(), alignment: align_of::<GoaAccountProxy>()}),
    ("GoaAccountProxyClass", Layout {size: size_of::<GoaAccountProxyClass>(), alignment: align_of::<GoaAccountProxyClass>()}),
    ("GoaAccountSkeleton", Layout {size: size_of::<GoaAccountSkeleton>(), alignment: align_of::<GoaAccountSkeleton>()}),
    ("GoaAccountSkeletonClass", Layout {size: size_of::<GoaAccountSkeletonClass>(), alignment: align_of::<GoaAccountSkeletonClass>()}),
    ("GoaCalendarIface", Layout {size: size_of::<GoaCalendarIface>(), alignment: align_of::<GoaCalendarIface>()}),
    ("GoaCalendarProxy", Layout {size: size_of::<GoaCalendarProxy>(), alignment: align_of::<GoaCalendarProxy>()}),
    ("GoaCalendarProxyClass", Layout {size: size_of::<GoaCalendarProxyClass>(), alignment: align_of::<GoaCalendarProxyClass>()}),
    ("GoaCalendarSkeleton", Layout {size: size_of::<GoaCalendarSkeleton>(), alignment: align_of::<GoaCalendarSkeleton>()}),
    ("GoaCalendarSkeletonClass", Layout {size: size_of::<GoaCalendarSkeletonClass>(), alignment: align_of::<GoaCalendarSkeletonClass>()}),
    ("GoaChatIface", Layout {size: size_of::<GoaChatIface>(), alignment: align_of::<GoaChatIface>()}),
    ("GoaChatProxy", Layout {size: size_of::<GoaChatProxy>(), alignment: align_of::<GoaChatProxy>()}),
    ("GoaChatProxyClass", Layout {size: size_of::<GoaChatProxyClass>(), alignment: align_of::<GoaChatProxyClass>()}),
    ("GoaChatSkeleton", Layout {size: size_of::<GoaChatSkeleton>(), alignment: align_of::<GoaChatSkeleton>()}),
    ("GoaChatSkeletonClass", Layout {size: size_of::<GoaChatSkeletonClass>(), alignment: align_of::<GoaChatSkeletonClass>()}),
    ("GoaClientClass", Layout {size: size_of::<GoaClientClass>(), alignment: align_of::<GoaClientClass>()}),
    ("GoaContactsIface", Layout {size: size_of::<GoaContactsIface>(), alignment: align_of::<GoaContactsIface>()}),
    ("GoaContactsProxy", Layout {size: size_of::<GoaContactsProxy>(), alignment: align_of::<GoaContactsProxy>()}),
    ("GoaContactsProxyClass", Layout {size: size_of::<GoaContactsProxyClass>(), alignment: align_of::<GoaContactsProxyClass>()}),
    ("GoaContactsSkeleton", Layout {size: size_of::<GoaContactsSkeleton>(), alignment: align_of::<GoaContactsSkeleton>()}),
    ("GoaContactsSkeletonClass", Layout {size: size_of::<GoaContactsSkeletonClass>(), alignment: align_of::<GoaContactsSkeletonClass>()}),
    ("GoaDocumentsIface", Layout {size: size_of::<GoaDocumentsIface>(), alignment: align_of::<GoaDocumentsIface>()}),
    ("GoaDocumentsProxy", Layout {size: size_of::<GoaDocumentsProxy>(), alignment: align_of::<GoaDocumentsProxy>()}),
    ("GoaDocumentsProxyClass", Layout {size: size_of::<GoaDocumentsProxyClass>(), alignment: align_of::<GoaDocumentsProxyClass>()}),
    ("GoaDocumentsSkeleton", Layout {size: size_of::<GoaDocumentsSkeleton>(), alignment: align_of::<GoaDocumentsSkeleton>()}),
    ("GoaDocumentsSkeletonClass", Layout {size: size_of::<GoaDocumentsSkeletonClass>(), alignment: align_of::<GoaDocumentsSkeletonClass>()}),
    ("GoaError", Layout {size: size_of::<GoaError>(), alignment: align_of::<GoaError>()}),
    ("GoaExchangeIface", Layout {size: size_of::<GoaExchangeIface>(), alignment: align_of::<GoaExchangeIface>()}),
    ("GoaExchangeProxy", Layout {size: size_of::<GoaExchangeProxy>(), alignment: align_of::<GoaExchangeProxy>()}),
    ("GoaExchangeProxyClass", Layout {size: size_of::<GoaExchangeProxyClass>(), alignment: align_of::<GoaExchangeProxyClass>()}),
    ("GoaExchangeSkeleton", Layout {size: size_of::<GoaExchangeSkeleton>(), alignment: align_of::<GoaExchangeSkeleton>()}),
    ("GoaExchangeSkeletonClass", Layout {size: size_of::<GoaExchangeSkeletonClass>(), alignment: align_of::<GoaExchangeSkeletonClass>()}),
    ("GoaFilesIface", Layout {size: size_of::<GoaFilesIface>(), alignment: align_of::<GoaFilesIface>()}),
    ("GoaFilesProxy", Layout {size: size_of::<GoaFilesProxy>(), alignment: align_of::<GoaFilesProxy>()}),
    ("GoaFilesProxyClass", Layout {size: size_of::<GoaFilesProxyClass>(), alignment: align_of::<GoaFilesProxyClass>()}),
    ("GoaFilesSkeleton", Layout {size: size_of::<GoaFilesSkeleton>(), alignment: align_of::<GoaFilesSkeleton>()}),
    ("GoaFilesSkeletonClass", Layout {size: size_of::<GoaFilesSkeletonClass>(), alignment: align_of::<GoaFilesSkeletonClass>()}),
    ("GoaMailIface", Layout {size: size_of::<GoaMailIface>(), alignment: align_of::<GoaMailIface>()}),
    ("GoaMailProxy", Layout {size: size_of::<GoaMailProxy>(), alignment: align_of::<GoaMailProxy>()}),
    ("GoaMailProxyClass", Layout {size: size_of::<GoaMailProxyClass>(), alignment: align_of::<GoaMailProxyClass>()}),
    ("GoaMailSkeleton", Layout {size: size_of::<GoaMailSkeleton>(), alignment: align_of::<GoaMailSkeleton>()}),
    ("GoaMailSkeletonClass", Layout {size: size_of::<GoaMailSkeletonClass>(), alignment: align_of::<GoaMailSkeletonClass>()}),
    ("GoaManagerIface", Layout {size: size_of::<GoaManagerIface>(), alignment: align_of::<GoaManagerIface>()}),
    ("GoaManagerProxy", Layout {size: size_of::<GoaManagerProxy>(), alignment: align_of::<GoaManagerProxy>()}),
    ("GoaManagerProxyClass", Layout {size: size_of::<GoaManagerProxyClass>(), alignment: align_of::<GoaManagerProxyClass>()}),
    ("GoaManagerSkeleton", Layout {size: size_of::<GoaManagerSkeleton>(), alignment: align_of::<GoaManagerSkeleton>()}),
    ("GoaManagerSkeletonClass", Layout {size: size_of::<GoaManagerSkeletonClass>(), alignment: align_of::<GoaManagerSkeletonClass>()}),
    ("GoaMapsIface", Layout {size: size_of::<GoaMapsIface>(), alignment: align_of::<GoaMapsIface>()}),
    ("GoaMapsProxy", Layout {size: size_of::<GoaMapsProxy>(), alignment: align_of::<GoaMapsProxy>()}),
    ("GoaMapsProxyClass", Layout {size: size_of::<GoaMapsProxyClass>(), alignment: align_of::<GoaMapsProxyClass>()}),
    ("GoaMapsSkeleton", Layout {size: size_of::<GoaMapsSkeleton>(), alignment: align_of::<GoaMapsSkeleton>()}),
    ("GoaMapsSkeletonClass", Layout {size: size_of::<GoaMapsSkeletonClass>(), alignment: align_of::<GoaMapsSkeletonClass>()}),
    ("GoaMediaServerIface", Layout {size: size_of::<GoaMediaServerIface>(), alignment: align_of::<GoaMediaServerIface>()}),
    ("GoaMediaServerProxy", Layout {size: size_of::<GoaMediaServerProxy>(), alignment: align_of::<GoaMediaServerProxy>()}),
    ("GoaMediaServerProxyClass", Layout {size: size_of::<GoaMediaServerProxyClass>(), alignment: align_of::<GoaMediaServerProxyClass>()}),
    ("GoaMediaServerSkeleton", Layout {size: size_of::<GoaMediaServerSkeleton>(), alignment: align_of::<GoaMediaServerSkeleton>()}),
    ("GoaMediaServerSkeletonClass", Layout {size: size_of::<GoaMediaServerSkeletonClass>(), alignment: align_of::<GoaMediaServerSkeletonClass>()}),
    ("GoaMusicIface", Layout {size: size_of::<GoaMusicIface>(), alignment: align_of::<GoaMusicIface>()}),
    ("GoaMusicProxy", Layout {size: size_of::<GoaMusicProxy>(), alignment: align_of::<GoaMusicProxy>()}),
    ("GoaMusicProxyClass", Layout {size: size_of::<GoaMusicProxyClass>(), alignment: align_of::<GoaMusicProxyClass>()}),
    ("GoaMusicSkeleton", Layout {size: size_of::<GoaMusicSkeleton>(), alignment: align_of::<GoaMusicSkeleton>()}),
    ("GoaMusicSkeletonClass", Layout {size: size_of::<GoaMusicSkeletonClass>(), alignment: align_of::<GoaMusicSkeletonClass>()}),
    ("GoaOAuth2BasedIface", Layout {size: size_of::<GoaOAuth2BasedIface>(), alignment: align_of::<GoaOAuth2BasedIface>()}),
    ("GoaOAuth2BasedProxy", Layout {size: size_of::<GoaOAuth2BasedProxy>(), alignment: align_of::<GoaOAuth2BasedProxy>()}),
    ("GoaOAuth2BasedProxyClass", Layout {size: size_of::<GoaOAuth2BasedProxyClass>(), alignment: align_of::<GoaOAuth2BasedProxyClass>()}),
    ("GoaOAuth2BasedSkeleton", Layout {size: size_of::<GoaOAuth2BasedSkeleton>(), alignment: align_of::<GoaOAuth2BasedSkeleton>()}),
    ("GoaOAuth2BasedSkeletonClass", Layout {size: size_of::<GoaOAuth2BasedSkeletonClass>(), alignment: align_of::<GoaOAuth2BasedSkeletonClass>()}),
    ("GoaOAuthBasedIface", Layout {size: size_of::<GoaOAuthBasedIface>(), alignment: align_of::<GoaOAuthBasedIface>()}),
    ("GoaOAuthBasedProxy", Layout {size: size_of::<GoaOAuthBasedProxy>(), alignment: align_of::<GoaOAuthBasedProxy>()}),
    ("GoaOAuthBasedProxyClass", Layout {size: size_of::<GoaOAuthBasedProxyClass>(), alignment: align_of::<GoaOAuthBasedProxyClass>()}),
    ("GoaOAuthBasedSkeleton", Layout {size: size_of::<GoaOAuthBasedSkeleton>(), alignment: align_of::<GoaOAuthBasedSkeleton>()}),
    ("GoaOAuthBasedSkeletonClass", Layout {size: size_of::<GoaOAuthBasedSkeletonClass>(), alignment: align_of::<GoaOAuthBasedSkeletonClass>()}),
    ("GoaObjectIface", Layout {size: size_of::<GoaObjectIface>(), alignment: align_of::<GoaObjectIface>()}),
    ("GoaObjectManagerClient", Layout {size: size_of::<GoaObjectManagerClient>(), alignment: align_of::<GoaObjectManagerClient>()}),
    ("GoaObjectManagerClientClass", Layout {size: size_of::<GoaObjectManagerClientClass>(), alignment: align_of::<GoaObjectManagerClientClass>()}),
    ("GoaObjectProxy", Layout {size: size_of::<GoaObjectProxy>(), alignment: align_of::<GoaObjectProxy>()}),
    ("GoaObjectProxyClass", Layout {size: size_of::<GoaObjectProxyClass>(), alignment: align_of::<GoaObjectProxyClass>()}),
    ("GoaObjectSkeleton", Layout {size: size_of::<GoaObjectSkeleton>(), alignment: align_of::<GoaObjectSkeleton>()}),
    ("GoaObjectSkeletonClass", Layout {size: size_of::<GoaObjectSkeletonClass>(), alignment: align_of::<GoaObjectSkeletonClass>()}),
    ("GoaPasswordBasedIface", Layout {size: size_of::<GoaPasswordBasedIface>(), alignment: align_of::<GoaPasswordBasedIface>()}),
    ("GoaPasswordBasedProxy", Layout {size: size_of::<GoaPasswordBasedProxy>(), alignment: align_of::<GoaPasswordBasedProxy>()}),
    ("GoaPasswordBasedProxyClass", Layout {size: size_of::<GoaPasswordBasedProxyClass>(), alignment: align_of::<GoaPasswordBasedProxyClass>()}),
    ("GoaPasswordBasedSkeleton", Layout {size: size_of::<GoaPasswordBasedSkeleton>(), alignment: align_of::<GoaPasswordBasedSkeleton>()}),
    ("GoaPasswordBasedSkeletonClass", Layout {size: size_of::<GoaPasswordBasedSkeletonClass>(), alignment: align_of::<GoaPasswordBasedSkeletonClass>()}),
    ("GoaPhotosIface", Layout {size: size_of::<GoaPhotosIface>(), alignment: align_of::<GoaPhotosIface>()}),
    ("GoaPhotosProxy", Layout {size: size_of::<GoaPhotosProxy>(), alignment: align_of::<GoaPhotosProxy>()}),
    ("GoaPhotosProxyClass", Layout {size: size_of::<GoaPhotosProxyClass>(), alignment: align_of::<GoaPhotosProxyClass>()}),
    ("GoaPhotosSkeleton", Layout {size: size_of::<GoaPhotosSkeleton>(), alignment: align_of::<GoaPhotosSkeleton>()}),
    ("GoaPhotosSkeletonClass", Layout {size: size_of::<GoaPhotosSkeletonClass>(), alignment: align_of::<GoaPhotosSkeletonClass>()}),
    ("GoaPrintersIface", Layout {size: size_of::<GoaPrintersIface>(), alignment: align_of::<GoaPrintersIface>()}),
    ("GoaPrintersProxy", Layout {size: size_of::<GoaPrintersProxy>(), alignment: align_of::<GoaPrintersProxy>()}),
    ("GoaPrintersProxyClass", Layout {size: size_of::<GoaPrintersProxyClass>(), alignment: align_of::<GoaPrintersProxyClass>()}),
    ("GoaPrintersSkeleton", Layout {size: size_of::<GoaPrintersSkeleton>(), alignment: align_of::<GoaPrintersSkeleton>()}),
    ("GoaPrintersSkeletonClass", Layout {size: size_of::<GoaPrintersSkeletonClass>(), alignment: align_of::<GoaPrintersSkeletonClass>()}),
    ("GoaReadLaterIface", Layout {size: size_of::<GoaReadLaterIface>(), alignment: align_of::<GoaReadLaterIface>()}),
    ("GoaReadLaterProxy", Layout {size: size_of::<GoaReadLaterProxy>(), alignment: align_of::<GoaReadLaterProxy>()}),
    ("GoaReadLaterProxyClass", Layout {size: size_of::<GoaReadLaterProxyClass>(), alignment: align_of::<GoaReadLaterProxyClass>()}),
    ("GoaReadLaterSkeleton", Layout {size: size_of::<GoaReadLaterSkeleton>(), alignment: align_of::<GoaReadLaterSkeleton>()}),
    ("GoaReadLaterSkeletonClass", Layout {size: size_of::<GoaReadLaterSkeletonClass>(), alignment: align_of::<GoaReadLaterSkeletonClass>()}),
    ("GoaTicketingIface", Layout {size: size_of::<GoaTicketingIface>(), alignment: align_of::<GoaTicketingIface>()}),
    ("GoaTicketingProxy", Layout {size: size_of::<GoaTicketingProxy>(), alignment: align_of::<GoaTicketingProxy>()}),
    ("GoaTicketingProxyClass", Layout {size: size_of::<GoaTicketingProxyClass>(), alignment: align_of::<GoaTicketingProxyClass>()}),
    ("GoaTicketingSkeleton", Layout {size: size_of::<GoaTicketingSkeleton>(), alignment: align_of::<GoaTicketingSkeleton>()}),
    ("GoaTicketingSkeletonClass", Layout {size: size_of::<GoaTicketingSkeletonClass>(), alignment: align_of::<GoaTicketingSkeletonClass>()}),
    ("GoaTodoIface", Layout {size: size_of::<GoaTodoIface>(), alignment: align_of::<GoaTodoIface>()}),
    ("GoaTodoProxy", Layout {size: size_of::<GoaTodoProxy>(), alignment: align_of::<GoaTodoProxy>()}),
    ("GoaTodoProxyClass", Layout {size: size_of::<GoaTodoProxyClass>(), alignment: align_of::<GoaTodoProxyClass>()}),
    ("GoaTodoSkeleton", Layout {size: size_of::<GoaTodoSkeleton>(), alignment: align_of::<GoaTodoSkeleton>()}),
    ("GoaTodoSkeletonClass", Layout {size: size_of::<GoaTodoSkeletonClass>(), alignment: align_of::<GoaTodoSkeletonClass>()}),
];

const RUST_CONSTANTS: &[(&str, &str)] = &[
    ("(gint) GOA_ERROR_ACCOUNT_EXISTS", "3"),
    ("(gint) GOA_ERROR_DIALOG_DISMISSED", "2"),
    ("(gint) GOA_ERROR_FAILED", "0"),
    ("(gint) GOA_ERROR_NOT_AUTHORIZED", "4"),
    ("(gint) GOA_ERROR_NOT_SUPPORTED", "1"),
    ("GOA_ERROR_NUM_ENTRIES", "6"),
    ("(gint) GOA_ERROR_SSL", "5"),
];