X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libtest%2Fframework.cc;h=daea4f4ebfa339edd0d88f3847fe30e5dfbcc999;hb=25efe3485198149616820ab4e52d2f18f0abe5a7;hp=dc9bddd95c1be16f7b2b5e8cb74608092659b132;hpb=bed5d0baa746d10fd3899be96a6ab8673daa7e03;p=m6w6%2Flibmemcached

diff --git a/libtest/framework.cc b/libtest/framework.cc
index dc9bddd9..daea4f4e 100644
--- a/libtest/framework.cc
+++ b/libtest/framework.cc
@@ -1,8 +1,8 @@
 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
- * 
- *  uTest, libtest
  *
- *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ *  Data Differential YATL (i.e. libtest)  library
+ *
+ *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
  *
  *  Redistribution and use in source and binary forms, with or without
  *  modification, are permitted provided that the following conditions are
@@ -34,105 +34,195 @@
  *
  */
 
+#include <config.h>
 
 #include <libtest/common.h>
+#include <libtest/collection.h>
+#include <libtest/signal.h>
+
+#include <fnmatch.h>
 #include <iostream>
 
 using namespace libtest;
 
-static test_return_t _runner_default(test_callback_fn func, void *p)
+Framework::Framework(libtest::SignalThread& signal,
+                     const std::string& only_run_arg,
+                     const std::string& wildcard_arg) :
+  _collections(NULL),
+  _total(0),
+  _success(0),
+  _skipped(0),
+  _failed(0),
+  _create(NULL),
+  _destroy(NULL),
+  _on_error(NULL),
+  _runner(NULL),
+  _socket(false),
+  _creators_ptr(NULL),
+  _signal(signal),
+  _only_run(only_run_arg),
+  _wildcard(wildcard_arg)
 {
-  if (func)
+  get_world(this);
+
+  for (collection_st *next= _collections; next and next->name; next++)
   {
-    return func(p);
+    _collection.push_back(new Collection(this, next));
   }
-
-  return TEST_SUCCESS;
 }
 
-static Runner defualt_runners= {
-  _runner_default,
-  _runner_default,
-  _runner_default
-};
-
-static test_return_t _default_callback(void *p)
+Framework::~Framework()
 {
-  (void)p;
+  if (_destroy and _destroy(_creators_ptr))
+  {
+    Error << "Failure in _destroy(), some resources may not have been cleaned up.";
+  }
+
+  _servers.shutdown();
+
+  delete _runner;
 
-  return TEST_SUCCESS;
+  for (std::vector<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end();
+       ++iter)
+  {
+    delete *iter;
+  }
 }
 
-Framework::Framework() :
-  collections(NULL),
-  _create(NULL),
-  _destroy(NULL),
-  collection_startup(_default_callback),
-  collection_shutdown(_default_callback),
-  _on_error(NULL),
-  runner(&defualt_runners),
-  _creators_ptr(NULL)
+bool Framework::match(const char* arg)
 {
+  if (_wildcard.empty() == false and fnmatch(_wildcard.c_str(), arg, 0))
+  {
+    return true;
+  }
+
+  return false;
 }
 
-Framework::~Framework()
+void Framework::exec()
 {
-  if (_destroy)
+  for (std::vector<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end() and (_signal.is_shutdown() == false);
+       ++iter)
   {
-    if (test_failed(_destroy(_creators_ptr)))
+    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)
     {
-      Error << "Failure in _destroy(), some resources may not have been cleaned up.";
+      _failed++;
+      Error << "Unhandled disconnection occurred:" << e.what();
+      throw;
     }
+    catch (...)
+    {
+      _failed++;
+      throw;
+    }
+
+    Outn();
   }
 }
 
-test_return_t Framework::Item::flush(void* arg, test_st* run)
+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()
 {
-  if (run->requires_flush and _flush)
+  uint32_t count= 0;
+  for (std::vector<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end();
+       ++iter)
   {
-    return _flush(arg);
+    count+= (*iter)->success();
   }
 
-  return TEST_SUCCESS;
+  return count;
 }
 
-test_return_t Framework::on_error(const test_return_t rc, void* arg)
+uint32_t Framework::sum_skipped()
 {
-  if (_on_error and test_failed(_on_error(rc, arg)))
+  uint32_t count= 0;
+  for (std::vector<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end();
+       ++iter)
   {
-    return TEST_FAILURE;
+    count+= (*iter)->skipped();
   }
 
-  return TEST_SUCCESS;
+  return count;
 }
 
-test_return_t Framework::startup(void* arg)
+uint32_t Framework::sum_failed()
 {
-  if (collection_startup)
+  uint32_t count= 0;
+  for (std::vector<Collection*>::iterator iter= _collection.begin();
+       iter != _collection.end();
+       ++iter)
   {
-    return collection_startup(arg);
+    count+= (*iter)->failed();
   }
 
-  return TEST_SUCCESS;
+  return count;
 }
 
-test_return_t Framework::Item::startup(void* arg)
+libtest::Runner *Framework::runner()
 {
-  if (_startup)
+  if (_runner == NULL)
   {
-    return _startup(arg);
+    _runner= new Runner;
   }
+  _runner->set_servers(_servers);
 
-  return TEST_SUCCESS;
+  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(&arg);
+    _creators_ptr= _create(_servers, rc);
   }
 
-  return NULL;
+  return rc;
 }