From patchwork Tue Jun 30 13:41:08 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michel Thierry X-Patchwork-Id: 6696041 Return-Path: X-Original-To: patchwork-intel-gfx@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 936DE9F3A0 for ; Tue, 30 Jun 2015 13:41:16 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 7996020552 for ; Tue, 30 Jun 2015 13:41:14 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id 500D520549 for ; Tue, 30 Jun 2015 13:41:13 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 91ACA891CA; Tue, 30 Jun 2015 06:41:12 -0700 (PDT) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga09.intel.com (mga09.intel.com [134.134.136.24]) by gabe.freedesktop.org (Postfix) with ESMTP id 50E7C891CA for ; Tue, 30 Jun 2015 06:41:11 -0700 (PDT) Received: from orsmga003.jf.intel.com ([10.7.209.27]) by orsmga102.jf.intel.com with ESMTP; 30 Jun 2015 06:41:11 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.15,378,1432623600"; d="scan'208";a="597453335" Received: from michelth-linux2.isw.intel.com ([10.102.226.189]) by orsmga003.jf.intel.com with ESMTP; 30 Jun 2015 06:41:09 -0700 From: Michel Thierry To: intel-gfx@lists.freedesktop.org Date: Tue, 30 Jun 2015 14:41:08 +0100 Message-Id: <1435671669-12572-1-git-send-email-michel.thierry@intel.com> X-Mailer: git-send-email 2.4.5 Subject: [Intel-gfx] [PATCH 1/2 i-g-t v2] lib: Add 64-bit version of igt_assert_cmp X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Spam-Status: No, score=-4.8 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP igt_assert_cmp64 and its derivatives: - igt_assert_cmpu64 - igt_assert_eq64 - igt_assert_eq_u64 - igt_assert_neq64 - igt_assert_lte64 - igt_assert_lt64 v2: Add igt_assert_cmp_t, this macro handles int, long and double var cases. (Chris) Cc: Chris Wilson Signed-off-by: Michel Thierry Reviewed-by: Chris Wilson --- lib/igt_core.h | 125 ++++++++++++++++++++++++++++++++++++++++++++------------- 1 file changed, 97 insertions(+), 28 deletions(-) diff --git a/lib/igt_core.h b/lib/igt_core.h index 2b2b6e9..09af295 100644 --- a/lib/igt_core.h +++ b/lib/igt_core.h @@ -323,6 +323,20 @@ void igt_exit(void) __attribute__((noreturn)); */ #define igt_fail_on_f(expr, f...) igt_assert_f(!(expr), f) +#define INTDECFORMAT "%d" +#define UINTHEXFORMAT "%#x" +#define DOUBLEDECFORMAT "%#lf" +#define LONGHEXFORMAT "%#llx" + +#define igt_assert_cmp_t(T, F, n1, cmp, ncmp, n2) \ + do { \ + T __n1 = (n1), __n2 = (n2); \ + if (!(__n1 cmp __n2)) \ + __igt_fail_assert(IGT_LOG_DOMAIN, __FILE__, __LINE__, __func__, \ + #n1 " " #cmp " " #n2, \ + "error: " F " " #ncmp " " F "\n", __n1, __n2); \ + } while (0) + /** * igt_assert_cmpint: * @n1: first value @@ -333,18 +347,13 @@ void igt_exit(void) __attribute__((noreturn)); * Fails (sub-)test if the condition is not met * * Should be used everywhere where a test compares two integer values. + * For 64-bit values use igt_assert_cmp64(). * * Like igt_assert(), but displays the values being compared on failure instead * of simply printing the stringified expression. */ #define igt_assert_cmpint(n1, cmp, ncmp, n2) \ - do { \ - int __n1 = (n1), __n2 = (n2); \ - if (__n1 cmp __n2) ; else \ - __igt_fail_assert(IGT_LOG_DOMAIN, __FILE__, __LINE__, __func__, \ - #n1 " " #cmp " " #n2, \ - "error: %d " #ncmp " %d\n", __n1, __n2); \ - } while (0) + igt_assert_cmp_t(int, INTDECFORMAT, n1, cmp, ncmp, n2) /** * igt_assert_cmpuint: @@ -353,16 +362,35 @@ void igt_exit(void) __attribute__((noreturn)); * @ncmp: negated version of @cmp * @n2: second value * - * Like igt_assert_cmpint(), but for unsigned ints; + * Like igt_assert_cmpint(), but for unsigned ints. For 64-bit values + * use igt_assert_cmpu64(). */ #define igt_assert_cmpuint(n1, cmp, ncmp, n2) \ - do { \ - uint32_t __n1 = (n1), __n2 = (n2); \ - if (__n1 cmp __n2) ; else \ - __igt_fail_assert(IGT_LOG_DOMAIN, __FILE__, __LINE__, __func__, \ - #n1 " " #cmp " " #n2, \ - "error: %#x " #ncmp " %#x\n", __n1, __n2); \ - } while (0) + igt_assert_cmp_t(uint32_t, UINTHEXFORMAT, n1, cmp, ncmp, n2) + +/** + * igt_assert_cmp64: + * @n1: first value + * @cmp: compare operator + * @ncmp: negated version of @cmp + * @n2: second value + * + * Like igt_assert_cmpint(), but for long longs; + */ +#define igt_assert_cmp64(n1, cmp, ncmp, n2) \ + igt_assert_cmp_t(long long, LONGHEXFORMAT, n1, cmp, ncmp, n2) + +/** + * igt_assert_cmpu64: + * @n1: first value + * @cmp: compare operator + * @ncmp: negated version of @cmp + * @n2: second value + * + * Like igt_assert_cmpint(), but for unsigned long longs; + */ +#define igt_assert_cmpu64(n1, cmp, ncmp, n2) \ + igt_assert_cmp_t(unsigned long long, LONGHEXFORMAT, n1, cmp, ncmp, n2) /** * igt_assert_cmpdouble: @@ -374,21 +402,15 @@ void igt_exit(void) __attribute__((noreturn)); * Like igt_assert_cmpint(), but for doubles; */ #define igt_assert_cmpdouble(n1, cmp, ncmp, n2) \ - do { \ - double __n1 = (n1), __n2 = (n2); \ - if (__n1 cmp __n2) ; else \ - __igt_fail_assert(IGT_LOG_DOMAIN, __FILE__, __LINE__, __func__, \ - #n1 " " #cmp " " #n2, \ - "error: %#lf " #ncmp " %#lf\n", __n1, __n2); \ - } while (0) + igt_assert_cmp_t(double, DOUBLEDECFORMAT, n1, cmp, ncmp, n2) /** * igt_assert_eq: * @n1: first integer * @n2: second integer * - * Fails (sub-)test if the two integers are not equal. Beware that for now this - * only works on integers. + * Fails (sub-)test if the two integers are not equal. Beware that this only + * works on integers. For 64-bit values, use igt_assert_eq64(). * * Like igt_assert(), but displays the values being compared on failure instead * of simply printing the stringified expression. @@ -405,6 +427,24 @@ void igt_exit(void) __attribute__((noreturn)); #define igt_assert_eq_u32(n1, n2) igt_assert_cmpuint(n1, ==, !=, n2) /** + * igt_assert_eq64: + * @n1: first value + * @n2: second value + * + * Like igt_assert_eq(), but for long long. + */ +#define igt_assert_eq64(n1, n2) igt_assert_cmp64(n1, ==, !=, n2) + +/** + * igt_assert_eq_u64: + * @n1: first value + * @n2: second value + * + * Like igt_assert_eq(), but for unsigned long long. + */ +#define igt_assert_eq_u64(n1, n2) igt_assert_cmpu64(n1, ==, !=, n2) + +/** * igt_assert_eq_double: * @n1: first double * @n2: second double @@ -418,8 +458,8 @@ void igt_exit(void) __attribute__((noreturn)); * @n1: first integer * @n2: second integer * - * Fails (sub-)test if the two integers are equal. Beware that for now this - * only works on integers. + * Fails (sub-)test if the two integers are equal. Beware that this only works + * on integers. For 64-bit values, use igt_assert_neq64(). * * Like igt_assert(), but displays the values being compared on failure instead * of simply printing the stringified expression. @@ -427,12 +467,22 @@ void igt_exit(void) __attribute__((noreturn)); #define igt_assert_neq(n1, n2) igt_assert_cmpint(n1, !=, ==, n2) /** + * igt_assert_neq64: + * @n1: first value + * @n2: second value + * + * Like igt_assert_neq(), but for long long. + */ +#define igt_assert_neq64(n1, n2) igt_assert_cmp64(n1, !=, ==, n2) + +/** * igt_assert_lte: * @n1: first integer * @n2: second integer * * Fails (sub-)test if the second integers is greater than the first. - * Beware that for now this only works on integers. + * Beware that this only works on integers, for 64-bit values, use + * igt_assert_lte64(). * * Like igt_assert(), but displays the values being compared on failure instead * of simply printing the stringified expression. @@ -440,12 +490,22 @@ void igt_exit(void) __attribute__((noreturn)); #define igt_assert_lte(n1, n2) igt_assert_cmpint(n1, <=, >, n2) /** + * igt_assert_lte64: + * @n1: first value + * @n2: second value + * + * Like igt_assert_lte(), but for long long. + */ +#define igt_assert_lte64(n1, n2) igt_assert_cmp64(n1, <=, >, n2) + +/** * igt_assert_lt: * @n1: first integer * @n2: second integer * * Fails (sub-)test if the second integers is strictly smaller than the first. - * Beware that for now this only works on integers. + * Beware that this only works on integers. For 64-bit values, use + * igt_assert_lt64(). * * Like igt_assert(), but displays the values being compared on failure instead * of simply printing the stringified expression. @@ -453,6 +513,15 @@ void igt_exit(void) __attribute__((noreturn)); #define igt_assert_lt(n1, n2) igt_assert_cmpint(n1, <, >=, n2) /** + * igt_assert_lt64: + * @n1: first value + * @n2: second value + * + * Like igt_assert_lt(), but for long long. + */ +#define igt_assert_lt64(n1, n2) igt_assert_cmp64(n1, <, >=, n2) + +/** * igt_require: * @expr: condition to test *