| /* |
| * Copyright 2007-2022 The OpenSSL Project Authors. All Rights Reserved. |
| * Copyright Siemens AG 2015-2022 |
| * |
| * Licensed under the Apache License 2.0 (the "License"). You may not use |
| * this file except in compliance with the License. You can obtain a copy |
| * in the file LICENSE in the source distribution or at |
| * https://www.openssl.org/source/license.html |
| */ |
| |
| /* |
| * A collection of test cases where check-format.pl should not report issues. |
| * There are some known false positives, though, which are marked below. |
| */ |
| |
| #define F \ |
| void f() \ |
| { \ |
| int i; \ |
| int j; \ |
| \ |
| return; \ |
| } |
| |
| /*- |
| * allow extra SPC in format-tagged multi-line comment |
| */ |
| int f(void) /* |
| * trailing multi-line comment |
| */ |
| { |
| typedef int INT; |
| void v; |
| short b; |
| char c; |
| signed s; |
| unsigned u; |
| int i; |
| long l; |
| float f; |
| double d; |
| enum {} enu; |
| struct {} stru; |
| union {} un; |
| auto a; |
| extern e; |
| static int stat; |
| const int con; |
| volatile int vola; |
| register int reg; |
| /* |
| * multi-line comment should not disturb detection of local decls |
| */ |
| BIO1 ***b; |
| /* intra-line comment should not disturb detection of local decls */ |
| unsigned k; |
| |
| /* intra-line comment should not disturb detection of end of local decls */ |
| if (ctx == NULL) { /* non-leading end-of-line comment */ |
| if (/* comment after '(' */ pem_name != NULL /* comment before ')' */) |
| /* entire-line comment indent usually like for the following line */ |
| return NULL; /* hanging indent also for this line after comment */ |
| /* leading comment has same indentation as normal code */ stmt; |
| /* entire-line comment may have same indent as normal code */ |
| } |
| |
| for (;;) |
| ; |
| for (i = 0;;) |
| ; |
| for (i = 0; i < 1;) |
| ; |
| for (;;) ; /* should not trigger: space before ';' */ |
| lab: ; /* should not trigger: space before ';' */ |
| |
| #if X |
| if (1) /* bad style: just part of control structure depends on #if */ |
| #else |
| if (2) /*@ resulting false positive */ |
| #endif |
| c; /*@ resulting false positive */ |
| |
| if (1) |
| if (2) |
| c; |
| else |
| e; |
| else |
| f; |
| do |
| do |
| 2; |
| while (1); |
| while (2); |
| |
| if (1) |
| f(a, b); |
| do |
| 1; while (2); /*@ more than one stmt just to construct case */ |
| if (1) |
| f(a, b); |
| else |
| do |
| 1; |
| while (2); |
| if (1) |
| f(a, b); |
| else do /*@ (non-brace) code before 'do' just to construct case */ |
| 1; |
| while (2); |
| f1234(a, |
| b); do /*@ (non-brace) code before 'do' just to construct case */ |
| 1; |
| while (2); |
| if (1) |
| f(a, |
| b); do /*@ (non-brace) code before 'do' just to construct case */ |
| 1; |
| while (2); |
| if (1) |
| f(a, b); |
| else |
| do f(c, c); /*@ (non-brace) code after 'do' just to construct case */ |
| while (2); |
| |
| if (1) |
| f(a, b); |
| else |
| return; |
| if (1) |
| f(a, |
| b); else /*@ (non-brace) code before 'else' just to construct case */ |
| do |
| 1; |
| while (2); |
| |
| if (1) |
| { /*@ brace after 'if' not on same line just to construct case */ |
| c; |
| d; |
| } |
| /* this comment is correctly indented if it refers to the following line */ |
| d; |
| |
| if (1) { |
| 2; |
| } else /*@ no brace after 'else' just to construct case */ |
| 3; |
| do { |
| } while (x); |
| if (1) { |
| 2; |
| } else { |
| 3; |
| } |
| if (4) |
| 5; |
| else |
| 6; |
| |
| if (1) { |
| if (2) { |
| case MAC_TYPE_MAC: |
| { |
| EVP_MAC_CTX *new_mac_ctx; |
| |
| if (ctx->pkey == NULL) |
| return 0; |
| } |
| break; |
| default: |
| /* This should be dead code */ |
| return 0; |
| } |
| } |
| if (expr_line1 |
| == expr_line2 |
| && expr_line3) { |
| c1; |
| } else { |
| c; |
| d; |
| } |
| if (expr_line1 |
| == expr_line2 |
| && expr_line3) |
| hanging_stmt; |
| } |
| |
| /* should not trigger: constant on LHS of comparison or assignment operator */ |
| X509 *x509 = NULL; |
| int y = a + 1 < b; |
| int ret, was_NULL = *certs == NULL; |
| |
| /* should not trigger: no space before binary ... operator */ |
| float z = 1e-6 * (-1) * b[+6] * 1e+1 * (a)->f * (long)+1 |
| - (tmstart.tv_sec + tmstart.tv_nsec * 1e-9); |
| struct st = {-1, 0}; |
| |
| const OPTIONS passwd_options[] = { |
| {"aixmd5", OPT_AIXMD5, '-', "AIX MD5-based password algorithm"}, |
| #if !defined(OPENSSL_NO_DES) && !defined(OPENSSL_NO_DEPRECATED_3_0) |
| {"crypt", OPT_CRYPT, '-', "Standard Unix password algorithm (default)"}, |
| #endif |
| OPT_R_OPTIONS, |
| |
| {NULL} |
| }; |
| |
| typedef * d(int) |
| x; |
| typedef (int) |
| x; |
| typedef (int)*() |
| x; |
| typedef *int * |
| x; |
| typedef OSSL_CMP_MSG *(*cmp_srv_process_cb_t) |
| (OSSL_CMP_SRV_CTX *ctx, OSSL_CMP_MSG *msg) |
| xx; |
| int f() |
| { |
| c; |
| if (1) { |
| c; |
| } |
| c; |
| if (1) |
| if (2) |
| { /*@ brace after 'if' not on same line just to construct case */ |
| c; |
| } |
| e; |
| const usign = { |
| 0xDF, |
| { |
| dd |
| }, |
| dd |
| }; |
| const unsign = { |
| 0xDF, { |
| dd |
| }, |
| dd |
| }; |
| } |
| const unsigned char trans_id[OSSL_CMP_TRANSACTIONID_LENGTH] = { |
| 0xDF, |
| }; |
| const unsigned char trans_id[OSSL_CMP_TRANSACTIONID_LENGTH] = |
| { |
| 0xDF, |
| }; |
| typedef |
| int |
| a; |
| |
| typedef |
| struct |
| { |
| int a; |
| } b; |
| typedef enum { |
| w = 0 |
| } e_type; |
| typedef struct { |
| enum { |
| w = 0 |
| } e_type; |
| enum { |
| w = 0 |
| } e_type; |
| } e; |
| struct s_type { |
| enum e_type { |
| w = 0 |
| }; |
| }; |
| struct s_type |
| { |
| enum e_type { |
| w = 0 |
| }; |
| enum e2_type { |
| w = 0 |
| }; |
| }; |
| |
| #define X 1 + 1 |
| #define Y /* .. */ 2 + 2 |
| #define Z 3 + 3 * (*a++) |
| |
| static varref cmp_vars[] = { /* comment. comment? comment! */ |
| {&opt_config}, {&opt_section}, |
| |
| {&opt_server}, {&opt_proxy}, {&opt_path}, |
| }; |
| |
| #define SWITCH(x) \ |
| switch (x) { \ |
| case 0: \ |
| break; \ |
| default: \ |
| break; \ |
| } |
| |
| #define DEFINE_SET_GET_BASE_TEST(PREFIX, SETN, GETN, DUP, FIELD, TYPE, ERR, \ |
| DEFAULT, NEW, FREE) \ |
| static int execute_CTX_##SETN##_##GETN##_##FIELD( \ |
| TEST_FIXTURE *fixture) \ |
| { \ |
| CTX *ctx = fixture->ctx; \ |
| int (*set_fn)(CTX *ctx, TYPE) = \ |
| (int (*)(CTX *ctx, TYPE))PREFIX##_##SETN##_##FIELD; \ |
| /* comment */ \ |
| } |
| |
| union un var; /* struct/union/enum in variable type */ |
| struct provider_store_st *f() /* struct/union/enum in function return type */ |
| { |
| } |
| static void f(struct pem_pass_data *data) /* struct/union/enum in arg list */ |
| { |
| } |
| |
| static void *fun(void) |
| { |
| if (pem_name != NULL) |
| /* comment */ |
| return NULL; |
| |
| label0: |
| label1: /* allow special indent 1 for label at outermost level in body */ |
| do { |
| label2: |
| size_t available_len, data_len; |
| const char *curr = txt, *next = txt; |
| char *tmp; |
| |
| { |
| label3: |
| } |
| } while (1); |
| |
| char *intraline_string_with_comment_delimiters_and_dbl_space = "1 /*1"; |
| char *multiline_string_with_comment_delimiters_and_dbl_space = "1 /*1\ |
| 2222222\'22222222222222222\"222222222" "33333 /*3333333333" "44 /*44444444444\ |
| 55555555555555\ |
| 6666"; |
| } |
| |
| ASN1_CHOICE(OSSL_CRMF_POPO) = { |
| ASN1_IMP(OSSL_CRMF_POPO, value.raVerified, ASN1_NULL, 0), |
| ASN1_EXP(OSSL_CRMF_POPO, value.keyAgreement, OSSL_CRMF_POPOPRIVKEY, 3) |
| } ASN1_CHOICE_END(OSSL_CRMF_POPO) |
| IMPLEMENT_ASN1_FUNCTIONS(OSSL_CRMF_POPO) |
| |
| ASN1_ADB(OSSL_CRMF_ATTRIBUTETYPEANDVALUE) = { |
| ADB_ENTRY(NID_id_regCtrl_regToken, |
| ASN1_SIMPLE(OSSL_CRMF_ATTRIBUTETYPEANDVALUE, |
| value.regToken, ASN1_UTF8STRING)), |
| } ASN1_ADB_END(OSSL_CRMF_ATTRIBUTETYPEANDVALUE, 0, type, 0, |
| &attributetypeandvalue_default_tt, NULL); |
| |
| ASN1_ITEM_TEMPLATE(OSSL_CRMF_MSGS) = |
| ASN1_EX_TEMPLATE_TYPE(ASN1_TFLG_SEQUENCE_OF, 0, |
| OSSL_CRMF_MSGS, OSSL_CRMF_MSG) |
| ASN1_ITEM_TEMPLATE_END(OSSL_CRMF_MSGS) |
| |
| void f_looong_body_200() |
| { /* function body length up to 200 lines accepted */ |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| } |
| |
| void f_looong_body_201() |
| { /* function body length > 200 lines, but LONG BODY marker present */ |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| ; |
| } |
