From mboxrd@z Thu Jan 1 00:00:00 1970 From: Brendan Higgins Subject: [PATCH v1 11/17] kunit: test: add test managed resource tests Date: Thu, 4 Apr 2019 15:06:46 -0700 Message-ID: <20190404220652.19765-12-brendanhiggins@google.com> References: <20190404220652.19765-1-brendanhiggins@google.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190404220652.19765-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: corbet@lwn.net, frowand.list@gmail.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, robh@kernel.org, shuah@kernel.org, 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, jdike@addtoit.com, dan.carpenter@oracle.com, devicetree@vger.kernel.org, linux-kbuild@vger.kernel.org, Tim.Bird@sony.com, Avinash Kondareddy , linux-um@lists.infradead.org, rostedt@goodmis.org, julia.lawall@lip6.fr, dan.j.williams@intel.com, kunit-dev@googlegroups.com, richard@nod.at, gregkh@linuxfoundation.org, linux-kernel@vger.kernel.org, mpe@ellerman.id.au, linux-fsdevel@vger.kernel.org List-Id: linux-nvdimm@lists.01.org RnJvbTogQXZpbmFzaCBLb25kYXJlZGR5IDxha25kcjQxQGdtYWlsLmNvbT4KClRlc3RzIGhvdyB0 ZXN0cyBpbnRlcmFjdCB3aXRoIHRlc3QgbWFuYWdlZCByZXNvdXJjZXMgaW4gdGhlaXIgbGlmZXRp bWUuCgpTaWduZWQtb2ZmLWJ5OiBBdmluYXNoIEtvbmRhcmVkZHkgPGFrbmRyNDFAZ21haWwuY29t PgpTaWduZWQtb2ZmLWJ5OiBCcmVuZGFuIEhpZ2dpbnMgPGJyZW5kYW5oaWdnaW5zQGdvb2dsZS5j b20+Ci0tLQoga3VuaXQvdGVzdC10ZXN0LmMgfCAxMjIgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKwogMSBmaWxlIGNoYW5nZWQsIDEyMiBpbnNlcnRpb25zKCsp CgpkaWZmIC0tZ2l0IGEva3VuaXQvdGVzdC10ZXN0LmMgYi9rdW5pdC90ZXN0LXRlc3QuYwppbmRl eCA0YmQ3YTM0ZDBhNmNiLi41NGFkZDhjYTQxOGEwIDEwMDY0NAotLS0gYS9rdW5pdC90ZXN0LXRl c3QuYworKysgYi9rdW5pdC90ZXN0LXRlc3QuYwpAQCAtMTM1LDMgKzEzNSwxMjUgQEAgc3RhdGlj IHN0cnVjdCBrdW5pdF9tb2R1bGUga3VuaXRfdHJ5X2NhdGNoX3Rlc3RfbW9kdWxlID0gewogCS50 ZXN0X2Nhc2VzID0ga3VuaXRfdHJ5X2NhdGNoX3Rlc3RfY2FzZXMsCiB9OwogbW9kdWxlX3Rlc3Qo a3VuaXRfdHJ5X2NhdGNoX3Rlc3RfbW9kdWxlKTsKKworLyoKKyAqIENvbnRleHQgZm9yIHRlc3Rp bmcgdGVzdCBtYW5hZ2VkIHJlc291cmNlcworICogaXNfcmVzb3VyY2VfaW5pdGlhbGl6ZWQgaXMg dXNlZCB0byB0ZXN0IGFyYml0cmFyeSByZXNvdXJjZXMKKyAqLworc3RydWN0IGt1bml0X3Rlc3Rf cmVzb3VyY2VfY29udGV4dCB7CisJc3RydWN0IGt1bml0IHRlc3Q7CisJYm9vbCBpc19yZXNvdXJj ZV9pbml0aWFsaXplZDsKK307CisKK3N0YXRpYyBpbnQgZmFrZV9yZXNvdXJjZV9pbml0KHN0cnVj dCBrdW5pdF9yZXNvdXJjZSAqcmVzLCB2b2lkICpjb250ZXh0KQoreworCXN0cnVjdCBrdW5pdF90 ZXN0X3Jlc291cmNlX2NvbnRleHQgKmN0eCA9IGNvbnRleHQ7CisKKwlyZXMtPmFsbG9jYXRpb24g PSAmY3R4LT5pc19yZXNvdXJjZV9pbml0aWFsaXplZDsKKwljdHgtPmlzX3Jlc291cmNlX2luaXRp YWxpemVkID0gdHJ1ZTsKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQgZmFrZV9yZXNvdXJj ZV9mcmVlKHN0cnVjdCBrdW5pdF9yZXNvdXJjZSAqcmVzKQoreworCWJvb2wgKmlzX3Jlc291cmNl X2luaXRpYWxpemVkID0gcmVzLT5hbGxvY2F0aW9uOworCisJKmlzX3Jlc291cmNlX2luaXRpYWxp emVkID0gZmFsc2U7Cit9CisKK3N0YXRpYyB2b2lkIGt1bml0X3Jlc291cmNlX3Rlc3RfaW5pdF9y ZXNvdXJjZXMoc3RydWN0IGt1bml0ICp0ZXN0KQoreworCXN0cnVjdCBrdW5pdF90ZXN0X3Jlc291 cmNlX2NvbnRleHQgKmN0eCA9IHRlc3QtPnByaXY7CisKKwlrdW5pdF9pbml0X3Rlc3QoJmN0eC0+ dGVzdCwgInRlc3RpbmdfdGVzdF9pbml0X3Rlc3QiKTsKKworCUtVTklUX0VYUEVDVF9UUlVFKHRl c3QsIGxpc3RfZW1wdHkoJmN0eC0+dGVzdC5yZXNvdXJjZXMpKTsKK30KKworc3RhdGljIHZvaWQg a3VuaXRfcmVzb3VyY2VfdGVzdF9hbGxvY19yZXNvdXJjZShzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7 CisJc3RydWN0IGt1bml0X3Rlc3RfcmVzb3VyY2VfY29udGV4dCAqY3R4ID0gdGVzdC0+cHJpdjsK KwlzdHJ1Y3Qga3VuaXRfcmVzb3VyY2UgKnJlczsKKwlrdW5pdF9yZXNvdXJjZV9mcmVlX3QgZnJl ZSA9IGZha2VfcmVzb3VyY2VfZnJlZTsKKworCXJlcyA9IGt1bml0X2FsbG9jX3Jlc291cmNlKCZj dHgtPnRlc3QsCisJCQkJICAgZmFrZV9yZXNvdXJjZV9pbml0LAorCQkJCSAgIGZha2VfcmVzb3Vy Y2VfZnJlZSwKKwkJCQkgICBjdHgpOworCisJS1VOSVRfQVNTRVJUX05PVF9FUlJfT1JfTlVMTCh0 ZXN0LCByZXMpOworCUtVTklUX0VYUEVDVF9FUSh0ZXN0LCAmY3R4LT5pc19yZXNvdXJjZV9pbml0 aWFsaXplZCwgcmVzLT5hbGxvY2F0aW9uKTsKKwlLVU5JVF9FWFBFQ1RfVFJVRSh0ZXN0LCBsaXN0 X2lzX2xhc3QoJnJlcy0+bm9kZSwgJmN0eC0+dGVzdC5yZXNvdXJjZXMpKTsKKwlLVU5JVF9FWFBF Q1RfRVEodGVzdCwgZnJlZSwgcmVzLT5mcmVlKTsKK30KKworc3RhdGljIHZvaWQga3VuaXRfcmVz b3VyY2VfdGVzdF9mcmVlX3Jlc291cmNlKHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwlzdHJ1Y3Qg a3VuaXRfdGVzdF9yZXNvdXJjZV9jb250ZXh0ICpjdHggPSB0ZXN0LT5wcml2OworCXN0cnVjdCBr dW5pdF9yZXNvdXJjZSAqcmVzID0ga3VuaXRfYWxsb2NfcmVzb3VyY2UoJmN0eC0+dGVzdCwKKwkJ CQkJCQkgIGZha2VfcmVzb3VyY2VfaW5pdCwKKwkJCQkJCQkgIGZha2VfcmVzb3VyY2VfZnJlZSwK KwkJCQkJCQkgIGN0eCk7CisKKwlrdW5pdF9mcmVlX3Jlc291cmNlKCZjdHgtPnRlc3QsIHJlcyk7 CisKKwlLVU5JVF9FWFBFQ1RfRVEodGVzdCwgZmFsc2UsIGN0eC0+aXNfcmVzb3VyY2VfaW5pdGlh bGl6ZWQpOworCUtVTklUX0VYUEVDVF9UUlVFKHRlc3QsIGxpc3RfZW1wdHkoJmN0eC0+dGVzdC5y ZXNvdXJjZXMpKTsKK30KKworc3RhdGljIHZvaWQga3VuaXRfcmVzb3VyY2VfdGVzdF9jbGVhbnVw X3Jlc291cmNlcyhzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJaW50IGk7CisJc3RydWN0IGt1bml0 X3Rlc3RfcmVzb3VyY2VfY29udGV4dCAqY3R4ID0gdGVzdC0+cHJpdjsKKwlzdHJ1Y3Qga3VuaXRf cmVzb3VyY2UgKnJlc291cmNlc1s1XTsKKworCWZvciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHJl c291cmNlcyk7IGkrKykgeworCQlyZXNvdXJjZXNbaV0gPSBrdW5pdF9hbGxvY19yZXNvdXJjZSgm Y3R4LT50ZXN0LAorCQkJCQkJICAgIGZha2VfcmVzb3VyY2VfaW5pdCwKKwkJCQkJCSAgICBmYWtl X3Jlc291cmNlX2ZyZWUsCisJCQkJCQkgICAgY3R4KTsKKwl9CisKKwlrdW5pdF9jbGVhbnVwKCZj dHgtPnRlc3QpOworCisJS1VOSVRfRVhQRUNUX1RSVUUodGVzdCwgbGlzdF9lbXB0eSgmY3R4LT50 ZXN0LnJlc291cmNlcykpOworfQorCitzdGF0aWMgaW50IGt1bml0X3Jlc291cmNlX3Rlc3RfaW5p dChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJc3RydWN0IGt1bml0X3Rlc3RfcmVzb3VyY2VfY29u dGV4dCAqY3R4ID0KKwkJCWt6YWxsb2Moc2l6ZW9mKCpjdHgpLCBHRlBfS0VSTkVMKTsKKworCWlm ICghY3R4KQorCQlyZXR1cm4gLUVOT01FTTsKKworCXRlc3QtPnByaXYgPSBjdHg7CisKKwlrdW5p dF9pbml0X3Rlc3QoJmN0eC0+dGVzdCwgInRlc3RfdGVzdF9jb250ZXh0Iik7CisKKwlyZXR1cm4g MDsKK30KKworc3RhdGljIHZvaWQga3VuaXRfcmVzb3VyY2VfdGVzdF9leGl0KHN0cnVjdCBrdW5p dCAqdGVzdCkKK3sKKwlzdHJ1Y3Qga3VuaXRfdGVzdF9yZXNvdXJjZV9jb250ZXh0ICpjdHggPSB0 ZXN0LT5wcml2OworCisJa3VuaXRfY2xlYW51cCgmY3R4LT50ZXN0KTsKKwlrZnJlZShjdHgpOwor fQorCitzdGF0aWMgc3RydWN0IGt1bml0X2Nhc2Uga3VuaXRfcmVzb3VyY2VfdGVzdF9jYXNlc1td ID0geworCUtVTklUX0NBU0Uoa3VuaXRfcmVzb3VyY2VfdGVzdF9pbml0X3Jlc291cmNlcyksCisJ S1VOSVRfQ0FTRShrdW5pdF9yZXNvdXJjZV90ZXN0X2FsbG9jX3Jlc291cmNlKSwKKwlLVU5JVF9D QVNFKGt1bml0X3Jlc291cmNlX3Rlc3RfZnJlZV9yZXNvdXJjZSksCisJS1VOSVRfQ0FTRShrdW5p dF9yZXNvdXJjZV90ZXN0X2NsZWFudXBfcmVzb3VyY2VzKSwKKwl7fSwKK307CisKK3N0YXRpYyBz dHJ1Y3Qga3VuaXRfbW9kdWxlIGt1bml0X3Jlc291cmNlX3Rlc3RfbW9kdWxlID0geworCS5uYW1l ID0gImt1bml0LXJlc291cmNlLXRlc3QiLAorCS5pbml0ID0ga3VuaXRfcmVzb3VyY2VfdGVzdF9p bml0LAorCS5leGl0ID0ga3VuaXRfcmVzb3VyY2VfdGVzdF9leGl0LAorCS50ZXN0X2Nhc2VzID0g a3VuaXRfcmVzb3VyY2VfdGVzdF9jYXNlcywKK307Cittb2R1bGVfdGVzdChrdW5pdF9yZXNvdXJj ZV90ZXN0X21vZHVsZSk7Ci0tIAoyLjIxLjAuMzkyLmdmOGY2Nzg3MTU5ZS1nb29nCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmktZGV2ZWwgbWFpbGlu ZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVl ZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWw= 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=-16.6 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_PASS,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 516E4C4360F for ; Thu, 4 Apr 2019 22:11:20 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 0EAC9217D4 for ; Thu, 4 Apr 2019 22:11:20 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="OOcaDPIB" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731183AbfDDWLT (ORCPT ); Thu, 4 Apr 2019 18:11:19 -0400 Received: from mail-qt1-f201.google.com ([209.85.160.201]:52039 "EHLO mail-qt1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730889AbfDDWKa (ORCPT ); Thu, 4 Apr 2019 18:10:30 -0400 Received: by mail-qt1-f201.google.com with SMTP id l26so3620448qtk.18 for ; Thu, 04 Apr 2019 15:10:29 -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=eSQTnJlsVyvVkHe102MVefzKzQnpLodW/Uu/p7ocufw=; b=OOcaDPIBFjNNiGZw7QY6fYXsb0W4NQAQjsAcAWcfEzOlt0OwYQIc5J4fefUyP7oYKi wQaEczWo/9IvNvEwTixlEez5VbeP3VsrYKzrRLWwSd2r0j/jVJ6zqRWIDpR0too8sWxq 78HAHmstJpjcRQU9/pBkMRMAjKilUpNGArEbHfPolO9bjFnpQTuU0fqv8GFAmWApoGSN mf+HldJP+Ktxq9DKw9MIB2LsSsDyX7Gu7v2OoLDwPZNJO1BFh/JfgobZyoXiWShFVfVQ LGLlmn3CdWhJgHWUMrcyqFo+Ei9bAF+4ZavRrcQCI6swKSx3Gv8segziCWQvJpPsqfWW 2dXQ== 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=eSQTnJlsVyvVkHe102MVefzKzQnpLodW/Uu/p7ocufw=; b=gStJ4QrkpOwdo69gsh2TCCSM66cEg5+kIHu1WwHj6fz97q5GSdVQpgw5ojqBmFomi2 Sbb1mb1VsiceN6IjMMFSv+v7K/jShrOTaTP072Z+SOlKwjTdPyQP2a6KcG708Zmk92L3 CV1bKoSL7e42eOstDjI4D1/lYTncNe4MelUBE8BVmM7getQhISG95Qquawss8Bc29DUs wV8ZjL6S83oCP4dEsf6qs01cXKWw4meZRAqC5W79t9GSmou2BuMQyUUjpnqStdUlVaj1 bs6twlFFXviuV3btgfMyLQtQiXzzrFgxPR8skDpSqwgEoOs3pdfohmYQtPgGUQWHUNpg ti3g== X-Gm-Message-State: APjAAAWctGnC8hwuziKAIyf1Uz5SIGrQlvz6FDz87VeZ0HOi7dUt2UFE Mk18rGnqKXds+xCzjCwIgAU+JEfJpfaez4zkjbOy9A== X-Google-Smtp-Source: APXvYqyi7cwVSN26mfyq5K1f5peAkTMwJzfuWDL/4vQZGxDUFxBEI1VylCGRxLXhEnQtAHnW3y1NBIesQoTqIctaXJ2qKA== X-Received: by 2002:ae9:e849:: with SMTP id a70mr1215066qkg.34.1554415829026; Thu, 04 Apr 2019 15:10:29 -0700 (PDT) Date: Thu, 4 Apr 2019 15:06:46 -0700 In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> Message-Id: <20190404220652.19765-12-brendanhiggins@google.com> Mime-Version: 1.0 References: <20190404220652.19765-1-brendanhiggins@google.com> X-Mailer: git-send-email 2.21.0.392.gf8f6787159e-goog Subject: [PATCH v1 11/17] kunit: test: add test managed resource tests From: Brendan Higgins To: corbet@lwn.net, frowand.list@gmail.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, robh@kernel.org, shuah@kernel.org, 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, dan.j.williams@intel.com, daniel@ffwll.ch, gregkh@linuxfoundation.org, jdike@addtoit.com, joel@jms.id.au, julia.lawall@lip6.fr, khilman@baylibre.com, knut.omang@oracle.com, mpe@ellerman.id.au, pmladek@suse.com, richard@nod.at, rostedt@goodmis.org, wfg@linux.intel.com, Avinash Kondareddy , 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 From: Avinash Kondareddy Tests how tests interact with test managed resources in their lifetime. Signed-off-by: Avinash Kondareddy Signed-off-by: Brendan Higgins --- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) diff --git a/kunit/test-test.c b/kunit/test-test.c index 4bd7a34d0a6cb..54add8ca418a0 100644 --- a/kunit/test-test.c +++ b/kunit/test-test.c @@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, }; module_test(kunit_try_catch_test_module); + +/* + * Context for testing test managed resources + * is_resource_initialized is used to test arbitrary resources + */ +struct kunit_test_resource_context { + struct kunit test; + bool is_resource_initialized; +}; + +static int fake_resource_init(struct kunit_resource *res, void *context) +{ + struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; + return 0; +} + +static void fake_resource_free(struct kunit_resource *res) +{ + bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_init_test(&ctx->test, "testing_test_init_test"); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res; + kunit_resource_free_t free = fake_resource_free; + + res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res); + KUNIT_EXPECT_EQ(test, &ctx->is_resource_initialized, res->allocation); + KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources)); + KUNIT_EXPECT_EQ(test, free, res->free); +} + +static void kunit_resource_test_free_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + kunit_free_resource(&ctx->test, res); + + KUNIT_EXPECT_EQ(test, false, ctx->is_resource_initialized); + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_cleanup_resources(struct kunit *test) +{ + int i; + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *resources[5]; + + for (i = 0; i < ARRAY_SIZE(resources); i++) { + resources[i] = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + } + + kunit_cleanup(&ctx->test); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static int kunit_resource_test_init(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = + kzalloc(sizeof(*ctx), GFP_KERNEL); + + if (!ctx) + return -ENOMEM; + + test->priv = ctx; + + kunit_init_test(&ctx->test, "test_test_context"); + + return 0; +} + +static void kunit_resource_test_exit(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_cleanup(&ctx->test); + kfree(ctx); +} + +static struct kunit_case kunit_resource_test_cases[] = { + KUNIT_CASE(kunit_resource_test_init_resources), + KUNIT_CASE(kunit_resource_test_alloc_resource), + KUNIT_CASE(kunit_resource_test_free_resource), + KUNIT_CASE(kunit_resource_test_cleanup_resources), + {}, +}; + +static struct kunit_module kunit_resource_test_module = { + .name = "kunit-resource-test", + .init = kunit_resource_test_init, + .exit = kunit_resource_test_exit, + .test_cases = kunit_resource_test_cases, +}; +module_test(kunit_resource_test_module); -- 2.21.0.392.gf8f6787159e-goog From mboxrd@z Thu Jan 1 00:00:00 1970 From: brendanhiggins at google.com (Brendan Higgins) Date: Thu, 4 Apr 2019 15:06:46 -0700 Subject: [PATCH v1 11/17] kunit: test: add test managed resource tests In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> References: <20190404220652.19765-1-brendanhiggins@google.com> Message-ID: <20190404220652.19765-12-brendanhiggins@google.com> From: Avinash Kondareddy Tests how tests interact with test managed resources in their lifetime. Signed-off-by: Avinash Kondareddy Signed-off-by: Brendan Higgins --- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) diff --git a/kunit/test-test.c b/kunit/test-test.c index 4bd7a34d0a6cb..54add8ca418a0 100644 --- a/kunit/test-test.c +++ b/kunit/test-test.c @@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, }; module_test(kunit_try_catch_test_module); + +/* + * Context for testing test managed resources + * is_resource_initialized is used to test arbitrary resources + */ +struct kunit_test_resource_context { + struct kunit test; + bool is_resource_initialized; +}; + +static int fake_resource_init(struct kunit_resource *res, void *context) +{ + struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; + return 0; +} + +static void fake_resource_free(struct kunit_resource *res) +{ + bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_init_test(&ctx->test, "testing_test_init_test"); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res; + kunit_resource_free_t free = fake_resource_free; + + res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res); + KUNIT_EXPECT_EQ(test, &ctx->is_resource_initialized, res->allocation); + KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources)); + KUNIT_EXPECT_EQ(test, free, res->free); +} + +static void kunit_resource_test_free_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + kunit_free_resource(&ctx->test, res); + + KUNIT_EXPECT_EQ(test, false, ctx->is_resource_initialized); + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_cleanup_resources(struct kunit *test) +{ + int i; + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *resources[5]; + + for (i = 0; i < ARRAY_SIZE(resources); i++) { + resources[i] = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + } + + kunit_cleanup(&ctx->test); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static int kunit_resource_test_init(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = + kzalloc(sizeof(*ctx), GFP_KERNEL); + + if (!ctx) + return -ENOMEM; + + test->priv = ctx; + + kunit_init_test(&ctx->test, "test_test_context"); + + return 0; +} + +static void kunit_resource_test_exit(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_cleanup(&ctx->test); + kfree(ctx); +} + +static struct kunit_case kunit_resource_test_cases[] = { + KUNIT_CASE(kunit_resource_test_init_resources), + KUNIT_CASE(kunit_resource_test_alloc_resource), + KUNIT_CASE(kunit_resource_test_free_resource), + KUNIT_CASE(kunit_resource_test_cleanup_resources), + {}, +}; + +static struct kunit_module kunit_resource_test_module = { + .name = "kunit-resource-test", + .init = kunit_resource_test_init, + .exit = kunit_resource_test_exit, + .test_cases = kunit_resource_test_cases, +}; +module_test(kunit_resource_test_module); -- 2.21.0.392.gf8f6787159e-goog From mboxrd@z Thu Jan 1 00:00:00 1970 From: brendanhiggins@google.com (Brendan Higgins) Date: Thu, 4 Apr 2019 15:06:46 -0700 Subject: [PATCH v1 11/17] kunit: test: add test managed resource tests In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> References: <20190404220652.19765-1-brendanhiggins@google.com> Message-ID: <20190404220652.19765-12-brendanhiggins@google.com> Content-Type: text/plain; charset="UTF-8" Message-ID: <20190404220646.0KAWYCgyK-AHrI_H14Yyz6Mw7uiI94H7sZCDhGPg9z4@z> From: Avinash Kondareddy Tests how tests interact with test managed resources in their lifetime. Signed-off-by: Avinash Kondareddy Signed-off-by: Brendan Higgins --- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) diff --git a/kunit/test-test.c b/kunit/test-test.c index 4bd7a34d0a6cb..54add8ca418a0 100644 --- a/kunit/test-test.c +++ b/kunit/test-test.c @@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, }; module_test(kunit_try_catch_test_module); + +/* + * Context for testing test managed resources + * is_resource_initialized is used to test arbitrary resources + */ +struct kunit_test_resource_context { + struct kunit test; + bool is_resource_initialized; +}; + +static int fake_resource_init(struct kunit_resource *res, void *context) +{ + struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; + return 0; +} + +static void fake_resource_free(struct kunit_resource *res) +{ + bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_init_test(&ctx->test, "testing_test_init_test"); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res; + kunit_resource_free_t free = fake_resource_free; + + res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res); + KUNIT_EXPECT_EQ(test, &ctx->is_resource_initialized, res->allocation); + KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources)); + KUNIT_EXPECT_EQ(test, free, res->free); +} + +static void kunit_resource_test_free_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + kunit_free_resource(&ctx->test, res); + + KUNIT_EXPECT_EQ(test, false, ctx->is_resource_initialized); + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_cleanup_resources(struct kunit *test) +{ + int i; + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *resources[5]; + + for (i = 0; i < ARRAY_SIZE(resources); i++) { + resources[i] = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + } + + kunit_cleanup(&ctx->test); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static int kunit_resource_test_init(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = + kzalloc(sizeof(*ctx), GFP_KERNEL); + + if (!ctx) + return -ENOMEM; + + test->priv = ctx; + + kunit_init_test(&ctx->test, "test_test_context"); + + return 0; +} + +static void kunit_resource_test_exit(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_cleanup(&ctx->test); + kfree(ctx); +} + +static struct kunit_case kunit_resource_test_cases[] = { + KUNIT_CASE(kunit_resource_test_init_resources), + KUNIT_CASE(kunit_resource_test_alloc_resource), + KUNIT_CASE(kunit_resource_test_free_resource), + KUNIT_CASE(kunit_resource_test_cleanup_resources), + {}, +}; + +static struct kunit_module kunit_resource_test_module = { + .name = "kunit-resource-test", + .init = kunit_resource_test_init, + .exit = kunit_resource_test_exit, + .test_cases = kunit_resource_test_cases, +}; +module_test(kunit_resource_test_module); -- 2.21.0.392.gf8f6787159e-goog From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-qk1-x749.google.com ([2607:f8b0:4864:20::749]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1hCAZ4-00006u-It for linux-um@lists.infradead.org; Thu, 04 Apr 2019 22:10:31 +0000 Received: by mail-qk1-x749.google.com with SMTP id 75so3441972qki.13 for ; Thu, 04 Apr 2019 15:10:29 -0700 (PDT) Date: Thu, 4 Apr 2019 15:06:46 -0700 In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> Message-Id: <20190404220652.19765-12-brendanhiggins@google.com> Mime-Version: 1.0 References: <20190404220652.19765-1-brendanhiggins@google.com> Subject: [PATCH v1 11/17] kunit: test: add test managed resource tests 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: corbet@lwn.net, frowand.list@gmail.com, keescook@google.com, kieran.bingham@ideasonboard.com, mcgrof@kernel.org, robh@kernel.org, shuah@kernel.org, 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, jdike@addtoit.com, dan.carpenter@oracle.com, devicetree@vger.kernel.org, linux-kbuild@vger.kernel.org, Tim.Bird@sony.com, Avinash Kondareddy , linux-um@lists.infradead.org, rostedt@goodmis.org, julia.lawall@lip6.fr, dan.j.williams@intel.com, kunit-dev@googlegroups.com, richard@nod.at, gregkh@linuxfoundation.org, linux-kernel@vger.kernel.org, daniel@ffwll.ch, mpe@ellerman.id.au, linux-fsdevel@vger.kernel.org From: Avinash Kondareddy Tests how tests interact with test managed resources in their lifetime. Signed-off-by: Avinash Kondareddy Signed-off-by: Brendan Higgins --- kunit/test-test.c | 122 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) diff --git a/kunit/test-test.c b/kunit/test-test.c index 4bd7a34d0a6cb..54add8ca418a0 100644 --- a/kunit/test-test.c +++ b/kunit/test-test.c @@ -135,3 +135,125 @@ static struct kunit_module kunit_try_catch_test_module = { .test_cases = kunit_try_catch_test_cases, }; module_test(kunit_try_catch_test_module); + +/* + * Context for testing test managed resources + * is_resource_initialized is used to test arbitrary resources + */ +struct kunit_test_resource_context { + struct kunit test; + bool is_resource_initialized; +}; + +static int fake_resource_init(struct kunit_resource *res, void *context) +{ + struct kunit_test_resource_context *ctx = context; + + res->allocation = &ctx->is_resource_initialized; + ctx->is_resource_initialized = true; + return 0; +} + +static void fake_resource_free(struct kunit_resource *res) +{ + bool *is_resource_initialized = res->allocation; + + *is_resource_initialized = false; +} + +static void kunit_resource_test_init_resources(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_init_test(&ctx->test, "testing_test_init_test"); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_alloc_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res; + kunit_resource_free_t free = fake_resource_free; + + res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res); + KUNIT_EXPECT_EQ(test, &ctx->is_resource_initialized, res->allocation); + KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources)); + KUNIT_EXPECT_EQ(test, free, res->free); +} + +static void kunit_resource_test_free_resource(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *res = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + + kunit_free_resource(&ctx->test, res); + + KUNIT_EXPECT_EQ(test, false, ctx->is_resource_initialized); + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static void kunit_resource_test_cleanup_resources(struct kunit *test) +{ + int i; + struct kunit_test_resource_context *ctx = test->priv; + struct kunit_resource *resources[5]; + + for (i = 0; i < ARRAY_SIZE(resources); i++) { + resources[i] = kunit_alloc_resource(&ctx->test, + fake_resource_init, + fake_resource_free, + ctx); + } + + kunit_cleanup(&ctx->test); + + KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources)); +} + +static int kunit_resource_test_init(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = + kzalloc(sizeof(*ctx), GFP_KERNEL); + + if (!ctx) + return -ENOMEM; + + test->priv = ctx; + + kunit_init_test(&ctx->test, "test_test_context"); + + return 0; +} + +static void kunit_resource_test_exit(struct kunit *test) +{ + struct kunit_test_resource_context *ctx = test->priv; + + kunit_cleanup(&ctx->test); + kfree(ctx); +} + +static struct kunit_case kunit_resource_test_cases[] = { + KUNIT_CASE(kunit_resource_test_init_resources), + KUNIT_CASE(kunit_resource_test_alloc_resource), + KUNIT_CASE(kunit_resource_test_free_resource), + KUNIT_CASE(kunit_resource_test_cleanup_resources), + {}, +}; + +static struct kunit_module kunit_resource_test_module = { + .name = "kunit-resource-test", + .init = kunit_resource_test_init, + .exit = kunit_resource_test_exit, + .test_cases = kunit_resource_test_cases, +}; +module_test(kunit_resource_test_module); -- 2.21.0.392.gf8f6787159e-goog _______________________________________________ linux-um mailing list linux-um@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-um