469 lines · 13.8 KB · Python
RawDownload
#!/usr/bin/env python3 """Unit tests for struct/union member extractor class."""  import osimport reimport unittestimport sys from unittest.mock import MagicMock SRC_DIR = os.path.dirname(os.path.realpath(__file__))sys.path.insert(0, os.path.join(SRC_DIR, "../lib/python")) from kdoc.c_lex import CToken, CTokenizerfrom unittest_helper import run_unittest ## List of tests.## The code will dynamically generate one test for each key on this dictionary.#def tokens_to_list(tokens):    tuples = []     for tok in tokens:        if tok.kind == CToken.SPACE:            continue         tuples += [(tok.kind, tok.value, tok.level)]     return tuples  def make_tokenizer_test(name, data):    """    Create a test named ``name`` using parameters given by ``data`` dict.    """     def test(self):        """In-lined lambda-like function to run the test"""         #        # Check if logger is working        #        if "log_msg" in data:            with self.assertLogs() as cm:                tokenizer = CTokenizer(data["source"])                 msg_found = False                for result in cm.output:                    if data["log_msg"] in result:                        msg_found = True                 self.assertTrue(msg_found, f"Missing log {data['log_msg']}")             return         #        # Check if tokenizer is producing expected results        #        tokens = CTokenizer(data["source"]).tokens         result = tokens_to_list(tokens)        expected = tokens_to_list(data["expected"])         self.assertEqual(result, expected, msg=f"{name}")     return test #: Tokenizer tests.TESTS_TOKENIZER = {    "__run__": make_tokenizer_test,     "basic_tokens": {        "source": """            int a; // comment            float b = 1.23;        """,        "expected": [            CToken(CToken.NAME, "int"),            CToken(CToken.NAME, "a"),            CToken(CToken.ENDSTMT, ";"),            CToken(CToken.COMMENT, "// comment"),            CToken(CToken.NAME, "float"),            CToken(CToken.NAME, "b"),            CToken(CToken.OP, "="),            CToken(CToken.NUMBER, "1.23"),            CToken(CToken.ENDSTMT, ";"),        ],    },     "depth_counters": {        "source": """            struct X {                int arr[10];                func(a[0], (b + c));            }        """,        "expected": [            CToken(CToken.STRUCT, "struct"),            CToken(CToken.NAME, "X"),            CToken(CToken.BEGIN, "{", brace_level=1),             CToken(CToken.NAME, "int", brace_level=1),            CToken(CToken.NAME, "arr", brace_level=1),            CToken(CToken.BEGIN, "[", brace_level=1, bracket_level=1),            CToken(CToken.NUMBER, "10", brace_level=1, bracket_level=1),            CToken(CToken.END, "]", brace_level=1),            CToken(CToken.ENDSTMT, ";", brace_level=1),            CToken(CToken.NAME, "func", brace_level=1),            CToken(CToken.BEGIN, "(", brace_level=1, paren_level=1),            CToken(CToken.NAME, "a", brace_level=1, paren_level=1),            CToken(CToken.BEGIN, "[", brace_level=1, paren_level=1, bracket_level=1),            CToken(CToken.NUMBER, "0", brace_level=1, paren_level=1, bracket_level=1),            CToken(CToken.END, "]", brace_level=1, paren_level=1),            CToken(CToken.PUNC, ",", brace_level=1, paren_level=1),            CToken(CToken.BEGIN, "(", brace_level=1, paren_level=2),            CToken(CToken.NAME, "b", brace_level=1, paren_level=2),            CToken(CToken.OP, "+", brace_level=1, paren_level=2),            CToken(CToken.NAME, "c", brace_level=1, paren_level=2),            CToken(CToken.END, ")", brace_level=1, paren_level=1),            CToken(CToken.END, ")", brace_level=1),            CToken(CToken.ENDSTMT, ";", brace_level=1),            CToken(CToken.END, "}"),        ],    },     "mismatch_error": {        "source": "int a$ = 5;",          # $ is illegal        "log_msg": "Unexpected token",    },} def make_private_test(name, data):    """    Create a test named ``name`` using parameters given by ``data`` dict.    """     def test(self):        """In-lined lambda-like function to run the test"""        tokens = CTokenizer(data["source"])        result = str(tokens)         #        # Avoid whitespace false positives        #        result = re.sub(r"\s++", " ", result).strip()        expected = re.sub(r"\s++", " ", data["trimmed"]).strip()         msg = f"failed when parsing this source:\n{data['source']}"        self.assertEqual(result, expected, msg=msg)     return test #: Tests to check if CTokenizer is handling properly public/private comments.TESTS_PRIVATE = {    #    # Simplest case: no private. Ensure that trimming won't affect struct    #    "__run__": make_private_test,    "no private": {        "source": """            struct foo {                int a;                int b;                int c;            };        """,        "trimmed": """            struct foo {                int a;                int b;                int c;            };        """,    },     #    # Play "by the books" by always having a public in place    #     "balanced_private": {        "source": """            struct foo {                int a;                /* private: */                int b;                /* public: */                int c;            };        """,        "trimmed": """            struct foo {                int a;                int c;            };        """,    },     "balanced_non_greddy_private": {        "source": """            struct foo {                int a;                /* private: */                int b;                /* public: */                int c;                /* private: */                int d;                /* public: */                int e;             };        """,        "trimmed": """            struct foo {                int a;                int c;                int e;            };        """,    },     "balanced_inner_private": {        "source": """            struct foo {                struct {                    int a;                    /* private: ignore below */                    int b;                /* public: but this should not be ignored */                };                int b;            };        """,        "trimmed": """            struct foo {                struct {                    int a;                };                int b;            };        """,    },     #    # Test what happens if there's no public after private place    #     "unbalanced_private": {        "source": """            struct foo {                int a;                /* private: */                int b;                int c;            };        """,        "trimmed": """            struct foo {                int a;            };        """,    },     "unbalanced_inner_private": {        "source": """            struct foo {                struct {                    int a;                    /* private: ignore below */                    int b;                /* but this should not be ignored */                };                int b;            };        """,        "trimmed": """            struct foo {                struct {                    int a;                };                int b;            };        """,    },     "unbalanced_struct_group_tagged_with_private": {        "source": """            struct page_pool_params {                struct_group_tagged(page_pool_params_fast, fast,                        unsigned int    order;                        unsigned int    pool_size;                        int             nid;                        struct device   *dev;                        struct napi_struct *napi;                        enum dma_data_direction dma_dir;                        unsigned int    max_len;                        unsigned int    offset;                };                struct_group_tagged(page_pool_params_slow, slow,                        struct net_device *netdev;                        unsigned int queue_idx;                        unsigned int    flags;                        /* private: used by test code only */                        void (*init_callback)(netmem_ref netmem, void *arg);                        void *init_arg;                };            };        """,        "trimmed": """            struct page_pool_params {                struct_group_tagged(page_pool_params_fast, fast,                        unsigned int    order;                        unsigned int    pool_size;                        int             nid;                        struct device   *dev;                        struct napi_struct *napi;                        enum dma_data_direction dma_dir;                        unsigned int    max_len;                        unsigned int    offset;                };                struct_group_tagged(page_pool_params_slow, slow,                        struct net_device *netdev;                        unsigned int queue_idx;                        unsigned int    flags;                };            };        """,    },     "unbalanced_two_struct_group_tagged_first_with_private": {        "source": """            struct page_pool_params {                struct_group_tagged(page_pool_params_slow, slow,                        struct net_device *netdev;                        unsigned int queue_idx;                        unsigned int    flags;                        /* private: used by test code only */                        void (*init_callback)(netmem_ref netmem, void *arg);                        void *init_arg;                };                struct_group_tagged(page_pool_params_fast, fast,                        unsigned int    order;                        unsigned int    pool_size;                        int             nid;                        struct device   *dev;                        struct napi_struct *napi;                        enum dma_data_direction dma_dir;                        unsigned int    max_len;                        unsigned int    offset;                };            };        """,        "trimmed": """            struct page_pool_params {                struct_group_tagged(page_pool_params_slow, slow,                        struct net_device *netdev;                        unsigned int queue_idx;                        unsigned int    flags;                };                struct_group_tagged(page_pool_params_fast, fast,                        unsigned int    order;                        unsigned int    pool_size;                        int             nid;                        struct device   *dev;                        struct napi_struct *napi;                        enum dma_data_direction dma_dir;                        unsigned int    max_len;                        unsigned int    offset;                };            };        """,    },    "unbalanced_without_end_of_line": {        "source": """ \            struct page_pool_params { \                struct_group_tagged(page_pool_params_slow, slow, \                        struct net_device *netdev; \                        unsigned int queue_idx; \                        unsigned int    flags;                        /* private: used by test code only */                        void (*init_callback)(netmem_ref netmem, void *arg); \                        void *init_arg; \                }; \                struct_group_tagged(page_pool_params_fast, fast, \                        unsigned int    order; \                        unsigned int    pool_size; \                        int             nid; \                        struct device   *dev; \                        struct napi_struct *napi; \                        enum dma_data_direction dma_dir; \                        unsigned int    max_len; \                        unsigned int    offset; \                }; \            };        """,        "trimmed": """            struct page_pool_params {                struct_group_tagged(page_pool_params_slow, slow,                        struct net_device *netdev;                        unsigned int queue_idx;                        unsigned int    flags;                };                struct_group_tagged(page_pool_params_fast, fast,                        unsigned int    order;                        unsigned int    pool_size;                        int             nid;                        struct device   *dev;                        struct napi_struct *napi;                        enum dma_data_direction dma_dir;                        unsigned int    max_len;                        unsigned int    offset;                };            };        """,    },} #: Dict containing all test groups fror CTokenizerTESTS = {    "TestPublicPrivate": TESTS_PRIVATE,    "TestTokenizer": TESTS_TOKENIZER,} def setUp(self):    self.maxDiff = None def build_test_class(group_name, table):    """    Dynamically creates a class instance using type() as a generator    for a new class derivated from unittest.TestCase.     We're opting to do it inside a function to avoid the risk of    changing the globals() dictionary.    """     class_dict = {        "setUp": setUp    }     run = table["__run__"]     for test_name, data in table.items():        if test_name == "__run__":            continue         class_dict[f"test_{test_name}"] = run(test_name, data)     cls = type(group_name, (unittest.TestCase,), class_dict)     return cls.__name__, cls ## Create classes and add them to the global dictionary#for group, table in TESTS.items():    t = build_test_class(group, table)    globals()[t[0]] = t[1] ## main#if __name__ == "__main__":    run_unittest(__file__)

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t