From patchwork Sat Mar 22 12:27:07 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Daniel Vetter X-Patchwork-Id: 3877471 Return-Path: X-Original-To: patchwork-intel-gfx@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.19.201]) by patchwork1.web.kernel.org (Postfix) with ESMTP id C65239F334 for ; Sat, 22 Mar 2014 12:27:23 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id AE2BA202D1 for ; Sat, 22 Mar 2014 12:27:22 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id E3A5A201BA for ; Sat, 22 Mar 2014 12:27:20 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 13A966E507; Sat, 22 Mar 2014 05:27:19 -0700 (PDT) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mail-ee0-f50.google.com (mail-ee0-f50.google.com [74.125.83.50]) by gabe.freedesktop.org (Postfix) with ESMTP id 40CE86E507 for ; Sat, 22 Mar 2014 05:27:17 -0700 (PDT) Received: by mail-ee0-f50.google.com with SMTP id c13so2681349eek.37 for ; Sat, 22 Mar 2014 05:27:15 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ffwll.ch; s=google; h=from:to:cc:subject:date:message-id:mime-version:content-type :content-transfer-encoding; bh=Hs4dceVYhV7jBCkGmSY8yIT9EQXF7yISgnr37sKeM2g=; b=TEa8Vn3BAIF31e1tuRpI6xeoKVy08TpRBQSOhTFA1zsz2RJdZv3H6mTzgaJBTU6ngG FLRrzHGI9owlF+EyNkyNv+F/ML6wdzyBeQo4Yxkpk+GVmkkXc2Xu4SV2ZKWhVPVXcR+p xz499PgsRujv9/wCAk0wfASmwkwWoZLyoCc2Y= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-type:content-transfer-encoding; bh=Hs4dceVYhV7jBCkGmSY8yIT9EQXF7yISgnr37sKeM2g=; b=d/RNh11ixIm4G+NWHEiiimQ3JpZ7FrmWoNscLjHROqje4mbHwPSImHyhnAeYNGLtKV tHKaRM2Uf7rCImq8EIQkMldlovmEski4P4DlyGivfDUyzlXgirNMTQJcOiihTyzTwnwt NylP9to5E7CTgAyAVq3mfS4pclR5iHMDXX7dgoOa7unBW9sGRB15wI9BZz7YwcV8dn3o 8Q53GpM8JHxKXN7TjlKDgJL+vqigM09FKLbcUX5azLA8vL9g5faUA8bwFqMAV2vVAXCR u6RxnY9fVuLUcfpSuFEQ6qhRH95aUIN0XDi7UlE79k7SGku2nUDr7YQ41stcU5wzd5qn fjLw== X-Gm-Message-State: ALoCoQmzAvJ5RuIAyOxgE0yCWIiBUdGPtiEfKez5ArLmg/9nxVBXwjvbfTTfmraSUEcNM+0v+bYz X-Received: by 10.14.206.137 with SMTP id l9mr53877272eeo.40.1395491235162; Sat, 22 Mar 2014 05:27:15 -0700 (PDT) Received: from phenom.ffwll.local (84-73-67-144.dclient.hispeed.ch. [84.73.67.144]) by mx.google.com with ESMTPSA id 4sm18613915eeq.33.2014.03.22.05.27.13 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Sat, 22 Mar 2014 05:27:14 -0700 (PDT) From: Daniel Vetter To: Intel Graphics Development Date: Sat, 22 Mar 2014 13:27:07 +0100 Message-Id: <1395491227-29513-1-git-send-email-daniel.vetter@ffwll.ch> X-Mailer: git-send-email 1.8.5.2 MIME-Version: 1.0 Cc: Daniel Vetter , Ben Widawsky Subject: [Intel-gfx] [PATCH] lib: allow igt_skip_on_simulation outside of fixtures. X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Spam-Status: No, score=-4.1 required=5.0 tests=BAYES_00,DKIM_SIGNED, RCVD_IN_DNSWL_MED, T_DKIM_INVALID, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP Thomas noticed that in simulation mode a lot of the tests fall over instead of skipping properly. This is due to recently added self-checks which ensure that any call to igt_skip happens either within a fixture or subtest block (or it's a simple test without subtests). This is to catch bugs since pretty much always not wrapping up hardware setup and checks into these blocks is a bug. Bug simulation skipping is a bit different, so allow that exception. Otherwise we'd need to fix up piles of tests (and likely need to play a game of whack-a-mole). Also add a library testcase for all the different variants to make sure it really works. Cc: Thomas Wood Cc: Ben Widawsky Signed-off-by: Daniel Vetter Acked-by: Ben Widawsky --- lib/igt_core.c | 12 ++++- tests/.gitignore | 1 + tests/Makefile.sources | 1 + tests/igt_simulation.c | 139 +++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 152 insertions(+), 1 deletion(-) create mode 100644 tests/igt_simulation.c diff --git a/lib/igt_core.c b/lib/igt_core.c index bdace83ab382..dbfcd74f9160 100644 --- a/lib/igt_core.c +++ b/lib/igt_core.c @@ -1117,13 +1117,23 @@ bool igt_run_in_simulation(void) * * Skip tests when INTEL_SIMULATION environment variable is set. It uses * igt_skip() internally and hence is fully subtest aware. + * + * Note that in contrast to all other functions which use igt_skip() internally + * it is allowed to use this outside of an #igt_fixture block in a test with + * subtests. This is because in contrast to most other test requirements, + * checking for simulation mode doesn't depend upon the present hardware and it + * so makes a lot of sense to have this check in the outermost #igt_main block. */ void igt_skip_on_simulation(void) { if (igt_only_list_subtests()) return; - igt_require(!igt_run_in_simulation()); + if (!in_fixture) { + igt_fixture + igt_require(!igt_run_in_simulation()); + } else + igt_require(!igt_run_in_simulation()); } /* structured logging */ diff --git a/tests/.gitignore b/tests/.gitignore index 623a621ccace..60aa3b497f88 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -107,6 +107,7 @@ igt_list_only igt_no_exit igt_no_exit_list_only igt_no_subtest +igt_simulation kms_addfb kms_cursor_crc kms_fbc_crc diff --git a/tests/Makefile.sources b/tests/Makefile.sources index 88866ac7ea75..8aeaac0ed15f 100644 --- a/tests/Makefile.sources +++ b/tests/Makefile.sources @@ -179,6 +179,7 @@ TESTS_testsuite = \ igt_fork_helper \ igt_list_only \ igt_no_subtest \ + igt_simulation \ $(NULL) TESTS = \ diff --git a/tests/igt_simulation.c b/tests/igt_simulation.c new file mode 100644 index 000000000000..b9c6241d12e4 --- /dev/null +++ b/tests/igt_simulation.c @@ -0,0 +1,139 @@ +/* + * Copyright © 2014 Intel Corporation + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice (including the next + * paragraph) shall be included in all copies or substantial portions of the + * Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + * IN THE SOFTWARE. + * + * Authors: + * Daniel Vetter + * + */ + +#include +#include +#include + +#include "drmtest.h" +#include "igt_core.h" + +bool simple; +bool list_subtests; +bool in_fixture; + +char test[] = "test"; +char list[] = "--list-subtests"; +char *argv_list[] = { test, list }; +char *argv_run[] = { test }; + +static int do_fork(void) +{ + int pid, status; + + switch (pid = fork()) { + case -1: + assert(0); + case 0: + if (simple) { + igt_simple_init(); + + igt_skip_on_simulation(); + + exit(0); + } else { + if (list_subtests) + igt_subtest_init(2, argv_list); + else + igt_subtest_init(1, argv_run); + + if (in_fixture) { + igt_fixture + igt_skip_on_simulation(); + } else + igt_skip_on_simulation(); + + igt_subtest("foo") + ; + + printf("baz\n"); + igt_exit(); + } + default: + while (waitpid(pid, &status, 0) == -1 && + errno == EINTR) + ; + + assert(WIFEXITED(status)); + + return WEXITSTATUS(status); + } +} + +int main(int argc, char **argv) +{ + /* simple tests */ + simple = true; + assert(setenv("INTEL_SIMULATION", "1", 1) == 0); + assert(do_fork() == 77); + + assert(setenv("INTEL_SIMULATION", "0", 1) == 0); + assert(do_fork() == 0); + + /* subtests, list mode */ + simple = false; + list_subtests = true; + + in_fixture = false; + assert(setenv("INTEL_SIMULATION", "1", 1) == 0); + assert(do_fork() == 0); + + in_fixture = false; + assert(setenv("INTEL_SIMULATION", "0", 1) == 0); + assert(do_fork() == 0); + + in_fixture = true; + assert(setenv("INTEL_SIMULATION", "1", 1) == 0); + assert(do_fork() == 0); + + in_fixture = true; + assert(setenv("INTEL_SIMULATION", "0", 1) == 0); + assert(do_fork() == 0); + + /* subtest, run mode */ + simple = false; + list_subtests = false; + + in_fixture = false; + assert(setenv("INTEL_SIMULATION", "1", 1) == 0); + assert(do_fork() == 77); + + in_fixture = false; + assert(setenv("INTEL_SIMULATION", "0", 1) == 0); + assert(do_fork() == 0); + + in_fixture = true; + assert(setenv("INTEL_SIMULATION", "1", 1) == 0); + assert(do_fork() == 77); + + in_fixture = true; + assert(setenv("INTEL_SIMULATION", "0", 1) == 0); + assert(do_fork() == 0); + + + return 0; +}