external/bsd/atf/dist/atf-c++/detail/test_helpers.cpp
author jmmv <jmmv@NetBSD.org>
Wed, 11 Jul 2012 22:37:05 +0000
branchtrunk
changeset 211918 3b6c919e0f27
parent 208235 d54a1a396a20
child 216782 87ba7be54a87
child 280393 591e5f54cb27
permissions -rw-r--r--
Import atf 0.16: Experimental version released on July 10th, 2012. * Added a --enable-tools flag to configure to request the build of the deprecated ATF tools, whose build is now disabled by default. In order to continue running tests, you should migrate to Kyua instead of enabling the build of the deprecated tools. The kyua-atf-compat package provides transitional compatibility versions of atf-run and atf-report built on top of Kyua. * Tweaked the ATF_TEST_CASE macro of atf-c++ so that the compiler can detect defined but unused test cases. * PR bin/45859: Fixed some XSLT bugs that resulted in the tc-time and tp-time XML tags leaking into the generated HTML file. Also improved the CSS file slightly to correct alignment and color issues with the timestamps column. * Optimized atf-c++/macros.hpp so that GNU G++ consumes less memory during compilation with GNU G++. * Flipped the default to building shared libraries for atf-c and atf-c++, and started versioning them. As a side-effect, this removes the --enable-unstable-shared flag from configure that appears to not work any more (under NetBSD). Additionally, some distributions require the use of shared libraries for proper dependency tracking (e.g. Fedora), so it is better if we do the right versioning upstream. * Project hosting moved from an adhoc solution (custom web site and Monotone repository) to Google Code (standard wiki and Git). ATF now lives in a subcomponent of the Kyua project.

//
// Automated Testing Framework (atf)
//
// Copyright (c) 2009 The NetBSD Foundation, Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
// CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
// IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
// GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
// IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
// IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//

extern "C" {
#include <regex.h>
}

#include <fstream>
#include <iostream>
#include <string>
#include <vector>

#include "../check.hpp"
#include "../config.hpp"
#include "../macros.hpp"

#include "fs.hpp"
#include "process.hpp"
#include "test_helpers.hpp"

void
build_check_cxx_o_aux(const atf::fs::path& sfile, const char* failmsg,
                      const bool expect_pass)
{
    std::vector< std::string > optargs;
    optargs.push_back("-I" + atf::config::get("atf_includedir"));
    optargs.push_back("-Wall");
    optargs.push_back("-Werror");

    const bool result = atf::check::build_cxx_o(
        sfile.str(), "test.o", atf::process::argv_array(optargs));
    if ((expect_pass && !result) || (!expect_pass && result))
        ATF_FAIL(failmsg);
}

void
build_check_cxx_o(const atf::tests::tc& tc, const char* sfile,
                  const char* failmsg, const bool expect_pass)
{
    const atf::fs::path sfilepath =
        atf::fs::path(tc.get_config_var("srcdir")) / sfile;
    build_check_cxx_o_aux(sfilepath, failmsg, expect_pass);
}

void
header_check(const char *hdrname)
{
    std::ofstream srcfile("test.c");
    ATF_REQUIRE(srcfile);
    srcfile << "#include <" << hdrname << ">\n";
    srcfile.close();

    const std::string failmsg = std::string("Header check failed; ") +
        hdrname + " is not self-contained";
    build_check_cxx_o_aux(atf::fs::path("test.c"), failmsg.c_str(), true);
}

atf::fs::path
get_process_helpers_path(const atf::tests::tc& tc)
{
    return atf::fs::path(tc.get_config_var("srcdir")) /
           ".." / "atf-c" / "detail" / "process_helpers";
}

bool
grep_file(const char* name, const char* regex)
{
    std::ifstream is(name);
    ATF_REQUIRE(is);

    bool found = false;

    std::string line;
    std::getline(is, line);
    while (!found && is.good()) {
        if (grep_string(line, regex))
            found = true;
        else
            std::getline(is, line);
    }

    return found;
}

bool
grep_string(const std::string& str, const char* regex)
{
    int res;
    regex_t preg;

    std::cout << "Looking for '" << regex << "' in '" << str << "'\n";
    ATF_REQUIRE(::regcomp(&preg, regex, REG_EXTENDED) == 0);

    res = ::regexec(&preg, str.c_str(), 0, NULL, 0);
    ATF_REQUIRE(res == 0 || res == REG_NOMATCH);

    ::regfree(&preg);

    return res == 0;
}

void
test_helpers_detail::check_equal(const char* expected[],
                                 const string_vector& actual)
{
    const char** expected_iter = expected;
    string_vector::const_iterator actual_iter = actual.begin();

    bool equals = true;
    while (equals && *expected_iter != NULL && actual_iter != actual.end()) {
        if (*expected_iter != *actual_iter) {
            equals = false;
        } else {
            expected_iter++;
            actual_iter++;
        }
    }
    if (equals && ((*expected_iter == NULL && actual_iter != actual.end()) ||
                   (*expected_iter != NULL && actual_iter == actual.end())))
        equals = false;

    if (!equals) {
        std::cerr << "EXPECTED:\n";
        for (expected_iter = expected; *expected_iter != NULL; expected_iter++)
            std::cerr << *expected_iter << "\n";

        std::cerr << "ACTUAL:\n";
        for (actual_iter = actual.begin(); actual_iter != actual.end();
             actual_iter++)
            std::cerr << *actual_iter << "\n";

        ATF_FAIL("Expected results differ to actual values");
    }
}