From patchwork Wed Sep 6 21:20:38 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 22690 Received: (qmail 123732 invoked by alias); 6 Sep 2017 21:21:00 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 123501 invoked by uid 89); 6 Sep 2017 21:21:00 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.3 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.2 spammy=watchdog X-HELO: sessmg23.ericsson.net Received: from sessmg23.ericsson.net (HELO sessmg23.ericsson.net) (193.180.251.45) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 06 Sep 2017 21:20:52 +0000 Received: from ESESSHC014.ericsson.se (Unknown_Domain [153.88.183.60]) by sessmg23.ericsson.net (Symantec Mail Security) with SMTP id F4.83.22436.1B660B95; Wed, 6 Sep 2017 23:20:49 +0200 (CEST) Received: from EUR01-HE1-obe.outbound.protection.outlook.com (153.88.183.145) by oa.msg.ericsson.com (153.88.183.60) with Microsoft SMTP Server (TLS) id 14.3.352.0; Wed, 6 Sep 2017 23:20:48 +0200 Received: from elxacz23q12.localdomain (80.216.43.226) by AM3PR07MB307.eurprd07.prod.outlook.com (2a01:111:e400:881b::15) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.35.3; Wed, 6 Sep 2017 21:20:46 +0000 From: Simon Marchi To: CC: , Simon Marchi Subject: [PATCH v2] Add selftests run filtering Date: Wed, 6 Sep 2017 23:20:38 +0200 Message-ID: <1504732838-6455-1-git-send-email-simon.marchi@ericsson.com> In-Reply-To: <0cc25dd0-4311-28e8-f0ca-443719354bed@redhat.com> References: <0cc25dd0-4311-28e8-f0ca-443719354bed@redhat.com> MIME-Version: 1.0 X-ClientProxiedBy: AM5PR06CA0003.eurprd06.prod.outlook.com (2603:10a6:206:2::16) To AM3PR07MB307.eurprd07.prod.outlook.com (2a01:111:e400:881b::15) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 83bf7fed-c43a-4804-5b45-08d4f56d23b6 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(2017030254152)(300000503095)(300135400095)(201703131423075)(201703031133081)(201702281549075)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:AM3PR07MB307; X-Microsoft-Exchange-Diagnostics: 1; AM3PR07MB307; 3:M1ybcZppLZsGl949fkCKaRj2ZhOfc+mjuT2czCkBvViUNSWqiuzgqfGhAa9ODiAoB1mHNqYpyuA0QBKqYHoxv+o2k2LD5D32xcU6E+g1zr9+G2O0pAhwGUR30n6OUmcfXXaEj9XKfyKwJPS7bVxeo9gUa9iRlcdG9F6eiHqfJEFwAsiqXEAEuCgIH/e9upQR9kbEwh7ytf5DHAO7YlmAaQpGx+8AqlLZAyliMuXkYwjBC9HOEFzrlTtsbomvhxE4; 25:cTAJZANTiGukaA7r2cvgMw0M088W51pC9W91YlXhAN2GAeDzuMU6G9o4BzvpKiur1cewoRXz9mqW3O2ANsrkN6GhRXf5Ppv05DaIJyAAt1DLgAUfazzAOPKJDMDqejNxdTxH8Z7cagR23nUNpMm5qps8wmMgV8L9J6L9NGl7AeGnCWBTncvug0SDM9suyH/6/rUq+ToxJ5Y9HYkf7lb+Z6/Hk1QDfxbiZOIE7DYrS4LfC5cKdvIEPIAllf+9I9oEFUUKrFNsElwPHYA8pR8MAaRWnpwZNKz1Gfh4q6y1z1//t+SLr+LDPZUM71wjZNslF9MG4ISfqGj5Oa0aVKab3Q==; 31:ySqGRwAW+QXKChZDTxVK5M2ynqcsmPO18oJHmX7MgHS3aXbWYyhNUfDEP06PIVhR8Co5mlFTXSMELLvy3eg7E/u/Dznh1+IdHz3XiebalM44vYM1Fpw7eptQOkAqEbz8G4+UyOk58+Q5U2Q6thXx9PJru/Ob9Up89dcIR2q3uZxlElFj1sz7CQs9+Ki+xYafuhaYUfNi67jh/+rNYJveE1E/kle8yOyRRbSkafDz1a4= X-MS-TrafficTypeDiagnostic: AM3PR07MB307: Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=simon.marchi@ericsson.com; X-Microsoft-Exchange-Diagnostics: 1; AM3PR07MB307; 20:kZ4+cAFe2KJzTaSd+A1U/6pXI/VE4e2P57PdMrDR0FOUbQ6DfbaA3WrLaGS6P8T2G1LRTqP5suEPgtqFZewxucxCvFlkW7FUU9ORuh2HVcuhHueU6Ijw5OlcacZPpZheOax0sGc7Jx8Bq90mZSu0U1k+2GATAufIvMsmS8d1onar4uw+0MrNpnkGPfmsPaFx/rw/KkjKOF8welxZdT+kju6MLe6pdHiVHw9JciotH6Fm5Qi18ahZqK5yCwawC+pR7OD+09sITqRBwL0sZCskfqc1ZiMxVcpDsim1lq4GnfK+9pb2+1YEME4rlTn58Olod/DJezLQbti768SLQlB+asSHhFI1t0oshpW3ouk3HZuKG29ycEZ4v56fWO1vDXPhh/sFX4oPcvLQ5onHjgQO3aEXkZIohi46rbXtwqLv+hp4w1zQt+TwsraKrOk2L4RbXP6HRt72i7ebVfrbHulhZ1CuiEsLL7RLMQPrzyfd17lYKG3UsKxYUzdZD2xwXmSU; 4:wL6NNvpFbMp1d9hVsUjj0W7koaAkhJTkTifIdeF1wWTDwWxOwSsLMeiCWLJEz7oLw4jEUn7rfoeLMOGMS9YCi/u7tPgITcbSkn5wss54y+I0XVPrWU+Za7BpMP2MJHPuCEB+vXIqfu7JgJ+HQ2ITnhB7SHQWpaTokjYkor/hoIaTmdBpoTGtYfg6xbjlRhEqB34qIoL3QBfnlYoc/lPmNxrcGogQaXDax/zYS29xb0aZ0eri0kowlJNOvOCIJv0k X-Exchange-Antispam-Report-Test: UriScan:; X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(2401047)(5005006)(8121501046)(100000703101)(100105400095)(93006095)(93001095)(10201501046)(3002001)(6041248)(20161123562025)(20161123560025)(20161123555025)(20161123564025)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123558100)(6072148)(201708071742011)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:AM3PR07MB307; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:AM3PR07MB307; X-Forefront-PRVS: 0422860ED4 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(7370300001)(4630300001)(6009001)(39860400002)(54534003)(199003)(189002)(6512007)(68736007)(5660300001)(2950100002)(305945005)(6916009)(7736002)(76176999)(50986999)(6666003)(42186005)(36756003)(189998001)(101416001)(4326008)(53936002)(106356001)(105586002)(33646002)(50226002)(2351001)(2906002)(2361001)(48376002)(5890100001)(50466002)(5003940100001)(81166006)(81156014)(8676002)(25786009)(478600001)(6506006)(6116002)(97736004)(66066001)(86362001)(107886003)(575784001)(7350300001)(110136004)(3846002)(6486002)(47776003); DIR:OUT; SFP:1101; SCL:1; SRVR:AM3PR07MB307; H:elxacz23q12.localdomain; FPR:; SPF:None; PTR:InfoNoRecords; A:1; MX:1; LANG:en; Received-SPF: None (protection.outlook.com: ericsson.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; AM3PR07MB307; 23:Lps9pza0c/WDTp9uWh++DpOSK61JD4MFWBD42oJmPs?= =?us-ascii?Q?Dj+sEb43aEfqVOXBNMLMVfA6YThnaCbXrOHogHjIJPp7ytN7/WPXfA91bZoe?= =?us-ascii?Q?8V1FQLfV4L/SdUVztvfC1R9qKcszHxbu6fXyIZXjabVihZfF7JlQY10vqlP7?= =?us-ascii?Q?CDKzLrLuq3DTpdMpsaK21h9hKY+TVMkLc2nS6JDlzbYh0x7iVE5/nUq2JhS8?= =?us-ascii?Q?ehgrHJGlVYdPy4Z4dGd90kAA4K9Ol17W6jZpLRDDlCIe4I7n3IZAaRM6VbQv?= =?us-ascii?Q?a/QmOOSfAifGM3H7on7IczNU6/KMzCVEgL7jpOnDd0dL2uKASnEZfLttp7K3?= =?us-ascii?Q?TzCPfgogwsktBXzsPPDmAPbRWBw+sC1l3FJccMS0HtBjyVF9WnlHmH5JJINL?= =?us-ascii?Q?HFaPwBYw2T6C49iefbtf8ZkbBgkdtfbc6Mw6LIA31O+JKD/fnpKEJB6x320k?= =?us-ascii?Q?V9Y1dhW47NiZ64BdmE1MdZ0+8LMzgjKDp6miC7WTIV67xyNI+tKpq3tKIqg8?= =?us-ascii?Q?ei9dTUAB7q6L5g0iivIbt0KcBwQiMg2FpfxgpLkrEszf22YdsffMVuIieA+8?= =?us-ascii?Q?8MxYpIkL5fB7qIg0xD48Kskb+DUEqJLKp0aRrn4/OaclkYACbcIuVFdoDh1E?= =?us-ascii?Q?QnlEhQY/E2mUuqxruf7dRvNLHa0N/At90sjBapCbcTOZeBifR0vnQn6KT6V+?= =?us-ascii?Q?jcTUQ6ziI1jLTG5gu5OrxS+z8BUv4C3Hcz9/+LllMsxWViEb/Vmuk4sIJCv5?= =?us-ascii?Q?v+hfdH6vi+ijKY7SSSObJBJUXKHT54AlDDY2d5WFZ+7nnf132ugg+fYVzaWO?= =?us-ascii?Q?SYXj+RwC487zLmVFhmea7sYkZZkTKjssdNiFETLrHD4sxvk1MgEiMcTXndrU?= =?us-ascii?Q?o8TInj1aL6aTRYInSc6plohl8EaKp4kYSV7wxFlTQj5B+NrZXFFd9uIqklfi?= =?us-ascii?Q?4k8LkCDT5QpZJhfxptdJJU8qP3+9mPXroihUmrngmh5/WSPCK66tQ6BDhQZn?= =?us-ascii?Q?KuS3+rAYgTWJtpnzWK0uvy4lQeGku4k8YPUbCi1q4298nDeoOTwuA8bG2QQN?= =?us-ascii?Q?KFAdb/d25A2DF417S7B0Cphu7Bh0udN2NYoAH0cEx8RjB0LAoD6v8a/evovU?= =?us-ascii?Q?KsDtW30hEQ/MAbCJRj1Mya2J2JYZj30icnyDjInRKi13qScBJ0SCxqEJ8BTR?= =?us-ascii?Q?XvhZJALtIbT2PBB5+qhvQDZcOFlLH83g3Ld1GGin+So6Lz7/9GVKh2fruFce?= =?us-ascii?Q?DawnEpl/9u+OhuWM8=3D?= X-Microsoft-Exchange-Diagnostics: 1; AM3PR07MB307; 6:Xzg8fGLTzhq9ftQf6vTw4BuhrxsdxbU9eo2uGB8+I5gENWBrHrt98odtaw8iSXYRHSbjAS739Vf5FO0jOo2bsyCJGz9KHub9ydKTbY8KlM3aVxgsMZ7Pvv6eCnSBIHwyA2WH+OglvQnspKVLvdppLEFBYSOLS+xDQL+BpbUrl9nMr+EbKrIFXOBnSsMYZEJEBuMMMAucu60+3It05rTEiI6iaLdnU2KzhCDKYDRgilVCRkNPpFOzhdWPRlzm963AGhn2uYudwyoh8ihhMHZvnTgMc5Wrq/+nKKJgHjqgdrJ9b5ZEf4Polo5e7yEhWqqFZ7IK8Dmm9qXj3OJEtUv1VQ==; 5:FlXpy1kEXwzE6orgfMo3ap/IvBEv7d8ZHMaMS14YltFuoLlaWe2DX6ST8xI6TADqElCrMUXarCHd+XdQjAFAd+9mjfBe0s1Ry4u90G2IXfLR/5Be1KAoKyQd0G3cHhCpBzT4GzccWQ1pRm2iJ4Yv0A==; 24:1m1vhygCxI3ao6HlpxEOEzbpvKpsyRDXo8Zi1cyQOgvfQLadCrb3JVqhcNPq3Q+R++b2KYBFzA85rXVl1wvOqwYrjSwCaf6y90H0I1BtXgA=; 7:UR7HqSLoR6PnzaN0uKG+kC8NnzQ69lRTMJeCg8G0n/rBoiLG7RbFn6nUJz8XCp+5vjlhPBJAuXgDI51GyQ+GRL6L+gDrZqpX7XtKl1VT83CQws7hR99EuUtL4NNQH0xn+bRqjB23jbxC+jY/9HXRYXrVfL7Cr7kE2X8j6eGBbWxvRlexNc8/V+xXr+yD7iqtt1A8DCnbRMjHuamXh1YbKBhnbAcxObpKSXvIhb5lUjY= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-MS-Exchange-CrossTenant-OriginalArrivalTime: 06 Sep 2017 21:20:46.2976 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: AM3PR07MB307 X-OriginatorOrg: ericsson.com X-IsSubscribed: yes New in v2: Instead of storing normal and arch selftests separately as in v1, duplicating how they're stored and ran, I decided to have a single container, and different types of selftests that implement how they should be executed. The "normal" type simply executes the test function, whereas the "gdbarch" type calls it for each arch. A visible difference compared to v1 is that we'll get a single entry/message for an arch test, not one for each (arch variant x test). I think it's more reasonnable, we have 19 tests instead of 2000-ish. I also added "maintenance info selftests". Actual commit log: With the growing number of selftests, I think it would be useful to be able to run only a subset of the tests. This patch associates a name to each registered selftest. It then allows doing something like: (gdb) maintenance selftest aarch64 Running self-tests. Running selftest aarch64-analyze-prologue. Running selftest aarch64-process-record. Ran 2 unit tests, 0 failed or with gdbserver: ./gdbserver --selftest=aarch64 In both cases, only the tests that contain "aarch64" in their name are ran. To help validate that the tests you want to run were actually ran, it also prints a message with the test name before running each test. Right now, all the arch-dependent tests are registered as a single test of the selftests. To be able to filter those too, I made them "first-class citizen" selftests. The selftest type is an interface, with different implementations for "simple selftests" and "arch selftests". The run_tests function simply iterates on that an invokes operator() on each test. I changed the tests data structure from a vector to a map, because - it allows iterating in a stable (alphabetical) order - it allows to easily verify if a test with a given name has been registered, to avoid duplicates There's also a new command "maintenance info selftests" that lists the registered selftests. gdb/ChangeLog: * common/selftest.h (selftest): New struct/interface. (register_test): Add name parameter, add new overload. (run_tests): Add filter parameter. (for_each_selftest_ftype): New typedef. (for_each_selftest): New declaration. * common/selftest.c (tests): Change type to map>. (simple_selftest): New struct. (register_test): New function. (register_test): Add name parameter and use it. (run_tests): Add filter parameter and use it. Add prints. Adjust to vector -> map change. * aarch64-tdep.c (_initialize_aarch64_tdep): Add names when registering selftests. * arm-tdep.c (_initialize_arm_tdep): Likewise. * disasm-selftests.c (_initialize_disasm_selftests): Likewise. * dwarf2-frame.c (_initialize_dwarf2_frame): Likewise. * dwarf2loc.c (_initialize_dwarf2loc): Likewise. * findvar.c (_initialize_findvar): Likewise. * gdbarch-selftests.c (_initialize_gdbarch_selftests): Likewise. * maint.c (maintenance_selftest): Update call to run_tests. (maintenance_info_selftests): New function. (_initialize_maint_cmds): Register "maintenance info selftests" command. * regcache.c (_initialize_regcache): Add names when registering selftests. * rust-exp.y (_initialize_rust_exp): Likewise. * selftest-arch.c (gdbarch_selftest): New struct. (gdbarch_tests): Remove. (register_test_foreach_arch): Add name parameter. Call register_test. (tests_with_arch): Remove, move most content to gdbarch_selftest::operator(). (_initialize_selftests_foreach_arch): Remove. * selftest-arch.h (register_test_foreach_arch): Add name parameter. (run_tests_with_arch): New declaration. * utils-selftests.c (_initialize_utils_selftests): Add names when registering selftests. * utils.c (_initialize_utils): Likewise. * unittests/array-view-selftests.c (_initialize_array_view_selftests): Likewise. * unittests/environ-selftests.c (_initialize_environ_selftests): Likewise. * unittests/function-view-selftests.c (_initialize_function_view_selftests): Likewise. * unittests/offset-type-selftests.c (_initialize_offset_type_selftests): Likewise. * unittests/optional-selftests.c (_initialize_optional_selftests): Likewise. * unittests/scoped_restore-selftests.c (_initialize_scoped_restore_selftests): Likewise. gdb/gdbserver/ChangeLog: * server.c (captured_main): Accept argument for --selftest. Update run_tests call. * linux-x86-tdesc-selftest.c (initialize_low_tdesc): Add names when registering selftests. --- gdb/aarch64-tdep.c | 6 +- gdb/arm-tdep.c | 2 +- gdb/common/selftest.c | 67 ++++++++++++--- gdb/common/selftest.h | 26 +++++- gdb/disasm-selftests.c | 6 +- gdb/dwarf2-frame.c | 3 +- gdb/dwarf2loc.c | 2 +- gdb/findvar.c | 4 +- gdb/gdbarch-selftests.c | 3 +- gdb/gdbserver/linux-x86-tdesc-selftest.c | 4 +- gdb/gdbserver/server.c | 8 +- gdb/maint.c | 14 +++- gdb/regcache.c | 3 +- gdb/rust-exp.y | 2 +- gdb/selftest-arch.c | 136 +++++++++++++++---------------- gdb/selftest-arch.h | 3 +- gdb/unittests/array-view-selftests.c | 3 +- gdb/unittests/environ-selftests.c | 3 +- gdb/unittests/function-view-selftests.c | 3 +- gdb/unittests/offset-type-selftests.c | 2 +- gdb/unittests/optional-selftests.c | 2 +- gdb/unittests/scoped_restore-selftests.c | 3 +- gdb/utils-selftests.c | 2 +- gdb/utils.c | 2 +- 24 files changed, 201 insertions(+), 108 deletions(-) diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c index 5a627a3..ebd3e47 100644 --- a/gdb/aarch64-tdep.c +++ b/gdb/aarch64-tdep.c @@ -3068,8 +3068,10 @@ When on, AArch64 specific debugging is enabled."), &setdebuglist, &showdebuglist); #if GDB_SELF_TEST - selftests::register_test (selftests::aarch64_analyze_prologue_test); - selftests::register_test (selftests::aarch64_process_record_test); + selftests::register_test ("aarch64-analyze-prologue", + selftests::aarch64_analyze_prologue_test); + selftests::register_test ("aarch64-process-record", + selftests::aarch64_process_record_test); #endif } diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c index 0c1a0b3..751ee27 100644 --- a/gdb/arm-tdep.c +++ b/gdb/arm-tdep.c @@ -9727,7 +9727,7 @@ vfp - VFP co-processor."), &setdebuglist, &showdebuglist); #if GDB_SELF_TEST - selftests::register_test (selftests::arm_record_test); + selftests::register_test ("arm-record", selftests::arm_record_test); #endif } diff --git a/gdb/common/selftest.c b/gdb/common/selftest.c index 0fb8f2a..793c15f 100644 --- a/gdb/common/selftest.c +++ b/gdb/common/selftest.c @@ -20,35 +20,71 @@ #include "common-exceptions.h" #include "common-debug.h" #include "selftest.h" -#include +#include namespace selftests { +/* All the tests that have been registered. Using an std::map allows keeping + the order of tests stable and easily looking whether a test name exists. */ -/* All the tests that have been registered. */ +static std::map> tests; -static std::vector tests; +/* A selftest that calls the test function without arguments. */ + +struct simple_selftest : public selftest +{ + simple_selftest (self_test_function *function_) + : function (function_) + {} + + void operator() () const override + { + function (); + } + + self_test_function *function; +}; /* See selftest.h. */ void -register_test (self_test_function *function) +register_test (const std::string &name, selftest *test) { - tests.push_back (function); + /* Check that no test with this name already exist. */ + gdb_assert (tests.find (name) == tests.end ()); + + tests[name] = std::unique_ptr (test); } /* See selftest.h. */ void -run_tests (void) +register_test (const std::string &name, self_test_function *function) { - int failed = 0; + register_test (name, new simple_selftest (function)); +} + +/* See selftest.h. */ - for (int i = 0; i < tests.size (); ++i) +void +run_tests (const char *filter) +{ + int ran = 0, failed = 0; + + for (const auto &pair : tests) { + const std::string &name = pair.first; + const std::unique_ptr &test = pair.second; + + if (filter != NULL && *filter != '\0' + && name.find (filter) == std::string::npos) + continue; + TRY { - tests[i] (); + debug_printf (_("Running selftest %s.\n"), name.c_str ()); + ++ran; + (*test) (); } CATCH (ex, RETURN_MASK_ERROR) { @@ -60,7 +96,16 @@ run_tests (void) reset (); } - debug_printf ("Ran %lu unit tests, %d failed\n", - (long) tests.size (), failed); + debug_printf (_("Ran %d unit tests, %d failed\n"), + ran, failed); } + +/* See selftest.h. */ + +void for_each_selftest (for_each_selftest_ftype func) +{ + for (const auto &pair : tests) + func (pair.first); +} + } // namespace selftests diff --git a/gdb/common/selftest.h b/gdb/common/selftest.h index e211c34..35a344f 100644 --- a/gdb/common/selftest.h +++ b/gdb/common/selftest.h @@ -27,18 +27,38 @@ typedef void self_test_function (void); namespace selftests { +/* Interface for the various kinds of selftests. */ + +struct selftest +{ + virtual void operator() () const = 0; +}; + /* Register a new self-test. */ -extern void register_test (self_test_function *function); +extern void register_test (const std::string &name, selftest *test); + +/* Register a new self-test. */ + +extern void register_test (const std::string &name, + self_test_function *function); /* Run all the self tests. This print a message describing the number - of test and the number of failures. */ + of test and the number of failures. + + If FILTER is not NULL and not empty, only tests with names containing FILTER + will be ran. */ -extern void run_tests (void); +extern void run_tests (const char *filter); /* Reset GDB or GDBserver's internal state. */ extern void reset (); +typedef void for_each_selftest_ftype (const std::string &name); + +/* Call FUNC for each registered selftest. */ + +extern void for_each_selftest (for_each_selftest_ftype func); } /* Check that VALUE is true, and, if not, throw an exception. */ diff --git a/gdb/disasm-selftests.c b/gdb/disasm-selftests.c index 4d38ccf..b8ef381 100644 --- a/gdb/disasm-selftests.c +++ b/gdb/disasm-selftests.c @@ -214,7 +214,9 @@ void _initialize_disasm_selftests (void) { #if GDB_SELF_TEST - selftests::register_test_foreach_arch (selftests::print_one_insn_test); - selftests::register_test_foreach_arch (selftests::memory_error_test); + selftests::register_test_foreach_arch ("print_one_insn", + selftests::print_one_insn_test); + selftests::register_test_foreach_arch ("memory_error", + selftests::memory_error_test); #endif } diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c index aaf3aee..268ecda 100644 --- a/gdb/dwarf2-frame.c +++ b/gdb/dwarf2-frame.c @@ -2406,6 +2406,7 @@ _initialize_dwarf2_frame (void) dwarf2_frame_objfile_data = register_objfile_data (); #if GDB_SELF_TEST - selftests::register_test_foreach_arch (selftests::execute_cfa_program_test); + selftests::register_test_foreach_arch ("execute_cfa_program", + selftests::execute_cfa_program_test); #endif } diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index 1a1b06a..6dd962d 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -4687,6 +4687,6 @@ _initialize_dwarf2loc (void) &setdebuglist, &showdebuglist); #if GDB_SELF_TEST - selftests::register_test (selftests::copy_bitwise_tests); + selftests::register_test ("copy_bitwise", selftests::copy_bitwise_tests); #endif } diff --git a/gdb/findvar.c b/gdb/findvar.c index de6b6ed..b3fb337 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -1095,6 +1095,8 @@ void _initialize_findvar (void) { #if GDB_SELF_TEST - selftests::register_test (selftests::findvar_tests::copy_integer_to_size_test); + selftests::register_test + ("copy_integer_to_size", + selftests::findvar_tests::copy_integer_to_size_test); #endif } diff --git a/gdb/gdbarch-selftests.c b/gdb/gdbarch-selftests.c index cb15964..f0b8d5d 100644 --- a/gdb/gdbarch-selftests.c +++ b/gdb/gdbarch-selftests.c @@ -151,6 +151,7 @@ void _initialize_gdbarch_selftests (void) { #if GDB_SELF_TEST - selftests::register_test_foreach_arch (selftests::register_to_value_test); + selftests::register_test_foreach_arch ("register_to_value", + selftests::register_to_value_test); #endif } diff --git a/gdb/gdbserver/linux-x86-tdesc-selftest.c b/gdb/gdbserver/linux-x86-tdesc-selftest.c index aa5a8e9..c5ab2ab 100644 --- a/gdb/gdbserver/linux-x86-tdesc-selftest.c +++ b/gdb/gdbserver/linux-x86-tdesc-selftest.c @@ -164,7 +164,7 @@ initialize_low_tdesc () init_registers_i386_avx_avx512_linux (); init_registers_i386_avx_mpx_avx512_pku_linux (); - selftests::register_test (selftests::tdesc::i386_tdesc_test); + selftests::register_test ("i386-tdesc", selftests::tdesc::i386_tdesc_test); #ifdef __x86_64__ init_registers_x32_linux (); @@ -178,6 +178,6 @@ initialize_low_tdesc () init_registers_amd64_avx_avx512_linux (); init_registers_amd64_avx_mpx_avx512_pku_linux (); - selftests::register_test (selftests::tdesc::amd64_tdesc_test); + selftests::register_test ("amd64-tdesc", selftests::tdesc::amd64_tdesc_test); #endif } diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c index 56c6393..4669fb7 100644 --- a/gdb/gdbserver/server.c +++ b/gdb/gdbserver/server.c @@ -3587,6 +3587,7 @@ captured_main (int argc, char *argv[]) volatile int attach = 0; int was_running; bool selftest = false; + const char *selftest_filter = NULL; while (*next_arg != NULL && **next_arg == '-') { @@ -3707,6 +3708,11 @@ captured_main (int argc, char *argv[]) run_once = 1; else if (strcmp (*next_arg, "--selftest") == 0) selftest = true; + else if (startswith (*next_arg, "--selftest=")) + { + selftest = true; + selftest_filter = *next_arg + strlen ("--selftest="); + } else { fprintf (stderr, "Unknown argument: %s\n", *next_arg); @@ -3783,7 +3789,7 @@ captured_main (int argc, char *argv[]) if (selftest) { - selftests::run_tests (); + selftests::run_tests (selftest_filter); throw_quit ("Quit"); } diff --git a/gdb/maint.c b/gdb/maint.c index 28f7287..49dbee5 100644 --- a/gdb/maint.c +++ b/gdb/maint.c @@ -959,7 +959,16 @@ show_per_command_cmd (char *args, int from_tty) static void maintenance_selftest (char *args, int from_tty) { - selftests::run_tests (); + selftests::run_tests (args); +} + +static void +maintenance_info_selftests (char *arg, int from_tty) +{ + printf_filtered ("Registered selftests:\n"); + selftests::for_each_selftest ([] (const std::string &name) { + printf_filtered (" - %s\n", name.c_str ()); + }); } @@ -1147,6 +1156,9 @@ This will run any unit tests that were built in to gdb.\n\ gdb will abort if any test fails."), &maintenancelist); + add_cmd ("selftests", class_maintenance, maintenance_info_selftests, + _("List the registered selftests."), &maintenanceinfolist); + add_setshow_zinteger_cmd ("watchdog", class_maintenance, &watchdog, _("\ Set watchdog timer."), _("\ Show watchdog timer."), _("\ diff --git a/gdb/regcache.c b/gdb/regcache.c index dcbcedd..9e20b67 100644 --- a/gdb/regcache.c +++ b/gdb/regcache.c @@ -1775,7 +1775,8 @@ Print the internal register configuration including each register's\n\ remote register number and buffer offset in the g/G packets.\n\ Takes an optional file parameter."), &maintenanceprintlist); + #if GDB_SELF_TEST - selftests::register_test (selftests::current_regcache_test); + selftests::register_test ("current_regcache", selftests::current_regcache_test); #endif } diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y index 4cb3aa2..34070ee 100644 --- a/gdb/rust-exp.y +++ b/gdb/rust-exp.y @@ -2781,6 +2781,6 @@ _initialize_rust_exp (void) gdb_assert (code == 0); #if GDB_SELF_TEST - selftests::register_test (rust_lex_tests); + selftests::register_test ("rust-lex", rust_lex_tests); #endif } diff --git a/gdb/selftest-arch.c b/gdb/selftest-arch.c index 9a19f76..c258da3 100644 --- a/gdb/selftest-arch.c +++ b/gdb/selftest-arch.c @@ -25,12 +25,75 @@ namespace selftests { -static std::vector gdbarch_tests; +/* A kind of selftest that calls the test function once for each gdbarch known + to GDB. */ + +struct gdbarch_selftest : public selftest +{ + gdbarch_selftest (self_test_foreach_arch_function *function_) + : function (function_) + {} + + void operator() () const override + { + const char **arches = gdbarch_printable_names (); + bool pass = true; + + for (int i = 0; arches[i] != NULL; i++) + { + if (strcmp ("fr300", arches[i]) == 0) + { + /* PR 20946 */ + continue; + } + else if (strcmp ("powerpc:EC603e", arches[i]) == 0 + || strcmp ("powerpc:e500mc", arches[i]) == 0 + || strcmp ("powerpc:e500mc64", arches[i]) == 0 + || strcmp ("powerpc:titan", arches[i]) == 0 + || strcmp ("powerpc:vle", arches[i]) == 0 + || strcmp ("powerpc:e5500", arches[i]) == 0 + || strcmp ("powerpc:e6500", arches[i]) == 0) + { + /* PR 19797 */ + continue; + } + + QUIT; + + TRY + { + struct gdbarch_info info; + + gdbarch_info_init (&info); + info.bfd_arch_info = bfd_scan_arch (arches[i]); + + struct gdbarch *gdbarch = gdbarch_find_by_info (info); + SELF_CHECK (gdbarch != NULL); + + function (gdbarch); + } + CATCH (ex, RETURN_MASK_ERROR) + { + pass = false; + exception_fprintf (gdb_stderr, ex, + _("Self test failed: arch %s: "), arches[i]); + } + END_CATCH + + reset (); + } + + SELF_CHECK (pass); + } + + self_test_foreach_arch_function *function; +}; void -register_test_foreach_arch (self_test_foreach_arch_function *function) +register_test_foreach_arch (const std::string &name, + self_test_foreach_arch_function *function) { - gdbarch_tests.push_back (function); + register_test (name, new gdbarch_selftest (function)); } void @@ -41,72 +104,5 @@ reset () reinit_frame_cache (); } -static void -tests_with_arch () -{ - int failed = 0; - - for (const auto &f : gdbarch_tests) - { - const char **arches = gdbarch_printable_names (); - - for (int i = 0; arches[i] != NULL; i++) - { - if (strcmp ("fr300", arches[i]) == 0) - { - /* PR 20946 */ - continue; - } - else if (strcmp ("powerpc:EC603e", arches[i]) == 0 - || strcmp ("powerpc:e500mc", arches[i]) == 0 - || strcmp ("powerpc:e500mc64", arches[i]) == 0 - || strcmp ("powerpc:titan", arches[i]) == 0 - || strcmp ("powerpc:vle", arches[i]) == 0 - || strcmp ("powerpc:e5500", arches[i]) == 0 - || strcmp ("powerpc:e6500", arches[i]) == 0) - { - /* PR 19797 */ - continue; - } - - QUIT; - - TRY - { - struct gdbarch_info info; - - gdbarch_info_init (&info); - info.bfd_arch_info = bfd_scan_arch (arches[i]); - - struct gdbarch *gdbarch = gdbarch_find_by_info (info); - SELF_CHECK (gdbarch != NULL); - f (gdbarch); - } - CATCH (ex, RETURN_MASK_ERROR) - { - ++failed; - exception_fprintf (gdb_stderr, ex, - _("Self test failed: arch %s: "), arches[i]); - } - END_CATCH - - reset (); - } - } - - SELF_CHECK (failed == 0); -} - } // namespace selftests #endif /* GDB_SELF_TEST */ - -/* Suppress warning from -Wmissing-prototypes. */ -extern initialize_file_ftype _initialize_selftests_foreach_arch; - -void -_initialize_selftests_foreach_arch () -{ -#if GDB_SELF_TEST - selftests::register_test (selftests::tests_with_arch); -#endif -} diff --git a/gdb/selftest-arch.h b/gdb/selftest-arch.h index dc16c4d..f1fa38e 100644 --- a/gdb/selftest-arch.h +++ b/gdb/selftest-arch.h @@ -24,7 +24,8 @@ typedef void self_test_foreach_arch_function (struct gdbarch *); namespace selftests { extern void - register_test_foreach_arch (self_test_foreach_arch_function *function); + register_test_foreach_arch (const std::string &name, + self_test_foreach_arch_function *function); } #endif /* SELFTEST_ARCH_H */ diff --git a/gdb/unittests/array-view-selftests.c b/gdb/unittests/array-view-selftests.c index e5c0043..f618c40 100644 --- a/gdb/unittests/array-view-selftests.c +++ b/gdb/unittests/array-view-selftests.c @@ -491,5 +491,6 @@ run_tests () void _initialize_array_view_selftests () { - selftests::register_test (selftests::array_view_tests::run_tests); + selftests::register_test ("array_view", + selftests::array_view_tests::run_tests); } diff --git a/gdb/unittests/environ-selftests.c b/gdb/unittests/environ-selftests.c index 81a71ee..f770901 100644 --- a/gdb/unittests/environ-selftests.c +++ b/gdb/unittests/environ-selftests.c @@ -301,5 +301,6 @@ run_tests () void _initialize_environ_selftests () { - selftests::register_test (selftests::gdb_environ_tests::run_tests); + selftests::register_test ("gdb_environ", + selftests::gdb_environ_tests::run_tests); } diff --git a/gdb/unittests/function-view-selftests.c b/gdb/unittests/function-view-selftests.c index d3018ba..a899299 100644 --- a/gdb/unittests/function-view-selftests.c +++ b/gdb/unittests/function-view-selftests.c @@ -174,5 +174,6 @@ run_tests () void _initialize_function_view_selftests () { - selftests::register_test (selftests::function_view::run_tests); + selftests::register_test ("function_view", + selftests::function_view::run_tests); } diff --git a/gdb/unittests/offset-type-selftests.c b/gdb/unittests/offset-type-selftests.c index 3e66547..5176f20 100644 --- a/gdb/unittests/offset-type-selftests.c +++ b/gdb/unittests/offset-type-selftests.c @@ -174,5 +174,5 @@ run_tests () void _initialize_offset_type_selftests () { - selftests::register_test (selftests::offset_type::run_tests); + selftests::register_test ("offset_type", selftests::offset_type::run_tests); } diff --git a/gdb/unittests/optional-selftests.c b/gdb/unittests/optional-selftests.c index 0bcf964..8ea19bb 100644 --- a/gdb/unittests/optional-selftests.c +++ b/gdb/unittests/optional-selftests.c @@ -90,5 +90,5 @@ run_tests () void _initialize_optional_selftests () { - selftests::register_test (selftests::optional::run_tests); + selftests::register_test ("optional", selftests::optional::run_tests); } diff --git a/gdb/unittests/scoped_restore-selftests.c b/gdb/unittests/scoped_restore-selftests.c index ea7492b..bc9aa2b 100644 --- a/gdb/unittests/scoped_restore-selftests.c +++ b/gdb/unittests/scoped_restore-selftests.c @@ -106,5 +106,6 @@ run_tests () void _initialize_scoped_restore_selftests () { - selftests::register_test (selftests::scoped_restore_tests::run_tests); + selftests::register_test ("scoped_restore", + selftests::scoped_restore_tests::run_tests); } diff --git a/gdb/utils-selftests.c b/gdb/utils-selftests.c index 08feac6..5a30a93 100644 --- a/gdb/utils-selftests.c +++ b/gdb/utils-selftests.c @@ -55,6 +55,6 @@ void _initialize_utils_selftests (void) { #if GDB_SELF_TEST - selftests::register_test (selftests::common_utils_tests); + selftests::register_test ("common-utils", selftests::common_utils_tests); #endif } diff --git a/gdb/utils.c b/gdb/utils.c index af50cf0..c67dc90 100644 --- a/gdb/utils.c +++ b/gdb/utils.c @@ -3307,6 +3307,6 @@ _initialize_utils (void) add_internal_problem_command (&demangler_warning_problem); #if GDB_SELF_TEST - selftests::register_test (gdb_realpath_tests); + selftests::register_test ("gdb_realpath", gdb_realpath_tests); #endif }