From mboxrd@z Thu Jan 1 00:00:00 1970 From: Brendan Higgins Subject: [PATCH v1 09/17] kunit: test: add tests for kunit test abort Date: Thu, 4 Apr 2019 15:06:44 -0700 Message-ID: <20190404220652.19765-10-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, 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 QWRkIEtVbml0IHRlc3RzIGZvciB0aGUgS1VuaXQgdGVzdCBhYm9ydCBtZWNoYW5pc20gKHNlZSBw cmVjZWRpbmcKY29tbWl0KS4gQWRkIHRlc3RzIGJvdGggZm9yIGdlbmVyYWwgdHJ5IGNhdGNoIG1l Y2hhbmlzbSBhcyB3ZWxsIGFzCm5vbi1hcmNoaXRlY3R1cmUgc3BlY2lmaWMgbWVjaGFuaXNtLgoK U2lnbmVkLW9mZi1ieTogQnJlbmRhbiBIaWdnaW5zIDxicmVuZGFuaGlnZ2luc0Bnb29nbGUuY29t PgotLS0KIGt1bml0L01ha2VmaWxlICAgIHwgICAzICstCiBrdW5pdC90ZXN0LXRlc3QuYyB8IDEz NSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiAyIGZpbGVz IGNoYW5nZWQsIDEzNyBpbnNlcnRpb25zKCspLCAxIGRlbGV0aW9uKC0pCiBjcmVhdGUgbW9kZSAx MDA2NDQga3VuaXQvdGVzdC10ZXN0LmMKCmRpZmYgLS1naXQgYS9rdW5pdC9NYWtlZmlsZSBiL2t1 bml0L01ha2VmaWxlCmluZGV4IDFmNzY4MGNmYTExYWQuLjUzMzM1NTg2N2FiZDIgMTAwNjQ0Ci0t LSBhL2t1bml0L01ha2VmaWxlCisrKyBiL2t1bml0L01ha2VmaWxlCkBAIC0zLDYgKzMsNyBAQCBv YmotJChDT05GSUdfS1VOSVQpICs9CQkJdGVzdC5vIFwKIAkJCQkJa3VuaXQtc3RyZWFtLm8gXAog CQkJCQl0cnktY2F0Y2gubwogCi1vYmotJChDT05GSUdfS1VOSVRfVEVTVCkgKz0JCXN0cmluZy1z dHJlYW0tdGVzdC5vCitvYmotJChDT05GSUdfS1VOSVRfVEVTVCkgKz0JCXRlc3QtdGVzdC5vIFwK KwkJCQkJc3RyaW5nLXN0cmVhbS10ZXN0Lm8KIAogb2JqLSQoQ09ORklHX0tVTklUX0VYQU1QTEVf VEVTVCkgKz0JZXhhbXBsZS10ZXN0Lm8KZGlmZiAtLWdpdCBhL2t1bml0L3Rlc3QtdGVzdC5jIGIv a3VuaXQvdGVzdC10ZXN0LmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MC4uYzgxYWU2ZWZiOTU5ZgotLS0gL2Rldi9udWxsCisrKyBiL2t1bml0L3Rlc3QtdGVzdC5jCkBA IC0wLDAgKzEsMTM1IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoK KyAqIEtVbml0IHRlc3QgZm9yIGNvcmUgdGVzdCBpbmZyYXN0cnVjdHVyZS4KKyAqCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTksIEdvb2dsZSBMTEMuCisgKiBBdXRob3I6IEJyZW5kYW4gSGlnZ2lucyA8 YnJlbmRhbmhpZ2dpbnNAZ29vZ2xlLmNvbT4KKyAqLworI2luY2x1ZGUgPGt1bml0L3Rlc3QuaD4K Kworc3RydWN0IGt1bml0X3RyeV9jYXRjaF90ZXN0X2NvbnRleHQgeworCXN0cnVjdCBrdW5pdF90 cnlfY2F0Y2ggKnRyeV9jYXRjaDsKKwlib29sIGZ1bmN0aW9uX2NhbGxlZDsKK307CisKK3ZvaWQg a3VuaXRfdGVzdF9zdWNjZXNzZnVsX3RyeSh2b2lkICpkYXRhKQoreworCXN0cnVjdCBrdW5pdCAq dGVzdCA9IGRhdGE7CisJc3RydWN0IGt1bml0X3RyeV9jYXRjaF90ZXN0X2NvbnRleHQgKmN0eCA9 IHRlc3QtPnByaXY7CisKKwljdHgtPmZ1bmN0aW9uX2NhbGxlZCA9IHRydWU7Cit9CisKK3ZvaWQg a3VuaXRfdGVzdF9ub19jYXRjaCh2b2lkICpkYXRhKQoreworCXN0cnVjdCBrdW5pdCAqdGVzdCA9 IGRhdGE7CisKKwlLVU5JVF9GQUlMKHRlc3QsICJDYXRjaCBzaG91bGQgbm90IGJlIGNhbGxlZC5c biIpOworfQorCitzdGF0aWMgdm9pZCBrdW5pdF90ZXN0X3RyeV9jYXRjaF9zdWNjZXNzZnVsX3Ry eV9ub19jYXRjaChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJc3RydWN0IGt1bml0X3RyeV9jYXRj aF90ZXN0X2NvbnRleHQgKmN0eCA9IHRlc3QtPnByaXY7CisJc3RydWN0IGt1bml0X3RyeV9jYXRj aCAqdHJ5X2NhdGNoID0gY3R4LT50cnlfY2F0Y2g7CisKKwlrdW5pdF90cnlfY2F0Y2hfaW5pdCh0 cnlfY2F0Y2gsCisJCQkgICAgIHRlc3QsCisJCQkgICAgIGt1bml0X3Rlc3Rfc3VjY2Vzc2Z1bF90 cnksCisJCQkgICAgIGt1bml0X3Rlc3Rfbm9fY2F0Y2gpOworCWt1bml0X3RyeV9jYXRjaF9ydW4o dHJ5X2NhdGNoLCB0ZXN0KTsKKworCUtVTklUX0VYUEVDVF9UUlVFKHRlc3QsIGN0eC0+ZnVuY3Rp b25fY2FsbGVkKTsKK30KKwordm9pZCBrdW5pdF90ZXN0X3Vuc3VjY2Vzc2Z1bF90cnkodm9pZCAq ZGF0YSkKK3sKKwlzdHJ1Y3Qga3VuaXQgKnRlc3QgPSBkYXRhOworCXN0cnVjdCBrdW5pdF90cnlf Y2F0Y2hfdGVzdF9jb250ZXh0ICpjdHggPSB0ZXN0LT5wcml2OworCXN0cnVjdCBrdW5pdF90cnlf Y2F0Y2ggKnRyeV9jYXRjaCA9IGN0eC0+dHJ5X2NhdGNoOworCisJa3VuaXRfdHJ5X2NhdGNoX3Ro cm93KHRyeV9jYXRjaCk7CisJS1VOSVRfRkFJTCh0ZXN0LCAiVGhpcyBsaW5lIHNob3VsZCBuZXZl ciBiZSByZWFjaGVkLlxuIik7Cit9CisKK3ZvaWQga3VuaXRfdGVzdF9jYXRjaCh2b2lkICpkYXRh KQoreworCXN0cnVjdCBrdW5pdCAqdGVzdCA9IGRhdGE7CisJc3RydWN0IGt1bml0X3RyeV9jYXRj aF90ZXN0X2NvbnRleHQgKmN0eCA9IHRlc3QtPnByaXY7CisKKwljdHgtPmZ1bmN0aW9uX2NhbGxl ZCA9IHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIGt1bml0X3Rlc3RfdHJ5X2NhdGNoX3Vuc3VjY2Vz c2Z1bF90cnlfZG9lc19jYXRjaChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7CisJc3RydWN0IGt1bml0 X3RyeV9jYXRjaF90ZXN0X2NvbnRleHQgKmN0eCA9IHRlc3QtPnByaXY7CisJc3RydWN0IGt1bml0 X3RyeV9jYXRjaCAqdHJ5X2NhdGNoID0gY3R4LT50cnlfY2F0Y2g7CisKKwlrdW5pdF90cnlfY2F0 Y2hfaW5pdCh0cnlfY2F0Y2gsCisJCQkgICAgIHRlc3QsCisJCQkgICAgIGt1bml0X3Rlc3RfdW5z dWNjZXNzZnVsX3RyeSwKKwkJCSAgICAga3VuaXRfdGVzdF9jYXRjaCk7CisJa3VuaXRfdHJ5X2Nh dGNoX3J1bih0cnlfY2F0Y2gsIHRlc3QpOworCisJS1VOSVRfRVhQRUNUX1RSVUUodGVzdCwgY3R4 LT5mdW5jdGlvbl9jYWxsZWQpOworfQorCitzdGF0aWMgdm9pZCBrdW5pdF90ZXN0X2dlbmVyaWNf dHJ5X2NhdGNoX3N1Y2Nlc3NmdWxfdHJ5X25vX2NhdGNoKAorCQlzdHJ1Y3Qga3VuaXQgKnRlc3Qp Cit7CisJc3RydWN0IGt1bml0X3RyeV9jYXRjaF90ZXN0X2NvbnRleHQgKmN0eCA9IHRlc3QtPnBy aXY7CisJc3RydWN0IGt1bml0X3RyeV9jYXRjaCAqdHJ5X2NhdGNoID0gY3R4LT50cnlfY2F0Y2g7 CisKKwl0cnlfY2F0Y2gtPnRlc3QgPSB0ZXN0OworCWt1bml0X2dlbmVyaWNfdHJ5X2NhdGNoX2lu aXQodHJ5X2NhdGNoKTsKKwl0cnlfY2F0Y2gtPnRyeSA9IGt1bml0X3Rlc3Rfc3VjY2Vzc2Z1bF90 cnk7CisJdHJ5X2NhdGNoLT5jYXRjaCA9IGt1bml0X3Rlc3Rfbm9fY2F0Y2g7CisKKwlrdW5pdF90 cnlfY2F0Y2hfcnVuKHRyeV9jYXRjaCwgdGVzdCk7CisKKwlLVU5JVF9FWFBFQ1RfVFJVRSh0ZXN0 LCBjdHgtPmZ1bmN0aW9uX2NhbGxlZCk7Cit9CisKK3N0YXRpYyB2b2lkIGt1bml0X3Rlc3RfZ2Vu ZXJpY190cnlfY2F0Y2hfdW5zdWNjZXNzZnVsX3RyeV9kb2VzX2NhdGNoKAorCQlzdHJ1Y3Qga3Vu aXQgKnRlc3QpCit7CisJc3RydWN0IGt1bml0X3RyeV9jYXRjaF90ZXN0X2NvbnRleHQgKmN0eCA9 IHRlc3QtPnByaXY7CisJc3RydWN0IGt1bml0X3RyeV9jYXRjaCAqdHJ5X2NhdGNoID0gY3R4LT50 cnlfY2F0Y2g7CisKKwl0cnlfY2F0Y2gtPnRlc3QgPSB0ZXN0OworCWt1bml0X2dlbmVyaWNfdHJ5 X2NhdGNoX2luaXQodHJ5X2NhdGNoKTsKKwl0cnlfY2F0Y2gtPnRyeSA9IGt1bml0X3Rlc3RfdW5z dWNjZXNzZnVsX3RyeTsKKwl0cnlfY2F0Y2gtPmNhdGNoID0ga3VuaXRfdGVzdF9jYXRjaDsKKwor CWt1bml0X3RyeV9jYXRjaF9ydW4odHJ5X2NhdGNoLCB0ZXN0KTsKKworCUtVTklUX0VYUEVDVF9U UlVFKHRlc3QsIGN0eC0+ZnVuY3Rpb25fY2FsbGVkKTsKK30KKworc3RhdGljIGludCBrdW5pdF90 cnlfY2F0Y2hfdGVzdF9pbml0KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwlzdHJ1Y3Qga3VuaXRf dHJ5X2NhdGNoX3Rlc3RfY29udGV4dCAqY3R4OworCisJY3R4ID0ga3VuaXRfa3phbGxvYyh0ZXN0 LCBzaXplb2YoKmN0eCksIEdGUF9LRVJORUwpOworCXRlc3QtPnByaXYgPSBjdHg7CisKKwljdHgt PnRyeV9jYXRjaCA9IGt1bml0X2ttYWxsb2ModGVzdCwKKwkJCQkgICAgICAgc2l6ZW9mKCpjdHgt PnRyeV9jYXRjaCksCisJCQkJICAgICAgIEdGUF9LRVJORUwpOworCisJcmV0dXJuIDA7Cit9CisK K3N0YXRpYyBzdHJ1Y3Qga3VuaXRfY2FzZSBrdW5pdF90cnlfY2F0Y2hfdGVzdF9jYXNlc1tdID0g eworCUtVTklUX0NBU0Uoa3VuaXRfdGVzdF90cnlfY2F0Y2hfc3VjY2Vzc2Z1bF90cnlfbm9fY2F0 Y2gpLAorCUtVTklUX0NBU0Uoa3VuaXRfdGVzdF90cnlfY2F0Y2hfdW5zdWNjZXNzZnVsX3RyeV9k b2VzX2NhdGNoKSwKKwlLVU5JVF9DQVNFKGt1bml0X3Rlc3RfZ2VuZXJpY190cnlfY2F0Y2hfc3Vj Y2Vzc2Z1bF90cnlfbm9fY2F0Y2gpLAorCUtVTklUX0NBU0Uoa3VuaXRfdGVzdF9nZW5lcmljX3Ry eV9jYXRjaF91bnN1Y2Nlc3NmdWxfdHJ5X2RvZXNfY2F0Y2gpLAorCXt9LAorfTsKKworc3RhdGlj IHN0cnVjdCBrdW5pdF9tb2R1bGUga3VuaXRfdHJ5X2NhdGNoX3Rlc3RfbW9kdWxlID0geworCS5u YW1lID0gImt1bml0LXRyeS1jYXRjaC10ZXN0IiwKKwkuaW5pdCA9IGt1bml0X3RyeV9jYXRjaF90 ZXN0X2luaXQsCisJLnRlc3RfY2FzZXMgPSBrdW5pdF90cnlfY2F0Y2hfdGVzdF9jYXNlcywKK307 Cittb2R1bGVfdGVzdChrdW5pdF90cnlfY2F0Y2hfdGVzdF9tb2R1bGUpOwotLSAKMi4yMS4wLjM5 Mi5nZjhmNjc4NzE1OWUtZ29vZwoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRl c2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8v ZHJpLWRldmVs 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=ham 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 B75C5C4360F for ; Thu, 4 Apr 2019 22:10:31 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 761D0218D4 for ; Thu, 4 Apr 2019 22:10:31 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="jEhdfpNF" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730934AbfDDWKa (ORCPT ); Thu, 4 Apr 2019 18:10:30 -0400 Received: from mail-vk1-f201.google.com ([209.85.221.201]:56429 "EHLO mail-vk1-f201.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1730830AbfDDWKZ (ORCPT ); Thu, 4 Apr 2019 18:10:25 -0400 Received: by mail-vk1-f201.google.com with SMTP id m191so1657846vka.23 for ; Thu, 04 Apr 2019 15:10:24 -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=xZZA9ZO9AvyPyc8p0zQtlzF4UjcXTNGJSsk4IccYADM=; b=jEhdfpNF9fIhHEFGb+2Hb1WpC2tWeQVpmsIjrKxlKtxxKK45b3nD38N6Q9BdQQ5S9N iPulwAlBtlLdcEkMVo5/gHv3iPs1Lxaaez2S+/wwRxG64kcJn7YemK0zQwllCcWoeqCr DeArPRbK/pb05ZveeFW5855Igl2I7HKQln5xHD3uxuyrny7k0ESwp+Uq7Ys6lfjpfbN5 wKsDmqjwKuo8PEJMy7SmRPXsTvVkrlEO3S/r0/I9MSey1R0/IiTcwHVTlP1qsACygkKw VwxsvBkbA0VbFbR7yGfc4d7nU930uIsUtPxr7TsZFK5MxOA3mOHwFRdYiLjLlfGRVQwe BM/w== 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=xZZA9ZO9AvyPyc8p0zQtlzF4UjcXTNGJSsk4IccYADM=; b=Sn+9hpD5Mdx3zvRTv6AoDGbJpyaevqlAMNNRUgIkWhQVJ1uPBSKdFtP4QF7K9FGFl4 PzwHJbDfyQijK+Lr9PokzmVmgN+X1jHKQfjwrCQCFrN5+3XKJwuGfcjUdFwzVYELKeTu etFOB0n1rBrcnnY4oFzhQNCN5WfdqmWYA0bOt6YGEwQWhY2AunfMtNPQYLdb8gRSZFTp mb8KL4RcL9sJmRTSM/lYdgtckt12kOWW+x6skSv+ih8T0yA/8W4kukuEN8HR/A9aiRfa i3yOQ3xBVYDYyGteNKrNScBzU3FmFXxbSpzowB86D4v53Zp1f1+Mjekkunn/6dnwq/Ht kwpg== X-Gm-Message-State: APjAAAUnrcqnY76NvGz9sOhMM7FLYYrn0CkAQH7aVm9ud0doh7u3Gq3H APLNnwW+QO4+03+AFf+Z5k8cuv6M8WSsWdDmqDVZXg== X-Google-Smtp-Source: APXvYqw5zqt5BfIYiqLiD+3uGQUj6vjyxtH1hOI7tiv6C1Z2ysFXMOBQPmEJXA5iKToUpOIh/OTNwicicPoPz8BM0mbDuQ== X-Received: by 2002:ab0:74d5:: with SMTP id f21mr1060439uaq.27.1554415823838; Thu, 04 Apr 2019 15:10:23 -0700 (PDT) Date: Thu, 4 Apr 2019 15:06:44 -0700 In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> Message-Id: <20190404220652.19765-10-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 09/17] kunit: test: add tests for kunit test abort 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, 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 KUnit tests for the KUnit test abort mechanism (see preceding commit). Add tests both for general try catch mechanism as well as non-architecture specific mechanism. Signed-off-by: Brendan Higgins --- kunit/Makefile | 3 +- kunit/test-test.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 kunit/test-test.c diff --git a/kunit/Makefile b/kunit/Makefile index 1f7680cfa11ad..533355867abd2 100644 --- a/kunit/Makefile +++ b/kunit/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_KUNIT) += test.o \ kunit-stream.o \ try-catch.o -obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o +obj-$(CONFIG_KUNIT_TEST) += test-test.o \ + string-stream-test.o obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o diff --git a/kunit/test-test.c b/kunit/test-test.c new file mode 100644 index 0000000000000..c81ae6efb959f --- /dev/null +++ b/kunit/test-test.c @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit test for core test infrastructure. + * + * Copyright (C) 2019, Google LLC. + * Author: Brendan Higgins + */ +#include + +struct kunit_try_catch_test_context { + struct kunit_try_catch *try_catch; + bool function_called; +}; + +void kunit_test_successful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +void kunit_test_no_catch(void *data) +{ + struct kunit *test = data; + + KUNIT_FAIL(test, "Catch should not be called.\n"); +} + +static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_successful_try, + kunit_test_no_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +void kunit_test_unsuccessful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_throw(try_catch); + KUNIT_FAIL(test, "This line should never be reached.\n"); +} + +void kunit_test_catch(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_unsuccessful_try, + kunit_test_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_successful_try_no_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_successful_try; + try_catch->catch = kunit_test_no_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_unsuccessful_try_does_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_unsuccessful_try; + try_catch->catch = kunit_test_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static int kunit_try_catch_test_init(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + test->priv = ctx; + + ctx->try_catch = kunit_kmalloc(test, + sizeof(*ctx->try_catch), + GFP_KERNEL); + + return 0; +} + +static struct kunit_case kunit_try_catch_test_cases[] = { + KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch), + KUNIT_CASE(kunit_test_generic_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_generic_try_catch_unsuccessful_try_does_catch), + {}, +}; + +static struct kunit_module kunit_try_catch_test_module = { + .name = "kunit-try-catch-test", + .init = kunit_try_catch_test_init, + .test_cases = kunit_try_catch_test_cases, +}; +module_test(kunit_try_catch_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:44 -0700 Subject: [PATCH v1 09/17] kunit: test: add tests for kunit test abort In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> References: <20190404220652.19765-1-brendanhiggins@google.com> Message-ID: <20190404220652.19765-10-brendanhiggins@google.com> Add KUnit tests for the KUnit test abort mechanism (see preceding commit). Add tests both for general try catch mechanism as well as non-architecture specific mechanism. Signed-off-by: Brendan Higgins --- kunit/Makefile | 3 +- kunit/test-test.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 kunit/test-test.c diff --git a/kunit/Makefile b/kunit/Makefile index 1f7680cfa11ad..533355867abd2 100644 --- a/kunit/Makefile +++ b/kunit/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_KUNIT) += test.o \ kunit-stream.o \ try-catch.o -obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o +obj-$(CONFIG_KUNIT_TEST) += test-test.o \ + string-stream-test.o obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o diff --git a/kunit/test-test.c b/kunit/test-test.c new file mode 100644 index 0000000000000..c81ae6efb959f --- /dev/null +++ b/kunit/test-test.c @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit test for core test infrastructure. + * + * Copyright (C) 2019, Google LLC. + * Author: Brendan Higgins + */ +#include + +struct kunit_try_catch_test_context { + struct kunit_try_catch *try_catch; + bool function_called; +}; + +void kunit_test_successful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +void kunit_test_no_catch(void *data) +{ + struct kunit *test = data; + + KUNIT_FAIL(test, "Catch should not be called.\n"); +} + +static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_successful_try, + kunit_test_no_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +void kunit_test_unsuccessful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_throw(try_catch); + KUNIT_FAIL(test, "This line should never be reached.\n"); +} + +void kunit_test_catch(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_unsuccessful_try, + kunit_test_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_successful_try_no_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_successful_try; + try_catch->catch = kunit_test_no_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_unsuccessful_try_does_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_unsuccessful_try; + try_catch->catch = kunit_test_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static int kunit_try_catch_test_init(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + test->priv = ctx; + + ctx->try_catch = kunit_kmalloc(test, + sizeof(*ctx->try_catch), + GFP_KERNEL); + + return 0; +} + +static struct kunit_case kunit_try_catch_test_cases[] = { + KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch), + KUNIT_CASE(kunit_test_generic_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_generic_try_catch_unsuccessful_try_does_catch), + {}, +}; + +static struct kunit_module kunit_try_catch_test_module = { + .name = "kunit-try-catch-test", + .init = kunit_try_catch_test_init, + .test_cases = kunit_try_catch_test_cases, +}; +module_test(kunit_try_catch_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:44 -0700 Subject: [PATCH v1 09/17] kunit: test: add tests for kunit test abort In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> References: <20190404220652.19765-1-brendanhiggins@google.com> Message-ID: <20190404220652.19765-10-brendanhiggins@google.com> Content-Type: text/plain; charset="UTF-8" Message-ID: <20190404220644.hOyDc7FIj6zO1kYU4tVbyFr_PC-a3OlNxcLWJidxApI@z> Add KUnit tests for the KUnit test abort mechanism (see preceding commit). Add tests both for general try catch mechanism as well as non-architecture specific mechanism. Signed-off-by: Brendan Higgins --- kunit/Makefile | 3 +- kunit/test-test.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 kunit/test-test.c diff --git a/kunit/Makefile b/kunit/Makefile index 1f7680cfa11ad..533355867abd2 100644 --- a/kunit/Makefile +++ b/kunit/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_KUNIT) += test.o \ kunit-stream.o \ try-catch.o -obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o +obj-$(CONFIG_KUNIT_TEST) += test-test.o \ + string-stream-test.o obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o diff --git a/kunit/test-test.c b/kunit/test-test.c new file mode 100644 index 0000000000000..c81ae6efb959f --- /dev/null +++ b/kunit/test-test.c @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit test for core test infrastructure. + * + * Copyright (C) 2019, Google LLC. + * Author: Brendan Higgins + */ +#include + +struct kunit_try_catch_test_context { + struct kunit_try_catch *try_catch; + bool function_called; +}; + +void kunit_test_successful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +void kunit_test_no_catch(void *data) +{ + struct kunit *test = data; + + KUNIT_FAIL(test, "Catch should not be called.\n"); +} + +static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_successful_try, + kunit_test_no_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +void kunit_test_unsuccessful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_throw(try_catch); + KUNIT_FAIL(test, "This line should never be reached.\n"); +} + +void kunit_test_catch(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_unsuccessful_try, + kunit_test_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_successful_try_no_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_successful_try; + try_catch->catch = kunit_test_no_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_unsuccessful_try_does_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_unsuccessful_try; + try_catch->catch = kunit_test_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static int kunit_try_catch_test_init(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + test->priv = ctx; + + ctx->try_catch = kunit_kmalloc(test, + sizeof(*ctx->try_catch), + GFP_KERNEL); + + return 0; +} + +static struct kunit_case kunit_try_catch_test_cases[] = { + KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch), + KUNIT_CASE(kunit_test_generic_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_generic_try_catch_unsuccessful_try_does_catch), + {}, +}; + +static struct kunit_module kunit_try_catch_test_module = { + .name = "kunit-try-catch-test", + .init = kunit_try_catch_test_init, + .test_cases = kunit_try_catch_test_cases, +}; +module_test(kunit_try_catch_test_module); -- 2.21.0.392.gf8f6787159e-goog From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-vk1-xa49.google.com ([2607:f8b0:4864:20::a49]) by bombadil.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1hCAZ0-0008WB-1K for linux-um@lists.infradead.org; Thu, 04 Apr 2019 22:10:27 +0000 Received: by mail-vk1-xa49.google.com with SMTP id 62so1668920vkx.16 for ; Thu, 04 Apr 2019 15:10:24 -0700 (PDT) Date: Thu, 4 Apr 2019 15:06:44 -0700 In-Reply-To: <20190404220652.19765-1-brendanhiggins@google.com> Message-Id: <20190404220652.19765-10-brendanhiggins@google.com> Mime-Version: 1.0 References: <20190404220652.19765-1-brendanhiggins@google.com> Subject: [PATCH v1 09/17] kunit: test: add tests for kunit test abort 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, 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 Add KUnit tests for the KUnit test abort mechanism (see preceding commit). Add tests both for general try catch mechanism as well as non-architecture specific mechanism. Signed-off-by: Brendan Higgins --- kunit/Makefile | 3 +- kunit/test-test.c | 135 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+), 1 deletion(-) create mode 100644 kunit/test-test.c diff --git a/kunit/Makefile b/kunit/Makefile index 1f7680cfa11ad..533355867abd2 100644 --- a/kunit/Makefile +++ b/kunit/Makefile @@ -3,6 +3,7 @@ obj-$(CONFIG_KUNIT) += test.o \ kunit-stream.o \ try-catch.o -obj-$(CONFIG_KUNIT_TEST) += string-stream-test.o +obj-$(CONFIG_KUNIT_TEST) += test-test.o \ + string-stream-test.o obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += example-test.o diff --git a/kunit/test-test.c b/kunit/test-test.c new file mode 100644 index 0000000000000..c81ae6efb959f --- /dev/null +++ b/kunit/test-test.c @@ -0,0 +1,135 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * KUnit test for core test infrastructure. + * + * Copyright (C) 2019, Google LLC. + * Author: Brendan Higgins + */ +#include + +struct kunit_try_catch_test_context { + struct kunit_try_catch *try_catch; + bool function_called; +}; + +void kunit_test_successful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +void kunit_test_no_catch(void *data) +{ + struct kunit *test = data; + + KUNIT_FAIL(test, "Catch should not be called.\n"); +} + +static void kunit_test_try_catch_successful_try_no_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_successful_try, + kunit_test_no_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +void kunit_test_unsuccessful_try(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_throw(try_catch); + KUNIT_FAIL(test, "This line should never be reached.\n"); +} + +void kunit_test_catch(void *data) +{ + struct kunit *test = data; + struct kunit_try_catch_test_context *ctx = test->priv; + + ctx->function_called = true; +} + +static void kunit_test_try_catch_unsuccessful_try_does_catch(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + kunit_try_catch_init(try_catch, + test, + kunit_test_unsuccessful_try, + kunit_test_catch); + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_successful_try_no_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_successful_try; + try_catch->catch = kunit_test_no_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static void kunit_test_generic_try_catch_unsuccessful_try_does_catch( + struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx = test->priv; + struct kunit_try_catch *try_catch = ctx->try_catch; + + try_catch->test = test; + kunit_generic_try_catch_init(try_catch); + try_catch->try = kunit_test_unsuccessful_try; + try_catch->catch = kunit_test_catch; + + kunit_try_catch_run(try_catch, test); + + KUNIT_EXPECT_TRUE(test, ctx->function_called); +} + +static int kunit_try_catch_test_init(struct kunit *test) +{ + struct kunit_try_catch_test_context *ctx; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + test->priv = ctx; + + ctx->try_catch = kunit_kmalloc(test, + sizeof(*ctx->try_catch), + GFP_KERNEL); + + return 0; +} + +static struct kunit_case kunit_try_catch_test_cases[] = { + KUNIT_CASE(kunit_test_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_try_catch_unsuccessful_try_does_catch), + KUNIT_CASE(kunit_test_generic_try_catch_successful_try_no_catch), + KUNIT_CASE(kunit_test_generic_try_catch_unsuccessful_try_does_catch), + {}, +}; + +static struct kunit_module kunit_try_catch_test_module = { + .name = "kunit-try-catch-test", + .init = kunit_try_catch_test_init, + .test_cases = kunit_try_catch_test_cases, +}; +module_test(kunit_try_catch_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