Test suite changes, tests, pffft.

emilio · emilio · commit dfc1141ebad4 · 2016-11-15T21:04:36.000+01:00
diff --git a/libbindgen/src/codegen/helpers.rs b/libbindgen/src/codegen/helpers.rs
@@ -147,13 +147,21 @@ pub mod ast_ty {
 
     pub fn cstr_expr(mut string: String) -> P<ast::Expr> {
         string.push('\0');
-        aster::AstBuilder::new().expr().build_lit(
-            aster::AstBuilder::new().lit().byte_str(string))
+        aster::AstBuilder::new()
+            .expr()
+            .build_lit(aster::AstBuilder::new().lit().byte_str(string))
     }
 
     pub fn float_expr(f: f64) -> P<ast::Expr> {
         use aster::str::ToInternedString;
-        let interned_str = f.to_string().as_str().to_interned_string();
+        let mut string = f.to_string();
+
+        // So it gets properly recognised as a floating point constant.
+        if !string.contains('.') {
+            string.push('.');
+        }
+
+        let interned_str = string.as_str().to_interned_string();
         let kind = ast::LitKind::FloatUnsuffixed(interned_str);
         aster::AstBuilder::new().expr().lit().build_lit(kind)
     }
diff --git a/libbindgen/src/codegen/mod.rs b/libbindgen/src/codegen/mod.rs
@@ -318,8 +318,7 @@ impl CodeGenerator for Var {
                 .expr();
             let item = match *val {
                 VarType::Int(val) => {
-                    const_item
-                        .build(helpers::ast_ty::int_expr(val))
+                    const_item.build(helpers::ast_ty::int_expr(val))
                         .build(ty)
                 }
                 VarType::String(ref bytes) => {
@@ -332,8 +331,7 @@ impl CodeGenerator for Var {
 
                     match String::from_utf8(bytes.clone()) {
                         Ok(string) => {
-                            const_item
-                                .build(helpers::ast_ty::cstr_expr(string))
+                            const_item.build(helpers::ast_ty::cstr_expr(string))
                                 .build(quote_ty!(ctx.ext_cx(), &'static $ty))
                         }
                         Err(..) => {
@@ -344,8 +342,7 @@ impl CodeGenerator for Var {
                     }
                 }
                 VarType::Float(f) => {
-                    const_item
-                        .build(helpers::ast_ty::float_expr(f))
+                    const_item.build(helpers::ast_ty::float_expr(f))
                         .build(ty)
                 }
                 VarType::Char(c) => {
diff --git a/libbindgen/src/ir/item.rs b/libbindgen/src/ir/item.rs
@@ -840,11 +840,7 @@ impl ClangItemParser for Item {
                       ctx: &mut BindgenContext)
                       -> ItemId {
         let id = ctx.next_item_id();
-        Self::from_ty_or_ref_with_id(id,
-                                     ty,
-                                     location,
-                                     parent_id,
-                                     ctx)
+        Self::from_ty_or_ref_with_id(id, ty, location, parent_id, ctx)
     }
 
     /// Parse a C++ type. If we find a reference to a type that has not been
diff --git a/libbindgen/src/ir/var.rs b/libbindgen/src/ir/var.rs
@@ -8,7 +8,7 @@ use super::context::{BindgenContext, ItemId};
 use super::function::cursor_mangling;
 use super::int::IntKind;
 use super::item::Item;
-use super::ty::{TypeKind, FloatKind};
+use super::ty::{FloatKind, TypeKind};
 
 #[derive(Debug)]
 pub enum VarType {
@@ -135,7 +135,8 @@ impl ClangSubItemParser for Var {
                     EvalResult::Str(val) => {
                         let char_ty =
                             Item::builtin_type(TypeKind::Int(IntKind::U8),
-                                               true, ctx);
+                                               true,
+                                               ctx);
                         (TypeKind::Pointer(char_ty), VarType::String(val))
                     }
                     EvalResult::Int(Wrapping(value)) => {
@@ -202,7 +203,8 @@ impl ClangSubItemParser for Var {
                         .or_else(|| {
                             let tu = ctx.translation_unit();
                             get_integer_literal_from_cursor(&cursor, tu)
-                        }).map(VarType::Int)
+                        })
+                        .map(VarType::Int)
                 } else if is_float {
                     cursor.evaluate()
                         .as_double()
diff --git a/libbindgen/tests/expectations/tests/constant-evaluate.rs b/libbindgen/tests/expectations/tests/constant-evaluate.rs
@@ -10,6 +10,6 @@ pub const bar: _bindgen_ty_1 = _bindgen_ty_1::bar;
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum _bindgen_ty_1 { foo = 4, bar = 8, }
 pub const BAZ: ::std::os::raw::c_longlong = 24;
-pub const fuzz: f64 = 51;
+pub const fuzz: f64 = 51.;
 pub const BAZZ: ::std::os::raw::c_char = 53;
 pub const WAT: ::std::os::raw::c_char = 0;
diff --git a/libbindgen/tests/expectations/tests/macro_const.rs b/libbindgen/tests/expectations/tests/macro_const.rs
diff --git a/libbindgen/tests/expectations/tests/type_alias_partial_template_especialization.rs b/libbindgen/tests/expectations/tests/type_alias_partial_template_especialization.rs
diff --git a/libbindgen/tests/expectations/tests/type_alias_template_specialized.rs b/libbindgen/tests/expectations/tests/type_alias_template_specialized.rs
diff --git a/libbindgen/tests/headers/constant-evaluate.h b/libbindgen/tests/headers/constant-evaluate.h
@@ -0,0 +1,11 @@
+// bindgen-unstable
+
+enum {
+  foo = 4,
+  bar = 8,
+};
+
+const long long BAZ = (1 << foo) | bar;
+const double fuzz = (1 + 50.0f);
+const char BAZZ = '5';
+const char WAT = '\0';
diff --git a/libbindgen/tests/headers/macro_const.h b/libbindgen/tests/headers/macro_const.h
@@ -0,0 +1,7 @@
+#define foo "bar"
+#define CHAR 'b'
+#define CHARR '\0'
+#define FLOAT 5.09f
+#define FLOAT_EXPR (5 / 1000.0f)
+
+#define INVALID_UTF8 "\xf0\x28\x8c\x28"
diff --git a/libbindgen/tests/headers/type_alias_partial_template_especialization.hpp b/libbindgen/tests/headers/type_alias_partial_template_especialization.hpp
@@ -0,0 +1,7 @@
+// bindgen-flags: -- -std=c++14
+template <typename A> using MaybeWrapped = A;
+
+template<class T>
+class Rooted {
+  MaybeWrapped<T> ptr;
+};
diff --git a/libbindgen/tests/headers/type_alias_template_specialized.hpp b/libbindgen/tests/headers/type_alias_template_specialized.hpp
@@ -0,0 +1,9 @@
+// bindgen-flags: --whitelist-type Rooted -- -std=c++14
+
+template <typename a> using MaybeWrapped = a;
+class Rooted {
+  MaybeWrapped<int> ptr;
+};
+
+/// <div rustbindgen replaces="MaybeWrapped"></div>
+template <typename a> using replaces_MaybeWrapped = a;
diff --git a/libbindgen/tests/tests.rs b/libbindgen/tests/tests.rs
@@ -7,7 +7,7 @@ extern crate log;
 extern crate shlex;
 
 use std::fs;
-use std::io::{BufRead, BufReader, Error, ErrorKind, Read};
+use std::io::{BufRead, BufReader, Error, ErrorKind, Read, Write};
 use std::path::PathBuf;
 
 #[path="../../src/options.rs"]
@@ -35,11 +35,18 @@ fn compare_generated_header(header: &PathBuf,
     };
 
     let mut buffer = String::new();
-    let f = try!(fs::File::open(&expected));
-    let _ = try!(BufReader::new(f).read_to_string(&mut buffer));
+    {
+        if let Ok(expected_file) = fs::File::open(&expected) {
+            try!(BufReader::new(expected_file).read_to_string(&mut buffer));
+        }
+    }
 
     if output == buffer {
-        return Ok(());
+        if !output.is_empty() {
+            return Ok(());
+        }
+        return Err(Error::new(ErrorKind::Other,
+                              "Something's gone really wrong!"))
     }
 
     println!("diff expected generated");
@@ -53,21 +60,34 @@ fn compare_generated_header(header: &PathBuf,
             diff::Result::Right(r) => println!("+{}", r),
         }
     }
+
+    // Override the diff.
+    {
+        let mut expected_file = try!(fs::File::create(&expected));
+        try!(expected_file.write_all(output.as_bytes()));
+    }
+
     Err(Error::new(ErrorKind::Other, "Header and binding differ!"))
 }
 
 fn create_bindgen_builder(header: &PathBuf)
-                          -> Result<libbindgen::Builder, Error> {
+                          -> Result<Option<libbindgen::Builder>, Error> {
     let source = try!(fs::File::open(header));
     let reader = BufReader::new(source);
 
     // Scoop up bindgen-flags from test header
-    let line: String = try!(reader.lines().take(1).collect());
-    let flags: Vec<String> = if line.contains("bindgen-flags:") {
-        line.split("bindgen-flags:").last().and_then(shlex::split)
-    } else {
-        None
-    }.unwrap_or(Vec::with_capacity(2));
+    let mut flags = Vec::with_capacity(2);
+
+    for line in reader.lines().take(2) {
+        let line = try!(line);
+        if line.contains("bindgen-flags: ") {
+            let extra_flags = line.split("bindgen-flags: ")
+                .last().and_then(shlex::split).unwrap();
+            flags.extend(extra_flags.into_iter());
+        } else if line.contains("bindgen-unstable") && !cfg!(feature = "llvm_stable") {
+            return Ok(None)
+        }
+    }
 
     // Fool builder_from_flags() into believing it has real env::args_os...
     // - add "bindgen" as executable name 0th element
@@ -89,17 +109,27 @@ fn create_bindgen_builder(header: &PathBuf)
         .map(ToString::to_string)
         .chain(flags.into_iter());
 
-    builder_from_flags(args).map(|(builder, _)| builder.no_unstable_rust())
+    builder_from_flags(args)
+        .map(|(builder, _)| Some(builder.no_unstable_rust()))
 }
 
 macro_rules! test_header {
     ($function:ident, $header:expr) => (
         #[test]
         fn $function() {
             let header = PathBuf::from($header);
-            let _ = create_bindgen_builder(&header)
-                .and_then(|builder| compare_generated_header(&header, builder))
-                .map_err(|err| panic!(format!("{}", err)) );
+            let result = create_bindgen_builder(&header)
+                .and_then(|builder| {
+                    if let Some(builder) = builder {
+                        compare_generated_header(&header, builder)
+                    } else {
+                        Ok(())
+                    }
+                });
+
+            if let Err(err) = result {
+                panic!("{}", err);
+            }
         }
     )
 }

Original file line number	Diff line number	Diff line change
`@@ -318,8 +318,7 @@ impl CodeGenerator for Var {`
`318`	`318`	`.expr();`
`319`	`319`	`let item = match *val {`
`320`	`320`	`VarType::Int(val) => {`
`321`		`- const_item`
`322`		`- .build(helpers::ast_ty::int_expr(val))`
	`321`	`+ const_item.build(helpers::ast_ty::int_expr(val))`
`323`	`322`	`.build(ty)`
`324`	`323`	`}`
`325`	`324`	`VarType::String(ref bytes) => {`
`@@ -332,8 +331,7 @@ impl CodeGenerator for Var {`
`332`	`331`
`333`	`332`	`match String::from_utf8(bytes.clone()) {`
`334`	`333`	`Ok(string) => {`
`335`		`- const_item`
`336`		`- .build(helpers::ast_ty::cstr_expr(string))`
	`334`	`+ const_item.build(helpers::ast_ty::cstr_expr(string))`
`337`	`335`	`.build(quote_ty!(ctx.ext_cx(), &'static $ty))`
`338`	`336`	`}`
`339`	`337`	`Err(..) => {`
`@@ -344,8 +342,7 @@ impl CodeGenerator for Var {`
`344`	`342`	`}`
`345`	`343`	`}`
`346`	`344`	`VarType::Float(f) => {`
`347`		`- const_item`
`348`		`- .build(helpers::ast_ty::float_expr(f))`
	`345`	`+ const_item.build(helpers::ast_ty::float_expr(f))`
`349`	`346`	`.build(ty)`
`350`	`347`	`}`
`351`	`348`	`VarType::Char(c) => {`