X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Fframework.cc;h=6cca8450abcbcffbc4a7672518acb96a668c0f0f;hb=35811e5efa56436f7f0e03c68bc8cf78f2b2c1c4;hp=b9d817b5ab457e9d01178312941a5f56b036046f;hpb=fe4757c512265eef4f8905b3392f19d33c436ddf;p=awesomized%2Flibmemcached diff --git a/libtest/framework.cc b/libtest/framework.cc index b9d817b5..6cca8450 100644 --- a/libtest/framework.cc +++ b/libtest/framework.cc @@ -1,39 +1,78 @@ /* vim:expandtab:shiftwidth=2:tabstop=2:smarttab: - * - * libtest * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Data Differential YATL (i.e. libtest) library * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 3 of the License, or (at your option) any later version. + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * 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. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT + * OWNER 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. * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ - #include + #include +#include +#include + +#include #include -using namespace libtest; +namespace libtest { -Framework::Framework() : - collections(NULL), +Framework::Framework(libtest::SignalThread& signal_, + const std::string& name_, + const std::string& only_run_arg, + const std::string& wildcard_arg) : + _total(0), + _success(0), + _skipped(0), + _failed(0), _create(NULL), _destroy(NULL), + _on_error(NULL), _runner(NULL), _socket(false), - _creators_ptr(NULL) + _creators_ptr(NULL), + _signal(signal_), + _only_run(only_run_arg), + _wildcard(wildcard_arg), + _name(name_) { + get_world(this); +} + +void Framework::collections(collection_st* collections_) +{ + for (collection_st *next= collections_; next and next->name; next++) + { + _collection.push_back(new Collection(this, next)); + } } Framework::~Framework() @@ -46,6 +85,129 @@ Framework::~Framework() _servers.shutdown(); delete _runner; + + for (std::vector::iterator iter= _collection.begin(); + iter != _collection.end(); + ++iter) + { + delete *iter; + } +} + +bool Framework::match(const char* arg) +{ + if (_wildcard.empty() == false and fnmatch(_wildcard.c_str(), arg, 0)) + { + return true; + } + + return false; +} + +void Framework::exec() +{ + for (std::vector::iterator iter= _collection.begin(); + iter != _collection.end() and (_signal.is_shutdown() == false); + ++iter) + { + if (_only_run.empty() == false and + fnmatch(_only_run.c_str(), (*iter)->name(), 0)) + { + continue; + } + + _total++; + + try + { + switch ((*iter)->exec()) + { + case TEST_FAILURE: + _failed++; + break; + + case TEST_SKIPPED: + _skipped++; + break; + + // exec() can return SUCCESS, but that doesn't mean that some tests did + // not fail or get skipped. + case TEST_SUCCESS: + _success++; + break; + } + } + catch (libtest::fatal& e) + { + _failed++; + stream::cerr(e.file(), e.line(), e.func()) << e.mesg(); + } + catch (libtest::disconnected& e) + { + _failed++; + stream::cerr(e.file(), e.line(), e.func()) << "Unhandled disconnection occurred: " << e.mesg(); + throw; + } + catch (...) + { + _failed++; + throw; + } + } + + void xml(const std::string& testsuites_name, std::ostream& output); +} + +uint32_t Framework::sum_total() +{ + uint32_t count= 0; + for (std::vector::iterator iter= _collection.begin(); + iter != _collection.end(); + ++iter) + { + count+= (*iter)->total(); + } + + return count; +} + +uint32_t Framework::sum_success() +{ + uint32_t count= 0; + for (std::vector::iterator iter= _collection.begin(); + iter != _collection.end(); + ++iter) + { + count+= (*iter)->success(); + } + + return count; +} + +uint32_t Framework::sum_skipped() +{ + uint32_t count= 0; + for (std::vector::iterator iter= _collection.begin(); + iter != _collection.end(); + ++iter) + { + count+= (*iter)->skipped(); + } + + return count; +} + +uint32_t Framework::sum_failed() +{ + uint32_t count= 0; + for (std::vector::iterator iter= _collection.begin(); + iter != _collection.end(); + ++iter) + { + count+= (*iter)->failed(); + } + + return count; } libtest::Runner *Framework::runner() @@ -59,13 +221,15 @@ libtest::Runner *Framework::runner() return _runner; } -void* Framework::create(test_return_t& arg) +test_return_t Framework::create() { - arg= TEST_SUCCESS; + test_return_t rc= TEST_SUCCESS; if (_create) { - return _creators_ptr= _create(_servers, arg); + _creators_ptr= _create(_servers, rc); } - return NULL; + return rc; } + +} // namespace libtest