← Back to branch summary

~brianaker/gearmand/warning-usage

« back to all changes in this revision

Viewing changes to libtest/framework.cc

  • Committer: Brian Aker
  • Date: 2012-05-04 03:46:04 UTC
  • Revision ID: brian@tangent.org-20120504034604-5t22ae4v2o45zjkq
Update for libtest, documentation, and fix for root bzr dir.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libtest/framework.cc
35
35
 */
36
36
 
37
37
#include <config.h>
 
38
 
38
39
#include <libtest/common.h>
 
40
#include <libtest/collection.h>
 
41
#include <libtest/signal.h>
 
42
 
 
43
#include <fnmatch.h>
39
44
#include <iostream>
40
45
 
41
46
using namespace libtest;
42
47
 
43
 
Framework::Framework() :
 
48
Framework::Framework(libtest::SignalThread& signal,
 
49
                     const std::string& only_run_arg,
 
50
                     const std::string& wildcard_arg) :
44
51
  collections(NULL),
 
52
  _total(0),
 
53
  _success(0),
 
54
  _skipped(0),
 
55
  _failed(0),
45
56
  _create(NULL),
46
57
  _destroy(NULL),
47
58
  _runner(NULL),
48
59
  _socket(false),
49
 
  _creators_ptr(NULL)
 
60
  _creators_ptr(NULL),
 
61
  _signal(signal),
 
62
  _only_run(only_run_arg),
 
63
  _wildcard(wildcard_arg)
50
64
{
 
65
  get_world(this);
 
66
 
 
67
  for (collection_st *next= collections; next and next->name; next++)
 
68
  {
 
69
    _collection.push_back(new Collection(this, next));
 
70
  }
51
71
}
52
72
 
53
73
Framework::~Framework()
60
80
  _servers.shutdown();
61
81
 
62
82
  delete _runner;
 
83
 
 
84
  for (std::vector<Collection*>::iterator iter= _collection.begin();
 
85
       iter != _collection.end();
 
86
       iter++)
 
87
  {
 
88
    delete *iter;
 
89
  }
 
90
}
 
91
 
 
92
bool Framework::match(const char* arg)
 
93
{
 
94
  if (_wildcard.empty() == false and fnmatch(_wildcard.c_str(), arg, 0))
 
95
  {
 
96
    return true;
 
97
  }
 
98
 
 
99
  return false;
 
100
}
 
101
 
 
102
void Framework::exec()
 
103
{
 
104
  for (std::vector<Collection*>::iterator iter= _collection.begin();
 
105
       iter != _collection.end() and (_signal.is_shutdown() == false);
 
106
       iter++)
 
107
  {
 
108
    if (_only_run.empty() == false and
 
109
        fnmatch(_only_run.c_str(), (*iter)->name(), 0))
 
110
    {
 
111
      continue;
 
112
    }
 
113
 
 
114
    _total++;
 
115
 
 
116
    try {
 
117
      switch ((*iter)->exec())
 
118
      {
 
119
      case TEST_FAILURE:
 
120
        _failed++;
 
121
        break;
 
122
 
 
123
      case TEST_SKIPPED:
 
124
        _skipped++;
 
125
        break;
 
126
 
 
127
        // exec() can return SUCCESS, but that doesn't mean that some tests did
 
128
        // not fail or get skipped.
 
129
      case TEST_SUCCESS:
 
130
        _success++;
 
131
        break;
 
132
      }
 
133
    }
 
134
    catch (libtest::fatal& e)
 
135
    {
 
136
      stream::cerr(e.file(), e.line(), e.func()) << e.mesg();
 
137
    }
 
138
    catch (libtest::disconnected& e)
 
139
    {
 
140
      Error << "Unhandled disconnection occurred:" << e.what();
 
141
      throw;
 
142
    }
 
143
 
 
144
    Outn();
 
145
  }
 
146
}
 
147
 
 
148
uint32_t Framework::sum_total()
 
149
{
 
150
  uint32_t count= 0;
 
151
  for (std::vector<Collection*>::iterator iter= _collection.begin();
 
152
       iter != _collection.end();
 
153
       iter++)
 
154
  {
 
155
    count+= (*iter)->total();
 
156
  }
 
157
 
 
158
  return count;
 
159
}
 
160
 
 
161
uint32_t Framework::sum_success()
 
162
{
 
163
  uint32_t count= 0;
 
164
  for (std::vector<Collection*>::iterator iter= _collection.begin();
 
165
       iter != _collection.end();
 
166
       iter++)
 
167
  {
 
168
    count+= (*iter)->success();
 
169
  }
 
170
 
 
171
  return count;
 
172
}
 
173
 
 
174
uint32_t Framework::sum_skipped()
 
175
{
 
176
  uint32_t count= 0;
 
177
  for (std::vector<Collection*>::iterator iter= _collection.begin();
 
178
       iter != _collection.end();
 
179
       iter++)
 
180
  {
 
181
    count+= (*iter)->skipped();
 
182
  }
 
183
 
 
184
  return count;
 
185
}
 
186
 
 
187
uint32_t Framework::sum_failed()
 
188
{
 
189
  uint32_t count= 0;
 
190
  for (std::vector<Collection*>::iterator iter= _collection.begin();
 
191
       iter != _collection.end();
 
192
       iter++)
 
193
  {
 
194
    count+= (*iter)->failed();
 
195
  }
 
196
 
 
197
  return count;
63
198
}
64
199
 
65
200
libtest::Runner *Framework::runner()
73
208
  return _runner;
74
209
}
75
210
 
76
 
void* Framework::create(test_return_t& arg)
 
211
test_return_t Framework::create()
77
212
{
78
 
  arg= TEST_SUCCESS;
 
213
  test_return_t rc= TEST_SUCCESS;
79
214
  if (_create)
80
215
  {
81
 
    return _creators_ptr= _create(_servers, arg);
 
216
    _creators_ptr= _create(_servers, rc);
82
217
  }
83
218
 
84
 
  return NULL;
 
219
  return rc;
85
220
}