etrobocon2018 feat.KatLab  770af34cce41ae9c30c41303275e1add2daae0c3 (with uncommitted changes)
 全て クラス 名前空間 ファイル 関数 変数 列挙型 列挙値 フレンド マクロ定義 ページ
SelectorTest.cpp
[詳解]
1 
5 #include "Selector.h"
6 #include <gtest/gtest.h>
7 
8 namespace etrobocon2018_test {
9 
10  // ブロックの位置のリストを設定すると設定値を返す
11  TEST(SelectorTest, getBlockPositionListTest)
12  {
13  Selector obj;
14  std::vector<std::int8_t> expected{ { 0, 1, 2, 3 } };
15 
16  obj.setBlockPositionList(expected);
17  auto actual = obj.getBlockPositionList();
18 
19  ASSERT_EQ(expected, actual);
20  }
21 
22  // Explorerクラスを用いた同じリストを返す
23  TEST(SelectorTest, searchRouteByExplorerTest)
24  {
25  Selector obj;
26  std::vector<int> expected{ { 11, 7, 3, 2, 1, 5 } };
27  std::vector<std::int8_t> nodeHadBlockList{{6, 9, 10}};
28 
29 
30  obj.prepareSearching(nodeHadBlockList);
31  auto actual = obj.searchRoute(11, 5);
32 
33  for(unsigned int i = 0; i < actual.size(); i++) {
34  EXPECT_EQ(actual[i], expected[i]);
35  }
36 
37  ASSERT_EQ(expected.size(), actual.size());
38  }
39 
40  // ノード8を返す
41  TEST(SelectorTest, searchNode8Test)
42  {
43  Selector obj;
44  std::vector<std::int8_t> blockList{ { 0, 1, 2, 8 } };
45  std::int8_t expected = 8;
46 
47  obj.setBlockPositionList(blockList);
48  auto actual = obj.searchBlockPosition(8);
49 
50  ASSERT_EQ(expected, actual);
51  }
52 
53  // ノード9を返す
54  TEST(SelectorTest, searchNode9Test)
55  {
56  Selector obj;
57  std::vector<std::int8_t> blockList{ { 0, 1, 2, 9 } };
58  std::int8_t expected = 9;
59 
60  obj.setBlockPositionList(blockList);
61  auto actual = obj.searchBlockPosition(8);
62 
63  ASSERT_EQ(expected, actual);
64  }
65 
66  // ノード1を返す
67  TEST(SelectorTest, searchNode1Test)
68  {
69  Selector obj;
70  std::vector<std::int8_t> blockList{ { 1, 2, 3, 7 } };
71  std::int8_t expected = 1;
72 
73  obj.setBlockPositionList(blockList);
74  auto actual = obj.searchBlockPosition(8);
75 
76  ASSERT_EQ(expected, actual);
77  }
78 
79  // ノード10を返す
80  TEST(SelectorTest, searchNode10Test)
81  {
82  Selector obj;
83  std::vector<std::int8_t> blockList{ { 0, 2, 10, 14 } };
84  std::int8_t expected = 10;
85 
86  obj.setBlockPositionList(blockList);
87  auto actual = obj.searchBlockPosition(8);
88 
89  ASSERT_EQ(expected, actual);
90  }
91 
92  // ノード6を返す
93  TEST(SelectorTest, searchNode6Test)
94  {
95  Selector obj;
96  std::vector<std::int8_t> blockList{ { 6, 7, 10, 11 } };
97  std::int8_t expected = 6;
98 
99  obj.addMovedBlockPosition(10);
100  obj.setBlockPositionList(blockList);
101  auto actual = obj.searchBlockPosition(13);
102 
103  ASSERT_EQ(expected, actual);
104  }
105 
106  // ノード0を返す
107  TEST(SelectorTest, searchNode0Test)
108  {
109  Selector obj;
110  std::vector<std::int8_t> blockList{ { 0, 2, 3, 15 } };
111  std::int8_t expected = 0;
112 
113  obj.setBlockPositionList(blockList);
114  auto actual = obj.searchBlockPosition(8);
115 
116  ASSERT_EQ(expected, actual);
117  }
118 
119  // 移動済みブロックを設定できているかどうかチェックする
120  TEST(SelectorTest, checkWhetherThereIsMovedBlock)
121  {
122  Selector obj;
123 
124  ASSERT_FALSE(obj.isAlreadyMovedNode(1));
125  ASSERT_FALSE(obj.isAlreadyMovedNode(10));
126 
127  obj.addMovedBlockPosition(1);
128 
129  ASSERT_TRUE(obj.isAlreadyMovedNode(1));
130  ASSERT_FALSE(obj.isAlreadyMovedNode(10));
131 
132  obj.addMovedBlockPosition(10);
133 
134  ASSERT_TRUE(obj.isAlreadyMovedNode(1));
135  ASSERT_TRUE(obj.isAlreadyMovedNode(10));
136  }
137 
138  // 初期値において次の動作は全て偽とする
139  TEST(SelectorTest, checkNextOperationIsAllFalseInInitialStageTest)
140  {
141  Selector obj;
142 
143  ASSERT_FALSE(obj.isEvacuatingWithNext());
144  ASSERT_FALSE(obj.isMovingWithNext());
145  ASSERT_FALSE(obj.isCarryingWithNext());
146  }
147 
148  // 次の動作を設定するとそれ以外の動作は全て偽とする
149  TEST(SelectorTest, checkNextOperationIsAllFalseWithoutSetNextWhenNextIsSetTest)
150  {
151  Selector obj;
152 
153  obj.setNext(Selector::Evacuating);
154  ASSERT_TRUE(obj.isEvacuatingWithNext());
155  ASSERT_FALSE(obj.isMovingWithNext());
156  ASSERT_FALSE(obj.isCarryingWithNext());
157 
158  obj.setNext(Selector::Moving);
159  ASSERT_FALSE(obj.isEvacuatingWithNext());
160  ASSERT_TRUE(obj.isMovingWithNext());
161  ASSERT_FALSE(obj.isCarryingWithNext());
162 
163  obj.setNext(Selector::Carrying);
164  ASSERT_FALSE(obj.isEvacuatingWithNext());
165  ASSERT_FALSE(obj.isMovingWithNext());
166  ASSERT_TRUE(obj.isCarryingWithNext());
167  }
168 
169  // 初期値において軌跡はないものとする
170  TEST(SelectorTest, checkThereAreNotNodeInInitialRouteTest)
171  {
172  Selector obj;
173  unsigned int expected = 0;
174 
175  // あってもなくても関係なし
176  obj.setBlockPositionList(std::vector<std::int8_t>({ 1, 2, 3 }));
177 
178  auto actual = obj.extractRoute();
179 
180  ASSERT_EQ(expected, actual.size());
181  }
182 
183  // 設定した軌跡を返す
184  TEST(SelectorTest, getSomeNodeInRouteWhenRouteIsSetTest)
185  {
186  Selector obj;
187  std::vector<int> expectedList = { 0, 1, 2, 3, 7, 11, 15, 14, 13, 12, 8, 4, 5, 6, 10, 9 };
188 
189  obj.updateRoute(expectedList);
190  auto actual = obj.extractRoute();
191 
192  ASSERT_EQ(expectedList.size(), actual.size());
193  for(unsigned int i = 0; i < actual.size(); i++) EXPECT_EQ(expectedList[i], actual[i]);
194 
195  expectedList = { 8, 9, 10, 11 };
196  obj.updateRoute(expectedList);
197  actual = obj.extractRoute();
198 
199  ASSERT_EQ(expectedList.size(), actual.size());
200  for(unsigned int i = 0; i < actual.size(); i++) EXPECT_EQ(expectedList[i], actual[i]);
201  }
202 
203  // 色を設定すると中央四角形における次に置くべき位置コードを取得する
204  TEST(SelectorTest, getNextPositionInCenterIfColorSetInNodeIDTest)
205  {
206  Selector obj;
207 
208  auto actual = obj.getPositionOfCenterQuadirilateral(Selector::Blue);
209  ASSERT_EQ(10, actual);
210 
211  actual = obj.getPositionOfCenterQuadirilateral(Selector::Red);
212  ASSERT_EQ(6, actual);
213 
214  actual = obj.getPositionOfCenterQuadirilateral(Selector::Yellow);
215  ASSERT_EQ(9, actual);
216 
217  actual = obj.getPositionOfCenterQuadirilateral(Selector::Green);
218  ASSERT_EQ(5, actual);
219 
220  actual = obj.getPositionOfCenterQuadirilateral(Selector::Undefined);
221  ASSERT_EQ(-1, actual);
222  }
223 
224  // 疑似スタック配列のプッシュ機能およびポップ機能を確認する
225  TEST(SelectorTest, checkPushingAndPoppingByPseudoStackTest)
226  {
227  Selector obj;
228 
229  obj.pushEvacuatedBlockPosition(10);
230  obj.pushEvacuatedBlockPosition(20);
231  obj.pushEvacuatedBlockPosition(30);
232 
233  auto actual = obj.popEvacuatedBlockPosition();
234  ASSERT_EQ(30, actual);
235  actual = obj.popEvacuatedBlockPosition();
236  ASSERT_EQ(20, actual);
237 
238  obj.pushEvacuatedBlockPosition(40);
239 
240  actual = obj.popEvacuatedBlockPosition();
241  ASSERT_EQ(40, actual);
242  actual = obj.popEvacuatedBlockPosition();
243  ASSERT_EQ(10, actual);
244  }
245 
246  // シナリオテストでノードを探索する
247  TEST(SelectorTest, searchNodeInSenarioTest)
248  {
249  Selector obj;
250  std::vector<std::int8_t> blockList{ { 8, 9, 11, 15 } };
251 
252  obj.setBlockPositionList(blockList);
253 
254  // 8を探す
255  auto actual8 = obj.searchBlockPosition(8);
256  ASSERT_EQ(8, actual8);
257 
258  // 9を探す
259  blockList = { 9, 10, 11, 15 };
260  obj.setBlockPositionList(blockList);
261  obj.addMovedBlockPosition(10);
262  auto actual9 = obj.searchBlockPosition(14);
263  ASSERT_EQ(9, actual9);
264 
265  // 11を探す
266  blockList = { 6, 10, 11, 15 };
267  obj.setBlockPositionList(blockList);
268  obj.addMovedBlockPosition(6);
269  auto actual11 = obj.searchBlockPosition(5);
270  ASSERT_EQ(11, actual11);
271 
272  // 15を探す
273  blockList = { 6, 9, 10, 15 };
274  obj.setBlockPositionList(blockList);
275  obj.addMovedBlockPosition(5);
276  auto actual15 = obj.searchBlockPosition(15);
277  ASSERT_EQ(15, actual15);
278  }
279 
280  // シナリオテストで一連のルートを探索する
281  TEST(SelectorTest, searchRouteInSenarioTest)
282  {
283  Selector obj;
284  std::vector<std::int8_t> blockList{ { 8, 9, 11, 15 } };
285  // 8->Blue, 9->Red, 11->Yellow, 15->Green
286  std::vector<int> expectedMovingToBlue = { 8 };
287  std::vector<int> expectedCarryingBlue = { 8, 12, 13, 14, 10 };
288  std::vector<int> expectedMovingToRed = { 14, 13, 9 };
289  std::vector<int> expectedCarryingRed = { 9, 5, 6 };
290  std::vector<int> expectedMovingToYellow = { 5, 1, 2, 3, 7, 11 };
291  std::vector<int> expectedCarryingYellow = { 11, 7, 3, 2, 1, 5, 9 };
292  std::vector<int> expectedMovingToGreen = { 5, 4, 8, 12, 13, 14, 15 };
293  std::vector<int> expectedCarryingGreen = { 15, 14, 13, 12, 8, 4, 5 };
294  std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };
295 
296  obj.setBlockPositionList(blockList);
297 
298  // 8に移動する
299  auto actualMovingToBlue = obj.exploreNextOperation(8, Selector::Undefined);
300 
301  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
302  ASSERT_EQ(expectedMovingToBlue.size(), actualMovingToBlue.size());
303  for(unsigned int i = 0; i < actualMovingToBlue.size(); i++)
304  EXPECT_EQ(actualMovingToBlue[i], expectedMovingToBlue[i]);
305  ASSERT_FALSE(obj.isEvacuatingWithNext());
306  ASSERT_TRUE(obj.isMovingWithNext());
307  ASSERT_FALSE(obj.isCarryingWithNext());
308  ASSERT_FALSE(obj.isBackstepping());
309  ASSERT_EQ(8, obj.getBlockPositionList()[0]);
310  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
311  ASSERT_EQ(11, obj.getBlockPositionList()[2]);
312  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
313  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
314 
315  // 10に運搬する
316  auto actualCarryingBlue = obj.exploreNextOperation(8, Selector::Blue);
317 
318  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
319  ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
320  for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
321  EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
322  ASSERT_FALSE(obj.isEvacuatingWithNext());
323  ASSERT_FALSE(obj.isMovingWithNext());
324  ASSERT_TRUE(obj.isCarryingWithNext());
325  ASSERT_TRUE(obj.isBackstepping());
326  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
327  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
328  ASSERT_EQ(11, obj.getBlockPositionList()[2]);
329  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
330  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
331 
332  // 9に移動する
333  auto actualMovingToRed = obj.exploreNextOperation(14, Selector::Undefined);
334 
335  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
336  ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
337  for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
338  EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
339  ASSERT_FALSE(obj.isEvacuatingWithNext());
340  ASSERT_TRUE(obj.isMovingWithNext());
341  ASSERT_FALSE(obj.isCarryingWithNext());
342  ASSERT_FALSE(obj.isBackstepping());
343  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
344  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
345  ASSERT_EQ(11, obj.getBlockPositionList()[2]);
346  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
347  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
348 
349  // 6に運搬する
350  auto actualCarryingRed = obj.exploreNextOperation(9, Selector::Red);
351 
352  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
353  ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
354  for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
355  EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
356  ASSERT_FALSE(obj.isEvacuatingWithNext());
357  ASSERT_FALSE(obj.isMovingWithNext());
358  ASSERT_TRUE(obj.isCarryingWithNext());
359  ASSERT_TRUE(obj.isBackstepping());
360  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
361  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
362  ASSERT_EQ(11, obj.getBlockPositionList()[2]);
363  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
364  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
365 
366  // 11に移動する
367  auto actualMovingToYellow = obj.exploreNextOperation(5, Selector::Undefined);
368 
369  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
370  ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
371  for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
372  EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
373  ASSERT_FALSE(obj.isEvacuatingWithNext());
374  ASSERT_TRUE(obj.isMovingWithNext());
375  ASSERT_FALSE(obj.isCarryingWithNext());
376  ASSERT_FALSE(obj.isBackstepping());
377  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
378  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
379  ASSERT_EQ(11, obj.getBlockPositionList()[2]);
380  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
381  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
382 
383  // 9に運搬する
384  auto actualCarryingYellow = obj.exploreNextOperation(11, Selector::Yellow);
385 
386  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
387  ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
388  for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
389  EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
390  ASSERT_FALSE(obj.isEvacuatingWithNext());
391  ASSERT_FALSE(obj.isMovingWithNext());
392  ASSERT_TRUE(obj.isCarryingWithNext());
393  ASSERT_TRUE(obj.isBackstepping());
394  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
395  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
396  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
397  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
398  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
399 
400  // 15に移動する
401  auto actualMovingToGreen = obj.exploreNextOperation(5, Selector::Undefined);
402 
403  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
404  ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
405  for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
406  EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
407  ASSERT_FALSE(obj.isEvacuatingWithNext());
408  ASSERT_TRUE(obj.isMovingWithNext());
409  ASSERT_FALSE(obj.isCarryingWithNext());
410  ASSERT_FALSE(obj.isBackstepping());
411  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
412  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
413  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
414  ASSERT_EQ(15, obj.getBlockPositionList()[3]);
415  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
416 
417  // 5に運搬する
418  auto actualCarryingGreen = obj.exploreNextOperation(15, Selector::Green);
419 
420  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
421  ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
422  for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
423  EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
424  ASSERT_FALSE(obj.isEvacuatingWithNext());
425  ASSERT_FALSE(obj.isMovingWithNext());
426  ASSERT_TRUE(obj.isCarryingWithNext());
427  ASSERT_TRUE(obj.isBackstepping());
428  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
429  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
430  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
431  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
432  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
433 
434  // 11に移動する
435  auto actualMovingTo11 = obj.exploreNextOperation(4, Selector::Undefined);
436 
437  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
438  ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
439  for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
440  EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
441  ASSERT_FALSE(obj.isEvacuatingWithNext());
442  ASSERT_TRUE(obj.isMovingWithNext());
443  ASSERT_FALSE(obj.isCarryingWithNext());
444  ASSERT_FALSE(obj.isBackstepping());
445  ASSERT_EQ(10, obj.getBlockPositionList()[0]);
446  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
447  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
448  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
449  ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
450  }
451 
452  // 経路が塞がれてる場合の一連のルートを探索する
453  TEST(SelectorTest, searchRouteWhenPathBlocked)
454  {
455  Selector obj;
456  std::vector<std::int8_t> blockList{ { 4, 8, 9, 13 } };
457  // 8->Blue, 9->Red, 13->Yellow, 4->Green
458  // std::vector<int> expectedMovingToBlue = {8};
459  std::vector<int> expectedEvacuatingBlue = { 8, 12 };
460  std::vector<int> expectedMovingToRed = { 8, 9 };
461  std::vector<int> expectedCarryingRed = { 9, 10, 6 };
462  std::vector<int> expectedReturningToBlue = { 10, 9, 8, 12 };
463  std::vector<int> expectedCarryingBlue = { 12, 8, 9, 10 };
464  std::vector<int> expectedMovingToYellow = { 9, 13 };
465  std::vector<int> expectedCarryingYellow = { 13, 9 };
466  std::vector<int> expectedMovingToGreen = { 13, 12, 8, 4 };
467  std::vector<int> expectedCarryingGreen = { 4, 5 };
468  std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };
469 
470  obj.setBlockPositionList(blockList);
471 
472  // 8に移動する
473  obj.exploreNextOperation(8, Selector::Undefined);
474  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
475  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
476 
477  // 12に一時避難する
478  auto actualEvacuatingBlue = obj.exploreNextOperation(8, Selector::Blue);
479 
480  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
481  ASSERT_EQ(expectedEvacuatingBlue.size(), actualEvacuatingBlue.size());
482  for(unsigned int i = 0; i < actualEvacuatingBlue.size(); i++)
483  EXPECT_EQ(actualEvacuatingBlue[i], expectedEvacuatingBlue[i]);
484  ASSERT_TRUE(obj.isEvacuatingWithNext());
485  ASSERT_FALSE(obj.isMovingWithNext());
486  ASSERT_FALSE(obj.isCarryingWithNext());
487  ASSERT_TRUE(obj.isBackstepping());
488  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
489  ASSERT_EQ(12, obj.getBlockPositionList()[1]);
490  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
491  ASSERT_EQ(13, obj.getBlockPositionList()[3]);
492  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
493 
494  // 9に移動する
495  auto actualMovingToRed = obj.exploreNextOperation(8, Selector::Undefined);
496 
497  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
498  ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
499  for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
500  EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
501  ASSERT_FALSE(obj.isEvacuatingWithNext());
502  ASSERT_TRUE(obj.isMovingWithNext());
503  ASSERT_FALSE(obj.isCarryingWithNext());
504  ASSERT_FALSE(obj.isBackstepping());
505  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
506  ASSERT_EQ(12, obj.getBlockPositionList()[1]);
507  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
508  ASSERT_EQ(13, obj.getBlockPositionList()[3]);
509  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
510 
511  // 6に運搬する
512  auto actualCarryingRed = obj.exploreNextOperation(9, Selector::Red);
513 
514  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
515  ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
516  for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
517  EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
518  ASSERT_FALSE(obj.isEvacuatingWithNext());
519  ASSERT_FALSE(obj.isMovingWithNext());
520  ASSERT_TRUE(obj.isCarryingWithNext());
521  ASSERT_TRUE(obj.isBackstepping());
522  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
523  ASSERT_EQ(12, obj.getBlockPositionList()[1]);
524  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
525  ASSERT_EQ(13, obj.getBlockPositionList()[3]);
526  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
527 
528  // 12に戻る
529  auto actualReturningToBlue = obj.exploreNextOperation(10, Selector::Undefined);
530 
531  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
532  ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
533  for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
534  EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
535  ASSERT_FALSE(obj.isEvacuatingWithNext());
536  ASSERT_TRUE(obj.isMovingWithNext());
537  ASSERT_FALSE(obj.isCarryingWithNext());
538  ASSERT_FALSE(obj.isBackstepping());
539  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
540  ASSERT_EQ(12, obj.getBlockPositionList()[1]);
541  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
542  ASSERT_EQ(13, obj.getBlockPositionList()[3]);
543  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
544 
545  // 10に運搬する
546  auto actualCarryingBlue = obj.exploreNextOperation(12, Selector::Blue);
547 
548  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
549  ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
550  for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
551  EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
552  ASSERT_FALSE(obj.isEvacuatingWithNext());
553  ASSERT_FALSE(obj.isMovingWithNext());
554  ASSERT_TRUE(obj.isCarryingWithNext());
555  ASSERT_TRUE(obj.isBackstepping());
556  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
557  ASSERT_EQ(10, obj.getBlockPositionList()[1]);
558  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
559  ASSERT_EQ(13, obj.getBlockPositionList()[3]);
560  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
561 
562  // 13に移動する
563  auto actualMovingToYellow = obj.exploreNextOperation(9, Selector::Undefined);
564 
565  ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
566  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
567  for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
568  EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
569  ASSERT_FALSE(obj.isEvacuatingWithNext());
570  ASSERT_TRUE(obj.isMovingWithNext());
571  ASSERT_FALSE(obj.isCarryingWithNext());
572  ASSERT_FALSE(obj.isBackstepping());
573  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
574  ASSERT_EQ(10, obj.getBlockPositionList()[1]);
575  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
576  ASSERT_EQ(13, obj.getBlockPositionList()[3]);
577  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
578 
579  // 9に運搬する
580  auto actualCarryingYellow = obj.exploreNextOperation(13, Selector::Yellow);
581 
582  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
583  ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
584  for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
585  EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
586  ASSERT_FALSE(obj.isEvacuatingWithNext());
587  ASSERT_FALSE(obj.isMovingWithNext());
588  ASSERT_TRUE(obj.isCarryingWithNext());
589  ASSERT_TRUE(obj.isBackstepping());
590  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
591  ASSERT_EQ(10, obj.getBlockPositionList()[1]);
592  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
593  ASSERT_EQ(9, obj.getBlockPositionList()[3]);
594  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
595 
596  // 4に移動する
597  auto actualMovingToGreen = obj.exploreNextOperation(13, Selector::Undefined);
598 
599  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
600  ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
601  for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
602  EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
603  ASSERT_FALSE(obj.isEvacuatingWithNext());
604  ASSERT_TRUE(obj.isMovingWithNext());
605  ASSERT_FALSE(obj.isCarryingWithNext());
606  ASSERT_FALSE(obj.isBackstepping());
607  ASSERT_EQ(4, obj.getBlockPositionList()[0]);
608  ASSERT_EQ(10, obj.getBlockPositionList()[1]);
609  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
610  ASSERT_EQ(9, obj.getBlockPositionList()[3]);
611  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
612 
613  // 5に運搬する
614  auto actualCarryingGreen = obj.exploreNextOperation(4, Selector::Green);
615 
616  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
617  ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
618  for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
619  EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
620  ASSERT_FALSE(obj.isEvacuatingWithNext());
621  ASSERT_FALSE(obj.isMovingWithNext());
622  ASSERT_TRUE(obj.isCarryingWithNext());
623  ASSERT_TRUE(obj.isBackstepping());
624  ASSERT_EQ(5, obj.getBlockPositionList()[0]);
625  ASSERT_EQ(10, obj.getBlockPositionList()[1]);
626  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
627  ASSERT_EQ(9, obj.getBlockPositionList()[3]);
628  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
629 
630  // 11に移動する
631  auto actualMovingTo11 = obj.exploreNextOperation(4, Selector::Undefined);
632 
633  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
634  ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
635  for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
636  EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
637  ASSERT_FALSE(obj.isEvacuatingWithNext());
638  ASSERT_TRUE(obj.isMovingWithNext());
639  ASSERT_FALSE(obj.isCarryingWithNext());
640  ASSERT_FALSE(obj.isBackstepping());
641  ASSERT_EQ(5, obj.getBlockPositionList()[0]);
642  ASSERT_EQ(10, obj.getBlockPositionList()[1]);
643  ASSERT_EQ(6, obj.getBlockPositionList()[2]);
644  ASSERT_EQ(9, obj.getBlockPositionList()[3]);
645  ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
646  }
647 
648  // 運搬先が1箇所埋まっている場合の一連のルートを探索する
649  TEST(SelectorTest, searchRouteWhenNextMovedPositionIsBuried)
650  {
651  Selector obj;
652  std::vector<std::int8_t> blockList{ { 3, 6, 8, 10 } };
653  // 8->Blue, 3->Red, 6->Yellow, 10->Green
654  // std::vector<int> expectedMovingToBlue = {8};
655  std::vector<int> expectedEvacuatingBlue = { 8, 12 };
656  std::vector<int> expectedMovingToGreen = { 8, 9, 10 };
657  std::vector<int> expectedCarryingGreen = { 10, 9, 5 };
658  std::vector<int> expectedReturningToBlue = { 9, 13, 12 };
659  std::vector<int> expectedCarryingBlue = { 12, 13, 14, 10 };
660  std::vector<int> expectedMovingToYellow = { 14, 15, 11, 7, 6 };
661  std::vector<int> expectedCarryingYellow = { 6, 7, 11, 15, 14, 13, 9 };
662  std::vector<int> expectedMovingToRed = { 13, 14, 15, 11, 7, 3 };
663  std::vector<int> expectedCarryingRed = { 3, 7, 6 };
664  std::vector<int> expectedMovingTo11 = { 7, 11 };
665 
666  obj.setBlockPositionList(blockList);
667 
668  // 8に移動する
669  obj.exploreNextOperation(8, Selector::Undefined);
670  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
671  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
672 
673  // 12に一時避難する
674  auto actualEvacuatingBlue = obj.exploreNextOperation(8, Selector::Blue);
675 
676  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
677  ASSERT_EQ(expectedEvacuatingBlue.size(), actualEvacuatingBlue.size());
678  for(unsigned int i = 0; i < actualEvacuatingBlue.size(); i++)
679  EXPECT_EQ(actualEvacuatingBlue[i], expectedEvacuatingBlue[i]);
680  ASSERT_TRUE(obj.isEvacuatingWithNext());
681  ASSERT_FALSE(obj.isMovingWithNext());
682  ASSERT_FALSE(obj.isCarryingWithNext());
683  ASSERT_TRUE(obj.isBackstepping());
684  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
685  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
686  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
687  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
688  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
689 
690  // 10に移動する
691  auto actualMovingToGreen = obj.exploreNextOperation(8, Selector::Undefined);
692 
693  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
694  ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
695  for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
696  EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
697  ASSERT_FALSE(obj.isEvacuatingWithNext());
698  ASSERT_TRUE(obj.isMovingWithNext());
699  ASSERT_FALSE(obj.isCarryingWithNext());
700  ASSERT_FALSE(obj.isBackstepping());
701  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
702  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
703  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
704  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
705  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
706 
707  // 5に運搬する
708  auto actualCarryingGreen = obj.exploreNextOperation(10, Selector::Green);
709 
710  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
711  ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
712  for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
713  EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
714  ASSERT_FALSE(obj.isEvacuatingWithNext());
715  ASSERT_FALSE(obj.isMovingWithNext());
716  ASSERT_TRUE(obj.isCarryingWithNext());
717  ASSERT_TRUE(obj.isBackstepping());
718  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
719  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
720  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
721  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
722  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
723 
724  // 12に移動する
725  auto actualReturningToBlue = obj.exploreNextOperation(9, Selector::Undefined);
726 
727  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
728  ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
729  for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
730  EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
731  ASSERT_FALSE(obj.isEvacuatingWithNext());
732  ASSERT_TRUE(obj.isMovingWithNext());
733  ASSERT_FALSE(obj.isCarryingWithNext());
734  ASSERT_FALSE(obj.isBackstepping());
735  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
736  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
737  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
738  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
739  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
740 
741  // 10に運搬する
742  auto actualCarryingBlue = obj.exploreNextOperation(12, Selector::Blue);
743 
744  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
745  ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
746  for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
747  EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
748  ASSERT_FALSE(obj.isEvacuatingWithNext());
749  ASSERT_FALSE(obj.isMovingWithNext());
750  ASSERT_TRUE(obj.isCarryingWithNext());
751  ASSERT_TRUE(obj.isBackstepping());
752  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
753  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
754  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
755  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
756  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
757 
758  // 6に移動する
759  auto actualMovingToYellow = obj.exploreNextOperation(14, Selector::Undefined);
760 
761  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
762  ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
763  for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
764  EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
765  ASSERT_FALSE(obj.isEvacuatingWithNext());
766  ASSERT_TRUE(obj.isMovingWithNext());
767  ASSERT_FALSE(obj.isCarryingWithNext());
768  ASSERT_FALSE(obj.isBackstepping());
769  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
770  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
771  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
772  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
773  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
774 
775  // 9に運搬する
776  auto actualCarryingYellow = obj.exploreNextOperation(6, Selector::Yellow);
777 
778  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
779  ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
780  for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
781  EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
782  ASSERT_FALSE(obj.isEvacuatingWithNext());
783  ASSERT_FALSE(obj.isMovingWithNext());
784  ASSERT_TRUE(obj.isCarryingWithNext());
785  ASSERT_TRUE(obj.isBackstepping());
786  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
787  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
788  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
789  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
790  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
791 
792  // 3に移動する
793  auto actualMovingToRed = obj.exploreNextOperation(13, Selector::Undefined);
794 
795  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
796  ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
797  for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
798  EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
799  ASSERT_FALSE(obj.isEvacuatingWithNext());
800  ASSERT_TRUE(obj.isMovingWithNext());
801  ASSERT_FALSE(obj.isCarryingWithNext());
802  ASSERT_FALSE(obj.isBackstepping());
803  ASSERT_EQ(3, obj.getBlockPositionList()[0]);
804  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
805  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
806  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
807  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
808 
809  // 6に運搬する
810  auto actualCarryingRed = obj.exploreNextOperation(3, Selector::Red);
811 
812  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
813  ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
814  for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
815  EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
816  ASSERT_FALSE(obj.isEvacuatingWithNext());
817  ASSERT_FALSE(obj.isMovingWithNext());
818  ASSERT_TRUE(obj.isCarryingWithNext());
819  ASSERT_TRUE(obj.isBackstepping());
820  ASSERT_EQ(6, obj.getBlockPositionList()[0]);
821  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
822  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
823  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
824  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
825 
826  // 11に移動する
827  auto actualMovingTo11 = obj.exploreNextOperation(7, Selector::Undefined);
828 
829  ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
830  for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
831  EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
832  ASSERT_FALSE(obj.isEvacuatingWithNext());
833  ASSERT_TRUE(obj.isMovingWithNext());
834  ASSERT_FALSE(obj.isCarryingWithNext());
835  ASSERT_FALSE(obj.isBackstepping());
836  ASSERT_EQ(6, obj.getBlockPositionList()[0]);
837  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
838  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
839  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
840  ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
841  }
842 
843  // 運搬先の運搬先の運搬先が埋まっている場合の一連のルートを探索する
844  TEST(SelectorTest, searchRouteWhenNextOfNextOfNextMovedPositionIsBuried)
845  {
846  Selector obj;
847  std::vector<std::int8_t> blockList{ { 5, 6, 8, 10 } };
848  // 8->Blue, 10->Red, 5->Yellow, 6->Green
849  // std::vector<int> expectedMovingToBlue = {8};
850  // std::vector<int> expectedEvacuatingBlue = {8, 12};
851  // std::vector<int> expectedMovingToRed = {8, 9, 10};
852  std::vector<int> expectedMovingToGreen = { 9, 13, 14, 15, 11, 7, 6 };
853  std::vector<int> expectedMovingToYellow = { 7, 3, 2, 1, 5 };
854  std::vector<int> expectedCarryingYellow = { 5, 9 };
855  std::vector<int> expectedReturningToGreen = { 5, 6 };
856  std::vector<int> expectedCarryingGreen = { 6, 5 };
857  std::vector<int> expectedReturningToRed = { 6, 10 };
858  std::vector<int> expectedCarryingRed = { 10, 6 };
859  std::vector<int> expectedReturningToBlue = { 10, 14, 13, 12 };
860  std::vector<int> expectedCarryingBlue = { 12, 13, 14, 10 };
861  std::vector<int> expectedMovingTo11 = { 14, 15, 11 };
862 
863  obj.setBlockPositionList(blockList);
864 
865  // 8に移動する
866  obj.exploreNextOperation(8, Selector::Undefined);
867  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
868  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
869 
870  // 12に一時避難する
871  obj.exploreNextOperation(8, Selector::Blue);
872  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
873  ASSERT_EQ(5, obj.getBlockPositionList()[0]);
874  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
875  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
876  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
877  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
878 
879  // 10に移動する
880  obj.exploreNextOperation(8, Selector::Undefined);
881  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
882  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
883 
884  // 6に移動する
885  auto actualMovingToGreen = obj.exploreNextOperation(10, Selector::Red);
886 
887  ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
888  ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
889  for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
890  EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
891  ASSERT_FALSE(obj.isEvacuatingWithNext());
892  ASSERT_TRUE(obj.isMovingWithNext());
893  ASSERT_FALSE(obj.isCarryingWithNext());
894  ASSERT_FALSE(obj.isBackstepping());
895  ASSERT_EQ(5, obj.getBlockPositionList()[0]);
896  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
897  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
898  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
899  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
900 
901  // 5に移動する
902  auto actualMovingToYellow = obj.exploreNextOperation(6, Selector::Green);
903 
904  ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
905  ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
906  for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
907  EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
908  ASSERT_FALSE(obj.isEvacuatingWithNext());
909  ASSERT_TRUE(obj.isMovingWithNext());
910  ASSERT_FALSE(obj.isCarryingWithNext());
911  ASSERT_FALSE(obj.isBackstepping());
912  ASSERT_EQ(5, obj.getBlockPositionList()[0]);
913  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
914  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
915  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
916  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
917 
918  // 9に運搬する
919  auto actualCarryingYellow = obj.exploreNextOperation(5, Selector::Yellow);
920 
921  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
922  ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
923  for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
924  EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
925  ASSERT_FALSE(obj.isEvacuatingWithNext());
926  ASSERT_FALSE(obj.isMovingWithNext());
927  ASSERT_TRUE(obj.isCarryingWithNext());
928  ASSERT_TRUE(obj.isBackstepping());
929  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
930  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
931  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
932  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
933  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
934 
935  // 6に戻る
936  auto actualReturningToGreen = obj.exploreNextOperation(5, Selector::Undefined);
937 
938  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
939  ASSERT_EQ(expectedReturningToGreen.size(), actualReturningToGreen.size());
940  for(unsigned int i = 0; i < actualReturningToGreen.size(); i++)
941  EXPECT_EQ(actualReturningToGreen[i], expectedReturningToGreen[i]);
942  ASSERT_FALSE(obj.isEvacuatingWithNext());
943  ASSERT_TRUE(obj.isMovingWithNext());
944  ASSERT_FALSE(obj.isCarryingWithNext());
945  ASSERT_FALSE(obj.isBackstepping());
946  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
947  ASSERT_EQ(6, obj.getBlockPositionList()[1]);
948  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
949  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
950  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
951 
952  // 5に運搬する
953  auto actualCarryingGreen = obj.exploreNextOperation(6, Selector::Green);
954 
955  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
956  ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
957  for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
958  EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
959  ASSERT_FALSE(obj.isEvacuatingWithNext());
960  ASSERT_FALSE(obj.isMovingWithNext());
961  ASSERT_TRUE(obj.isCarryingWithNext());
962  ASSERT_TRUE(obj.isBackstepping());
963  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
964  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
965  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
966  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
967  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
968 
969  // 10に戻る
970  auto actualReturningToRed = obj.exploreNextOperation(6, Selector::Undefined);
971 
972  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
973  ASSERT_EQ(expectedReturningToRed.size(), actualReturningToRed.size());
974  for(unsigned int i = 0; i < actualReturningToRed.size(); i++)
975  EXPECT_EQ(actualReturningToRed[i], expectedReturningToRed[i]);
976  ASSERT_FALSE(obj.isEvacuatingWithNext());
977  ASSERT_TRUE(obj.isMovingWithNext());
978  ASSERT_FALSE(obj.isCarryingWithNext());
979  ASSERT_FALSE(obj.isBackstepping());
980  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
981  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
982  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
983  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
984  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
985 
986  // 6に運搬する
987  auto actualCarryingRed = obj.exploreNextOperation(10, Selector::Red);
988 
989  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
990  ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
991  for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
992  EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
993  ASSERT_FALSE(obj.isEvacuatingWithNext());
994  ASSERT_FALSE(obj.isMovingWithNext());
995  ASSERT_TRUE(obj.isCarryingWithNext());
996  ASSERT_TRUE(obj.isBackstepping());
997  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
998  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
999  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
1000  ASSERT_EQ(6, obj.getBlockPositionList()[3]);
1001  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1002 
1003  // 12に戻る
1004  auto actualReturningToBlue = obj.exploreNextOperation(10, Selector::Undefined);
1005 
1006  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1007  ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
1008  for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
1009  EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
1010  ASSERT_FALSE(obj.isEvacuatingWithNext());
1011  ASSERT_TRUE(obj.isMovingWithNext());
1012  ASSERT_FALSE(obj.isCarryingWithNext());
1013  ASSERT_FALSE(obj.isBackstepping());
1014  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
1015  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
1016  ASSERT_EQ(12, obj.getBlockPositionList()[2]);
1017  ASSERT_EQ(6, obj.getBlockPositionList()[3]);
1018  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1019 
1020  // 10に運搬する
1021  auto actualCarryingBlue = obj.exploreNextOperation(12, Selector::Blue);
1022 
1023  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1024  ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
1025  for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
1026  EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
1027  ASSERT_FALSE(obj.isEvacuatingWithNext());
1028  ASSERT_FALSE(obj.isMovingWithNext());
1029  ASSERT_TRUE(obj.isCarryingWithNext());
1030  ASSERT_TRUE(obj.isBackstepping());
1031  ASSERT_EQ(9, obj.getBlockPositionList()[0]);
1032  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
1033  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1034  ASSERT_EQ(6, obj.getBlockPositionList()[3]);
1035  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1036 
1037  // 11に移動する
1038  auto actualMovingTo11 = obj.exploreNextOperation(14, Selector::Undefined);
1039 
1040  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1041  ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
1042  for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
1043  EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
1044  ASSERT_FALSE(obj.isEvacuatingWithNext());
1045  ASSERT_TRUE(obj.isMovingWithNext());
1046  ASSERT_FALSE(obj.isCarryingWithNext());
1047  ASSERT_FALSE(obj.isBackstepping());
1048  ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
1049  }
1050 
1051  // 運搬先がループしている場合の一連のルートを探索する
1052  TEST(SelectorTest, searchRouteWhenEachNextMovedPositionsIsLooped)
1053  {
1054  Selector obj;
1055  std::vector<std::int8_t> blockList{ { 0, 5, 9, 10 } };
1056  // 9->Blue, 0->Red, 5->Yellow, 10->Green
1057  std::vector<int> expectedMovingToBlue = { 8, 9 };
1058  std::vector<int> expectedMovingToGreen = { 8, 12, 13, 14, 10 };
1059  std::vector<int> expectedMovingToYellow = { 14, 15, 11, 7, 6, 5 };
1060  std::vector<int> expectedEvacuatingYellow = { 5, 6, 7, 3 };
1061  std::vector<int> expectedReturningToGreen = { 7, 11, 10 };
1062  std::vector<int> expectedCarryingGreen = { 10, 6, 5 };
1063  std::vector<int> expectedReturningToBlue = { 6, 10, 9 };
1064  std::vector<int> expectedCarryingBlue = { 9, 10 };
1065  std::vector<int> expectedMovingToRed = { 9, 8, 4, 0 };
1066  std::vector<int> expectedCarryingRed = { 0, 1, 2, 6 };
1067  std::vector<int> expectedReturningToYellow = { 2, 3 };
1068  std::vector<int> expectedCarryingYellow = { 3, 7, 11, 15, 14, 13, 9 };
1069  std::vector<int> expectedMovingTo11 = { 13, 14, 15, 11 };
1070 
1071  obj.setBlockPositionList(blockList);
1072 
1073  // 9に移動する
1074  auto actualMovingToBlue = obj.exploreNextOperation(8, Selector::Undefined);
1075 
1076  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1077  ASSERT_EQ(expectedMovingToBlue.size(), actualMovingToBlue.size());
1078  for(unsigned int i = 0; i < actualMovingToBlue.size(); i++)
1079  EXPECT_EQ(actualMovingToBlue[i], expectedMovingToBlue[i]);
1080  ASSERT_FALSE(obj.isEvacuatingWithNext());
1081  ASSERT_TRUE(obj.isMovingWithNext());
1082  ASSERT_FALSE(obj.isCarryingWithNext());
1083  ASSERT_FALSE(obj.isBackstepping());
1084  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1085  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
1086  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1087  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
1088  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1089 
1090  // 10に移動する
1091  auto actualMovingToGreen = obj.exploreNextOperation(9, Selector::Blue);
1092 
1093  ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
1094  ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
1095  for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
1096  EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
1097  ASSERT_FALSE(obj.isEvacuatingWithNext());
1098  ASSERT_TRUE(obj.isMovingWithNext());
1099  ASSERT_FALSE(obj.isCarryingWithNext());
1100  ASSERT_FALSE(obj.isBackstepping());
1101  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1102  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
1103  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1104  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
1105  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1106 
1107  // 5に移動する
1108  auto actualMovingToYellow = obj.exploreNextOperation(10, Selector::Green);
1109 
1110  ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
1111  ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
1112  for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
1113  EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
1114  ASSERT_FALSE(obj.isEvacuatingWithNext());
1115  ASSERT_TRUE(obj.isMovingWithNext());
1116  ASSERT_FALSE(obj.isCarryingWithNext());
1117  ASSERT_FALSE(obj.isBackstepping());
1118  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1119  ASSERT_EQ(5, obj.getBlockPositionList()[1]);
1120  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1121  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
1122  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1123 
1124  // 3に一時避難する
1125  auto actualEvacuatingYellow = obj.exploreNextOperation(5, Selector::Yellow);
1126 
1127  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1128  ASSERT_EQ(expectedEvacuatingYellow.size(), actualEvacuatingYellow.size());
1129  for(unsigned int i = 0; i < actualEvacuatingYellow.size(); i++)
1130  EXPECT_EQ(actualEvacuatingYellow[i], expectedEvacuatingYellow[i]);
1131  ASSERT_TRUE(obj.isEvacuatingWithNext());
1132  ASSERT_FALSE(obj.isMovingWithNext());
1133  ASSERT_FALSE(obj.isCarryingWithNext());
1134  ASSERT_TRUE(obj.isBackstepping());
1135  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1136  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1137  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1138  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
1139  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1140 
1141  // 10に戻る
1142  auto actualReturningToGreen = obj.exploreNextOperation(7, Selector::Undefined);
1143 
1144  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1145  ASSERT_EQ(expectedReturningToGreen.size(), actualReturningToGreen.size());
1146  for(unsigned int i = 0; i < actualReturningToGreen.size(); i++)
1147  EXPECT_EQ(actualReturningToGreen[i], expectedReturningToGreen[i]);
1148  ASSERT_FALSE(obj.isEvacuatingWithNext());
1149  ASSERT_TRUE(obj.isMovingWithNext());
1150  ASSERT_FALSE(obj.isCarryingWithNext());
1151  ASSERT_FALSE(obj.isBackstepping());
1152  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1153  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1154  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1155  ASSERT_EQ(10, obj.getBlockPositionList()[3]);
1156  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1157 
1158  // 5に運搬する
1159  auto actualCarryingGreen = obj.exploreNextOperation(10, Selector::Green);
1160 
1161  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1162  ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
1163  for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
1164  EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
1165  ASSERT_FALSE(obj.isEvacuatingWithNext());
1166  ASSERT_FALSE(obj.isMovingWithNext());
1167  ASSERT_TRUE(obj.isCarryingWithNext());
1168  ASSERT_TRUE(obj.isBackstepping());
1169  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1170  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1171  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1172  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1173  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1174 
1175  // 9に戻る
1176  auto actualReturningToBlue = obj.exploreNextOperation(6, Selector::Undefined);
1177 
1178  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1179  ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
1180  for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
1181  EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
1182  ASSERT_FALSE(obj.isEvacuatingWithNext());
1183  ASSERT_TRUE(obj.isMovingWithNext());
1184  ASSERT_FALSE(obj.isCarryingWithNext());
1185  ASSERT_FALSE(obj.isBackstepping());
1186  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1187  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1188  ASSERT_EQ(9, obj.getBlockPositionList()[2]);
1189  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1190  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1191 
1192  // 10に運搬する
1193  auto actualCarryingBlue = obj.exploreNextOperation(9, Selector::Blue);
1194 
1195  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1196  ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
1197  for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
1198  EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
1199  ASSERT_FALSE(obj.isEvacuatingWithNext());
1200  ASSERT_FALSE(obj.isMovingWithNext());
1201  ASSERT_TRUE(obj.isCarryingWithNext());
1202  ASSERT_TRUE(obj.isBackstepping());
1203  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1204  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1205  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1206  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1207  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1208 
1209  // 0に移動する
1210  auto actualMovingToRed = obj.exploreNextOperation(9, Selector::Undefined);
1211 
1212  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1213  ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
1214  for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
1215  EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
1216  ASSERT_FALSE(obj.isEvacuatingWithNext());
1217  ASSERT_TRUE(obj.isMovingWithNext());
1218  ASSERT_FALSE(obj.isCarryingWithNext());
1219  ASSERT_FALSE(obj.isBackstepping());
1220  ASSERT_EQ(0, obj.getBlockPositionList()[0]);
1221  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1222  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1223  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1224  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1225 
1226  // 6に運搬する
1227  auto actualCarryingRed = obj.exploreNextOperation(0, Selector::Red);
1228 
1229  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1230  ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
1231  for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
1232  EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
1233  ASSERT_FALSE(obj.isEvacuatingWithNext());
1234  ASSERT_FALSE(obj.isMovingWithNext());
1235  ASSERT_TRUE(obj.isCarryingWithNext());
1236  ASSERT_TRUE(obj.isBackstepping());
1237  ASSERT_EQ(6, obj.getBlockPositionList()[0]);
1238  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1239  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1240  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1241  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1242 
1243  // 3に戻る
1244  auto actualReturningToYellow = obj.exploreNextOperation(2, Selector::Undefined);
1245 
1246  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1247  ASSERT_EQ(expectedReturningToYellow.size(), actualReturningToYellow.size());
1248  for(unsigned int i = 0; i < actualReturningToYellow.size(); i++)
1249  EXPECT_EQ(actualReturningToYellow[i], expectedReturningToYellow[i]);
1250  ASSERT_FALSE(obj.isEvacuatingWithNext());
1251  ASSERT_TRUE(obj.isMovingWithNext());
1252  ASSERT_FALSE(obj.isCarryingWithNext());
1253  ASSERT_FALSE(obj.isBackstepping());
1254  ASSERT_EQ(6, obj.getBlockPositionList()[0]);
1255  ASSERT_EQ(3, obj.getBlockPositionList()[1]);
1256  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1257  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1258  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1259 
1260  // 9に運搬する
1261  auto actualCarryingYellow = obj.exploreNextOperation(3, Selector::Yellow);
1262 
1263  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1264  ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
1265  for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
1266  EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
1267  ASSERT_FALSE(obj.isEvacuatingWithNext());
1268  ASSERT_FALSE(obj.isMovingWithNext());
1269  ASSERT_TRUE(obj.isCarryingWithNext());
1270  ASSERT_TRUE(obj.isBackstepping());
1271  ASSERT_EQ(6, obj.getBlockPositionList()[0]);
1272  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
1273  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1274  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1275  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1276 
1277  // 11に移動する
1278  auto actualMovingTo11 = obj.exploreNextOperation(13, Selector::Undefined);
1279 
1280  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1281  ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
1282  for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
1283  EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
1284  ASSERT_FALSE(obj.isEvacuatingWithNext());
1285  ASSERT_TRUE(obj.isMovingWithNext());
1286  ASSERT_FALSE(obj.isCarryingWithNext());
1287  ASSERT_FALSE(obj.isBackstepping());
1288  ASSERT_EQ(6, obj.getBlockPositionList()[0]);
1289  ASSERT_EQ(9, obj.getBlockPositionList()[1]);
1290  ASSERT_EQ(10, obj.getBlockPositionList()[2]);
1291  ASSERT_EQ(5, obj.getBlockPositionList()[3]);
1292  ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
1293  }
1294 
1295  // 中央四角形に4つのブロックが初期位置として配置されている場合の一連のルートを探索する
1296  TEST(SelectorTest, searchRouteWhenAllNodeInitialPositionsIsFromCenterQuadirilateralTest)
1297  {
1298  Selector obj;
1299  std::vector<std::int8_t> blockList{ { 5, 6, 9, 10 } };
1300  // 6->Blue, 10->Red, 5->Yellow, 9->Green
1301  std::vector<int> expectedMovingToGreen = { 8, 9 };
1302  std::vector<int> expectedEvacuatingGreen = { 9, 13, 12 };
1303  std::vector<int> expectedMovingToYellow = { 13, 9, 5 };
1304  std::vector<int> expectedCarryingYellow = { 5, 9 };
1305  std::vector<int> expectedMovingToBlue = { 5, 6 };
1306  std::vector<int> expectedMovingToRed = { 5, 1, 2, 3, 7, 11, 10 };
1307  std::vector<int> expectedEvacuatingRed = { 10, 14, 15 };
1308  std::vector<int> expectedReturningToBlue = { 14, 10, 6 };
1309  std::vector<int> expectedCarryingBlue = { 6, 10 };
1310  std::vector<int> expectedReturningToRed = { 6, 7, 11, 15 };
1311  std::vector<int> expectedCarryingRed = { 15, 11, 7, 6 };
1312  std::vector<int> expectedReturningToGreen = { 7, 11, 15, 14, 13, 12 };
1313  std::vector<int> expectedCarryingGreen = { 12, 8, 4, 5 };
1314  std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };
1315 
1316  obj.setBlockPositionList(blockList);
1317 
1318  // 9に移動する
1319  auto actualMovingToGreen = obj.exploreNextOperation(8, Selector::Undefined);
1320 
1321  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1322  ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
1323  for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
1324  EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
1325  ASSERT_FALSE(obj.isEvacuatingWithNext());
1326  ASSERT_TRUE(obj.isMovingWithNext());
1327  ASSERT_FALSE(obj.isCarryingWithNext());
1328  ASSERT_FALSE(obj.isBackstepping());
1329  ASSERT_EQ(obj.getBlockPositionList()[0], 5);
1330  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1331  ASSERT_EQ(obj.getBlockPositionList()[2], 9);
1332  ASSERT_EQ(obj.getBlockPositionList()[3], 10);
1333  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1334 
1335  // 12に一時避難する
1336  auto actualEvacuatingGreen = obj.exploreNextOperation(9, Selector::Green);
1337 
1338  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1339  ASSERT_EQ(expectedEvacuatingGreen.size(), actualEvacuatingGreen.size());
1340  for(unsigned int i = 0; i < actualEvacuatingGreen.size(); i++)
1341  EXPECT_EQ(actualEvacuatingGreen[i], expectedEvacuatingGreen[i]);
1342  ASSERT_TRUE(obj.isEvacuatingWithNext());
1343  ASSERT_FALSE(obj.isMovingWithNext());
1344  ASSERT_FALSE(obj.isCarryingWithNext());
1345  ASSERT_TRUE(obj.isBackstepping());
1346  ASSERT_EQ(obj.getBlockPositionList()[0], 5);
1347  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1348  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1349  ASSERT_EQ(obj.getBlockPositionList()[3], 10);
1350  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1351 
1352  // 5に移動する
1353  auto actualMovingToYellow = obj.exploreNextOperation(13, Selector::Undefined);
1354 
1355  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1356  ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
1357  for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
1358  EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
1359  ASSERT_FALSE(obj.isEvacuatingWithNext());
1360  ASSERT_TRUE(obj.isMovingWithNext());
1361  ASSERT_FALSE(obj.isCarryingWithNext());
1362  ASSERT_FALSE(obj.isBackstepping());
1363  ASSERT_EQ(obj.getBlockPositionList()[0], 5);
1364  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1365  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1366  ASSERT_EQ(obj.getBlockPositionList()[3], 10);
1367  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1368 
1369  // 9に運搬する
1370  auto actualCarryingYellow = obj.exploreNextOperation(5, Selector::Yellow);
1371 
1372  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1373  ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
1374  for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
1375  EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
1376  ASSERT_FALSE(obj.isEvacuatingWithNext());
1377  ASSERT_FALSE(obj.isMovingWithNext());
1378  ASSERT_TRUE(obj.isCarryingWithNext());
1379  ASSERT_TRUE(obj.isBackstepping());
1380  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1381  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1382  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1383  ASSERT_EQ(obj.getBlockPositionList()[3], 10);
1384  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1385 
1386  // 6に移動する
1387  auto actualMovingToBlue = obj.exploreNextOperation(5, Selector::Undefined);
1388 
1389  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1390  ASSERT_EQ(expectedMovingToBlue.size(), actualMovingToBlue.size());
1391  for(unsigned int i = 0; i < actualMovingToBlue.size(); i++)
1392  EXPECT_EQ(actualMovingToBlue[i], expectedMovingToBlue[i]);
1393  ASSERT_FALSE(obj.isEvacuatingWithNext());
1394  ASSERT_TRUE(obj.isMovingWithNext());
1395  ASSERT_FALSE(obj.isCarryingWithNext());
1396  ASSERT_FALSE(obj.isBackstepping());
1397  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1398  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1399  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1400  ASSERT_EQ(obj.getBlockPositionList()[3], 10);
1401  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1402 
1403  // 10に移動する
1404  auto actualMovingToRed = obj.exploreNextOperation(6, Selector::Blue);
1405 
1406  ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
1407  ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
1408  for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
1409  EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
1410  ASSERT_FALSE(obj.isEvacuatingWithNext());
1411  ASSERT_TRUE(obj.isMovingWithNext());
1412  ASSERT_FALSE(obj.isCarryingWithNext());
1413  ASSERT_FALSE(obj.isBackstepping());
1414  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1415  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1416  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1417  ASSERT_EQ(obj.getBlockPositionList()[3], 10);
1418  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1419 
1420  // 15に一時避難する
1421  auto actualEvacuatingRed = obj.exploreNextOperation(10, Selector::Red);
1422 
1423  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1424  ASSERT_EQ(expectedEvacuatingRed.size(), actualEvacuatingRed.size());
1425  for(unsigned int i = 0; i < actualEvacuatingRed.size(); i++)
1426  EXPECT_EQ(actualEvacuatingRed[i], expectedEvacuatingRed[i]);
1427  ASSERT_TRUE(obj.isEvacuatingWithNext());
1428  ASSERT_FALSE(obj.isMovingWithNext());
1429  ASSERT_FALSE(obj.isCarryingWithNext());
1430  ASSERT_TRUE(obj.isBackstepping());
1431  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1432  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1433  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1434  ASSERT_EQ(obj.getBlockPositionList()[3], 15);
1435  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1436 
1437  // 6に戻る
1438  auto actualReturningToBlue = obj.exploreNextOperation(14, Selector::Undefined);
1439 
1440  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1441  ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
1442  for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
1443  EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
1444  ASSERT_FALSE(obj.isEvacuatingWithNext());
1445  ASSERT_TRUE(obj.isMovingWithNext());
1446  ASSERT_FALSE(obj.isCarryingWithNext());
1447  ASSERT_FALSE(obj.isBackstepping());
1448  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1449  ASSERT_EQ(obj.getBlockPositionList()[1], 6);
1450  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1451  ASSERT_EQ(obj.getBlockPositionList()[3], 15);
1452  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1453 
1454  // 10に運搬する
1455  auto actualCarryingBlue = obj.exploreNextOperation(6, Selector::Blue);
1456 
1457  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1458  ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
1459  for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
1460  EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
1461  ASSERT_FALSE(obj.isEvacuatingWithNext());
1462  ASSERT_FALSE(obj.isMovingWithNext());
1463  ASSERT_TRUE(obj.isCarryingWithNext());
1464  ASSERT_TRUE(obj.isBackstepping());
1465  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1466  ASSERT_EQ(obj.getBlockPositionList()[1], 10);
1467  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1468  ASSERT_EQ(obj.getBlockPositionList()[3], 15);
1469  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1470 
1471  // 15に戻る
1472  auto actualReturningToRed = obj.exploreNextOperation(6, Selector::Undefined);
1473 
1474  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1475  ASSERT_EQ(expectedReturningToRed.size(), actualReturningToRed.size());
1476  for(unsigned int i = 0; i < actualReturningToRed.size(); i++)
1477  EXPECT_EQ(actualReturningToRed[i], expectedReturningToRed[i]);
1478  ASSERT_FALSE(obj.isEvacuatingWithNext());
1479  ASSERT_TRUE(obj.isMovingWithNext());
1480  ASSERT_FALSE(obj.isCarryingWithNext());
1481  ASSERT_FALSE(obj.isBackstepping());
1482  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1483  ASSERT_EQ(obj.getBlockPositionList()[1], 10);
1484  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1485  ASSERT_EQ(obj.getBlockPositionList()[3], 15);
1486  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1487 
1488  // 6に運搬する
1489  auto actualCarryingRed = obj.exploreNextOperation(15, Selector::Red);
1490 
1491  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1492  ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
1493  for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
1494  EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
1495  ASSERT_FALSE(obj.isEvacuatingWithNext());
1496  ASSERT_FALSE(obj.isMovingWithNext());
1497  ASSERT_TRUE(obj.isCarryingWithNext());
1498  ASSERT_TRUE(obj.isBackstepping());
1499  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1500  ASSERT_EQ(obj.getBlockPositionList()[1], 10);
1501  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1502  ASSERT_EQ(obj.getBlockPositionList()[3], 6);
1503  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1504 
1505  // 12に戻る
1506  auto actualReturningToGreen = obj.exploreNextOperation(7, Selector::Undefined);
1507 
1508  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1509  ASSERT_EQ(expectedReturningToGreen.size(), actualReturningToGreen.size());
1510  for(unsigned int i = 0; i < actualReturningToGreen.size(); i++)
1511  EXPECT_EQ(actualReturningToGreen[i], expectedReturningToGreen[i]);
1512  ASSERT_FALSE(obj.isEvacuatingWithNext());
1513  ASSERT_TRUE(obj.isMovingWithNext());
1514  ASSERT_FALSE(obj.isCarryingWithNext());
1515  ASSERT_FALSE(obj.isBackstepping());
1516  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1517  ASSERT_EQ(obj.getBlockPositionList()[1], 10);
1518  ASSERT_EQ(obj.getBlockPositionList()[2], 12);
1519  ASSERT_EQ(obj.getBlockPositionList()[3], 6);
1520  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1521 
1522  // 5に運搬する
1523  auto actualCarryingGreen = obj.exploreNextOperation(12, Selector::Green);
1524 
1525  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1526  ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
1527  for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
1528  EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
1529  ASSERT_FALSE(obj.isEvacuatingWithNext());
1530  ASSERT_FALSE(obj.isMovingWithNext());
1531  ASSERT_TRUE(obj.isCarryingWithNext());
1532  ASSERT_TRUE(obj.isBackstepping());
1533  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1534  ASSERT_EQ(obj.getBlockPositionList()[1], 10);
1535  ASSERT_EQ(obj.getBlockPositionList()[2], 5);
1536  ASSERT_EQ(obj.getBlockPositionList()[3], 6);
1537  ASSERT_FALSE(obj.isAlreadyAllBlockMoved());
1538 
1539  // 11に移動する
1540  auto actualMovingTo11 = obj.exploreNextOperation(4, Selector::Undefined);
1541 
1542  ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
1543  ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
1544  for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
1545  EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
1546  ASSERT_FALSE(obj.isEvacuatingWithNext());
1547  ASSERT_TRUE(obj.isMovingWithNext());
1548  ASSERT_FALSE(obj.isCarryingWithNext());
1549  ASSERT_FALSE(obj.isBackstepping());
1550  ASSERT_EQ(obj.getBlockPositionList()[0], 9);
1551  ASSERT_EQ(obj.getBlockPositionList()[1], 10);
1552  ASSERT_EQ(obj.getBlockPositionList()[2], 5);
1553  ASSERT_EQ(obj.getBlockPositionList()[3], 6);
1554  ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
1555  }
1556 
1557 } // namespace etrobocon2018_test
Selector::isBackstepping
bool isBackstepping()
Definition: Selector.cpp:294
Selector::prepareSearching
void prepareSearching(std::vector< std::int8_t > list)
Definition: Selector.cpp:233
Selector::searchRoute
std::vector< int > searchRoute(std::int8_t start, std::int8_t end)
Definition: Selector.cpp:242
Selector::updateRoute
void updateRoute(std::vector< int > route)
Definition: Selector.cpp:334
Selector::getBlockPositionList
std::vector< std::int8_t > getBlockPositionList()
Definition: Selector.cpp:203
Selector::getPositionOfCenterQuadirilateral
std::int8_t getPositionOfCenterQuadirilateral(BlockColor color)
Definition: Selector.cpp:304
Selector::popEvacuatedBlockPosition
std::int8_t popEvacuatedBlockPosition()
Definition: Selector.cpp:220
Selector::isCarryingWithNext
bool isCarryingWithNext()
Definition: Selector.cpp:289
etrobocon2018_test::TEST
TEST(AIAnswerArrayTest, construct)
Definition: AIAnswerArrayTest.cpp:10
Selector::setBlockPositionList
void setBlockPositionList(std::vector< std::int8_t > list)
Definition: Selector.cpp:196
Selector::isEvacuatingWithNext
bool isEvacuatingWithNext()
Definition: Selector.cpp:279
Selector::isAlreadyMovedNode
bool isAlreadyMovedNode(std::int8_t position)
Definition: Selector.cpp:177
Selector::isMovingWithNext
bool isMovingWithNext()
Definition: Selector.cpp:284
Selector::extractRoute
std::vector< int > extractRoute()
Definition: Selector.cpp:347
Selector::pushEvacuatedBlockPosition
void pushEvacuatedBlockPosition(std::int8_t position)
Definition: Selector.cpp:214
Selector::exploreNextOperation
std::vector< int > exploreNextOperation(std::int8_t currentPosition, BlockColor color)
Definition: Selector.cpp:3
Selector::isAlreadyAllBlockMoved
bool isAlreadyAllBlockMoved()
Definition: Selector.cpp:183
Selector::isBacksteppingBeforeNextOperation
bool isBacksteppingBeforeNextOperation()
Definition: Selector.cpp:299
Selector::setNext
void setNext(NextOperationOfSearchingRouteIs next)
Definition: Selector.cpp:253
Selector.h
ブロック選択クラス
Selector::addMovedBlockPosition
void addMovedBlockPosition(std::int8_t position)
Definition: Selector.cpp:208
Selector
ブロック選択クラス
Definition: Selector.h:113
Selector::searchBlockPosition
std::int8_t searchBlockPosition(std::int8_t currentPosition)
Definition: Selector.cpp:118
構築:   doxygen 1.8.6