return iResult;
}
+int AliHLTComponent::ConfigureFromArgumentString(int argc, const char** argv)
+{
+ // see header file for function documentation
+ int iResult=0;
+ vector<const char*> array;
+ TObjArray choppedArguments;
+ TString argument="";
+ int i=0;
+ for (i=0; i<argc && iResult>=0; i++) {
+ argument=argv[i];
+ if (argument.IsNull()) continue;
+ TObjArray* pTokens=argument.Tokenize(" ");
+ if (pTokens) {
+ if (pTokens->GetEntriesFast()<2) {
+ array.push_back(argv[i]);
+ } else {
+ for (int n=0; n<pTokens->GetEntriesFast(); n++) {
+ choppedArguments.AddLast(pTokens->At(n));
+ array.push_back(((TObjString*)pTokens->At(n))->GetString().Data());
+ }
+ pTokens->SetOwner(kFALSE);
+ }
+ delete pTokens;
+ }
+ }
+
+ for (i=0; (unsigned)i<array.size() && iResult>=0;) {
+ int result=ScanConfigurationArgument(array.size()-i, &array[i]);
+ if (result==0) {
+ HLTWarning("unknown component argument %s", array[i]);
+ i++;
+ } else if (result>0) {
+ i+=result;
+ } else {
+ iResult=result;
+ if (iResult==-EINVAL) {
+ HLTError("unknown argument %s", array[i]);
+ } else if (iResult==-EPROTO) {
+ HLTError("missing/wrong parameter for argument %s (%s)", array[i], array.size()>(unsigned)i+1)?array[i+1]:"missing";
+ } else {
+ HLTError("scan of argument %s failed (%d)", array[i], iResult);
+ }
+ }
+ }
+
+ return iResult;
+}
+
+int AliHLTComponent::ConfigureFromCDBTObjString(const char* entries)
+{
+ // see header file for function documentation
+ int iResult=0;
+ TString arguments;
+ TString confEntries=entries;
+ TObjArray* pTokens=confEntries.Tokenize(" ");
+ if (pTokens) {
+ for (int n=0; n<pTokens->GetEntriesFast(); n++) {
+ const char* path=((TObjString*)pTokens->At(n))->GetString().Data();
+ const char* chainId=GetChainId();
+ HLTInfo("configure from entry %s, chain id %s", path, (chainId!=NULL && chainId[0]!=0)?chainId:"<none>");
+ TObject* pOCDBObject = LoadAndExtractOCDBObject(path);
+ if (pOCDBObject) {
+ TObjString* pString=dynamic_cast<TObjString*>(pOCDBObject);
+ if (pString) {
+ HLTInfo("received configuration object string: \'%s\'", pString->GetString().Data());
+ arguments+=pString->GetString().Data();
+ arguments+=" ";
+ } else {
+ HLTError("configuration object \"%s\" has wrong type, required TObjString", path);
+ iResult=-EINVAL;
+ }
+ } else {
+ HLTError("can not fetch object \"%s\" from OCDB", path);
+ iResult=-ENOENT;
+ }
+ }
+ delete pTokens;
+ }
+ if (iResult>=0 && !arguments.IsNull()) {
+ const char* array=arguments.Data();
+ iResult=ConfigureFromArgumentString(1, &array);
+ }
+ return iResult;
+}
+
+TObject* AliHLTComponent::LoadAndExtractOCDBObject(const char* path, int version, int subVersion)
+{
+ // see header file for function documentation
+ AliCDBEntry* pEntry=AliHLTMisc::Instance().LoadOCDBEntry(path, GetRunNo(), version, subVersion);
+ if (!pEntry) return NULL;
+ return AliHLTMisc::Instance().ExtractObject(pEntry);
+}
+
int AliHLTComponent::DoInit( int /*argc*/, const char** /*argv*/)
{
// default implementation, childs can overload
return 0;
}
+int AliHLTComponent::ScanConfigurationArgument(int /*argc*/, const char** /*argv*/)
+{
+ // default implementation, childs can overload
+ HLTLogKeyword("dummy");
+ HLTWarning("The function needs to be implemented by the component");
+ return 0;
+}
+
int AliHLTComponent::StartOfRun()
{
// default implementation, childs can overload
* If the component has multiple output data types @ref GetOutputDataType
* should return @ref kAliHLTMultipleDataType. The framework will invoke
* @ref GetOutputDataTypes, a list can be filled.
+ * - @ref Reconfigure
+ * This function is invoked by the framework on a special event which
+ * triggers the reconfiguration of the component.
*
* @subsection alihltcomponent-processing-mehods Data processing
*
* framework will allocate a buffer of appropriate size and call the processing
* again.
*
- * @subsection alihltcomponent-error-codes Data processing
+ * @subsection alihltcomponent-error-codes Return values/Error codes
* For return codes, the following scheme applies:
* - The data processing methods have to indicate error conditions by a negative
* error/return code. Preferably the system error codes are used like
* <pre>
* \#include \<cerrno\>
* </pre>
+ * This schema aplies to all interface functions of the component base class.
+ * For data processing it is as follows:
* - If no suitable input block could be found (e.g. no clusters for the TPC cluster
* finder) set size to 0, block list is empty, return 0
* - If no ususable or significant signal could be found in the input blocks
* - @ref AliHLTDataSource::GetEvent
* - @ref AliHLTDataSink::DumpEvent
*
- *
+ * The base class passes all relevant parameters for data access directly on to the
+ * component. Input blocks can be accessed by means of the array <tt> blocks </tt>.
+ * Output data are written directly to shared memory provided by the pointer
+ * <tt> outputPtr </tt> and output block descriptors are inserted directly to the
+ * list <tt> outputBlocks </tt>.
+ *
+ * \b NOTE: The high-level input data access methods can be used also from the low
+ * level interface. Also the PushBack functions can be used BUT ONLY if no data is
+ * written to the output buffer and no data block descriptors are inserted into the
+ * output block list.
+ *
+ * @section alihltcomponent-initialization Component initialization and configuration
+ * The component interface provides two optional methods for component initialization
+ * and configuration. The @ref DoInit function is called once before the processing.
+ * During the event processing, a special event can trigger a reconfiguration and the
+ * @ref Reconfigure method is called. There are three possible options of initialization
+ * and configuration:
+ * - default values: set directly in the source code
+ * - OCDB objects: all necessary information must be loaded from OCDB objects. The
+ * Offline Conditions Data Base stores objects specifically valid for individual runs
+ * or run ranges.
+ * - Component arguments: can be specified for every component in the chain
+ * configuration. The arguments can be used to override specific parameters of the
+ * component.
+ *
+ * As a general rule, the three options should be processed in that sequence, i.e
+ * default parameters might be overridden by OCDB configuration, and the latter one
+ * by component arguments.
+ *
+ * @subsection alihltcomponent-initialization-arguments Component arguments
+ * In normal operation, components are supposed to run without any additional argument,
+ * however such arguments can be useful for testing and debugging. The idea follows
+ * the format of command line arguments. A keyword is indicated by a dash and an
+ * optional argument might follow, e.g.:
+ * <pre>
+ * -argument1 0.5 -argument2
+ * </pre>
+ * In this case argument1 requires an additional parameter whereas argument2 does not.
+ * The arguments will be provided as an array of separated arguments.
+ *
+ * Component arguments can be classified into initialization arguments and configuration
+ * arguments. The latter are applicable for both the @ref DoInit and @ref Reconfigure
+ * method whereas initialization arguments are not applicable after DoInit.
+ *
+ * @subsection alihltcomponent-initialization-ocdb OCDB objects
+ * OCDB objects are ROOT <tt>TObjects</tt> and can be of any type. This is in particular
+ * useful for complex parameter sets. However in most cases, a simple approach of human
+ * readable command line arguments is appropriate. Such a string can be simply stored
+ * in a TObjString (take note that the TString does not derive from TObject). The
+ * same arguments as for the command line can be used. Take note that in the TObjString
+ * all arguments are separated by blanks, instead of being in an array of separate
+ * strings.
+ *
+ * The base class provides two functions regarding OCDB objects:
+ * - LoadAndExtractOCDBObject() loads the OCDB entry for the specified path and extracts
+ * the TObject from it.
+ * - ConfigureFromCDBTObjString() can load a number of OCDB objects and calls the
+ * argument parsing ConfigureFromArgumentString
+ *
+ *
+ * @subsection alihltcomponent-initialization-sequence Initialization sequence
+ * Using the approach of <tt>TObjString</tt>-type configuration objects allows to treat
+ * configuration from both @ref DoInit and @ref Reconfigure in the same way.
+ *
+ * The base class provides the function ConfigureFromArgumentString() which loops over
+ * all arguments and calls the child's method ScanConfigurationArgument(). Here the
+ * actual treatment of the argument and its parameters needs to be implemented.
+ * ConfigureFromArgumentString() can treat both arrays of arguments and arguments in
+ * one single string separated by blanks. The two options can be mixed.
+ *
+ * A second bas class function ConfigureFromCDBTObjString() allows to configure
+ * directly from a number of OCDB objects. This requires the entries to be of
+ * type TObjString and the child implementation of ScanConfigurationArgument().
+ *
* @section alihltcomponent-handling Component handling
* The handling of HLT analysis components is carried out by the AliHLTComponentHandler.
* Component are registered automatically at load-time of the component shared library
* under the following suppositions:
* - the component library has to be loaded from the AliHLTComponentHandler using the
* @ref AliHLTComponentHandler::LoadLibrary method.
+ * - the library defines an AliHLTModuleAgent which registers all components.
+ * See AliHLTModuleAgent::RegisterComponents <br>
+ * or <br>
* - the component implementation defines one global object (which is generated
- * when the library is loaded)
+ * when the library is loaded) <br>
*
* @subsection alihltcomponent-design-rules General design considerations
* The analysis code should be implemented in one or more destict class(es). A
*
* Further rules:
* - avoid big static arrays in the component, allocate the memory at runtime
+ * - allocate all kind of complex data members (like classes, ROOT TObjects of
+ * any kind) dynamically in DoInit and clean up in DoDeinit
*
* @section alihlt_component_arguments Default arguments
* The component base class provides some default arguments:
* leading absolute path of the CDB location. The framework might also
* provide the id of the component in the analysis chain.
*
+ * The actual sequence of configuration depends on the component. As a
+ * general rule, the component should load the specific OCDB object if
+ * provided as parameter, and load the default objects if the parameter
+ * is NULL. However, other schemes are possible. See @ref
+ *
* \b Note: The CDB will be initialized by the framework, either already set
* from AliRoot or from the wrapper interface during initialization.
*
*/
virtual int ReadPreprocessorValues(const char* modules);
+ /**
+ * Child implementation to scan a number of configuration arguments.
+ * The method is invoked by the framework in conjunction with the
+ * common framework functions ConfigureFromArgumentString and
+ * ConfigureFromCDBTObjString.
+ * Function needs to scan the argument and optional additional
+ * parameters and returns the number of elements in the array which
+ * have been treated.
+ * @param argc
+ * @param argv
+ * @return number of arguments which have been scanned or neg error
+ * code if failed <br>
+ * \li -EINVAL unknown argument
+ * \li -EPROTO protocol error, e.g. missing parameter
+ */
+ virtual int ScanConfigurationArgument(int argc, const char** argv);
+
/**
* Custom handler for the SOR event.
* Is invoked from the base class if an SOR event is in the block list.
*/
void DataType2Text(const AliHLTComponentDataType& type, char output[kAliHLTComponentDataTypefIDsize+kAliHLTComponentDataTypefOriginSize+2]) const;
+ /**
+ * Loop through a list of component arguments.
+ * The list can be either an array of separated strings or one single
+ * string containing blank separated arguments, or both mixed.
+ * ScanConfigurationArgument() is called to allow the component to treat
+ * the individual arguments.
+ * @return neg. error code if failed
+ */
+ int ConfigureFromArgumentString(int argc, const char** argv);
+
+ /**
+ * Read configuration objects from OCDB and configure from
+ * the content of TObjString entries.
+ * @param entries blank separated list of OCDB paths
+ * @return neg. error code if failed
+ */
+ int ConfigureFromCDBTObjString(const char* entries);
+
+ /**
+ * Load specified entry from the OCDB and extract the object.
+ * The entry is explicitely unloaded from the cache before it is loaded.
+ * @param path path of the entry under to root of the OCDB
+ * @param version version of the entry
+ * @param subVersion subversion of the entry
+ */
+ TObject* LoadAndExtractOCDBObject(const char* path, int version = -1, int subVersion = -1);
+
+
/**
* Get event number.
* @return value of the internal event counter
EXTRA_DIST =
check_PROGRAMS = testAliHLTBlockDataCollection \
+ testAliHLTComponent \
dtOperators \
testDefaultDataTypes
-# testAliHLT_C_Component_WrapperInterface
+# testAliHLT_C_Component_WrapperInterface
testAliHLTBlockDataCollection_SOURCES = testAliHLTBlockDataCollection.cxx
testAliHLTBlockDataCollection_LDADD = $(top_builddir)/BASE/libHLTbase.la
testDefaultDataTypes_SOURCES = testDefaultDataTypes.C
testDefaultDataTypes_LDADD = $(top_builddir)/BASE/libHLTbase.la
+testAliHLTComponent_SOURCES = testAliHLTComponent.C
+testAliHLTComponent_LDADD = $(top_builddir)/BASE/libHLTbase.la
+
TESTS = $(check_PROGRAMS)
int iStart=0;
for (;arguments[i]!=0; i++) {
if (arguments[i]=='\'') {
- if (bQuote=!bQuote) {
+ if (bQuote=(!bQuote)) {
// opening quote, set start
} else {
// closing quote, add argument
/** @file testAliHLTComponent_CTPTrigger.C
@author Matthias Richter
@date
- @brief Test program for default data types
+ @brief Test program for the AliHLTComponent base class
*/
#ifndef __CINT__
#include "TRandom.h"
#include "AliHLTDataTypes.h"
#include "AliHLTProcessor.h"
+#include "algorithm"
+#include "TObjArray.h"
+#include "TObjString.h"
+#include "TString.h"
#endif
+using namespace std;
+
class AliHLTTestComponent : public AliHLTProcessor
{
public:
- AliHLTTestComponent() {}
+ AliHLTTestComponent() :
+ fArguments(),
+ fCurrentArgument(fArguments.begin())
+ {}
+
~AliHLTTestComponent() {}
const char* GetComponentID() {return "TestComponent";};
void GetOutputDataSize(unsigned long& constBase, double& inputMultiplier) {constBase=0; inputMultiplier=0;}
AliHLTComponent* Spawn() {return new AliHLTTestComponent;}
- int InitTest(const char* param) {
- return ScanECSParam(param);
+ class AliHLTConfigurationArgument {
+ public:
+ AliHLTConfigurationArgument(const char* argument) :
+ fElements(NULL)
+ {
+ TString work=argument;
+ fElements=work.Tokenize(" ");
+ }
+
+ AliHLTConfigurationArgument(const AliHLTConfigurationArgument& src) :
+ fElements(NULL)
+ {
+ if (src.fElements) {
+ fElements=dynamic_cast<TObjArray*>(src.fElements->Clone());
+ }
+ }
+
+ ~AliHLTConfigurationArgument() {
+ if (fElements) delete fElements;
+ }
+
+ AliHLTConfigurationArgument& operator=(const AliHLTConfigurationArgument& src) {
+ delete fElements;
+ if (src.fElements) {
+ fElements=dynamic_cast<TObjArray*>(src.fElements->Clone());
+ }
+ return *this;
+ }
+
+ const char* Argument() {
+ if (!fElements) return NULL;
+ return ((TObjString*)fElements->At(0))->GetString().Data();
+ }
+
+ int NofParameters() {
+ if (!fElements) return 0;
+ return fElements->GetEntriesFast()-1;
+ }
+
+ const char* Parameter(int i) {
+ if (!fElements ||
+ fElements->GetEntriesFast()<=i+1) return NULL;
+ return ((TObjString*)fElements->At(i+1))->GetString().Data();
+ }
+
+ bool operator==(const char* string) {
+ if (!fElements) return 0;
+ return (((TObjString*)fElements->At(0))->GetString().CompareTo(string))==0;
+ }
+
+ bool operator!=(const char* string) {
+ return !operator==(string);
+ }
+
+ void Print() {
+ if (!fElements) {
+ cout << "############# empty ############" << endl;
+ return;
+ }
+ cout << " Print: " << Argument() << " with " << NofParameters() << " parameter(s)";
+ for (int n=0; n<NofParameters(); n++) cout << " " << Parameter(n);
+ cout << endl;
+ }
+
+ private:
+ TObjArray* fElements;
+ };
+
+ int ScanConfigurationArgument(int argc, const char** argv) {
+ if (fCurrentArgument==fArguments.end()) return 0;
+ int count=0;
+
+ // check whether it is an argument at all
+ if (*(argv[count])!='-') {
+ cerr << "not a recognized argument: " << argv[count] << endl;
+ return -EINVAL;
+ }
+
+ // check whether the argument matches
+ //fCurrentArgument->Print();
+ if (*fCurrentArgument!=argv[count]) {
+ cerr << "argument sequence does not match: got " << argv[count] << " expected " << fCurrentArgument->Argument() << endl;
+ return -EINVAL;
+ }
+
+ count++;
+ // read parameters
+ if (fCurrentArgument->NofParameters()>0) {
+ if (argc<=count) {
+ cerr << "missing parameter" << endl;
+ return -EPROTO;
+ }
+
+ // implement more checks here
+ count+=fCurrentArgument->NofParameters();
+ }
+ fCurrentArgument++;
+ return count;
+ }
+
+ int FillArgumentVector(const char** arguments, vector<AliHLTConfigurationArgument>& list) {
+ list.clear();
+ for (const char** iter=arguments; *iter!=NULL; iter++) {
+ list.push_back(AliHLTConfigurationArgument(*iter));
+ }
+ return list.size();
+ }
+
+ int FillArgv(vector<AliHLTConfigurationArgument>& list, vector<const char*>& argv) {
+ argv.clear();
+ for (vector<AliHLTConfigurationArgument>::iterator argument=list.begin();
+ argument!=list.end(); argument++) {
+ argv.push_back(argument->Argument());
+ for (int n=0; n<argument->NofParameters(); n++) {
+ argv.push_back(argument->Parameter(n));
+ }
+ }
+ return argv.size();
+ }
+
+ void PrintArgv(int argc, const char** argv) {
+ for (int n=0; n<argc; n++) {
+ cout << " " << n << " : " << argv[n] << endl;
+ }
+ }
+
+ int CheckSequence(const char* sequence[], int mode=0) {
+ int iResult=0;
+ if ((iResult=FillArgumentVector(sequence, fArguments))<0) {
+ cerr << "failed to fill argument vector" << endl;
+ return iResult;
+ }
+ vector<const char*> argv;
+ if (mode==0) {
+ if ((iResult=FillArgv(fArguments, argv))<0) {
+ cerr << "failed to fill argument array" << endl;
+ return iResult;
+ }
+ } else {
+ for (const char** element=sequence; *element!=NULL; element++)
+ argv.push_back(*element);
+ }
+ fCurrentArgument=fArguments.begin();
+ //PrintArgv(argv.size(), &argv[0]);
+ if ((iResult=ConfigureFromArgumentString(argv.size(), &argv[0]))<0) {
+ cerr << "ConfigureFromArgumentString failed " << endl;
+ return iResult;
+ }
+
+ return iResult;
+ }
+
+ int CheckConfigure() {
+ int iResult=0;
+ const char* sequence1[]={"-sequence1","-argument2 5", NULL};
+ if ((iResult=CheckSequence(sequence1))<0) {
+ cerr << "failed checking sequence " << sequence1[0] << endl;
+ return iResult;
+ }
+
+ const char* sequence2[]={"-sequence2","-argument2 5 8", "-argument3 test", NULL};
+ if ((iResult=CheckSequence(sequence2))<0) {
+ cerr << "failed checking sequence in mode 0: " << sequence2[0] << endl;
+ return iResult;
+ }
+
+ if ((iResult=CheckSequence(sequence2, 1))<0) {
+ cerr << "failed checking sequence in mode 1: " << sequence2[0] << endl;
+ return iResult;
+ }
+
+ const char* sequence3[]={"-solenoidBz 5", NULL};
+ if ((iResult=CheckSequence(sequence3))<0) {
+ cerr << "failed checking sequence " << sequence3[0] << endl;
+ return iResult;
+ }
+ return iResult;
+ }
+
+ int InitCTPTest(const char* param) {
+ // this quick test needs to be the functions of the base class to be
+ // defined 'protected'
+ //return ScanECSParam(param);
//return InitCTPTriggerClasses(param);
+ return -ENOSYS;
}
- bool Check(const char* expression, AliHLTComponentTriggerData* data) {
+ bool CheckCTP(const char* expression, AliHLTComponentTriggerData* data) {
return EvaluateCTPTriggerClass(expression, *data);
}
AliHLTComponentTriggerData& /*trigData*/) {
return 0;
}
+private:
+ vector<AliHLTConfigurationArgument> fArguments;
+ vector<AliHLTConfigurationArgument>::iterator fCurrentArgument;
};
class AliHLTTriggerDataAccess
Byte_t* fMine;
};
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+//
+// setup of the CTP test
+
/**
* Get a random number in the given range.
*/
return classes.size();
}
-int testAliHLTComponent_CTPTrigger()
+/**
+ * Test the CTP trigger tools
+ * The base class is initialized with an ECS string of randomly defined trigger
+ * classes consisting of random bits and names. Than a couple of expressions is
+ * test for various random bit patterns.
+ */
+int testCTPTrigger()
{
+ cout << "checking CTP functionality of the base class" << endl;
int iResult=0;
vector<AliHLTTestComponent::AliHLTCTPTriggerClass> triggerClasses;
if (GenerateTriggerClasses(GetRandom(5,gkNCTPTriggerClasses), triggerClasses)<=0) {
AliHLTTestComponent component;
component.SetGlobalLoggingLevel(kHLTLogDefault);
- if ((iResult=component.InitTest(parameter.Data()))<0) return iResult;
+ if ((iResult=component.InitCTPTest(parameter.Data()))<0) {
+ cerr << "InitCTPTest failed :" << iResult << endl;
+ return iResult;
+ }
AliHLTTriggerDataAccess trigData;
for (int cycle=0; cycle<500 && iResult>=0; cycle++) {
// is
result=element->Trigger();
expression=element->ClassName();
- trigger=component.Check(expression.Data(), trigData.Data());
+ trigger=component.CheckCTP(expression.Data(), trigData.Data());
if (trigger!=result) {
cout << expression << ": " << element->Trigger()
<< "->" << trigger
expression="!";
expression+=element->ClassName();
result=!result;
- trigger=component.Check(expression.Data(), trigData.Data());
+ trigger=component.CheckCTP(expression.Data(), trigData.Data());
if (trigger!=result) {
cout << expression << ": " << element->Trigger()
<< "->" << trigger
result=shuffle[0].Trigger() || shuffle[1].Trigger() || shuffle[2].Trigger();
expression.Form("%s || %s || %s",
shuffle[0].ClassName(), shuffle[1].ClassName(), shuffle[2].ClassName());
- trigger=component.Check(expression.Data(), trigData.Data());
+ trigger=component.CheckCTP(expression.Data(), trigData.Data());
if (trigger!=result) {
cout << expression << ": " << shuffle[0].Trigger() << shuffle[1].Trigger() << shuffle[2].Trigger()
<< "->" << trigger
expression.Form("%s && %s && %s",
shuffle[0].ClassName(), shuffle[1].ClassName(), shuffle[2].ClassName());
- trigger=component.Check(expression.Data(), trigData.Data());
+ trigger=component.CheckCTP(expression.Data(), trigData.Data());
if (trigger!=result) {
cout << expression << ": " << shuffle[0].Trigger() << shuffle[1].Trigger() << shuffle[2].Trigger()
<< "->" << trigger
expression.Form("%s && (%s || %s)",
shuffle[0].ClassName(), shuffle[1].ClassName(), shuffle[2].ClassName());
- trigger=component.Check(expression.Data(), trigData.Data());
+ trigger=component.CheckCTP(expression.Data(), trigData.Data());
if (trigger!=result) {
cout << expression << ": " << shuffle[0].Trigger() << shuffle[1].Trigger() << shuffle[2].Trigger()
<< "->" << trigger
return iResult;
}
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+//
+// setup of the Configure test
+int testConfigure()
+{
+ cout << "checking common configuration tools of the base class" << endl;
+ AliHLTTestComponent component;
+ return component.CheckConfigure();
+}
+
+/////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////
+//
+// main functions
+
+int testAliHLTComponent()
+{
+ int iResult=0;
+ //if ((iResult=testCTPTrigger())<0) return iResult;
+ if ((iResult=testConfigure())<0) return iResult;
+ return iResult;
+}
+
int main(int /*argc*/, const char** /*argv*/)
{
int iResult=0;
- iResult=testAliHLTComponent_CTPTrigger();
+ iResult=testAliHLTComponent();
return iResult;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff