//OpenSCADA module Special.SystemTests file: test_kernel.cpp
/***************************************************************************
* Copyright (C) 2003-2024 by Roman Savochenko, <roman@oscada.org> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; version 2 of the License. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <string>
#include <sys/times.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <math.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdarg.h>
#include "mod_tests.h"
#include "test_prm.h"
#include "test_xml.h"
#include "test_mess.h"
#include "test_SOAttach.h"
#include "test_val.h"
#include "test_DB.h"
#include "test_TrOut.h"
#include "test_SysContrLang.h"
#include "test_ValBuf.h"
#include "test_archive.h"
#include "test_Base64Code.h"
//*************************************************
//* Modul info! *
#define MOD_ID "SystemTests"
#define MOD_NAME trS("OpenSCADA and its modules' tests")
#define MOD_TYPE SSPC_ID
#define VER_TYPE SSPC_VER
#define SUB_TYPE "TEST"
#define MOD_VER "1.8.10"
#define AUTHORS trS("Roman Savochenko")
#define DESCRIPTION trS("Provides the group of tests to OpenSCADA and its modules.")
#define LICENSE "GPL2"
//*************************************************
KernelTest::TTest *KernelTest::mod;
extern "C"
{
TModule::SAt module( int n_mod )
{
if(n_mod == 0) return TModule::SAt(MOD_ID,MOD_TYPE,VER_TYPE);
return TModule::SAt("");
}
TModule *attach( const TModule::SAt &AtMod, const string &source )
{
if(AtMod == TModule::SAt(MOD_ID,MOD_TYPE,VER_TYPE)) return new KernelTest::TTest(source);
return NULL;
}
}
using namespace KernelTest;
//*************************************************
//* BDTest::TTest *
//*************************************************
TTest::TTest( string name ) : TSpecial(MOD_ID)
{
mod = this;
modInfoMainSet(MOD_NAME, MOD_TYPE, MOD_VER, AUTHORS, DESCRIPTION, LICENSE, name);
mTest = grpAdd("test_",true);
}
TTest::~TTest()
{
if(runSt) modStop();
}
void TTest::postEnable( int flag )
{
TModule::postEnable(flag);
if(flag&TCntrNode::NodeRestore) return;
//> Reg static tests
testReg(new TestPrm());
testReg(new TestXML());
testReg(new TestMess());
testReg(new TestSOAttach());
testReg(new TestVal());
testReg(new TestDB());
testReg(new TestTrOut());
testReg(new TestSysContrLang());
testReg(new TestValBuf());
testReg(new TestArchive());
testReg(new TestBase64Code());
//> Enable static tests
vector<string> lst;
testList(lst);
for(unsigned i_l = 0; i_l < lst.size(); i_l++)
testAt(lst[i_l]).at().setStart(true);
}
string TTest::cat( ) { return "TEST:" MOD_ID ":"; }
void TTest::mess( const string &testNm, const char *fmt, ... )
{
char mess[prmStrBuf_SZ];
va_list argptr;
va_start(argptr, fmt);
vsnprintf(mess, sizeof(mess), fmt, argptr);
va_end(argptr);
mess_info((cat()+testNm).c_str(), "%s", mess);
}
void TTest::modInfo( vector<string> &list )
{
TModule::modInfo(list);
list.push_back("SubType");
}
string TTest::modInfo( const string &name )
{
if(name == "SubType") return SUB_TYPE;
return TModule::modInfo(name);
}
string TTest::optDescr( )
{
string rez;
rez = TSYS::strMess(_(
"======================= Module <%s:%s> options =======================\n"
"---- Parameters of the module section '%s' of the configuration file ----\n"
" *** Main options of all the tests ***\n"
" id test id;\n"
" on flag enabling test;\n"
" per period of repeating, seconds.\n"
" *** Test options ***\n"), MOD_TYPE, MOD_ID, nodePath().c_str());
vector<string> ls;
testList(ls);
for(unsigned iT = 0; iT < ls.size(); iT++) {
AutoHD<TFunction> fnc = testAt(ls[iT]);
rez += TSYS::strMess(" %d) %s\t%s\n",iT+1,fnc.at().id().c_str(),fnc.at().descr().c_str());
for(int i_prm = 0; i_prm < fnc.at().ioSize( ); i_prm++) {
if(fnc.at().io(i_prm)->flg() & (IO::Output|IO::Return)) continue;
rez += TSYS::strMess(" %d:%s\t%s\n",i_prm,fnc.at().io(i_prm)->id().c_str(),fnc.at().io(i_prm)->name().c_str());
}
}
rez += "\n";
return rez;
}
void TTest::load_( )
{
// Load parameters from command line
// Load parameters from config-file
}
void TTest::modStart( )
{
if(!runSt) SYS->taskCreate(nodePath('.',true), 0, Task, this);
}
void TTest::modStop( )
{
if(runSt) SYS->taskDestroy(nodePath('.',true), &endrun);
}
void *TTest::Task( void *CfgM )
{
int count = 0, i_cnt = 0;
TTest *tst = (TTest*)CfgM;
tst->runSt = true;
tst->endrun = false;
//Task counter
while(!tst->endrun)
{
//1 sec
if(++i_cnt > 1/prmWait_DL) // 1 sec
{
i_cnt = 0;
if(++count == 1000000) count = 0;
//Get All fields
ResAlloc res(SYS->cfgRes(), false);
XMLNode *mn = SYS->cfgNode(tst->nodePath(0,false)), *t_n = NULL;
for(int nd_cnt = 0; mn && (t_n=mn->childGet("prm",nd_cnt++,true)); )
if(tst->testPresent(t_n->attr("id")) && t_n->attr("on") == "1" &&
s2i(t_n->attr("per")) && !(count%s2i(t_n->attr("per"))))
{
AutoHD<TFunction> fnc = tst->testAt(t_n->attr("id"));
TValFunc fc("stdcalc", &fnc.at());
for(int i_prm = 0; i_prm < fc.ioSize( ); i_prm++)
{
if(fc.ioFlg(i_prm) & (IO::Output|IO::Return)) continue;
fc.setS(i_prm, t_n->attr(fc.func()->io(i_prm)->id()));
}
try{ fc.calc("root"); }
catch(TError &err) { mess_err(err.cat.c_str(), "%s", err.mess.c_str()); }
}
}
TSYS::sysSleep(prmWait_DL);
}
tst->runSt = false;
return NULL;
}
void TTest::prXMLNode( const string &testNm, XMLNode *node, int level )
{
vector<string> list;
mess(testNm, _("%s{%d \"%s\", text \"%s\", childs - %d."),
string(level,' ').c_str(), level, node->name().c_str(), node->text().c_str(), node->childSize());
node->attrList(list);
for(unsigned i_att = 0; i_att < list.size(); i_att++)
mess(testNm, _(" Attr \"%s\" = \"%s\"."), list[i_att].c_str(), node->attr(list[i_att]).c_str());
for(unsigned i_ch = 0; i_ch < node->childSize(); i_ch++)
prXMLNode(testNm, node->childGet(i_ch), level+1);
mess(testNm, "%s}%d \"%s\"", string(level,' ').c_str(), level, node->name().c_str());
}
TVariant TTest::objFuncCall( const string &id, vector<TVariant> &prms, const string &user_lang )
{
// ElTp {funcID}(ElTp prm1, ...) - the test {funcID} call
// prm{N} - {N} parameter to the test.
if(testPresent(id)) return testAt(id).at().objFuncCall("call", prms, user_lang);
return TCntrNode::objFuncCall(id, prms, user_lang);
}
void TTest::cntrCmdProc( XMLNode *opt )
{
//Get page info
if(opt->name() == "info")
{
TSpecial::cntrCmdProc(opt);
ctrMkNode("grp",opt,-1,"/br/test_",_("Test"),R_R_R_,"root",SSPC_ID,2,"idm",i2s(limObjNm_SZ).c_str(),"idSz",i2s(limObjID_SZ).c_str());
if(ctrMkNode("area",opt,1,"/tests",_("Tests")))
{
ctrMkNode("fld",opt,-1,"/tests/nmb",_("Number"),R_R_R_,"root",SSPC_ID,1,"tp","str");
ctrMkNode("list",opt,-1,"/tests/tests",_("Tests"),R_R_R_,"root",SSPC_ID,4,
"tp","br","idm",i2s(limObjNm_SZ).c_str(),"br_pref","test_","idSz",i2s(limObjID_SZ).c_str());
}
return;
}
//Process command to page
string a_path = opt->attr("path");
if((a_path == "/br/test_" || a_path == "/tests/tests") && ctrChkNode(opt,"get",R_R_R_,"root",SSPC_ID,SEC_RD))
{
vector<string> lst;
testList(lst);
for(unsigned iT = 0; iT < lst.size(); iT++)
opt->childAdd("el")->setAttr("id",lst[iT])->setText(testAt(lst[iT]).at().name());
}
else if(a_path == "/tests/nmb" && ctrChkNode(opt))
{
vector<string> lst;
testList(lst);
int enCnt = 0;
for(unsigned iT = 0; iT < lst.size(); iT++)
if(testAt(lst[iT]).at().startStat()) enCnt++;
opt->setText(TSYS::strMess(_("All: %d; Accessed: %d"),lst.size(),enCnt));
}
else TSpecial::cntrCmdProc(opt);
}