Update copyright to LGPL on all files
[dyninst.git] / testsuite / src / TestOutputDriver.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31 #include "TestOutputDriver.h"
32
33 #include <map>
34 #include <string>
35
36 #include "test_info_new.h"
37
38 static void parseLabel(std::map<std::string, std::string> *attrs,
39                        char *label);
40 static void parseLabel2(std::map<std::string, std::string> *attrs,
41                         std::string label);
42 static void parseLabel3(std::map<std::string, std::string> *attrs,
43                         std::string label);
44
45 static void parseLabel(std::map<std::string, std::string> *attrs,
46                        char *label) {
47   parseLabel2(attrs, std::string(label));
48 }
49
50 static void parseLabel2(std::map<std::string, std::string> *attrs,
51                         std::string label) {
52   // This method is supposed to strip off the enclosing { and } and any
53   // whitespace at the beginning or end of the label string
54   std::string::size_type start = label.find_first_not_of("{ \t\n");
55   std::string::size_type end = label.find_last_not_of("} \t\n");
56   std::string stripped_label = label.substr(start, end - start + 1);
57   parseLabel3(attrs, stripped_label);
58 }
59
60 static void parseLabel3(std::map<std::string, std::string> *attrs,
61                         std::string label) {
62   // Now parse the first element in the label and recursively call this guy
63   // until we get to an empty string
64   if (label.empty()) { // Base case for recursion
65     // There's an error here in my recursion base case
66     return;
67   } else {
68     // Find the first comma in label; that's where our first attribute
69     std::string::size_type first_comma = label.find(',', 0);
70     // first_comma points to the comma character (one past the last character
71     // we want to look at)
72     if (std::string::npos == first_comma) {
73       // If there's no comma, we'll look at the whole string
74       first_comma = label.length();
75       // first_comma points to the "null" (one past the last character we want
76       // to look at)
77     }
78     // Name of the attribute starts at index 0
79     std::string::size_type key_start = 0;
80     std::string::size_type key_end = label.find(": ", 0);
81     std::string::size_type val_start = key_end + 2;
82     std::string::size_type val_end = first_comma;
83     attrs->insert(make_pair(label.substr(key_start, key_end - key_start),
84                             label.substr(val_start, val_end - val_start)));
85     // TODO Set label to the string starting with the next attribute and make
86     // the recursive call
87     std::string next_attr = label.substr(first_comma);
88     // Strip off the comma and any whitespace after it
89     std::string::size_type fix_index;
90     if ((fix_index = next_attr.find_first_not_of(", \t\n")) != std::string::npos) {
91       next_attr = next_attr.substr(fix_index);
92     }
93     parseLabel3(attrs, next_attr);
94   }
95 }
96
97 TESTLIB_DLL_EXPORT bool TestOutputDriver::getAttributesMap(TestInfo *test, 
98                 RunGroup *group, std::map<std::string, std::string> &attrs) {
99   if ((NULL == test) || (NULL == test->label)) {
100     return false;
101   }
102
103   // Fill in attributes corresponding to the TestInfo object
104   // Ugh.  To do this properly I need to either parse TestInfo's label field
105   // or change how TestInfo is constructed so it takes all the attributes I'm
106   // interested in.  I think I'd be better off parsing the label field, so we
107   // don't need to change TestInfo whenever build parameters change.
108   // What's a good way to parse a string using C++?
109   parseLabel(&attrs, const_cast<char *>(test->label));
110   return true;
111 }
112
113 TESTLIB_DLL_EXPORT void TestOutputDriver::getMutateeArgs(std::vector<std::string> &args) {
114   args.clear();
115 }