From patchwork Mon Apr 9 19:01:32 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 26661 Received: (qmail 43303 invoked by alias); 9 Apr 2018 19:01:59 -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 43286 invoked by uid 89); 9 Apr 2018 19:01:59 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-25.6 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=7812, compares, H*r:207 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; Mon, 09 Apr 2018 19:01:57 +0000 Received: from ESESSHC001.ericsson.se (Unknown_Domain [153.88.183.21]) by sessmg23.ericsson.net (Symantec Mail Security) with SMTP id 38.86.29657.2A8BBCA5; Mon, 9 Apr 2018 21:01:54 +0200 (CEST) Received: from ESESSMB502.ericsson.se (153.88.183.163) by ESESSHC001.ericsson.se (153.88.183.21) with Microsoft SMTP Server (TLS) id 14.3.382.0; Mon, 9 Apr 2018 21:01:54 +0200 Received: from ESESSMB502.ericsson.se (153.88.183.163) by ESESSMB502.ericsson.se (153.88.183.163) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1034.26; Mon, 9 Apr 2018 21:01:53 +0200 Received: from NAM02-SN1-obe.outbound.protection.outlook.com (153.88.183.157) by ESESSMB502.ericsson.se (153.88.183.163) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1034.26 via Frontend Transport; Mon, 9 Apr 2018 21:01:53 +0200 Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=simon.marchi@ericsson.com; Received: from [142.133.61.222] (192.75.88.130) by BL0PR1501MB2001.namprd15.prod.outlook.com (2603:10b6:207:31::31) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.653.12; Mon, 9 Apr 2018 19:01:50 +0000 Subject: Re: [PATCH] Add selftests for range_contains and insert_into_bit_range_vector To: Pedro Alves , Simon Marchi , References: <20180407143801.19596-1-simon.marchi@polymtl.ca> From: Simon Marchi Message-ID: <09d2a032-8726-6351-ab9a-63574734a3e5@ericsson.com> Date: Mon, 9 Apr 2018 15:01:32 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.7.0 MIME-Version: 1.0 In-Reply-To: X-ClientProxiedBy: MWHPR03CA0006.namprd03.prod.outlook.com (2603:10b6:300:117::16) To BL0PR1501MB2001.namprd15.prod.outlook.com (2603:10b6:207:31::31) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: be1b8524-e9d1-44e8-73ef-08d59e4c5a30 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(5600026)(4604075)(4534165)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020); SRVR:BL0PR1501MB2001; X-Microsoft-Exchange-Diagnostics: 1; BL0PR1501MB2001; 3:uRu0V2R4aNhGlytm2CK2e2lgo/CUczkDmsWJZvb9zoy+N4I0qbGJtsS1V5ZQY0PidCCcVFbbmgA61RLdtJTwIV3q9cLFKnTJynnYsPRuNRZMi8TXZNHH2Rk4Z+1zpPwtEhGTFQOe8QLCyHwQcjUdCvRbJqnR/VWLdvH5GrBGmghu3hzKWURz97C0cDr19kNTWX/NI+p4Fdy5wJ0ABupCatxe2HUlldTHOQ3CEIJLAMm6aZYGwCJbPK+6DqH+7lci; 25:9xZ0GdRJdBywnW+uX9BWnMW9kgMtN4Tkq9BNdvmRRLtRzEqrA5+9XvpBNDRYqDu9i4gAVbKP3fjtVm5lnfAr/97Uvl85Hk8qNap0SC9S+hpJu7t4/EFng9c9SiQA8eb6eoX1ETVhUiWlvjZXqrZgKChBc3DU+gP4cyFqIEI6ufYi7zCiqQKwdZgfVg5s/1AN9WWRPk/CcEVzOSpjmdnsh3zCPWkDdIMsjYbdC5Yhi4lIG9mGEV34hPnCxpxOLgSj5yxkCjpYCEailJQM4YBisTbLLurGNxmhqD1oihWgDBtPcCEEzTF6WzNo7WQEOxsYX2NjtQJum+C7jAXt/czf2g==; 31:HzupcPxspUp8WQcotUDS2xHNvXtgBWEHhDUBW2voJ2i4zSl1md08XK1Z1T5+alMmaBLZty124lAKHcBmYSCQoCDHfoCy3QA2Zcvq6Mekl2vVFau+tNfF0ZeO8ILrk95XMUoBk/m58XgAt5JXSGbFJOU1MCIV3imI+KE0fya8xUKxLWvz2oZOUfYh8kDivnC7FM0PzLHBpOKDEfMyP+Tqs/4q+kDcA8ooOHjvIexcA5g= X-MS-TrafficTypeDiagnostic: BL0PR1501MB2001: X-Microsoft-Exchange-Diagnostics: 1; BL0PR1501MB2001; 20:EZ6ACQHx9RFxX0mHTwrx5sNYFbkHrAg/A6YqtPh6PH6BN+yD0HcwMTKzbL+SNjc5wMhQY4+h8ldP9/5Ho+aKV5z+KobyKsMcgJLlvMfJVLOZ1bde1F6hNe/sSlIFJ4BqpfGC6s+4CFpKCJEIeYl3dtFxCnPYml8K/+rPT5B8D0SxTAM05d2/o3i64UR9cQ5V5b/HNjYNnFKiTJMYteUMNGaAlPmzlqqacLFq2PUrZMzT2X/6TobM40Slf+qZOWErs0W4wNWX/27r5rXJ6nCnUJjxY38kRUz/imhSHYuTUw/OxSfL1Kslr28y02CL8fi/TV2NW5I4bYGkmfDFKf6EKKsFBmxkGr7XaUrttQjQpXB4U0gipS2l4PfLSgraTG8jSJBPCAqy/JAROMWxwuTRJrF3RMg7NccFlP8E0YI/QM3vMOVdzveWimlJNtlRYoQ30PrTZli9peW2iybAUWROvyqwlTcMlRLyQ445L2/pr2pFX0KFEQZ9y9T8ILJ/Vw4o; 4:qqADrIcUbqc2sGtfAvmGcx0jevkOr676F/w+LTNFkRlNWQHmQ8SsB5zqIOkXyIukzS4csRTg0zARI20p32xEqUw5u0YHwqpObgAYQnMp/XY87EY1azU/t1g2cSJePNYv/4M7qyqji+ru+RaGedzkAm2vKPJMmbT/azFZxJyvei/euNQ1Dkt8SPZ8MldSjPhHap8g9tlhJEaM3QEGXn0cFLFrOLE3ywSa67UdbPl8zEFX5Mvj8qYlGf3FJbrfA/MMB/TIJDN10AUZgkVKAbScCOaexHRcHoAwnKyE5RdXQQ8Tq7oIJpg7Jc1jJrH1mnRJ X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(131327999870524); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(8121501046)(5005006)(10201501046)(3002001)(93006095)(93001095)(3231221)(944501327)(52105095)(6041310)(20161123558120)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123560045)(20161123562045)(20161123564045)(6072148)(201708071742011); SRVR:BL0PR1501MB2001; BCL:0; PCL:0; RULEID:; SRVR:BL0PR1501MB2001; X-Forefront-PRVS: 0637FCE711 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(6049001)(39380400002)(396003)(366004)(376002)(346002)(39860400002)(189003)(54534003)(377424004)(199004)(2906002)(31686004)(52116002)(65806001)(386003)(66066001)(65956001)(23676004)(6116002)(2486003)(53546011)(64126003)(229853002)(25786009)(52146003)(47776003)(3846002)(97736004)(8936002)(8676002)(105586002)(7736002)(478600001)(81166006)(81156014)(68736007)(5660300001)(76176011)(305945005)(50466002)(31696002)(36756003)(6666003)(53936002)(956004)(2616005)(86362001)(11346002)(6246003)(65826007)(476003)(446003)(230700001)(6486002)(486006)(16526019)(316002)(49976009)(186003)(16576012)(106356001)(58126008)(110136005)(26005)(78286006); DIR:OUT; SFP:1101; SCL:1; SRVR:BL0PR1501MB2001; H:[142.133.61.222]; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; MX:1; A:1; Received-SPF: None (protection.outlook.com: ericsson.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?utf-8?B?MTtCTDBQUjE1MDFNQjIwMDE7MjM6Rmd2V3pQVjBMalQ0dFo4RiszSWRHVlZT?= =?utf-8?B?azhhWTZ6YlJTNGVleDJhRy9Scm42NE4xMkJoVjdVTG5wTlVGQXppRi9ZUUwr?= =?utf-8?B?RDdEMjhOUmpaUitUNGo1YThuUVlMbnNuUUhQbjU1SUpIL1AwNmFSMCtBMFN1?= =?utf-8?B?aTlvV3Qvb1VhMmdCSU1VMUE4UDRUeTdhSGVsN2t6M0FSdmx5NDhPaCtycTdN?= =?utf-8?B?TlVlOXRNeFAvdzJFd09EdE5VNGJ4cStaNnRQNDBDRjZyU3FwS1E2blRTeGFq?= =?utf-8?B?Wm9hV01LcUE2Rm1HaTByWnFNTkkxSUlaZ1g5V2I4UWRRSnhEZU1YbThGU2lQ?= =?utf-8?B?RXpRNTBmRHQ0UDZxSGlhTFU5M0wxUmpJZ3V6N0I5NWdvY21NdUNlNHU2RWhK?= =?utf-8?B?TnJkMlZ6MnJmQUIzVGY0S09vcFVML2JBQ2g0WmNkT2xJUnhCZmRULytvZkJj?= =?utf-8?B?MFlNbXdKTlJ3aHlFZGlJTFNZbzF4My9nYjJDMG5EZ3NBZGRoQXhQWWUrS3Ex?= =?utf-8?B?Q2J4SUVHY1gySFhOSmVhZmtlbjQ5anlKRDlZOUpkNmJHdzZMb053YVBGdHAx?= =?utf-8?B?OEx2Njd0cURoTzBHbHBwTC9kTVBQblN2US9WTzNsVUxLQTZMSDNTdURHK2VF?= =?utf-8?B?dld0VThwdi9sUGF1N2FKaEdQaHVXWVI5WlpuaUJ0V2Zlc25CTGdyaXUrUnEw?= =?utf-8?B?NnJSRTJGekpBck9FaEE4ZnpmUmhSa1NVamxqampjYTVWLyt6WmZTcU9hbGh1?= =?utf-8?B?RDlla1VsOGZrOCtlek1Ta0ZQSEZKZ3k4MEhQMjRTQ2NZZlpwa3ZlR3JXVFc1?= =?utf-8?B?ZlRJN0dqZ3FBSVNucGl6SkNRb0dRQ1FjeU91YXBFZ3QvRW1ML1k4UkQvZmlo?= =?utf-8?B?ZytzYytWQS9wNFhDMmFNTUdGcXQxNzM2aFZBN2J4eVBTbFBzaS9YNUR0U0tC?= =?utf-8?B?YzhYSjdOTEw5R2xjSUdVN2VuZSs1M0tlbDlvOHVIUU8vQlYxK2lRZEs1TVc0?= =?utf-8?B?L2FBbTJJcWtXbHhsOVZ6TStRNXVFVERpd3ZuYW4yaU5OOVo0bHRoWFNRZ3FT?= =?utf-8?B?WHh4cjdzYlJvTEtZQzY3TDBUZFFSSUh2WVFBVHFHVlpmUE9RUVZlaGlwdGJQ?= =?utf-8?B?c3k3MnBUb1Y2Ulc3YzVCVks1OHFSeWh5R1JSR05YM1QvQXBuSWJJTEhhZERy?= =?utf-8?B?MTB0Z0wzSTJDb1BmUmIzQ1Y5aDVzdEtZSmNhMW05WXQySG5pWVJaT3VkUmhY?= =?utf-8?B?QjJ5Q21hQ213RDFsS1lGcHp5T1cwTU1GV0l4clliZitlUWF6MS9sVStwYW5u?= =?utf-8?B?OU15SU5HRmpFRWpHUGYxdWdxMHhUbnNhaWZrWUJFcENWMmVMNHdya2J6Wlgx?= =?utf-8?B?MHBaTjJKbkpVbkEyaW9KdS9mbnoxTWhBK3MxcTJ6eGU4YmRqaXI0VncyNmtX?= =?utf-8?B?MzRWYi9GMW9hbjd3Wk0xWlJEdVFNNDl0SVhUczl4WjNudnBVdmZvOTRCUTF6?= =?utf-8?B?Y1VjSFNBd3lnRkNzcTRoeFpnclNMS082QmxsWVZKZWZPejdzS0kybXE4VUI3?= =?utf-8?B?aEdLQnNSR2pYelRZRkhjUUZROUlia3BuaTNJUFkzMXVQMkJxTHFkWHdiUklO?= =?utf-8?B?MUs5U0NJSy8zNWlibnJKTWNQZ0RnNlQ4czd0VFJNV3RTMm54SkVaQmdudWFL?= =?utf-8?B?dnV3Yy9ydTlaVnVkbEZUQ2JWRzNnbWY1M0hQTWt2TnQ4UjNLOXRuNkdPcDc3?= =?utf-8?B?Y05ieW5Pdk5SQmUwWVpLclhmcTZaV0haSkprMXdIVllvZWh4NkZHSFdCUll4?= =?utf-8?B?RlVUUGxoSExETFVVRFl5cEY4bTRVOWVIdTJNNDFqNDBiS1dkbStkU2plazRH?= =?utf-8?B?NTlMMWVORnFQaWpkRW93RHZIRGFFRk5UdVd4ay8ybDgxaERzUWlKcU1GV2xj?= =?utf-8?B?YWFRRnRLSENkZGtzYkQ0WjFKOUhsSHVsMUtsT1BaS2d1cDZiMlhOYnAvRmZu?= =?utf-8?Q?gff5WysO?= X-Microsoft-Antispam-Message-Info: cOuraqV2IendE2QTNBNVcm2VJQ+KxSFybnlOQfS9wbLYYMiVyTgWQ5vHplUTP/LbV6xi/6BRSUP4QCIuVwpGEdBPSYyWXhPqmte3F12GZIaQf7C7xxALJUPYSwjim1JiazGejZ8IC9dTwovTHBEA1EFWtuXQD8mIjxnTL1LSl5V9xVH2HQYbGftafz3+NINj X-Microsoft-Exchange-Diagnostics: 1; BL0PR1501MB2001; 6:DuQ6x+3cp9TU5MiyAyoiKYuBAMa65Pr53Rcy0TOf5nRhEDYyDn4SfvbAQvo4AV5Xl6RZlabZzm6zCWiv9eA0mMdfUL9KC8b/W8McX5IfX/OiXU1UN0pAxpN8kEAjl6/ee2BHsdQo5FSOBDCMCuPpz9y4exzGIIPOacpQ1EgpuqZ3OFP5PFX+PsSV5TmbqDme9/LIozfG2eGNE/+Qxi50ARaQyCoR8Fc6tTvc8TaoWZ94kdSeU/kEpYN1yxsJXb4tdsfS05psNcl/XQSaGuUexXgMLbZTOMc6Gx7TRKB0fetCDFerKYrUJ7tvNdNmMleWefph/OTaCI0M0STq7VjLgyhJ/EFppQRBVYvLQTGWqwF5vhqoRu6YJyoipuRerniftRu8bEOUM9YWJAxFaKFrdx/jPlSIrM3mIQiI5Fpb7Cks/bI5osWlZjW562CMF3rGuvGW37v6R9ZvwLAhg1IokA==; 5:YbLZpX0HN/wDqBVRqHLVcyBrtbZH8lgo2uQh1DL0k8EP6s2/L44Z441DVIWqme8exaOxGDPL+lehqzHuPB+zBAumeAwAp6nR8VTORJlm0Q7qnSztPWsftJCxhfGuYYBfTzdAoVFi5Vmu9hdJHcoQS02S02kZ3D2/IckipkGNr6Q=; 24:6sniJ9kMhlCjhnWrHJd6Ac3xr2B9GVKIYuSNpP1luK6jAstIHs+UdclYLEw2DAU6QTfENEU8P3Jiopdtco+99LCj45/7zZfXD2OczoePaLU= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BL0PR1501MB2001; 7:EcEj8bffqPNaYE7H3IFgNftUHrS+xicPGm8SH2cB6I1VM8Je9PTnqfbHgdJJuXwpPevsr4eGUkhybo9ZYxe9VwlOCQtqf9v07rKsBq/H71EoviT6tGHJxHKUQ8PCRyMamA2FIYdsDuLZkosL1F6lX64K1aCT8vnuxzzpCmStah8LKoG4HWT0FlJC8ljR/aGJDx/AYyK2+0d/+bb/dEY1oDd4xV9e6AM6v2MZ7lu5JWAjpX9pLX8y/jdJH+UkZz9r X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Apr 2018 19:01:50.1664 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: be1b8524-e9d1-44e8-73ef-08d59e4c5a30 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 92e84ceb-fbfd-47ab-be52-080c6b87953f X-MS-Exchange-Transport-CrossTenantHeadersStamped: BL0PR1501MB2001 X-OriginatorOrg: ericsson.com X-IsSubscribed: yes On 2018-04-07 02:33 PM, Pedro Alves wrote: > See patch below on top of yours implementing most of the suggestions > above, except the missing comments. > > WDYT? I agree with all your suggested changes. Here is the merged patch I would push. I also changed "test_range_contains" to "test_ranges_contain" to match the name of the function. From 2cff246786550ab5239b7d388db47bf3457e870a Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Sat, 7 Apr 2018 10:38:01 -0400 Subject: [PATCH] Add selftests for range_contains and insert_into_bit_range_vector Add some selftests for these two functions. To to make it easier to compare sequences of ranges, add operator== and operator!= to compare two gdb::array_view, and add operator== in struct range. gdb/ChangeLog: * value.c: Include "selftest.h" and "common/array-view.h". (struct range) : New. (test_ranges_contain): New. (check_ranges_vector): New. (test_insert_into_bit_range_vector): New. (_initialize_values): Register selftests. * common/array-view.h (operator==, operator!=): New. --- gdb/common/array-view.h | 27 +++++++++ gdb/value.c | 155 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 182 insertions(+) diff --git a/gdb/common/array-view.h b/gdb/common/array-view.h index 3a09ec7..319ea99 100644 --- a/gdb/common/array-view.h +++ b/gdb/common/array-view.h @@ -174,6 +174,33 @@ private: size_type m_size; }; +/* Compare LHS and RHS for (deep) equality. That is, whether LHS and + RHS have the same sizes, and whether each pair of elements of LHS + and RHS at the same position compares equal. */ + +template +bool +operator== (const gdb::array_view &lhs, const gdb::array_view &rhs) +{ + if (lhs.size () != rhs.size ()) + return false; + + for (size_t i = 0; i < lhs.size (); i++) + if (!(lhs[i] == rhs[i])) + return false; + + return true; +} + +/* Compare two array_views for inequality. */ + +template +bool +operator!= (const gdb::array_view &lhs, const gdb::array_view &rhs) +{ + return !(lhs == rhs); +} + } /* namespace gdb */ #endif diff --git a/gdb/value.c b/gdb/value.c index 3d6595f..12aa2b8 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -41,6 +41,8 @@ #include "user-regs.h" #include #include "completer.h" +#include "selftest.h" +#include "common/array-view.h" /* Definition of a user function. */ struct internal_function @@ -76,6 +78,12 @@ struct range { return offset < other.offset; } + + /* Returns true if THIS is equal to OTHER. */ + bool operator== (const range &other) const + { + return offset == other.offset && length == other.length; + } }; /* Returns true if the ranges defined by [offset1, offset1+len1) and @@ -3903,6 +3911,148 @@ isvoid_internal_fn (struct gdbarch *gdbarch, return value_from_longest (builtin_type (gdbarch)->builtin_int, ret); } +#if GDB_SELF_TEST +namespace selftests +{ + +/* Test the ranges_contain function. */ + +static void +test_ranges_contain () +{ + std::vector ranges; + range r; + + /* [10, 14] */ + r.offset = 10; + r.length = 5; + ranges.push_back (r); + + /* [20, 24] */ + r.offset = 20; + r.length = 5; + ranges.push_back (r); + + /* [2, 6] */ + SELF_CHECK (!ranges_contain (ranges, 2, 5)); + /* [9, 13] */ + SELF_CHECK (ranges_contain (ranges, 9, 5)); + /* [10, 11] */ + SELF_CHECK (ranges_contain (ranges, 10, 2)); + /* [10, 14] */ + SELF_CHECK (ranges_contain (ranges, 10, 5)); + /* [13, 18] */ + SELF_CHECK (ranges_contain (ranges, 13, 6)); + /* [14, 18] */ + SELF_CHECK (ranges_contain (ranges, 14, 5)); + /* [15, 18] */ + SELF_CHECK (!ranges_contain (ranges, 15, 4)); + /* [16, 19] */ + SELF_CHECK (!ranges_contain (ranges, 16, 4)); + /* [16, 21] */ + SELF_CHECK (ranges_contain (ranges, 16, 6)); + /* [21, 21] */ + SELF_CHECK (ranges_contain (ranges, 21, 1)); + /* [21, 25] */ + SELF_CHECK (ranges_contain (ranges, 21, 5)); + /* [26, 28] */ + SELF_CHECK (!ranges_contain (ranges, 26, 3)); +} + +/* Check that RANGES contains the same ranges as EXPECTED. */ + +static bool +check_ranges_vector (gdb::array_view ranges, + gdb::array_view expected) +{ + return ranges == expected; +} + +/* Test the insert_into_bit_range_vector function. */ + +static void +test_insert_into_bit_range_vector () +{ + std::vector ranges; + + /* [10, 14] */ + { + insert_into_bit_range_vector (&ranges, 10, 5); + static const range expected[] = { + {10, 5} + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [10, 14] */ + { + insert_into_bit_range_vector (&ranges, 11, 4); + static const range expected = {10, 5}; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [10, 14] [20, 24] */ + { + insert_into_bit_range_vector (&ranges, 20, 5); + static const range expected[] = { + {10, 5}, + {20, 5}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [10, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 17, 5); + static const range expected[] = { + {10, 5}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 8] [10, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 2, 7); + static const range expected[] = { + {2, 7}, + {10, 5}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 9, 1); + static const range expected[] = { + {2, 13}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 14] [17, 24] */ + { + insert_into_bit_range_vector (&ranges, 9, 1); + static const range expected[] = { + {2, 13}, + {17, 8}, + }; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } + + /* [2, 33] */ + { + insert_into_bit_range_vector (&ranges, 4, 30); + static const range expected = {2, 32}; + SELF_CHECK (check_ranges_vector (ranges, expected)); + } +} + +} /* namespace selftests */ +#endif /* GDB_SELF_TEST */ + void _initialize_values (void) { @@ -3954,4 +4104,9 @@ prevents future values, larger than this size, from being allocated."), set_max_value_size, show_max_value_size, &setlist, &showlist); +#if GDB_SELF_TEST + selftests::register_test ("ranges_contain", selftests::test_ranges_contain); + selftests::register_test ("insert_into_bit_range_vector", + selftests::test_insert_into_bit_range_vector); +#endif }