PlasCom2  1.0
XPACC Multi-physics simluation application
TestVarious.C
Go to the documentation of this file.
1 #include "Testing.H"
2 #include "Simulation.H"
3 #include "PCPPIntervalUtils.H"
4 
5 void OutputFactors(const std::deque<size_t> &inFac,size_t inNum)
6 {
7  std::cout << "Prime Factors of " << inNum << ":" << std::endl;
8  std::deque<size_t>::const_iterator facIt = inFac.begin();
9  while(facIt != inFac.end()){
10  std::cout << *facIt++;
11  if(facIt != inFac.end())
12  std::cout << ",";
13  }
14  std::cout << std::endl;
15 }
16 void OutputTestPartition(unsigned int rank,unsigned int numPart,pcpp::IndexIntervalType &partInterval)
17 {
18  std::cout << "Partition(" << rank << "," << numPart << "):";
19  partInterval.PrettyPrint(std::cout);
20  std::cout << std::endl;
21 }
22 void TestVarious(ix::test::results &serialUnitResults)
23 {
24  bool testPass = true;
25 
26  // int SimplePartitionInterval(const pcpp::IndexIntervalType &inInterval,
27  // std::vector<bool> partDirection,
28  // int partID,int numPart,
29  // pcpp::IndexIntervalType &outInterval);
30 
31 
32  std::vector<size_t> domainStart(3,0);
33  std::vector<size_t> domainSize1(3,16);
34  pcpp::IndexIntervalType testInterval1(domainStart,domainSize1);
35  std::vector<bool> partDirection;
36  pcpp::IndexIntervalType partInterval;
37  std::vector<int> numPartitions;
38  std::vector<bool> partitionTest(16,false);
39  partitionTest[1] = true;
40  if(SimplePartitionInterval(testInterval1,partDirection,0,1,partInterval,numPartitions)){
41  testPass = false;
42  } else {
43  partitionTest[0] = true;
44  if(partInterval != testInterval1)
45  partitionTest[0] = false;
46  }
47  numPartitions.resize(0);
48  partDirection.resize(0);
49  if(SimplePartitionInterval(testInterval1,partDirection,0,2,partInterval,numPartitions)){
50  testPass = false;
51  } else {
52  partitionTest[1] = true;
53  if(partInterval[0] != testInterval1[0] &&
54  partInterval[1] != testInterval1[1] &&
55  partInterval[2].second != 7)
56  partitionTest[1] = false;
57  }
58  numPartitions.resize(0);
59  if(SimplePartitionInterval(testInterval1,partDirection,1,2,partInterval,numPartitions)){
60  testPass = false;
61  } else {
62  partitionTest[2] = true;
63  if(partInterval[0] != testInterval1[0] &&
64  partInterval[1] != testInterval1[1] &&
65  partInterval[2].first != 8)
66  partitionTest[2] = false;
67  }
68  partDirection.resize(0);
69  numPartitions.resize(0);
70  if(SimplePartitionInterval(testInterval1,partDirection,0,3,partInterval,numPartitions)){
71  testPass = false;
72  } else {
73  partitionTest[3] = true;
74  if(partInterval[0] != testInterval1[0] &&
75  partInterval[1] != testInterval1[1] &&
76  partInterval[2].second != 5)
77  partitionTest[3] = false;
78  }
79  numPartitions.resize(0);
80  if(SimplePartitionInterval(testInterval1,partDirection,1,3,partInterval,numPartitions)){
81  testPass = false;
82  } else {
83  partitionTest[3] = true;
84  if(partInterval[2].first != 6 &&
85  partInterval[2].second != 10 &&
86  partInterval[1] != testInterval1[1] &&
87  partInterval[0] != testInterval1[0])
88  partitionTest[3] = false;
89  }
90  numPartitions.resize(0);
91  if(SimplePartitionInterval(testInterval1,partDirection,2,3,partInterval,numPartitions)){
92  testPass = false;
93  } else {
94  partitionTest[3] = true;
95  if(partInterval[2].first != 11 &&
96  partInterval[2].second != 15 &&
97  partInterval[1] != testInterval1[1] &&
98  partInterval[0] != testInterval1[0])
99  partitionTest[3] = false;
100  }
101  partDirection.resize(0);
102  numPartitions.resize(0);
103  if(SimplePartitionInterval(testInterval1,partDirection,0,4,partInterval,numPartitions)){
104  testPass = false;
105  std::cout << "Test 4 failed." << std::endl;
106  } else {
107  OutputTestPartition(0,4,partInterval);
108  partitionTest[4] = true;
109  if(partInterval[2].second != 7 &&
110  partInterval[1].second != 7 &&
111  partInterval[0] != testInterval1[0])
112  partitionTest[4] = false;
113  }
114  numPartitions.resize(0);
115  if(SimplePartitionInterval(testInterval1,partDirection,1,4,partInterval,numPartitions)){
116  testPass = false;
117  } else {
118  OutputTestPartition(1,4,partInterval);
119  partitionTest[5] = true;
120  if(partInterval[1].first != 8 &&
121  partInterval[2].second != 7 &&
122  partInterval[0] != testInterval1[0])
123  partitionTest[5] = false;
124  }
125  numPartitions.resize(0);
126  if(SimplePartitionInterval(testInterval1,partDirection,2,4,partInterval,numPartitions)){
127  testPass = false;
128  } else {
129  OutputTestPartition(2,4,partInterval);
130  partitionTest[6] = true;
131  if(partInterval[1].second != 7 &&
132  partInterval[2].second != 15 &&
133  partInterval[0] != testInterval1[0])
134  partitionTest[6] = false;
135  }
136  numPartitions.resize(0);
137  if(SimplePartitionInterval(testInterval1,partDirection,3,4,partInterval,numPartitions)){
138  testPass = false;
139  } else {
140  OutputTestPartition(3,4,partInterval);
141  partitionTest[7] = true;
142  if(partInterval[1].first != 8 &&
143  partInterval[2].first != 8 &&
144  partInterval[0] != testInterval1[0])
145  partitionTest[7] = false;
146  }
147  partDirection.resize(0);
148  numPartitions.resize(0);
149  if(SimplePartitionInterval(testInterval1,partDirection,0,8,partInterval,numPartitions)){
150  testPass = false;
151  } else {
152  partitionTest[8] = true;
153  if(partInterval[0].second != 7 &&
154  partInterval[1].second != 7 &&
155  partInterval[2].second != 7)
156  partitionTest[8] = false;
157  }
158  numPartitions.resize(0);
159  if(SimplePartitionInterval(testInterval1,partDirection,1,8,partInterval,numPartitions)){
160  testPass = false;
161  } else {
162  partitionTest[9] = true;
163  if(partInterval[0].second != 15 &&
164  partInterval[1].second != 7 &&
165  partInterval[2].second != 7)
166  partitionTest[9] = false;
167  }
168  numPartitions.resize(0);
169  if(SimplePartitionInterval(testInterval1,partDirection,2,8,partInterval,numPartitions)){
170  testPass = false;
171  } else {
172  partitionTest[10] = true;
173  if(partInterval[0].second != 7 &&
174  partInterval[1].second != 15 &&
175  partInterval[2].second != 7)
176  partitionTest[10] = false;
177  }
178  numPartitions.resize(0);
179  if(SimplePartitionInterval(testInterval1,partDirection,3,8,partInterval,numPartitions)){
180  testPass = false;
181  } else {
182  partitionTest[11] = true;
183  if(partInterval[0].second != 15 &&
184  partInterval[1].second != 15 &&
185  partInterval[2].second != 7)
186  partitionTest[11] = false;
187  }
188  numPartitions.resize(0);
189  if(SimplePartitionInterval(testInterval1,partDirection,4,8,partInterval,numPartitions)){
190  testPass = false;
191  } else {
192  partitionTest[12] = true;
193  if(partInterval[0].second != 7 &&
194  partInterval[1].second != 7 &&
195  partInterval[2].second != 15)
196  partitionTest[12] = false;
197  }
198  numPartitions.resize(0);
199  if(SimplePartitionInterval(testInterval1,partDirection,5,8,partInterval,numPartitions)){
200  testPass = false;
201  } else {
202  partitionTest[13] = true;
203  if(partInterval[0].second != 15 &&
204  partInterval[1].second != 7 &&
205  partInterval[2].second != 15)
206  partitionTest[13] = false;
207  }
208  numPartitions.resize(0);
209  if(SimplePartitionInterval(testInterval1,partDirection,6,8,partInterval,numPartitions)){
210  testPass = false;
211  } else {
212  partitionTest[14] = true;
213  if(partInterval[0].second != 7 &&
214  partInterval[1].second != 15 &&
215  partInterval[2].second != 15)
216  partitionTest[14] = false;
217  }
218  numPartitions.resize(0);
219  if(SimplePartitionInterval(testInterval1,partDirection,7,8,partInterval,numPartitions)){
220  testPass = false;
221  } else {
222  partitionTest[15] = true;
223  if(partInterval[0].second != 15 &&
224  partInterval[1].second != 15 &&
225  partInterval[2].second != 15)
226  partitionTest[15] = false;
227  }
228 
229  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval",testPass);
230  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-1",partitionTest[0]);
231  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-2-0",partitionTest[1]);
232  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-2-1",partitionTest[2]);
233  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-3",partitionTest[3]);
234  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-4-0",partitionTest[4]);
235  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-4-1",partitionTest[5]);
236  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-4-2",partitionTest[6]);
237  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-4-3",partitionTest[7]);
238  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-0",partitionTest[8]);
239  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-1",partitionTest[9]);
240  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-2",partitionTest[10]);
241  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-3",partitionTest[11]);
242  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-4",partitionTest[12]);
243  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-5",partitionTest[13]);
244  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-6",partitionTest[14]);
245  serialUnitResults.UpdateResult("PCPP::SimplePartitionInterval-8-7",partitionTest[15]);
246 
247 
248 }
249 
pcpp::util::SimplePartitionInterval
int SimplePartitionInterval(const pcpp::IndexIntervalType &inInterval, std::vector< bool > partDirection, int partID, int numPart, pcpp::IndexIntervalType &outInterval, std::vector< int > &numPartitions)
Multi-dimensional interval partitioning (non-MPI)
Definition: PCPPIntervalUtils.C:151
TestVarious
void TestVarious(ix::test::results &serialUnitResults)
Definition: TestVarious.C:22
ix::test::results
Encapsulating class for collections of test results.
Definition: Testing.H:18
OutputTestPartition
void OutputTestPartition(unsigned int rank, unsigned int numPart, pcpp::IndexIntervalType &partInterval)
Definition: TestVarious.C:16
Testing.H
Testing constructs for unit testing.
ix::test::results::UpdateResult
void UpdateResult(const std::string &name, const ValueType &result)
Updates an existing test result.
Definition: Testing.H:55
ix::util::sizeextent::PrettyPrint
std::ostream & PrettyPrint(std::ostream &outStream) const
Definition: IndexUtil.C:6
ix::util::sizeextent
Simple Block Structured Mesh object.
Definition: IndexUtil.H:21
OutputFactors
void OutputFactors(const std::deque< size_t > &inFac, size_t inNum)
Definition: TestVarious.C:5
testPass
bool testPass
Definition: TestICEReplace.C:2