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
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")
{
}
~LogParserTest()
{
if ( log_num_good.exists() ) log_num_good.remove();
if ( log_num_late.exists() ) log_num_late.remove();
if ( log_num_early.exists() ) log_num_early.remove();
if ( log_num_single.exists() ) log_num_single.remove();
if ( log_str.exists() ) log_str.remove();
if ( icp_file.exists() ) icp_file.remove();
}
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
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;
}
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;
}
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;
}
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;
}
// 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
404
405
406
407
408
409
410
411
412
413
414
415
416
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
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());
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
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;
}
}
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
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
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();
}
//*/
Poco::File log_num_good;// run time interval is within first - last times of the log
Poco::File log_num_late;// first time is later than run start
Poco::File log_num_early;// last time is earlier than run ends
Poco::File log_num_single;// single value
Poco::File log_str;// file of strings
Poco::File icp_file;// icpevent file
Janik Zikovsky
committed
tm ti_data;
tm * ti;
Peterson, Peter
committed
};
#endif /*LOGPARSERTEST_H_*/