JetGroupProductTest.cxx File Reference

#include "gtest/gtest.h"
#include "TrigHLTJetHypo/../src/JetGroupProduct.h"
#include "TrigHLTJetHypo/../src/DebugInfoCollector.h"
#include <vector>
#include <map>

Include dependency graph for JetGroupProductTest.cxx:

Go to the source code of this file.

Typedefs
using	res = std::pair<std::vector<unsigned int>, bool>
using	vec = std::vector<unsigned int>

Functions
	TEST (JetGroupProductTester, empty)
	TEST (JetGroupProductTester, onecondition)
	TEST (JetGroupProductTester, repeatedcond)
	TEST (JetGroupProductTester, twocond)
	TEST (JetGroupProductTester, reallife)

Typedef Documentation

res

using res = std::pair<std::vector<unsigned int>, bool>

Definition at line 11 of file JetGroupProductTest.cxx.

vec

using vec = std::vector<unsigned int>

Definition at line 12 of file JetGroupProductTest.cxx.

Function Documentation

TEST() [1/5]

TEST	(	JetGroupProductTester	,
		empty	)

Definition at line 14 of file JetGroupProductTest.cxx.

                                   {
  std::vector<std::size_t> siblings;
  CondInd2JetGroupsInds satisfiedBy;
  std::vector<std::size_t> condMult;
  JetGroupInd2ElemInds jg2elemjgs;
 
  JetGroupProduct jgp(siblings, satisfiedBy, condMult, jg2elemjgs);
  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
 
  EXPECT_FALSE(jgp.valid());
  EXPECT_TRUE((jgp.next(collector)).empty());
}

TEST() [2/5]

TEST	(	JetGroupProductTester	,
		onecondition	)

Definition at line 28 of file JetGroupProductTest.cxx.

                                          {
  std::vector<std::size_t> siblings{1};
 
  CondInd2JetGroupsInds satisfiedBy;
  satisfiedBy[0] = std::vector<std::size_t>();
  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
 
  std::vector<std::size_t> condMult{0, 1};
 
  JetGroupInd2ElemInds jg2elemjgs;
  jg2elemjgs[0] = std::vector<std::size_t> {0};
  jg2elemjgs[1] = std::vector<std::size_t> {1};
  jg2elemjgs[2] = std::vector<std::size_t> {2};
  
  JetGroupProduct jgp(siblings, satisfiedBy, condMult, jg2elemjgs);
 
  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
  
  EXPECT_TRUE(jgp.valid());
 
  auto exp = std::vector<std::size_t>{0};
  EXPECT_EQ(jgp.next(collector), exp);
 
  exp = std::vector<std::size_t>{1};
  EXPECT_EQ(jgp.next(collector), exp);
 
  exp = std::vector<std::size_t>{2};
  EXPECT_EQ(jgp.next(collector), exp);
 
  EXPECT_TRUE(jgp.next(collector).empty());
}

TEST() [3/5]

TEST	(	JetGroupProductTester	,
		reallife	)

Definition at line 128 of file JetGroupProductTest.cxx.

                                      {
  std::vector<std::size_t> siblings{1, 2};
 
  CondInd2JetGroupsInds satisfiedBy;
  satisfiedBy[0] = std::vector<std::size_t>();
  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
  satisfiedBy[2] = std::vector<std::size_t> {
    0, 1, 2, 3, 4, 6, 7, 9, 10, 11, 12, 13,
    14, 15, 17, 19, 21, 25, 26, 29, 33};
  
  std::vector<std::size_t> condMult{1, 1, 3};
  
  JetGroupInd2ElemInds jg2elemjgs;
  for (const auto& i : satisfiedBy[2]){
    jg2elemjgs[i] = std::vector<std::size_t> {i};
  }
    JetGroupProduct jgp(siblings, satisfiedBy, condMult, jg2elemjgs);
 
  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
 
  EXPECT_TRUE(jgp.valid());
  
  std::size_t ipass{0};
  
  while (true) {
    auto indices = jgp.next(collector);
    if (indices.empty()){break;}
    ++ipass;
  }
 
  // 2925 = 3*C(21,3) - overlaps and duplicates
  EXPECT_EQ (ipass, 2925u);
  
}

TEST() [4/5]

TEST	(	JetGroupProductTester	,
		repeatedcond	)

Definition at line 60 of file JetGroupProductTest.cxx.

                                          {
  std::vector<std::size_t> siblings{1};
 
  CondInd2JetGroupsInds satisfiedBy;
  satisfiedBy[0] = std::vector<std::size_t>();
  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
 
  std::vector<std::size_t> condMult{1, 2};
 
  JetGroupInd2ElemInds jg2elemjgs;
  jg2elemjgs[0] = std::vector<std::size_t> {0};
  jg2elemjgs[1] = std::vector<std::size_t> {1};
  jg2elemjgs[2] = std::vector<std::size_t> {2};
  
  JetGroupProduct jgp(siblings, satisfiedBy, condMult, jg2elemjgs);
 
  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
 
  EXPECT_TRUE(jgp.valid());
 
  auto exp = std::vector<std::size_t>{0, 1};
  EXPECT_EQ(jgp.next(collector), exp);
 
  exp = std::vector<std::size_t>{0, 2};
  EXPECT_EQ(jgp.next(collector), exp);
 
 
  exp = std::vector<std::size_t>{1, 2};
  EXPECT_EQ(jgp.next(collector), exp);
 
  EXPECT_TRUE(jgp.next(collector).empty());
}

TEST() [5/5]

TEST	(	JetGroupProductTester	,
		twocond	)

Definition at line 93 of file JetGroupProductTest.cxx.

                                     {
  std::vector<std::size_t> siblings{1, 2};
 
  CondInd2JetGroupsInds satisfiedBy;
  satisfiedBy[0] = std::vector<std::size_t>();
  satisfiedBy[1] = std::vector<std::size_t> {0, 1, 2};
  satisfiedBy[2] = std::vector<std::size_t> {0, 1, 2};
 
  std::vector<std::size_t> condMult{1, 1, 1};
 
  JetGroupInd2ElemInds jg2elemjgs;
  jg2elemjgs[0] = std::vector<std::size_t> {0};
  jg2elemjgs[1] = std::vector<std::size_t> {1};
  jg2elemjgs[2] = std::vector<std::size_t> {2};
  
  JetGroupProduct jgp(siblings, satisfiedBy, condMult, jg2elemjgs);
 
  auto collector = std::unique_ptr<ITrigJetHypoInfoCollector>(nullptr);
 
  EXPECT_TRUE(jgp.valid());
 
  auto exp = std::vector<std::size_t>{0, 1};
  EXPECT_EQ(jgp.next(collector), exp);
 
  exp = std::vector<std::size_t>{0, 2};
  EXPECT_EQ(jgp.next(collector), exp);
  
  exp = std::vector<std::size_t>{1, 2};
  EXPECT_EQ(jgp.next(collector), exp);
 
  EXPECT_TRUE(jgp.next(collector).empty());
  if(collector) {collector->write();}
 
}