#ifndef LOGPARSERTEST_H_
#define LOGPARSERTEST_H_
#include <cxxtest/TestSuite.h>
#include <iostream>
#include <fstream>
#include "MantidKernel/LogParser.h"
#include "MantidKernel/TimeSeriesProperty.h"
#include "Poco/File.h"
using namespace Mantid::Kernel;
class LogParserTest : public CxxTest::TestSuite
{
public:
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();
LogParser lp(icp_file.path());
Property* p1 = lp.createLogProperty(log_num_good.path(),"good");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
// time 1
TS_ASSERT_EQUALS(vmap.size(), 9);
TS_ASSERT_EQUALS(v->second, 1);
ti_data = v->first.to_tm(); ti = &ti_data;
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));
ti_data = v->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
TS_ASSERT_EQUALS(rv->second, 9);
ti_data = rv->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
TS_ASSERT_DELTA(timeMean(p1),8.4904, 0.001);
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;
}
void testLate()
{
mkICP();
mkLate();
LogParser lp(icp_file.path());
Property* p1 = lp.createLogProperty(log_num_late.path(),"late");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
// time 1
TS_ASSERT_EQUALS(vmap.size(), 8);
TS_ASSERT_EQUALS(v->second, 2);
ti_data = v->first.to_tm(); ti = &ti_data;
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));
ti_data = v->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
TS_ASSERT_EQUALS(rv->second, 9);
ti_data = rv->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
TS_ASSERT_DELTA(timeMean(p1),8.4941, 0.001);
delete p1;
}
void testEarly()
{
mkICP();
mkEarly();
LogParser lp(icp_file.path());
Property* p1 = lp.createLogProperty(log_num_early.path(),"early");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
// time 1
TS_ASSERT_EQUALS(vmap.size(), 8);
TS_ASSERT_EQUALS(v->second, 1);
ti_data = v->first.to_tm(); ti = &ti_data;
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));
ti_data = v->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
TS_ASSERT_EQUALS(rv->second, 8);
ti_data = rv->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 23);
TS_ASSERT_DELTA(timeMean(p1),4.9090, 0.001);
delete p1;
}
void testSingle()
{
mkICP();
mkSingle();
LogParser lp(icp_file.path());
Property* p1 = lp.createLogProperty(log_num_single.path(),"single");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
// time 1
TS_ASSERT_EQUALS(vmap.size(), 1);
TS_ASSERT_EQUALS(v->second, 4);
ti_data = v->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
//Can't get a valid mean with a single time and no intervals in it.
//TS_ASSERT_DELTA(timeMean(p1),4., 0.001);
delete p1;
}
void testStr()
{
mkICP();
mkStr();
LogParser lp(icp_file.path());
Property* p1 = lp.createLogProperty(log_str.path(),"str");
TS_ASSERT(p1);
TimeSeriesProperty<std::string>* tp1 = dynamic_cast<TimeSeriesProperty<std::string>*>(p1);
std::map<DateAndTime, std::string> vmap = tp1->valueAsMap();
std::map<DateAndTime, std::string>::iterator v= vmap.begin();
// time 1
TS_ASSERT_EQUALS(vmap.size(), 9);
TS_ASSERT_EQUALS(v->second, " line 1");
ti_data = v->first.to_tm(); ti = &ti_data;
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");
ti_data = v->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 12);
TS_ASSERT_EQUALS(ti->tm_min, 22);
// last time
std::map<DateAndTime, std::string>::reverse_iterator rv = vmap.rbegin();
TS_ASSERT_EQUALS(rv->second, " line 9");
ti_data = rv->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
// assert_throws(timeMean(p1));
delete p1;
}
void testNoICPevent()
{
if ( icp_file.exists() ) icp_file.remove();
mkGood();
LogParser lp(icp_file.path());
Property* p1 = lp.createLogProperty(log_num_good.path(),"good");
TS_ASSERT(p1);
TimeSeriesProperty<double>* tp1 = dynamic_cast<TimeSeriesProperty<double>*>(p1);
std::map<DateAndTime, double> vmap = tp1->valueAsMap();
std::map<DateAndTime, double>::iterator v= vmap.begin();
// time 1
TS_ASSERT_EQUALS(vmap.size(), 9);
TS_ASSERT_EQUALS(v->second, 1);
ti_data = v->first.to_tm(); ti = &ti_data;
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
std::map<DateAndTime, double>::reverse_iterator rv = vmap.rbegin();
TS_ASSERT_EQUALS(rv->second, 9);
ti_data = rv->first.to_tm(); ti = &ti_data;
TS_ASSERT_EQUALS(ti->tm_hour, 14);
TS_ASSERT_EQUALS(ti->tm_min, 3);
TS_ASSERT_DELTA(timeMean(p1),8.4904, 0.001);
delete p1;
}
//----------------------------------------------------------------------------
void test_timeMean()
{
TimeSeriesProperty<double> * log = new TimeSeriesProperty<double>("MydoubleLog");
TS_ASSERT( log->addValue("2007-11-30T16:17:00",1) );
TS_ASSERT( log->addValue("2007-11-30T16:17:10",2) );
TS_ASSERT( log->addValue("2007-11-30T16:17:20",3) );
TS_ASSERT( log->addValue("2007-11-30T16:17:30",4) );
TS_ASSERT( log->addValue("2007-11-30T16:17:40",5) );
TS_ASSERT( log->addValue("2007-11-30T16:17:50",6) );
TS_ASSERT( log->addValue("2007-11-30T16:18:00",7) );
TS_ASSERT( log->addValue("2007-11-30T16:18:10",8) );
TS_ASSERT( log->addValue("2007-11-30T16:18:20",9) );
TS_ASSERT( log->addValue("2007-11-30T16:18:30",10) );
TS_ASSERT( log->addValue("2007-11-30T16:18:40",11) );
TS_ASSERT_EQUALS( log->realSize(), 11);
TS_ASSERT_DELTA(timeMean(log), 6.0, 1e-3);
}
void test_timeMean_one_Value()
{
TimeSeriesProperty<double> * log = new TimeSeriesProperty<double>("MydoubleLog");
TS_ASSERT( log->addValue("2007-11-30T16:17:00",56) );
TS_ASSERT_EQUALS( log->realSize(), 1);
TS_ASSERT_DELTA(timeMean(log), 56.0, 1e-3);
}
//*/
private:
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 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
tm ti_data;
tm * ti;
};
#endif /*LOGPARSERTEST_H_*/