--- /dev/null
+// $Id$
+
+/**************************************************************************
+ * This file is property of and copyright by the ALICE HLT Project *
+ * ALICE Experiment at CERN, All rights reserved. *
+ * *
+ * Primary Authors: Matthias Richter <Matthias.Richter@ift.uib.no> *
+ * for The ALICE HLT Project. *
+ * *
+ * Permission to use, copy, modify and distribute this software and its *
+ * documentation strictly for non-commercial purposes is hereby granted *
+ * without fee, provided that the above copyright notice appears in all *
+ * copies and that both the copyright notice and this permission notice *
+ * appear in the supporting documentation. The authors make no claims *
+ * about the suitability of this software for any purpose. It is *
+ * provided "as is" without express or implied warranty. *
+ **************************************************************************/
+
+/** @file testDefaultDataTypes.C
+ @author Matthias Richter
+ @date
+ @brief Test program for default data types
+ */
+
+#include "AliHLTDataTypes.h"
+#include "AliHLTComponent.h"
+
+int main(int /*argc*/, const char** /*argv*/)
+{
+ /** multiple output data types */
+ const AliHLTComponentDataType kAliHLTMultipleDataTypeTest = {
+ sizeof(AliHLTComponentDataType),
+ {'M','U','L','T','I','P','L','E'},
+ {'P','R','I','V'}
+ };
+
+ /** data to file exchange subscriber */
+ const AliHLTComponentDataType kAliHLTDataTypeFXSCalibTest = {
+ sizeof(AliHLTComponentDataType),
+ {'F','X','S','_','C','A','L',' '},
+ {'H','L','T',' '}
+ };
+
+ /** DDL list data type */
+ const AliHLTComponentDataType kAliHLTDataTypeDDLTest = {
+ sizeof(AliHLTComponentDataType),
+ {'D','D','L','L','I','S','T',' '},
+ {'H','L','T',' '}
+ };
+
+ /** SOR data type */
+ const AliHLTComponentDataType kAliHLTDataTypeSORTest = {
+ sizeof(AliHLTComponentDataType),
+ {'S','T','A','R','T','O','F','R'},
+ {'P','R','I','V'}
+ };
+
+ /** EOR data type */
+ const AliHLTComponentDataType kAliHLTDataTypeEORTest = {
+ sizeof(AliHLTComponentDataType),
+ {'E','N','D','O','F','R','U','N'},
+ {'P','R','I','V'}
+ };
+
+ /** run type data block */
+ const AliHLTComponentDataType kAliHLTDataTypeRunTypeTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','U','N','T','Y','P','E',' '},
+ {'P','R','I','V'}
+ };
+
+ /** Event type specification */
+ const AliHLTComponentDataType kAliHLTDataTypeEventTest = {
+ sizeof(AliHLTComponentDataType),
+ {'E','V','E','N','T','T','Y','P'},
+ {'P','R','I','V'}
+ };
+
+ /** Configuration event data type */
+ const AliHLTComponentDataType kAliHLTDataTypeComConfTest = {
+ sizeof(AliHLTComponentDataType),
+ {'C','O','M','_','C','O','N','F'},
+ {'P','R','I','V'}
+ };
+
+ /** DCS value update event */
+ const AliHLTComponentDataType kAliHLTDataTypeUpdtDCSTest = {
+ sizeof(AliHLTComponentDataType),
+ {'U','P','D','T','_','D','C','S'},
+ {'P','R','I','V'}
+ };
+
+ /** RAW DDL data specification, data publisher will set type id and origin correctly */
+ const AliHLTComponentDataType kAliHLTDataTypeDDLRawTest = {
+ sizeof(AliHLTComponentDataType),
+ {'D','D','L','_','R','A','W',' '},
+ {'*','*','*','\0'}
+ };
+
+ /** ESD data specification */
+ const AliHLTComponentDataType kAliHLTDataTypeESDObjectTest = {
+ sizeof(AliHLTComponentDataType),
+ {'A','L','I','E','S','D','V','0'},
+ {'*','*','*','\0'}
+ };
+
+ /** ESD tree data specification */
+ const AliHLTComponentDataType kAliHLTDataTypeESDTreeTest = {
+ sizeof(AliHLTComponentDataType),
+ {'E','S','D','_','T','R','E','E'},
+ {'*','*','*','\0'}
+ };
+
+ /** AliRoot TreeD data specification */
+ const AliHLTComponentDataType kAliHLTDataTypeAliTreeDTest = {
+ sizeof(AliHLTComponentDataType),
+ {'A','L','I','T','R','E','E','D'},
+ {'*','*','*','\0'}
+ };
+
+ /** AliRoot TreeR data specification */
+ const AliHLTComponentDataType kAliHLTDataTypeAliTreeRTest = {
+ sizeof(AliHLTComponentDataType),
+ {'A','L','I','T','R','E','E','R'},
+ {'*','*','*','\0'}
+ };
+
+ /** 16 bit Hardware address selection data specification, origin is 'any' */
+ const AliHLTComponentDataType kAliHLTDataTypeHwAddr16Test = {
+ sizeof(AliHLTComponentDataType),
+ {'H','W','A','D','D','R','1','6'},
+ {'*','*','*','\0'}
+ };
+
+ /** Event statistics */
+ const AliHLTComponentDataType kAliHLTDataTypeEventStatisticsTest = {
+ sizeof(AliHLTComponentDataType),
+ {'E','V','_','S','T','A','T','I'},
+ {'*','*','*','\0'}
+ };
+
+ /** Event summary */
+ const AliHLTComponentDataType kAliHLTDataTypeEventSummaryTest = {
+ sizeof(AliHLTComponentDataType),
+ {'E','V','_','S','U','M','M','A'},
+ {'H','L','T',' '}
+ };
+
+ /** Run statistics */
+ const AliHLTComponentDataType kAliHLTDataTypeRunStatisticsTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','U','N','S','T','A','T','I'},
+ {'*','*','*','\0'}
+ };
+
+ /** Run summary */
+ const AliHLTComponentDataType kAliHLTDataTypeRunSummaryTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','U','N','S','U','M','M','A'},
+ {'H','L','T',' '}
+ };
+
+ /** Component statistics */
+ const AliHLTComponentDataType kAliHLTDataTypeComponentStatisticsTest = {
+ sizeof(AliHLTComponentDataType),
+ {'C','O','M','P','S','T','A','T'},
+ {'P','R','I','V'}
+ };
+
+ /** Component table */
+ const AliHLTComponentDataType kAliHLTDataTypeComponentTableTest = {
+ sizeof(AliHLTComponentDataType),
+ {'C','O','M','P','T','A','B','L'},
+ {'P','R','I','V'}
+ };
+
+ /** general ROOT TObject */
+ const AliHLTComponentDataType kAliHLTDataTypeTObjectTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','O','O','T','T','O','B','J'},
+ {'*','*','*','\0'}
+ };
+
+ /** ROOT TObjArray */
+ const AliHLTComponentDataType kAliHLTDataTypeTObjArrayTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','O','O','T','O','B','A','R'},
+ {'*','*','*','\0'}
+ };
+
+ /** ROOT TTree */
+ const AliHLTComponentDataType kAliHLTDataTypeTTreeTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','O','O','T','T','R','E','E'},
+ {'*','*','*','\0'}
+ };
+
+ /** ROOT TH1 (can be used for all histograms, they derive from TH1) */
+ const AliHLTComponentDataType kAliHLTDataTypeHistogramTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','O','O','T','H','I','S','T'},
+ {'*','*','*','\0'}
+ };
+
+ /** ROOT TNtuple */
+ const AliHLTComponentDataType kAliHLTDataTypeTNtupleTest = {
+ sizeof(AliHLTComponentDataType),
+ {'R','O','O','T','T','U','P','L'},
+ {'*','*','*','\0'}
+ };
+
+ ////////////////////////
+
+
+ if (kAliHLTMultipleDataTypeTest!=kAliHLTMultipleDataType) {
+ cerr << "missmatch comparing kAliHLTMultipleDataType: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTMultipleDataType).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTMultipleDataTypeTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeFXSCalibTest!=kAliHLTDataTypeFXSCalib) {
+ cerr << "missmatch comparing kAliHLTDataTypeFXSCalib: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeFXSCalib).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeFXSCalibTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeDDLTest!=kAliHLTDataTypeDDL) {
+ cerr << "missmatch comparing kAliHLTDataTypeDDL: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeDDL).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeDDLTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeSORTest!=kAliHLTDataTypeSOR) {
+ cerr << "missmatch comparing kAliHLTDataTypeSOR: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeSOR).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeSORTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeEORTest!=kAliHLTDataTypeEOR) {
+ cerr << "missmatch comparing kAliHLTDataTypeEOR: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEOR).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEORTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeRunTypeTest!=kAliHLTDataTypeRunType) {
+ cerr << "missmatch comparing kAliHLTDataTypeRunType: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeRunType).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeRunTypeTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeEventTest!=kAliHLTDataTypeEvent) {
+ cerr << "missmatch comparing kAliHLTDataTypeEvent: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEvent).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEventTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeComConfTest!=kAliHLTDataTypeComConf) {
+ cerr << "missmatch comparing kAliHLTDataTypeComConf: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeComConf).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeComConfTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeUpdtDCSTest!=kAliHLTDataTypeUpdtDCS) {
+ cerr << "missmatch comparing kAliHLTDataTypeUpdtDCS: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeUpdtDCS).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeUpdtDCSTest).c_str() << endl;
+ return -1;
+ }
+
+ /*, data publisher will set type id and origin correctly */
+ if (kAliHLTDataTypeDDLRawTest!=kAliHLTDataTypeDDLRaw) {
+ cerr << "missmatch comparing kAliHLTDataTypeDDLRaw: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeDDLRaw).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeDDLRawTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeESDObjectTest!=kAliHLTDataTypeESDObject) {
+ cerr << "missmatch comparing kAliHLTDataTypeESDObject: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeESDObject).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeESDObjectTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeESDTreeTest!=kAliHLTDataTypeESDTree) {
+ cerr << "missmatch comparing kAliHLTDataTypeESDTree: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeESDTree).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeESDTreeTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeAliTreeDTest!=kAliHLTDataTypeAliTreeD) {
+ cerr << "missmatch comparing kAliHLTDataTypeAliTreeD: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeAliTreeD).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeAliTreeDTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeAliTreeRTest!=kAliHLTDataTypeAliTreeR) {
+ cerr << "missmatch comparing kAliHLTDataTypeAliTreeR: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeAliTreeR).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeAliTreeRTest).c_str() << endl;
+ return -1;
+ }
+
+ /*, origin is 'any' */
+ if (kAliHLTDataTypeHwAddr16Test!=kAliHLTDataTypeHwAddr16) {
+ cerr << "missmatch comparing kAliHLTDataTypeHwAddr16: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeHwAddr16).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeHwAddr16Test).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeEventStatisticsTest!=kAliHLTDataTypeEventStatistics) {
+ cerr << "missmatch comparing kAliHLTDataTypeEventStatistics: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEventStatistics).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEventStatisticsTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeEventSummaryTest!=kAliHLTDataTypeEventSummary) {
+ cerr << "missmatch comparing kAliHLTDataTypeEventSummary: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEventSummary).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeEventSummaryTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeRunStatisticsTest!=kAliHLTDataTypeRunStatistics) {
+ cerr << "missmatch comparing kAliHLTDataTypeRunStatistics: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeRunStatistics).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeRunStatisticsTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeRunSummaryTest!=kAliHLTDataTypeRunSummary) {
+ cerr << "missmatch comparing kAliHLTDataTypeRunSummary: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeRunSummary).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeRunSummaryTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeComponentStatisticsTest!=kAliHLTDataTypeComponentStatistics) {
+ cerr << "missmatch comparing kAliHLTDataTypeComponentStatistics: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeComponentStatistics).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeComponentStatisticsTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeComponentTableTest!=kAliHLTDataTypeComponentTable) {
+ cerr << "missmatch comparing kAliHLTDataTypeComponentTable: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeComponentTable).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeComponentTableTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeTObjectTest!=kAliHLTDataTypeTObject) {
+ cerr << "missmatch comparing kAliHLTDataTypeTObject: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTObject).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTObjectTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeTObjArrayTest!=kAliHLTDataTypeTObjArray) {
+ cerr << "missmatch comparing kAliHLTDataTypeTObjArray: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTObjArray).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTObjArrayTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeTTreeTest!=kAliHLTDataTypeTTree) {
+ cerr << "missmatch comparing kAliHLTDataTypeTTree: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTTree).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTTreeTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeHistogramTest!=kAliHLTDataTypeHistogram) {
+ cerr << "missmatch comparing kAliHLTDataTypeHistogram: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeHistogram).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeHistogramTest).c_str() << endl;
+ return -1;
+ }
+
+ if (kAliHLTDataTypeTNtupleTest!=kAliHLTDataTypeTNtuple) {
+ cerr << "missmatch comparing kAliHLTDataTypeTNtuple: ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTNtuple).c_str() << " vs. ";
+ cerr << AliHLTComponent::DataType2Text(kAliHLTDataTypeTNtupleTest).c_str() << endl;
+ return -1;
+ }
+
+ return 0;
+}