Add more unit tests (LLNL#243)

* Add more tests

* Remove replicated code

Author: daboehme

src/tools/cali-query/query_common.cpp

@@ -13,6 +13,8 @@
 #include "caliper/common/Log.h"
 #include "caliper/common/util/split.hpp"
 
+#include "../../common/util/parse_util.h"
+
 #include "../../services/Services.h"
 
 #include "caliper/ConfigManager.h"
@@ -27,61 +29,14 @@ using namespace util;
 namespace
 {
 
-inline bool
-is_one_of(char c, const char* characters)
-{
-    for (const char* ptr = characters; *ptr != '\0'; ++ptr)
-        if (*ptr == c)
-            return true;
-
-    return false;
-}
-
-/// \brief Read next character, ignoring whitespace
-char
-parse_char(std::istream& is)
-{
-    char ret = '\0';
-
-    do {
-        ret = is.get();
-    } while (is.good() && isspace(ret));
-    
-    return ret;
-}
-
-/// \brief Parse text from stream, ignoring whitespace, until one of ",()" are found
-std::string
-parse_word(std::istream& is)
-{
-    std::string ret;
-
-    while (is.good()) {
-        auto c = is.get();
-
-        if (!is.good())
-            break;
-        if (isspace(c))
-            continue;
-        if (is_one_of(c, ",()\n")) {
-            is.unget();
-            break;
-        }
-
-        ret.push_back(c);
-    }
-
-    return ret;
-}
-
 /// \brief Parse "(arg1, arg2, ...)" argument list, ignoring whitespace
 std::vector<std::string>
 parse_arglist(std::istream& is)
 {
     std::vector<std::string> ret;
     std::string word;
 
-    char c = parse_char(is);
+    char c = util::read_char(is);
 
     if (!is.good())
         return ret;
@@ -90,10 +45,10 @@ parse_arglist(std::istream& is)
         is.unget();
         return ret;
     }
-    
+
     do {
-        std::string str = parse_word(is);
-        c = parse_char(is);
+        std::string str = util::read_word(is, ",()");
+        c = util::read_char(is);
 
         if (!str.empty() && (c == ',' || c == ')'))
             ret.push_back(str);
@@ -103,20 +58,20 @@ parse_arglist(std::istream& is)
         is.unget();
         ret.clear();
     }
-    
+
     return ret;
 }
 
 std::pair< int, std::vector<std::string> >
 parse_functioncall(std::istream& is, const QuerySpec::FunctionSignature* defs)
 {
     // read function name
-    std::string fname = parse_word(is);
+    std::string fname = util::read_word(is, ",()");
 
     if (fname.empty())
         return std::make_pair(-1, std::vector<std::string>());
 
-    // find function among given signatures    
+    // find function among given signatures
     int retid = 0;
 
     for ( ; defs && defs[retid].name && (fname != defs[retid].name); ++retid)
@@ -127,7 +82,7 @@ parse_functioncall(std::istream& is, const QuerySpec::FunctionSignature* defs)
         return std::make_pair(-1, std::vector<std::string>());
     }
 
-    // read argument list    
+    // read argument list
     std::vector<std::string> args = parse_arglist(is);
     int argsize = static_cast<int>(args.size());
 
@@ -159,7 +114,7 @@ QueryArgsParser::parse_args(const Args& args)
 
     m_error = false;
     m_error_msg.clear();
-    
+
     // parse CalQL query (if any)
 
     if (args.is_set("query")) {
@@ -173,23 +128,23 @@ QueryArgsParser::parse_args(const Args& args)
         } else
             m_spec = p.spec();
     }
-    
+
     // setup filter
 
     if (args.is_set("select")) {
         m_spec.filter.selection = QuerySpec::FilterSelection::List;
         m_spec.filter.list      = RecordSelector::parse(args.get("select"));
     }
-    
+
     // setup attribute selection
-    
+
     if (args.is_set("attributes")) {
         m_spec.attribute_selection.selection = QuerySpec::AttributeSelection::List;
         util::split(args.get("attributes"), ',', std::back_inserter(m_spec.attribute_selection.list));
     }
-    
+
     // setup aggregation
