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

   1 //
   2 // Automated Testing Framework (atf)
   3 //
   4 // Copyright (c) 2007 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 "check.hpp"
  38
  39 #include "detail/exceptions.hpp"
  40 #include "detail/process.hpp"
  41 #include "detail/sanity.hpp"
  42
  43 namespace impl = atf::check;
  44 #define IMPL_NAME "atf::check"
  45
  46 // ------------------------------------------------------------------------
  47 // The "check_result" class.
  48 // ------------------------------------------------------------------------
  49
  50 impl::check_result::check_result(const atf_check_result_t* result)
  51 {
  52     std::memcpy(&m_result, result, sizeof(m_result));
  53 }
  54
  55 impl::check_result::~check_result(void)
  56 {
  57     atf_check_result_fini(&m_result);
  58 }
  59
  60 bool
  61 impl::check_result::exited(void)
  62     const
  63 {
  64     return atf_check_result_exited(&m_result);
  65 }
  66
  67 int
  68 impl::check_result::exitcode(void)
  69     const
  70 {
  71     PRE(exited());
  72     return atf_check_result_exitcode(&m_result);
  73 }
  74
  75 bool
  76 impl::check_result::signaled(void)
  77     const
  78 {
  79     return atf_check_result_signaled(&m_result);
  80 }
  81
  82 int
  83 impl::check_result::termsig(void)
  84     const
  85 {
  86     PRE(signaled());
  87     return atf_check_result_termsig(&m_result);
  88 }
  89
  90 const std::string
  91 impl::check_result::stdout_path(void) const
  92 {
  93     return atf_check_result_stdout(&m_result);
  94 }
  95
  96 const std::string
  97 impl::check_result::stderr_path(void) const
  98 {
  99     return atf_check_result_stderr(&m_result);
 100 }
 101
 102 // ------------------------------------------------------------------------
 103 // Free functions.
 104 // ------------------------------------------------------------------------
 105
 106 bool
 107 impl::build_c_o(const std::string& sfile, const std::string& ofile,
 108                 const atf::process::argv_array& optargs)
 109 {
 110     bool success;
 111
 112     atf_error_t err = atf_check_build_c_o(sfile.c_str(), ofile.c_str(),
 113                                           optargs.exec_argv(), &success);
 114     if (atf_is_error(err))
 115         throw_atf_error(err);
 116
 117     return success;
 118 }
 119
 120 bool
 121 impl::build_cpp(const std::string& sfile, const std::string& ofile,
 122                 const atf::process::argv_array& optargs)
 123 {
 124     bool success;
 125
 126     atf_error_t err = atf_check_build_cpp(sfile.c_str(), ofile.c_str(),
 127                                           optargs.exec_argv(), &success);
 128     if (atf_is_error(err))
 129         throw_atf_error(err);
 130
 131     return success;
 132 }
 133
 134 bool
 135 impl::build_cxx_o(const std::string& sfile, const std::string& ofile,
 136                   const atf::process::argv_array& optargs)
 137 {
 138     bool success;
 139
 140     atf_error_t err = atf_check_build_cxx_o(sfile.c_str(), ofile.c_str(),
 141                                             optargs.exec_argv(), &success);
 142     if (atf_is_error(err))
 143         throw_atf_error(err);
 144
 145     return success;
 146 }
 147
 148 std::auto_ptr< impl::check_result >
 149 impl::exec(const atf::process::argv_array& argva)
 150 {
 151     atf_check_result_t result;
 152
 153     atf_error_t err = atf_check_exec_array(argva.exec_argv(), &result);
 154     if (atf_is_error(err))
 155         throw_atf_error(err);
 156
 157     return std::auto_ptr< impl::check_result >(new impl::check_result(&result));
 158 }