Add Test.h again as UTF-8.

bindgen-integration/cpp/Test.h

@@ -0,0 +1,243 @@
+#include "stub.h" // this bad path is made valid by a `-I include` clang arg
+
+#pragma once
+
+#define TESTMACRO
+
+#define TESTMACRO_INTEGER 42
+#define TESTMACRO_STRING "Hello Preprocessor!"
+#define TESTMACRO_STRING_EXPANDED TESTMACRO_STRING
+#define TESTMACRO_CUSTOMINTKIND_PATH 123
+
+// The following two macros are parsed the same by cexpr, but are semantically
+// different.
+#define TESTMACRO_NONFUNCTIONAL (TESTMACRO_INTEGER)
+#define TESTMACRO_FUNCTIONAL_EMPTY(TESTMACRO_INTEGER)
+#define TESTMACRO_FUNCTIONAL_NONEMPTY(TESTMACRO_INTEGER)-TESTMACRO_INTEGER
+#define TESTMACRO_FUNCTIONAL_TOKENIZED(  a, b   ,c,d,e   ) a/b c    d ## e
+#define TESTMACRO_FUNCTIONAL_SPLIT(  a, \
+        b) b,\
+        a
+//#define TESTMACRO_INVALID("string") // A conforming preprocessor rejects this
+#define TESTMACRO_STRING_EXPR ("string")
+#define TESTMACRO_STRING_FUNC_NON_UTF8(x) (x "ÿÿ") /* invalid UTF-8 on purpose */
+
+enum {
+  MY_ANNOYING_MACRO =
+#define MY_ANNOYING_MACRO 1
+    MY_ANNOYING_MACRO,
+};
+
+class Test {
+  int m_int;
+  double m_double;
+public:
+  static const char* name();
+  Test(int foo);
+  Test(double foo);
+
+  static const int COUNTDOWN[];
+  static const int* COUNTDOWN_PTR;
+  static const int* countdown();
+};
+
+class ITest {
+  virtual void foo() = 0;
+};
+
+class VirtualDestructor {
+public:
+  static unsigned sDestructorCount;
+  virtual ~VirtualDestructor() = 0;
+};
+
+class InheritsFromVirtualDestructor final : public VirtualDestructor {
+public:
+  static unsigned sDestructorCount;
+  InheritsFromVirtualDestructor();
+  ~InheritsFromVirtualDestructor() final;
+};
+
+namespace testing {
+
+typedef Test TypeAlias;
+
+} // namespace testing
+
+typedef testing::TypeAlias TypeAlias;
+
+namespace bitfields {
+
+struct First {
+    unsigned char three_bits_byte_one : 3;
+    // This starts a new byte, leaving 5 bits unused.
+    unsigned char :0;
+
+    unsigned char six_bits_byte_two : 6;
+    unsigned char two_bits_byte_two : 2;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(unsigned char first,
+                unsigned char second,
+                unsigned char third);
+};
+
+struct Second {
+    int thirty_one_bits : 31;
+    bool one_bit : 1;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(int first,
+                bool second);
+};
+
+enum ItemKind {
+    ITEM_KIND_UNO = 0,
+    ITEM_KIND_DOS,
+    ITEM_KIND_TRES,
+};
+
+struct Third {
+    int flags : 28;
+    bool is_whatever : 1;
+    ItemKind kind : 3;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(int first, bool second, ItemKind third);
+};
+
+enum MyEnum {
+    ONE = 0,
+    TWO,
+    THREE,
+    FOUR,
+};
+
+struct Fourth {
+    MyEnum tag: 2;
+    unsigned long ptr: 48;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(MyEnum tag, unsigned long ptr);
+};
+
+struct Date2 {
+    unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+    unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+    unsigned short nMonth    : 5;    // 0..12  (5 bits)
+    unsigned short nYear     : 8;    // 0..100 (8 bits)
+    unsigned char byte : 8;
+
+    bool assert(unsigned short nWeekDay,
+                unsigned short nMonthDay,
+                unsigned short nMonth,
+                unsigned short nYear,
+                unsigned short byte);
+};
+
+
+struct Fifth {
+    unsigned short nWeekDay  : 3;    // 0..7   (3 bits)
+    unsigned short nMonthDay : 6;    // 0..31  (6 bits)
+    unsigned short nMonth    : 5;    // 0..12  (5 bits)
+    unsigned short nYear     : 8;    // 0..100 (8 bits)
+    unsigned char byte;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(unsigned short nWeekDay,
+                unsigned short nMonthDay,
+                unsigned short nMonth,
+                unsigned short nYear,
+                unsigned char byte);
+};
+
+struct Sixth {
+    unsigned char byte;
+    unsigned char nWeekDay  : 3;
+    unsigned char nMonth    : 5;
+    unsigned char nMonthDay : 6;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(unsigned char byte,
+                unsigned char nWeekDay,
+                unsigned char nMonth,
+                unsigned char nMonthDay);
+};
+
+struct Seventh {
+    bool first_one_bit : 1;
+    unsigned int second_thirty_bits : 30;
+    unsigned short third_two_bits : 2;
+    unsigned int fourth_thirty_bits : 30;
+    unsigned short fifth_two_bits : 2;
+    bool sixth_one_bit : 1;
+    unsigned int seventh_thirty_bits : 30;
+
+    /// Returns true if the bitfields match the arguments, false otherwise.
+    bool assert(bool first,
+                int second,
+                unsigned short third,
+                unsigned int fourth,
+                unsigned short fifth,
+                bool sixth,
+                int seventh);
+};
+
+} // namespace bitfields
+
+struct AutoRestoreBool {
+  bool* m_ptr;
+  bool m_value;
+
+  AutoRestoreBool(bool*);
+  ~AutoRestoreBool();
+};
+
+struct WithWChar {
+  wchar_t foo[30];
+};
+
+// The names of the following items are unprefixed by the parse callbacks.
+const int MY_PREFIXED_CONST_VALUE = 3;
+
+int my_prefixed_function_name();
+
+struct my_prefixed_bar {
+    int foo;
+};
+
+struct my_prefixed_foo {
+   my_prefixed_bar member;
+};
+
+enum my_prefixed_enum_to_be_constified {
+  ONE = 1,
+  TWO,
+  THREE,
+};
+
+struct my_prefixed_baz {
+  char foo[30];
+};
+
+template<typename T>
+struct my_prefixed_templated_foo {
+  T member;
+};
+
+my_prefixed_templated_foo<my_prefixed_baz> TEMPLATED_CONST_VALUE;
+
+void my_prefixed_function_to_remove();
+
+typedef union {
+  double v[4];
+} Coord;
+
+Coord coord(double x, double y, double z, double t);
+
+// Used to test custom derives on enum. See `test_custom_derive`.
+enum MyOrderedEnum {
+  MICRON,
+  METER,
+  LIGHTYEAR,
+};