-    
+
     if (args.is_set("aggregate")) {
         // aggregation ops
         m_spec.aggregation_ops.selection = QuerySpec::AggregationSelection::Default;
@@ -203,20 +158,20 @@ QueryArgsParser::parse_args(const Args& args)
             char c;
 
             const QuerySpec::FunctionSignature* defs = Aggregator::aggregation_defs();
-            
+
             do {
                 auto fpair = parse_functioncall(is, defs);
 
                 if (fpair.first >= 0)
                     m_spec.aggregation_ops.list.emplace_back(defs[fpair.first], fpair.second);
 
-                c = parse_char(is);
+                c = util::read_char(is);
             } while (is.good() && c == ',');
         }
 
-        // aggregation key 
+        // aggregation key
         m_spec.aggregation_key.selection = QuerySpec::AttributeSelection::Default;
-        
+
         if (args.is_set("aggregate-key")) {
             std::string keystr = args.get("aggregate-key");
 
@@ -228,12 +183,12 @@ QueryArgsParser::parse_args(const Args& args)
             }
         }
     }
-    
+
     // setup sort
-    
+
     if (args.is_set("sort")) {
         m_spec.sort.selection = QuerySpec::SortSelection::List;
-        
+
         std::vector<std::string> list;
         util::split(args.get("sort"), ',', std::back_inserter(list));
 
@@ -242,9 +197,9 @@ QueryArgsParser::parse_args(const Args& args)
     }
 
     // setup formatter
-    
+
     for (const QuerySpec::FunctionSignature* fmtsig = FormatProcessor::formatter_defs(); fmtsig && fmtsig->name; ++fmtsig) {
-        // see if a formatting option is set        
+        // see if a formatting option is set
         if (args.is_set(fmtsig->name)) {
             m_spec.format.opt       = QuerySpec::FormatSpec::User;
             m_spec.format.formatter = *fmtsig;
@@ -263,11 +218,11 @@ QueryArgsParser::parse_args(const Args& args)
 
                 return false;
             }
-            
+
             break;
         }
     }
-        
+
     return true;
 }
 

test/ci_app_tests/CMakeLists.txt

@@ -44,11 +44,13 @@ set(PYTHON_SCRIPTS
   test_aggregate.py
   test_basictrace.py
   test_c_api.py
+  test_caliquery.py
   test_file_io.py
   test_json.py
   test_log.py
   test_multichannel.py
   test_report.py
+  test_textlog.py
   test_thread.py
   test_validator.py
   calipertest.py)

test/ci_app_tests/calipertest.py

@@ -73,13 +73,13 @@ def run_test_with_query(target_cmd, query_cmd, env):
 def run_test(target_cmd, env):
     """ Execute a command, and return its output """
 
-    target_proc = subprocess.Popen(target_cmd, env=env, stdout=subprocess.PIPE)
+    target_proc = subprocess.Popen(target_cmd, env=env, stdout=subprocess.PIPE,stderr=subprocess.PIPE)
     proc_out, proc_err = target_proc.communicate()
 
     if (target_proc.returncode != 0):
         raise CaliperExecError('Command ' + str(target_cmd) + ' exited with ' + str(target_proc.returncode))
 
-    return proc_out
+    return (proc_out,proc_err)
 
 
 def get_snapshots_from_text(query_output):

test/ci_app_tests/test_basictrace.py

@@ -1,4 +1,4 @@
-# Basic smoke tests: create and read a simple trace 
+# Basic smoke tests: create and read a simple trace, test various options
 
 import json
 import unittest
@@ -72,7 +72,7 @@ def test_default_scope_switch(self):
             snapshots, { 'cali.attribute.name': 'iteration',
                          'cali.attribute.prop': '13' # CALI_ATTR_SCOPE_PROCESS | CALI_ATTR_ASVALUE
             }))
-        
+
     def test_sec_unit_selection(self):
         target_cmd = [ './ci_test_basic' ]
         query_cmd  = [ '../../src/tools/cali-query/cali-query', '--list-attributes', '-e', '--print-attributes', 'cali.attribute.name,time.unit' ]
@@ -139,7 +139,6 @@ def test_largetrace(self):
 
         self.assertTrue(cat.has_snapshot_with_attributes(
             snapshots, { 'function' : 'main/foo', 'event.end#loop': 'fooloop', 'count' : '400' }))
-        
 
     def test_globals(self):
         target_cmd = [ './ci_test_basic' ]
