gcc/testsuite/gcc.dg/tree-ssa/ssa-dse-10.c

   1 /* { dg-do compile } */
   2 /* { dg-options "-O -w -fdump-tree-dse-vops" } */
   3
   4 __extension__ typedef __SIZE_TYPE__ size_t;
   5 typedef struct _IO_FILE FILE;
   6 typedef struct
   7 {
   8 } __mbstate_t;
   9 typedef struct
  10 {
  11 } _G_fpos_t;
  12 typedef struct
  13 {
  14 };
  15 typedef int (*__gconv_trans_fct) (struct __gconv_step *,
  16       size_t *);
  17 typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
  18      size_t *);
  19 struct __gconv_trans_data
  20 {
  21 };
  22 struct __gconv_step_data
  23 {
  24 };
  25 typedef struct __gconv_info
  26 {
  27 } *__gconv_t;
  28 typedef union
  29 {
  30   struct
  31   {
  32   } __combined;
  33 } _G_iconv_t;
  34 typedef __builtin_va_list __gnuc_va_list;
  35 enum __codecvt_result
  36 {
  37   __codecvt_noconv
  38 };
  39 struct _IO_FILE {
  40 };
  41 vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
  42 {
  43 }
  44 putchar (int __c)
  45 {
  46 }
  47 fputc_unlocked (int __c, FILE *__stream)
  48 {
  49 }
  50 putc_unlocked (int __c, FILE *__stream)
  51 {
  52 }
  53 __attribute__ ((__nothrow__)) ferror_unlocked (FILE *__stream)
  54 {
  55 }
  56 extern int __sprintf_chk (char *__restrict __s, int __flag, size_t __slen,
  57      __gnuc_va_list __ap);
  58 gets (char *__str)
  59 {
  60 }
  61 extern char *__fgets_chk (char *__restrict __s, size_t __size, int __n,
  62      FILE *__restrict __stream) __attribute__ ((__warn_unused_result__));
  63 fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
  64 {
  65 }
  66 typedef void *LPVOID;
  67 typedef int BOOL, *PBOOL, *LPBOOL;
  68 typedef unsigned char BYTE, *PBYTE, *LPBYTE;
  69 typedef unsigned short WORD, *PWORD, *LPWORD;
  70 typedef unsigned int DWORD, *PDWORD, *LPDWORD;
  71 typedef struct _GUID
  72 {
  73 } GUID;
  74 enum
  75 {
  76   _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
  77 };
  78 extern char *__strtok_r (char *__restrict __s,
  79     __const char *__restrict __delim,
  80          char **__restrict __save_ptr)
  81      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2, 3)));
  82 __strcspn_c3 (__const char *__s, int __reject1, int __reject2,
  83        int __reject3)
  84 {
  85 }
  86 extern __inline size_t __strspn_c3 (__const char *__s, int __accept1,
  87         int __accept2, int __accept3);
  88 extern __inline size_t
  89 __strspn_c3 (__const char *__s, int __accept1, int __accept2, int __accept3)
  90 {
  91 }
  92 extern __inline char *__strpbrk_c2 (__const char *__s, int __accept1,
  93          int __accept2);
  94 extern __inline char *
  95 __strpbrk_c2 (__const char *__s, int __accept1, int __accept2)
  96 {
  97 }
  98 extern __inline char *__strpbrk_c3 (__const char *__s, int __accept1,
  99        int __accept3)
 100 {
 101 }
 102 __strtok_r_1c (char *__s, char __sep, char **__nextp)
 103 {
 104     {
 105    {
 106    }
 107     }
 108 }
 109 __strsep_1c (char **__s, char __reject)
 110 {
 111 }
 112 __strsep_2c (char **__s, char __reject1, char __reject2)
 113 {
 114     {
 115  {
 116  }
 117     }
 118 }
 119 extern __inline char *__strsep_3c (char **__s, char __reject1, char __reject2,
 120        char __reject3);
 121 extern __inline char *
 122 __strsep_3c (char **__s, char __reject1, char __reject2, char __reject3)
 123 {
 124     {
 125  {
 126      {
 127      }
 128  }
 129     }
 130 }
 131 __attribute__ ((__nothrow__)) __memcpy_ichk (void *__restrict __dest, __const void *__restrict __src, size_t __len)
 132 {
 133 }
 134 __attribute__ ((__nothrow__)) __memmove_ichk (void *__dest, __const void *__src, size_t __len)
 135 {
 136 }
 137 __attribute__ ((__nothrow__)) __strncpy_ichk (char *__restrict __dest, __const char *__restrict __src, size_t __len)
 138 {
 139 }
 140 __attribute__ ((__nothrow__)) stpncpy (char *__dest, __const char *__src, size_t __n)
 141 {
 142   if (__builtin_object_size (__dest, 2 > 1) != (size_t) -1
 143       && (!__builtin_constant_p (__n) || __n <= __builtin_object_size (__dest, 2 > 1)))
 144     return __stpncpy_chk (__dest, __src, __n, __builtin_object_size (__dest, 2 > 1));
 145 }
 146 __attribute__ ((__nothrow__)) __strncat_ichk (char *__restrict __dest, __const char *__restrict __src, size_t __len)
 147 {
 148 }
 149 typedef void *PVOID;
 150 typedef char CHAR, *PCHAR;
 151 typedef int LONG, *PLONG;
 152 typedef unsigned short WCHAR, *PWCHAR;
 153 typedef CHAR *PSTR, *LPSTR, *NPSTR;
 154 typedef const CHAR *PCSTR, *LPCSTR;
 155 typedef WCHAR *PWSTR, *LPWSTR, *NWPSTR;
 156 typedef LONG HRESULT;
 157 typedef struct _MEMORY_BASIC_INFORMATION
 158 {
 159 } SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;
 160 typedef enum _HEAP_INFORMATION_CLASS {
 161     HeapCompatibilityInformation,
 162 } HEAP_INFORMATION_CLASS;
 163 typedef struct _FLOATING_SAVE_AREA
 164 {
 165 } CONTEXT86;
 166 typedef struct _LDT_ENTRY {
 167     union {
 168         struct {
 169         } Bits;
 170     } HighWord;
 171 } LDT_ENTRY, *PLDT_ENTRY;
 172 typedef struct _EXCEPTION_RECORD
 173 {
 174 } EXCEPTION_RECORD, *PEXCEPTION_RECORD;
 175 typedef struct _EXCEPTION_POINTERS
 176 {
 177 } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
 178 typedef struct _NT_TIB
 179 {
 180  union {
 181  } ;
 182 } NT_TIB, *PNT_TIB;
 183 extern inline struct _TEB * __attribute__((__stdcall__)) NtCurrentTeb(void)
 184 {
 185 } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
 186 typedef struct _IMAGE_SYMBOL {
 187     union {
 188         struct {
 189         } FcnAry;
 190     } Section;
 191 } IMAGE_AUX_SYMBOL;
 192 typedef struct _IMAGE_EXPORT_DIRECTORY {
 193  union {
 194  } u1;
 195 } IMAGE_BOUND_FORWARDER_REF, *PIMAGE_BOUND_FORWARDER_REF;
 196 typedef struct _IMAGE_BASE_RELOCATION
 197 {
 198 } IMAGE_BASE_RELOCATION,*PIMAGE_BASE_RELOCATION;
 199 typedef struct _IMAGE_RELOCATION
 200 {
 201     union {
 202     } ;
 203 } IMAGE_RELOCATION, *PIMAGE_RELOCATION;
 204 typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER
 205 {
 206 } IMAGE_RESOURCE_DIRECTORY,*PIMAGE_RESOURCE_DIRECTORY;
 207 typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
 208  union {
 209   struct {
 210   } ;
 211                 struct {
 212   } ;
 213  } ;
 214 } IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;
 215 typedef enum ReplacesCorHdrNumericDefines
 216 {
 217     MAX_PACKAGE_NAME = 1024,
 218 } ReplacesCorHdrNumericDefines;
 219 typedef struct IMAGE_COR20_HEADER
 220 {
 221 } MESSAGE_RESOURCE_DATA,*PMESSAGE_RESOURCE_DATA;
 222 typedef PVOID PSECURITY_DESCRIPTOR;
 223 typedef enum _TOKEN_INFORMATION_CLASS {
 224   TokenUser = 1,
 225 } TOKEN_INFORMATION_CLASS;
 226 typedef struct _GENERIC_MAPPING {
 227 } ACL, *PACL;
 228 typedef struct _ACL_SIZE_INFORMATION
 229 {
 230 } ACL_SIZE_INFORMATION, *PACL_SIZE_INFORMATION;
 231 typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
 232 typedef struct {
 233 } SID_AND_ATTRIBUTES;
 234 typedef enum {
 235     WinBuiltinTerminalServerLicenseServersSid = 60
 236 } WELL_KNOWN_SID_TYPE;
 237 typedef struct _TOKEN_USER {
 238 } TOKEN_GROUPS, *PTOKEN_GROUPS;
 239 typedef union _LARGE_INTEGER {
 240     struct {
 241     };
 242 } LARGE_INTEGER, *PLARGE_INTEGER;
 243 typedef union _ULARGE_INTEGER {
 244     struct {
 245     };
 246 } LUID, *PLUID;
 247 typedef struct _LUID_AND_ATTRIBUTES {
 248 } LUID_AND_ATTRIBUTES, *PLUID_AND_ATTRIBUTES;
 249 typedef enum tagTOKEN_TYPE {
 250   TokenPrimary = 1,
 251 } SECURITY_IMPERSONATION_LEVEL, *PSECURITY_IMPERSONATION_LEVEL;
 252 typedef struct _SECURITY_QUALITY_OF_SERVICE {
 253 } QUOTA_LIMITS_EX, *PQUOTA_LIMITS_EX;
 254 typedef enum _LATENCY_TIME {
 255         VerifyProcessorPowerPolicyDc,
 256 } POWER_INFORMATION_LEVEL;
 257 typedef struct _ADMINISTRATOR_POWER_POLICY {
 258 } RTL_CRITICAL_SECTION_DEBUG, *PRTL_CRITICAL_SECTION_DEBUG, RTL_RESOURCE_DEBUG, *PRTL_RESOURCE_DEBUG;
 259 typedef struct _RTL_CRITICAL_SECTION {
 260 } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
 261 typedef struct _IO_COUNTERS {
 262 } OSVERSIONINFOA, *POSVERSIONINFOA, *LPOSVERSIONINFOA;
 263 typedef struct {
 264 } OSVERSIONINFOW, *POSVERSIONINFOW, *LPOSVERSIONINFOW, RTL_OSVERSIONINFOW, *PRTL_OSVERSIONINFOW;
 265 typedef struct {
 266 } OSVERSIONINFOEXA, *POSVERSIONINFOEXA, *LPOSVERSIONINFOEXA;
 267 typedef struct {
 268 } OSVERSIONINFOEXW, *POSVERSIONINFOEXW, *LPOSVERSIONINFOEXW, RTL_OSVERSIONINFOEXW, *PRTL_OSVERSIONINFOEXW;
 269 typedef struct tagSIZE
 270 {
 271 } POINT, *PPOINT, *LPPOINT;
 272 typedef struct _POINTL
 273 {
 274 } FILETIME, *PFILETIME, *LPFILETIME;
 275 typedef struct tagRECT
 276 {
 277   } ldiv_t;
 278 extern double strtod (__const char *__restrict __nptr,
 279         char **__restrict __endptr)
 280      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
 281 extern long int strtol (__const char *__restrict __nptr,
 282    char **__restrict __endptr, int __base)
 283      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
 284 extern long int __strtol_internal (__const char *__restrict __nptr,
 285        int __base, int __group)
 286      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
 287 extern unsigned long int __strtoul_internal (__const char *__restrict __nptr,
 288           int __base, int __group)
 289      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1))) __attribute__ ((__warn_unused_result__));
 290 extern __inline double
 291 __attribute__ ((__nothrow__)) strtod (__const char *__restrict __nptr, char **__restrict __endptr)
 292 {
 293 }
 294 extern __inline long int
 295 __attribute__ ((__nothrow__)) strtol (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
 296 {
 297 }
 298 __attribute__ ((__nothrow__)) strtoll (__const char *__restrict __nptr, char **__restrict __endptr, int __base)
 299 {
 300 }
 301 __attribute__ ((__nothrow__)) atoi (__const char *__nptr)
 302 {
 303 }
 304 typedef int int32_t __attribute__ ((__mode__ (__SI__)));
 305 typedef struct
 306   {
 307   };
 308 extern int random_r (struct random_data *__restrict __buf,
 309        int32_t *__restrict __result) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 310 struct drand48_data
 311   {
 312   };
 313 extern int drand48_r (struct drand48_data *__restrict __buffer,
 314         long int *__restrict __result)
 315      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 316 extern int mrand48_r (struct drand48_data *__restrict __buffer,
 317         long int *__restrict __result)
 318      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 319 extern int jrand48_r (unsigned short int __xsubi[3],
 320         long int *__restrict __result)
 321      __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (2)));
 322 extern int seed48_r (unsigned short int __seed16v[3],
 323        struct drand48_data *__buffer) __attribute__ ((__nothrow__)) __attribute__ ((__nonnull__ (1, 2)));
 324 extern char *qfcvt (long double __value, int __ndigit,
 325         size_t __resolvedlen) __attribute__ ((__nothrow__)) __attribute__ ((__warn_unused_result__));
 326 __attribute__ ((__nothrow__)) realpath (__const char *__restrict __name, char *__restrict __resolved)
 327 {
 328 }
 329 __attribute__ ((__nothrow__)) ptsname_r (int __fd, char *__buf, size_t __buflen)
 330 {
 331 }
 332 typedef struct _EXCEPTION_DEBUG_INFO {
 333 } EXCEPTION_DEBUG_INFO;
 334 typedef struct _CREATE_THREAD_DEBUG_INFO {
 335 } CREATE_THREAD_DEBUG_INFO;
 336 typedef struct _CREATE_PROCESS_DEBUG_INFO {
 337 } CREATE_PROCESS_DEBUG_INFO;
 338 typedef struct _EXIT_THREAD_DEBUG_INFO {
 339 } LOAD_DLL_DEBUG_INFO;
 340 typedef struct _UNLOAD_DLL_DEBUG_INFO {
 341 } RIP_INFO;
 342 typedef struct _DEBUG_EVENT {
 343     union {
 344     } u;
 345 } DEBUG_EVENT, *LPDEBUG_EVENT;
 346 typedef struct _OFSTRUCT
 347 {
 348 } WIN32_FIND_DATAA, *PWIN32_FIND_DATAA, *LPWIN32_FIND_DATAA;
 349 typedef struct _WIN32_FIND_DATAW
 350 {
 351 } WIN32_FIND_DATAW, *PWIN32_FIND_DATAW, *LPWIN32_FIND_DATAW;
 352 typedef enum _FINDEX_SEARCH_OPS
 353 {
 354  FindExSearchNameMatch,
 355 } FINDEX_SEARCH_OPS;
 356 typedef struct _PROCESS_HEAP_ENTRY
 357 {
 358     union {
 359         struct {
 360         } Block;
 361         struct {
 362         } Region;
 363     } ;
 364 } PROCESS_HEAP_ENTRY, *PPROCESS_HEAP_ENTRY, *LPPROCESS_HEAP_ENTRY;
 365 typedef struct tagMEMORYSTATUS
 366 {
 367 } MEMORYSTATUSEX, *LPMEMORYSTATUSEX;
 368 typedef struct _SYSTEMTIME{
 369         WORD wYear;
 370 } SYSTEMTIME, *PSYSTEMTIME, *LPSYSTEMTIME;
 371 typedef struct _OVERLAPPED {
 372         union {
 373             struct {
 374             } ;
 375         } ;
 376 } PROCESS_INFORMATION, *PPROCESS_INFORMATION, *LPPROCESS_INFORMATION;
 377 typedef struct _TIME_ZONE_INFORMATION{
 378 } TIME_ZONE_INFORMATION, *PTIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION;
 379 typedef struct _BY_HANDLE_FILE_INFORMATION
 380 {
 381 } ACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA, *PACTCTX_SECTION_KEYED_DATA_ASSEMBLY_METADATA;
 382 typedef struct tagACTCTX_SECTION_KEYED_DATA {
 383 } COMMTIMEOUTS,*LPCOMMTIMEOUTS;
 384 typedef enum _COMPUTER_NAME_FORMAT
 385 {
 386  ComputerNameNetBIOS,
 387 } COMPUTER_NAME_FORMAT;
 388 typedef struct tagHW_PROFILE_INFOA {
 389 } HW_PROFILE_INFOA, *LPHW_PROFILE_INFOA;
 390 typedef struct tagHW_PROFILE_INFOW {
 391 } HW_PROFILE_INFOW, *LPHW_PROFILE_INFOW;
 392 BOOL __attribute__((__stdcall__)) SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR,SECURITY_DESCRIPTOR_CONTROL,
 393                                                 SECURITY_DESCRIPTOR_CONTROL);
 394 typedef struct tagSYSLEVEL
 395 {
 396 } SYSLEVEL;
 397 static inline PVOID __attribute__((__stdcall__)) InterlockedCompareExchangePointer( PVOID volatile *dest, PVOID xchg, PVOID compare )
 398 {
 399 }
 400 static inline PVOID __attribute__((__stdcall__)) InterlockedExchangePointer( PVOID volatile *dest, PVOID val )
 401 {
 402 }
 403 typedef unsigned long HCRYPTPROV;
 404 typedef unsigned long HCRYPTKEY;
 405 typedef void *HCERTSTOREPROV;
 406 typedef struct _PROV_ENUMALGS {
 407 } PROV_ENUMALGS;
 408 typedef struct _HMAC_INFO {
 409 } HMAC_INFO, *PHMAC_INFO;
 410 typedef struct _CRYPTOAPI_BLOB {
 411   DWORD cbData;
 412   BYTE* pbData;
 413 } CRYPT_INTEGER_BLOB, *PCRYPT_INTEGER_BLOB,
 414   CRYPT_OBJID_BLOB, *PCRYPT_OBJID_BLOB,
 415   CERT_NAME_BLOB, *PCERT_NAME_BLOB,
 416   CERT_RDN_VALUE_BLOB, *PCERT_RDN_VALUE_BLOB,
 417   CRYPT_DER_BLOB, *PCRYPT_DER_BLOB,
 418   CRYPT_ATTR_BLOB, *PCRYPT_ATTR_BLOB;
 419 typedef struct _CRYPTPROTECT_PROMPTSTRUCT{
 420 } CRYPTPROTECT_PROMPTSTRUCT, *PCRYPTPROTECT_PROMPTSTRUCT;
 421 typedef struct _CRYPT_ALGORITHM_IDENTIFIER {
 422   LPSTR pszObjId;
 423   CRYPT_OBJID_BLOB Parameters;
 424 } CRYPT_ALGORITHM_IDENTIFIER, *PCRYPT_ALGORITHM_IDENTIFIER;
 425 typedef struct _CRYPT_ATTRIBUTE_TYPE_VALUE {
 426 } CRYPT_ATTRIBUTE_TYPE_VALUE, *PCRYPT_ATTRIBUTE_TYPE_VALUE;
 427 typedef struct _PUBLICKEYSTRUC {
 428 } BLOBHEADER, PUBLICKEYSTRUC;
 429 typedef struct _RSAPUBKEY {
 430     DWORD magic;
 431     DWORD pubexp;
 432 } RSAPUBKEY;
 433 typedef struct _CRYPT_BIT_BLOB {
 434     DWORD cbData;
 435     BYTE *pbData;
 436     DWORD cUnusedBits;
 437 } CRYPT_BIT_BLOB, *PCRYPT_BIT_BLOB;
 438 typedef struct _CRYPT_KEY_PROV_PARAM {
 439 } CRYPT_KEY_PROV_PARAM, *PCRYPT_KEY_PROV_PARAM;
 440 typedef struct _CRYPT_KEY_PROV_INFO {
 441     CRYPT_ALGORITHM_IDENTIFIER Algorithm;
 442     CRYPT_BIT_BLOB PublicKey;
 443 } CERT_PUBLIC_KEY_INFO, *PCERT_PUBLIC_KEY_INFO;
 444 typedef struct _CERT_EXTENSION {
 445     LPSTR pszObjId;
 446     CRYPT_OBJID_BLOB Value;
 447 } CERT_EXTENSION, *PCERT_EXTENSION;
 448 typedef struct _CERT_EXTENSIONS {
 449     DWORD cExtension;
 450     PCERT_EXTENSION rgExtension;
 451 } CERT_EXTENSIONS, *PCERT_EXTENSIONS;
 452 typedef struct _CERT_INFO {
 453     CRYPT_INTEGER_BLOB SerialNumber;
 454     CERT_NAME_BLOB Subject;
 455     CERT_PUBLIC_KEY_INFO SubjectPublicKeyInfo;
 456 } CERT_INFO, *PCERT_INFO;
 457 typedef struct _CERT_RDN_ATTR {
 458     LPSTR pszObjId;
 459     CERT_RDN_VALUE_BLOB Value;
 460 } CERT_RDN_ATTR, *PCERT_RDN_ATTR;
 461 typedef struct _CERT_RDN {
 462 } CERT_RDN, *PCERT_RDN;
 463 typedef struct _CERT_NAME_INFO {
 464     DWORD cRDN;
 465 } CERT_NAME_INFO, *PCERT_NAME_INFO;
 466 typedef struct _CERT_NAME_VALUE {
 467     DWORD dwValueType;
 468     CERT_RDN_VALUE_BLOB Value;
 469 } CERT_NAME_VALUE, *PCERT_NAME_VALUE;
 470 typedef struct _CERT_ENCRYPTED_PRIVATE_KEY_INFO {
 471     CERT_NAME_BLOB CertIssuer;
 472 } CERT_AUTHORITY_KEY_ID_INFO, *PCERT_AUTHORITY_KEY_ID_INFO;
 473 typedef struct _CERT_PRIVATE_KEY_VALIDITY {
 474 } CERT_OTHER_NAME, *PCERT_OTHER_NAME;
 475 typedef struct _CERT_ALT_NAME_ENTRY {
 476     DWORD dwAltNameChoice;
 477     union {
 478         LPWSTR pwszURL;
 479     } ;
 480 } CERT_ALT_NAME_ENTRY, *PCERT_ALT_NAME_ENTRY;
 481 typedef struct _CERT_ALT_NAME_INFO {
 482     DWORD cAltEntry;
 483     PCERT_ALT_NAME_ENTRY rgAltEntry;
 484 } CERT_ALT_NAME_INFO, *PCERT_ALT_NAME_INFO;
 485 typedef struct _CERT_BASIC_CONSTRAINTS_INFO {
 486     CERT_NAME_BLOB *rgSubtreesConstraint;
 487 } CERT_BASIC_CONSTRAINTS_INFO, *PCERT_BASIC_CONSTRAINTS_INFO;
 488 typedef struct _CERT_BASIC_CONSTRAINTS2_INFO {
 489 } CERT_BASIC_CONSTRAINTS2_INFO, *PCERT_BASIC_CONSTRAINTS2_INFO;
 490 typedef struct _CERT_POLICY_QUALIFIER_INFO {
 491 } CERT_POLICY_QUALIFIER_INFO, *PCERT_POLICY_QUALIFIER_INFO;
 492 typedef struct _CERT_POLICY_QUALIFIER_NOTICE_REFERENCE {
 493 } CERT_POLICY_QUALIFIER_NOTICE_REFERENCE,
 494  *PCERT_POLICY_QUALIFIER_NOTICE_REFERENCE;
 495 typedef struct _CERT_POLICY_QUALIFIER_USER_NOTICE {
 496     DWORD cValue;
 497     PCRYPT_DER_BLOB rgValue;
 498 } CRYPT_SEQUENCE_OF_ANY, *PCRYPT_SEQUENCE_OF_ANY;
 499 typedef struct _CERT_AUTHORITY_KEY_ID2_INFO {
 500     PCERT_INFO pCertInfo;
 501 } CERT_CONTEXT, *PCERT_CONTEXT;
 502 typedef const CERT_CONTEXT *PCCERT_CONTEXT;
 503 typedef struct _CRL_ENTRY {
 504 } CRL_ENTRY, *PCRL_ENTRY;
 505 typedef struct _CRL_INFO {
 506     DWORD cCRLEntry;
 507     DWORD cExtension;
 508 } CRL_INFO, *PCRL_INFO;
 509 typedef struct _CRL_DIST_POINT_NAME {
 510     DWORD dwDistPointNameChoice;
 511     union {
 512     } ;
 513 } CRL_DIST_POINT_NAME, *PCRL_DIST_POINT_NAME;
 514 typedef struct _CRL_DIST_POINT {
 515     CRL_DIST_POINT_NAME DistPointName;
 516     CRYPT_BIT_BLOB ReasonFlags;
 517     CERT_ALT_NAME_INFO CRLIssuer;
 518 } CRL_DIST_POINT, *PCRL_DIST_POINT;
 519 typedef struct _CRL_DIST_POINTS_INFO {
 520     DWORD cDistPoint;
 521     PCRL_DIST_POINT rgDistPoint;
 522 } CRL_DIST_POINTS_INFO, *PCRL_DIST_POINTS_INFO;
 523 typedef struct _CRL_ISSUING_DIST_POINT {
 524     BOOL fOnlyContainsUserCerts;
 525 } CRL_ISSUING_DIST_POINT, *PCRL_ISSUING_DIST_POINT;
 526 typedef struct _CERT_GENERAL_SUBTREE {
 527 } CRYPT_ATTRIBUTE, *PCRYPT_ATTRIBUTE;
 528 typedef struct _CRYPT_ATTRIBUTES {
 529 } CRYPT_ATTRIBUTES, *PCRYPT_ATTRIBUTES;
 530 typedef struct _CERT_REQUEST_INFO {
 531     DWORD dwVersion;
 532     CRYPT_ALGORITHM_IDENTIFIER SignatureAlgorithm;
 533     CRYPT_BIT_BLOB Signature;
 534 } CERT_SIGNED_CONTENT_INFO, *PCERT_SIGNED_CONTENT_INFO;
 535 typedef struct _CRL_CONTEXT {
 536 } CRL_CONTEXT, *PCRL_CONTEXT;
 537 typedef struct _VTableProvStruc {
 538 } CTL_CONTEXT, *PCTL_CONTEXT;
 539 typedef struct _CRYPT_TIME_STAMP_REQUEST_INFO {
 540 } CERT_REVOCATION_STATUS, *PCERT_REVOCATION_STATUS;
 541 typedef struct _CERT_TRUST_STATUS {
 542 } CERT_SYSTEM_STORE_RELOCATE_PARA, *PCERT_SYSTEM_STORE_RELOCATE_PARA;
 543 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_ENUM_SYSTEM_STORE_LOCATION)(
 544  void *pvArg);
 545 typedef struct _CRYPT_ENCODE_PARA {
 546 } CERT_STORE_PROV_INFO, *PCERT_STORE_PROV_INFO;
 547 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_DLL_OPEN_STORE_PROV_FUNC)(
 548  DWORD dwFlags, DWORD dwCtrlType, void const *pvCtrlPara);
 549 typedef struct _CERT_STORE_PROV_FIND_INFO {
 550 } CERT_STORE_PROV_FIND_INFO, *PCERT_STORE_PROV_FIND_INFO;
 551 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_FIND_CERT)(HCERTSTOREPROV hStoreProv,
 552  DWORD dwFlags, void **ppvStoreProvFindInfo, PCCERT_CONTEXT *ppProvCertContext);
 553 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_FREE_FIND_CERT)(
 554  DWORD dwFlags, void *pvData, DWORD *pcbData);
 555 typedef BOOL (__attribute__((__stdcall__)) *PFN_CERT_STORE_PROV_GET_CTL_PROPERTY)(
 556  DWORD dwFlags, void *pvData);
 557 typedef struct _CERT_CREATE_CONTEXT_PARA {
 558 } CRYPT_OID_FUNC_ENTRY, *PCRYPT_OID_FUNC_ENTRY;
 559 typedef BOOL (__attribute__((__stdcall__)) *PFN_CRYPT_ENUM_OID_FUNC)(DWORD dwEncodingType,
 560  const DWORD rgcbValueData[], void *pvArg);
 561 typedef struct _CRYPT_OID_INFO {
 562     union {
 563     } ;
 564 } CRYPT_OID_INFO, *PCRYPT_OID_INFO;
 565 typedef const CRYPT_OID_INFO CCRYPT_OID_INFO, *PCCRYPT_OID_INFO;
 566 typedef BOOL (__attribute__((__stdcall__)) *PFN_CRYPT_ENUM_OID_INFO)(PCCRYPT_OID_INFO pInfo,
 567  void *pvArg);
 568 typedef struct _CRYPT_SIGN_MESSAGE_PARA {
 569 } CRYPT_HASH_MESSAGE_PARA, *PCRYPT_HASH_MESSAGE_PARA;
 570 typedef struct _CRYPT_KEY_SIGN_MESSAGE_PARA {
 571 } CRYPT_URL_INFO, *PCRYPT_URL_INFO;
 572 typedef void (__attribute__((__stdcall__)) *PFN_CRYPT_ASYNC_PARAM_FREE_FUNC)(LPSTR pszParamOid,
 573  LPVOID pvParam);
 574 typedef struct _CRYPT_CREDENTIALS {
 575 } CRYPT_CREDENTIALS, *PCRYPT_CREDENTIALS;
 576 typedef struct _CRYPT_PASSWORD_CREDENTIALSA {
 577 } CRYPT_PASSWORD_CREDENTIALSW, *PCRYPT_PASSWORD_CREDENTIALSW;
 578 typedef struct _CRYPT_RETRIEVE_AUX_INFO {
 579 } CRYPT_RETRIEVE_AUX_INFO, *PCRYPT_RETRIEVE_AUX_INFO;
 580 typedef struct _CERT_CHAIN_ENGINE_CONFIG
 581 {
 582 } CERT_CHAIN_ENGINE_CONFIG, *PCERT_CHAIN_ENGINE_CONFIG;
 583 BOOL __attribute__((__stdcall__)) CryptExportPublicKeyInfoEx(HCRYPTPROV hCryptProv, DWORD dwKeySpec,
 584  DWORD dwCertEncodingType, LPSTR pszPublicKeyObjId, DWORD dwFlags,
 585  void *pvAuxInfo, PCERT_PUBLIC_KEY_INFO pInfo, DWORD *pcbInfo);
 586 BOOL __attribute__((__stdcall__)) CryptImportPublicKeyInfo(HCRYPTPROV hCryptProv,
 587  PCRYPT_RETRIEVE_AUX_INFO pAuxInfo);
 588 struct encodedInt
 589 {
 590     int val;
 591     const BYTE *encoded;
 592 };
 593 static const struct encodedInt ints[] = {
 594 };
 595 struct encodedBigInt
 596 {
 597     const BYTE *val;
 598     const BYTE *encoded;
 599 };
 600 static const struct encodedBigInt bigInts[] = {
 601 };
 602 static const struct encodedBigInt bigUInts[] = {
 603 };
 604 static void test_encodeInt(DWORD dwEncoding)
 605 {
 606     DWORD bufSize = 0;
 607     int i;
 608     BOOL ret;
 609     CRYPT_INTEGER_BLOB blob;
 610     BYTE *buf = ((void *)0);
 611     ret = CryptEncodeObjectEx(0, ((LPCSTR)27), &ints[0].val, 0, ((void *)0), ((void *)0),
 612      "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
 613     {
 614         ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)27), &ints[i].val,
 615          0x08000, ((void *)0), &buf, &bufSize);
 616         {
 617             (winetest_set_location("encode.c", 119), 0) ? 0 : winetest_ok(buf[0] == 2, "Got unexpected type %d for integer (expected 2)\n",
 618              buf[1], ints[i].encoded[1]);
 619         }
 620         ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)28), &blob,
 621          0, ((void *)0), ((void *)0), &bufSize);
 622         {
 623         }
 624         ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)38), &blob,
 625          0x08000, ((void *)0), &buf, &bufSize);
 626         {
 627             (winetest_set_location("encode.c", 187), 0) ? 0 : winetest_ok(buf[1] == bigUInts[i].encoded[1], "Got length %d, expected %d\n",
 628              buf[1], bigUInts[i].encoded[1]);
 629             (winetest_set_location("encode.c", 189), 0) ? 0 : winetest_ok(!memcmp(buf + 1, bigUInts[i].encoded + 1,
 630              bigUInts[i].encoded[1] + 1),
 631              "Encoded value didn't match expected\n");
 632         }
 633     }
 634 }
 635 static void test_decodeInt(DWORD dwEncoding)
 636 {
 637     static const BYTE longForm[] = { 2, 0x81, 0x01, 0x01 };
 638     BYTE *buf = ((void *)0);
 639     DWORD bufSize = 0;
 640     int i;
 641     BOOL ret;
 642     ret = CryptDecodeObjectEx(3, ((LPCSTR)27), (BYTE *)&ints[0].encoded,
 643      ints[0].encoded[1] + 2, 0, ((void *)0), ((void *)0), &bufSize);
 644     (winetest_set_location("encode.c", 225), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x80093104L),
 645      "Expected CRYPT_E_ASN1_BADTAG, got %d\n", GetLastError());
 646     {
 647         {
 648             (winetest_set_location("encode.c", 249), 0) ? 0 : winetest_ok(!memcmp(buf, &ints[i].val, bufSize), "Expected %d, got %d\n",
 649              ints[i].val, *(int *)buf);
 650         }
 651     }
 652     {
 653         ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)28),
 654          &bufSize);
 655         {
 656             CRYPT_INTEGER_BLOB *blob = (CRYPT_INTEGER_BLOB *)buf;
 657             (winetest_set_location("encode.c", 296), 0) ? 0 : winetest_ok(blob->cbData == strlen((const char*)bigUInts[i].val),
 658              "Unexpected value\n");
 659         }
 660     }
 661     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)28), longForm,
 662      sizeof(longForm), 0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
 663     {
 664     }
 665 }
 666 static const struct encodedInt enums[] = {
 667 };
 668 static const LPCSTR enumeratedTypes[] = { ((LPCSTR)29),
 669  "2.5.29.21" };
 670 static void test_encodeEnumerated(DWORD dwEncoding)
 671 {
 672     DWORD i, j;
 673     {
 674         {
 675             BOOL ret;
 676             DWORD bufSize = 0;
 677             ret = CryptEncodeObjectEx(dwEncoding, enumeratedTypes[i],
 678              &bufSize);
 679             {
 680             }
 681         }
 682     }
 683 }
 684 static void test_decodeEnumerated(DWORD dwEncoding)
 685 {
 686     DWORD i, j;
 687     {
 688         {
 689             BOOL ret;
 690             DWORD bufSize = sizeof(int);
 691             int val;
 692             ret = CryptDecodeObjectEx(dwEncoding, enumeratedTypes[i],
 693              (BYTE *)&val, &bufSize);
 694             (winetest_set_location("encode.c", 403), 0) ? 0 : winetest_ok(val == enums[j].val, "Unexpected value %d, expected %d\n",
 695              val, enums[j].val);
 696         }
 697     }
 698 }
 699 struct encodedFiletime
 700 {
 701     SYSTEMTIME sysTime;
 702     const BYTE *encodedTime;
 703 };
 704 static void testTimeEncoding(DWORD dwEncoding, LPCSTR structType,
 705  const struct encodedFiletime *time)
 706 {
 707 }
 708 static void testTimeDecoding(DWORD dwEncoding, LPCSTR structType,
 709  const struct encodedFiletime *time)
 710 {
 711     BOOL ret;
 712     if (structType == ((LPCSTR)30) ||
 713      (time->sysTime.wYear >= 1950 && time->sysTime.wYear <= 2050))
 714     {
 715     }
 716         (winetest_set_location("encode.c", 476), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x8009310BL),
 717          "Expected CRYPT_E_ASN1_BADTAG, got 0x%08x\n", GetLastError());
 718 }
 719 static const BYTE bin22[] = {
 720     0x18,0x0f,'2','1','4','5','0','6','0','6','1','6','1','0','0','0','Z'};
 721 static const struct encodedFiletime times[] = {
 722 };
 723 static void test_encodeFiletime(DWORD dwEncoding)
 724 {
 725     {
 726     }
 727 }
 728 static const BYTE bin23[] = {
 729     0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','0','0','0','Z'};
 730 static const BYTE bin24[] = {
 731     0x18,0x13,'1','9','4','5','0','6','0','6','1','6','1','0','0','0','.','9','9','9','Z'};
 732 static const BYTE bin26[] = {
 733     0x17,0x0b,'4','5','0','6','0','6','1','6','1','0','Z'};
 734 static const BYTE bin33[] = {
 735     0x17,0x0f,'4','5','0','6','0','6','1','6','1','0','-','0','1','0','0'};
 736 static const BYTE bin35[] = {
 737     0x17,0x08, '4','5','0','6','0','6','1','6'};
 738 static const BYTE bin38[] = {
 739     0x18,0x08, '2','1','4','5','0','6','0','6'};
 740 static void test_decodeFiletime(DWORD dwEncoding)
 741 {
 742     static const struct encodedFiletime otherTimes[] = {
 743     };
 744     static const unsigned char *bogusTimes[] = {
 745     };
 746     {
 747     }
 748 }
 749 static const char commonName[] = "Juan Lang";
 750 static const char surName[] = "Lang";
 751 static const BYTE emptySequence[] = { 0x30, 0 };
 752 static const BYTE emptyRDNs[] = { 0x30, 0x02, 0x31, 0 };
 753 static const BYTE twoRDNs[] = {
 754     0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0};
 755 static const BYTE encodedTwoRDNs[] = {
 756 };
 757 static const BYTE us[] = { 0x55, 0x53 };
 758 static const BYTE minnesota[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f,
 759  0x6f, 0x6c, 0x69, 0x73 };
 760 static const BYTE codeweavers[] = { 0x43, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x61,
 761  0x76, 0x65, 0x72, 0x73 };
 762 static const BYTE wine[] = { 0x57, 0x69, 0x6e, 0x65, 0x20, 0x44, 0x65, 0x76,
 763  0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74 };
 764 static const BYTE aric[] = { 0x61, 0x72, 0x69, 0x63, 0x40, 0x63, 0x6f, 0x64,
 765  0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63, 0x6f, 0x6d };
 766 static CHAR oid_us[] = "2.5.4.6",
 767             oid_aric[] = "1.2.840.113549.1.9.1";
 768 static CERT_RDN_ATTR rdnAttrs[] = { { oid_us, 4, { sizeof(us), (LPBYTE)us } },
 769                                            { oid_aric, 7, { sizeof(aric), (LPBYTE)aric } } };
 770 static const BYTE encodedRDNAttrs[] = {
 771 };
 772 static void test_encodeName(DWORD dwEncoding)
 773 {
 774     CERT_NAME_INFO info;
 775     static CHAR oid_common_name[] = "2.5.4.3",
 776                 oid_sur_name[] = "2.5.4.4";
 777     BOOL ret;
 778     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), ((void *)0),
 779      "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
 780     {
 781     }
 782     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), &info,
 783      "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
 784     {
 785     }
 786     {
 787     }
 788     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)7), &info,
 789      "Expected E_INVALIDARG, got %08x\n", GetLastError());
 790     {
 791     }
 792 }
 793 static WCHAR commonNameW[] = { 'J','u','a','n',' ','L','a','n','g',0 };
 794 static const BYTE twoRDNsNoNull[] = {
 795  0x20,0x4c,0x61,0x6e,0x67 };
 796 static const BYTE anyType[] = {
 797  0x61,0x4c,0x67,0x6e };
 798 static void test_encodeUnicodeName(DWORD dwEncoding)
 799 {
 800     BOOL ret;
 801     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)20), ((void *)0),
 802      "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
 803     {
 804     }
 805 }
 806 static void compareNameValues(const CERT_NAME_VALUE *expected,
 807  const CERT_NAME_VALUE *got)
 808 {
 809     (winetest_set_location("encode.c", 913), 0) ? 0 : winetest_ok(got->dwValueType == expected->dwValueType,
 810      expected->dwValueType, got->Value.cbData, expected->Value.cbData);
 811         (winetest_set_location("encode.c", 920), 0) ? 0 : winetest_ok(!memcmp(got->Value.pbData, expected->Value.pbData,
 812          (((got->Value.cbData) < (expected->Value.cbData)) ? (got->Value.cbData) : (expected->Value.cbData))),
 813          "String type %d: unexpected value\n", expected->dwValueType);
 814 }
 815 static void compareRDNAttrs(const CERT_RDN_ATTR *expected,
 816  const CERT_RDN_ATTR *got)
 817 {
 818     {
 819         {
 820             (winetest_set_location("encode.c", 934), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (got->pszObjId) && __builtin_constant_p (expected->pszObjId) && (__s1_len = strlen (got->pszObjId), __s2_len = strlen (expected->pszObjId), (!((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__builtin_constant_p (got->pszObjId) && ((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) && (__s1_len = strlen (got->pszObjId), __s1_len < 4) ? (__builtin_constant_p (expected->pszObjId) && ((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (expected->pszObjId); register int __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (got->pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (expected->pszObjId) && ((size_t)(const void *)((expected->pszObjId) + 1) - (size_t)(const void *)(expected->pszObjId) == 1) && (__s2_len = strlen (expected->pszObjId), __s2_len < 4) ? (__builtin_constant_p (got->pszObjId) && ((size_t)(const void *)((got->pszObjId) + 1) - (size_t)(const void *)(got->pszObjId) == 1) ? __builtin_strcmp (got->pszObjId, expected->pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (got->pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (expected->pszObjId))[3]); } } __result; }))) : __builtin_strcmp (got->pszObjId, expected->pszObjId)))); }),
 821              expected->pszObjId);
 822         }
 823     }
 824 }
 825 static void compareRDNs(const CERT_RDN *expected, const CERT_RDN *got)
 826 {
 827     {
 828     }
 829 }
 830 static void compareNames(const CERT_NAME_INFO *expected,
 831  const CERT_NAME_INFO *got)
 832 {
 833     (winetest_set_location("encode.c", 959), 0) ? 0 : winetest_ok(got->cRDN == expected->cRDN, "Expected %d RDNs, got %d\n",
 834      expected->cRDN, got->cRDN);
 835     {
 836     }
 837 }
 838 static void test_decodeName(DWORD dwEncoding)
 839 {
 840     BYTE *buf = ((void *)0);
 841     DWORD bufSize = 0;
 842     BOOL ret;
 843     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)7), emptySequence,
 844      (BYTE *)&buf, &bufSize);
 845     {
 846         static CHAR oid_sur_name[] = "2.5.4.4",
 847                     oid_common_name[] = "2.5.4.3";
 848         CERT_RDN_ATTR attrs[] = {
 849          { oid_sur_name, 4, { sizeof(surName),
 850           (BYTE *)commonName } },
 851         };
 852     }
 853     {
 854     }
 855 }
 856 static void test_decodeUnicodeName(DWORD dwEncoding)
 857 {
 858     BYTE *buf = ((void *)0);
 859     DWORD bufSize = 0;
 860     BOOL ret;
 861     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), emptySequence,
 862      (BYTE *)&buf, &bufSize);
 863     {
 864     }
 865     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), emptyRDNs,
 866      (BYTE *)&buf, &bufSize);
 867     {
 868     }
 869     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)20), twoRDNsNoNull,
 870      (BYTE *)&buf, &bufSize);
 871     {
 872         static CHAR oid_sur_name[] = "2.5.4.4",
 873                     oid_common_name[] = "2.5.4.3";
 874         CERT_RDN_ATTR attrs[] = {
 875          { oid_sur_name, 4,
 876          { lstrlenW(commonNameW) * sizeof(WCHAR), (BYTE *)commonNameW } },
 877         };
 878     }
 879 }
 880 struct EncodedNameValue
 881 {
 882     CERT_NAME_VALUE value;
 883 };
 884 static const char bogusPrintable[] = "~";
 885 static const BYTE bin42[] = { 0x16,0x02,0x80,0x00 };
 886 static const BYTE bin43[] = { 0x13,0x02,0x7e,0x00 };
 887 static BYTE octetCommonNameValue[] = {
 888  0x12,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
 889 static BYTE printableCommonNameValue[] = {
 890  0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
 891 static BYTE t61CommonNameValue[] = {
 892  0x14,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
 893 static BYTE graphicCommonNameValue[] = {
 894  0x61,0x00,0x6e,0x00,0x67,0x00,0x00 };
 895 static BYTE utf8CommonNameValue[] = {
 896  0x0c,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00 };
 897 static struct EncodedNameValue nameValues[] = {
 898  { { 5, { sizeof(commonName), (BYTE *)commonName } },
 899      sizeof(bin42) },
 900  { { 4, { sizeof(bogusPrintable),
 901      (BYTE *)bogusPrintable } }, bin43, sizeof(bin43) },
 902 };
 903 static void test_encodeNameValue(DWORD dwEncoding)
 904 {
 905     DWORD size = 0, i;
 906     BOOL ret;
 907     CERT_NAME_VALUE value = { 0, { 0, ((void *)0) } };
 908     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)6), &value,
 909      "Expected CRYPT_E_ASN1_CHOICE, got %08x\n", GetLastError());
 910     {
 911         (winetest_set_location("encode.c", 1209), 0) ? 0 : winetest_ok(size == sizeof(printableCommonNameValue), "Unexpected size %d\n",
 912          "Unexpected encoding\n");
 913         ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)6),
 914          nameValues[i].value.dwValueType, GetLastError());
 915         {
 916         }
 917     }
 918 }
 919 static void test_decodeNameValue(DWORD dwEncoding)
 920 {
 921     int i;
 922     BYTE *buf = ((void *)0);
 923     DWORD bufSize = 0;
 924     BOOL ret;
 925     {
 926         ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)6),
 927          (BYTE *)&buf, &bufSize);
 928         {
 929             compareNameValues(&nameValues[i].value,
 930              (const CERT_NAME_VALUE *)buf);
 931         }
 932     }
 933 }
 934 static const BYTE emptyURL[] = { 0x30, 0x02, 0x86, 0x00 };
 935 static const WCHAR url[] = { 'h','t','t','p',':','/','/','w','i','n','e',
 936  0x6f, 0x72, 0x67 };
 937 static const BYTE encodedIPAddr[] = { 0x30, 0x06, 0x87, 0x04, 0x7f, 0x00, 0x00,
 938  0x01 };
 939 static void test_encodeAltName(DWORD dwEncoding)
 940 {
 941     CERT_ALT_NAME_INFO info = { 0 };
 942     BYTE *buf = ((void *)0);
 943     DWORD size = 0;
 944     BOOL ret;
 945     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)12), &info,
 946      0x08000, ((void *)0), (BYTE *)&buf, &size);
 947     {
 948     }
 949     {
 950     }
 951 }
 952 static void test_decodeAltName(DWORD dwEncoding)
 953 {
 954     BOOL ret;
 955     DWORD bufSize = 0;
 956     CERT_ALT_NAME_INFO *info;
 957     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)12),
 958      &bufSize);
 959     {
 960         (winetest_set_location("encode.c", 1392), 0) ? 0 : winetest_ok(info->cAltEntry == 0, "Expected 0 entries, got %d\n",
 961          info->cAltEntry);
 962     }
 963     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)12), emptyURL,
 964      &bufSize);
 965     {
 966     }
 967 }
 968 struct encodedBits
 969 {
 970     const BYTE *encoded;
 971     DWORD cbDecoded;
 972 };
 973 static const struct encodedBits bits[] = {
 974 };
 975 static void test_encodeBits(DWORD dwEncoding)
 976 {
 977     DWORD i;
 978     {
 979         DWORD bufSize = 0;
 980         {
 981             (winetest_set_location("encode.c", 1802), 0) ? 0 : winetest_ok(bufSize == bits[i].encoded[1] + 2,
 982              bits[i].encoded[1] + 2);
 983         }
 984     }
 985 }
 986 static void test_decodeBits(DWORD dwEncoding)
 987 {
 988     DWORD i;
 989     {
 990         {
 991             CRYPT_BIT_BLOB *blob;
 992             (winetest_set_location("encode.c", 1835), 0) ? 0 : winetest_ok(blob->cbData == bits[i].cbDecoded,
 993                  "Unexpected value\n");
 994         }
 995     }
 996     {
 997     }
 998 }
 999 struct Constraints2
