diff --git a/test/DrawTest.C b/test/DrawTest.C
new file mode 100644
index 0000000000000000000000000000000000000000..4a47340ce7c77320a1842ee4a66fe9bc22af453c
--- /dev/null
+++ b/test/DrawTest.C
@@ -0,0 +1,150 @@
+#include "TTree.h"
+#include "TFile.h"
+#include "TList.h"
+#include <TBenchmark.h>
+
+int gHasLibrary = kFALSE;
+TList gSkipped;
+
+void DrawSkippable(TTree* tree, const char* what, const char* where, bool skip) {
+ //cerr << "Doing " << what << " which is " << skip << endl;
+ if (skip) gSkipped.Add(new TNamed(where,where));
+ else {
+ TString cut = what;
+ cut.Append(">>");
+ cut.Append(where);
+ tree->Draw(cut.Data(),"","goff");
+ }
+};
+
+void DrawSkippable(TTree* tree, const char* what, const char* cond,
+ const char* where, bool skip) {
+ //cerr << "Doing " << what << " which is " << skip << endl;
+ if (skip) gSkipped.Add(new TNamed(where,where));
+ else {
+ TString cut = what;
+ cut.Append(">>");
+ cut.Append(where);
+ tree->Draw(cut.Data(),cond,"goff");
+ }
+};
+
+// Rootmarks for fcdflnx1 is 153.4
+void DrawMarks() {
+
+ // The base is currently: RunDrawTest.C++("Event.old.split.root",0)
+ Float_t rt_base = 2.33;
+ Float_t cp_base = 2.34;
+
+ Float_t rt = gBenchmark->GetRealTime("DrawTest");
+ Float_t ct = gBenchmark->GetCpuTime("DrawTest");
+
+ // gBenchmark->Print("DrawTest");
+
+ Float_t rootmarks = 200*(rt_base + cp_base)/(rt + ct);
+
+ printf("* ROOTMARKS =%6.1f * Root%-8s %d/%d\n",rootmarks,gROOT->GetVersion(),gROOT->GetVersionDate(),gROOT->GetVersionTime());
+
+}
+
+
+//_______________________________________________________________
+TDirectory* GenerateDrawHist(TTree *tree,int level = 1)
+{
+// Test selections via TreeFormula
+// tree is a TTree when called by stress9
+// tree is a TChain when called from stres11
+// This is a quite complex test checking the results of TTree::Draw
+// or TChain::Draw with an explicit loop on events.
+// Also a good test for the interpreter
+
+ gROOT->cd();
+ TDirectory *hfile = gDirectory;
+
+ gBenchmark = new TBenchmark();
+ gBenchmark->Start("DrawTest");
+
+ // Each tree->Draw generates an histogram
+ DrawSkippable(tree,"GetNtrack()","hGetNtrack",!(level>0 && gHasLibrary));
+
+ //gBenchmark->Show("DrawTest"); gBenchmark->Start("DrawTest");
+
+ tree->Draw("fNtrack>>hNtrack", "","goff");
+ tree->Draw("fNseg>>hNseg", "","goff");
+ tree->Draw("fTemperature>>hTemp", "","goff");
+
+ tree->Draw("fH.GetMean()>>hHmean","","goff");
+ if (level>0) tree->Draw("fH.fXaxis.fXmax>>hHAxisMax","","goff");
+ if (level>0) tree->Draw("fH.fXaxis.GetXmax()>>hHAxisGetMax","","goff");
+ DrawSkippable(tree,"fH.GetXaxis().GetXmax()","hHGetAxisGetMax",!(level>0));
+ DrawSkippable(tree,"fH.GetXaxis().fXmax","hHGetAxisMax",!(level>0));
+ DrawSkippable(tree,"GetHistogram().GetXaxis().GetXmax()","hGetHGetAxisMax",
+ !(level>0&&gHasLibrary));
+ DrawSkippable(tree,"event.GetHistogram().GetXaxis().GetXmax()",
+ "hGetRefHGetAxisMax",!(level>0&&gHasLibrary));
+
+ tree->Draw("fTracks.fPx>>hPx","fEvtHdr.fEvtNum%10 == 0","goff");
+ tree->Draw("fTracks.fPy>>hPy","fEvtHdr.fEvtNum%10 == 0","goff");
+ tree->Draw("fTracks.fPz>>hPz","fEvtHdr.fEvtNum%10 == 0","goff");
+ tree->Draw("fRandom>>hRandom","fEvtHdr.fEvtNum%10 == 1","goff");
+ tree->Draw("fMass2>>hMass2", "fEvtHdr.fEvtNum%10 == 1","goff");
+ tree->Draw("fBx>>hBx", "fEvtHdr.fEvtNum%10 == 1","goff");
+ tree->Draw("fBy>>hBy", "fEvtHdr.fEvtNum%10 == 1","goff");
+ tree->Draw("fXfirst>>hXfirst","fEvtHdr.fEvtNum%10 == 2","goff");
+ tree->Draw("fYfirst>>hYfirst","fEvtHdr.fEvtNum%10 == 2","goff");
+ tree->Draw("fZfirst>>hZfirst","fEvtHdr.fEvtNum%10 == 2","goff");
+ tree->Draw("fXlast>>hXlast", "fEvtHdr.fEvtNum%10 == 3","goff");
+ tree->Draw("fYlast>>hYlast", "fEvtHdr.fEvtNum%10 == 3","goff");
+ tree->Draw("fZlast>>hZlast", "fEvtHdr.fEvtNum%10 == 3","goff");
+ tree->Draw("fCharge>>hCharge","fPx < 0","goff");
+ tree->Draw("fNpoint>>hNpoint","fPx < 0","goff");
+ tree->Draw("fValid>>hValid", "fPx < 0","goff");
+
+ tree->Draw("fMatrix>>hFullMatrix","","goff");
+ tree->Draw("fMatrix[][0]>>hColMatrix","","goff");
+ tree->Draw("fMatrix[1][]>>hRowMatrix","","goff");
+ tree->Draw("fMatrix[2][2]>>hCellMatrix","","goff");
+
+ tree->Draw("fMatrix - fVertex>>hFullOper","","goff");
+ tree->Draw("fMatrix[2][1] - fVertex[5][1]>>hCellOper","","goff");
+ tree->Draw("fMatrix[][1] - fVertex[5][1]>>hColOper","","goff");
+ tree->Draw("fMatrix[2][] - fVertex[5][2]>>hRowOper","","goff");
+ tree->Draw("fMatrix[2][] - fVertex[5][]>>hMatchRowOper","","goff");
+ tree->Draw("fMatrix[][2] - fVertex[][1]>>hMatchColOper","","goff");
+ tree->Draw("fMatrix[][2] - fVertex[][]>>hRowMatOper","","goff");
+ tree->Draw("fMatrix[][2] - fVertex[5][]>>hMatchDiffOper","","goff");
+ tree->Draw("fMatrix[][] - fVertex[][]>>hFullOper2","","goff");
+
+ // Test on variable arrays
+ tree->Draw("fClosestDistance>>hClosestDistance","","goff");
+ tree->Draw("fClosestDistance[2]>>hClosestDistance2","","goff");
+ tree->Draw("fClosestDistance[9]>>hClosestDistance9","","goff");
+
+ // Test variable indexing
+ DrawSkippable(tree,"fClosestDistance[fNvertex/2]","hClosestDistanceIndex",
+ !(level>0));
+ DrawSkippable(tree,"fPx:fPy[fNpoint]","fPy[fNpoint]>0","hPxInd",!(level>0));
+
+ // Test of simple function calls
+ DrawSkippable(tree,"sqrt(fNtrack)","hSqrtNtrack",!(level>0));
+
+ // Test string operations
+ DrawSkippable(tree,"fEvtHdr.fEvtNum","fType==\"type1\" ","hString",!(level>0));
+ DrawSkippable(tree,"fEvtHdr.fEvtNum","strstr(fType,\"1\") ","+hString",!(level>0));
+
+ // Test binary operators
+ DrawSkippable(tree,"fValid<<4","hShiftValid",!(level>0));
+ DrawSkippable(tree,"((fValid<<4)>>2)","+hShiftValid",!(level>0));
+ DrawSkippable(tree,"fValid&0x1","(fNvertex>10) && (fNseg<=6000)"
+ ,"hAndValid",!(level>0));
+
+ // Test weight
+ DrawSkippable(tree,"fPx","(fBx>.4) || (fBy<=-.4)","hPxBx",!(level>0));
+ DrawSkippable(tree,"fPx","fBx*fBx*(fBx>.4) + fBy*fBy*(fBy<=-.4)",
+ "hPxBxWeight",!(level>0));
+
+ gBenchmark->Show("DrawTest"); gBenchmark->Start("DrawTest");
+
+ return hfile;
+
+}
diff --git a/test/DrawTest.sh b/test/DrawTest.sh
new file mode 100755
index 0000000000000000000000000000000000000000..468f7f5d69523ad2284a8d4ea704e78bb17b8fbc
--- /dev/null
+++ b/test/DrawTest.sh
@@ -0,0 +1,7 @@
+#! /bin/sh
+
+MakeFiles.sh
+root -b -q 'MakeRef.C("Event.new.split9.root");'
+RunDrawTest.sh
+
+
diff --git a/test/MakeFiles.sh b/test/MakeFiles.sh
new file mode 100755
index 0000000000000000000000000000000000000000..5b2a642f14cb49125bbc15b3c46b58eb904387df
--- /dev/null
+++ b/test/MakeFiles.sh
@@ -0,0 +1,26 @@
+#!/bin/sh -xf
+
+size=50
+tracks=600
+comp=0
+action=1
+
+./Event $size $comp 0 $action $tracks 1
+mv Event.root Event.new.split0.root
+
+./Event $size $comp 1 $action $tracks 1
+mv Event.root Event.new.split1.root
+
+./Event $size $comp 9 $action $tracks 1
+mv Event.root Event.new.split9.root
+
+./Event $size $comp 0 $action $tracks 0
+mv Event.root Event.old.streamed.root
+
+./Event $size $comp 1 $action $tracks 0
+mv Event.root Event.old.split.root
+
+# Next step is to do something like
+# root -q 'MakeRef.C("Event.old.split.root");'
+
+
diff --git a/test/MakeRef.C b/test/MakeRef.C
new file mode 100644
index 0000000000000000000000000000000000000000..d035dd8b6d8d77c83928f11eb8bdee81fab357fa
--- /dev/null
+++ b/test/MakeRef.C
@@ -0,0 +1,247 @@
+#include "RunDrawTest.C"
+
+#include "TClassTable.h"
+#include "TDirectory.h"
+#include "TFile.h"
+#include "TH1.h"
+
+#ifndef __CINT__
+#include "Event.h"
+#endif
+
+TH1F* RefClone(TH1F* orig) {
+ TH1F *cloned = (TH1F*)orig->Clone();
+ TString name = orig->GetName();
+ name.Prepend("ref");
+ cloned->SetName(name);
+ cloned->Reset();
+ return cloned;
+};
+
+TH1F* RefClone(TDirectory* from, const char* name) {
+ TH1F * orig = (TH1F*)from->Get(name);
+ if (!orig) {
+ cerr << "Missing " << name << " from " << from->GetName() << endl;
+ return 0;
+ }
+ return RefClone(orig);
+}
+
+void MakeHisto(TTree *tree, TDirectory* To) {
+
+ cout << "Generating histograms from TTree::Draw" << endl;
+ TDirectory* where = GenerateDrawHist(tree);
+ To->cd();
+
+ Event *event = new Event();
+ tree->SetBranchAddress("event",&event);
+
+ //We make clones of the generated histograms
+ //We set new names and reset the clones.
+ //We want to have identical histogram limits
+ TH1F *refNtrack = RefClone(where,"hNtrack");
+ TH1F *refGetNtrack = RefClone(where,"hGetNtrack");
+ TH1F *refNseg = RefClone(where,"hNseg");
+ TH1F *refTemp = RefClone(where,"hTemp");
+ TH1F *refHmean = RefClone(where,"hHmean");
+ TH1F *refHAxisMax = RefClone(where,"hHAxisMax");
+ TH1F *refHAxisGetMax = RefClone(where,"hHAxisGetMax");
+ TH1F *refHGetAxisGetMax = RefClone(where,"hHGetAxisGetMax");
+ TH1F *refHGetAxisMax = RefClone(where,"hHGetAxisMax");
+ TH1F *refGetHGetAxisMax = RefClone(where,"hGetHGetAxisMax");
+ TH1F *refGetRefHGetAxisMax = RefClone(where,"hGetRefHGetAxisMax");
+
+ TH1F *refPx = RefClone(where,"hPx");
+ TH1F *refPy = RefClone(where,"hPy");
+ TH1F *refPz = RefClone(where,"hPz");
+ TH1F *refRandom = RefClone(where,"hRandom");
+ TH1F *refMass2 = RefClone(where,"hMass2");
+ TH1F *refBx = RefClone(where,"hBx");
+ TH1F *refBy = RefClone(where,"hBy");
+ TH1F *refXfirst = RefClone(where,"hXfirst");
+ TH1F *refYfirst = RefClone(where,"hYfirst");
+ TH1F *refZfirst = RefClone(where,"hZfirst");
+ TH1F *refXlast = RefClone(where,"hXlast");
+ TH1F *refYlast = RefClone(where,"hYlast");
+ TH1F *refZlast = RefClone(where,"hZlast");
+ TH1F *refCharge = RefClone(where,"hCharge");
+ TH1F *refNpoint = RefClone(where,"hNpoint");
+ TH1F *refValid = RefClone(where,"hValid");
+
+ TH1F *refFullMatrix = RefClone(where,"hFullMatrix");
+ TH1F *refColMatrix = RefClone(where,"hColMatrix");
+ TH1F *refRowMatrix = RefClone(where,"hRowMatrix");
+ TH1F *refCellMatrix = RefClone(where,"hCellMatrix");
+ TH1F *refFullOper = RefClone(where,"hFullOper");
+ TH1F *refCellOper = RefClone(where,"hCellOper");
+ TH1F *refColOper = RefClone(where,"hColOper");
+ TH1F *refRowOper = RefClone(where,"hRowOper");
+ TH1F *refMatchRowOper = RefClone(where,"hMatchRowOper");
+ TH1F *refMatchColOper = RefClone(where,"hMatchColOper");
+ TH1F *refRowMatOper = RefClone(where,"hRowMatOper");
+ TH1F *refMatchDiffOper= RefClone(where,"hMatchDiffOper");
+ TH1F *refFullOper2 = RefClone(where,"hFullOper2");
+
+ TH1F *refClosestDistance = RefClone(where,"hClosestDistance");
+ TH1F *refClosestDistance2 = RefClone(where,"hClosestDistance2");
+ TH1F *refClosestDistance9 = RefClone(where,"hClosestDistance9");
+
+ TH1F *refClosestDistanceIndex = RefClone(where, "hClosestDistanceIndex");
+ TH2F *refPxInd = (TH2F*)RefClone(where,"hPxInd");
+
+ TH1F *refSqrtNtrack = RefClone(where,"hSqrtNtrack");
+ TH1F *refShiftValid = RefClone(where,"hShiftValid");
+ TH1F *refAndValid = RefClone(where,"hAndValid");
+
+ TH1F *refString = RefClone(where,"hString");
+
+ TH1F *refPxBx = RefClone(where,"hPxBx");
+ TH1F *refPxBxWeight = RefClone(where,"hPxBxWeight");
+
+ // Loop with user code on all events and fill the ref histograms
+ // The code below should produce identical results to the tree->Draw above
+
+ cout << "Recalculating the histograms with custom loop." << endl;
+
+ TClonesArray *tracks = event->GetTracks();
+ Int_t nev = (Int_t)tree->GetEntries();
+ Int_t i, ntracks, evmod,i0,i1, Nvertex;
+ Track *t;
+ EventHeader *head;
+ Int_t nbin = 0;
+ for (Int_t ev=0;ev<nev;ev++) {
+ nbin += tree->GetEntry(ev);
+ head = event->GetHeader();
+ evmod = head->GetEvtNum()%10;
+ refNtrack->Fill(event->GetNtrack());
+ refGetNtrack->Fill(event->GetNtrack());
+ refNseg->Fill(event->GetNseg());
+ refTemp->Fill(event->GetTemperature());
+ refHmean->Fill(event->GetHistogram()->GetMean());
+ refHAxisMax->Fill(event->GetHistogram()->GetXaxis()->GetXmax());
+ refHAxisGetMax->Fill(event->GetHistogram()->GetXaxis()->GetXmax());
+ refHGetAxisGetMax->Fill(event->GetHistogram()->GetXaxis()->GetXmax());
+ refHGetAxisMax->Fill(event->GetHistogram()->GetXaxis()->GetXmax());
+ refGetHGetAxisMax->Fill(event->GetHistogram()->GetXaxis()->GetXmax());
+ refGetRefHGetAxisMax->Fill(event->GetHistogram()->GetXaxis()->GetXmax());
+ refSqrtNtrack->Fill(sqrt(event->GetNtrack()));
+
+ //NOTE: This is loop is to take in consideration a know bug :(
+ for (int i9=0;i9<20;i9++) {
+ if (!strcmp("type1",event->GetType()))
+ refString->Fill(event->GetHeader()->GetEvtNum());
+ if (strstr(event->GetType(),"1"))
+ refString->Fill(event->GetHeader()->GetEvtNum());
+ }
+
+ Nvertex = event->GetNvertex();
+ for(i0=0;i0<Nvertex;i0++) {
+ refClosestDistance->Fill(event->GetClosestDistance(i0));
+ }
+ if (Nvertex>2) refClosestDistance2->Fill(event->GetClosestDistance(2));
+ if (Nvertex>9) refClosestDistance9->Fill(event->GetClosestDistance(9));
+ refClosestDistanceIndex->Fill(event->GetClosestDistance(Nvertex/2));
+
+ for(i0=0;i0<4;i0++) {
+ for(i1=0;i1<4;i1++) {
+ refFullMatrix->Fill(event->GetMatrix(i0,i1));
+ }
+ refColMatrix->Fill(event->GetMatrix(i0,0));
+ refRowMatrix->Fill(event->GetMatrix(1,i0)); // done here because the matrix is square!
+ }
+ refCellMatrix->Fill(event->GetMatrix(2,2));
+
+ ntracks = event->GetNtrack();
+ if ( 5 < ntracks ) {
+ t = (Track*)tracks->UncheckedAt(5);
+ for(i0=0;i0<4;i0++) {
+ for(i1=0;i1<4;i1++) {
+ }
+ refColOper->Fill( event->GetMatrix(i0,1) - t->GetVertex(1) );
+ refRowOper->Fill( event->GetMatrix(2,i0) - t->GetVertex(2) );
+ }
+ for(i0=0;i0<3;i0++) {
+ refMatchRowOper->Fill( event->GetMatrix(2,i0) - t->GetVertex(i0) );
+ refMatchDiffOper->Fill( event->GetMatrix(i0,2) - t->GetVertex(i0) );
+ }
+ refCellOper->Fill( event->GetMatrix(2,1) - t->GetVertex(1) );
+ }
+ for (i=0;i<ntracks;i++) {
+ t = (Track*)tracks->UncheckedAt(i);
+ if (evmod == 0) refPx->Fill(t->GetPx());
+ if (evmod == 0) refPy->Fill(t->GetPy());
+ if (evmod == 0) refPz->Fill(t->GetPz());
+ if (evmod == 1) refRandom->Fill(t->GetRandom());
+ if (evmod == 1) refMass2->Fill(t->GetMass2());
+ if (evmod == 1) refBx->Fill(t->GetBx());
+ if (evmod == 1) refBy->Fill(t->GetBy());
+ if (evmod == 2) refXfirst->Fill(t->GetXfirst());
+ if (evmod == 2) refYfirst->Fill(t->GetYfirst());
+ if (evmod == 2) refZfirst->Fill(t->GetZfirst());
+ if (evmod == 3) refXlast->Fill(t->GetXlast());
+ if (evmod == 3) refYlast->Fill(t->GetYlast());
+ if (evmod == 3) refZlast->Fill(t->GetZlast());
+ if (t->GetPx() < 0) {
+ refCharge->Fill(t->GetCharge());
+ refNpoint->Fill(t->GetNpoint());
+ refValid->Fill(t->GetValid());
+ }
+ Int_t valid = t->GetValid();
+ refShiftValid->Fill(valid << 4);
+ refShiftValid->Fill( (valid << 4) >> 2 );
+ if (event->GetNvertex()>10 && event->GetNseg()<=6000) {
+ refAndValid->Fill( t->GetValid() & 0x1 );
+ }
+
+ Track * t2 = (Track*)tracks->At(t->GetNpoint());
+ if (t2 && t2->GetPy()>0) {
+ refPxInd->Fill(t2->GetPy(),t->GetPx());
+ }
+ float Bx,By;
+ Bx = t->GetBx();
+ By = t->GetBy();
+ if ((Bx>.4) || (By<=-.4)) refPxBx->Fill(t->GetPx());
+ double weight = Bx*Bx*(Bx>.4) + By*By*(By<=-.4);
+ if (weight) refPxBxWeight->Fill(t->GetPx(),weight);
+
+ if (i<4) {
+ for(i1=0;i1<3;i1++) { // 3 is the min of the 2nd dim of Matrix and Vertex
+ refFullOper ->Fill( event->GetMatrix(i,i1) - t->GetVertex(i1) );
+ refFullOper2->Fill( event->GetMatrix(i,i1) - t->GetVertex(i1) );
+ refRowMatOper->Fill( event->GetMatrix(i,2) - t->GetVertex(i1) );
+ }
+ refMatchColOper->Fill( event->GetMatrix(i,2) - t->GetVertex(1) );
+ }
+ }
+ }
+
+ delete event;
+ Event::Reset();
+
+}
+
+void MakeRef(const char* from) {
+ if (!TClassTable::GetDict("Event")) {
+ gROOT->ProcessLine(".L libEvent.so");
+ gHasLibrary = kTRUE;
+ }
+
+ gROOT->GetList()->Delete();
+
+ TFile *hfile = new TFile(from);
+ TTree *tree = (TTree*)hfile->Get("T");
+
+ TFile* f= new TFile("draw_test_ref.root","recreate");
+ MakeHisto(tree,f);
+ f->Write();
+ delete f;
+
+ delete hfile;
+
+ gROOT->cd();
+ cout << "Checking histograms" << endl;
+ Compare(gDirectory);
+
+ // gROOT->GetList()->Delete();
+
+}
diff --git a/test/RunDrawTest.C b/test/RunDrawTest.C
new file mode 100644
index 0000000000000000000000000000000000000000..abf930f594cf79d83cb2e4e6179bdcbbc2f1de01
--- /dev/null
+++ b/test/RunDrawTest.C
@@ -0,0 +1,172 @@
+#include "TCanvas.h"
+#include "TClassTable.h"
+#include "TFile.h"
+#include "TH1.h"
+#include "TKey.h"
+#include "TChain.h"
+
+#include "iostream.h"
+
+#include "DrawTest.C"
+
+Bool_t gInteractiveTest = kTRUE;
+Bool_t gQuietLevel = 0;
+
+//_______________________________________________________________
+Int_t HistCompare(TH1 *ref, TH1 *comp)
+{
+// Compare histograms h1 and h2
+// Check number of entries, mean and rms
+// if means differ by more than 1/1000 of the range return -1
+// if rms differs in percent by more than 1/1000 return -2
+// Otherwise return difference of number of entries
+
+ Int_t n1 = (Int_t)ref->GetEntries();
+ Double_t mean1 = ref->GetMean();
+ Double_t rms1 = ref->GetRMS();
+ Int_t n2 = (Int_t)comp->GetEntries();
+ Double_t mean2 = comp->GetMean();
+ Double_t rms2 = comp->GetRMS();
+
+ Int_t factor = 1;
+ if (n2==2*n1) {
+ // we have a chain.
+ factor = 2;
+ }
+
+ Float_t xrange = ref->GetXaxis()->GetXmax() - ref->GetXaxis()->GetXmin();
+ if (TMath::Abs((mean1-mean2)/xrange) > 0.001*xrange) return -1;
+ if (rms1 && TMath::Abs((rms1-rms2)/rms1) > 0.001) return -2;
+ return n1*factor-n2;
+}
+
+Int_t Compare(TDirectory* from) {
+ TFile * reffile = new TFile("draw_test_ref.root");
+
+ TIter next(reffile->GetListOfKeys());
+ TH1 *ref, *draw;
+ const char* name;
+ Int_t comp;
+ Int_t fail = 0;
+ TKey* key;
+ while ((key=(TKey*)next())) {
+ if (strcmp(key->GetClassName(),"TH1F")
+ && strcmp(key->GetClassName(),"TH2F") )
+ continue; //may be a TList of TStreamerInfo
+ ref = (TH1*)reffile->Get(key->GetName());
+ name = ref->GetName();
+ if (strncmp(name,"ref",3)) continue;
+ name += 3;
+ draw = (TH1*)from->Get(name);
+ if (!draw) {
+ if (!gSkipped.FindObject(name)) {
+ cerr << "Miss: " << name << endl;
+ fail++;
+ }
+ continue;
+ }
+ comp = HistCompare(ref,draw);
+ if (comp!=0) {
+ cerr << "Fail: " << name << ":" << comp << endl;
+ fail++;
+ if (gInteractiveTest) {
+ TCanvas * canv = new TCanvas();
+ canv->Divide(2,1);
+ canv->cd(1); ref->Draw();
+ canv->cd(2); draw->Draw();
+ return 1;
+ }
+ } else {
+ if (gQuietLevel<1) cerr << "Succ: " << name << ":" << comp << endl;
+ }
+ }
+ return fail;
+}
+
+void SetVerboseLevel(Int_t verboseLevel) {
+ switch (verboseLevel) {
+ case 0: gInteractiveTest = kFALSE;
+ gQuietLevel = 2;
+ break;
+ case 1: gInteractiveTest = kFALSE;
+ gQuietLevel = 1;
+ break;
+ case 2: gInteractiveTest = kFALSE;
+ gQuietLevel = 0;
+ break;
+ case 3: gInteractiveTest = kTRUE;
+ gQuietLevel = 0;
+ break;
+ }
+}
+
+void RunDrawTest(const char* from, Int_t mode = 0, Int_t verboseLevel = 0) {
+ // This launch a test a TTree::Draw.
+ // The mode currently available are:
+ // 0: Do not load the shared library
+ // 1: Load the shared library before opening the file
+ // 2: Load the shared library after opening the file
+ // 3: Simple TChain test with shared library
+ // 4: Simple Friend test with shared library
+ // The verboseLeve currently available:
+ // 0: As silent as possible, only report errors and overall speed results.
+ // 1: Output 0 + label for the start of each phase
+ // 2: Output 1 + more details on the different phase being done
+ // 3: Output 2 + stop at the first first and draw a canvas showing the differences
+
+ SetVerboseLevel(verboseLevel);
+
+ if (mode == 1) {
+ if (!TClassTable::GetDict("Event")) {
+ gROOT->ProcessLine(".L libEvent.so");
+ }
+ gHasLibrary = kTRUE;
+ }
+
+ TFile *hfile = 0;
+ TTree *tree;
+ if (mode <3) {
+ hfile = new TFile(from);
+ tree = (TTree*)hfile->Get("T");
+ }
+
+ if (mode >= 2 && mode <= 4) {
+ if (!TClassTable::GetDict("Event")) {
+ gROOT->ProcessLine(".L libEvent.so");
+ } else {
+ cerr << "Since libEvent.so has already been loaded, mode 2 can not be tested!";
+ cerr << endl;
+ }
+ gHasLibrary = kTRUE;
+ }
+
+ if (mode == 3) {
+ // Test Chains.
+ TChain * chain = new TChain("T");
+ chain->Add(from);
+ chain->Add(from);
+ tree = chain;
+ }
+
+ if (mode == 4) {
+ // Test friends.
+ tree = new TTree("T","Base of friendship");
+ tree->AddFriend("T",from);
+ }
+
+ if (gQuietLevel<2) cout << "Generating histograms from TTree::Draw" << endl;
+ TDirectory* where = GenerateDrawHist(tree);
+
+ if (gQuietLevel<2) cout << "Comparing histograms" << endl;
+ if (Compare(where)>0) {
+ cout << "DrawTest: Comparison failed" << endl;
+ return;
+ }
+ DrawMarks();
+
+ cout << "DrawTest: Comparison was successfull" << endl;
+ if (hfile) delete hfile;
+ else delete tree;
+ gROOT->GetList()->Delete();
+
+}
diff --git a/test/RunDrawTest.sh b/test/RunDrawTest.sh
new file mode 100755
index 0000000000000000000000000000000000000000..ddb981285b02b8e7c59cad6c0b3ff378e13e9846
--- /dev/null
+++ b/test/RunDrawTest.sh
@@ -0,0 +1,38 @@
+#!/bin/sh
+
+# Previous step is to do something like
+# root -l -q 'MakeRef.C("Event.old.split.root");'
+
+ClassWarning='Warning in <TClass::TClass>: no dictionary for class'
+RootPrompt='root \[0\]'
+Streamer="Event::Streamer not available,"
+
+root.exe -l -q -b 'RunDrawTest.C++("Event.old.split.root",0)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.split.root",1)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.split.root",2)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.split.root",3)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.split.root",4)' 2>&1 | grep -v "$RootPrompt"
+
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.streamed.root",0)' 2>&1 | grep -v "$Streamer\|$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.streamed.root",1)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.streamed.root",2)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.streamed.root",3)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.old.streamed.root",4)' 2>&1 | grep -v "$RootPrompt"
+
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split9.root",0)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split9.root",1)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split9.root",2)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split9.root",3)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split9.root",4)' 2>&1 | grep -v "$RootPrompt"
+
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split1.root",0)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split1.root",1)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split1.root",2)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split1.root",3)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split1.root",4)' 2>&1 | grep -v "$RootPrompt"
+
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split0.root",0)' 2>&1 | grep -v "$Streamer\|$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split0.root",1)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split0.root",2)' 2>&1 | grep -v "$ClassWarning\|$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split0.root",3)' 2>&1 | grep -v "$RootPrompt"
+root.exe -l -q -b 'RunDrawTest.C+("Event.new.split0.root",4)' 2>&1 | grep -v "$RootPrompt"