@@ -158,7 +157,7 @@ def test_globals(self):
 
         self.assertTrue(cat.has_snapshot_with_keys(
             snapshots, { 'cali.caliper.version' } ) )
-        
+
     def test_esc(self):
         target_cmd = [ './ci_test_basic' ]
         query_cmd  = [ '../../src/tools/cali-query/cali-query', '-j', '-s', 'cali.event.set' ]
@@ -172,7 +171,6 @@ def test_esc(self):
         obj = json.loads( cat.run_test_with_query(target_cmd, query_cmd, caliper_config) )
 
         self.assertEqual(obj[0]['event.set# =\\weird ""attribute"=  '], '  \\\\ weird," name",' )
-        
 
     def test_macros(self):
         # Use ConfigManager API here
@@ -203,7 +201,7 @@ def test_macros(self):
                 'function'   : 'main/foo',
                 'loop'       : 'mainloop/fooloop',
                 'iteration#fooloop' : '3' }))
-        
+
     def test_property_override(self):
         target_cmd = [ './ci_test_macros' ]
         query_cmd  = [ '../../src/tools/cali-query/cali-query', '-e', '--list-attributes' ]
@@ -263,7 +261,7 @@ def test_binding(self):
         snapshots = cat.get_snapshots_from_text(query_output)
 
         self.assertTrue(cat.has_snapshot_with_attributes(
-            snapshots, { 'testbinding' : 'binding.nested=outer/binding.nested=inner' }))            
+            snapshots, { 'testbinding' : 'binding.nested=outer/binding.nested=inner' }))
 
 if __name__ == "__main__":
     unittest.main()

test/ci_app_tests/test_caliquery.py

@@ -0,0 +1,47 @@
+# Some tests for the cali-query tool
+
+import json
+import unittest
+
+import calipertest as cat
+
+class CaliperCaliQueryTest(unittest.TestCase):
+    """ cali-query test cases """
+
+    def test_caliquery_args(self):
+        target_cmd = [ './ci_test_aggregate' ]
+        query_cmd  = [ '../../src/tools/cali-query/cali-query', '-a', 'count(),sum(time.inclusive.duration)', '--aggregate-key=loop.id', '-s', 'loop.id=A', '--json' ]
+
+        caliper_config = {
+            'CALI_CONFIG_PROFILE'    : 'serial-trace',
+            'CALI_RECORDER_FILENAME' : 'stdout',
+            'CALI_LOG_VERBOSITY'     : '0',
+        }
+
+        obj = json.loads( cat.run_test_with_query(target_cmd, query_cmd, caliper_config) )
+
+        self.assertEqual(obj[0]["path"], "A")
+        self.assertEqual(obj[0]["count"], 16)
+        self.assertTrue("sum#time.inclusive.duration" in obj[0])
+
+    def test_caliquery_list_services(self):
+        target_cmd = [ '../../src/tools/cali-query/cali-query', '--help=services' ]
+
+        env = { 
+            'CALI_LOG_VERBOSITY' : '0',
+        }
+
+        service_targets = [
+            'aggregate', 'event', 'recorder', 'report', 'timestamp', 'trace'
+        ]
+
+        _,report_err = cat.run_test(target_cmd, env)
+        res = report_err.decode().split(',')
+
+        for target in service_targets:
+            if not target in res:
+                self.fail('%s not found in log' % target)
+
+
+if __name__ == "__main__":
+    unittest.main()

test/ci_app_tests/test_ioservice.py

@@ -62,7 +62,7 @@ def test_hatchet_profile_ioservice(self):
             'CALI_LOG_VERBOSITY'     : '0'
         }
 
-        obj = json.loads( cat.run_test(target_cmd, caliper_config) )
+        obj = json.loads( cat.run_test(target_cmd, caliper_config)[0] )
 
         self.assertEqual(obj[1]['path'], 'main')
         self.assertEqual(int(obj[1]['Bytes read']), 16)

test/ci_app_tests/test_json.py

@@ -113,7 +113,7 @@ def test_hatchetcontroller(self):
             'CALI_LOG_VERBOSITY'     : '0'
         }
 
-        obj = json.loads( cat.run_test(target_cmd, caliper_config) )
+        obj = json.loads( cat.run_test(target_cmd, caliper_config)[0] )
 
         self.assertTrue( { 'data', 'columns', 'column_metadata', 'nodes' }.issubset(set(obj.keys())) )