libtest: fix doesnotexist spawn test

[awesomized/libmemcached] / libtest / framework.cc

diff --git a/libtest/framework.cc b/libtest/framework.cc
index 3bab5f0ad3f414f702529f1994c842a4847a746f..2c9ba74b4aebc346b40856eb51b358a4263077a0 100644 (file)
--- a/libtest/framework.cc
+++ b/libtest/framework.cc
@@ -34,20 +34,46 @@
  *
  */
 
-#include <config.h>
+#include "libtest/yatlcon.h"
+
 #include <libtest/common.h>
+#include <libtest/collection.h>
+#include <libtest/signal.h>
+
+#include <algorithm>
+#include <fnmatch.h>
 #include <iostream>
 
-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()
@@ -60,6 +86,127 @@ Framework::~Framework()
   _servers.shutdown();
 
   delete _runner;
+
+  std::for_each(_collection.begin(), _collection.end(), DeleteFromVector());
+  _collection.clear();
+}
+
+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<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end() and (_signal.is_shutdown() == false);
+       ++iter)
+  {
+    if (*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 (const libtest::fatal& e)
+      {
+        _failed++;
+        stream::cerr(e.file(), e.line(), e.func()) << e.what();
+      }
+      catch (const libtest::disconnected& e)
+      {
+        _failed++;
+        Error << "Unhandled disconnection occurred:" << e.what();
+        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<Collection*>::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<Collection*>::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<Collection*>::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<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end();
+       ++iter)
+  {
+    count+= (*iter)->failed();
+  }
+
+  return count;
 }
 
 libtest::Runner *Framework::runner()
@@ -73,13 +220,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