int test_shared_ptr_reset()
{
int Error(0);
{
gli::shared_ptr<int> DataA(new int(76));
gli::shared_ptr<int> DataB(DataA);
Error += DataA.get() ? 0 : 1;
Error += DataB.get() ? 0 : 1;
Error += DataA.use_count() == 2 ? 0 : 1;
Error += DataB.use_count() == 2 ? 0 : 1;
DataB.reset(new int(82));
Error += DataA.unique() ? 0 : 1;
Error += DataB.unique() ? 0 : 1;
DataA.reset();
Error += !DataA.unique() ? 0 : 1;
Error += DataB.unique() ? 0 : 1;
Error += !DataA.get() ? 0 : 1;
Error += DataB.get() ? 0 : 1;
DataB.reset();
Error += !DataA.unique() ? 0 : 1;
Error += !DataB.unique() ? 0 : 1;
Error += !DataA.get() ? 0 : 1;
Error += !DataB.get() ? 0 : 1;
}
return Error;
}
int test_shared_ptr_comp()
{
int Error(0);
{
gli::shared_ptr<int> DataA(new int(76));
gli::shared_ptr<int> DataB = DataA;
Error += DataA == DataB ? 0 : 1;
gli::shared_ptr<int> DataC(DataA);
Error += DataA == DataC ? 0 : 1;
}
{
gli::shared_ptr<int> DataA(new int(76));
gli::shared_ptr<int> DataB(new int(76));
Error += DataA != DataB ? 0 : 1;
}
return Error;
}
int main()
{
__esan::HashTable<int, int> IntTable;
assert(IntTable.size() == 0);
// Test iteration on an empty table.
int Count = 0;
for (auto Iter = IntTable.begin(); Iter != IntTable.end();
++Iter, ++Count) {
// Empty.
}
assert(Count == 0);
bool Added = IntTable.add(4, 42);
assert(Added);
assert(!IntTable.add(4, 42));
assert(IntTable.size() == 1);
int Value;
bool Found = IntTable.lookup(4, Value);
assert(Found && Value == 42);
// Test iterator.
IntTable.lock();
for (auto Iter = IntTable.begin(); Iter != IntTable.end();
++Iter, ++Count) {
assert((*Iter).Key == 4);
assert((*Iter).Data == 42);
}
IntTable.unlock();
assert(Count == 1);
assert(Count == IntTable.size());
assert(!IntTable.remove(5));
assert(IntTable.remove(4));
// Test a more complex payload.
__esan::HashTable<int, MyDataPayload> DataTable(4);
MyDataPayload NewData(new MyData("mystring"));
Added = DataTable.add(4, NewData);
assert(Added);
MyDataPayload FoundData;
Found = DataTable.lookup(4, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "mystring") == 0);
assert(!DataTable.remove(5));
assert(DataTable.remove(4));
// Test resize.
for (int i = 0; i < 4; ++i) {
MyDataPayload MoreData(new MyData("delete-at-end"));
Added = DataTable.add(i+1, MoreData);
assert(Added);
assert(!DataTable.add(i+1, MoreData));
}
for (int i = 0; i < 4; ++i) {
Found = DataTable.lookup(i+1, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "delete-at-end") == 0);
}
DataTable.lock();
Count = 0;
for (auto Iter = DataTable.begin(); Iter != DataTable.end();
++Iter, ++Count) {
int Key = (*Iter).Key;
FoundData = (*Iter).Data;
assert(Key >= 1 && Key <= 4);
assert(strcmp(FoundData.Data->Buf, "delete-at-end") == 0);
}
DataTable.unlock();
assert(Count == 4);
assert(Count == DataTable.size());
// Ensure the iterator supports a range-based for loop.
DataTable.lock();
Count = 0;
for (auto Pair : DataTable) {
assert(Pair.Key >= 1 && Pair.Key <= 4);
assert(strcmp(Pair.Data.Data->Buf, "delete-at-end") == 0);
++Count;
}
DataTable.unlock();
assert(Count == 4);
assert(Count == DataTable.size());
// Test payload freeing via smart pointer wrapper.
__esan::HashTable<MyDataPayload, MyDataPayload, true> DataKeyTable;
MyDataPayload DataA(new MyData("string AB"));
DataKeyTable.lock();
Added = DataKeyTable.add(DataA, DataA);
assert(Added);
Found = DataKeyTable.lookup(DataA, FoundData);
assert(Found && strcmp(FoundData.Data->Buf, "string AB") == 0);
MyDataPayload DataB(new MyData("string AB"));
Added = DataKeyTable.add(DataB, DataB);
assert(!Added);
DataKeyTable.remove(DataB); // Should free the DataA payload.
DataKeyTable.unlock();
// Test custom functors.
struct CustomHash {
size_t operator()(int Key) const { return Key % 4; }
};
struct CustomEqual {
bool operator()(int Key1, int Key2) const { return Key1 %4 == Key2 % 4; }
};
__esan::HashTable<int, int, false, CustomHash, CustomEqual> ModTable;
Added = ModTable.add(2, 42);
assert(Added);
Added = ModTable.add(6, 42);
assert(!Added);
fprintf(stderr, "All checks passed.\n");
return 0;
}
int main(){
bool redocuts=false;
if(redocuts){
DataFile DataA(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Twel,MagAll,buketap,"BDTApplied_SampleA");
DataFile DataB(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Twel,MagAll,buketap,"BDTApplied_SampleB");
DataFile DataA11(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Elev,MagAll,buketap,"BDTApplied_SampleA");
DataFile DataB11(std::getenv("BUKETAPDATABDTRESPROOT"),Data,Elev,MagAll,buketap,"BDTApplied_SampleB");
TreeReader* Data12Reader= new TreeReader("DecayTree");
Data12Reader->AddFile(DataA);
Data12Reader->AddFile(DataB);
Data12Reader->Initialize();
TreeReader* Data11Reader= new TreeReader("DecayTree");
Data11Reader->AddFile(DataA11);
Data11Reader->AddFile(DataB11);
Data11Reader->Initialize();
TFile* LocalCutTree12 = new TFile("CutTree12.root","RECREATE");
TTree* CutTree12=Data12Reader->CopyTree("gamma_CL>0.1&&BDT_response>0.36&&Kaon_MC12TuneV3_ProbNNk>0.4&&piminus_MC12TuneV3_ProbNNpi>0.2&&piplus_MC12TuneV3_ProbNNpi>0.2",-1,"DecayTree");
CutTree12->Write();
LocalCutTree12->Close();
delete LocalCutTree12;
TFile* LocalCutTree11 = new TFile("CutTree11.root","RECREATE");
TTree* CutTree11=Data11Reader->CopyTree("gamma_CL>0.1&&BDT_response>0.30&&Kaon_MC12TuneV3_ProbNNk>0.4&&piminus_MC12TuneV3_ProbNNpi>0.2&&piplus_MC12TuneV3_ProbNNpi>0.2",-1,"DecayTree");
CutTree11->Write();
LocalCutTree11->Close();
delete LocalCutTree11;
}
TFile* Input12= new TFile("CutTree12.root");
TTree* InputTree12= (TTree*)Input12->Get("DecayTree");
TFile* Output12= new TFile("Output12.root","RECREATE");
TRandom3* Rand= new TRandom3(224);
TH1I* nCandPerEvent12=new TH1I("NCandPerEvent12","NCandPerEvent12",10,0,10);
TTree* SingleTree12=HandyFunctions::GetSingleTree(Rand,InputTree12,nCandPerEvent12,NULL);
nCandPerEvent12->Write();
SingleTree12->Write();
Output12->Write();
TFile* Input11= new TFile("CutTree11.root");
TTree* InputTree11= (TTree*)Input11->Get("DecayTree");
TFile* Output11= new TFile("Output11.root","RECREATE");
TH1I* nCandPerEvent11=new TH1I("NCandPerEvent11","NCandPerEvent11",10,0,10);
TTree* SingleTree11=HandyFunctions::GetSingleTree(Rand,InputTree11,nCandPerEvent11,NULL);
nCandPerEvent11->Write();
SingleTree11->Write();
Output11->Write();
}
