external/bsd/atf/dist/atf-c++/check.cpp

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2007, 2008, 2009 The NetBSD Foundation, Inc.
   5 // All rights reserved.
   6 //
   7 // Redistribution and use in source and binary forms, with or without
   8 // modification, are permitted provided that the following conditions
   9 // are met:
  10 // 1. Redistributions of source code must retain the above copyright
  11 //    notice, this list of conditions and the following disclaimer.
  12 // 2. Redistributions in binary form must reproduce the above copyright
  13 //    notice, this list of conditions and the following disclaimer in the
  14 //    documentation and/or other materials provided with the distribution.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
  17 // CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  18 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  19 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20 // IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
  21 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
  23 // GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  25 // IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  26 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  27 // IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 //
  29
  30 #include <cstring>
  31
  32 extern "C" {
  33 #include "atf-c/build.h"
  34 #include "atf-c/error.h"
  35 }
  36
  37 #include "atf-c++/check.hpp"
  38 #include "atf-c++/exceptions.hpp"
  39 #include "atf-c++/process.hpp"
  40 #include "atf-c++/sanity.hpp"
  41
  42 namespace impl = atf::check;
  43 #define IMPL_NAME "atf::check"
  44
  45 // ------------------------------------------------------------------------
  46 // The "check_result" class.
  47 // ------------------------------------------------------------------------
  48
  49 impl::check_result::check_result(const atf_check_result_t* result)
  50 {
  51     std::memcpy(&m_result, result, sizeof(m_result));
  52
  53     atf_list_citer_t iter;
  54     atf_list_for_each_c(iter, atf_check_result_argv(&m_result))
  55         m_argv.push_back((const char *)atf_list_citer_data(iter));
  56 }
  57
  58 impl::check_result::~check_result(void)
  59 {
  60     atf_check_result_fini(&m_result);
  61 }
  62
  63 const std::vector< std::string >&
  64 impl::check_result::argv(void)
  65     const
  66 {
  67     return m_argv;
  68 }
  69
  70 bool
  71 impl::check_result::exited(void)
  72     const
  73 {
  74     return atf_check_result_exited(&m_result);
  75 }
  76
  77 int
  78 impl::check_result::exitcode(void)
  79     const
  80 {
  81     PRE(exited());
  82     return atf_check_result_exitcode(&m_result);
  83 }
  84
  85 const atf::fs::path
  86 impl::check_result::stdout_path(void)
  87     const
  88 {
  89     return atf_check_result_stdout(&m_result);
  90 }
  91
  92 const atf::fs::path
  93 impl::check_result::stderr_path(void)
  94         const
  95 {
  96     return atf_check_result_stderr(&m_result);
  97 }
  98
  99 // ------------------------------------------------------------------------
 100 // Free functions.
 101 // ------------------------------------------------------------------------
 102
 103 bool
 104 impl::build_c_o(const atf::fs::path& sfile, const atf::fs::path& ofile,
 105                 const atf::process::argv_array& optargs)
 106 {
 107     bool success;
 108
 109     atf_error_t err = atf_check_build_c_o(sfile.c_str(), ofile.c_str(),
 110                                           optargs.exec_argv(), &success);
 111     if (atf_is_error(err))
 112         throw_atf_error(err);
 113
 114     return success;
 115 }
 116
 117 bool
 118 impl::build_cpp(const atf::fs::path& sfile, const atf::fs::path& ofile,
 119                 const atf::process::argv_array& optargs)
 120 {
 121     bool success;
 122
 123     atf_error_t err = atf_check_build_cpp(sfile.c_str(), ofile.c_str(),
 124                                           optargs.exec_argv(), &success);
 125     if (atf_is_error(err))
 126         throw_atf_error(err);
 127
 128     return success;
 129 }
 130
 131 bool
 132 impl::build_cxx_o(const atf::fs::path& sfile, const atf::fs::path& ofile,
 133                   const atf::process::argv_array& optargs)
 134 {
 135     bool success;
 136
 137     atf_error_t err = atf_check_build_cxx_o(sfile.c_str(), ofile.c_str(),
 138                                             optargs.exec_argv(), &success);
 139     if (atf_is_error(err))
 140         throw_atf_error(err);
 141
 142     return success;
 143 }
 144
 145 impl::check_result
 146 impl::exec(const atf::process::argv_array& argva)
 147 {
 148     atf_check_result_t result;
 149
 150     atf_error_t err = atf_check_exec_array(argva.exec_argv(), &result);
 151     if (atf_is_error(err))
 152         throw_atf_error(err);
 153
 154     return impl::check_result(&result);
 155 }