Newer
Older
Peterson, Peter
committed
#ifndef LOGPARSERTEST_H_
#define LOGPARSERTEST_H_
#include <cxxtest/TestSuite.h>
#include <iostream>
#include <fstream>
Gigg, Martyn Anthony
committed
#include "MantidKernel/LogParser.h"
#include "MantidKernel/PropertyWithValue.h"
Peterson, Peter
committed
#include "MantidKernel/TimeSeriesProperty.h"
#include <boost/scoped_ptr.hpp>
Peterson, Peter
committed
Russell Taylor
committed
#include <Poco/File.h>
Peterson, Peter
committed
namespace{
class TmpFile{
Poco::File m_file;
public:
TmpFile(const std::string& fname):m_file(fname){}
~TmpFile(){remove();}
const std::string& path() const {return m_file.path();}
bool exists() const {return m_file.exists();}
void remove() {if (m_file.exists()) m_file.remove();}
};
}
Peterson, Peter
committed
using namespace Mantid::Kernel;
class LogParserTest : public CxxTest::TestSuite
{
Russell Taylor
committed
public:
static LogParserTest *createSuite() { return new LogParserTest(); }
static void destroySuite(LogParserTest *suite) { delete suite; }
Peterson, Peter
committed
LogParserTest()
:log_num_good("TST000000_good.txt"),
log_num_late("TST000000_late.txt"),
log_num_early("TST000000_early.txt"),
log_num_single("TST000000_single.txt"),
log_str("TST000000_str.txt"),
icp_file("TST000000_icpevent.txt"),
log_str_repeat("TST000000_repeat.txt"),
log_num_repeat("TST000000_num_repeat.txt"),
log_str_continuations("TST000000_str_continue.txt")
Peterson, Peter
committed
{
}
void testGood()
{
mkICP();
mkGood();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
Peterson, Peter
committed
Property* p1 = lp.createLogProperty(log_num_good.path(),"good");
Janik Zikovsky
committed
TS_ASSERT(p1);
Peterson, Peter
committed
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
Janik Zikovsky
committed
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
Peterson, Peter
committed
// time 1
TS_ASSERT_EQUALS(vmap.size(), 9);
TS_ASSERT_EQUALS(v->second, 1);
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Janik Zikovsky
committed
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
v++;v++;v++;v++;
// time 5
//TS_ASSERT(isNaN(v->second));
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
Janik Zikovsky
committed
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
Peterson, Peter
committed
TS_ASSERT_EQUALS(rv->second, 9);
Janik Zikovsky
committed
ti_data = rv->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
Janik Zikovsky
committed
TS_ASSERT_DELTA(timeMean(p1),8.4904, 0.001);
Peterson, Peter
committed
TS_ASSERT_EQUALS(tp1->nthValue(0),1);
TS_ASSERT_EQUALS(tp1->nthValue(1),2);
TS_ASSERT_EQUALS(tp1->nthValue(2),3);
TS_ASSERT_EQUALS(tp1->nthValue(3),4);
TS_ASSERT_EQUALS(tp1->nthValue(4),5);
TS_ASSERT_EQUALS(tp1->nthValue(5),6);
TS_ASSERT_EQUALS(tp1->nthValue(6),7);
TS_ASSERT_EQUALS(tp1->nthValue(7),8);
TS_ASSERT_EQUALS(tp1->firstValue(),1);
//TS_ASSERT_EQUALS(secondValue(p1),2);
TS_ASSERT_EQUALS(tp1->lastValue(),9);
delete p1;
Peterson, Peter
committed
}
Peterson, Peter
committed
void testLate()
{
mkICP();
mkLate();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
Peterson, Peter
committed
Property* p1 = lp.createLogProperty(log_num_late.path(),"late");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
Janik Zikovsky
committed
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
Peterson, Peter
committed
// time 1
TS_ASSERT_EQUALS(vmap.size(), 8);
TS_ASSERT_EQUALS(v->second, 2);
Janik Zikovsky
committed
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
v++;v++;v++;v++;
// time 5
//TS_ASSERT(isNaN(v->second));
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
Janik Zikovsky
committed
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
Peterson, Peter
committed
TS_ASSERT_EQUALS(rv->second, 9);
Janik Zikovsky
committed
ti_data = rv->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
Janik Zikovsky
committed
TS_ASSERT_DELTA(timeMean(p1),8.4941, 0.001);
Peterson, Peter
committed
delete p1;
Peterson, Peter
committed
}
void testEarly()
{
mkICP();
mkEarly();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
Peterson, Peter
committed
Property* p1 = lp.createLogProperty(log_num_early.path(),"early");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
Janik Zikovsky
committed
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
Peterson, Peter
committed
// time 1
TS_ASSERT_EQUALS(vmap.size(), 8);
TS_ASSERT_EQUALS(v->second, 1);
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
v++;v++;v++;v++;
// time 5
//TS_ASSERT(isNaN(v->second));
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
Janik Zikovsky
committed
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
Peterson, Peter
committed
TS_ASSERT_EQUALS(rv->second, 8);
Janik Zikovsky
committed
ti_data = rv->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 23);
Janik Zikovsky
committed
TS_ASSERT_DELTA(timeMean(p1),4.9090, 0.001);
Peterson, Peter
committed
delete p1;
Peterson, Peter
committed
}
void testSingle()
{
mkICP();
mkSingle();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
Peterson, Peter
committed
Property* p1 = lp.createLogProperty(log_num_single.path(),"single");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
Janik Zikovsky
committed
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
Peterson, Peter
committed
// time 1
TS_ASSERT_EQUALS(vmap.size(), 1);
TS_ASSERT_EQUALS(v->second, 4);
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
Janik Zikovsky
committed
//Can't get a valid mean with a single time and no intervals in it.
//TS_ASSERT_DELTA(timeMean(p1),4., 0.001);
Peterson, Peter
committed
delete p1;
Peterson, Peter
committed
}
void testStr()
{
mkICP();
mkStr();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
Peterson, Peter
committed
Property* p1 = lp.createLogProperty(log_str.path(),"str");
TS_ASSERT(p1);
TimeSeriesProperty<std::string>* tp1 = dynamic_cast<TimeSeriesProperty<std::string>*>(p1);
Janik Zikovsky
committed
std::map<DateAndTime, std::string> vmap = tp1->valueAsMap();
std::map<DateAndTime, std::string>::iterator v= vmap.begin();
Peterson, Peter
committed
// time 1
TS_ASSERT_EQUALS(vmap.size(), 9);
TS_ASSERT_EQUALS(v->second, " line 1");
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
v++;v++;v++;
// time 4
TS_ASSERT_EQUALS(v->second, " line 4");
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
Janik Zikovsky
committed
std::map<DateAndTime, std::string>::reverse_iterator rv = vmap.rbegin();
Peterson, Peter
committed
TS_ASSERT_EQUALS(rv->second, " line 9");
Janik Zikovsky
committed
ti_data = rv->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
// assert_throws(timeMean(p1));
delete p1;
Peterson, Peter
committed
}
// Test a variant of the log file containing CHANGE_PERIOD flags
void testConstructionFromFileUsingICPVariant_CHANGE_PERIOD()
{
mkICPVariant();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
const Property * prop = lp.createAllPeriodsLog();
const auto *timeseriesprop = dynamic_cast<const TimeSeriesProperty<int>*>(prop);
TS_ASSERT(timeseriesprop);
//Check the size
TS_ASSERT_EQUALS(4, timeseriesprop->size());
//Check the exact time stamps
TS_ASSERT_EQUALS(DateAndTime("2000-09-05T12:22:55").toSimpleString(), timeseriesprop->nthTime(0).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2000-09-05T12:23:08").toSimpleString(), timeseriesprop->nthTime(1).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2000-09-05T12:23:22").toSimpleString(), timeseriesprop->nthTime(2).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2000-09-05T12:23:37").toSimpleString(), timeseriesprop->nthTime(3).toSimpleString());
}
void testConstructionFromPropertyUsingICPVariant_CHANGE_PERIOD()
{
auto* log = new TimeSeriesProperty<std::string>("ICPLog");
// Notice we are using "CHANGE_PERIOD"
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:15:00", "CHANGE_PERIOD 1") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:16:00", "CHANGE_PERIOD 2") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:00", "CHANGE_PERIOD 3") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:00", "CHANGE_PERIOD 2") );
LogParser logparser(log);
const Property * prop = logparser.createAllPeriodsLog();
const auto *timeseriesprop = dynamic_cast<const TimeSeriesProperty<int>*>(prop);
TS_ASSERT(timeseriesprop);
//Check the size
TS_ASSERT_EQUALS(4, timeseriesprop->size());
//Check the exact time stamps
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:15:00").toSimpleString(), timeseriesprop->nthTime(0).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:16:00").toSimpleString(), timeseriesprop->nthTime(1).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:17:00").toSimpleString(), timeseriesprop->nthTime(2).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:18:00").toSimpleString(), timeseriesprop->nthTime(3).toSimpleString());
delete log;
}
void testConstructionFromPropertyUsingICPVariant_CHANGE_SPACE_PERIOD()
{
auto* log = new TimeSeriesProperty<std::string>("ICPLog");
// Notice we are using "CHANGE PERIOD"
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:15:00", "CHANGE PERIOD 1") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:16:00", "CHANGE PERIOD 2") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:00", "CHANGE PERIOD 3") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:00", "CHANGE PERIOD 2") );
LogParser logparser(log);
const Property *prop = logparser.createAllPeriodsLog();
const auto *timeseriesprop = dynamic_cast<const TimeSeriesProperty<int>*>(prop);
TS_ASSERT(timeseriesprop);
//Check the size
TS_ASSERT_EQUALS(4, timeseriesprop->size());
//Check the exact time stamps
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:15:00").toSimpleString(), timeseriesprop->nthTime(0).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:16:00").toSimpleString(), timeseriesprop->nthTime(1).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:17:00").toSimpleString(), timeseriesprop->nthTime(2).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:18:00").toSimpleString(), timeseriesprop->nthTime(3).toSimpleString());
delete log;
// Check that periods that don't have a full "CHANGE PERIOD" flag are not added.
void testWontAddPeriodWithoutPERIODpartOfCHANGE_SPACE_PERIOD()
{
auto* log = new TimeSeriesProperty<std::string>("ICPLog");
// Notice we are using "CHANGE PERIOD"
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:15:00", "CHANGE PERIOD 1") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:16:00", "CHANGE PERIOD 2") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:00", "CHANGE PERIOD 3") );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:00", "CHANGE 2") ); //This is a duff entry. Shouldn't get added.
LogParser logparser(log);
const Property *prop = logparser.createAllPeriodsLog();
const auto *timeseriesprop = dynamic_cast<const TimeSeriesProperty<int>*>(prop);
TS_ASSERT(timeseriesprop);
//Check the size
TS_ASSERT_EQUALS(3, timeseriesprop->size());
//Check the exact time stamps
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:15:00").toSimpleString(), timeseriesprop->nthTime(0).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:16:00").toSimpleString(), timeseriesprop->nthTime(1).toSimpleString());
TS_ASSERT_EQUALS(DateAndTime("2007-11-30T16:17:00").toSimpleString(), timeseriesprop->nthTime(2).toSimpleString());
delete log;
void testCreatesCurrentPeriodLog()
{
//Check it with a few expected period numbers.
doTestCurrentPeriodLog(1);
doTestCurrentPeriodLog(2);
doTestCurrentPeriodLog(3);
}
Peterson, Peter
committed
void testNoICPevent()
{
if ( icp_file.exists() ) icp_file.remove();
mkGood();
Property *icp_log = LogParser::createLogProperty(icp_file.path(),"icpevent");
LogParser lp(icp_log);
Peterson, Peter
committed
Property* p1 = lp.createLogProperty(log_num_good.path(),"good");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
Janik Zikovsky
committed
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
Peterson, Peter
committed
// time 1
TS_ASSERT_EQUALS(vmap.size(), 9);
TS_ASSERT_EQUALS(v->second, 1);
Janik Zikovsky
committed
ti_data = v->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
v++;v++;v++;v++;
// time 5
//TS_ASSERT(!isNaN(v->second));
// last time
Janik Zikovsky
committed
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
Peterson, Peter
committed
TS_ASSERT_EQUALS(rv->second, 9);
Janik Zikovsky
committed
ti_data = rv->first.to_tm(); ti = &ti_data;
Peterson, Peter
committed
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
Janik Zikovsky
committed
TS_ASSERT_DELTA(timeMean(p1),8.4904, 0.001);
Peterson, Peter
committed
delete p1;
}
Janik Zikovsky
committed
//----------------------------------------------------------------------------
void test_timeMean()
{
TimeSeriesProperty<double> * log = new TimeSeriesProperty<double>("MydoubleLog");
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:00",1) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:10",2) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:20",3) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:30",4) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:40",5) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:50",6) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:00",7) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:10",8) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:20",9) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:30",10) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:18:40",11) );
Janik Zikovsky
committed
TS_ASSERT_EQUALS( log->realSize(), 11);
TS_ASSERT_DELTA(timeMean(log), 6.0, 1e-3);
Janik Zikovsky
committed
}
void test_timeMean_one_Value()
{
TimeSeriesProperty<double> * log = new TimeSeriesProperty<double>("MydoubleLog");
TS_ASSERT_THROWS_NOTHING( log->addValue("2007-11-30T16:17:00",56) );
Janik Zikovsky
committed
TS_ASSERT_EQUALS( log->realSize(), 1);
TS_ASSERT_DELTA(timeMean(log), 56.0, 1e-3);
Janik Zikovsky
committed
}
/// Tests to see if we can cope with duplicate log values that have the same time.
void test_timeMean_duplicate_values_with_same_timestamp()
{
TimeSeriesProperty<double> * log = new TimeSeriesProperty<double>("MydoubleLog");
// Add the same value twice
TS_ASSERT_THROWS_NOTHING( log->addValue("2012-07-19T20:00:00", 666) );
TS_ASSERT_THROWS_NOTHING( log->addValue("2012-07-19T20:00:00", 666) );
TS_ASSERT_EQUALS( log->realSize(), 2);
TS_ASSERT_DELTA( timeMean(log), 666, 1e-3);
Janik Zikovsky
committed
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
void test_isICPEventLogNewStyle_works()
{
TimeSeriesProperty<std::string> * oldlog = new TimeSeriesProperty<std::string>("MyOldICPevent");
TS_ASSERT_THROWS_NOTHING( oldlog->addValue("2012-07-19T20:00:00", "START") );
TS_ASSERT_THROWS_NOTHING( oldlog->addValue("2012-07-19T20:00:01", "BEGIN") );
TS_ASSERT_THROWS_NOTHING( oldlog->addValue("2012-07-19T20:00:02", "PAUSE") );
auto logm = oldlog->valueAsMultiMap();
TS_ASSERT( !LogParser::isICPEventLogNewStyle(logm) );
delete oldlog;
TimeSeriesProperty<std::string> * newlog = new TimeSeriesProperty<std::string>("MyNewICPevent");
TS_ASSERT_THROWS_NOTHING( newlog->addValue("2012-07-19T20:00:00", "START") );
TS_ASSERT_THROWS_NOTHING( newlog->addValue("2012-07-19T20:00:01", "START_COLLECTION PERIOD 1") );
TS_ASSERT_THROWS_NOTHING( newlog->addValue("2012-07-19T20:00:02", "PAUSE") );
logm = newlog->valueAsMultiMap();
TS_ASSERT( LogParser::isICPEventLogNewStyle(logm) );
delete newlog;
newlog = new TimeSeriesProperty<std::string>("MyNewICPevent1");
TS_ASSERT_THROWS_NOTHING( newlog->addValue("2012-07-19T20:00:00", "START") );
TS_ASSERT_THROWS_NOTHING( newlog->addValue("2012-07-19T20:00:01", "STOP_COLLECTION PERIOD 1") );
TS_ASSERT_THROWS_NOTHING( newlog->addValue("2012-07-19T20:00:02", "PAUSE") );
logm = newlog->valueAsMultiMap();
TS_ASSERT( LogParser::isICPEventLogNewStyle(logm) );
delete newlog;
}
void test_new_style_command_parsing()
{
TimeSeriesProperty<std::string> * log = new TimeSeriesProperty<std::string>("MyICPevent");
log->addValue("2013-10-16T19:04:47", "CHANGE_PERIOD 1");
log->addValue("2013-10-16T19:04:48", "RESUME");
log->addValue("2013-10-16T19:04:48", "START_COLLECTION PERIOD 1 GF 60015 RF 75039 GUAH 69.875610");
log->addValue("2013-10-16T19:06:53", "STOP_COLLECTION PERIOD 1 GF 65024 RF 81303 GUAH 75.712013 DUR 125");
log->addValue("2013-10-16T19:06:53", "PAUSE");
log->addValue("2013-10-16T19:06:53", "CHANGE_PERIOD 2");
log->addValue("2013-10-16T19:06:53", "RESUME");
log->addValue("2013-10-16T19:06:53", "START_COLLECTION PERIOD 2 GF 65024 RF 81303 GUAH 75.712013");
log->addValue("2013-10-16T19:08:58", "STOP_COLLECTION PERIOD 2 GF 70033 RF 87567 GUAH 81.547050 DUR 125");
log->addValue("2013-10-16T19:08:58", "PAUSE");
log->addValue("2013-10-16T19:08:58", "CHANGE_PERIOD 1");
log->addValue("2013-10-16T19:08:59", "RESUME");
log->addValue("2013-10-16T19:08:59", "START_COLLECTION PERIOD 1 GF 70033 RF 87567 GUAH 81.547050");
log->addValue("2013-10-16T19:11:03", "STOP_COLLECTION PERIOD 1 GF 75005 RF 93784 GUAH 87.339035 DUR 124");
log->addValue("2013-10-16T19:11:03", "PAUSE");
log->addValue("2013-10-16T19:11:03", "CHANGE_PERIOD 2");
log->addValue("2013-10-16T19:11:04", "RESUME");
log->addValue("2013-10-16T19:11:04", "START_COLLECTION PERIOD 2 GF 75005 RF 93784 GUAH 87.339035");
log->addValue("2013-10-16T19:13:09", "STOP_COLLECTION PERIOD 2 GF 80016 RF 100049 GUAH 93.174751 DUR 125");
log->addValue("2013-10-16T19:13:09", "PAUSE");
log->addValue("2013-10-16T19:13:09", "CHANGE_PERIOD 1");
log->addValue("2013-10-16T19:13:09", "RESUME");
std::vector< std::pair<std::string,int> > checkPeriod(5);
checkPeriod[0] = std::make_pair("2013-10-16T19:04:47", 1 );
checkPeriod[1] = std::make_pair("2013-10-16T19:06:53", 2 );
checkPeriod[2] = std::make_pair("2013-10-16T19:08:58", 1 );
checkPeriod[3] = std::make_pair("2013-10-16T19:11:03", 2 );
checkPeriod[4] = std::make_pair("2013-10-16T19:13:09", 1 );
std::vector< std::pair<std::string,bool> > checkRunning(8);
checkRunning[0] = std::make_pair("2013-10-16T19:04:48", true );
checkRunning[1] = std::make_pair("2013-10-16T19:06:53", false );
checkRunning[2] = std::make_pair("2013-10-16T19:06:53", true );
checkRunning[3] = std::make_pair("2013-10-16T19:08:58", false );
checkRunning[4] = std::make_pair("2013-10-16T19:08:59", true );
checkRunning[5] = std::make_pair("2013-10-16T19:11:03", false );
checkRunning[6] = std::make_pair("2013-10-16T19:11:04", true );
checkRunning[7] = std::make_pair("2013-10-16T19:13:09", false );
LogParser logparser( log );
const Property *prop = logparser.createAllPeriodsLog();
const auto *allPeriodsProp = dynamic_cast<const TimeSeriesProperty<int>*>(prop);
TS_ASSERT(allPeriodsProp);
TS_ASSERT_EQUALS(5, allPeriodsProp->size());
auto logm = allPeriodsProp->valueAsMultiMap();
size_t i = 0;
for(auto it = logm.begin(); it != logm.end(); ++it)
{
TS_ASSERT_EQUALS( it->first.toISO8601String(), checkPeriod[i].first );
TS_ASSERT_EQUALS( it->second, checkPeriod[i].second );
++i;
}
prop = logparser.createRunningLog();
const auto *runningProp = dynamic_cast<const TimeSeriesProperty<bool>*>(prop);
TS_ASSERT(runningProp);
TS_ASSERT_EQUALS(8, runningProp->size());
auto logm1 = runningProp->valueAsMultiMap();
i = 0;
for(auto it = logm1.begin(); it != logm1.end(); ++it)
{
TS_ASSERT_EQUALS( it->first.toISO8601String(), checkRunning[i].first );
TS_ASSERT_EQUALS( it->second, checkRunning[i].second );
++i;
}
delete prop;
delete log;
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
void test_str_repeat()
{
mkStrRepeat();
Property *prop = LogParser::createLogProperty(log_str_repeat.path(),"log");
const auto *log = dynamic_cast<const TimeSeriesProperty<std::string>*>(prop);
TS_ASSERT(log);
auto logm = log->valueAsMultiMap();
auto it = logm.begin();
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:34");
TS_ASSERT_EQUALS( it->second, " First line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:34");
TS_ASSERT_EQUALS( it->second, " Second line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, " First line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, " Second line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, " Third line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, " Fourth line"); ++it;
}
void test_num_repeat()
{
mkNumRepeat();
Property *prop = LogParser::createLogProperty(log_str_repeat.path(),"log");
const auto *log = dynamic_cast<const TimeSeriesProperty<double>*>(prop);
TS_ASSERT(log);
auto logm = log->valueAsMultiMap();
auto it = logm.begin();
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:34");
TS_ASSERT_EQUALS( it->second, 1); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:34");
TS_ASSERT_EQUALS( it->second, 2); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, 3); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, 4); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, 5); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:23:33");
TS_ASSERT_EQUALS( it->second, 6); ++it;
}
void test_str_continuation()
{
mkStrContinuations();
Property *prop = LogParser::createLogProperty(log_str_continuations.path(),"log");
const auto *log = dynamic_cast<const TimeSeriesProperty<std::string>*>(prop);
TS_ASSERT(log);
auto logm = log->valueAsMultiMap();
auto it = logm.begin();
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:31");
TS_ASSERT_EQUALS( it->second, " First line Second line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:34");
TS_ASSERT_EQUALS( it->second, " First line"); ++it;
TS_ASSERT_EQUALS( it->first.toISO8601String(), "2000-09-05T12:22:34");
TS_ASSERT_EQUALS( it->second, " Second line Third line"); ++it;
}
Peterson, Peter
committed
private:
/// Helper method to run common test code for checking period logs.
void doTestCurrentPeriodLog(const int& expected_period)
{
auto* log = new TimeSeriesProperty<std::string>("ICPLog");
LogParser logparser(log);
Property* prop = logparser.createCurrentPeriodLog(expected_period);
PropertyWithValue<int>* prop_with_value = dynamic_cast<PropertyWithValue<int>* >(prop);
int value;
TS_ASSERT(prop_with_value != NULL);
Mantid::Kernel::toValue<int>(prop_with_value->value(), value);
TS_ASSERT_EQUALS(expected_period, value);
delete prop;
delete log;
}
Peterson, Peter
committed
void mkICP()
{
std::ofstream f( icp_file.path().c_str());
int dt = 0;
f << "2000-09-05T12:22:28 START_SE_WAIT"<<'\n';
f << "2000-09-05T12:22:33 BEGIN"<<'\n';dt+=8;
f << "2000-09-05T12:22:41 PAUSE"<<'\n';dt+=4;
f << "2000-09-05T12:22:55 CHANGE PERIOD 2"<<'\n';dt+=3;
f << "2000-09-05T12:22:58 RESUME"<<'\n';dt+=6;
f << "2000-09-05T12:23:04 PAUSE"<<'\n';dt+=4;
f << "2000-09-05T12:23:08 CHANGE PERIOD 1"<<'\n';dt+=2;
f << "2000-09-05T12:23:10 RESUME"<<'\n';dt+=8;
f << "2000-09-05T12:23:18 START_SE_WAIT"<<'\n';dt+=4;
f << "2000-09-05T12:23:22 CHANGE PERIOD 2"<<'\n';dt+=5;
f << "2000-09-05T12:23:27 RESUME"<<'\n';dt+=7;
f << "2000-09-05T12:23:34 ABORT"<<'\n';dt+=3;
f << "2000-09-05T12:23:37 CHANGE PERIOD 1"<<'\n';dt+=5;
f << "2000-09-05T12:23:42 END_SE_WAIT"<<'\n';
f << "2000-09-05T14:03:54 END"<<'\n';
f.close();
}
void mkICPVariant()
{
std::ofstream f( icp_file.path().c_str());
int dt = 0;
f << "2000-09-05T12:22:28 START_SE_WAIT"<<'\n';
f << "2000-09-05T12:22:33 BEGIN"<<'\n';dt+=8;
f << "2000-09-05T12:22:41 PAUSE"<<'\n';dt+=4;
f << "2000-09-05T12:22:55 CHANGE_PERIOD 2"<<'\n';dt+=3;
f << "2000-09-05T12:22:58 RESUME"<<'\n';dt+=6;
f << "2000-09-05T12:23:04 PAUSE"<<'\n';dt+=4;
f << "2000-09-05T12:23:08 CHANGE_PERIOD 1"<<'\n';dt+=2;
f << "2000-09-05T12:23:10 RESUME"<<'\n';dt+=8;
f << "2000-09-05T12:23:18 START_SE_WAIT"<<'\n';dt+=4;
f << "2000-09-05T12:23:22 CHANGE_PERIOD 2"<<'\n';dt+=5;
f << "2000-09-05T12:23:27 RESUME"<<'\n';dt+=7;
f << "2000-09-05T12:23:34 ABORT"<<'\n';dt+=3;
f << "2000-09-05T12:23:37 CHANGE_PERIOD 1"<<'\n';dt+=5;
f << "2000-09-05T12:23:42 END_SE_WAIT"<<'\n';
f << "2000-09-05T14:03:54 END"<<'\n';
f.close();
}
Peterson, Peter
committed
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
void mkGood()
{
std::ofstream f( log_num_good.path().c_str());
int dt = 4;
f << "2000-09-05T12:22:31 "<<1<<'\n';
f << "2000-09-05T12:22:37 "<<2<<'\n';dt+=1;
f << "2000-09-05T12:22:38 "<<3<<'\n';dt+=1;
f << "2000-09-05T12:22:39 "<<4<<'\n';dt+=3;
f << "2000-09-05T12:22:42 "<<5<<'\n';dt+=5;
f << "2000-09-05T12:22:47 "<<6<<'\n';dt+=9;
f << "2000-09-05T12:22:56 "<<7<<'\n';dt+=4;
f << "2000-09-05T12:23:00 "<<8<<'\n';
f << "2000-09-05T14:03:56 "<<9<<'\n';
f.close();
}
void mkLate()
{
std::ofstream f( log_num_late.path().c_str());
int dt = 4;
f << "2000-09-05T12:22:37 "<<2<<'\n';dt+=1;
f << "2000-09-05T12:22:38 "<<3<<'\n';dt+=1;
f << "2000-09-05T12:22:39 "<<4<<'\n';dt+=3;
f << "2000-09-05T12:22:42 "<<5<<'\n';dt+=5;
f << "2000-09-05T12:22:47 "<<6<<'\n';dt+=9;
f << "2000-09-05T12:22:56 "<<7<<'\n';dt+=4;
f << "2000-09-05T12:23:00 "<<8<<'\n';
f << "2000-09-05T14:03:56 "<<9<<'\n';
f.close();
}
void mkEarly()
{
std::ofstream f( log_num_early.path().c_str());
int dt = 4;
f << "2000-09-05T12:22:31 "<<1<<'\n';
f << "2000-09-05T12:22:37 "<<2<<'\n';dt+=1;
f << "2000-09-05T12:22:38 "<<3<<'\n';dt+=1;
f << "2000-09-05T12:22:39 "<<4<<'\n';dt+=3;
f << "2000-09-05T12:22:42 "<<5<<'\n';dt+=5;
f << "2000-09-05T12:22:47 "<<6<<'\n';dt+=9;
f << "2000-09-05T12:22:56 "<<7<<'\n';dt+=4;
f << "2000-09-05T12:23:00 "<<8<<'\n';
f.close();
}
void mkSingle()
{
std::ofstream f( log_num_single.path().c_str());
f << "2000-09-05T12:22:51 "<<4<<'\n';
f.close();
}
void mkStr()
{
std::ofstream f( log_str.path().c_str());
int dt = 4;
f << "2000-09-05T12:22:31 line "<<1<<'\n';
f << "2000-09-05T12:22:37 line "<<2<<'\n';dt+=1;
f << "2000-09-05T12:22:38 line "<<3<<'\n';dt+=1;
f << "2000-09-05T12:22:39 line "<<4<<'\n';dt+=3;
f << "2000-09-05T12:22:42 line "<<5<<'\n';dt+=5;
f << "2000-09-05T12:22:47 line "<<6<<'\n';dt+=9;
f << "2000-09-05T12:22:56 line "<<7<<'\n';dt+=4;
f << "2000-09-05T12:23:00 line "<<8<<'\n';
f << "2000-09-05T14:03:56 line "<<9<<'\n';
f.close();
}
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
void mkStrContinuations()
{
std::ofstream f( log_str_continuations.path().c_str() );
f << "2000-09-05T12:22:31 First line" << std::endl;
f << "Second line" << std::endl;
f << "2000-09-05T12:22:34 First line" << std::endl;
f << "2000-09-05T12:22:34 Second line" << std::endl;
f << "Third line" << std::endl;
f.close();
}
void mkStrRepeat()
{
std::ofstream f( log_str_repeat.path().c_str() );
f << "2000-09-05T12:22:34 First line" << std::endl;
f << "2000-09-05T12:22:34 Second line" << std::endl;
f << "2000-09-05T12:23:33 First line" << std::endl;
f << "2000-09-05T12:23:33 Second line" << std::endl;
f << "2000-09-05T12:23:33 Third line" << std::endl;
f << "2000-09-05T12:23:33 Fourth line" << std::endl;
f.close();
}
void mkNumRepeat()
{
std::ofstream f( log_str_repeat.path().c_str() );
f << "2000-09-05T12:22:34 1" << std::endl;
f << "2000-09-05T12:22:34 2" << std::endl;
f << "2000-09-05T12:23:33 3" << std::endl;
f << "2000-09-05T12:23:33 4" << std::endl;
f << "2000-09-05T12:23:33 5" << std::endl;
f << "2000-09-05T12:23:33 6" << std::endl;
f.close();
}
TmpFile log_num_good;// run time interval is within first - last times of the log
TmpFile log_num_late;// first time is later than run start
TmpFile log_num_early;// last time is earlier than run ends
TmpFile log_num_single;// single value
TmpFile log_str;// file of strings
TmpFile icp_file;// icpevent file
TmpFile log_str_repeat;// string log with repeating lines
TmpFile log_num_repeat;// num log with repeating lines
TmpFile log_str_continuations;// string log with continuation lines
Janik Zikovsky
committed
tm ti_data;
tm * ti;
Peterson, Peter
committed
};
#endif /*LOGPARSERTEST_H_*/