From patchwork Mon May 21 11:06:51 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Philippe Waroquiers X-Patchwork-Id: 27351 Received: (qmail 87210 invoked by alias); 21 May 2018 11:07:22 -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 87080 invoked by uid 89); 21 May 2018 11:07:21 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-27.6 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, RCVD_IN_DNSWL_LOW, SPF_PASS autolearn=ham version=3.3.2 spammy=1-3, sk:environ, nan X-HELO: mailsec110.isp.belgacom.be Received: from mailsec110.isp.belgacom.be (HELO mailsec110.isp.belgacom.be) (195.238.20.106) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 21 May 2018 11:07:19 +0000 IronPort-PHdr: =?us-ascii?q?9a23=3AoQ90/BEJet8ZCHNHwPEG+51GYnF86YWxBRYc798d?= =?us-ascii?q?s5kLTJ7zr8ywAkXT6L1XgUPTWs2DsrQY07GQ6/iocFdDyK7JiGoFfp1IWk1Nou?= =?us-ascii?q?QttCtkPvS4D1bmJuXhdS0wEZcKflZk+3amLRodQ56mNBXdrXKo8DEdBAj0OxZr?= =?us-ascii?q?KeTpAI7SiNm82/yv95HJbAhEmDSwbaluIBmqsA7cqtQYjYx+J6gr1xDHuGFIe+?= =?us-ascii?q?NYxWNpIVKcgRPx7dqu8ZBg7ipdpesv+9ZPXqvmcas4S6dYDCk9PGAu+MLrrxjD?= =?us-ascii?q?QhCR6XYaT24bjwBHAwnB7BH9Q5fxri73vfdz1SWGIcH7S60/VDK/5KlpVRDokj?= =?us-ascii?q?8KOT4n/m/KhMJ+j6VVrxCvpxFk34LYfJuYOOZkc6/BYd8XQ3dKUMZLVyxGB4Ox?= =?us-ascii?q?d5EBD+oAPeZcron9v0MOogWjDgasHuzv0DhIhmbr3a07zeshCxrG1xEnEtIWsH?= =?us-ascii?q?TUrdH1NKYKUeCt0qbE1zvCYOlM2Tf68YjIbxEhru+WXbJrasfR0kovFgPDjlqO?= =?us-ascii?q?tYzpJSia2foUvmWd8uFuW+Wvi2s9pAFwpDii3sgsio/Uho4PzVDE7yp5zYAoLt?= =?us-ascii?q?O7UE52ecOoHIdUui2AKod7TN8uT3t1tCoky7AKo4C3cSYUxJkh2hXRceaIc5KS?= =?us-ascii?q?7RLmTOuRJDB4i297d7+nnBay9FSgyvX7VsmpzFZGtipFncfItnAKzxHT79WIRu?= =?us-ascii?q?F9/kem3DaAyRjf6uBCIU8qiarWM4MtzqI0m5YJrEjOEDP6lF/rgKOId0go4Pak?= =?us-ascii?q?5ur5brn+o5+TLY50igXwMqQ0ncy/BPw1MhAOX2ia/eS81aXj/VXnT7lQgPw5iL?= =?us-ascii?q?PZsJfDJcQGp662HRVV0p045hakDDen0NIYkmcbLF5fYx2IkZDlO0vSL/DgEfe/?= =?us-ascii?q?n1OsnS9kx//bJbLtG43NIWLfkLj9fbZy9VVcxREozdBY+pJUEK0OL+z9W0Drrt?= =?us-ascii?q?zXEAU1Mwuuw+boEN99zJ8RWXqTAq+FN6PfqUeI5uIuI+mIZY8VoC79JOY/6//g?= =?us-ascii?q?l3A5g1gdfbC03ZsWdn+4BO9mLl6CYXrvgtYBF3kFvhYkQOPxllLRGQJUMnm+Ve?= =?us-ascii?q?ck7y0wCI+9JZzEW5qmjaOIxir9GYdZNU5cDVXZKXfpc4ScQ/pEVyuIJdZ8kzEe?= =?us-ascii?q?TvD1U48g0RC2rAK81LN9KfPJ+yACrrr418lz6vGVnxxkpm88NNiUz2zYFzI8pW?= =?us-ascii?q?gPXTJjhK0=3D?= X-IronPort-Anti-Spam-Filtered: true X-IronPort-Anti-Spam-Result: =?us-ascii?q?A2A/CABwpwJb/+h+gm1cHgEGDINDJD19K?= =?us-ascii?q?IxYjBMBgikBXZNKgWQLHwwBgUuCdQKCFSI3FQECAQEBAQEBAgFrHAyCNSKCUgZ?= =?us-ascii?q?WIxA/EjkeIoMZAoIDqHKEWINmgg+KCT+FZoE7gTKGDwKYCUMHAoFnhAOIYguBd?= =?us-ascii?q?YsIinWGAoElMiKBUm2DFgmCFxeGG4I+hUA9MHgBGgGPHwEB?= X-IPAS-Result: =?us-ascii?q?A2A/CABwpwJb/+h+gm1cHgEGDINDJD19KIxYjBMBgikBXZN?= =?us-ascii?q?KgWQLHwwBgUuCdQKCFSI3FQECAQEBAQEBAgFrHAyCNSKCUgZWIxA/EjkeIoMZA?= =?us-ascii?q?oIDqHKEWINmgg+KCT+FZoE7gTKGDwKYCUMHAoFnhAOIYguBdYsIinWGAoElMiK?= =?us-ascii?q?BUm2DFgmCFxeGG4I+hUA9MHgBGgGPHwEB?= Received: from 232.126-130-109.adsl-dyn.isp.belgacom.be (HELO md.home) ([109.130.126.232]) by relay.skynet.be with ESMTP/TLS/DHE-RSA-AES128-GCM-SHA256; 21 May 2018 13:07:00 +0200 From: Philippe Waroquiers To: gdb-patches@sourceware.org Cc: Philippe Waroquiers Subject: [RFA 8/8] Add a self-test for cli-utils.c Date: Mon, 21 May 2018 13:06:51 +0200 Message-Id: <20180521110651.13842-9-philippe.waroquiers@skynet.be> In-Reply-To: <20180521110651.13842-1-philippe.waroquiers@skynet.be> References: <20180521110651.13842-1-philippe.waroquiers@skynet.be> X-IsSubscribed: yes tests added for: * number_or_range_parser number_or_range_parser is somewhat cumbersome to use and/or does not work as described in cli-utils.h In particular, cur_tok () is currently not maintained as described in cli-utils.h, but changing this is better done in another patch, as it implies to change callers. The SELF_CHECK for cumbersome (or unexpected) behaviour are commented now. Note that the same commented tests are similarly wrong in unpatched gdb. * check_for_flags_vqcs * check_for_flags --- gdb/Makefile.in | 1 + gdb/unittests/cli-utils-selftests.c | 228 ++++++++++++++++++++++++++++++++++++ 2 files changed, 229 insertions(+) create mode 100644 gdb/unittests/cli-utils-selftests.c diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 09a2ad2ca3..7fdb774036 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -416,6 +416,7 @@ SUBDIR_PYTHON_CFLAGS = SUBDIR_UNITTESTS_SRCS = \ unittests/array-view-selftests.c \ + unittests/cli-utils-selftests.c \ unittests/common-utils-selftests.c \ unittests/environ-selftests.c \ unittests/format_pieces-selftests.c \ diff --git a/gdb/unittests/cli-utils-selftests.c b/gdb/unittests/cli-utils-selftests.c new file mode 100644 index 0000000000..31cede7398 --- /dev/null +++ b/gdb/unittests/cli-utils-selftests.c @@ -0,0 +1,228 @@ +/* Unit tests for the cli-utils.c file. + + Copyright (C) 2018 Free Software Foundation, Inc. + + This file is part of GDB. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "defs.h" +#include "cli/cli-utils.h" +#include "selftest.h" + +namespace selftests { +namespace cli_utils { + +static void +test_number_or_range_parser () +{ + number_or_range_parser one ("1"); + + SELF_CHECK (one.finished () == false); + SELF_CHECK (one.get_number () == 1); + SELF_CHECK (one.finished () == true); + SELF_CHECK (strcmp (one.cur_tok (), "") == 0); + + number_or_range_parser one_after ("1 after"); + + SELF_CHECK (one_after.finished () == false); + SELF_CHECK (one_after.get_number () == 1); + // SELF_CHECK (one_after.finished () == true); + // number_or_range_parser is cumbersome : to have finished == true, + // you have to call get_number once more. But then, the cur_tok is wrong. + // It should be restructured to have the setup (e.g. discovering if + // we have a number or a range or something else) in the init phase. + // This allows to indicate finished == true just after init, + // in case the init string is not a number or range. + SELF_CHECK (strcmp (one_after.cur_tok (), "after") == 0); + + number_or_range_parser one_three ("1-3"); + + for (int i = 1; i < 4; i++) { + SELF_CHECK (one_three.finished () == false); + SELF_CHECK (one_three.get_number () == i); + } + SELF_CHECK (one_three.finished () == true); + SELF_CHECK (strcmp (one_three.cur_tok (), "") == 0); + + number_or_range_parser one_three_after ("1-3 after"); + + for (int i = 1; i < 4; i++) { + SELF_CHECK (one_three_after.finished () == false); + SELF_CHECK (one_three_after.get_number () == i); + } + // SELF_CHECK (one_three_after.finished () == true); + // See above. + SELF_CHECK (strcmp (one_three_after.cur_tok (), "after") == 0); + + number_or_range_parser minus_one ("-1"); + + SELF_CHECK (minus_one.finished () == false); + TRY + { + minus_one.get_number (); + SELF_CHECK (false); + } + CATCH (ex, RETURN_MASK_ERROR) + { + SELF_CHECK (ex.reason == RETURN_ERROR); + SELF_CHECK (ex.error == GENERIC_ERROR); + SELF_CHECK (strcmp (ex.message, "negative value") == 0); + SELF_CHECK (strcmp (minus_one.cur_tok (), "-1") == 0); + } + END_CATCH; + + number_or_range_parser nan ("-whatever"); + + // SELF_CHECK (nan.finished () == true); + // See above + SELF_CHECK (one_three_after.get_number () == 0); + SELF_CHECK (strcmp (nan.cur_tok (), "-whatever") == 0); +} + +static void +test_check_for_flags () +{ + const char *flags = "abc"; + const char *non_flags_args = "non flags args"; + int flags_counts[strlen (flags)]; + int res; + + const char *t1 = "-aa non flags args"; + + SELF_CHECK (check_for_flags (&t1, flags, flags_counts) == 1); + SELF_CHECK (strcmp (t1, non_flags_args) == 0); + SELF_CHECK (flags_counts[0] == 2 + && flags_counts[1] == 0 + && flags_counts[2] == 0); + + const char *t2 = "-cbcbc non flags args"; + + SELF_CHECK (check_for_flags (&t2, flags, flags_counts) == 1); + SELF_CHECK (strcmp (t2, non_flags_args) == 0); + SELF_CHECK (flags_counts[0] == 0 + && flags_counts[1] == 2 + && flags_counts[2] == 3); + + const char *t3 = non_flags_args; + + SELF_CHECK (check_for_flags (&t3, flags, flags_counts) == 0); + SELF_CHECK (strcmp (t3, non_flags_args) == 0); + SELF_CHECK (flags_counts[0] == 0 + && flags_counts[1] == 0 + && flags_counts[2] == 0); + + const char *t4 = "-cbxyzc"; + const char *orig_t4 = t4; + + SELF_CHECK (check_for_flags (&t4, flags, flags_counts) == -1); + SELF_CHECK (strcmp (t4, orig_t4) == 0); + SELF_CHECK (flags_counts[0] == 0 + && flags_counts[1] == 1 + && flags_counts[2] == 2); + +} + +static void +test_check_for_flags_vqcs () +{ + int verbosity; + bool cont; + bool silent; + const char *non_flags_args = "non flags args"; + + const char *t1 = "-vvvqqqs non flags args"; + + verbosity = 1; + cont = true; + silent = false; + SELF_CHECK (check_for_flags_vqcs ("test_check_for_flags_vqcs.t1", + &t1, + &verbosity, + 4, &cont, &silent) == 1); + SELF_CHECK (verbosity == 1); + SELF_CHECK (cont == false && silent == true); + SELF_CHECK (strcmp (t1, non_flags_args) == 0); + + const char *t2 = "non flags args"; + + verbosity = 2; + cont = true; + silent = true; + SELF_CHECK (check_for_flags_vqcs ("test_check_for_flags_vqcs.t2", + &t2, + &verbosity, + 4, &cont, &silent) == 0); + SELF_CHECK (verbosity == 2); + SELF_CHECK (cont == false && silent == false); + SELF_CHECK (strcmp (t2, non_flags_args) == 0); + + const char *t3 = "-123 non flags args"; + const char *orig_t3 = t3; + + verbosity = 3; + cont = true; + silent = true; + SELF_CHECK (check_for_flags_vqcs ("test_check_for_flags_vqcs.t3", + &t3, + &verbosity, + 4, &cont, &silent) == 0); + SELF_CHECK (verbosity == 3); + SELF_CHECK (cont == false && silent == false); + SELF_CHECK (strcmp (t3, orig_t3) == 0); + + const char *t4 = "-qqxyz non flags args"; + const char *orig_t4 = t4; + TRY + { + verbosity = 4; + cont = true; + silent = true; + (void) check_for_flags_vqcs ("test_check_for_flags_vqcs.t4", + &t4, + &verbosity, + 4, &cont, &silent); + SELF_CHECK (false); + } + CATCH (ex, RETURN_MASK_ERROR) + { + SELF_CHECK (ex.reason == RETURN_ERROR); + SELF_CHECK (ex.error == GENERIC_ERROR); + SELF_CHECK + (strcmp (ex.message, + "test_check_for_flags_vqcs.t4 only accepts flags vqcs") == 0); + SELF_CHECK (strcmp (t4, orig_t4) == 0); + SELF_CHECK (verbosity == 4); + } + END_CATCH; + +} + +static void +test_cli_utils () +{ + selftests::cli_utils::test_number_or_range_parser (); + selftests::cli_utils::test_check_for_flags (); + selftests::cli_utils::test_check_for_flags_vqcs (); +} + +} +} + +void +_initialize_cli_utils_selftests () +{ + selftests::register_test ("cli_utils", + selftests::cli_utils::test_cli_utils); +}