int test_shared_ptr_use_count() { int Error(0); { gli::shared_ptr<int> DataA(new int(76)); Error += DataA.unique() ? 0 : 1; gli::shared_ptr<int> DataB = DataA; Error += DataA.use_count() == 2 ? 0 : 1; Error += DataB.use_count() == 2 ? 0 : 1; } { gli::shared_ptr<int> DataA(new int(76)); gli::shared_ptr<int> DataB = DataA; DataB.reset(); long CountA = DataA.use_count(); long CountB = DataB.use_count(); Error += CountA == 1 ? 0 : 1; Error += CountB == 0 ? 0 : 1; } { gli::shared_ptr<int> DataA(new int(76)); gli::shared_ptr<int> DataB = DataA; DataB.reset(); DataA.reset(); long CountA = DataA.use_count(); long CountB = DataB.use_count(); Error += CountA == 0 ? 0 : 1; Error += CountB == 0 ? 0 : 1; } { gli::shared_ptr<int> DataA(new int(76)); DataA = DataA; long CountA = DataA.use_count(); Error += CountA == 1 ? 0 : 1; } return Error; }
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 test_shared_ptr_empty() { int Error(0); { gli::shared_ptr<int> DataA; Error += !DataA.get() ? 0 : 1; } { gli::shared_ptr<int> DataA(new int(76)); DataA.reset(); Error += !DataA.get() ? 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(); }