From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.5 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, DKIM_INVALID,DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7463EC3A5A2 for ; Sat, 21 Sep 2019 00:23:08 +0000 (UTC) Received: from ml01.01.org (ml01.01.org [198.145.21.10]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 3D7CE217F9 for ; Sat, 21 Sep 2019 00:23:08 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=google.com header.i=@google.com header.b="T/VqOz2a" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3D7CE217F9 Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=google.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-nvdimm-bounces@lists.01.org Received: from [127.0.0.1] (localhost [IPv6:::1]) by ml01.01.org (Postfix) with ESMTP id C1A7D202EDBBA; Fri, 20 Sep 2019 17:25:58 -0700 (PDT) Received-SPF: Pass (sender SPF authorized) identity=mailfrom; client-ip=2607:f8b0:4864:20::c4a; helo=mail-yw1-xc4a.google.com; envelope-from=3mf6fxq4kdf06m9i85icdbbdinbjjbg9.7jhgdips-iq8dhhgdnon.vw.jmb@flex--brendanhiggins.bounces.google.com; receiver=linux-nvdimm@lists.01.org Received: from mail-yw1-xc4a.google.com (mail-yw1-xc4a.google.com [IPv6:2607:f8b0:4864:20::c4a]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id BF047202EDBAB for ; Fri, 20 Sep 2019 17:25:56 -0700 (PDT) Received: by mail-yw1-xc4a.google.com with SMTP id r64so2250739ywb.3 for ; Fri, 20 Sep 2019 17:23:06 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=/bZoZEZVz8wX45GPttRV01z+eGnuFCzZ/9DmK4u44kE=; b=T/VqOz2aArb3kNyk3BuS/M62SlRttJ3IY6VAOADhVJG62DdpXmJa9RJp8hS5IFcc7V mRVzrfMBi0R6+Kk+XCfxpJkzoGQ/n4P/IaxLp4thVimSZwTlc5NfpdB9BzQsIwA2ii9H 756K2mZitRlOzqFUMOxCjdRC5614BO3WzTtHFi7zhXC2VdYe3YMAs7nev5k2E1Pa9D9m StsdpIhfYGTmNDCjAyEh6eL4QwbZmAgnu4piFfLkPOchoUVWrVkijllC26mXbl5fD1xx +jI2Bx0qRFmSn3M60KleRCzPZsEo02UGc2AArljtyX6D3Skmcy/XmzPtfEnIDdUQPaqG LdUw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=/bZoZEZVz8wX45GPttRV01z+eGnuFCzZ/9DmK4u44kE=; b=VpXNXhlHXQF7jEjDxpICtyrwMiEmCDqrqx9pb1TP/vMvFE6+bPI8mkdl19B8gsvTS1 CKTVm010d4whqvc7L/GTSIMg0o2eZdo/jQ1sA5hHRJEt9o5IZN5EUJ6vLfmBGMZRwcqS dzymAG7KraXwgenWFRYjbHTGFeX/NZmO1VUzpqH2R0YeRYQ/dJs+TVqKGJudM4TMT9VV FVFuJdbcQjYpMZKXJEMYX9a6aHAWU5ZHD8OjMoqZIp2rp+cm2ltaJ35IMp5rr5BpRNS6 3lWUpvrewLAjy8jRZKKktZEKpNHJ6+G+iXf3QKtyib6sRjCkHJkL5Bm4AvQBz1sy53lb 1HsA== X-Gm-Message-State: APjAAAVM3xRPApL5SScw5cQ77NmZezuqae++53bldqkQYUS83jNpoV8+ Pd8HQQES+ds8sfPwzJ5v1sDYfjY2NMcYF/6/vlNPzA== X-Google-Smtp-Source: APXvYqyqcWNa8g0kLDr2kM4XX4x8G/rhPspG/b/5ukMW1ectjG0wKPZ7LvfJ9QqMfWv3ZtkLIz0/E56mjpxNYpmwHOGQzg== X-Received: by 2002:a5b:645:: with SMTP id o5mr13595229ybq.175.1569021592619; Fri, 20 Sep 2019 16:19:52 -0700 (PDT) Date: Fri, 20 Sep 2019 16:19:09 -0700 In-Reply-To: <20190920231923.141900-1-brendanhiggins@google.com> Message-Id: <20190920231923.141900-6-brendanhiggins@google.com> Mime-Version: 1.0 References: <20190920231923.141900-1-brendanhiggins@google.com> X-Mailer: git-send-email 2.23.0.351.gc4317032e6-goog Subject: [PATCH v16 05/19] kunit: test: add the concept of expectations From: Brendan Higgins To: frowand.list@gmail.com, gregkh@linuxfoundation.org, jpoimboe@redhat.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, peterz@infradead.org, robh@kernel.org, sboyd@kernel.org, shuah@kernel.org, tytso@mit.edu, yamada.masahiro@socionext.com X-BeenThere: linux-nvdimm@lists.01.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: "Linux-nvdimm developer list." List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: pmladek@suse.com, linux-doc@vger.kernel.org, amir73il@gmail.com, Brendan Higgins , dri-devel@lists.freedesktop.org, Alexander.Levin@microsoft.com, linux-kselftest@vger.kernel.org, linux-nvdimm@lists.01.org, khilman@baylibre.com, knut.omang@oracle.com, wfg@linux.intel.com, joel@jms.id.au, rientjes@google.com, jdike@addtoit.com, dan.carpenter@oracle.com, devicetree@vger.kernel.org, linux-kbuild@vger.kernel.org, Tim.Bird@sony.com, linux-um@lists.infradead.org, rostedt@goodmis.org, julia.lawall@lip6.fr, kunit-dev@googlegroups.com, richard@nod.at, torvalds@linux-foundation.org, rdunlap@infradead.org, linux-kernel@vger.kernel.org, daniel@ffwll.ch, mpe@ellerman.id.au, linux-fsdevel@vger.kernel.org Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Errors-To: linux-nvdimm-bounces@lists.01.org Sender: "Linux-nvdimm" Add support for expectations, which allow properties to be specified and then verified in tests. Signed-off-by: Brendan Higgins Reviewed-by: Greg Kroah-Hartman Reviewed-by: Logan Gunthorpe Reviewed-by: Stephen Boyd --- include/kunit/test.h | 836 +++++++++++++++++++++++++++++++++++++++++++ lib/kunit/test.c | 62 ++++ 2 files changed, 898 insertions(+) diff --git a/include/kunit/test.h b/include/kunit/test.h index 6781c756f11b..30a62de16bc9 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -9,6 +9,8 @@ #ifndef _KUNIT_TEST_H #define _KUNIT_TEST_H +#include +#include #include #include @@ -372,4 +374,838 @@ void __printf(3, 4) kunit_printk(const char *level, #define kunit_err(test, fmt, ...) \ kunit_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) +/** + * KUNIT_SUCCEED() - A no-op expectation. Only exists for code clarity. + * @test: The test context object. + * + * The opposite of KUNIT_FAIL(), it is an expectation that cannot fail. In other + * words, it does nothing and only exists for code clarity. See + * KUNIT_EXPECT_TRUE() for more information. + */ +#define KUNIT_SUCCEED(test) do {} while (0) + +void kunit_do_assertion(struct kunit *test, + struct kunit_assert *assert, + bool pass, + const char *fmt, ...); + +#define KUNIT_ASSERTION(test, pass, assert_class, INITIALIZER, fmt, ...) do { \ + struct assert_class __assertion = INITIALIZER; \ + kunit_do_assertion(test, \ + &__assertion.assert, \ + pass, \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + + +#define KUNIT_FAIL_ASSERTION(test, assert_type, fmt, ...) \ + KUNIT_ASSERTION(test, \ + false, \ + kunit_fail_assert, \ + KUNIT_INIT_FAIL_ASSERT_STRUCT(test, assert_type), \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_FAIL() - Always causes a test to fail when evaluated. + * @test: The test context object. + * @fmt: an informational message to be printed when the assertion is made. + * @...: string format arguments. + * + * The opposite of KUNIT_SUCCEED(), it is an expectation that always fails. In + * other words, it always results in a failed expectation, and consequently + * always causes the test case to fail when evaluated. See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_FAIL(test, fmt, ...) \ + KUNIT_FAIL_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + expected_true, \ + fmt, \ + ...) \ + KUNIT_ASSERTION(test, \ + !!(condition) == !!expected_true, \ + kunit_unary_assert, \ + KUNIT_INIT_UNARY_ASSERT_STRUCT(test, \ + assert_type, \ + #condition, \ + expected_true), \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ + KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + true, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_TRUE_ASSERTION(test, assert_type, condition) \ + KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, NULL) + +#define KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ + KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + false, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_FALSE_ASSERTION(test, assert_type, condition) \ + KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, NULL) + +/* + * A factory macro for defining the assertions and expectations for the basic + * comparisons defined for the built in types. + * + * Unfortunately, there is no common type that all types can be promoted to for + * which all the binary operators behave the same way as for the actual types + * (for example, there is no type that long long and unsigned long long can + * both be cast to where the comparison result is preserved for all values). So + * the best we can do is do the comparison in the original types and then coerce + * everything to long long for printing; this way, the comparison behaves + * correctly and the printed out value usually makes sense without + * interpretation, but can always be interpreted to figure out the actual + * value. + */ +#define KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + op, \ + right, \ + fmt, \ + ...) \ +do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + ((void)__typecheck(__left, __right)); \ + \ + KUNIT_ASSERTION(test, \ + __left op __right, \ + assert_class, \ + ASSERT_CLASS_INIT(test, \ + assert_type, \ + #op, \ + #left, \ + __left, \ + #right, \ + __right), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, ==, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_NE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, !=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_LT_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, <, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_LE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, <=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_GT_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, >, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_GE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, >=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_EQ_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_NE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_NE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_NE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_LT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_LT_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_LT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_LT_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_LT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_LE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_LE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_LE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_LE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_LE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_GT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_GT_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_GT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_GT_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_GT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_GE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_GE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_GE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_GE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_GE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, \ + op, \ + right, \ + fmt, \ + ...) \ +do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + KUNIT_ASSERTION(test, \ + strcmp(__left, __right) op 0, \ + kunit_binary_str_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT(test, \ + assert_type, \ + #op, \ + #left, \ + __left, \ + #right, \ + __right), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, ==, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_STR_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, !=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_STR_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + assert_type, \ + ptr, \ + fmt, \ + ...) \ +do { \ + typeof(ptr) __ptr = (ptr); \ + \ + KUNIT_ASSERTION(test, \ + !IS_ERR_OR_NULL(__ptr), \ + kunit_ptr_not_err_assert, \ + KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, \ + assert_type, \ + #ptr, \ + __ptr), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, assert_type, ptr) \ + KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + assert_type, \ + ptr, \ + NULL) + +/** + * KUNIT_EXPECT_TRUE() - Causes a test failure when the expression is not true. + * @test: The test context object. + * @condition: an arbitrary boolean expression. The test fails when this does + * not evaluate to true. + * + * This and expectations of the form `KUNIT_EXPECT_*` will cause the test case + * to fail when the specified condition is not met; however, it will not prevent + * the test case from continuing to run; this is otherwise known as an + * *expectation failure*. + */ +#define KUNIT_EXPECT_TRUE(test, condition) \ + KUNIT_TRUE_ASSERTION(test, KUNIT_EXPECTATION, condition) + +#define KUNIT_EXPECT_TRUE_MSG(test, condition, fmt, ...) \ + KUNIT_TRUE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + condition, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_FALSE() - Makes a test failure when the expression is not false. + * @test: The test context object. + * @condition: an arbitrary boolean expression. The test fails when this does + * not evaluate to false. + * + * Sets an expectation that @condition evaluates to false. See + * KUNIT_EXPECT_TRUE() for more information. + */ +#define KUNIT_EXPECT_FALSE(test, condition) \ + KUNIT_FALSE_ASSERTION(test, KUNIT_EXPECTATION, condition) + +#define KUNIT_EXPECT_FALSE_MSG(test, condition, fmt, ...) \ + KUNIT_FALSE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + condition, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_EQ() - Sets an expectation that @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_EQ(test, left, right) \ + KUNIT_BINARY_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_EQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_PTR_EQ() - Expects that pointers @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a pointer. + * @right: an arbitrary expression that evaluates to a pointer. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_PTR_EQ(test, left, right) \ + KUNIT_BINARY_PTR_EQ_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right) + +#define KUNIT_EXPECT_PTR_EQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_NE() - An expectation that @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the values that @left and @right evaluate to are not + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_NE(test, left, right) \ + KUNIT_BINARY_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_NE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_PTR_NE() - Expects that pointers @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a pointer. + * @right: an arbitrary expression that evaluates to a pointer. + * + * Sets an expectation that the values that @left and @right evaluate to are not + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_PTR_NE(test, left, right) \ + KUNIT_BINARY_PTR_NE_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right) + +#define KUNIT_EXPECT_PTR_NE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_LT() - An expectation that @left is less than @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is less than the + * value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) < (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_LT(test, left, right) \ + KUNIT_BINARY_LT_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_LT_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_LT_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_LE() - Expects that @left is less than or equal to @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is less than or + * equal to the value that @right evaluates to. Semantically this is equivalent + * to KUNIT_EXPECT_TRUE(@test, (@left) <= (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_LE(test, left, right) \ + KUNIT_BINARY_LE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_LE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_LE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_GT() - An expectation that @left is greater than @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is greater than + * the value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) > (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_GT(test, left, right) \ + KUNIT_BINARY_GT_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_GT_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_GT_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_GE() - Expects that @left is greater than or equal to @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is greater than + * the value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) >= (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_GE(test, left, right) \ + KUNIT_BINARY_GE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_GE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_GE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_STREQ() - Expects that strings @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a null terminated string. + * @right: an arbitrary expression that evaluates to a null terminated string. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_EXPECT_STREQ(test, left, right) \ + KUNIT_BINARY_STR_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_STREQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_STRNEQ() - Expects that strings @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a null terminated string. + * @right: an arbitrary expression that evaluates to a null terminated string. + * + * Sets an expectation that the values that @left and @right evaluate to are + * not equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_EXPECT_STRNEQ(test, left, right) \ + KUNIT_BINARY_STR_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_STRNEQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_NOT_ERR_OR_NULL() - Expects that @ptr is not null and not err. + * @test: The test context object. + * @ptr: an arbitrary pointer. + * + * Sets an expectation that the value that @ptr evaluates to is not null and not + * an errno stored in a pointer. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ptr) \ + KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, KUNIT_EXPECTATION, ptr) + +#define KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, ptr, fmt, ...) \ + KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + ptr, \ + fmt, \ + ##__VA_ARGS__) + #endif /* _KUNIT_TEST_H */ diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 68b1037ab74d..3cbceb34b3b3 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -120,6 +120,68 @@ static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case, test_case->name); } +static void kunit_print_string_stream(struct kunit *test, + struct string_stream *stream) +{ + struct string_stream_fragment *fragment; + char *buf; + + buf = string_stream_get_string(stream); + if (!buf) { + kunit_err(test, + "Could not allocate buffer, dumping stream:\n"); + list_for_each_entry(fragment, &stream->fragments, node) { + kunit_err(test, fragment->fragment); + } + kunit_err(test, "\n"); + } else { + kunit_err(test, buf); + kunit_kfree(test, buf); + } +} + +static void kunit_fail(struct kunit *test, struct kunit_assert *assert) +{ + struct string_stream *stream; + + kunit_set_failure(test); + + stream = alloc_string_stream(test, GFP_KERNEL); + if (!stream) { + WARN(true, + "Could not allocate stream to print failed assertion in %s:%d\n", + assert->file, + assert->line); + return; + } + + assert->format(assert, stream); + + kunit_print_string_stream(test, stream); + + WARN_ON(string_stream_destroy(stream)); +} + +void kunit_do_assertion(struct kunit *test, + struct kunit_assert *assert, + bool pass, + const char *fmt, ...) +{ + va_list args; + + if (pass) + return; + + va_start(args, fmt); + + assert->message.fmt = fmt; + assert->message.va = &args; + + kunit_fail(test, assert); + + va_end(args); +} + void kunit_init_test(struct kunit *test, const char *name) { spin_lock_init(&test->lock); -- 2.23.0.351.gc4317032e6-goog _______________________________________________ Linux-nvdimm mailing list Linux-nvdimm@lists.01.org https://lists.01.org/mailman/listinfo/linux-nvdimm From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-17.4 required=3.0 tests=DKIMWL_WL_MED,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT,USER_IN_DEF_DKIM_WL autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1EEB2C3A5A2 for ; Fri, 20 Sep 2019 23:21:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C143C2190F for ; Fri, 20 Sep 2019 23:21:35 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="T/VqOz2a" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2437288AbfITXVf (ORCPT ); Fri, 20 Sep 2019 19:21:35 -0400 Received: from mail-yw1-f74.google.com ([209.85.161.74]:47094 "EHLO mail-yw1-f74.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2407089AbfITXTy (ORCPT ); Fri, 20 Sep 2019 19:19:54 -0400 Received: by mail-yw1-f74.google.com with SMTP id 132so6754741ywo.13 for ; Fri, 20 Sep 2019 16:19:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc; bh=/bZoZEZVz8wX45GPttRV01z+eGnuFCzZ/9DmK4u44kE=; b=T/VqOz2aArb3kNyk3BuS/M62SlRttJ3IY6VAOADhVJG62DdpXmJa9RJp8hS5IFcc7V mRVzrfMBi0R6+Kk+XCfxpJkzoGQ/n4P/IaxLp4thVimSZwTlc5NfpdB9BzQsIwA2ii9H 756K2mZitRlOzqFUMOxCjdRC5614BO3WzTtHFi7zhXC2VdYe3YMAs7nev5k2E1Pa9D9m StsdpIhfYGTmNDCjAyEh6eL4QwbZmAgnu4piFfLkPOchoUVWrVkijllC26mXbl5fD1xx +jI2Bx0qRFmSn3M60KleRCzPZsEo02UGc2AArljtyX6D3Skmcy/XmzPtfEnIDdUQPaqG LdUw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc; bh=/bZoZEZVz8wX45GPttRV01z+eGnuFCzZ/9DmK4u44kE=; b=JbaSvAv9rzZ+Ez4OTsJar/yDmMQx45vl1eAmZdqsmf3CkD6z6ag1EUEidG6UsImmbC u+089EF6k8pxEYuyEC4Jh8NqEo2HLTVst7uVZYZOlEYqmBML219mN+USfid8sZVPzlhK Z963t1nSeUFQ7BpJ1m3KaKbcXhNrQTEJEncgfIRzlI2Si5oBYlmLVPO+nd4brCWbpcJZ HA8bkIcnVY2mucrcnsQuSQQ0LoDCMLio1XXVi3kZS/xSzcww2gafcuVA0wjlPBbdfit8 s2hz8R4bPMwCEqdYNJfl6ysg1d4i2I7OgoGMIcIs19Qa8OfAZRJkDLkucTb8+VLGvbkS x6YA== X-Gm-Message-State: APjAAAWkBTaPAs3WejY0ujrIMlejYbxxMxJoOTITe1U9NFoYSpkNRP68 heLO8Vdo8X28LKPC8UJuYo8glzFhcSnwjtJdFjg0/w== X-Google-Smtp-Source: APXvYqyqcWNa8g0kLDr2kM4XX4x8G/rhPspG/b/5ukMW1ectjG0wKPZ7LvfJ9QqMfWv3ZtkLIz0/E56mjpxNYpmwHOGQzg== X-Received: by 2002:a5b:645:: with SMTP id o5mr13595229ybq.175.1569021592619; Fri, 20 Sep 2019 16:19:52 -0700 (PDT) Date: Fri, 20 Sep 2019 16:19:09 -0700 In-Reply-To: <20190920231923.141900-1-brendanhiggins@google.com> Message-Id: <20190920231923.141900-6-brendanhiggins@google.com> Mime-Version: 1.0 References: <20190920231923.141900-1-brendanhiggins@google.com> X-Mailer: git-send-email 2.23.0.351.gc4317032e6-goog Subject: [PATCH v16 05/19] kunit: test: add the concept of expectations From: Brendan Higgins To: frowand.list@gmail.com, gregkh@linuxfoundation.org, jpoimboe@redhat.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, peterz@infradead.org, robh@kernel.org, sboyd@kernel.org, shuah@kernel.org, tytso@mit.edu, yamada.masahiro@socionext.com Cc: devicetree@vger.kernel.org, dri-devel@lists.freedesktop.org, kunit-dev@googlegroups.com, linux-doc@vger.kernel.org, linux-fsdevel@vger.kernel.org, linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, linux-kselftest@vger.kernel.org, linux-nvdimm@lists.01.org, linux-um@lists.infradead.org, Alexander.Levin@microsoft.com, Tim.Bird@sony.com, amir73il@gmail.com, dan.carpenter@oracle.com, daniel@ffwll.ch, jdike@addtoit.com, joel@jms.id.au, julia.lawall@lip6.fr, khilman@baylibre.com, knut.omang@oracle.com, logang@deltatee.com, mpe@ellerman.id.au, pmladek@suse.com, rdunlap@infradead.org, richard@nod.at, rientjes@google.com, rostedt@goodmis.org, wfg@linux.intel.com, torvalds@linux-foundation.org, Brendan Higgins Content-Type: text/plain; charset="UTF-8" Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add support for expectations, which allow properties to be specified and then verified in tests. Signed-off-by: Brendan Higgins Reviewed-by: Greg Kroah-Hartman Reviewed-by: Logan Gunthorpe Reviewed-by: Stephen Boyd --- include/kunit/test.h | 836 +++++++++++++++++++++++++++++++++++++++++++ lib/kunit/test.c | 62 ++++ 2 files changed, 898 insertions(+) diff --git a/include/kunit/test.h b/include/kunit/test.h index 6781c756f11b..30a62de16bc9 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -9,6 +9,8 @@ #ifndef _KUNIT_TEST_H #define _KUNIT_TEST_H +#include +#include #include #include @@ -372,4 +374,838 @@ void __printf(3, 4) kunit_printk(const char *level, #define kunit_err(test, fmt, ...) \ kunit_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) +/** + * KUNIT_SUCCEED() - A no-op expectation. Only exists for code clarity. + * @test: The test context object. + * + * The opposite of KUNIT_FAIL(), it is an expectation that cannot fail. In other + * words, it does nothing and only exists for code clarity. See + * KUNIT_EXPECT_TRUE() for more information. + */ +#define KUNIT_SUCCEED(test) do {} while (0) + +void kunit_do_assertion(struct kunit *test, + struct kunit_assert *assert, + bool pass, + const char *fmt, ...); + +#define KUNIT_ASSERTION(test, pass, assert_class, INITIALIZER, fmt, ...) do { \ + struct assert_class __assertion = INITIALIZER; \ + kunit_do_assertion(test, \ + &__assertion.assert, \ + pass, \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + + +#define KUNIT_FAIL_ASSERTION(test, assert_type, fmt, ...) \ + KUNIT_ASSERTION(test, \ + false, \ + kunit_fail_assert, \ + KUNIT_INIT_FAIL_ASSERT_STRUCT(test, assert_type), \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_FAIL() - Always causes a test to fail when evaluated. + * @test: The test context object. + * @fmt: an informational message to be printed when the assertion is made. + * @...: string format arguments. + * + * The opposite of KUNIT_SUCCEED(), it is an expectation that always fails. In + * other words, it always results in a failed expectation, and consequently + * always causes the test case to fail when evaluated. See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_FAIL(test, fmt, ...) \ + KUNIT_FAIL_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + expected_true, \ + fmt, \ + ...) \ + KUNIT_ASSERTION(test, \ + !!(condition) == !!expected_true, \ + kunit_unary_assert, \ + KUNIT_INIT_UNARY_ASSERT_STRUCT(test, \ + assert_type, \ + #condition, \ + expected_true), \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ + KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + true, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_TRUE_ASSERTION(test, assert_type, condition) \ + KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, NULL) + +#define KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ + KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + false, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_FALSE_ASSERTION(test, assert_type, condition) \ + KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, NULL) + +/* + * A factory macro for defining the assertions and expectations for the basic + * comparisons defined for the built in types. + * + * Unfortunately, there is no common type that all types can be promoted to for + * which all the binary operators behave the same way as for the actual types + * (for example, there is no type that long long and unsigned long long can + * both be cast to where the comparison result is preserved for all values). So + * the best we can do is do the comparison in the original types and then coerce + * everything to long long for printing; this way, the comparison behaves + * correctly and the printed out value usually makes sense without + * interpretation, but can always be interpreted to figure out the actual + * value. + */ +#define KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + op, \ + right, \ + fmt, \ + ...) \ +do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + ((void)__typecheck(__left, __right)); \ + \ + KUNIT_ASSERTION(test, \ + __left op __right, \ + assert_class, \ + ASSERT_CLASS_INIT(test, \ + assert_type, \ + #op, \ + #left, \ + __left, \ + #right, \ + __right), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, ==, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_NE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, !=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_LT_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, <, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_LE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, <=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_GT_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, >, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_GE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, >=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_EQ_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_NE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_NE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_NE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_LT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_LT_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_LT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_LT_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_LT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_LE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_LE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_LE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_LE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_LE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_GT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_GT_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_GT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_GT_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_GT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_GE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_GE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_GE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_GE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_GE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, \ + op, \ + right, \ + fmt, \ + ...) \ +do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + KUNIT_ASSERTION(test, \ + strcmp(__left, __right) op 0, \ + kunit_binary_str_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT(test, \ + assert_type, \ + #op, \ + #left, \ + __left, \ + #right, \ + __right), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, ==, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_STR_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, !=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_STR_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + assert_type, \ + ptr, \ + fmt, \ + ...) \ +do { \ + typeof(ptr) __ptr = (ptr); \ + \ + KUNIT_ASSERTION(test, \ + !IS_ERR_OR_NULL(__ptr), \ + kunit_ptr_not_err_assert, \ + KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, \ + assert_type, \ + #ptr, \ + __ptr), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, assert_type, ptr) \ + KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + assert_type, \ + ptr, \ + NULL) + +/** + * KUNIT_EXPECT_TRUE() - Causes a test failure when the expression is not true. + * @test: The test context object. + * @condition: an arbitrary boolean expression. The test fails when this does + * not evaluate to true. + * + * This and expectations of the form `KUNIT_EXPECT_*` will cause the test case + * to fail when the specified condition is not met; however, it will not prevent + * the test case from continuing to run; this is otherwise known as an + * *expectation failure*. + */ +#define KUNIT_EXPECT_TRUE(test, condition) \ + KUNIT_TRUE_ASSERTION(test, KUNIT_EXPECTATION, condition) + +#define KUNIT_EXPECT_TRUE_MSG(test, condition, fmt, ...) \ + KUNIT_TRUE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + condition, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_FALSE() - Makes a test failure when the expression is not false. + * @test: The test context object. + * @condition: an arbitrary boolean expression. The test fails when this does + * not evaluate to false. + * + * Sets an expectation that @condition evaluates to false. See + * KUNIT_EXPECT_TRUE() for more information. + */ +#define KUNIT_EXPECT_FALSE(test, condition) \ + KUNIT_FALSE_ASSERTION(test, KUNIT_EXPECTATION, condition) + +#define KUNIT_EXPECT_FALSE_MSG(test, condition, fmt, ...) \ + KUNIT_FALSE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + condition, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_EQ() - Sets an expectation that @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_EQ(test, left, right) \ + KUNIT_BINARY_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_EQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_PTR_EQ() - Expects that pointers @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a pointer. + * @right: an arbitrary expression that evaluates to a pointer. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_PTR_EQ(test, left, right) \ + KUNIT_BINARY_PTR_EQ_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right) + +#define KUNIT_EXPECT_PTR_EQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_NE() - An expectation that @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the values that @left and @right evaluate to are not + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_NE(test, left, right) \ + KUNIT_BINARY_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_NE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_PTR_NE() - Expects that pointers @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a pointer. + * @right: an arbitrary expression that evaluates to a pointer. + * + * Sets an expectation that the values that @left and @right evaluate to are not + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_PTR_NE(test, left, right) \ + KUNIT_BINARY_PTR_NE_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right) + +#define KUNIT_EXPECT_PTR_NE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_LT() - An expectation that @left is less than @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is less than the + * value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) < (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_LT(test, left, right) \ + KUNIT_BINARY_LT_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_LT_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_LT_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_LE() - Expects that @left is less than or equal to @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is less than or + * equal to the value that @right evaluates to. Semantically this is equivalent + * to KUNIT_EXPECT_TRUE(@test, (@left) <= (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_LE(test, left, right) \ + KUNIT_BINARY_LE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_LE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_LE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_GT() - An expectation that @left is greater than @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is greater than + * the value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) > (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_GT(test, left, right) \ + KUNIT_BINARY_GT_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_GT_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_GT_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_GE() - Expects that @left is greater than or equal to @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is greater than + * the value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) >= (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_GE(test, left, right) \ + KUNIT_BINARY_GE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_GE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_GE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_STREQ() - Expects that strings @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a null terminated string. + * @right: an arbitrary expression that evaluates to a null terminated string. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_EXPECT_STREQ(test, left, right) \ + KUNIT_BINARY_STR_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_STREQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_STRNEQ() - Expects that strings @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a null terminated string. + * @right: an arbitrary expression that evaluates to a null terminated string. + * + * Sets an expectation that the values that @left and @right evaluate to are + * not equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_EXPECT_STRNEQ(test, left, right) \ + KUNIT_BINARY_STR_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_STRNEQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_NOT_ERR_OR_NULL() - Expects that @ptr is not null and not err. + * @test: The test context object. + * @ptr: an arbitrary pointer. + * + * Sets an expectation that the value that @ptr evaluates to is not null and not + * an errno stored in a pointer. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ptr) \ + KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, KUNIT_EXPECTATION, ptr) + +#define KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, ptr, fmt, ...) \ + KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + ptr, \ + fmt, \ + ##__VA_ARGS__) + #endif /* _KUNIT_TEST_H */ diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 68b1037ab74d..3cbceb34b3b3 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -120,6 +120,68 @@ static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case, test_case->name); } +static void kunit_print_string_stream(struct kunit *test, + struct string_stream *stream) +{ + struct string_stream_fragment *fragment; + char *buf; + + buf = string_stream_get_string(stream); + if (!buf) { + kunit_err(test, + "Could not allocate buffer, dumping stream:\n"); + list_for_each_entry(fragment, &stream->fragments, node) { + kunit_err(test, fragment->fragment); + } + kunit_err(test, "\n"); + } else { + kunit_err(test, buf); + kunit_kfree(test, buf); + } +} + +static void kunit_fail(struct kunit *test, struct kunit_assert *assert) +{ + struct string_stream *stream; + + kunit_set_failure(test); + + stream = alloc_string_stream(test, GFP_KERNEL); + if (!stream) { + WARN(true, + "Could not allocate stream to print failed assertion in %s:%d\n", + assert->file, + assert->line); + return; + } + + assert->format(assert, stream); + + kunit_print_string_stream(test, stream); + + WARN_ON(string_stream_destroy(stream)); +} + +void kunit_do_assertion(struct kunit *test, + struct kunit_assert *assert, + bool pass, + const char *fmt, ...) +{ + va_list args; + + if (pass) + return; + + va_start(args, fmt); + + assert->message.fmt = fmt; + assert->message.va = &args; + + kunit_fail(test, assert); + + va_end(args); +} + void kunit_init_test(struct kunit *test, const char *name) { spin_lock_init(&test->lock); -- 2.23.0.351.gc4317032e6-goog From mboxrd@z Thu Jan 1 00:00:00 1970 From: Brendan Higgins Subject: [PATCH v16 05/19] kunit: test: add the concept of expectations Date: Fri, 20 Sep 2019 16:19:09 -0700 Message-ID: <20190920231923.141900-6-brendanhiggins@google.com> References: <20190920231923.141900-1-brendanhiggins@google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190920231923.141900-1-brendanhiggins@google.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: frowand.list@gmail.com, gregkh@linuxfoundation.org, jpoimboe@redhat.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, peterz@infradead.org, robh@kernel.org, sboyd@kernel.org, shuah@kernel.org, tytso@mit.edu, yamada.masahiro@socionext.com Cc: pmladek@suse.com, linux-doc@vger.kernel.org, amir73il@gmail.com, Brendan Higgins , dri-devel@lists.freedesktop.org, Alexander.Levin@microsoft.com, linux-kselftest@vger.kernel.org, linux-nvdimm@lists.01.org, khilman@baylibre.com, knut.omang@oracle.com, wfg@linux.intel.com, joel@jms.id.au, rientjes@google.com, jdike@addtoit.com, dan.carpenter@oracle.com, devicetree@vger.kernel.org, linux-kbuild@vger.kernel.org, Tim.Bird@sony.com, linux-um@lists.infradead.org, rostedt@goodmis.org, julia.lawall@lip6.fr, kunit-dev@googlegroups.com, richard@nod.at, torvalds@linux-foundation.org, rdunlap@infradead.org, linux-kernel@vger.kernel.org, mpe@ellerman.id.au, linux-fsdevel@vger.kernel.org, logang@deltatee.com List-Id: devicetree@vger.kernel.org QWRkIHN1cHBvcnQgZm9yIGV4cGVjdGF0aW9ucywgd2hpY2ggYWxsb3cgcHJvcGVydGllcyB0byBi ZSBzcGVjaWZpZWQgYW5kCnRoZW4gdmVyaWZpZWQgaW4gdGVzdHMuCgpTaWduZWQtb2ZmLWJ5OiBC cmVuZGFuIEhpZ2dpbnMgPGJyZW5kYW5oaWdnaW5zQGdvb2dsZS5jb20+ClJldmlld2VkLWJ5OiBH cmVnIEtyb2FoLUhhcnRtYW4gPGdyZWdraEBsaW51eGZvdW5kYXRpb24ub3JnPgpSZXZpZXdlZC1i eTogTG9nYW4gR3VudGhvcnBlIDxsb2dhbmdAZGVsdGF0ZWUuY29tPgpSZXZpZXdlZC1ieTogU3Rl cGhlbiBCb3lkIDxzYm95ZEBrZXJuZWwub3JnPgotLS0KIGluY2x1ZGUva3VuaXQvdGVzdC5oIHwg ODM2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGxpYi9rdW5p dC90ZXN0LmMgICAgIHwgIDYyICsrKysKIDIgZmlsZXMgY2hhbmdlZCwgODk4IGluc2VydGlvbnMo KykKCmRpZmYgLS1naXQgYS9pbmNsdWRlL2t1bml0L3Rlc3QuaCBiL2luY2x1ZGUva3VuaXQvdGVz dC5oCmluZGV4IDY3ODFjNzU2ZjExYi4uMzBhNjJkZTE2YmM5IDEwMDY0NAotLS0gYS9pbmNsdWRl L2t1bml0L3Rlc3QuaAorKysgYi9pbmNsdWRlL2t1bml0L3Rlc3QuaApAQCAtOSw2ICs5LDggQEAK ICNpZm5kZWYgX0tVTklUX1RFU1RfSAogI2RlZmluZSBfS1VOSVRfVEVTVF9ICiAKKyNpbmNsdWRl IDxrdW5pdC9hc3NlcnQuaD4KKyNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxs aW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KIApAQCAtMzcyLDQgKzM3NCw4 MzggQEAgdm9pZCBfX3ByaW50ZigzLCA0KSBrdW5pdF9wcmludGsoY29uc3QgY2hhciAqbGV2ZWws CiAjZGVmaW5lIGt1bml0X2Vycih0ZXN0LCBmbXQsIC4uLikgXAogCWt1bml0X3ByaW50ayhLRVJO X0VSUiwgdGVzdCwgZm10LCAjI19fVkFfQVJHU19fKQogCisvKioKKyAqIEtVTklUX1NVQ0NFRUQo KSAtIEEgbm8tb3AgZXhwZWN0YXRpb24uIE9ubHkgZXhpc3RzIGZvciBjb2RlIGNsYXJpdHkuCisg KiBAdGVzdDogVGhlIHRlc3QgY29udGV4dCBvYmplY3QuCisgKgorICogVGhlIG9wcG9zaXRlIG9m IEtVTklUX0ZBSUwoKSwgaXQgaXMgYW4gZXhwZWN0YXRpb24gdGhhdCBjYW5ub3QgZmFpbC4gSW4g b3RoZXIKKyAqIHdvcmRzLCBpdCBkb2VzIG5vdGhpbmcgYW5kIG9ubHkgZXhpc3RzIGZvciBjb2Rl IGNsYXJpdHkuIFNlZQorICogS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IgbW9yZSBpbmZvcm1hdGlv bi4KKyAqLworI2RlZmluZSBLVU5JVF9TVUNDRUVEKHRlc3QpIGRvIHt9IHdoaWxlICgwKQorCit2 b2lkIGt1bml0X2RvX2Fzc2VydGlvbihzdHJ1Y3Qga3VuaXQgKnRlc3QsCisJCQlzdHJ1Y3Qga3Vu aXRfYXNzZXJ0ICphc3NlcnQsCisJCQlib29sIHBhc3MsCisJCQljb25zdCBjaGFyICpmbXQsIC4u Lik7CisKKyNkZWZpbmUgS1VOSVRfQVNTRVJUSU9OKHRlc3QsIHBhc3MsIGFzc2VydF9jbGFzcywg SU5JVElBTElaRVIsIGZtdCwgLi4uKSBkbyB7ICBcCisJc3RydWN0IGFzc2VydF9jbGFzcyBfX2Fz c2VydGlvbiA9IElOSVRJQUxJWkVSOwkJCSAgICAgICBcCisJa3VuaXRfZG9fYXNzZXJ0aW9uKHRl c3QsCQkJCQkgICAgICAgXAorCQkJICAgJl9fYXNzZXJ0aW9uLmFzc2VydCwJCQkJICAgICAgIFwK KwkJCSAgIHBhc3MsCQkJCQkgICAgICAgXAorCQkJICAgZm10LAkJCQkJCSAgICAgICBcCisJCQkg ICAjI19fVkFfQVJHU19fKTsJCQkJICAgICAgIFwKK30gd2hpbGUgKDApCisKKworI2RlZmluZSBL VU5JVF9GQUlMX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgZm10LCAuLi4pCQkgICAgICAg XAorCUtVTklUX0FTU0VSVElPTih0ZXN0LAkJCQkJCSAgICAgICBcCisJCQlmYWxzZSwJCQkJCQkg ICAgICAgXAorCQkJa3VuaXRfZmFpbF9hc3NlcnQsCQkJCSAgICAgICBcCisJCQlLVU5JVF9JTklU X0ZBSUxfQVNTRVJUX1NUUlVDVCh0ZXN0LCBhc3NlcnRfdHlwZSksICAgICAgXAorCQkJZm10LAkJ CQkJCSAgICAgICBcCisJCQkjI19fVkFfQVJHU19fKQorCisvKioKKyAqIEtVTklUX0ZBSUwoKSAt IEFsd2F5cyBjYXVzZXMgYSB0ZXN0IHRvIGZhaWwgd2hlbiBldmFsdWF0ZWQuCisgKiBAdGVzdDog VGhlIHRlc3QgY29udGV4dCBvYmplY3QuCisgKiBAZm10OiBhbiBpbmZvcm1hdGlvbmFsIG1lc3Nh Z2UgdG8gYmUgcHJpbnRlZCB3aGVuIHRoZSBhc3NlcnRpb24gaXMgbWFkZS4KKyAqIEAuLi46IHN0 cmluZyBmb3JtYXQgYXJndW1lbnRzLgorICoKKyAqIFRoZSBvcHBvc2l0ZSBvZiBLVU5JVF9TVUND RUVEKCksIGl0IGlzIGFuIGV4cGVjdGF0aW9uIHRoYXQgYWx3YXlzIGZhaWxzLiBJbgorICogb3Ro ZXIgd29yZHMsIGl0IGFsd2F5cyByZXN1bHRzIGluIGEgZmFpbGVkIGV4cGVjdGF0aW9uLCBhbmQg Y29uc2VxdWVudGx5CisgKiBhbHdheXMgY2F1c2VzIHRoZSB0ZXN0IGNhc2UgdG8gZmFpbCB3aGVu IGV2YWx1YXRlZC4gU2VlIEtVTklUX0VYUEVDVF9UUlVFKCkKKyAqIGZvciBtb3JlIGluZm9ybWF0 aW9uLgorICovCisjZGVmaW5lIEtVTklUX0ZBSUwodGVzdCwgZm10LCAuLi4pCQkJCQkgICAgICAg XAorCUtVTklUX0ZBSUxfQVNTRVJUSU9OKHRlc3QsCQkJCQkgICAgICAgXAorCQkJICAgICBLVU5J VF9FWFBFQ1RBVElPTiwJCQkJICAgICAgIFwKKwkJCSAgICAgZm10LAkJCQkJICAgICAgIFwKKwkJ CSAgICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmluZSBLVU5JVF9VTkFSWV9BU1NFUlRJT04odGVz dCwJCQkJCSAgICAgICBcCisJCQkgICAgICBhc3NlcnRfdHlwZSwJCQkJICAgICAgIFwKKwkJCSAg ICAgIGNvbmRpdGlvbiwJCQkJICAgICAgIFwKKwkJCSAgICAgIGV4cGVjdGVkX3RydWUsCQkJCSAg ICAgICBcCisJCQkgICAgICBmbXQsCQkJCQkgICAgICAgXAorCQkJICAgICAgLi4uKQkJCQkJICAg ICAgIFwKKwlLVU5JVF9BU1NFUlRJT04odGVzdCwJCQkJCQkgICAgICAgXAorCQkJISEoY29uZGl0 aW9uKSA9PSAhIWV4cGVjdGVkX3RydWUsCQkgICAgICAgXAorCQkJa3VuaXRfdW5hcnlfYXNzZXJ0 LAkJCQkgICAgICAgXAorCQkJS1VOSVRfSU5JVF9VTkFSWV9BU1NFUlRfU1RSVUNUKHRlc3QsCQkg ICAgICAgXAorCQkJCQkJICAgICAgIGFzc2VydF90eXBlLAkgICAgICAgXAorCQkJCQkJICAgICAg ICNjb25kaXRpb24sCSAgICAgICBcCisJCQkJCQkgICAgICAgZXhwZWN0ZWRfdHJ1ZSksCSAgICAg ICBcCisJCQlmbXQsCQkJCQkJICAgICAgIFwKKwkJCSMjX19WQV9BUkdTX18pCisKKyNkZWZpbmUg S1VOSVRfVFJVRV9NU0dfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBjb25kaXRpb24sIGZt dCwgLi4uKSAgICAgICBcCisJS1VOSVRfVU5BUllfQVNTRVJUSU9OKHRlc3QsCQkJCQkgICAgICAg XAorCQkJICAgICAgYXNzZXJ0X3R5cGUsCQkJCSAgICAgICBcCisJCQkgICAgICBjb25kaXRpb24s CQkJCSAgICAgICBcCisJCQkgICAgICB0cnVlLAkJCQkJICAgICAgIFwKKwkJCSAgICAgIGZtdCwJ CQkJCSAgICAgICBcCisJCQkgICAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtVTklUX1RS VUVfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBjb25kaXRpb24pIFwKKwlLVU5JVF9UUlVF X01TR19BU1NFUlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGNvbmRpdGlvbiwgTlVMTCkKKworI2Rl ZmluZSBLVU5JVF9GQUxTRV9NU0dfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBjb25kaXRp b24sIGZtdCwgLi4uKSAgICAgIFwKKwlLVU5JVF9VTkFSWV9BU1NFUlRJT04odGVzdCwJCQkJCSAg ICAgICBcCisJCQkgICAgICBhc3NlcnRfdHlwZSwJCQkJICAgICAgIFwKKwkJCSAgICAgIGNvbmRp dGlvbiwJCQkJICAgICAgIFwKKwkJCSAgICAgIGZhbHNlLAkJCQkJICAgICAgIFwKKwkJCSAgICAg IGZtdCwJCQkJCSAgICAgICBcCisJCQkgICAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtV TklUX0ZBTFNFX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgY29uZGl0aW9uKSBcCisJS1VO SVRfRkFMU0VfTVNHX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgY29uZGl0aW9uLCBOVUxM KQorCisvKgorICogQSBmYWN0b3J5IG1hY3JvIGZvciBkZWZpbmluZyB0aGUgYXNzZXJ0aW9ucyBh bmQgZXhwZWN0YXRpb25zIGZvciB0aGUgYmFzaWMKKyAqIGNvbXBhcmlzb25zIGRlZmluZWQgZm9y IHRoZSBidWlsdCBpbiB0eXBlcy4KKyAqCisgKiBVbmZvcnR1bmF0ZWx5LCB0aGVyZSBpcyBubyBj b21tb24gdHlwZSB0aGF0IGFsbCB0eXBlcyBjYW4gYmUgcHJvbW90ZWQgdG8gZm9yCisgKiB3aGlj aCBhbGwgdGhlIGJpbmFyeSBvcGVyYXRvcnMgYmVoYXZlIHRoZSBzYW1lIHdheSBhcyBmb3IgdGhl IGFjdHVhbCB0eXBlcworICogKGZvciBleGFtcGxlLCB0aGVyZSBpcyBubyB0eXBlIHRoYXQgbG9u ZyBsb25nIGFuZCB1bnNpZ25lZCBsb25nIGxvbmcgY2FuCisgKiBib3RoIGJlIGNhc3QgdG8gd2hl cmUgdGhlIGNvbXBhcmlzb24gcmVzdWx0IGlzIHByZXNlcnZlZCBmb3IgYWxsIHZhbHVlcykuIFNv CisgKiB0aGUgYmVzdCB3ZSBjYW4gZG8gaXMgZG8gdGhlIGNvbXBhcmlzb24gaW4gdGhlIG9yaWdp bmFsIHR5cGVzIGFuZCB0aGVuIGNvZXJjZQorICogZXZlcnl0aGluZyB0byBsb25nIGxvbmcgZm9y IHByaW50aW5nOyB0aGlzIHdheSwgdGhlIGNvbXBhcmlzb24gYmVoYXZlcworICogY29ycmVjdGx5 IGFuZCB0aGUgcHJpbnRlZCBvdXQgdmFsdWUgdXN1YWxseSBtYWtlcyBzZW5zZSB3aXRob3V0Cisg KiBpbnRlcnByZXRhdGlvbiwgYnV0IGNhbiBhbHdheXMgYmUgaW50ZXJwcmV0ZWQgdG8gZmlndXJl IG91dCB0aGUgYWN0dWFsCisgKiB2YWx1ZS4KKyAqLworI2RlZmluZSBLVU5JVF9CQVNFX0JJTkFS WV9BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X2NsYXNzLAkJCSAg ICAgICBcCisJCQkJICAgIEFTU0VSVF9DTEFTU19JTklULAkJCSAgICAgICBcCisJCQkJICAgIGFz c2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAg IG9wLAkJCQkJICAgICAgIFwKKwkJCQkgICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAgIGZt dCwJCQkJICAgICAgIFwKKwkJCQkgICAgLi4uKQkJCQkgICAgICAgXAorZG8gewkJCQkJCQkJCSAg ICAgICBcCisJdHlwZW9mKGxlZnQpIF9fbGVmdCA9IChsZWZ0KTsJCQkJCSAgICAgICBcCisJdHlw ZW9mKHJpZ2h0KSBfX3JpZ2h0ID0gKHJpZ2h0KTsJCQkJICAgICAgIFwKKwkoKHZvaWQpX190eXBl Y2hlY2soX19sZWZ0LCBfX3JpZ2h0KSk7CQkJCSAgICAgICBcCisJCQkJCQkJCQkgICAgICAgXAor CUtVTklUX0FTU0VSVElPTih0ZXN0LAkJCQkJCSAgICAgICBcCisJCQlfX2xlZnQgb3AgX19yaWdo dCwJCQkJICAgICAgIFwKKwkJCWFzc2VydF9jbGFzcywJCQkJCSAgICAgICBcCisJCQlBU1NFUlRf Q0xBU1NfSU5JVCh0ZXN0LAkJCQkgICAgICAgXAorCQkJCQkgIGFzc2VydF90eXBlLAkJCSAgICAg ICBcCisJCQkJCSAgI29wLAkJCQkgICAgICAgXAorCQkJCQkgICNsZWZ0LAkJCSAgICAgICBcCisJ CQkJCSAgX19sZWZ0LAkJCSAgICAgICBcCisJCQkJCSAgI3JpZ2h0LAkJCSAgICAgICBcCisJCQkJ CSAgX19yaWdodCksCQkJICAgICAgIFwKKwkJCWZtdCwJCQkJCQkgICAgICAgXAorCQkJIyNfX1ZB X0FSR1NfXyk7CQkJCQkgICAgICAgXAorfSB3aGlsZSAoMCkKKworI2RlZmluZSBLVU5JVF9CQVNF X0VRX01TR19BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X2NsYXNz LAkJCSAgICAgICBcCisJCQkJICAgIEFTU0VSVF9DTEFTU19JTklULAkJCSAgICAgICBcCisJCQkJ ICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAgIGxlZnQsCQkJCSAgICAgICBcCisJ CQkJICAgIHJpZ2h0LAkJCQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJCSAgICAgICBcCisJCQkJ ICAgIC4uLikJCQkJICAgICAgIFwKKwlLVU5JVF9CQVNFX0JJTkFSWV9BU1NFUlRJT04odGVzdCwJ CQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X2NsYXNzLAkJCSAgICAgICBcCisJCQkJICAgIEFT U0VSVF9DTEFTU19JTklULAkJCSAgICAgICBcCisJCQkJICAgIGFzc2VydF90eXBlLAkJCSAgICAg ICBcCisJCQkJICAgIGxlZnQsID09LCByaWdodCwJCQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJ CSAgICAgICBcCisJCQkJICAgICMjX19WQV9BUkdTX18pCisKKyNkZWZpbmUgS1VOSVRfQkFTRV9O RV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgIGFzc2VydF9jbGFzcywJ CQkgICAgICAgXAorCQkJCSAgICBBU1NFUlRfQ0xBU1NfSU5JVCwJCQkgICAgICAgXAorCQkJCSAg ICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCSAgICBsZWZ0LAkJCQkgICAgICAgXAorCQkJ CSAgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkgICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAg ICAuLi4pCQkJCSAgICAgICBcCisJS1VOSVRfQkFTRV9CSU5BUllfQVNTRVJUSU9OKHRlc3QsCQkJ CSAgICAgICBcCisJCQkJICAgIGFzc2VydF9jbGFzcywJCQkgICAgICAgXAorCQkJCSAgICBBU1NF UlRfQ0xBU1NfSU5JVCwJCQkgICAgICAgXAorCQkJCSAgICBhc3NlcnRfdHlwZSwJCQkgICAgICAg XAorCQkJCSAgICBsZWZ0LCAhPSwgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkgICAgZm10LAkJCQkg ICAgICAgXAorCQkJCSAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtVTklUX0JBU0VfTFRf TVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICBhc3NlcnRfY2xhc3MsCQkJ ICAgICAgIFwKKwkJCQkgICAgQVNTRVJUX0NMQVNTX0lOSVQsCQkJICAgICAgIFwKKwkJCQkgICAg YXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkgICAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkg ICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAgIGZtdCwJCQkJICAgICAgIFwKKwkJCQkgICAg Li4uKQkJCQkgICAgICAgXAorCUtVTklUX0JBU0VfQklOQVJZX0FTU0VSVElPTih0ZXN0LAkJCQkg ICAgICAgXAorCQkJCSAgICBhc3NlcnRfY2xhc3MsCQkJICAgICAgIFwKKwkJCQkgICAgQVNTRVJU X0NMQVNTX0lOSVQsCQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwK KwkJCQkgICAgbGVmdCwgPCwgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkgICAgZm10LAkJCQkgICAg ICAgXAorCQkJCSAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtVTklUX0JBU0VfTEVfTVNH X0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICBhc3NlcnRfY2xhc3MsCQkJICAg ICAgIFwKKwkJCQkgICAgQVNTRVJUX0NMQVNTX0lOSVQsCQkJICAgICAgIFwKKwkJCQkgICAgYXNz ZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkgICAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkgICAg cmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAgIGZtdCwJCQkJICAgICAgIFwKKwkJCQkgICAgLi4u KQkJCQkgICAgICAgXAorCUtVTklUX0JBU0VfQklOQVJZX0FTU0VSVElPTih0ZXN0LAkJCQkgICAg ICAgXAorCQkJCSAgICBhc3NlcnRfY2xhc3MsCQkJICAgICAgIFwKKwkJCQkgICAgQVNTRVJUX0NM QVNTX0lOSVQsCQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJ CQkgICAgbGVmdCwgPD0sIHJpZ2h0LAkJCSAgICAgICBcCisJCQkJICAgIGZtdCwJCQkJICAgICAg IFwKKwkJCQkgICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmluZSBLVU5JVF9CQVNFX0dUX01TR19B U1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X2NsYXNzLAkJCSAgICAg ICBcCisJCQkJICAgIEFTU0VSVF9DTEFTU19JTklULAkJCSAgICAgICBcCisJCQkJICAgIGFzc2Vy dF90eXBlLAkJCSAgICAgICBcCisJCQkJICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgIHJp Z2h0LAkJCQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJCSAgICAgICBcCisJCQkJICAgIC4uLikJ CQkJICAgICAgIFwKKwlLVU5JVF9CQVNFX0JJTkFSWV9BU1NFUlRJT04odGVzdCwJCQkJICAgICAg IFwKKwkJCQkgICAgYXNzZXJ0X2NsYXNzLAkJCSAgICAgICBcCisJCQkJICAgIEFTU0VSVF9DTEFT U19JTklULAkJCSAgICAgICBcCisJCQkJICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJ ICAgIGxlZnQsID4sIHJpZ2h0LAkJCSAgICAgICBcCisJCQkJICAgIGZtdCwJCQkJICAgICAgIFwK KwkJCQkgICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmluZSBLVU5JVF9CQVNFX0dFX01TR19BU1NF UlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X2NsYXNzLAkJCSAgICAgICBc CisJCQkJICAgIEFTU0VSVF9DTEFTU19JTklULAkJCSAgICAgICBcCisJCQkJICAgIGFzc2VydF90 eXBlLAkJCSAgICAgICBcCisJCQkJICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgIHJpZ2h0 LAkJCQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJCSAgICAgICBcCisJCQkJICAgIC4uLikJCQkJ ICAgICAgIFwKKwlLVU5JVF9CQVNFX0JJTkFSWV9BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwK KwkJCQkgICAgYXNzZXJ0X2NsYXNzLAkJCSAgICAgICBcCisJCQkJICAgIEFTU0VSVF9DTEFTU19J TklULAkJCSAgICAgICBcCisJCQkJICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAg IGxlZnQsID49LCByaWdodCwJCQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJCSAgICAgICBcCisJ CQkJICAgICMjX19WQV9BUkdTX18pCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZX0VRX01TR19BU1NF UlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQsIHJpZ2h0LCBmbXQsIC4uLilcCisJS1VOSVRf QkFTRV9FUV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgIGt1bml0X2Jp bmFyeV9hc3NlcnQsCQkgICAgICAgXAorCQkJCSAgICBLVU5JVF9JTklUX0JJTkFSWV9BU1NFUlRf U1RSVUNULAkgICAgICAgXAorCQkJCSAgICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCSAg ICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCSAgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkgICAg Zm10LAkJCQkgICAgICAgXAorCQkJCSAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtVTklU X0JJTkFSWV9FUV9BU1NFUlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQsIHJpZ2h0KQkgICAg ICAgXAorCUtVTklUX0JJTkFSWV9FUV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJ CQkJICAgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkgICAgICBsZWZ0LAkJCQkgICAg ICAgXAorCQkJCSAgICAgIHJpZ2h0LAkJCQkgICAgICAgXAorCQkJCSAgICAgIE5VTEwpCisKKyNk ZWZpbmUgS1VOSVRfQklOQVJZX1BUUl9FUV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBc CisJCQkJCSAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkJICBsZWZ0LAkJCQkgICAgICAg XAorCQkJCQkgIHJpZ2h0LAkJCSAgICAgICBcCisJCQkJCSAgZm10LAkJCQkgICAgICAgXAorCQkJ CQkgIC4uLikJCQkJICAgICAgIFwKKwlLVU5JVF9CQVNFX0VRX01TR19BU1NFUlRJT04odGVzdCwJ CQkJICAgICAgIFwKKwkJCQkgICAga3VuaXRfYmluYXJ5X3B0cl9hc3NlcnQsCQkgICAgICAgXAor CQkJCSAgICBLVU5JVF9JTklUX0JJTkFSWV9QVFJfQVNTRVJUX1NUUlVDVCwgICAgICAgXAorCQkJ CSAgICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCSAgICBsZWZ0LAkJCQkgICAgICAgXAor CQkJCSAgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkgICAgZm10LAkJCQkgICAgICAgXAorCQkJ CSAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtVTklUX0JJTkFSWV9QVFJfRVFfQVNTRVJU SU9OKHRlc3QsIGFzc2VydF90eXBlLCBsZWZ0LCByaWdodCkJICAgICAgIFwKKwlLVU5JVF9CSU5B UllfUFRSX0VRX01TR19BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkJICBhc3NlcnRf dHlwZSwJCQkgICAgICAgXAorCQkJCQkgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJCSAgcmlnaHQs CQkJICAgICAgIFwKKwkJCQkJICBOVUxMKQorCisjZGVmaW5lIEtVTklUX0JJTkFSWV9ORV9NU0df QVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBsZWZ0LCByaWdodCwgZm10LCAuLi4pXAorCUtV TklUX0JBU0VfTkVfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICBrdW5p dF9iaW5hcnlfYXNzZXJ0LAkJICAgICAgIFwKKwkJCQkgICAgS1VOSVRfSU5JVF9CSU5BUllfQVNT RVJUX1NUUlVDVCwJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJ CQkgICAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkgICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJ ICAgIGZtdCwJCQkJICAgICAgIFwKKwkJCQkgICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmluZSBL VU5JVF9CSU5BUllfTkVfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBsZWZ0LCByaWdodCkJ ICAgICAgIFwKKwlLVU5JVF9CSU5BUllfTkVfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAg XAorCQkJCSAgICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAgICAgbGVmdCwJCQkJ ICAgICAgIFwKKwkJCQkgICAgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkgICAgICBOVUxMKQor CisjZGVmaW5lIEtVTklUX0JJTkFSWV9QVFJfTkVfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAg ICAgXAorCQkJCQkgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJCSAgbGVmdCwJCQkJICAg ICAgIFwKKwkJCQkJICByaWdodCwJCQkgICAgICAgXAorCQkJCQkgIGZtdCwJCQkJICAgICAgIFwK KwkJCQkJICAuLi4pCQkJCSAgICAgICBcCisJS1VOSVRfQkFTRV9ORV9NU0dfQVNTRVJUSU9OKHRl c3QsCQkJCSAgICAgICBcCisJCQkJICAgIGt1bml0X2JpbmFyeV9wdHJfYXNzZXJ0LAkJICAgICAg IFwKKwkJCQkgICAgS1VOSVRfSU5JVF9CSU5BUllfUFRSX0FTU0VSVF9TVFJVQ1QsICAgICAgIFwK KwkJCQkgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkgICAgbGVmdCwJCQkJICAgICAg IFwKKwkJCQkgICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAgIGZtdCwJCQkJICAgICAgIFwK KwkJCQkgICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmluZSBLVU5JVF9CSU5BUllfUFRSX05FX0FT U0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgbGVmdCwgcmlnaHQpCSAgICAgICBcCisJS1VOSVRf QklOQVJZX1BUUl9ORV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJCSAgYXNz ZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkJICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCQkgIHJp Z2h0LAkJCSAgICAgICBcCisJCQkJCSAgTlVMTCkKKworI2RlZmluZSBLVU5JVF9CSU5BUllfTFRf TVNHX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgbGVmdCwgcmlnaHQsIGZtdCwgLi4uKVwK KwlLVU5JVF9CQVNFX0xUX01TR19BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAg a3VuaXRfYmluYXJ5X2Fzc2VydCwJCSAgICAgICBcCisJCQkJICAgIEtVTklUX0lOSVRfQklOQVJZ X0FTU0VSVF9TVFJVQ1QsCSAgICAgICBcCisJCQkJICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBc CisJCQkJICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgIHJpZ2h0LAkJCQkgICAgICAgXAor CQkJCSAgICBmbXQsCQkJCSAgICAgICBcCisJCQkJICAgICMjX19WQV9BUkdTX18pCisKKyNkZWZp bmUgS1VOSVRfQklOQVJZX0xUX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgbGVmdCwgcmln aHQpCSAgICAgICBcCisJS1VOSVRfQklOQVJZX0xUX01TR19BU1NFUlRJT04odGVzdCwJCQkJICAg ICAgIFwKKwkJCQkgICAgICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCSAgICAgIGxlZnQs CQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAgICAgTlVM TCkKKworI2RlZmluZSBLVU5JVF9CSU5BUllfUFRSX0xUX01TR19BU1NFUlRJT04odGVzdCwJCQkJ ICAgICAgIFwKKwkJCQkJICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCQkgIGxlZnQsCQkJ CSAgICAgICBcCisJCQkJCSAgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkJICBmbXQsCQkJCSAgICAg ICBcCisJCQkJCSAgLi4uKQkJCQkgICAgICAgXAorCUtVTklUX0JBU0VfTFRfTVNHX0FTU0VSVElP Tih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICBrdW5pdF9iaW5hcnlfcHRyX2Fzc2VydCwJCSAg ICAgICBcCisJCQkJICAgIEtVTklUX0lOSVRfQklOQVJZX1BUUl9BU1NFUlRfU1RSVUNULCAgICAg ICBcCisJCQkJICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAgIGxlZnQsCQkJCSAg ICAgICBcCisJCQkJICAgIHJpZ2h0LAkJCQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJCSAgICAg ICBcCisJCQkJICAgICMjX19WQV9BUkdTX18pCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZX1BUUl9M VF9BU1NFUlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQsIHJpZ2h0KQkgICAgICAgXAorCUtV TklUX0JJTkFSWV9QVFJfTFRfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCQkg IGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJCSAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkJ ICByaWdodCwJCQkgICAgICAgXAorCQkJCQkgIE5VTEwpCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZ X0xFX01TR19BU1NFUlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQsIHJpZ2h0LCBmbXQsIC4u LilcCisJS1VOSVRfQkFTRV9MRV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJ ICAgIGt1bml0X2JpbmFyeV9hc3NlcnQsCQkgICAgICAgXAorCQkJCSAgICBLVU5JVF9JTklUX0JJ TkFSWV9BU1NFUlRfU1RSVUNULAkgICAgICAgXAorCQkJCSAgICBhc3NlcnRfdHlwZSwJCQkgICAg ICAgXAorCQkJCSAgICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCSAgICByaWdodCwJCQkJICAgICAg IFwKKwkJCQkgICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAgICAjI19fVkFfQVJHU19fKQorCisj ZGVmaW5lIEtVTklUX0JJTkFSWV9MRV9BU1NFUlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQs IHJpZ2h0KQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9MRV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJ CSAgICAgICBcCisJCQkJICAgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkgICAgICBs ZWZ0LAkJCQkgICAgICAgXAorCQkJCSAgICAgIHJpZ2h0LAkJCQkgICAgICAgXAorCQkJCSAgICAg IE5VTEwpCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZX1BUUl9MRV9NU0dfQVNTRVJUSU9OKHRlc3Qs CQkJCSAgICAgICBcCisJCQkJCSAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkJICBsZWZ0 LAkJCQkgICAgICAgXAorCQkJCQkgIHJpZ2h0LAkJCSAgICAgICBcCisJCQkJCSAgZm10LAkJCQkg ICAgICAgXAorCQkJCQkgIC4uLikJCQkJICAgICAgIFwKKwlLVU5JVF9CQVNFX0xFX01TR19BU1NF UlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAga3VuaXRfYmluYXJ5X3B0cl9hc3NlcnQs CQkgICAgICAgXAorCQkJCSAgICBLVU5JVF9JTklUX0JJTkFSWV9QVFJfQVNTRVJUX1NUUlVDVCwg ICAgICAgXAorCQkJCSAgICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCSAgICBsZWZ0LAkJ CQkgICAgICAgXAorCQkJCSAgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkgICAgZm10LAkJCQkg ICAgICAgXAorCQkJCSAgICAjI19fVkFfQVJHU19fKQorCisjZGVmaW5lIEtVTklUX0JJTkFSWV9Q VFJfTEVfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBsZWZ0LCByaWdodCkJICAgICAgIFwK KwlLVU5JVF9CSU5BUllfUFRSX0xFX01TR19BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJ CQkJICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJCQkgIGxlZnQsCQkJCSAgICAgICBcCisJ CQkJCSAgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkJICBOVUxMKQorCisjZGVmaW5lIEtVTklUX0JJ TkFSWV9HVF9NU0dfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBsZWZ0LCByaWdodCwgZm10 LCAuLi4pXAorCUtVTklUX0JBU0VfR1RfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAor CQkJCSAgICBrdW5pdF9iaW5hcnlfYXNzZXJ0LAkJICAgICAgIFwKKwkJCQkgICAgS1VOSVRfSU5J VF9CSU5BUllfQVNTRVJUX1NUUlVDVCwJICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X3R5cGUsCQkJ ICAgICAgIFwKKwkJCQkgICAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkgICAgcmlnaHQsCQkJCSAg ICAgICBcCisJCQkJICAgIGZtdCwJCQkJICAgICAgIFwKKwkJCQkgICAgIyNfX1ZBX0FSR1NfXykK KworI2RlZmluZSBLVU5JVF9CSU5BUllfR1RfQVNTRVJUSU9OKHRlc3QsIGFzc2VydF90eXBlLCBs ZWZ0LCByaWdodCkJICAgICAgIFwKKwlLVU5JVF9CSU5BUllfR1RfTVNHX0FTU0VSVElPTih0ZXN0 LAkJCQkgICAgICAgXAorCQkJCSAgICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAg ICAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkgICAgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkg ICAgICBOVUxMKQorCisjZGVmaW5lIEtVTklUX0JJTkFSWV9QVFJfR1RfTVNHX0FTU0VSVElPTih0 ZXN0LAkJCQkgICAgICAgXAorCQkJCQkgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJCSAg bGVmdCwJCQkJICAgICAgIFwKKwkJCQkJICByaWdodCwJCQkgICAgICAgXAorCQkJCQkgIGZtdCwJ CQkJICAgICAgIFwKKwkJCQkJICAuLi4pCQkJCSAgICAgICBcCisJS1VOSVRfQkFTRV9HVF9NU0df QVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgIGt1bml0X2JpbmFyeV9wdHJfYXNz ZXJ0LAkJICAgICAgIFwKKwkJCQkgICAgS1VOSVRfSU5JVF9CSU5BUllfUFRSX0FTU0VSVF9TVFJV Q1QsICAgICAgIFwKKwkJCQkgICAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkgICAgbGVm dCwJCQkJICAgICAgIFwKKwkJCQkgICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAgIGZtdCwJ CQkJICAgICAgIFwKKwkJCQkgICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmluZSBLVU5JVF9CSU5B UllfUFRSX0dUX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgbGVmdCwgcmlnaHQpCSAgICAg ICBcCisJS1VOSVRfQklOQVJZX1BUUl9HVF9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBc CisJCQkJCSAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkJICBsZWZ0LAkJCQkgICAgICAg XAorCQkJCQkgIHJpZ2h0LAkJCSAgICAgICBcCisJCQkJCSAgTlVMTCkKKworI2RlZmluZSBLVU5J VF9CSU5BUllfR0VfTVNHX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgbGVmdCwgcmlnaHQs IGZtdCwgLi4uKVwKKwlLVU5JVF9CQVNFX0dFX01TR19BU1NFUlRJT04odGVzdCwJCQkJICAgICAg IFwKKwkJCQkgICAga3VuaXRfYmluYXJ5X2Fzc2VydCwJCSAgICAgICBcCisJCQkJICAgIEtVTklU X0lOSVRfQklOQVJZX0FTU0VSVF9TVFJVQ1QsCSAgICAgICBcCisJCQkJICAgIGFzc2VydF90eXBl LAkJCSAgICAgICBcCisJCQkJICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgIHJpZ2h0LAkJ CQkgICAgICAgXAorCQkJCSAgICBmbXQsCQkJCSAgICAgICBcCisJCQkJICAgICMjX19WQV9BUkdT X18pCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZX0dFX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlw ZSwgbGVmdCwgcmlnaHQpCSAgICAgICBcCisJS1VOSVRfQklOQVJZX0dFX01TR19BU1NFUlRJT04o dGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAgICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJ CSAgICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQsCQkJCSAgICAgICBcCisJ CQkJICAgICAgTlVMTCkKKworI2RlZmluZSBLVU5JVF9CSU5BUllfUFRSX0dFX01TR19BU1NFUlRJ T04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkJICBhc3NlcnRfdHlwZSwJCQkgICAgICAgXAorCQkJ CQkgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJCSAgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkJICBm bXQsCQkJCSAgICAgICBcCisJCQkJCSAgLi4uKQkJCQkgICAgICAgXAorCUtVTklUX0JBU0VfR0Vf TVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICBrdW5pdF9iaW5hcnlfcHRy X2Fzc2VydCwJCSAgICAgICBcCisJCQkJICAgIEtVTklUX0lOSVRfQklOQVJZX1BUUl9BU1NFUlRf U1RSVUNULCAgICAgICBcCisJCQkJICAgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJICAg IGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgIHJpZ2h0LAkJCQkgICAgICAgXAorCQkJCSAgICBm bXQsCQkJCSAgICAgICBcCisJCQkJICAgICMjX19WQV9BUkdTX18pCisKKyNkZWZpbmUgS1VOSVRf QklOQVJZX1BUUl9HRV9BU1NFUlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQsIHJpZ2h0KQkg ICAgICAgXAorCUtVTklUX0JJTkFSWV9QVFJfR0VfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAg ICAgXAorCQkJCQkgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJCSAgbGVmdCwJCQkJICAg ICAgIFwKKwkJCQkJICByaWdodCwJCQkgICAgICAgXAorCQkJCQkgIE5VTEwpCisKKyNkZWZpbmUg S1VOSVRfQklOQVJZX1NUUl9BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICBhc3Nl cnRfdHlwZSwJCQkJICAgICAgIFwKKwkJCQkgICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCSAgIG9w LAkJCQkJICAgICAgIFwKKwkJCQkgICByaWdodCwJCQkJICAgICAgIFwKKwkJCQkgICBmbXQsCQkJ CQkgICAgICAgXAorCQkJCSAgIC4uLikJCQkJCSAgICAgICBcCitkbyB7CQkJCQkJCQkJICAgICAg IFwKKwl0eXBlb2YobGVmdCkgX19sZWZ0ID0gKGxlZnQpOwkJCQkJICAgICAgIFwKKwl0eXBlb2Yo cmlnaHQpIF9fcmlnaHQgPSAocmlnaHQpOwkJCQkgICAgICAgXAorCQkJCQkJCQkJICAgICAgIFwK KwlLVU5JVF9BU1NFUlRJT04odGVzdCwJCQkJCQkgICAgICAgXAorCQkJc3RyY21wKF9fbGVmdCwg X19yaWdodCkgb3AgMCwJCQkgICAgICAgXAorCQkJa3VuaXRfYmluYXJ5X3N0cl9hc3NlcnQsCQkJ ICAgICAgIFwKKwkJCUtVTklUX0lOSVRfQklOQVJZX0FTU0VSVF9TVFJVQ1QodGVzdCwJCSAgICAg ICBcCisJCQkJCQkJYXNzZXJ0X3R5cGUsCSAgICAgICBcCisJCQkJCQkJI29wLAkJICAgICAgIFwK KwkJCQkJCQkjbGVmdCwJCSAgICAgICBcCisJCQkJCQkJX19sZWZ0LAkJICAgICAgIFwKKwkJCQkJ CQkjcmlnaHQsCQkgICAgICAgXAorCQkJCQkJCV9fcmlnaHQpLAkgICAgICAgXAorCQkJZm10LAkJ CQkJCSAgICAgICBcCisJCQkjI19fVkFfQVJHU19fKTsJCQkJCSAgICAgICBcCit9IHdoaWxlICgw KQorCisjZGVmaW5lIEtVTklUX0JJTkFSWV9TVFJfRVFfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkg ICAgICAgXAorCQkJCQkgIGFzc2VydF90eXBlLAkJCSAgICAgICBcCisJCQkJCSAgbGVmdCwJCQkJ ICAgICAgIFwKKwkJCQkJICByaWdodCwJCQkgICAgICAgXAorCQkJCQkgIGZtdCwJCQkJICAgICAg IFwKKwkJCQkJICAuLi4pCQkJCSAgICAgICBcCisJS1VOSVRfQklOQVJZX1NUUl9BU1NFUlRJT04o dGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICBhc3NlcnRfdHlwZSwJCQkJICAgICAgIFwKKwkJCQkg ICBsZWZ0LCA9PSwgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkgICBmbXQsCQkJCQkgICAgICAgXAor CQkJCSAgICMjX19WQV9BUkdTX18pCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZX1NUUl9FUV9BU1NF UlRJT04odGVzdCwgYXNzZXJ0X3R5cGUsIGxlZnQsIHJpZ2h0KQkgICAgICAgXAorCUtVTklUX0JJ TkFSWV9TVFJfRVFfTVNHX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCQkgIGFzc2Vy dF90eXBlLAkJCSAgICAgICBcCisJCQkJCSAgbGVmdCwJCQkJICAgICAgIFwKKwkJCQkJICByaWdo dCwJCQkgICAgICAgXAorCQkJCQkgIE5VTEwpCisKKyNkZWZpbmUgS1VOSVRfQklOQVJZX1NUUl9O RV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJCSAgYXNzZXJ0X3R5cGUsCQkJ ICAgICAgIFwKKwkJCQkJICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCQkgIHJpZ2h0LAkJCSAgICAg ICBcCisJCQkJCSAgZm10LAkJCQkgICAgICAgXAorCQkJCQkgIC4uLikJCQkJICAgICAgIFwKKwlL VU5JVF9CSU5BUllfU1RSX0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgIGFzc2Vy dF90eXBlLAkJCQkgICAgICAgXAorCQkJCSAgIGxlZnQsICE9LCByaWdodCwJCQkgICAgICAgXAor CQkJCSAgIGZtdCwJCQkJCSAgICAgICBcCisJCQkJICAgIyNfX1ZBX0FSR1NfXykKKworI2RlZmlu ZSBLVU5JVF9CSU5BUllfU1RSX05FX0FTU0VSVElPTih0ZXN0LCBhc3NlcnRfdHlwZSwgbGVmdCwg cmlnaHQpCSAgICAgICBcCisJS1VOSVRfQklOQVJZX1NUUl9ORV9NU0dfQVNTRVJUSU9OKHRlc3Qs CQkJCSAgICAgICBcCisJCQkJCSAgYXNzZXJ0X3R5cGUsCQkJICAgICAgIFwKKwkJCQkJICBsZWZ0 LAkJCQkgICAgICAgXAorCQkJCQkgIHJpZ2h0LAkJCSAgICAgICBcCisJCQkJCSAgTlVMTCkKKwor I2RlZmluZSBLVU5JVF9QVFJfTk9UX0VSUl9PUl9OVUxMX01TR19BU1NFUlRJT04odGVzdCwJCQkg ICAgICAgXAorCQkJCQkJYXNzZXJ0X3R5cGUsCQkgICAgICAgXAorCQkJCQkJcHRyLAkJCSAgICAg ICBcCisJCQkJCQlmbXQsCQkJICAgICAgIFwKKwkJCQkJCS4uLikJCQkgICAgICAgXAorZG8gewkJ CQkJCQkJCSAgICAgICBcCisJdHlwZW9mKHB0cikgX19wdHIgPSAocHRyKTsJCQkJCSAgICAgICBc CisJCQkJCQkJCQkgICAgICAgXAorCUtVTklUX0FTU0VSVElPTih0ZXN0LAkJCQkJCSAgICAgICBc CisJCQkhSVNfRVJSX09SX05VTEwoX19wdHIpLAkJCQkgICAgICAgXAorCQkJa3VuaXRfcHRyX25v dF9lcnJfYXNzZXJ0LAkJCSAgICAgICBcCisJCQlLVU5JVF9JTklUX1BUUl9OT1RfRVJSX1NUUlVD VCh0ZXN0LAkJICAgICAgIFwKKwkJCQkJCSAgICAgIGFzc2VydF90eXBlLAkgICAgICAgXAorCQkJ CQkJICAgICAgI3B0ciwJCSAgICAgICBcCisJCQkJCQkgICAgICBfX3B0ciksCQkgICAgICAgXAor CQkJZm10LAkJCQkJCSAgICAgICBcCisJCQkjI19fVkFfQVJHU19fKTsJCQkJCSAgICAgICBcCit9 IHdoaWxlICgwKQorCisjZGVmaW5lIEtVTklUX1BUUl9OT1RfRVJSX09SX05VTExfQVNTRVJUSU9O KHRlc3QsIGFzc2VydF90eXBlLCBwdHIpCSAgICAgICBcCisJS1VOSVRfUFRSX05PVF9FUlJfT1Jf TlVMTF9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJICAgICAgIFwKKwkJCQkJCWFzc2VydF90eXBlLAkJ ICAgICAgIFwKKwkJCQkJCXB0ciwJCQkgICAgICAgXAorCQkJCQkJTlVMTCkKKworLyoqCisgKiBL VU5JVF9FWFBFQ1RfVFJVRSgpIC0gQ2F1c2VzIGEgdGVzdCBmYWlsdXJlIHdoZW4gdGhlIGV4cHJl c3Npb24gaXMgbm90IHRydWUuCisgKiBAdGVzdDogVGhlIHRlc3QgY29udGV4dCBvYmplY3QuCisg KiBAY29uZGl0aW9uOiBhbiBhcmJpdHJhcnkgYm9vbGVhbiBleHByZXNzaW9uLiBUaGUgdGVzdCBm YWlscyB3aGVuIHRoaXMgZG9lcworICogbm90IGV2YWx1YXRlIHRvIHRydWUuCisgKgorICogVGhp cyBhbmQgZXhwZWN0YXRpb25zIG9mIHRoZSBmb3JtIGBLVU5JVF9FWFBFQ1RfKmAgd2lsbCBjYXVz ZSB0aGUgdGVzdCBjYXNlCisgKiB0byBmYWlsIHdoZW4gdGhlIHNwZWNpZmllZCBjb25kaXRpb24g aXMgbm90IG1ldDsgaG93ZXZlciwgaXQgd2lsbCBub3QgcHJldmVudAorICogdGhlIHRlc3QgY2Fz ZSBmcm9tIGNvbnRpbnVpbmcgdG8gcnVuOyB0aGlzIGlzIG90aGVyd2lzZSBrbm93biBhcyBhbgor ICogKmV4cGVjdGF0aW9uIGZhaWx1cmUqLgorICovCisjZGVmaW5lIEtVTklUX0VYUEVDVF9UUlVF KHRlc3QsIGNvbmRpdGlvbikgXAorCUtVTklUX1RSVUVfQVNTRVJUSU9OKHRlc3QsIEtVTklUX0VY UEVDVEFUSU9OLCBjb25kaXRpb24pCisKKyNkZWZpbmUgS1VOSVRfRVhQRUNUX1RSVUVfTVNHKHRl c3QsIGNvbmRpdGlvbiwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX1RSVUVfTVNHX0FTU0VS VElPTih0ZXN0LAkJCQkJICAgICAgIFwKKwkJCQkgS1VOSVRfRVhQRUNUQVRJT04sCQkJICAgICAg IFwKKwkJCQkgY29uZGl0aW9uLAkJCQkgICAgICAgXAorCQkJCSBmbXQsCQkJCQkgICAgICAgXAor CQkJCSAjI19fVkFfQVJHU19fKQorCisvKioKKyAqIEtVTklUX0VYUEVDVF9GQUxTRSgpIC0gTWFr ZXMgYSB0ZXN0IGZhaWx1cmUgd2hlbiB0aGUgZXhwcmVzc2lvbiBpcyBub3QgZmFsc2UuCisgKiBA dGVzdDogVGhlIHRlc3QgY29udGV4dCBvYmplY3QuCisgKiBAY29uZGl0aW9uOiBhbiBhcmJpdHJh cnkgYm9vbGVhbiBleHByZXNzaW9uLiBUaGUgdGVzdCBmYWlscyB3aGVuIHRoaXMgZG9lcworICog bm90IGV2YWx1YXRlIHRvIGZhbHNlLgorICoKKyAqIFNldHMgYW4gZXhwZWN0YXRpb24gdGhhdCBA Y29uZGl0aW9uIGV2YWx1YXRlcyB0byBmYWxzZS4gU2VlCisgKiBLVU5JVF9FWFBFQ1RfVFJVRSgp IGZvciBtb3JlIGluZm9ybWF0aW9uLgorICovCisjZGVmaW5lIEtVTklUX0VYUEVDVF9GQUxTRSh0 ZXN0LCBjb25kaXRpb24pIFwKKwlLVU5JVF9GQUxTRV9BU1NFUlRJT04odGVzdCwgS1VOSVRfRVhQ RUNUQVRJT04sIGNvbmRpdGlvbikKKworI2RlZmluZSBLVU5JVF9FWFBFQ1RfRkFMU0VfTVNHKHRl c3QsIGNvbmRpdGlvbiwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX0ZBTFNFX01TR19BU1NF UlRJT04odGVzdCwJCQkJCSAgICAgICBcCisJCQkJICBLVU5JVF9FWFBFQ1RBVElPTiwJCQkgICAg ICAgXAorCQkJCSAgY29uZGl0aW9uLAkJCQkgICAgICAgXAorCQkJCSAgZm10LAkJCQkJICAgICAg IFwKKwkJCQkgICMjX19WQV9BUkdTX18pCisKKy8qKgorICogS1VOSVRfRVhQRUNUX0VRKCkgLSBT ZXRzIGFuIGV4cGVjdGF0aW9uIHRoYXQgQGxlZnQgYW5kIEByaWdodCBhcmUgZXF1YWwuCisgKiBA dGVzdDogVGhlIHRlc3QgY29udGV4dCBvYmplY3QuCisgKiBAbGVmdDogYW4gYXJiaXRyYXJ5IGV4 cHJlc3Npb24gdGhhdCBldmFsdWF0ZXMgdG8gYSBwcmltaXRpdmUgQyB0eXBlLgorICogQHJpZ2h0 OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0aGF0IGV2YWx1YXRlcyB0byBhIHByaW1pdGl2ZSBD IHR5cGUuCisgKgorICogU2V0cyBhbiBleHBlY3RhdGlvbiB0aGF0IHRoZSB2YWx1ZXMgdGhhdCBA bGVmdCBhbmQgQHJpZ2h0IGV2YWx1YXRlIHRvIGFyZQorICogZXF1YWwuIFRoaXMgaXMgc2VtYW50 aWNhbGx5IGVxdWl2YWxlbnQgdG8KKyAqIEtVTklUX0VYUEVDVF9UUlVFKEB0ZXN0LCAoQGxlZnQp ID09IChAcmlnaHQpKS4gU2VlIEtVTklUX0VYUEVDVF9UUlVFKCkgZm9yCisgKiBtb3JlIGluZm9y bWF0aW9uLgorICovCisjZGVmaW5lIEtVTklUX0VYUEVDVF9FUSh0ZXN0LCBsZWZ0LCByaWdodCkg XAorCUtVTklUX0JJTkFSWV9FUV9BU1NFUlRJT04odGVzdCwgS1VOSVRfRVhQRUNUQVRJT04sIGxl ZnQsIHJpZ2h0KQorCisjZGVmaW5lIEtVTklUX0VYUEVDVF9FUV9NU0codGVzdCwgbGVmdCwgcmln aHQsIGZtdCwgLi4uKQkJICAgICAgIFwKKwlLVU5JVF9CSU5BUllfRVFfTVNHX0FTU0VSVElPTih0 ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICAgIEtVTklUX0VYUEVDVEFUSU9OLAkJICAgICAgIFwK KwkJCQkgICAgICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCSAgICAgIHJpZ2h0LAkJCQkgICAgICAg XAorCQkJCSAgICAgIGZtdCwJCQkJICAgICAgIFwKKwkJCQkgICAgICAjI19fVkFfQVJHU19fKQor CisvKioKKyAqIEtVTklUX0VYUEVDVF9QVFJfRVEoKSAtIEV4cGVjdHMgdGhhdCBwb2ludGVycyBA bGVmdCBhbmQgQHJpZ2h0IGFyZSBlcXVhbC4KKyAqIEB0ZXN0OiBUaGUgdGVzdCBjb250ZXh0IG9i amVjdC4KKyAqIEBsZWZ0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0aGF0IGV2YWx1YXRlcyB0 byBhIHBvaW50ZXIuCisgKiBAcmlnaHQ6IGFuIGFyYml0cmFyeSBleHByZXNzaW9uIHRoYXQgZXZh bHVhdGVzIHRvIGEgcG9pbnRlci4KKyAqCisgKiBTZXRzIGFuIGV4cGVjdGF0aW9uIHRoYXQgdGhl IHZhbHVlcyB0aGF0IEBsZWZ0IGFuZCBAcmlnaHQgZXZhbHVhdGUgdG8gYXJlCisgKiBlcXVhbC4g VGhpcyBpcyBzZW1hbnRpY2FsbHkgZXF1aXZhbGVudCB0bworICogS1VOSVRfRVhQRUNUX1RSVUUo QHRlc3QsIChAbGVmdCkgPT0gKEByaWdodCkpLiBTZWUgS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IK KyAqIG1vcmUgaW5mb3JtYXRpb24uCisgKi8KKyNkZWZpbmUgS1VOSVRfRVhQRUNUX1BUUl9FUSh0 ZXN0LCBsZWZ0LCByaWdodCkJCQkJICAgICAgIFwKKwlLVU5JVF9CSU5BUllfUFRSX0VRX0FTU0VS VElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCSAgICAgIEtVTklUX0VYUEVDVEFUSU9OLAkJICAg ICAgIFwKKwkJCQkgICAgICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCSAgICAgIHJpZ2h0KQorCisj ZGVmaW5lIEtVTklUX0VYUEVDVF9QVFJfRVFfTVNHKHRlc3QsIGxlZnQsIHJpZ2h0LCBmbXQsIC4u LikJCSAgICAgICBcCisJS1VOSVRfQklOQVJZX1BUUl9FUV9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJ CSAgICAgICBcCisJCQkJCSAgS1VOSVRfRVhQRUNUQVRJT04sCQkgICAgICAgXAorCQkJCQkgIGxl ZnQsCQkJCSAgICAgICBcCisJCQkJCSAgcmlnaHQsCQkJICAgICAgIFwKKwkJCQkJICBmbXQsCQkJ CSAgICAgICBcCisJCQkJCSAgIyNfX1ZBX0FSR1NfXykKKworLyoqCisgKiBLVU5JVF9FWFBFQ1Rf TkUoKSAtIEFuIGV4cGVjdGF0aW9uIHRoYXQgQGxlZnQgYW5kIEByaWdodCBhcmUgbm90IGVxdWFs LgorICogQHRlc3Q6IFRoZSB0ZXN0IGNvbnRleHQgb2JqZWN0LgorICogQGxlZnQ6IGFuIGFyYml0 cmFyeSBleHByZXNzaW9uIHRoYXQgZXZhbHVhdGVzIHRvIGEgcHJpbWl0aXZlIEMgdHlwZS4KKyAq IEByaWdodDogYW4gYXJiaXRyYXJ5IGV4cHJlc3Npb24gdGhhdCBldmFsdWF0ZXMgdG8gYSBwcmlt aXRpdmUgQyB0eXBlLgorICoKKyAqIFNldHMgYW4gZXhwZWN0YXRpb24gdGhhdCB0aGUgdmFsdWVz IHRoYXQgQGxlZnQgYW5kIEByaWdodCBldmFsdWF0ZSB0byBhcmUgbm90CisgKiBlcXVhbC4gVGhp cyBpcyBzZW1hbnRpY2FsbHkgZXF1aXZhbGVudCB0bworICogS1VOSVRfRVhQRUNUX1RSVUUoQHRl c3QsIChAbGVmdCkgIT0gKEByaWdodCkpLiBTZWUgS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IKKyAq IG1vcmUgaW5mb3JtYXRpb24uCisgKi8KKyNkZWZpbmUgS1VOSVRfRVhQRUNUX05FKHRlc3QsIGxl ZnQsIHJpZ2h0KSBcCisJS1VOSVRfQklOQVJZX05FX0FTU0VSVElPTih0ZXN0LCBLVU5JVF9FWFBF Q1RBVElPTiwgbGVmdCwgcmlnaHQpCisKKyNkZWZpbmUgS1VOSVRfRVhQRUNUX05FX01TRyh0ZXN0 LCBsZWZ0LCByaWdodCwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9ORV9NU0df QVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgICAgS1VOSVRfRVhQRUNUQVRJT04s CQkgICAgICAgXAorCQkJCSAgICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQs CQkJCSAgICAgICBcCisJCQkJICAgICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAgICAgICMjX19W QV9BUkdTX18pCisKKy8qKgorICogS1VOSVRfRVhQRUNUX1BUUl9ORSgpIC0gRXhwZWN0cyB0aGF0 IHBvaW50ZXJzIEBsZWZ0IGFuZCBAcmlnaHQgYXJlIG5vdCBlcXVhbC4KKyAqIEB0ZXN0OiBUaGUg dGVzdCBjb250ZXh0IG9iamVjdC4KKyAqIEBsZWZ0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0 aGF0IGV2YWx1YXRlcyB0byBhIHBvaW50ZXIuCisgKiBAcmlnaHQ6IGFuIGFyYml0cmFyeSBleHBy ZXNzaW9uIHRoYXQgZXZhbHVhdGVzIHRvIGEgcG9pbnRlci4KKyAqCisgKiBTZXRzIGFuIGV4cGVj dGF0aW9uIHRoYXQgdGhlIHZhbHVlcyB0aGF0IEBsZWZ0IGFuZCBAcmlnaHQgZXZhbHVhdGUgdG8g YXJlIG5vdAorICogZXF1YWwuIFRoaXMgaXMgc2VtYW50aWNhbGx5IGVxdWl2YWxlbnQgdG8KKyAq IEtVTklUX0VYUEVDVF9UUlVFKEB0ZXN0LCAoQGxlZnQpICE9IChAcmlnaHQpKS4gU2VlIEtVTklU X0VYUEVDVF9UUlVFKCkgZm9yCisgKiBtb3JlIGluZm9ybWF0aW9uLgorICovCisjZGVmaW5lIEtV TklUX0VYUEVDVF9QVFJfTkUodGVzdCwgbGVmdCwgcmlnaHQpCQkJCSAgICAgICBcCisJS1VOSVRf QklOQVJZX1BUUl9ORV9BU1NFUlRJT04odGVzdCwJCQkJICAgICAgIFwKKwkJCQkgICAgICBLVU5J VF9FWFBFQ1RBVElPTiwJCSAgICAgICBcCisJCQkJICAgICAgbGVmdCwJCQkJICAgICAgIFwKKwkJ CQkgICAgICByaWdodCkKKworI2RlZmluZSBLVU5JVF9FWFBFQ1RfUFRSX05FX01TRyh0ZXN0LCBs ZWZ0LCByaWdodCwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9QVFJfTkVfTVNH X0FTU0VSVElPTih0ZXN0LAkJCQkgICAgICAgXAorCQkJCQkgIEtVTklUX0VYUEVDVEFUSU9OLAkJ ICAgICAgIFwKKwkJCQkJICBsZWZ0LAkJCQkgICAgICAgXAorCQkJCQkgIHJpZ2h0LAkJCSAgICAg ICBcCisJCQkJCSAgZm10LAkJCQkgICAgICAgXAorCQkJCQkgICMjX19WQV9BUkdTX18pCisKKy8q KgorICogS1VOSVRfRVhQRUNUX0xUKCkgLSBBbiBleHBlY3RhdGlvbiB0aGF0IEBsZWZ0IGlzIGxl c3MgdGhhbiBAcmlnaHQuCisgKiBAdGVzdDogVGhlIHRlc3QgY29udGV4dCBvYmplY3QuCisgKiBA bGVmdDogYW4gYXJiaXRyYXJ5IGV4cHJlc3Npb24gdGhhdCBldmFsdWF0ZXMgdG8gYSBwcmltaXRp dmUgQyB0eXBlLgorICogQHJpZ2h0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0aGF0IGV2YWx1 YXRlcyB0byBhIHByaW1pdGl2ZSBDIHR5cGUuCisgKgorICogU2V0cyBhbiBleHBlY3RhdGlvbiB0 aGF0IHRoZSB2YWx1ZSB0aGF0IEBsZWZ0IGV2YWx1YXRlcyB0byBpcyBsZXNzIHRoYW4gdGhlCisg KiB2YWx1ZSB0aGF0IEByaWdodCBldmFsdWF0ZXMgdG8uIFRoaXMgaXMgc2VtYW50aWNhbGx5IGVx dWl2YWxlbnQgdG8KKyAqIEtVTklUX0VYUEVDVF9UUlVFKEB0ZXN0LCAoQGxlZnQpIDwgKEByaWdo dCkpLiBTZWUgS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IKKyAqIG1vcmUgaW5mb3JtYXRpb24uCisg Ki8KKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0xUKHRlc3QsIGxlZnQsIHJpZ2h0KSBcCisJS1VOSVRf QklOQVJZX0xUX0FTU0VSVElPTih0ZXN0LCBLVU5JVF9FWFBFQ1RBVElPTiwgbGVmdCwgcmlnaHQp CisKKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0xUX01TRyh0ZXN0LCBsZWZ0LCByaWdodCwgZm10LCAu Li4pCQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9MVF9NU0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAg ICAgICBcCisJCQkJICAgICAgS1VOSVRfRVhQRUNUQVRJT04sCQkgICAgICAgXAorCQkJCSAgICAg IGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQsCQkJCSAgICAgICBcCisJCQkJICAg ICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAgICAgICMjX19WQV9BUkdTX18pCisKKy8qKgorICog S1VOSVRfRVhQRUNUX0xFKCkgLSBFeHBlY3RzIHRoYXQgQGxlZnQgaXMgbGVzcyB0aGFuIG9yIGVx dWFsIHRvIEByaWdodC4KKyAqIEB0ZXN0OiBUaGUgdGVzdCBjb250ZXh0IG9iamVjdC4KKyAqIEBs ZWZ0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0aGF0IGV2YWx1YXRlcyB0byBhIHByaW1pdGl2 ZSBDIHR5cGUuCisgKiBAcmlnaHQ6IGFuIGFyYml0cmFyeSBleHByZXNzaW9uIHRoYXQgZXZhbHVh dGVzIHRvIGEgcHJpbWl0aXZlIEMgdHlwZS4KKyAqCisgKiBTZXRzIGFuIGV4cGVjdGF0aW9uIHRo YXQgdGhlIHZhbHVlIHRoYXQgQGxlZnQgZXZhbHVhdGVzIHRvIGlzIGxlc3MgdGhhbiBvcgorICog ZXF1YWwgdG8gdGhlIHZhbHVlIHRoYXQgQHJpZ2h0IGV2YWx1YXRlcyB0by4gU2VtYW50aWNhbGx5 IHRoaXMgaXMgZXF1aXZhbGVudAorICogdG8gS1VOSVRfRVhQRUNUX1RSVUUoQHRlc3QsIChAbGVm dCkgPD0gKEByaWdodCkpLiBTZWUgS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IKKyAqIG1vcmUgaW5m b3JtYXRpb24uCisgKi8KKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0xFKHRlc3QsIGxlZnQsIHJpZ2h0 KSBcCisJS1VOSVRfQklOQVJZX0xFX0FTU0VSVElPTih0ZXN0LCBLVU5JVF9FWFBFQ1RBVElPTiwg bGVmdCwgcmlnaHQpCisKKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0xFX01TRyh0ZXN0LCBsZWZ0LCBy aWdodCwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9MRV9NU0dfQVNTRVJUSU9O KHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgICAgS1VOSVRfRVhQRUNUQVRJT04sCQkgICAgICAg XAorCQkJCSAgICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQsCQkJCSAgICAg ICBcCisJCQkJICAgICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAgICAgICMjX19WQV9BUkdTX18p CisKKy8qKgorICogS1VOSVRfRVhQRUNUX0dUKCkgLSBBbiBleHBlY3RhdGlvbiB0aGF0IEBsZWZ0 IGlzIGdyZWF0ZXIgdGhhbiBAcmlnaHQuCisgKiBAdGVzdDogVGhlIHRlc3QgY29udGV4dCBvYmpl Y3QuCisgKiBAbGVmdDogYW4gYXJiaXRyYXJ5IGV4cHJlc3Npb24gdGhhdCBldmFsdWF0ZXMgdG8g YSBwcmltaXRpdmUgQyB0eXBlLgorICogQHJpZ2h0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0 aGF0IGV2YWx1YXRlcyB0byBhIHByaW1pdGl2ZSBDIHR5cGUuCisgKgorICogU2V0cyBhbiBleHBl Y3RhdGlvbiB0aGF0IHRoZSB2YWx1ZSB0aGF0IEBsZWZ0IGV2YWx1YXRlcyB0byBpcyBncmVhdGVy IHRoYW4KKyAqIHRoZSB2YWx1ZSB0aGF0IEByaWdodCBldmFsdWF0ZXMgdG8uIFRoaXMgaXMgc2Vt YW50aWNhbGx5IGVxdWl2YWxlbnQgdG8KKyAqIEtVTklUX0VYUEVDVF9UUlVFKEB0ZXN0LCAoQGxl ZnQpID4gKEByaWdodCkpLiBTZWUgS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IKKyAqIG1vcmUgaW5m b3JtYXRpb24uCisgKi8KKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0dUKHRlc3QsIGxlZnQsIHJpZ2h0 KSBcCisJS1VOSVRfQklOQVJZX0dUX0FTU0VSVElPTih0ZXN0LCBLVU5JVF9FWFBFQ1RBVElPTiwg bGVmdCwgcmlnaHQpCisKKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0dUX01TRyh0ZXN0LCBsZWZ0LCBy aWdodCwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9HVF9NU0dfQVNTRVJUSU9O KHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgICAgS1VOSVRfRVhQRUNUQVRJT04sCQkgICAgICAg XAorCQkJCSAgICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQsCQkJCSAgICAg ICBcCisJCQkJICAgICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAgICAgICMjX19WQV9BUkdTX18p CisKKy8qKgorICogS1VOSVRfRVhQRUNUX0dFKCkgLSBFeHBlY3RzIHRoYXQgQGxlZnQgaXMgZ3Jl YXRlciB0aGFuIG9yIGVxdWFsIHRvIEByaWdodC4KKyAqIEB0ZXN0OiBUaGUgdGVzdCBjb250ZXh0 IG9iamVjdC4KKyAqIEBsZWZ0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0aGF0IGV2YWx1YXRl cyB0byBhIHByaW1pdGl2ZSBDIHR5cGUuCisgKiBAcmlnaHQ6IGFuIGFyYml0cmFyeSBleHByZXNz aW9uIHRoYXQgZXZhbHVhdGVzIHRvIGEgcHJpbWl0aXZlIEMgdHlwZS4KKyAqCisgKiBTZXRzIGFu IGV4cGVjdGF0aW9uIHRoYXQgdGhlIHZhbHVlIHRoYXQgQGxlZnQgZXZhbHVhdGVzIHRvIGlzIGdy ZWF0ZXIgdGhhbgorICogdGhlIHZhbHVlIHRoYXQgQHJpZ2h0IGV2YWx1YXRlcyB0by4gVGhpcyBp cyBzZW1hbnRpY2FsbHkgZXF1aXZhbGVudCB0bworICogS1VOSVRfRVhQRUNUX1RSVUUoQHRlc3Qs IChAbGVmdCkgPj0gKEByaWdodCkpLiBTZWUgS1VOSVRfRVhQRUNUX1RSVUUoKSBmb3IKKyAqIG1v cmUgaW5mb3JtYXRpb24uCisgKi8KKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0dFKHRlc3QsIGxlZnQs IHJpZ2h0KSBcCisJS1VOSVRfQklOQVJZX0dFX0FTU0VSVElPTih0ZXN0LCBLVU5JVF9FWFBFQ1RB VElPTiwgbGVmdCwgcmlnaHQpCisKKyNkZWZpbmUgS1VOSVRfRVhQRUNUX0dFX01TRyh0ZXN0LCBs ZWZ0LCByaWdodCwgZm10LCAuLi4pCQkgICAgICAgXAorCUtVTklUX0JJTkFSWV9HRV9NU0dfQVNT RVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJICAgICAgS1VOSVRfRVhQRUNUQVRJT04sCQkg ICAgICAgXAorCQkJCSAgICAgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJICAgICAgcmlnaHQsCQkJ CSAgICAgICBcCisJCQkJICAgICAgZm10LAkJCQkgICAgICAgXAorCQkJCSAgICAgICMjX19WQV9B UkdTX18pCisKKy8qKgorICogS1VOSVRfRVhQRUNUX1NUUkVRKCkgLSBFeHBlY3RzIHRoYXQgc3Ry aW5ncyBAbGVmdCBhbmQgQHJpZ2h0IGFyZSBlcXVhbC4KKyAqIEB0ZXN0OiBUaGUgdGVzdCBjb250 ZXh0IG9iamVjdC4KKyAqIEBsZWZ0OiBhbiBhcmJpdHJhcnkgZXhwcmVzc2lvbiB0aGF0IGV2YWx1 YXRlcyB0byBhIG51bGwgdGVybWluYXRlZCBzdHJpbmcuCisgKiBAcmlnaHQ6IGFuIGFyYml0cmFy eSBleHByZXNzaW9uIHRoYXQgZXZhbHVhdGVzIHRvIGEgbnVsbCB0ZXJtaW5hdGVkIHN0cmluZy4K KyAqCisgKiBTZXRzIGFuIGV4cGVjdGF0aW9uIHRoYXQgdGhlIHZhbHVlcyB0aGF0IEBsZWZ0IGFu ZCBAcmlnaHQgZXZhbHVhdGUgdG8gYXJlCisgKiBlcXVhbC4gVGhpcyBpcyBzZW1hbnRpY2FsbHkg ZXF1aXZhbGVudCB0bworICogS1VOSVRfRVhQRUNUX1RSVUUoQHRlc3QsICFzdHJjbXAoKEBsZWZ0 KSwgKEByaWdodCkpKS4gU2VlIEtVTklUX0VYUEVDVF9UUlVFKCkKKyAqIGZvciBtb3JlIGluZm9y bWF0aW9uLgorICovCisjZGVmaW5lIEtVTklUX0VYUEVDVF9TVFJFUSh0ZXN0LCBsZWZ0LCByaWdo dCkgXAorCUtVTklUX0JJTkFSWV9TVFJfRVFfQVNTRVJUSU9OKHRlc3QsIEtVTklUX0VYUEVDVEFU SU9OLCBsZWZ0LCByaWdodCkKKworI2RlZmluZSBLVU5JVF9FWFBFQ1RfU1RSRVFfTVNHKHRlc3Qs IGxlZnQsIHJpZ2h0LCBmbXQsIC4uLikJCSAgICAgICBcCisJS1VOSVRfQklOQVJZX1NUUl9FUV9N U0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJCSAgS1VOSVRfRVhQRUNUQVRJT04s CQkgICAgICAgXAorCQkJCQkgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJCSAgcmlnaHQsCQkJICAg ICAgIFwKKwkJCQkJICBmbXQsCQkJCSAgICAgICBcCisJCQkJCSAgIyNfX1ZBX0FSR1NfXykKKwor LyoqCisgKiBLVU5JVF9FWFBFQ1RfU1RSTkVRKCkgLSBFeHBlY3RzIHRoYXQgc3RyaW5ncyBAbGVm dCBhbmQgQHJpZ2h0IGFyZSBub3QgZXF1YWwuCisgKiBAdGVzdDogVGhlIHRlc3QgY29udGV4dCBv YmplY3QuCisgKiBAbGVmdDogYW4gYXJiaXRyYXJ5IGV4cHJlc3Npb24gdGhhdCBldmFsdWF0ZXMg dG8gYSBudWxsIHRlcm1pbmF0ZWQgc3RyaW5nLgorICogQHJpZ2h0OiBhbiBhcmJpdHJhcnkgZXhw cmVzc2lvbiB0aGF0IGV2YWx1YXRlcyB0byBhIG51bGwgdGVybWluYXRlZCBzdHJpbmcuCisgKgor ICogU2V0cyBhbiBleHBlY3RhdGlvbiB0aGF0IHRoZSB2YWx1ZXMgdGhhdCBAbGVmdCBhbmQgQHJp Z2h0IGV2YWx1YXRlIHRvIGFyZQorICogbm90IGVxdWFsLiBUaGlzIGlzIHNlbWFudGljYWxseSBl cXVpdmFsZW50IHRvCisgKiBLVU5JVF9FWFBFQ1RfVFJVRShAdGVzdCwgc3RyY21wKChAbGVmdCks IChAcmlnaHQpKSkuIFNlZSBLVU5JVF9FWFBFQ1RfVFJVRSgpCisgKiBmb3IgbW9yZSBpbmZvcm1h dGlvbi4KKyAqLworI2RlZmluZSBLVU5JVF9FWFBFQ1RfU1RSTkVRKHRlc3QsIGxlZnQsIHJpZ2h0 KSBcCisJS1VOSVRfQklOQVJZX1NUUl9ORV9BU1NFUlRJT04odGVzdCwgS1VOSVRfRVhQRUNUQVRJ T04sIGxlZnQsIHJpZ2h0KQorCisjZGVmaW5lIEtVTklUX0VYUEVDVF9TVFJORVFfTVNHKHRlc3Qs IGxlZnQsIHJpZ2h0LCBmbXQsIC4uLikJCSAgICAgICBcCisJS1VOSVRfQklOQVJZX1NUUl9ORV9N U0dfQVNTRVJUSU9OKHRlc3QsCQkJCSAgICAgICBcCisJCQkJCSAgS1VOSVRfRVhQRUNUQVRJT04s CQkgICAgICAgXAorCQkJCQkgIGxlZnQsCQkJCSAgICAgICBcCisJCQkJCSAgcmlnaHQsCQkJICAg ICAgIFwKKwkJCQkJICBmbXQsCQkJCSAgICAgICBcCisJCQkJCSAgIyNfX1ZBX0FSR1NfXykKKwor LyoqCisgKiBLVU5JVF9FWFBFQ1RfTk9UX0VSUl9PUl9OVUxMKCkgLSBFeHBlY3RzIHRoYXQgQHB0 ciBpcyBub3QgbnVsbCBhbmQgbm90IGVyci4KKyAqIEB0ZXN0OiBUaGUgdGVzdCBjb250ZXh0IG9i amVjdC4KKyAqIEBwdHI6IGFuIGFyYml0cmFyeSBwb2ludGVyLgorICoKKyAqIFNldHMgYW4gZXhw ZWN0YXRpb24gdGhhdCB0aGUgdmFsdWUgdGhhdCBAcHRyIGV2YWx1YXRlcyB0byBpcyBub3QgbnVs bCBhbmQgbm90CisgKiBhbiBlcnJubyBzdG9yZWQgaW4gYSBwb2ludGVyLiBUaGlzIGlzIHNlbWFu dGljYWxseSBlcXVpdmFsZW50IHRvCisgKiBLVU5JVF9FWFBFQ1RfVFJVRShAdGVzdCwgIUlTX0VS Ul9PUl9OVUxMKEBwdHIpKS4gU2VlIEtVTklUX0VYUEVDVF9UUlVFKCkgZm9yCisgKiBtb3JlIGlu Zm9ybWF0aW9uLgorICovCisjZGVmaW5lIEtVTklUX0VYUEVDVF9OT1RfRVJSX09SX05VTEwodGVz dCwgcHRyKSBcCisJS1VOSVRfUFRSX05PVF9FUlJfT1JfTlVMTF9BU1NFUlRJT04odGVzdCwgS1VO SVRfRVhQRUNUQVRJT04sIHB0cikKKworI2RlZmluZSBLVU5JVF9FWFBFQ1RfTk9UX0VSUl9PUl9O VUxMX01TRyh0ZXN0LCBwdHIsIGZtdCwgLi4uKQkJICAgICAgIFwKKwlLVU5JVF9QVFJfTk9UX0VS Ul9PUl9OVUxMX01TR19BU1NFUlRJT04odGVzdCwJCQkgICAgICAgXAorCQkJCQkJS1VOSVRfRVhQ RUNUQVRJT04sCSAgICAgICBcCisJCQkJCQlwdHIsCQkJICAgICAgIFwKKwkJCQkJCWZtdCwJCQkg ICAgICAgXAorCQkJCQkJIyNfX1ZBX0FSR1NfXykKKwogI2VuZGlmIC8qIF9LVU5JVF9URVNUX0gg Ki8KZGlmZiAtLWdpdCBhL2xpYi9rdW5pdC90ZXN0LmMgYi9saWIva3VuaXQvdGVzdC5jCmluZGV4 IDY4YjEwMzdhYjc0ZC4uM2NiY2ViMzRiM2IzIDEwMDY0NAotLS0gYS9saWIva3VuaXQvdGVzdC5j CisrKyBiL2xpYi9rdW5pdC90ZXN0LmMKQEAgLTEyMCw2ICsxMjAsNjggQEAgc3RhdGljIHZvaWQg a3VuaXRfcHJpbnRfdGVzdF9jYXNlX29rX25vdF9vayhzdHJ1Y3Qga3VuaXRfY2FzZSAqdGVzdF9j YXNlLAogCQkJICAgICAgdGVzdF9jYXNlLT5uYW1lKTsKIH0KIAorc3RhdGljIHZvaWQga3VuaXRf cHJpbnRfc3RyaW5nX3N0cmVhbShzdHJ1Y3Qga3VuaXQgKnRlc3QsCisJCQkJICAgICAgc3RydWN0 IHN0cmluZ19zdHJlYW0gKnN0cmVhbSkKK3sKKwlzdHJ1Y3Qgc3RyaW5nX3N0cmVhbV9mcmFnbWVu dCAqZnJhZ21lbnQ7CisJY2hhciAqYnVmOworCisJYnVmID0gc3RyaW5nX3N0cmVhbV9nZXRfc3Ry aW5nKHN0cmVhbSk7CisJaWYgKCFidWYpIHsKKwkJa3VuaXRfZXJyKHRlc3QsCisJCQkgICJDb3Vs ZCBub3QgYWxsb2NhdGUgYnVmZmVyLCBkdW1waW5nIHN0cmVhbTpcbiIpOworCQlsaXN0X2Zvcl9l YWNoX2VudHJ5KGZyYWdtZW50LCAmc3RyZWFtLT5mcmFnbWVudHMsIG5vZGUpIHsKKwkJCWt1bml0 X2Vycih0ZXN0LCBmcmFnbWVudC0+ZnJhZ21lbnQpOworCQl9CisJCWt1bml0X2Vycih0ZXN0LCAi XG4iKTsKKwl9IGVsc2UgeworCQlrdW5pdF9lcnIodGVzdCwgYnVmKTsKKwkJa3VuaXRfa2ZyZWUo dGVzdCwgYnVmKTsKKwl9Cit9CisKK3N0YXRpYyB2b2lkIGt1bml0X2ZhaWwoc3RydWN0IGt1bml0 ICp0ZXN0LCBzdHJ1Y3Qga3VuaXRfYXNzZXJ0ICphc3NlcnQpCit7CisJc3RydWN0IHN0cmluZ19z dHJlYW0gKnN0cmVhbTsKKworCWt1bml0X3NldF9mYWlsdXJlKHRlc3QpOworCisJc3RyZWFtID0g YWxsb2Nfc3RyaW5nX3N0cmVhbSh0ZXN0LCBHRlBfS0VSTkVMKTsKKwlpZiAoIXN0cmVhbSkgewor CQlXQVJOKHRydWUsCisJCSAgICAgIkNvdWxkIG5vdCBhbGxvY2F0ZSBzdHJlYW0gdG8gcHJpbnQg ZmFpbGVkIGFzc2VydGlvbiBpbiAlczolZFxuIiwKKwkJICAgICBhc3NlcnQtPmZpbGUsCisJCSAg ICAgYXNzZXJ0LT5saW5lKTsKKwkJcmV0dXJuOworCX0KKworCWFzc2VydC0+Zm9ybWF0KGFzc2Vy dCwgc3RyZWFtKTsKKworCWt1bml0X3ByaW50X3N0cmluZ19zdHJlYW0odGVzdCwgc3RyZWFtKTsK KworCVdBUk5fT04oc3RyaW5nX3N0cmVhbV9kZXN0cm95KHN0cmVhbSkpOworfQorCit2b2lkIGt1 bml0X2RvX2Fzc2VydGlvbihzdHJ1Y3Qga3VuaXQgKnRlc3QsCisJCQlzdHJ1Y3Qga3VuaXRfYXNz ZXJ0ICphc3NlcnQsCisJCQlib29sIHBhc3MsCisJCQljb25zdCBjaGFyICpmbXQsIC4uLikKK3sK Kwl2YV9saXN0IGFyZ3M7CisKKwlpZiAocGFzcykKKwkJcmV0dXJuOworCisJdmFfc3RhcnQoYXJn cywgZm10KTsKKworCWFzc2VydC0+bWVzc2FnZS5mbXQgPSBmbXQ7CisJYXNzZXJ0LT5tZXNzYWdl LnZhID0gJmFyZ3M7CisKKwlrdW5pdF9mYWlsKHRlc3QsIGFzc2VydCk7CisKKwl2YV9lbmQoYXJn cyk7Cit9CisKIHZvaWQga3VuaXRfaW5pdF90ZXN0KHN0cnVjdCBrdW5pdCAqdGVzdCwgY29uc3Qg Y2hhciAqbmFtZSkKIHsKIAlzcGluX2xvY2tfaW5pdCgmdGVzdC0+bG9jayk7Ci0tIAoyLjIzLjAu MzUxLmdjNDMxNzAzMmU2LWdvb2cKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVk ZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZv L2RyaS1kZXZlbA== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-yb1-xb49.google.com ([2607:f8b0:4864:20::b49]) by bombadil.infradead.org with esmtps (Exim 4.92.2 #3 (Red Hat Linux)) id 1iBSBw-0003Gz-CW for linux-um@lists.infradead.org; Fri, 20 Sep 2019 23:19:59 +0000 Received: by mail-yb1-xb49.google.com with SMTP id f15so395524ybk.8 for ; Fri, 20 Sep 2019 16:19:53 -0700 (PDT) Date: Fri, 20 Sep 2019 16:19:09 -0700 In-Reply-To: <20190920231923.141900-1-brendanhiggins@google.com> Message-Id: <20190920231923.141900-6-brendanhiggins@google.com> Mime-Version: 1.0 References: <20190920231923.141900-1-brendanhiggins@google.com> Subject: [PATCH v16 05/19] kunit: test: add the concept of expectations From: Brendan Higgins List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Sender: "linux-um" Errors-To: linux-um-bounces+geert=linux-m68k.org@lists.infradead.org To: frowand.list@gmail.com, gregkh@linuxfoundation.org, jpoimboe@redhat.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, peterz@infradead.org, robh@kernel.org, sboyd@kernel.org, shuah@kernel.org, tytso@mit.edu, yamada.masahiro@socionext.com Cc: pmladek@suse.com, linux-doc@vger.kernel.org, amir73il@gmail.com, Brendan Higgins , dri-devel@lists.freedesktop.org, Alexander.Levin@microsoft.com, linux-kselftest@vger.kernel.org, linux-nvdimm@lists.01.org, khilman@baylibre.com, knut.omang@oracle.com, wfg@linux.intel.com, joel@jms.id.au, rientjes@google.com, jdike@addtoit.com, dan.carpenter@oracle.com, devicetree@vger.kernel.org, linux-kbuild@vger.kernel.org, Tim.Bird@sony.com, linux-um@lists.infradead.org, rostedt@goodmis.org, julia.lawall@lip6.fr, kunit-dev@googlegroups.com, richard@nod.at, torvalds@linux-foundation.org, rdunlap@infradead.org, linux-kernel@vger.kernel.org, daniel@ffwll.ch, mpe@ellerman.id.au, linux-fsdevel@vger.kernel.org, logang@deltatee.com Add support for expectations, which allow properties to be specified and then verified in tests. Signed-off-by: Brendan Higgins Reviewed-by: Greg Kroah-Hartman Reviewed-by: Logan Gunthorpe Reviewed-by: Stephen Boyd --- include/kunit/test.h | 836 +++++++++++++++++++++++++++++++++++++++++++ lib/kunit/test.c | 62 ++++ 2 files changed, 898 insertions(+) diff --git a/include/kunit/test.h b/include/kunit/test.h index 6781c756f11b..30a62de16bc9 100644 --- a/include/kunit/test.h +++ b/include/kunit/test.h @@ -9,6 +9,8 @@ #ifndef _KUNIT_TEST_H #define _KUNIT_TEST_H +#include +#include #include #include @@ -372,4 +374,838 @@ void __printf(3, 4) kunit_printk(const char *level, #define kunit_err(test, fmt, ...) \ kunit_printk(KERN_ERR, test, fmt, ##__VA_ARGS__) +/** + * KUNIT_SUCCEED() - A no-op expectation. Only exists for code clarity. + * @test: The test context object. + * + * The opposite of KUNIT_FAIL(), it is an expectation that cannot fail. In other + * words, it does nothing and only exists for code clarity. See + * KUNIT_EXPECT_TRUE() for more information. + */ +#define KUNIT_SUCCEED(test) do {} while (0) + +void kunit_do_assertion(struct kunit *test, + struct kunit_assert *assert, + bool pass, + const char *fmt, ...); + +#define KUNIT_ASSERTION(test, pass, assert_class, INITIALIZER, fmt, ...) do { \ + struct assert_class __assertion = INITIALIZER; \ + kunit_do_assertion(test, \ + &__assertion.assert, \ + pass, \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + + +#define KUNIT_FAIL_ASSERTION(test, assert_type, fmt, ...) \ + KUNIT_ASSERTION(test, \ + false, \ + kunit_fail_assert, \ + KUNIT_INIT_FAIL_ASSERT_STRUCT(test, assert_type), \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_FAIL() - Always causes a test to fail when evaluated. + * @test: The test context object. + * @fmt: an informational message to be printed when the assertion is made. + * @...: string format arguments. + * + * The opposite of KUNIT_SUCCEED(), it is an expectation that always fails. In + * other words, it always results in a failed expectation, and consequently + * always causes the test case to fail when evaluated. See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_FAIL(test, fmt, ...) \ + KUNIT_FAIL_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + expected_true, \ + fmt, \ + ...) \ + KUNIT_ASSERTION(test, \ + !!(condition) == !!expected_true, \ + kunit_unary_assert, \ + KUNIT_INIT_UNARY_ASSERT_STRUCT(test, \ + assert_type, \ + #condition, \ + expected_true), \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ + KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + true, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_TRUE_ASSERTION(test, assert_type, condition) \ + KUNIT_TRUE_MSG_ASSERTION(test, assert_type, condition, NULL) + +#define KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, fmt, ...) \ + KUNIT_UNARY_ASSERTION(test, \ + assert_type, \ + condition, \ + false, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_FALSE_ASSERTION(test, assert_type, condition) \ + KUNIT_FALSE_MSG_ASSERTION(test, assert_type, condition, NULL) + +/* + * A factory macro for defining the assertions and expectations for the basic + * comparisons defined for the built in types. + * + * Unfortunately, there is no common type that all types can be promoted to for + * which all the binary operators behave the same way as for the actual types + * (for example, there is no type that long long and unsigned long long can + * both be cast to where the comparison result is preserved for all values). So + * the best we can do is do the comparison in the original types and then coerce + * everything to long long for printing; this way, the comparison behaves + * correctly and the printed out value usually makes sense without + * interpretation, but can always be interpreted to figure out the actual + * value. + */ +#define KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + op, \ + right, \ + fmt, \ + ...) \ +do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + ((void)__typecheck(__left, __right)); \ + \ + KUNIT_ASSERTION(test, \ + __left op __right, \ + assert_class, \ + ASSERT_CLASS_INIT(test, \ + assert_type, \ + #op, \ + #left, \ + __left, \ + #right, \ + __right), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, ==, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_NE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, !=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_LT_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, <, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_LE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, <=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_GT_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, >, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BASE_GE_MSG_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_BINARY_ASSERTION(test, \ + assert_class, \ + ASSERT_CLASS_INIT, \ + assert_type, \ + left, >=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_EQ_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_EQ_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_NE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_NE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_NE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_LT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_LT_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_LT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_LT_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_LT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_LT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_LE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_LE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_LE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_LE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_LE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_LE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_GT_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_GT_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_GT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_GT_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_GT_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_GT_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_GE_MSG_ASSERTION(test, assert_type, left, right, fmt, ...)\ + KUNIT_BASE_GE_MSG_ASSERTION(test, \ + kunit_binary_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_GE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BASE_GE_MSG_ASSERTION(test, \ + kunit_binary_ptr_assert, \ + KUNIT_INIT_BINARY_PTR_ASSERT_STRUCT, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_PTR_GE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_PTR_GE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, \ + op, \ + right, \ + fmt, \ + ...) \ +do { \ + typeof(left) __left = (left); \ + typeof(right) __right = (right); \ + \ + KUNIT_ASSERTION(test, \ + strcmp(__left, __right) op 0, \ + kunit_binary_str_assert, \ + KUNIT_INIT_BINARY_ASSERT_STRUCT(test, \ + assert_type, \ + #op, \ + #left, \ + __left, \ + #right, \ + __right), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, ==, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_STR_EQ_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + fmt, \ + ...) \ + KUNIT_BINARY_STR_ASSERTION(test, \ + assert_type, \ + left, !=, right, \ + fmt, \ + ##__VA_ARGS__) + +#define KUNIT_BINARY_STR_NE_ASSERTION(test, assert_type, left, right) \ + KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + assert_type, \ + left, \ + right, \ + NULL) + +#define KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + assert_type, \ + ptr, \ + fmt, \ + ...) \ +do { \ + typeof(ptr) __ptr = (ptr); \ + \ + KUNIT_ASSERTION(test, \ + !IS_ERR_OR_NULL(__ptr), \ + kunit_ptr_not_err_assert, \ + KUNIT_INIT_PTR_NOT_ERR_STRUCT(test, \ + assert_type, \ + #ptr, \ + __ptr), \ + fmt, \ + ##__VA_ARGS__); \ +} while (0) + +#define KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, assert_type, ptr) \ + KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + assert_type, \ + ptr, \ + NULL) + +/** + * KUNIT_EXPECT_TRUE() - Causes a test failure when the expression is not true. + * @test: The test context object. + * @condition: an arbitrary boolean expression. The test fails when this does + * not evaluate to true. + * + * This and expectations of the form `KUNIT_EXPECT_*` will cause the test case + * to fail when the specified condition is not met; however, it will not prevent + * the test case from continuing to run; this is otherwise known as an + * *expectation failure*. + */ +#define KUNIT_EXPECT_TRUE(test, condition) \ + KUNIT_TRUE_ASSERTION(test, KUNIT_EXPECTATION, condition) + +#define KUNIT_EXPECT_TRUE_MSG(test, condition, fmt, ...) \ + KUNIT_TRUE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + condition, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_FALSE() - Makes a test failure when the expression is not false. + * @test: The test context object. + * @condition: an arbitrary boolean expression. The test fails when this does + * not evaluate to false. + * + * Sets an expectation that @condition evaluates to false. See + * KUNIT_EXPECT_TRUE() for more information. + */ +#define KUNIT_EXPECT_FALSE(test, condition) \ + KUNIT_FALSE_ASSERTION(test, KUNIT_EXPECTATION, condition) + +#define KUNIT_EXPECT_FALSE_MSG(test, condition, fmt, ...) \ + KUNIT_FALSE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + condition, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_EQ() - Sets an expectation that @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_EQ(test, left, right) \ + KUNIT_BINARY_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_EQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_PTR_EQ() - Expects that pointers @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a pointer. + * @right: an arbitrary expression that evaluates to a pointer. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) == (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_PTR_EQ(test, left, right) \ + KUNIT_BINARY_PTR_EQ_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right) + +#define KUNIT_EXPECT_PTR_EQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_PTR_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_NE() - An expectation that @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the values that @left and @right evaluate to are not + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_NE(test, left, right) \ + KUNIT_BINARY_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_NE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_PTR_NE() - Expects that pointers @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a pointer. + * @right: an arbitrary expression that evaluates to a pointer. + * + * Sets an expectation that the values that @left and @right evaluate to are not + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) != (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_PTR_NE(test, left, right) \ + KUNIT_BINARY_PTR_NE_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right) + +#define KUNIT_EXPECT_PTR_NE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_PTR_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_LT() - An expectation that @left is less than @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is less than the + * value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) < (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_LT(test, left, right) \ + KUNIT_BINARY_LT_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_LT_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_LT_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_LE() - Expects that @left is less than or equal to @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is less than or + * equal to the value that @right evaluates to. Semantically this is equivalent + * to KUNIT_EXPECT_TRUE(@test, (@left) <= (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_LE(test, left, right) \ + KUNIT_BINARY_LE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_LE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_LE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_GT() - An expectation that @left is greater than @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is greater than + * the value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) > (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_GT(test, left, right) \ + KUNIT_BINARY_GT_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_GT_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_GT_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_GE() - Expects that @left is greater than or equal to @right. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a primitive C type. + * @right: an arbitrary expression that evaluates to a primitive C type. + * + * Sets an expectation that the value that @left evaluates to is greater than + * the value that @right evaluates to. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, (@left) >= (@right)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_GE(test, left, right) \ + KUNIT_BINARY_GE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_GE_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_GE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_STREQ() - Expects that strings @left and @right are equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a null terminated string. + * @right: an arbitrary expression that evaluates to a null terminated string. + * + * Sets an expectation that the values that @left and @right evaluate to are + * equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_EXPECT_STREQ(test, left, right) \ + KUNIT_BINARY_STR_EQ_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_STREQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_STR_EQ_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_STRNEQ() - Expects that strings @left and @right are not equal. + * @test: The test context object. + * @left: an arbitrary expression that evaluates to a null terminated string. + * @right: an arbitrary expression that evaluates to a null terminated string. + * + * Sets an expectation that the values that @left and @right evaluate to are + * not equal. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, strcmp((@left), (@right))). See KUNIT_EXPECT_TRUE() + * for more information. + */ +#define KUNIT_EXPECT_STRNEQ(test, left, right) \ + KUNIT_BINARY_STR_NE_ASSERTION(test, KUNIT_EXPECTATION, left, right) + +#define KUNIT_EXPECT_STRNEQ_MSG(test, left, right, fmt, ...) \ + KUNIT_BINARY_STR_NE_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + left, \ + right, \ + fmt, \ + ##__VA_ARGS__) + +/** + * KUNIT_EXPECT_NOT_ERR_OR_NULL() - Expects that @ptr is not null and not err. + * @test: The test context object. + * @ptr: an arbitrary pointer. + * + * Sets an expectation that the value that @ptr evaluates to is not null and not + * an errno stored in a pointer. This is semantically equivalent to + * KUNIT_EXPECT_TRUE(@test, !IS_ERR_OR_NULL(@ptr)). See KUNIT_EXPECT_TRUE() for + * more information. + */ +#define KUNIT_EXPECT_NOT_ERR_OR_NULL(test, ptr) \ + KUNIT_PTR_NOT_ERR_OR_NULL_ASSERTION(test, KUNIT_EXPECTATION, ptr) + +#define KUNIT_EXPECT_NOT_ERR_OR_NULL_MSG(test, ptr, fmt, ...) \ + KUNIT_PTR_NOT_ERR_OR_NULL_MSG_ASSERTION(test, \ + KUNIT_EXPECTATION, \ + ptr, \ + fmt, \ + ##__VA_ARGS__) + #endif /* _KUNIT_TEST_H */ diff --git a/lib/kunit/test.c b/lib/kunit/test.c index 68b1037ab74d..3cbceb34b3b3 100644 --- a/lib/kunit/test.c +++ b/lib/kunit/test.c @@ -120,6 +120,68 @@ static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case, test_case->name); } +static void kunit_print_string_stream(struct kunit *test, + struct string_stream *stream) +{ + struct string_stream_fragment *fragment; + char *buf; + + buf = string_stream_get_string(stream); + if (!buf) { + kunit_err(test, + "Could not allocate buffer, dumping stream:\n"); + list_for_each_entry(fragment, &stream->fragments, node) { + kunit_err(test, fragment->fragment); + } + kunit_err(test, "\n"); + } else { + kunit_err(test, buf); + kunit_kfree(test, buf); + } +} + +static void kunit_fail(struct kunit *test, struct kunit_assert *assert) +{ + struct string_stream *stream; + + kunit_set_failure(test); + + stream = alloc_string_stream(test, GFP_KERNEL); + if (!stream) { + WARN(true, + "Could not allocate stream to print failed assertion in %s:%d\n", + assert->file, + assert->line); + return; + } + + assert->format(assert, stream); + + kunit_print_string_stream(test, stream); + + WARN_ON(string_stream_destroy(stream)); +} + +void kunit_do_assertion(struct kunit *test, + struct kunit_assert *assert, + bool pass, + const char *fmt, ...) +{ + va_list args; + + if (pass) + return; + + va_start(args, fmt); + + assert->message.fmt = fmt; + assert->message.va = &args; + + kunit_fail(test, assert); + + va_end(args); +} + void kunit_init_test(struct kunit *test, const char *name) { spin_lock_init(&test->lock); -- 2.23.0.351.gc4317032e6-goog _______________________________________________ linux-um mailing list linux-um@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-um