def _parse_string(self, string, predefines=True):
		exts = []
		if predefines:
			for predefine in self._predefines:
				try:
					ast = py010parser.parse_string(predefine, parser=self._parser, cpp_path=self._cpp_path, cpp_args=self._cpp_args)
					exts += ast.ext
				except:
					pass

		res = py010parser.parse_string(string, parser=self._parser, cpp_path=self._cpp_path, cpp_args=self._cpp_args)
		res.ext = exts + res.ext

		return res

 def test_untypedefd_enum_as_typeid(self):
     res = parse_string("""
         enum <ulong> BLAH {
             BLAH1, BLAH2, BLAH3
         };
         local BLAH x;
     """, optimize=True)

 def test_basic(self):
     res = parse_string("""
         struct NAME {
                 int		stringLength;
                 char	name[stringLength];
         } name;
     """, optimize=True)

    def test_value_types(self):
        res = parse_string("""
            time_t var1;
            OLETIME var2;
            FILETIME var3;
            DOSTIME var4;
            DOSDATE var5;
            HFLOAT var6;
            hfloat var7;
            DOUBLE var8;
            double var9;
            FLOAT var10;
            float var11;
            __uint64 var12;
            QWORD var13;
            UINT64 var14;
            UQUAD var15;
            uquad var16;
            uint64 var17;
            __int64 var18;
            INT64 var19;
            QUAD var20;
            quad var21;
            int64 var22;
            DWORD var23;
            ULONG var24;
            UINT32 var25;
            UINT var26;
            ulong var27;
            uint32 var28;
            uint var29;
            LONG var30;
            INT32 var31;
            INT var32;
            long var33;
            int32 var34;
            int var35;
            WORD var36;
            UINT16 var37;
            USHORT var38;
            uint16 var39;
            ushort var40;
            INT16 var41;
            SHORT var42;
            int16 var43;
            short var44;
            UBYTE var45;
            UCHAR var46;
            ubyte var47;
            uchar var48;
            BYTE var49;
            CHAR var50;
            byte var51;
            char var52;

            string var53;
            wstring var54;
            wchar_t var55;
        """, optimize=True)

    def test_pass_by_reference(self):
        res = parse_string("""
        void some_function(int &num, int &num2) {
        }

        void some_function(int &num2) {
        }
        """, optimize=True)

 def test_declaration_in_if(self):
     res = parse_string("""
         if(1) {
             int c;
         } else {
             int b;
         }
     """, optimize=True)

 def test_struct_bitfield_with_metadata(self):
     res = parse_string("""
         typedef struct tgCifDirEntry {
                 uint16 storage_method : 2;
                 uint16 data_type : 3;
                 uint16 id_code : 11 <format=hex>;
         } CifDirEntry <read=ReadCifDirEntry>;
     """, optimize=True)

 def test_initializer_in_struct(self):
     res = parse_string("""
         local int b = 11;
         typedef struct BLAH {
             local int a = 10;
             int a:10;
         } blah;
     """, optimize=True)

 def test_declaration_in_struct(self):
     res = parse_string("""
         int c;
         switch(c) {
             case 1:
                 c++;
             case 2:
                 int c;
         }
     """, optimize=True)

    def test_block_item_at_root(self):
        # had to get rid of the default int ret val on functions
        # from pycparser

        res = parse_string("""
        int a = 10;
        void some_function(int num) {
            some_function();
        }
        a++;
        some_function();
        """, optimize=True)

    def test_struct_with_args_calling_not_func_decl2(self):
        res = parse_string("""
            typedef struct(int a) {
                char chars[a];
            } test_structure;

            local int size = 4;
            test_structure test(size); // this SHOULD NOT be a function declaration
        """, predefine_types=False)
        decl = res.children()[2][1]
        self.assertEqual(decl.type.__class__, c_ast.StructCallTypeDecl)
        self.assertEqual(decl.type.args.__class__, c_ast.ExprList)

    def test_bitfield_in_if(self):
        res = parse_string("""
            struct {
                if(1) {
                    int field1:16;
                    //int field1;
                }
            } blah;
        """, optimize=True, predefine_types=False)

        bitfield_decl = res.children()[0][1].type.type.children()[0][1].iftrue.children()[0][1]
        self.assertNotEqual(type(bitfield_decl), dict)

 def test_c_keywords_in_enum(self):
     res = parse_string("""
         enum <int> BLAH {
             goto,
             register,
             extern,
             goto,
             volatile,
             static
         };
         local BLAH x;
     """, optimize=True)

 def test_nested_bitfield_in_struct(self):
     res = parse_string("""
         typedef struct BLAH {
             int a;
             switch(a) {
                 case 10:
                     int b:10;
                 default:
                     int c:10;
             }
         } blah;
     """, optimize=True)

    def test_comment_single_line(self):
        res = parse_string("""
            // this is a comment
            int blah;
        """, optimize=True, predefine_types=False)

        self.assertEqual(len(res.children()), 1, "should only have one node in the AST")

        node = res.children()[0][1]
        self.assertEqual(node.name, "blah")
        self.assertEqual(node.type.declname, "blah")
        self.assertEqual(node.type.type.names, ["int"])

    def test_if_in_struct(self):
        res = parse_string("""
            struct BLAH {
                int a:1;
                int b:2;
                int c:29;

                if(hello) {
                    b = 10;
                }
            } blah;
            """, optimize=True)

    def test_structs_with_params_resetting1(self):
        res = parse_string("""
            typedef struct (int a, int b) {
                char chars1[a];
                char chars2[b];
            } blah;

            blah test(2, 3);
        """, optimize=True)

        res = parse_string("""
            typedef union {
                int some_int;
                struct {
                    char a;
                    char b;
                    char c;
                    char d;
                } some_chars;
            } blah;

            blah some_union;
        """, optimize=True)

    def test_basic_struct_typedef(self):
        res = parse_string("""
            typedef union {
                int some_int;
                struct {
                    char a;
                    char b;
                    char c;
                    char d;
                } some_chars;
            } blah;

            blah some_union;
        """, optimize=True, predefine_types=False)

    def test_switch_in_struct(self):
        res = parse_string("""
            struct BLAH {
                int c;

                switch(c) {
                    case 1:
                        int aa;
                    case 2:
                        int bb;
                    default:
                        int cc;
                }
            } blah;
            """, optimize=True)

    def test_basic_struct_with_args_calling(self):
        res = parse_string("""
            typedef struct (int a) {
                int blah;
            } SPECIAL_STRUCT;

            SPECIAL_STRUCT test(10);

            int blah() {
                return 10;
            }
        """, optimize=True, predefine_types=False)
        decl = res.children()[1][1]
        self.assertTrue(isinstance(decl.type, c_ast.StructCallTypeDecl))
        decl_args = decl.type.args.children()
        self.assertEqual(decl_args[0][1].value, "10")
        self.assertEqual(len(decl_args), 1)