1000 {
1001     CERT_BASIC_CONSTRAINTS2_INFO info;
1002 };
1003 static const struct Constraints2 constraints2[] = {
1004 };
1005 static const BYTE encodedDomainName[] = { 0x30, 0x2b, 0x31, 0x29, 0x30, 0x11,
1006  0x16, 0x06, 0x77, 0x69, 0x6e, 0x65, 0x68, 0x71 };
1007 static void test_encodeBasicConstraints(DWORD dwEncoding)
1008 {
1009     CERT_NAME_BLOB nameBlob = { sizeof(encodedDomainName),
1010      (LPBYTE)encodedDomainName };
1011     {
1012         {
1013         }
1014     }
1015     {
1016     }
1017 }
1018 static const unsigned char encodedCommonName[] = {
1019     0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0};
1020 static void test_decodeBasicConstraints(DWORD dwEncoding)
1021 {
1022     static const BYTE inverted[] = { 0x30, 0x06, 0x02, 0x01, 0x01, 0x01, 0x01,
1023      0xff };
1024     DWORD i;
1025     BOOL ret;
1026     BYTE *buf = ((void *)0);
1027     DWORD bufSize = 0;
1028     {
1029         ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)15),
1030          0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
1031         {
1032             CERT_BASIC_CONSTRAINTS2_INFO *info =
1033             (winetest_set_location("encode.c", 1984), 0) ? 0 : winetest_ok(!memcmp(info, &constraints2[i].info, sizeof(*info)),
1034              "Unexpected value for item %d\n", i);
1035         }
1036     }
1037     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)15),
1038      (BYTE *)&buf, &bufSize);
1039     {
1040         CERT_BASIC_CONSTRAINTS_INFO *info = (CERT_BASIC_CONSTRAINTS_INFO *)buf;
1041         {
1042             (winetest_set_location("encode.c", 2043), 0) ? 0 : winetest_ok(info->rgSubtreesConstraint[0].cbData ==
1043              info->rgSubtreesConstraint[0].cbData);
1044             (winetest_set_location("encode.c", 2046), 0) ? 0 : winetest_ok(!memcmp(info->rgSubtreesConstraint[0].pbData, encodedDomainName,
1045              sizeof(encodedDomainName)), "Unexpected value\n");
1046         }
1047     }
1048 }
1049 static const BYTE modulus1[] = { 0,0,0,1,1,1,1,1 };
1050 struct EncodedRSAPubKey
1051 {
1052     const BYTE *modulus;
1053     size_t decodedModulusLen;
1054 };
1055 struct EncodedRSAPubKey rsaPubKeys[] = {
1056 };
1057 static void test_encodeRsaPublicKey(DWORD dwEncoding)
1058 {
1059     BYTE toEncode[sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) + sizeof(modulus1)];
1060     RSAPUBKEY *rsaPubKey = (RSAPUBKEY *)(toEncode + sizeof(BLOBHEADER));
1061     BOOL ret;
1062     BYTE *buf = ((void *)0);
1063     DWORD bufSize = 0, i;
1064     ret = CryptDecodeObjectEx(dwEncoding, "1.2.840.113549.1.1.1",
1065      "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
1066     {
1067         {
1068             (winetest_set_location("encode.c", 2210), 0) ? 0 : winetest_ok(bufSize >= sizeof(BLOBHEADER) + sizeof(RSAPUBKEY) +
1069              "Wrong size %d\n", bufSize);
1070             (winetest_set_location("encode.c", 2223), 0) ? 0 : winetest_ok(rsaPubKey->magic == 0x31415352,
1071              rsaPubKey->pubexp);
1072             (winetest_set_location("encode.c", 2229), 0) ? 0 : winetest_ok(!memcmp(buf + sizeof(BLOBHEADER) + sizeof(RSAPUBKEY),
1073              rsaPubKeys[i].modulus, rsaPubKeys[i].decodedModulusLen),
1074              "Unexpected modulus\n");
1075         }
1076     }
1077 }
1078 static const BYTE intSequence[] = { 0x30, 0x1b, 0x02, 0x01, 0x01, 0x02, 0x01,
1079  0x02, 0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
1080 static const BYTE mixedSequence[] = { 0x30, 0x27, 0x17, 0x0d, 0x30, 0x35, 0x30,
1081  0xff, 0x7f, 0x02, 0x04, 0xba, 0xdd, 0xf0, 0x0d };
1082 static void test_encodeSequenceOfAny(DWORD dwEncoding)
1083 {
1084     BYTE *buf = ((void *)0);
1085     {
1086     }
1087     {
1088         (winetest_set_location("encode.c", 2284), 0) ? 0 : winetest_ok(!memcmp(buf, mixedSequence, mixedSequence[1] + 2),
1089          "Unexpected value\n");
1090     }
1091 }
1092 static void test_decodeSequenceOfAny(DWORD dwEncoding)
1093 {
1094     BOOL ret;
1095     BYTE *buf = ((void *)0);
1096     DWORD bufSize = 0;
1097     {
1098         {
1099         }
1100     }
1101     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)34), mixedSequence,
1102      &bufSize);
1103     {
1104         CRYPT_SEQUENCE_OF_ANY *seq = (CRYPT_SEQUENCE_OF_ANY *)buf;
1105         (winetest_set_location("encode.c", 2324), 0) ? 0 : winetest_ok(seq->cValue == sizeof(ints) / sizeof(ints[0]),
1106          seq->rgValue[0].cbData);
1107         (winetest_set_location("encode.c", 2330), 0) ? 0 : winetest_ok(!memcmp(seq->rgValue[0].pbData, times[0].encodedTime,
1108          times[0].encodedTime[1] + 2), "Unexpected value\n");
1109     }
1110 }
1111 struct encodedExtensions
1112 {
1113     CERT_EXTENSIONS exts;
1114 };
1115 static BYTE noncrit_ext_data[] = { 0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1116 static CHAR oid_basic_constraints2[] = "2.5.29.19";
1117 static CERT_EXTENSION nonCriticalExt =
1118  { oid_basic_constraints2, 0, { 8, noncrit_ext_data } };
1119 static const struct encodedExtensions exts[] = {
1120 };
1121 static void test_encodeExtensions(DWORD dwEncoding)
1122 {
1123     DWORD i;
1124     {
1125         {
1126         }
1127     }
1128     {
1129         BOOL ret;
1130         BYTE *buf = ((void *)0);
1131         DWORD bufSize = 0;
1132         ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)5),
1133          ((void *)0), (BYTE *)&buf, &bufSize);
1134         {
1135             CERT_EXTENSIONS *ext = (CERT_EXTENSIONS *)buf;
1136             DWORD j;
1137             (winetest_set_location("encode.c", 2405), 0) ? 0 : winetest_ok(ext->cExtension == exts[i].exts.cExtension,
1138              ext->cExtension);
1139             {
1140                 (winetest_set_location("encode.c", 2410), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (ext->rgExtension[j].pszObjId) && __builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && (__s1_len = strlen (ext->rgExtension[j].pszObjId), __s2_len = strlen (exts[i].exts.rgExtension[j].pszObjId), (!((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__builtin_constant_p (ext->rgExtension[j].pszObjId) && ((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) && (__s1_len = strlen (ext->rgExtension[j].pszObjId), __s1_len < 4) ? (__builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && ((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId); register int __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (exts[i].exts.rgExtension[j].pszObjId) && ((size_t)(const void *)((exts[i].exts.rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(exts[i].exts.rgExtension[j].pszObjId) == 1) && (__s2_len = strlen (exts[i].exts.rgExtension[j].pszObjId), __s2_len < 4) ? (__builtin_constant_p (ext->rgExtension[j].pszObjId) && ((size_t)(const void *)((ext->rgExtension[j].pszObjId) + 1) - (size_t)(const void *)(ext->rgExtension[j].pszObjId) == 1) ? __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (ext->rgExtension[j].pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (exts[i].exts.rgExtension[j].pszObjId))[3]); } } __result; }))) : __builtin_strcmp (ext->rgExtension[j].pszObjId, exts[i].exts.rgExtension[j].pszObjId)))); }),
1141                  ext->rgExtension[j].pszObjId);
1142                 (winetest_set_location("encode.c", 2415), 0) ? 0 : winetest_ok(!memcmp(ext->rgExtension[j].Value.pbData,
1143                  exts[i].exts.rgExtension[j].Value.cbData),
1144                  "Unexpected value\n");
1145             }
1146         }
1147     }
1148 }
1149 struct encodedPublicKey
1150 {
1151     const BYTE *encoded;
1152     const BYTE *encodedNoNull;
1153 };
1154 static const BYTE aKey[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
1155  0xe, 0xf };
1156 static const BYTE params[] = { 0x02, 0x01, 0x01 };
1157 static const unsigned char bin66[] = {
1158     0x30,0x0f,0x30,0x0a,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x05,0x00,0x03,0x01,0x00};
1159 static const unsigned char bin67[] = {
1160     0x30,0x0d,0x30,0x08,0x06,0x06,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x03,0x01,0x00};
1161 static const unsigned char bin69[] = {
1162     0x0f};
1163 static unsigned char bin72[] = { 0x05,0x00};
1164 static CHAR oid_bogus[] = "1.2.3",
1165             oid_rsa[] = "1.2.840.113549";
1166 static const struct encodedPublicKey pubKeys[] = {
1167  { { { oid_rsa, { 0, ((void *)0) } }, { 0, ((void *)0), 0} },
1168   { { oid_rsa, { 2, bin72 } }, { sizeof(aKey), (BYTE *)aKey, 0} } },
1169  { { { oid_rsa, { sizeof(params), (BYTE *)params } }, { sizeof(aKey),
1170   (BYTE *)aKey, 0 } } },
1171 };
1172 static void test_encodePublicKeyInfo(DWORD dwEncoding)
1173 {
1174     DWORD i;
1175     {
1176         BOOL ret;
1177         BYTE *buf = ((void *)0);
1178         DWORD bufSize = 0;
1179         ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)8),
1180          &bufSize);
1181         {
1182             (winetest_set_location("encode.c", 2505), 0) ? 0 : winetest_ok(bufSize == pubKeys[i].encoded[1] + 2 ||
1183              pubKeys[i].encodedNoNull[1] + 2, bufSize);
1184                 (winetest_set_location("encode.c", 2510), 0) ? 0 : winetest_ok(!memcmp(buf, pubKeys[i].encoded, pubKeys[i].encoded[1] + 2),
1185                  "Unexpected value\n");
1186                 (winetest_set_location("encode.c", 2513), 0) ? 0 : winetest_ok(!memcmp(buf, pubKeys[i].encodedNoNull,
1187                  pubKeys[i].encodedNoNull[1] + 2), "Unexpected value\n");
1188         }
1189     }
1190 }
1191 static void comparePublicKeyInfo(const CERT_PUBLIC_KEY_INFO *expected,
1192  const CERT_PUBLIC_KEY_INFO *got)
1193 {
1194     (winetest_set_location("encode.c", 2523), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p (expected->Algorithm.pszObjId) && __builtin_constant_p (got->Algorithm.pszObjId) && (__s1_len = strlen (expected->Algorithm.pszObjId), __s2_len = strlen (got->Algorithm.pszObjId), (!((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__builtin_constant_p (expected->Algorithm.pszObjId) && ((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) && (__s1_len = strlen (expected->Algorithm.pszObjId), __s1_len < 4) ? (__builtin_constant_p (got->Algorithm.pszObjId) && ((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (got->Algorithm.pszObjId); register int __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (got->Algorithm.pszObjId) && ((size_t)(const void *)((got->Algorithm.pszObjId) + 1) - (size_t)(const void *)(got->Algorithm.pszObjId) == 1) && (__s2_len = strlen (got->Algorithm.pszObjId), __s2_len < 4) ? (__builtin_constant_p (expected->Algorithm.pszObjId) && ((size_t)(const void *)((expected->Algorithm.pszObjId) + 1) - (size_t)(const void *)(expected->Algorithm.pszObjId) == 1) ? __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) (expected->Algorithm.pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (got->Algorithm.pszObjId))[3]); } } __result; }))) : __builtin_strcmp (expected->Algorithm.pszObjId, got->Algorithm.pszObjId)))); }),
1195      expected->PublicKey.cbData, got->PublicKey.cbData);
1196         (winetest_set_location("encode.c", 2538), 0) ? 0 : winetest_ok(!memcmp(expected->PublicKey.pbData, got->PublicKey.pbData,
1197          got->PublicKey.cbData), "Unexpected public key value\n");
1198 }
1199 static void test_decodePublicKeyInfo(DWORD dwEncoding)
1200 {
1201     static const BYTE bogusPubKeyInfo[] = { 0x30, 0x22, 0x30, 0x0d, 0x06, 0x06,
1202      0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };
1203     BOOL ret;
1204     BYTE *buf = ((void *)0);
1205     DWORD bufSize = 0;
1206     {
1207         ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)8),
1208          0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
1209         {
1210         }
1211     }
1212     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)8),
1213      "Expected CRYPT_E_ASN1_CORRUPT, got %08x\n", GetLastError());
1214 }
1215 static const BYTE v1Cert[] = { 0x30, 0x33, 0x02, 0x00, 0x30, 0x02, 0x06, 0x00,
1216  0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
1217 static const BYTE v2Cert[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x01, 0x02,
1218  0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
1219 static const BYTE v3Cert[] = { 0x30, 0x38, 0xa0, 0x03, 0x02, 0x01, 0x02, 0x02,
1220  0x30, 0x5a, 0x30, 0x07, 0x30, 0x02, 0x06, 0x00, 0x03, 0x01, 0x00 };
1221 static const BYTE v1CertWithConstraints[] = { 0x30, 0x4b, 0x02, 0x00, 0x30,
1222  0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
1223 static const BYTE v1CertWithSerial[] = { 0x30, 0x4c, 0x02, 0x01, 0x01, 0x30,
1224  0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
1225 static const BYTE bigCert[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
1226  0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 };
1227 static void test_encodeCertToBeSigned(DWORD dwEncoding)
1228 {
1229     BOOL ret;
1230     BYTE *buf = ((void *)0);
1231     DWORD size = 0;
1232     CERT_INFO info = { 0 };
1233     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)2), ((void *)0),
1234      0x08000, ((void *)0), (BYTE *)&buf, &size);
1235     {
1236     }
1237     {
1238     }
1239     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)2), &info,
1240      0x08000, ((void *)0), (BYTE *)&buf, &size);
1241     {
1242     }
1243     {
1244     }
1245 }
1246 static void test_decodeCertToBeSigned(DWORD dwEncoding)
1247 {
1248     static const BYTE *corruptCerts[] = { v1Cert, v2Cert, v3Cert,
1249      v1CertWithConstraints, v1CertWithSerial };
1250     BOOL ret;
1251     (winetest_set_location("encode.c", 2727), 0) ? 0 : winetest_ok(!ret && GetLastError() == ((HRESULT)0x80093102L),
1252      "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
1253     {
1254         ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)2),
1255          "Expected CRYPT_E_ASN1_CORRUPT, got %08x\n", GetLastError());
1256     }
1257     {
1258     }
1259 }
1260 static const BYTE hash[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xa, 0xb, 0xc, 0xd,
1261  0xe, 0xf };
1262 static const BYTE signedBigCert[] = {
1263  0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00 };
1264 static void test_encodeCert(DWORD dwEncoding)
1265 {
1266     CERT_SIGNED_CONTENT_INFO info = { { sizeof(bigCert), (BYTE *)bigCert },
1267      { ((void *)0), { 0, ((void *)0) } }, { sizeof(hash), (BYTE *)hash, 0 } };
1268     BOOL ret;
1269     BYTE *buf = ((void *)0);
1270     DWORD bufSize = 0;
1271     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)1), &info,
1272      0x08000, ((void *)0), (BYTE *)&buf, &bufSize);
1273     {
1274     }
1275 }
1276 static void test_decodeCert(DWORD dwEncoding)
1277 {
1278     BOOL ret;
1279     BYTE *buf = ((void *)0);
1280     DWORD size = 0;
1281     {
1282     }
1283     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)2), signedBigCert,
1284      sizeof(signedBigCert), 0x08000, ((void *)0), (BYTE *)&buf, &size);
1285     {
1286         CERT_INFO *info = (CERT_INFO *)buf;
1287         (winetest_set_location("encode.c", 2843), 0) ? 0 : winetest_ok(info->SerialNumber.cbData == 1,
1288          *info->SerialNumber.pbData);
1289         (winetest_set_location("encode.c", 2852), 0) ? 0 : winetest_ok(info->Subject.cbData == sizeof(encodedCommonName),
1290          "Wrong size %d\n", info->Subject.cbData);
1291         (winetest_set_location("encode.c", 2854), 0) ? 0 : winetest_ok(!memcmp(info->Subject.pbData, encodedCommonName,
1292          info->Subject.cbData), "Unexpected subject\n");
1293     }
1294 }
1295 static const BYTE distPointWithUrl[] = { 0x30, 0x19, 0x30, 0x17, 0xa0, 0x15,
1296  0x6e, 0x65, 0x68, 0x71, 0x2e, 0x6f, 0x72, 0x67 };
1297 static const BYTE distPointWithIssuer[] = { 0x30, 0x17, 0x30, 0x15, 0xa2, 0x13,
1298  0x2e, 0x6f, 0x72, 0x67 };
1299 static const BYTE crlReason = 1 |
1300  3;
1301 static void test_encodeCRLDistPoints(DWORD dwEncoding)
1302 {
1303     CRL_DIST_POINTS_INFO xxxinfo = { 0 };
1304     CRL_DIST_POINT point = { { 0 } };
1305     BOOL ret;
1306     BYTE *buf = ((void *)0);
1307     DWORD size = 0;
1308     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)35), &xxxinfo,
1309      "Expected E_INVALIDARG, got %08x\n", GetLastError());
1310     xxxinfo.cDistPoint = 1;
1311     xxxinfo.rgDistPoint = &point;
1312     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)35), &xxxinfo,
1313      0x08000, ((void *)0), (BYTE *)&buf, &size);
1314     point.ReasonFlags.cbData = sizeof(crlReason);
1315     {
1316     }
1317 }
1318 static void test_decodeCRLDistPoints(DWORD dwEncoding)
1319 {
1320     BOOL ret;
1321     BYTE *buf = ((void *)0);
1322     DWORD size = 0;
1323     PCERT_ALT_NAME_ENTRY entry;
1324     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)35),
1325      (BYTE *)&buf, &size);
1326     {
1327         (winetest_set_location("encode.c", 3065), 0) ? 0 : winetest_ok(entry->dwAltNameChoice == 7,
1328          "Expected CERT_ALT_NAME_URL, got %d\n", entry->dwAltNameChoice);
1329     }
1330 }
1331 static const BYTE urlIDP[] = { 0x30,0x17,0xa0,0x15,0xa0,0x13,0x86,0x11,0x68,
1332  0x67 };
1333 static void test_encodeCRLIssuingDistPoint(DWORD dwEncoding)
1334 {
1335     BOOL ret;
1336     BYTE *buf = ((void *)0);
1337     DWORD size = 0;
1338     CRL_ISSUING_DIST_POINT point = { { 0 } };
1339     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)54), ((void *)0),
1340      "Expected STATUS_ACCESS_VIOLATION, got %08x\n", GetLastError());
1341     {
1342     }
1343     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)54), &point,
1344      0x08000, ((void *)0), (BYTE *)&buf, &size);
1345     {
1346     }
1347     {
1348     }
1349 }
1350 static void compareAltNameEntry(const CERT_ALT_NAME_ENTRY *expected,
1351  const CERT_ALT_NAME_ENTRY *got)
1352 {
1353     (winetest_set_location("encode.c", 3149), 0) ? 0 : winetest_ok(expected->dwAltNameChoice == got->dwAltNameChoice,
1354      got->dwAltNameChoice);
1355     {
1356         {
1357             (winetest_set_location("encode.c", 3161), 0) ? 0 : winetest_ok((!(*expected).pwszURL && !(*got).pwszURL) ||
1358                !lstrcmpW((*expected).pwszURL, (*got).pwszURL), "Unexpected name\n");
1359         }
1360     }
1361 }
1362 static void compareAltNameInfo(const CERT_ALT_NAME_INFO *expected,
1363  const CERT_ALT_NAME_INFO *got)
1364 {
1365 }
1366 static const BYTE v1CRL[] = { 0x30, 0x15, 0x30, 0x02, 0x06, 0x00, 0x18, 0x0f,
1367  0x30, 0x5a };
1368 static const BYTE v2CRL[] = { 0x30, 0x18, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06,
1369  0x30, 0x30, 0x30, 0x30, 0x5a };
1370 static const BYTE v1CRLWithIssuer[] = { 0x30, 0x2c, 0x30, 0x02, 0x06, 0x00,
1371  0x5a };
1372 static const BYTE v1CRLWithIssuerAndEmptyEntry[] = { 0x30, 0x43, 0x30, 0x02,
1373  0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
1374 static const BYTE v1CRLWithIssuerAndEntry[] = { 0x30, 0x44, 0x30, 0x02, 0x06,
1375  0x30, 0x31, 0x30, 0x31, 0x30, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x5a };
1376 static const BYTE v1CRLWithEntryExt[] = { 0x30,0x5a,0x30,0x02,0x06,0x00,0x30,
1377  0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1378 static const BYTE v1CRLWithExt[] = { 0x30,0x5c,0x30,0x02,0x06,0x00,0x30,0x15,
1379  0xff,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1380 static const BYTE v2CRLWithExt[] = { 0x30,0x5c,0x02,0x01,0x01,0x30,0x02,0x06,
1381  0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1382 static const BYTE v2CRLWithIssuingDistPoint[] = { 0x30,0x5c,0x02,0x01,0x01,
1383  0x03,0x55,0x1d,0x13,0x04,0x08,0x30,0x06,0x01,0x01,0xff,0x02,0x01,0x01 };
1384 static void test_encodeCRLToBeSigned(DWORD dwEncoding)
1385 {
1386     BOOL ret;
1387     BYTE *buf = ((void *)0);
1388     DWORD size = 0;
1389     CRL_INFO info = { 0 };
1390     {
1391         (winetest_set_location("encode.c", 3386), 0) ? 0 : winetest_ok(size == sizeof(v1CRLWithIssuerAndEntry),
1392          "Wrong size %d\n", size);
1393     }
1394     {
1395     }
1396     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)3), &info,
1397      0x08000, ((void *)0), (BYTE *)&buf, &size);
1398     {
1399     }
1400     {
1401     }
1402 }
1403 static const BYTE verisignCRL[] = { 0x30, 0x82, 0x01, 0xb1, 0x30, 0x82, 0x01,
1404 0x61,0xc0,0x99,0x16,0x71,0x05,0xb6,0x25,0x14,0x64,0x4f,0x30 };
1405 static void test_decodeCRLToBeSigned(DWORD dwEncoding)
1406 {
1407     BOOL ret;
1408     BYTE *buf = ((void *)0);
1409     DWORD size = 0, i;
1410     {
1411     }
1412     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1413      (BYTE *)&buf, &size);
1414     {
1415         CRL_INFO *info = (CRL_INFO *)buf;
1416         (winetest_set_location("encode.c", 4016), 0) ? 0 : winetest_ok(info->cCRLEntry == 0, "Expected 0 CRL entries, got %d\n",
1417          "Unexpected issuer\n");
1418     }
1419     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1420      0x08000, ((void *)0), (BYTE *)&buf, &size);
1421     {
1422         CRL_INFO *info = (CRL_INFO *)buf;
1423         (winetest_set_location("encode.c", 4041), 0) ? 0 : winetest_ok(info->cCRLEntry == 1, "Expected 1 CRL entries, got %d\n",
1424          "Unexpected issuer\n");
1425     }
1426     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1427      0x08000, ((void *)0), (BYTE *)&buf, &size);
1428     {
1429         CRL_INFO *info = (CRL_INFO *)buf;
1430         (winetest_set_location("encode.c", 4085), 0) ? 0 : winetest_ok(info->cCRLEntry == 209, "Expected 209 CRL entries, got %d\n",
1431          info->cExtension);
1432     }
1433     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)3),
1434      ((void *)0), (BYTE *)&buf, &size);
1435     {
1436     }
1437 }
1438 static const BYTE authorityKeyIdWithIssuer[] = { 0x30,0x19,0xa1,0x17,0x30,0x15,
1439  0x20,0x4c,0x61,0x6e,0x67,0x00 };
1440 static const BYTE authorityKeyIdWithSerial[] = { 0x30,0x03,0x82,0x01,0x01 };
1441 static void test_encodeAuthorityKeyId(DWORD dwEncoding)
1442 {
1443     CERT_AUTHORITY_KEY_ID_INFO info = { { 0 } };
1444     BOOL ret;
1445     BYTE *buf = ((void *)0);
1446     DWORD size = 0;
1447     {
1448     }
1449     {
1450     }
1451     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)9), &info,
1452      0x08000, ((void *)0), (BYTE *)&buf, &size);
1453     {
1454     }
1455     ret = CryptEncodeObjectEx(dwEncoding, ((LPCSTR)9), &info,
1456      0x08000, ((void *)0), (BYTE *)&buf, &size);
1457     {
1458         (winetest_set_location("encode.c", 4284), 0) ? 0 : winetest_ok(size == sizeof(authorityKeyIdWithSerial), "Unexpected size %d\n",
1459          size);
1460     }
1461 }
1462 static void test_decodeAuthorityKeyId(DWORD dwEncoding)
1463 {
1464     BOOL ret;
1465     LPBYTE buf = ((void *)0);
1466     DWORD size = 0;
1467     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)9),
1468      (BYTE *)&buf, &size);
1469     {
1470     }
1471     ret = CryptDecodeObjectEx(dwEncoding, ((LPCSTR)9),
1472      0x08000, ((void *)0), (BYTE *)&buf, &size);
1473     {
1474         (winetest_set_location("encode.c", 4355), 0) ? 0 : winetest_ok(size >= sizeof(CERT_AUTHORITY_KEY_ID_INFO), "Unexpected size %d\n",
1475          "Unexpected serial number\n");
1476     }
1477 }
1478 static void testExportPublicKey(HCRYPTPROV csp, PCERT_PUBLIC_KEY_INFO *pInfo)
1479 {
1480     BOOL ret;
1481     DWORD size = 0;
1482     {
1483         ret = CryptExportPublicKeyInfoEx(csp, 2, 0x00000001,
1484          ((void *)0), 0, ((void *)0), ((void *)0), &size);
1485         {
1486             {
1487                 (winetest_set_location("encode.c", 4416), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && __builtin_constant_p ("1.2.840.113549.1.1.1") && (__s1_len = strlen ((*pInfo)->Algorithm.pszObjId), __s2_len = strlen ("1.2.840.113549.1.1.1"), (!((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) || __s1_len >= 4) && (!((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) || __s2_len >= 4)) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && ((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) && (__s1_len = strlen ((*pInfo)->Algorithm.pszObjId), __s1_len < 4) ? (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"); register int __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) && (__s2_len = strlen ("1.2.840.113549.1.1.1"), __s2_len < 4) ? (__builtin_constant_p ((*pInfo)->Algorithm.pszObjId) && ((size_t)(const void *)(((*pInfo)->Algorithm.pszObjId) + 1) - (size_t)(const void *)((*pInfo)->Algorithm.pszObjId) == 1) ? __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1") : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ((*pInfo)->Algorithm.pszObjId); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[3]); } } __result; }))) : __builtin_strcmp ((*pInfo)->Algorithm.pszObjId, "1.2.840.113549.1.1.1")))); }),
1488                  (*pInfo)->Algorithm.pszObjId);
1489             }
1490         }
1491     }
1492 }
1493 static const BYTE expiredCert[] = { 0x30, 0x82, 0x01, 0x33, 0x30, 0x81, 0xe2,
1494  0x49, 0xe5, 0xf9, 0x65, 0xf3 };
1495 static void testImportPublicKey(HCRYPTPROV csp, PCERT_PUBLIC_KEY_INFO info)
1496 {
1497     BOOL ret;
1498     HCRYPTKEY key;
1499     PCCERT_CONTEXT context;
1500     (winetest_set_location("encode.c", 4464), 0) ? 0 : winetest_ok(!ret && GetLastError() == 2,
1501      GetLastError());
1502     {
1503         (winetest_set_location("encode.c", 4485), 0) ? 0 : winetest_ok(!__extension__ ({ size_t __s1_len, __s2_len; (__builtin_constant_p ("1.2.840.113549.1.1.1") && __builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && (__s1_len = strlen ("1.2.840.113549.1.1.1"), __s2_len = strlen (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId), (!((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) || __s1_len >= 4) && (!((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) || __s2_len >= 4)) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) && (__s1_len = strlen ("1.2.840.113549.1.1.1"), __s1_len < 4) ? (__builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && ((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s2 = (__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId); register int __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[0] - __s2[0]); if (__s1_len > 0 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[1] - __s2[1]); if (__s1_len > 1 && __result == 0) { __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[2] - __s2[2]); if (__s1_len > 2 && __result == 0) __result = (((__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"))[3] - __s2[3]); } } __result; }))) : (__builtin_constant_p (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) && ((size_t)(const void *)((context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) + 1) - (size_t)(const void *)(context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) == 1) && (__s2_len = strlen (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId), __s2_len < 4) ? (__builtin_constant_p ("1.2.840.113549.1.1.1") && ((size_t)(const void *)(("1.2.840.113549.1.1.1") + 1) - (size_t)(const void *)("1.2.840.113549.1.1.1") == 1) ? __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId) : (__extension__ ({ __const unsigned char *__s1 = (__const unsigned char *) (__const char *) ("1.2.840.113549.1.1.1"); register int __result = __s1[0] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[0]; if (__s2_len > 0 && __result == 0) { __result = (__s1[1] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[1]); if (__s2_len > 1 && __result == 0) { __result = (__s1[2] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[2]); if (__s2_len > 2 && __result == 0) __result = (__s1[3] - ((__const unsigned char *) (__const char *) (context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId))[3]); } } __result; }))) : __builtin_strcmp ("1.2.840.113549.1.1.1", context->pCertInfo->SubjectPublicKeyInfo.Algorithm.pszObjId)))); }),
1504          &context->pCertInfo->SubjectPublicKeyInfo, 0, 0, ((void *)0), &key);
1505     }
1506 }
1507 static const char cspName[] = "WineCryptTemp";
1508 static void testPortPublicKeyInfo(void)
1509 {
1510     HCRYPTPROV csp;
1511     BOOL ret;
1512     CryptAcquireContextA(&csp, cspName, "Microsoft Base Cryptographic Provider v1.0", 1,
1513      0x00000008);
1514     ret = CryptAcquireContextA(&csp, cspName, "Microsoft Base Cryptographic Provider v1.0", 1,
1515      0x00000010);
1516 }
1517 void func_encode(void)
1518 {
1519     test_encodeCRLDistPoints(0x00000001);
1520 }
1521
1522 /* { dg-final { scan-tree-dump-times " xxxinfo = {}" 1 "dse1"} } */
1523 /* { dg-final { cleanup-tree-dump "dse\[1-2\]" } } */