etrobocon2018_test 名前空間

クラス
class	BlockStrategyTest
class	DistinguisherTest
class	LeftCourseTest
class	LifterTest
class	LineTracerWalkerTest
class	NormalCourseTest
class	TEST_CLASS
class	RightCourseTest
class	test_SpeedControl
class	UserInterfaceTest

関数
	TEST (AIAnswerArrayTest, construct)
	TEST (AIAnswerArrayTest, constructSpecifiedSize)
	TEST (AIAnswerArrayTest, constructSpecifiedType)
	TEST (AIAnswerArrayTest, sizeTest)
	TEST (AIAnswerArrayTest, positionTest)
	TEST (AIAnswerArrayTest, atTest)
	TEST (AIAnswerArrayTest, atTestDouble)
	TEST (AIAnswerArrayTest, operatorTest)
	TEST (AIAnswerArrayTest, castTest)
	TEST (AIAnswerArrayTest, probsTest)
	TEST (AIAnswerArrayTest, handwritingTest)
	TEST (ColorBlockTest, createColorBlock)
	TEST (ColorBlockPlaceTest, createColorBlockPlace)
	TEST (ColorBlockPlaceTest, setColorBlock)
	TEST (ColorBlockPlaceTest, connectColorBlockPlace)
	TEST (ColorBlockPlaceTest, dynamicCreateColorBlockPlace)
	TEST (BlockSolverTest, getChangeDirection)
	TEST (BlockSolverTest, move)
	TEST (BlockSolverTest, move2)
	TEST (BlockSolverTest, runrun)
	TEST_F (BlockStrategyTest, createColorBlockPlace)
	TEST_F (BlockStrategyTest, connectColorBlockPlace)
	TEST_F (BlockStrategyTest, putColorBlockPlace)
	TEST_F (BlockStrategyTest, getDirection)
	TEST (DistanceTest, getDistanceTotalTest1)
	TEST (DistanceTest, getDistanceCurrentTest1)
	TEST (DistanceTest, getDistanceCurrentTest2)
	TEST_F (DistinguisherTest, getColorWhiteTest2)
	TEST_F (DistinguisherTest, getColorBlackTest1)
	TEST_F (DistinguisherTest, getColorBlackTest2)
	TEST (EtRobocon2018Test, CreateTest)
	TEST (ExplorerTest, getInitialValueOfBlockAreaNodeListTest)
	TEST (ExplorerTest, getValueOfBlockAreaNodeListTest)
	TEST (ExplorerTest, checkNodeHadBlockTest)
	TEST (ExplorerTest, searchRouteFrom0To1Test)
	TEST (ExplorerTest, searchRouteFrom1To0Test)
	TEST (ExplorerTest, searchRouteFrom8To9Test)
	TEST (ExplorerTest, searchRouteFrom11To10Test)
	TEST (ExplorerTest, searchRouteFrom0To2Test)
	TEST (ExplorerTest, searchRouteFrom2To0Test)
	TEST (ExplorerTest, searchShortestRouteFrom11To5Test)
	TEST (ExplorerTest, searchRouteFrom11To5Circumventing6Test)
	TEST (ExplorerTest, searchRouteFrom11To5Circumventing6And10Test)
	TEST (ExplorerTest, searchRouteFrom13To6Circumventing10Test)
	TEST (ExplorerTest, searchRouteFrom11To5Circumventing6And9And10Test)
	TEST (ExplorerTest, searchRouteInSenarioTest)
	TEST (FirstCodeTest, get0WhenNoneUpAndDownAnyDigit)
	TEST (FirstCodeTest, get10000WhenOnceUp5thDigit)
	TEST (FirstCodeTest, get1000WhenOnceUp4thDigit)
	TEST (FirstCodeTest, get100WhenOnceUp3rdDigit)
	TEST (FirstCodeTest, get10WhenOnceUp2ndDigit)
	TEST (FirstCodeTest, get1WhenOnceUp1stDigit)
	TEST (FirstCodeTest, get0When10thUp5thDigit)
	TEST (FirstCodeTest, get0WhenOnceUpAndDown1stDigita)
	TEST (FirstCodeTest, get90000WhenOnceDown5thDigit)
	TEST (FirstCodeTest, get0When10thDown5thDigit)
	TEST (FirstCodeTest, get12345WhenOnceDown5thDigit)
	TEST (FirstCodeTest, get5WhenDoNotChangeLeftAndRightAnyDigitNumber)
	TEST (FirstCodeTest, get4WhenOnceChangeRightDigitNumber)
	TEST (FirstCodeTest, get5When5thChangeRightDigitNumber)
	TEST (FirstCodeTest, get5WhenOnceChangeLeftDigitNumberAfterTwiceChangeRightDigitNumber)
	TEST (FirstCodeTest, get1WhenOnceChangeLeftDigitNumber)
	TEST (InitialPositionCodeDecoderTest, getInitialPositionCodeListTest1)
	TEST (InitialPositionCodeDecoderTest, getInitialPositionPowerBlockCodeTest1)
	TEST (InitialPositionCodeDecoderTest, returnInitialPositionCodeListByNegativeIntegerTest)
	TEST (InitialPositionCodeDecoderTest, decodePowerBlockCodeTest1)
	TEST (InitialPositionCodeDecoderTest, decodeFirstColorBlockOfCodeTest1)
	TEST (InitialPositionCodeDecoderTest, decodeSecondColorBlockOfCodeTest1)
	TEST (InitialPositionCodeDecoderTest, decodeThirdColorBlockOfCodeTest1)
	TEST (InitialPositionCodeDecoderTest, decodeFourthColorBlockOfCodeTest1)
	TEST (InitialPositionCodeDecoderTest, decodeRandomCodeTest)
	TEST_F (LeftCourseTest, runTest)
	TEST (LeftNormalCourseTest, CreateTest)
	TEST_F (LifterTest, setDefaultCountTest)
	TEST_F (LifterTest, getCurrentAngleTest1)
	TEST_F (LifterTest, getCurrentAngleTest2)
	TEST_F (LifterTest, limitPwmTest1)
	TEST_F (LifterTest, limitPwmTest2)
	TEST_F (LifterTest, limitPwmTest3)
	TEST_F (LifterTest, limitPwmTest4)
	TEST_F (LifterTest, liftUpTest1)
	TEST_F (LifterTest, liftUpTest2)
	TEST_F (LifterTest, liftDownTest1)
	TEST_F (LifterTest, liftDownTest2)
	TEST_F (LifterTest, defaultSetTest1)
	TEST_F (LifterTest, defaultSetTest2)
	TEST_F (LineTracerWalkerTest, runLineTest)
	TEST_F (LineTracerWalkerTest, setForwardTest)
	TEST (LPF, sensorTest)
	TEST (MotorAngleTest, absoluteAngleMeanTestPositive)
	TEST (MotorAngleTest, absoluteAngleMeanTestNegative)
	TEST (MotorAngleTest, absoluteAngleMeanTestZero)
	TEST (MotorAngleTest, relativeAngleMeanTestPositive)
	TEST (MotorAngleTest, relativeAngleMeanNegative)
	TEST (MotorAngleTest, relativeAngleMeanZero)
	TEST (MotorAngleTest, angularDifferenceTestPositive)
	TEST (MotorAngleTest, angularDifferenceTestNegative)
	TEST (MotorAngleTest, angularDifferenceTestZero)
	TEST (MotorAngleTest, absoluteValueOfAngleTest)
	TEST (NavigatorTest, resetTest)
	TEST (NodeTest, getInitialValueOfNodeIDTest)
	TEST (NodeTest, getInitialValueOfBlockExistsTest)
	TEST (NodeTest, getInitialValueOfPositionTest)
	TEST (NodeTest, getValueOfNodeIDTest)
	TEST (NodeTest, initializeValueOfNodeIDTest)
	TEST (NodeTest, getValueOfBlockExistsTest)
	TEST (NodeTest, getValueOfPositionTest)
	TEST (NodeTest, getValueOfNeighborListTest)
	TEST (NodeTest, getValueOf3NeighborListTest)
	TEST (NodeTest, getValueOfNeighborListOf3x3Test)
	TEST (NodeTest, getValueOfNeighborListOf4x4Test)
	TEST (NodeTest, getValueOfNeighborListOfETRobocon2018Test)
	TEST (NodeTest, getValueOfNeighborListOfETRobocon2017Test)
	TEST_F (NormalCourseTest, stopTest)
	TEST (PidTest, CalculateTest1)
	TEST (detectBarrierTest, CalculateTest2)
	TEST (PidTest, limitOutputTest1)
	TEST (PidTest, limitOutputTest2)
	TEST (PidTest, limitOutputTest3)
	TEST (RightNormalCourseTest, CreateTest)
	TEST (RightNormalCourseTest, runTest)
	TEST (SelectorTest, getBlockPositionListTest)
	TEST (SelectorTest, searchRouteByExplorerTest)
	TEST (SelectorTest, searchNode8Test)
	TEST (SelectorTest, searchNode9Test)
	TEST (SelectorTest, searchNode1Test)
	TEST (SelectorTest, searchNode10Test)
	TEST (SelectorTest, searchNode6Test)
	TEST (SelectorTest, searchNode0Test)
	TEST (SelectorTest, checkWhetherThereIsMovedBlock)
	TEST (SelectorTest, checkNextOperationIsAllFalseInInitialStageTest)
	TEST (SelectorTest, checkNextOperationIsAllFalseWithoutSetNextWhenNextIsSetTest)
	TEST (SelectorTest, checkThereAreNotNodeInInitialRouteTest)
	TEST (SelectorTest, getSomeNodeInRouteWhenRouteIsSetTest)
	TEST (SelectorTest, getNextPositionInCenterIfColorSetInNodeIDTest)
	TEST (SelectorTest, checkPushingAndPoppingByPseudoStackTest)
	TEST (SelectorTest, searchNodeInSenarioTest)
	TEST (SelectorTest, searchRouteInSenarioTest)
	TEST (SelectorTest, searchRouteWhenPathBlocked)
	TEST (SelectorTest, searchRouteWhenNextMovedPositionIsBuried)
	TEST (SelectorTest, searchRouteWhenNextOfNextOfNextMovedPositionIsBuried)
	TEST (SelectorTest, searchRouteWhenEachNextMovedPositionsIsLooped)
	TEST (SelectorTest, searchRouteWhenAllNodeInitialPositionsIsFromCenterQuadirilateralTest)
void	straight (SelfLocalization &sl, int kyori, int &l, int &r)
void	curve (SelfLocalization &sl, float sub_degree, int &l, int &r)
	TEST (SelfLocalizationTest, CalculateTest1)
	TEST (SelfLocalizationTest, calculateBetweenEv3AndBorder1)
	TEST (SelfLocalizationTest, calculateBetweenEv3AndBorder2)
	TEST (SelfLocalizationTest, calculateBetweenEv3AndBorder3)
	TEST (SelfLocalizationTest, calculateBetweenEv3AndBorder4)
	TEST (SelfLocalizationTest, calculateBetweenEv3AndBorder5)
	TEST (SelfLocalizationTest, calculateCurrentAngleTest1)
	TEST (SelfLocalizationTest, calculateCurrentAngleTest2)
	TEST (SelfLocalizationTest, calculateCurrentAngleTest3)
	TEST (SelfLocalizationTest, isOverNormalVectorTest1)
	TEST (SelfLocalizationTest, isOverNormalVectorTest2)
	TEST (SelfLocalizationTest, isOverNormalVectorTest3)
	TEST (SelfLocalizationTest, isOverNormalVectorTest4)
	TEST (SpeedControlTest, calculateSpeedForPidTest1)
	TEST (SpeedControlTest, calculateSpeedForPidTest2)
	TEST (SpeedControlTest, calcDistance4msTest1)
	TEST (TurnControlTest, CreateTest)
	TEST_F (UserInterfaceTest, setBrightnessWithColorTest)
	TEST_F (UserInterfaceTest, setBrightnessTest)
	TEST (WalkerTest, CreateTest)
	TEST (CoordinateTest, updateTest)
	TEST (CoordinateTest, updateTest2)
	TEST (CoordinateTest, resetTest)
	TEST (WheelOdometryTest, velocityTest)
	TEST (WheelOdometryTest, velocityTestHuge)
	TEST (WheelOdometryTest, angularVelocityTest)
	TEST (WheelOdometryTest, resetTest)
	TEST (WheelOdometryTest, updateTest)
	TEST (WheelOdometryTest, updateCoordinateTest)
	TEST (WheelOdometryTest, getRotationAngleTest)
	TEST (WheelOdometryTest, getCoordinateTest)
	TEST (WheelOdometryTest, getPointXTest)
	TEST (WheelOdometryTest, getPointYTest)

詳解

SelfLocalizationTest.cpp

DistinguisherTest.cpp

ExplorerTest.cpp

FirstCodeTest.cpp

InitialPositionCodeDecoderTest.cpp

LifterTest.cpp

NodeTest.cpp

PidTest.cpp

SelectorTest.cpp

SpeedControlTest.cpp

関数詳解

void etrobocon2018_test::curve	(	SelfLocalization &	sl,
		float	sub_degree,
		int &	l,
		int &	r
	)

SelfLocalizationTest.cpp の 24 行目に定義があります。

  {
    int angle_one = -3;
    if(sub_degree < 0) angle_one = 3;
    sub_degree = sub_degree / 90;
    for(int i = 0; i < 120 * std::abs(sub_degree); i++) {
      l += angle_one;
      sl.update(l, r);
    }
  }

呼び出し関係図:

被呼び出し関係図:

void etrobocon2018_test::straight	(	SelfLocalization &	sl,
		int	kyori,
		int &	l,
		int &	r
	)

SelfLocalizationTest.cpp の 15 行目に定義があります。

  {
    for(int i = 0; i < kyori; i++) {
      l += 10;
      r += 10;
      sl.update(l, r);
    }
  }

呼び出し関係図:

被呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		absoluteAngleMeanTestPositive
	)

MotorAngleTest.cpp の 8 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = 10;
    std::int32_t right = 20;

    float mean = (left + right) / 2.0f;
    ASSERT_FLOAT_EQ(mean, angle.absoluteAngleMean(left, right));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	CoordinateTest	,
		updateTest
	)

WheelOdometryTest.cpp の 9 行目に定義があります。

  {
    Coordinate coordinate;
    coordinate.update(10.0f, 5.0f);
    ASSERT_FLOAT_EQ(5.0f / 2.0f, coordinate.arg);
    ASSERT_FLOAT_EQ(10.0f, coordinate.radius);
    ASSERT_FLOAT_EQ(10.0f * std::cos(5.0f / 2.0f), coordinate.x);
    ASSERT_FLOAT_EQ(10.0f * std::sin(5.0f / 2.0f), coordinate.y);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NavigatorTest	,
		resetTest
	)

NavigatorTest.cpp の 9 行目に定義があります。

  {
    Navigator navigator;
    navigator.move(10);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		construct
	)

AIAnswerArrayTest.cpp の 10 行目に定義があります。

  {
    AI_Answer::array<int> array;
  }

etrobocon2018_test::TEST	(	ExplorerTest	,
		getInitialValueOfBlockAreaNodeListTest
	)

ExplorerTest.cpp の 11 行目に定義があります。

  {
    Explorer obj;

    auto actual = obj.getBlockAreaNodeList();

    ASSERT_EQ(nullptr, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	LPF	,
		sensorTest
	)

LPFTest.cpp の 11 行目に定義があります。

  {
    LPF filter;
    std::int32_t sensor = 24;  // This is 適当

    // 前回のセンサ値がない場合は、入力値をそのまま返す
    ASSERT_EQ(static_cast<float>(sensor), filter.sensor(sensor));

    // フィルタ処理
<<<<<<< HEAD
    std::int32_t current_sensor = 77;  // This is 適当
    float expected = 0.9 * sensor + 0.1 * current_sensor;
=======
    std::uint8_t current_sensor = 77;  // This is 適当
    std::uint8_t expected = 0.9 * sensor + 0.1 * current_sensor;
>>>>>>> 751b48e58956ffd3ea049220ab92d433957e4fe9
    ASSERT_EQ(expected, filter.sensor(current_sensor));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getInitialValueOfNodeIDTest
	)

NodeTest.cpp の 11 行目に定義があります。

  {
    Node obj;
    std::int8_t expected = 0;

    auto actual = obj.getNodeID();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		getBlockPositionListTest
	)

SelectorTest.cpp の 11 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> expected{ { 0, 1, 2, 3 } };

    obj.setBlockPositionList(expected);
    auto actual = obj.getBlockPositionList();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		constructSpecifiedSize
	)

AIAnswerArrayTest.cpp の 15 行目に定義があります。

  {
    AI_Answer::array<int, 2> array;
  }

etrobocon2018_test::TEST	(	LeftNormalCourseTest	,
		CreateTest
	)

LeftNormalCourseTest.cpp の 15 行目に定義があります。

{ LeftNormalCourse lnc; }

etrobocon2018_test::TEST	(	TurnControlTest	,
		CreateTest
	)

TurnControlTest.cpp の 15 行目に定義があります。

{ TurnControl tc; }

etrobocon2018_test::TEST	(	WalkerTest	,
		CreateTest
	)

WalkerTest.cpp の 15 行目に定義があります。

{ Walker walker; }

etrobocon2018_test::TEST	(	DistanceTest	,
		getDistanceTotalTest1
	)

DistanceTest.cpp の 15 行目に定義があります。

  {
    Distance ds;
    int l, r;

    l = 10;
    r = 20;

    ASSERT_EQ(ds.getDistanceTotal(l, r), (l + r) / 2);
  }

etrobocon2018_test::TEST	(	EtRobocon2018Test	,
		CreateTest
	)

EtRobocon2018Test.cpp の 15 行目に定義があります。

  {
    EtRobocon2018 et;
    //  et.start(1);
  }

etrobocon2018_test::TEST	(	RightNormalCourseTest	,
		CreateTest
	)

RightNormalCourseTest.cpp の 15 行目に定義があります。

{ RightNormalCourse rnc; }

etrobocon2018_test::TEST	(	SpeedControlTest	,
		calculateSpeedForPidTest1
	)

SpeedControlTest.cpp の 16 行目に定義があります。

  {
    SpeedControl sp;
    int value;

    sp.setPid(2.0, 4.8, 0.024, 150.0);
    value = sp.calculateSpeedForPid(0, 0);

    ASSERT_LE(value, 100);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get0WhenNoneUpAndDownAnyDigit
	)

FirstCodeTest.cpp の 16 行目に定義があります。

  {
    FirstCode obj;

    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ColorBlockTest	,
		createColorBlock
	)

BlockAreaTest.cpp の 17 行目に定義があります。

  {
    ColorBlock block{};
    block.color = GameColor::RED;

    ASSERT_EQ(block.color, GameColor::RED);
  }

etrobocon2018_test::TEST	(	RightNormalCourseTest	,
		runTest
	)

RightNormalCourseTest.cpp の 17 行目に定義があります。

  {
    RightNormalCourse rnc;
    for(int i = 0; i < 13000; i++) {
      rnc.statusCheck(i, i);
      rnc.runNormalCourse(30, 30, 30, 30);
    }
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		getInitialPositionCodeListTest1
	)

InitialPositionCodeDecoderTest.cpp の 17 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::vector<std::int8_t> expected = {0, 0, 0, 0};

    auto actual = obj.getInitialPositionCodeList();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		absoluteAngleMeanTestNegative
	)

MotorAngleTest.cpp の 18 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = -10;
    std::int32_t right = 30;

    float mean = (left + right) / 2.0f;
    ASSERT_FLOAT_EQ(mean, angle.absoluteAngleMean(left, right));

    left = 20;
    right = -50;
    mean = (left + right) / 2.0f;
    ASSERT_FLOAT_EQ(mean, angle.absoluteAngleMean(left, right));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	CoordinateTest	,
		updateTest2
	)

WheelOdometryTest.cpp の 19 行目に定義があります。

  {
    Coordinate coordinate;
    coordinate.update(10.0f, 5.0f);
    float radius = 10.0f + 5.0f;
    float arg = 5.0f / 2.0f + 10.0f / 2.0f;
    float x = 10.0f * std::cos(5.0f / 2.0f);
    float y = 10.0f * std::sin(5.0f / 2.0f);
    ASSERT_FLOAT_EQ(x, coordinate.x);
    ASSERT_FLOAT_EQ(y, coordinate.y);

    coordinate.update(5.0f, 10.0f);
    ASSERT_FLOAT_EQ(arg, coordinate.arg);
    ASSERT_FLOAT_EQ(radius, coordinate.radius);
    ASSERT_FLOAT_EQ(5.0f * std::cos(arg) + x, coordinate.x);
    ASSERT_FLOAT_EQ(5.0f * std::sin(arg) + y, coordinate.y);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		constructSpecifiedType
	)

AIAnswerArrayTest.cpp の 20 行目に定義があります。

  {
    AI_Answer::array<double, 2> array;
    AI_Answer::array<AI_Answer::array<int, 2>> arrayarray;
  }

etrobocon2018_test::TEST	(	ExplorerTest	,
		getValueOfBlockAreaNodeListTest
	)

ExplorerTest.cpp の 21 行目に定義があります。

  {
    Explorer obj;
    std::vector<Node> expectedList
        = { Node{},     Node{ 1 },  Node{ 2 },  Node{ 3 }, Node{ 4 },  Node{ 5 },
            Node{ 6 },  Node{ 7 },  Node{ 8 },  Node{ 9 }, Node{ 10 }, Node{ 11 },
            Node{ 12 }, Node{ 13 }, Node{ 14 }, Node{ 15 } };
    std::vector<std::vector<int>> expectedPositionList = { { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 0 },

                                                           { 0, 1 }, { 1, 1 }, { 2, 1 }, { 3, 1 },

                                                           { 0, 2 }, { 1, 2 }, { 2, 2 }, { 3, 2 },

                                                           { 0, 3 }, { 1, 3 }, { 2, 3 }, { 3, 3 } };

    obj.createBlockArea();
    auto actual = obj.getBlockAreaNodeList();

    ASSERT_EQ(expectedList.size(), actual->size());

    for(unsigned int i = 0; i < expectedList.size(); i++) {
      ASSERT_EQ(expectedList[i].getNodeID(), actual->at(i)->getNodeID());
      ASSERT_EQ(expectedPositionList[i][0], actual->at(i)->getPositionX());
      ASSERT_EQ(expectedPositionList[i][1], actual->at(i)->getPositionY());
    }
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getInitialValueOfBlockExistsTest
	)

NodeTest.cpp の 22 行目に定義があります。

  {
    Node obj;

    auto actual = obj.hasBlock();

    ASSERT_FALSE(actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteByExplorerTest
	)

SelectorTest.cpp の 23 行目に定義があります。

  {
    Selector obj;
    std::vector<int> expected{ { 11, 7, 3, 2, 1, 5 } };
    std::vector<std::int8_t> nodeHadBlockList{{6, 9, 10}};


    obj.prepareSearching(nodeHadBlockList);
    auto actual = obj.searchRoute(11, 5);

    for(unsigned int i = 0; i < actual.size(); i++) {
      EXPECT_EQ(actual[i], expected[i]);
    }

    ASSERT_EQ(expected.size(), actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	PidTest	,
		CalculateTest1
	)

PidTest.cpp の 24 行目に定義があります。

  {
    TEST_CLASS pid;

    // コンストラクタの引数targetに30を入れる
    pid.setPid(0.5, 0.5, 0.5, 30.0);
    // calculateにtarget以下の値を入力する
    pid.calculate(20.0);
    // アウトプットは負の数になる
    ASSERT_LT(pid.get_output(), 0.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ColorBlockPlaceTest	,
		createColorBlockPlace
	)

BlockAreaTest.cpp の 25 行目に定義があります。

  {
    ColorBlockPlace blockPlace00(GameColor::RED, 0);
    ASSERT_EQ(blockPlace00.getPlaceCord(), 0);
    ASSERT_EQ(blockPlace00.getColor(), GameColor::RED);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		sizeTest
	)

AIAnswerArrayTest.cpp の 26 行目に定義があります。

  {
    AI_Answer::array<int> array;
    ASSERT_EQ(6, array.size());

    AI_Answer::array<int, 1> list;
    ASSERT_EQ(1, list.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get10000WhenOnceUp5thDigit
	)

FirstCodeTest.cpp の 26 行目に定義があります。

  {
    FirstCode obj;

    obj.upDigit(5);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 10000);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	DistanceTest	,
		getDistanceCurrentTest1
	)

DistanceTest.cpp の 26 行目に定義があります。

  {
    Distance ds;
    int l, r, step_l, step_r;

    l = 10;
    r = 20;
    ds.getDistanceTotal(l, r);
    ds.resetDistance(l, r);
    step_l = 20;
    step_r = 10;

    ASSERT_EQ(ds.getDistanceCurrent(l + step_l, r + step_r), (step_l + step_r) / 2);
  }

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		getInitialPositionPowerBlockCodeTest1
	)

InitialPositionCodeDecoderTest.cpp の 28 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    int8_t expected = 0;

    auto actual = obj.getInitialPositionPowerBlockCode();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SpeedControlTest	,
		calculateSpeedForPidTest2
	)

SpeedControlTest.cpp の 28 行目に定義があります。

  {
    SpeedControl sp;
    int value, r, l;
    r = l = 0;
    sp.setPid(2.0, 4.8, 0.024, 150.0);
    for(int i = 0; i < 25; i++) {
      if(i == 24) {
        r = l += 10000;
      }
      value = sp.calculateSpeedForPid(r, l);
      l = r += i * 10;
    }

    ASSERT_GE(value, -100);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	BlockSolverTest	,
		getChangeDirection
	)

BlockSolverTest.cpp の 31 行目に定義があります。

  {
    Controller controller;
    Walker walker{ controller };
    BlockSolver blockSolver{ controller, walker, 01233, 40 };
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
    blockSolver.nowDirection = blockSolver.getChangeDirection(1);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 3);
    blockSolver.nowDirection = blockSolver.getChangeDirection(1);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 0);
    blockSolver.nowDirection = blockSolver.getChangeDirection(-1);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 3);
    blockSolver.nowDirection = blockSolver.getChangeDirection(-1);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
    blockSolver.nowDirection = blockSolver.getChangeDirection(-1);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 1);
    blockSolver.nowDirection = blockSolver.getChangeDirection(2);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 3);
  }

etrobocon2018_test::TEST	(	NodeTest	,
		getInitialValueOfPositionTest
	)

NodeTest.cpp の 32 行目に定義があります。

  {
    Node obj;
    std::int8_t expectedX = 0;
    std::int8_t expectedY = 0;

    auto actualX = obj.getPositionX();
    auto actualY = obj.getPositionY();

    ASSERT_EQ(expectedX, actualX);
    ASSERT_EQ(expectedY, actualY);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ColorBlockPlaceTest	,
		setColorBlock
	)

BlockAreaTest.cpp の 32 行目に定義があります。

  {
    std::shared_ptr<ColorBlock> colorBlock0 = std::make_shared<ColorBlock>();
    ColorBlockPlace blockPlace00(GameColor::RED, 0);
    blockPlace00.block = colorBlock0;
    ASSERT_EQ(blockPlace00.block->color, GameColor::UNKNOWN);
    blockPlace00.block->color = GameColor::BLUE;
    ASSERT_EQ(blockPlace00.block->color, GameColor::BLUE);
  }

etrobocon2018_test::TEST	(	MotorAngleTest	,
		absoluteAngleMeanTestZero
	)

MotorAngleTest.cpp の 33 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = 0;
    std::int32_t right = 0;

    float mean = (left + right) / 2.0f;
    ASSERT_FLOAT_EQ(mean, angle.absoluteAngleMean(left, right));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		CalculateTest1
	)

SelfLocalizationTest.cpp の 35 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);

    sl.update(100, 200);

    ASSERT_GE(sl.getPointX(), 10.0);
    ASSERT_GE(sl.getPointY(), 2.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		positionTest
	)

AIAnswerArrayTest.cpp の 35 行目に定義があります。

  {
    AI_Answer::array<int> array;
    ASSERT_EQ(0, array.position());

    array.push_back(1);
    ASSERT_EQ(1, array.position());

    array.push_back(20);
    ASSERT_EQ(2, array.position());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	CoordinateTest	,
		resetTest
	)

WheelOdometryTest.cpp の 37 行目に定義があります。

  {
    Coordinate coordinate;
    coordinate.update(10.0, 5.0);
    coordinate.reset();
    ASSERT_FLOAT_EQ(0.0, coordinate.arg);
    ASSERT_FLOAT_EQ(0.0, coordinate.radius);
    ASSERT_FLOAT_EQ(0.0, coordinate.x);
    ASSERT_FLOAT_EQ(0.0, coordinate.y);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get1000WhenOnceUp4thDigit
	)

FirstCodeTest.cpp の 37 行目に定義があります。

  {
    FirstCode obj;

    obj.upDigit(4);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 1000);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	detectBarrierTest	,
		CalculateTest2
	)

PidTest.cpp の 37 行目に定義があります。

  {
    TEST_CLASS pid;

    // コンストラクタの引数targetに30を入れる
    pid.setPid(0.5, 0.5, 0.5, 30.0);
    // calculateにtarget以下の値を入力する
    pid.calculate(50.0);
    // アウトプットは正の数になる
    ASSERT_GT(pid.get_output(), 0.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		returnInitialPositionCodeListByNegativeIntegerTest
	)

InitialPositionCodeDecoderTest.cpp の 39 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::vector<std::int8_t> expected = {0, 0, 0, 0};

    obj.decode(-1);
    auto actual = obj.getInitialPositionCodeList();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	DistanceTest	,
		getDistanceCurrentTest2
	)

DistanceTest.cpp の 41 行目に定義があります。

  {
    Distance ds;
    int l, r;

    l = 100;
    r = 200;
    ds.getDistanceTotal(l, r);
    ds.resetDistance(l, r);

    ASSERT_EQ(ds.getDistanceTotal(l, r), (l + r) / 2);
  }

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNode8Test
	)

SelectorTest.cpp の 41 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 0, 1, 2, 8 } };
    std::int8_t expected = 8;

    obj.setBlockPositionList(blockList);
    auto actual = obj.searchBlockPosition(8);

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ColorBlockPlaceTest	,
		connectColorBlockPlace
	)

BlockAreaTest.cpp の 42 行目に定義があります。

  {
    std::shared_ptr<ColorBlockPlace> blockPlace00
        = std::make_shared<ColorBlockPlace>(GameColor::RED, 0);
    std::shared_ptr<ColorBlockPlace> blockPlace01
        = std::make_shared<ColorBlockPlace>(GameColor::YELLOW, 1);

    blockPlace00->black_line[Direction::NORTH] = blockPlace01;
    blockPlace01->black_line[Direction::SOUTH] = blockPlace00;
    ASSERT_EQ(blockPlace00->black_line[Direction::NORTH]->getColor(), GameColor::YELLOW);
    ASSERT_EQ(blockPlace01->black_line[Direction::SOUTH]->getColor(), GameColor::RED);
  }

etrobocon2018_test::TEST	(	MotorAngleTest	,
		relativeAngleMeanTestPositive
	)

MotorAngleTest.cpp の 43 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = 10;
    std::int32_t right = 10;
    float mean = (left + right) / 2.0f;

    ASSERT_FLOAT_EQ(mean, angle.relativeAngleMean(left, right));

    std::int32_t left2 = 20;
    std::int32_t right2 = 30;
    float mean2 = ((left2 - left) + (right2 - right)) / 2.0f;

    ASSERT_FLOAT_EQ(mean2, angle.relativeAngleMean(left2, right2));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateBetweenEv3AndBorder1
	)

SelfLocalizationTest.cpp の 45 行目に定義があります。

  {
    SelfLocalization sl(0, 0, true);
    float distance = sl.calculate_between_ev3_and_border(0.0, 0.0, 10.0, 10.0, 0.0, 0.0);
    ASSERT_FLOAT_EQ(distance, 0.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfNodeIDTest
	)

NodeTest.cpp の 46 行目に定義があります。

  {
    Node obj;
    std::int8_t expected = 10;

    obj.setNodeID(10);
    auto actual = obj.getNodeID();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		atTest
	)

AIAnswerArrayTest.cpp の 47 行目に定義があります。

  {
    AI_Answer::array<int> array;
    ASSERT_EQ(0, array.at(0));

    array.push_back(100);
    ASSERT_EQ(100, array.at(0));

    array.push_back(200);
    ASSERT_EQ(200, array.at(1));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		checkNodeHadBlockTest
	)

ExplorerTest.cpp の 48 行目に定義があります。

  {
    Explorer obj;
    obj.createBlockArea();

    bool actual = obj.hasBlock(0);
    ASSERT_FALSE(actual);

    obj.setHasBlockIn(0);
    actual = obj.hasBlock(0);
    ASSERT_TRUE(actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		velocityTest
	)

WheelOdometryTest.cpp の 48 行目に定義があります。

  {
    MotorAngle motor_angle;
    float transform = 3.14f * 99.0f / 2.0f / 180.0f / 0.04f;
    float angle = motor_angle.relativeAngleMean(5, 5);

    WheelOdometry odometry;
    ASSERT_FLOAT_EQ(transform * angle, odometry.velocity(5, 5));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get100WhenOnceUp3rdDigit
	)

FirstCodeTest.cpp の 48 行目に定義があります。

  {
    FirstCode obj;

    obj.upDigit(3);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 100);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	PidTest	,
		limitOutputTest1
	)

PidTest.cpp の 50 行目に定義があります。

  {
    TEST_CLASS pid;

    // コンストラクタの引数targetに30を入れる
    pid.setPid(0.5, 0.5, 0.5, 30.0);
    // calculateにtarget以上の値を入力する
    pid.calculate(300.0);
    // アウトプットは100.0になる
    double output = pid.limitOutput(pid.get_output());
    ASSERT_GE(output, 100.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		decodePowerBlockCodeTest1
	)

InitialPositionCodeDecoderTest.cpp の 51 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::int32_t codeList = 1;
    int8_t expected = 1;

    obj.decode(codeList);
    auto actual = obj.getInitialPositionPowerBlockCode();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	BlockSolverTest	,
		move
	)

BlockSolverTest.cpp の 51 行目に定義があります。

  {
    Controller controller;
    Walker walker{ controller };
    BlockSolver blockSolver{ controller, walker, 01233, 40 };
    blockSolver.moveDirection(9);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
    blockSolver.moveDirection(10);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
    blockSolver.moveDirection(6);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 1);
    blockSolver.moveDirection(5);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 0);
    blockSolver.moveDirection(6);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
  }

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateBetweenEv3AndBorder2
	)

SelfLocalizationTest.cpp の 52 行目に定義があります。

  {
    SelfLocalization sl(0, 0, true);
    float distance = sl.calculate_between_ev3_and_border(-50.0, 80.0, 127.0, 91.0, -85.0, 70.0);
    ASSERT_NEAR(distance, 7.809, 0.001);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNode9Test
	)

SelectorTest.cpp の 54 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 0, 1, 2, 9 } };
    std::int8_t expected = 9;

    obj.setBlockPositionList(blockList);
    auto actual = obj.searchBlockPosition(8);

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ColorBlockPlaceTest	,
		dynamicCreateColorBlockPlace
	)

BlockAreaTest.cpp の 55 行目に定義があります。

  {
    std::array<GameColor, 16> colorArray{ GameColor::RED,    GameColor::YELLOW, GameColor::BLUE,
                                          GameColor::GREEN,  GameColor::BLUE,   GameColor::GREEN,
                                          GameColor::RED,    GameColor::YELLOW, GameColor::RED,
                                          GameColor::YELLOW, GameColor::BLUE,   GameColor::GREEN,
                                          GameColor::BLUE,   GameColor::GREEN,  GameColor::RED,
                                          GameColor::YELLOW };

    std::array<std::shared_ptr<ColorBlockPlace>, 16> colorBlockPlaceArray;
    for(std::int8_t i = 0; i < 16; i++) {
      std::shared_ptr<ColorBlockPlace> blockPlace
          = std::make_shared<ColorBlockPlace>(colorArray[i], i);
      colorBlockPlaceArray[i] = blockPlace;
    }
  }

etrobocon2018_test::TEST	(	SpeedControlTest	,
		calcDistance4msTest1
	)

SpeedControlTest.cpp の 56 行目に定義があります。

  {
    test_SpeedControl sp;
    int value;
    float circle;

    circle = 2 * 3.14 * 81;
    value = sp.calcDistance4ms(0, 0);
    value += sp.calcDistance4ms(90, 90);
    value += sp.calcDistance4ms(180, 180);
    value += sp.calcDistance4ms(270, 270);
    value += sp.calcDistance4ms(360, 360);

    ASSERT_EQ(value, (int)circle);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		velocityTestHuge
	)

WheelOdometryTest.cpp の 58 行目に定義があります。

  {
    MotorAngle motor_angle;
    float transform = 3.14f * 99.0f / 2.0f / 180.0f / 0.04f;
    float angle = motor_angle.relativeAngleMean(140, 140);

    WheelOdometry odometry;
    ASSERT_FLOAT_EQ(transform * angle, odometry.velocity(140, 140));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		initializeValueOfNodeIDTest
	)

NodeTest.cpp の 58 行目に定義があります。

  {
    std::int8_t expected = 9;

    Node obj(9);
    auto actual = obj.getNodeID();

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateBetweenEv3AndBorder3
	)

SelfLocalizationTest.cpp の 59 行目に定義があります。

  {
    SelfLocalization sl(0, 0, true);
    float distance = sl.calculate_between_ev3_and_border(2.0, 1.0, 6.0, 7.0, 3.0, 4.0);
    ASSERT_NEAR(distance, -0.83205, 0.001);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		relativeAngleMeanNegative
	)

MotorAngleTest.cpp の 59 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = -10;
    std::int32_t right = -20;
    float mean = (left + right) / 2.0f;
    ASSERT_FLOAT_EQ(mean, angle.relativeAngleMean(left, right));

    std::int32_t left2 = -20;
    std::int32_t right2 = -30;
    float mean2 = ((left2 - left) + (right2 - right)) / 2.0f;

    ASSERT_FLOAT_EQ(mean2, angle.relativeAngleMean(left2, right2));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get10WhenOnceUp2ndDigit
	)

FirstCodeTest.cpp の 59 行目に定義があります。

  {
    FirstCode obj;

    obj.upDigit(2);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 10);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		atTestDouble
	)

AIAnswerArrayTest.cpp の 59 行目に定義があります。

  {
    AI_Answer::array<double> array;
    ASSERT_DOUBLE_EQ(0.0, array.at(0));

    array.push_back(1.2);
    ASSERT_DOUBLE_EQ(1.2, array.at(0));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom0To1Test
	)

ExplorerTest.cpp の 62 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 2;
    std::vector<int> expectedList = { 0, 1 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(0, 1);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		decodeFirstColorBlockOfCodeTest1
	)

InitialPositionCodeDecoderTest.cpp の 64 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::int32_t codeList = 65538;
    std::vector<std::int8_t> expected = {1, 0, 0, 0};

    obj.decode(codeList);
    auto actual = obj.getInitialPositionCodeList();

    ASSERT_EQ(expected.at(0), actual.at(0));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	PidTest	,
		limitOutputTest2
	)

PidTest.cpp の 64 行目に定義があります。

  {
    TEST_CLASS pid;

    // コンストラクタの引数targetに300を入れる
    pid.setPid(0.5, 0.5, 0.5, 300.0);
    // calculateにtarget以下の値を入力する
    pid.calculate(30.0);
    // アウトプットは-100.0になる
    double output = pid.limitOutput(pid.get_output());
    ASSERT_GE(output, -100.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateBetweenEv3AndBorder4
	)

SelfLocalizationTest.cpp の 66 行目に定義があります。

  {
    SelfLocalization sl(0, 0, true);
    float distance = sl.calculate_between_ev3_and_border(0.0, 0.0, 10.0, 0.0, 3.0, 0.0);
    ASSERT_NEAR(distance, 0.0, 0.001);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	BlockSolverTest	,
		move2
	)

BlockSolverTest.cpp の 67 行目に定義があります。

  {
    Controller controller;
    Walker walker{ controller };
    BlockSolver blockSolver{ controller, walker, 01233, 40 };
    blockSolver.moveDirection(9);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
    blockSolver.moveDirection(8);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 0);
    blockSolver.moveDirection(4);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 1);
    blockSolver.moveDirection(5);
    ASSERT_EQ(static_cast<int>(blockSolver.nowDirection), 2);
  }

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNode1Test
	)

SelectorTest.cpp の 67 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 1, 2, 3, 7 } };
    std::int8_t expected = 1;

    obj.setBlockPositionList(blockList);
    auto actual = obj.searchBlockPosition(8);

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		operatorTest
	)

AIAnswerArrayTest.cpp の 68 行目に定義があります。

  {
    AI_Answer::array<int> array;
    ASSERT_EQ(0, array[0]);

    array.push_back(100);
    ASSERT_EQ(100, array[0]);

    array.push_back(200);
    ASSERT_EQ(200, array[1]);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfBlockExistsTest
	)

NodeTest.cpp の 69 行目に定義があります。

  {
    Node obj;

    obj.setHasBlock(true);
    auto actual = obj.hasBlock();

    ASSERT_TRUE(actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		angularVelocityTest
	)

WheelOdometryTest.cpp の 69 行目に定義があります。

  {
    MotorAngle motor_angle;
    float transform = 99.0f / 2.0f / 147.5f / 0.04f;
    float angle = motor_angle.angularDifference(2, 5);

    WheelOdometry odometry;
    ASSERT_FLOAT_EQ(transform * angle, odometry.angularVelocity(2, 5));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get1WhenOnceUp1stDigit
	)

FirstCodeTest.cpp の 70 行目に定義があります。

  {
    FirstCode obj;

    obj.upDigit(1);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 1);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateBetweenEv3AndBorder5
	)

SelfLocalizationTest.cpp の 73 行目に定義があります。

  {
    SelfLocalization sl(0, 0, true);
    float distance = sl.calculate_between_ev3_and_border(0.0, 0.0, 0.0, 10.0, 0.0, 3.0);
    ASSERT_NEAR(distance, 0.0, 0.001);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		relativeAngleMeanZero
	)

MotorAngleTest.cpp の 74 行目に定義があります。

  {
    MotorAngle angle;
    ASSERT_FLOAT_EQ(0.0f, angle.relativeAngleMean(0, 0));
    ASSERT_FLOAT_EQ(0.0f, angle.relativeAngleMean(0, 0));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		decodeSecondColorBlockOfCodeTest1
	)

InitialPositionCodeDecoderTest.cpp の 77 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::int32_t codeList = 135171;
    std::vector<std::int8_t> expected = {2, 1, 0, 0};

    obj.decode(codeList);
    auto actual = obj.getInitialPositionCodeList();

    ASSERT_EQ(expected.at(1), actual.at(1));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	PidTest	,
		limitOutputTest3
	)

PidTest.cpp の 78 行目に定義があります。

  {
    TEST_CLASS pid;

    // コンストラクタの引数targetに30を入れる
    pid.setPid(0.5, 0.5, 0.5, 30.0);
    // calculateにtarget以下の値を入力する
    pid.calculate(30.0);
    // アウトプットは0になる
    double output = pid.limitOutput(pid.get_output());
    ASSERT_DOUBLE_EQ(output, 0.0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom1To0Test
	)

ExplorerTest.cpp の 79 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 2;
    std::vector<int> expectedList = { 1, 0 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(1, 0);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		resetTest
	)

WheelOdometryTest.cpp の 79 行目に定義があります。

  {
    WheelOdometry odometry;
    odometry.update(10.0f, 5.0f);
    const Coordinate& coordinate = odometry.reset();
    ASSERT_FLOAT_EQ(0.0f, coordinate.radius);
    ASSERT_FLOAT_EQ(0.0f, coordinate.arg);
    ASSERT_FLOAT_EQ(0.0f, coordinate.x);
    ASSERT_FLOAT_EQ(0.0f, coordinate.y);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		castTest
	)

AIAnswerArrayTest.cpp の 80 行目に定義があります。

  {
    AI_Answer::array<int> array;
    ASSERT_EQ(0, array.cast(0));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateCurrentAngleTest1
	)

SelfLocalizationTest.cpp の 80 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    int l, r;
    l = r = 0;

    straight(sl, 20, l, r);
    curve(sl, 45, l, r);

    sl.calculate_current_angle();

    ASSERT_EQ(sl.current_angle_degree, 69);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfPositionTest
	)

NodeTest.cpp の 80 行目に定義があります。

  {
    Node obj;
    std::int8_t expectedX = 5;
    std::int8_t expectedY = 8;

    obj.setPosition(5, 8);
    auto actualX = obj.getPositionX();
    auto actualY = obj.getPositionY();

    ASSERT_EQ(expectedX, actualX);
    ASSERT_EQ(expectedY, actualY);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNode10Test
	)

SelectorTest.cpp の 80 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 0, 2, 10, 14 } };
    std::int8_t expected = 10;

    obj.setBlockPositionList(blockList);
    auto actual = obj.searchBlockPosition(8);

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	BlockSolverTest	,
		runrun
	)

BlockSolverTest.cpp の 81 行目に定義があります。

  {
    Controller controller;
    Walker walker{ controller };
    BlockSolver blockSolver{ controller, walker, 84722, 40 };
    blockSolver.run();
  }

etrobocon2018_test::TEST	(	MotorAngleTest	,
		angularDifferenceTestPositive
	)

MotorAngleTest.cpp の 81 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = 10;
    std::int32_t right = 20;

    ASSERT_FLOAT_EQ(right - left, angle.angularDifference(left, right));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get0When10thUp5thDigit
	)

FirstCodeTest.cpp の 81 行目に定義があります。

  {
    FirstCode obj;

    for(int i = 0; i < 10; i++) {
      obj.upDigit(5);
    }
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		probsTest
	)

AIAnswerArrayTest.cpp の 86 行目に定義があります。

  {
    AI_Answer::array<int> array;
    array.push_back({1, 0, 1, 1, 0, 1});
    array.handwriting();

    ASSERT_EQ(1.0, array.probs[2]);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		decodeThirdColorBlockOfCodeTest1
	)

InitialPositionCodeDecoderTest.cpp の 90 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::int32_t codeList = 205060;
    std::vector<std::int8_t> expected = {3, 2, 1, 0};

    obj.decode(codeList);
    auto actual = obj.getInitialPositionCodeList();

    ASSERT_EQ(expected.at(2), actual.at(2));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		updateTest
	)

WheelOdometryTest.cpp の 90 行目に定義があります。

  {
    MotorAngle motor_angle;
    float transform = 3.14f * 99.0f / 2.0f / 180.0f;
    float angle = motor_angle.relativeAngleMean(2, 5);
    float expected_distance = transform * angle;

    transform = 99.0f / 2.0f / 147.5f;
    angle = motor_angle.angularDifference(2, 5);
    float expected_angle = transform * angle;

    WheelOdometry odometry;
    const Coordinate& coordinate = odometry.update(2, 5);
    ASSERT_FLOAT_EQ(expected_distance, coordinate.radius);
    ASSERT_FLOAT_EQ(expected_angle / 2.0f, coordinate.arg);
    ASSERT_FLOAT_EQ(expected_distance * std::cos(expected_angle / 2.0f), coordinate.x);
    ASSERT_FLOAT_EQ(expected_distance * std::sin(expected_angle / 2.0f), coordinate.y);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		angularDifferenceTestNegative
	)

MotorAngleTest.cpp の 90 行目に定義があります。

  {
    MotorAngle angle;
    std::int32_t left = -10;
    std::int32_t right = -20;

    ASSERT_FLOAT_EQ(right - left, angle.angularDifference(left, right));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNode6Test
	)

SelectorTest.cpp の 93 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 6, 7, 10, 11 } };
    std::int8_t expected = 6;

    obj.addMovedBlockPosition(10);
    obj.setBlockPositionList(blockList);
    auto actual = obj.searchBlockPosition(13);

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateCurrentAngleTest2
	)

SelfLocalizationTest.cpp の 94 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    int l, r;
    l = r = 0;

    straight(sl, 20, l, r);
    curve(sl, -45, l, r);

    sl.calculate_current_angle();

    ASSERT_EQ(sl.current_angle_degree, -69);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get0WhenOnceUpAndDown1stDigita
	)

FirstCodeTest.cpp の 94 行目に定義があります。

  {
    FirstCode obj;

    obj.upDigit(1);
    obj.downDigit(1);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfNeighborListTest
	)

NodeTest.cpp の 95 行目に定義があります。

  {
    Node nodeA;
    Node nodeB;
    nodeA.setNodeID(1);
    nodeB.setNodeID(2);
    std::vector<Node*> expected = {&nodeA, &nodeB};
    Node obj{&expected};

    auto actual = obj.getNeighbors();

    ASSERT_EQ(&expected, actual);
    ASSERT_EQ(expected.at(0), actual->at(0));

    expected.at(0)->setNodeID(3);
    ASSERT_EQ(&expected, actual);
    ASSERT_EQ(expected.at(0), actual->at(0));
    ASSERT_EQ(expected.at(0)->getNodeID(), actual->at(0)->getNodeID());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom8To9Test
	)

ExplorerTest.cpp の 96 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 2;
    std::vector<int> expectedList = { 8, 9 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(8, 9);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	AIAnswerArrayTest	,
		handwritingTest
	)

AIAnswerArrayTest.cpp の 96 行目に定義があります。

  {
    AI_Answer::array<int> array;
    array.push_back({0, 0, 1, 1, 1, 1});

    ASSERT_EQ(0, array.handwriting());

    AI_Answer::array<int> array1;
    array1.push_back({0, 0, 0, 1, 0, 1});
    ASSERT_EQ(1, array1.handwriting());

    AI_Answer::array<int> array2;
    array2.push_back({1, 0, 1, 1, 0, 1});
    ASSERT_EQ(2, array2.handwriting());

    AI_Answer::array<int> array3;
    array3.push_back({1, 0, 0, 1, 1, 1});
    ASSERT_EQ(3, array3.handwriting());

    AI_Answer::array<int> array4;
    array4.push_back({1, 1, 1, 0, 1, 1});
    ASSERT_EQ(4, array4.handwriting());

    AI_Answer::array<int> array5;
    array5.push_back({1, 1, 0, 1, 1, 1});
    ASSERT_EQ(5, array5.handwriting());

    AI_Answer::array<int> array6;
    array6.push_back({1, 1, 1, 1, 1, 1});
    ASSERT_EQ(6, array6.handwriting());

    AI_Answer::array<int> array7;
    array7.push_back({1, 0, 0, 1, 0, 1});
    ASSERT_EQ(7, array7.handwriting());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		angularDifferenceTestZero
	)

MotorAngleTest.cpp の 99 行目に定義があります。

  {
    MotorAngle angle;
    ASSERT_FLOAT_EQ(0.0f, angle.angularDifference(0, 0));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		decodeFourthColorBlockOfCodeTest1
	)

InitialPositionCodeDecoderTest.cpp の 103 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;
    std::int32_t codeList = 274965;
    std::vector<std::int8_t> expected = {4, 3, 2, 1};

    obj.decode(codeList);
    auto actual = obj.getInitialPositionCodeList();

    ASSERT_EQ(expected.at(3), actual.at(3));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	MotorAngleTest	,
		absoluteValueOfAngleTest
	)

MotorAngleTest.cpp の 105 行目に定義があります。

  {
    MotorAngle angle;
    ASSERT_EQ(10, angle.absoluteValueOfAngle(10));
    ASSERT_EQ(10, angle.absoluteValueOfAngle(-10));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get90000WhenOnceDown5thDigit
	)

FirstCodeTest.cpp の 106 行目に定義があります。

  {
    FirstCode obj;

    obj.downDigit(5);
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 90000);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNode0Test
	)

SelectorTest.cpp の 107 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 0, 2, 3, 15 } };
    std::int8_t expected = 0;

    obj.setBlockPositionList(blockList);
    auto actual = obj.searchBlockPosition(8);

    ASSERT_EQ(expected, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		calculateCurrentAngleTest3
	)

SelfLocalizationTest.cpp の 108 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    int l, r;
    l = r = 0;

    straight(sl, 20, l, r);
    curve(sl, 90, l, r);
    straight(sl, 20, l, r);
    curve(sl, -90, l, r);

    sl.calculate_current_angle();

    ASSERT_EQ(sl.current_angle_degree, 0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		updateCoordinateTest
	)

WheelOdometryTest.cpp の 109 行目に定義があります。

  {
    WheelOdometry odometry;
    MotorAngle motor_angle;
    ASSERT_FLOAT_EQ(0.0, odometry.getCoordinate().radius);
    ASSERT_FLOAT_EQ(0.0, odometry.getCoordinate().arg);

    float transform = 3.14f * 99.0f / 2.0f / 180.0f;
    float angle = motor_angle.relativeAngleMean(2, 5);
    float expected_distance = transform * angle;
    odometry.update(2, 5);

    ASSERT_FLOAT_EQ(expected_distance, odometry.getCoordinate().radius);
    odometry.update(4, 10);
    ASSERT_FLOAT_EQ(2 * expected_distance, odometry.getCoordinate().radius);
    odometry.update(6, 15);
    ASSERT_FLOAT_EQ(3 * expected_distance, odometry.getCoordinate().radius);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom11To10Test
	)

ExplorerTest.cpp の 113 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 2;
    std::vector<int> expectedList = { 11, 10 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(11, 10);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	InitialPositionCodeDecoderTest	,
		decodeRandomCodeTest
	)

InitialPositionCodeDecoderTest.cpp の 116 行目に定義があります。

  {
    InitialPositionCodeDecoder obj;

    std::vector<std::int32_t> power16 = {1, 16, 16*16, 16*16*16, 16*16*16*16};
    // 乱数を生成する
    std::mt19937 mt{ std::random_device{}() };
    // カラーブロックの乱数範囲を定める
    std::uniform_int_distribution<std::int8_t> distC(1, 15);
    // パワーブロックの乱数範囲を定める
    std::uniform_int_distribution<std::int8_t> distP(1, 8);

    for(int i = 0; i < 100; i++) {
      std::vector<std::int8_t> expectedC = {distC(mt), distC(mt), distC(mt), distC(mt)};
      std::int8_t expectedP = distP(mt);
      std::int32_t expected =
          expectedC[0] * power16[4] +
          expectedC[1] * power16[3] +
          expectedC[2] * power16[2] +
          expectedC[3] * power16[1] +
          expectedP * power16[0];

      obj.decode(expected);
      auto actual = obj.getInitialPositionCode();
      auto actualC = obj.getInitialPositionCodeList();
      auto actualP = obj.getInitialPositionPowerBlockCode();

      EXPECT_EQ(expected, actual);
      EXPECT_EQ(expectedC, actualC);
      EXPECT_EQ(expectedP, actualP);
    }
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOf3NeighborListTest
	)

NodeTest.cpp の 116 行目に定義があります。

  {
    Node node1(1);
    Node node2(2);
    Node node3(3);

    std::vector<Node*> neighbors1 = {&node2};
    std::vector<Node*> neighbors2 = {&node1, &node3};
    std::vector<Node*> neighbors3 = {&node2};

    node1.setNeighbors(&neighbors1);
    node2.setNeighbors(&neighbors2);
    node3.setNeighbors(&neighbors3);

    auto actual1 = node1.getNeighbors();
    auto actual2 = node2.getNeighbors();
    auto actual3 = node3.getNeighbors();

    ASSERT_EQ(&neighbors1, actual1);
    ASSERT_EQ(&neighbors2, actual2);
    ASSERT_EQ(&neighbors3, actual3);

    ASSERT_EQ(&node1, actual1->at(0)->getNeighbors()->at(0));
    ASSERT_EQ(&node2, actual2->at(0)->getNeighbors()->at(0));
    ASSERT_EQ(&node2, actual2->at(1)->getNeighbors()->at(0));
    ASSERT_EQ(&node3, actual3->at(0)->getNeighbors()->at(1));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get0When10thDown5thDigit
	)

FirstCodeTest.cpp の 117 行目に定義があります。

  {
    FirstCode obj;

    for(int i = 0; i < 10; i++) {
      obj.downDigit(5);
    }
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 0);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		checkWhetherThereIsMovedBlock
	)

SelectorTest.cpp の 120 行目に定義があります。

  {
    Selector obj;

    ASSERT_FALSE(obj.isAlreadyMovedNode(1));
    ASSERT_FALSE(obj.isAlreadyMovedNode(10));

    obj.addMovedBlockPosition(1);

    ASSERT_TRUE(obj.isAlreadyMovedNode(1));
    ASSERT_FALSE(obj.isAlreadyMovedNode(10));

    obj.addMovedBlockPosition(10);

    ASSERT_TRUE(obj.isAlreadyMovedNode(1));
    ASSERT_TRUE(obj.isAlreadyMovedNode(10));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		isOverNormalVectorTest1
	)

SelfLocalizationTest.cpp の 124 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    sl.init_normal_vector(0.0, 0.0, 100.0, 100.0, 0.0, 0.0);
    ASSERT_EQ(sl.is_over_normal_vector(10.0, 10.0), false);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		getRotationAngleTest
	)

WheelOdometryTest.cpp の 128 行目に定義があります。

  {
    WheelOdometry odometry;
    float transform = 99.0f / 147.5f;
    float angle = (5.0f + 5.0f) / 2.0f;

    ASSERT_FLOAT_EQ(transform * angle, odometry.getRotationAngle(-5, 5));

    float angle2 = (2.0f + 2.0f) / 2.0f;

    ASSERT_FLOAT_EQ(transform * angle2, odometry.getRotationAngle(-2, 2));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom0To2Test
	)

ExplorerTest.cpp の 130 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 3;
    std::vector<int> expectedList = { 0, 1, 2 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(0, 2);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get12345WhenOnceDown5thDigit
	)

FirstCodeTest.cpp の 130 行目に定義があります。

  {
    FirstCode obj;
    int set[5];
    set[0] = 5;
    set[1] = 4;
    set[2] = 3;
    set[3] = 2;
    set[4] = 1;

    for(int i = 0; i < 5; i++) {
      for(int j = 0; j < set[i]; j++) {
        obj.upDigit(i + 1);
      }
    }
    int expected = obj.getFirstCode();

    ASSERT_EQ(expected, 12345);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		isOverNormalVectorTest2
	)

SelfLocalizationTest.cpp の 131 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    sl.init_normal_vector(0.0, 0.0, 100.0, 100.0, 0.0, 0.0);
    ASSERT_EQ(sl.is_over_normal_vector(101.0, 101.0), true);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		isOverNormalVectorTest3
	)

SelfLocalizationTest.cpp の 138 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    sl.init_normal_vector(0.0, 0.0, 100.0, 100.0, 0.0, 0.0);
    ASSERT_EQ(sl.is_over_normal_vector(99.0, 101.0), true);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		checkNextOperationIsAllFalseInInitialStageTest
	)

SelectorTest.cpp の 139 行目に定義があります。

  {
    Selector obj;

    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		getCoordinateTest
	)

WheelOdometryTest.cpp の 141 行目に定義があります。

  {
    WheelOdometry odometry;
    const Coordinate& coordinate = odometry.getCoordinate();

    ASSERT_FLOAT_EQ(0.0f, coordinate.radius);
    ASSERT_FLOAT_EQ(0.0f, coordinate.arg);
    ASSERT_FLOAT_EQ(0.0f, coordinate.x);
    ASSERT_FLOAT_EQ(0.0f, coordinate.y);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfNeighborListOf3x3Test
	)

NodeTest.cpp の 145 行目に定義があります。

  {
    std::vector<Node*> blockAreaNodePtrList(9);
    std::vector<Node> blockAreaNodeList(9);

    for (std::int8_t i = 0; i < 9; i++)
    {
      Node currentNode(i);
      blockAreaNodeList[i] = currentNode;
      blockAreaNodePtrList[i] = &blockAreaNodeList[i];
    }
    std::vector<Node*>* blockAreaNodePtrListPtr = &blockAreaNodePtrList;


    std::vector<Node*> neighborsOfNode0;
    std::vector<Node*> neighborsOfNode1;
    std::vector<Node*> neighborsOfNode2;

    std::vector<Node*> neighborsOfNode3;
    std::vector<Node*> neighborsOfNode4;
    std::vector<Node*> neighborsOfNode5;

    std::vector<Node*> neighborsOfNode6;
    std::vector<Node*> neighborsOfNode7;
    std::vector<Node*> neighborsOfNode8;


    int numbers0[2] = {1, 3};
    for (int i = 0; i < 2; i++)
    {
      neighborsOfNode0.push_back(blockAreaNodePtrListPtr->at(numbers0[i]));
    }
    int numbers1[3] = {0, 2, 4};
    for (int i = 0; i < 3; i++)
    {
      neighborsOfNode1.push_back(blockAreaNodePtrListPtr->at(numbers1[i]));
    }
    int numbers2[2] = {1, 5};
    for (int i = 0; i < 2; i++)
    {
      neighborsOfNode2.push_back(blockAreaNodePtrListPtr->at(numbers2[i]));
    }


    int numbers3[3] = {0, 4, 6};
    for (int i = 0; i < 3; i++)
    {
      neighborsOfNode3.push_back(blockAreaNodePtrListPtr->at(numbers3[i]));
    }
    int numbers4[4] = {1, 3, 5, 7};
    for (int i = 0; i < 4; i++)
    {
      neighborsOfNode4.push_back(blockAreaNodePtrListPtr->at(numbers4[i]));
    }
    int numbers5[3] = {2, 4, 8};
    for (int i = 0; i < 3; i++)
    {
      neighborsOfNode5.push_back(blockAreaNodePtrListPtr->at(numbers5[i]));
    }


    int numbers6[2] = {3, 7};
    for (int i = 0; i < 2; i++)
    {
      neighborsOfNode6.push_back(blockAreaNodePtrListPtr->at(numbers6[i]));
    }
    int numbers7[3] = {4, 6, 8};
    for (int i = 0; i < 3; i++)
    {
      neighborsOfNode7.push_back(blockAreaNodePtrListPtr->at(numbers7[i]));
    }
    int numbers8[2] = {5, 7};
    for (int i = 0; i < 2; i++)
    {
      neighborsOfNode8.push_back(blockAreaNodePtrListPtr->at(numbers8[i]));
    }


    blockAreaNodePtrListPtr->at(0)->setNeighbors(&neighborsOfNode0);
    blockAreaNodePtrListPtr->at(1)->setNeighbors(&neighborsOfNode1);
    blockAreaNodePtrListPtr->at(2)->setNeighbors(&neighborsOfNode2);

    blockAreaNodePtrListPtr->at(3)->setNeighbors(&neighborsOfNode3);
    blockAreaNodePtrListPtr->at(4)->setNeighbors(&neighborsOfNode4);
    blockAreaNodePtrListPtr->at(5)->setNeighbors(&neighborsOfNode5);

    blockAreaNodePtrListPtr->at(6)->setNeighbors(&neighborsOfNode6);
    blockAreaNodePtrListPtr->at(7)->setNeighbors(&neighborsOfNode7);
    blockAreaNodePtrListPtr->at(8)->setNeighbors(&neighborsOfNode8);


    ASSERT_EQ(blockAreaNodePtrListPtr->at(0)->getNodeID(), blockAreaNodeList[1].getNeighbors()->at(0)->getNodeID());

    ASSERT_EQ(&blockAreaNodeList[0], blockAreaNodeList[1].getNeighbors()->at(0));
    ASSERT_EQ(&blockAreaNodeList[0], neighborsOfNode1[0]);
    ASSERT_EQ(blockAreaNodeList[1].getNodeID(), blockAreaNodeList[0].getNeighbors()->at(0)->getNodeID());
    ASSERT_EQ(&blockAreaNodeList[1], blockAreaNodeList[0].getNeighbors()->at(0));

    // 中央は4方の隣接ノードと等しい
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(1)->getNeighbors()->at(2));
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(3)->getNeighbors()->at(1));
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(5)->getNeighbors()->at(1));
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(7)->getNeighbors()->at(0));

    // 中央は4隅の隣接ノードの隣接ノードと等しい
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(0)->getNeighbors()->at(0)->getNeighbors()->at(2));
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(2)->getNeighbors()->at(1)->getNeighbors()->at(1));
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(6)->getNeighbors()->at(0)->getNeighbors()->at(1));
    ASSERT_EQ(blockAreaNodePtrListPtr->at(4), blockAreaNodePtrListPtr->at(8)->getNeighbors()->at(1)->getNeighbors()->at(0));
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelfLocalizationTest	,
		isOverNormalVectorTest4
	)

SelfLocalizationTest.cpp の 145 行目に定義があります。

  {
    SelfLocalization sl(0, 0, false);
    sl.init_normal_vector(0.0, 0.0, 100.0, 100.0, 0.0, 0.0);
    ASSERT_EQ(sl.is_over_normal_vector(101.0, 99.0), true);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom2To0Test
	)

ExplorerTest.cpp の 147 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 3;
    std::vector<int> expectedList = { 2, 1, 0 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(2, 0);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		checkNextOperationIsAllFalseWithoutSetNextWhenNextIsSetTest
	)

SelectorTest.cpp の 149 行目に定義があります。

  {
    Selector obj;

    obj.setNext(Selector::Evacuating);
    ASSERT_TRUE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());

    obj.setNext(Selector::Moving);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());

    obj.setNext(Selector::Carrying);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get5WhenDoNotChangeLeftAndRightAnyDigitNumber
	)

FirstCodeTest.cpp の 151 行目に定義があります。

  {
    FirstCode obj;

    int expected = obj.getDigit();

    ASSERT_EQ(expected, 5);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		getPointXTest
	)

WheelOdometryTest.cpp の 152 行目に定義があります。

  {
    WheelOdometry odometry;
    const Coordinate& coordinate = odometry.update(2, 5);

    ASSERT_FLOAT_EQ(coordinate.x, odometry.getPointX());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	WheelOdometryTest	,
		getPointYTest
	)

WheelOdometryTest.cpp の 160 行目に定義があります。

  {
    WheelOdometry odometry;
    const Coordinate& coordinate = odometry.update(2, 5);

    ASSERT_FLOAT_EQ(coordinate.y, odometry.getPointY());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get4WhenOnceChangeRightDigitNumber
	)

FirstCodeTest.cpp の 161 行目に定義があります。

  {
    FirstCode obj;

    obj.changeRightDigit();
    int expected = obj.getDigit();

    ASSERT_EQ(expected, 4);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchShortestRouteFrom11To5Test
	)

ExplorerTest.cpp の 164 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 4;
    std::vector<int> expectedList = { 11, 10, 9, 5 };

    obj.createBlockArea();
    auto actual = obj.searchRoute(11, 5);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		checkThereAreNotNodeInInitialRouteTest
	)

SelectorTest.cpp の 170 行目に定義があります。

  {
    Selector obj;
    unsigned int expected = 0;

    // あってもなくても関係なし
    obj.setBlockPositionList(std::vector<std::int8_t>({ 1, 2, 3 }));

    auto actual = obj.extractRoute();

    ASSERT_EQ(expected, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get5When5thChangeRightDigitNumber
	)

FirstCodeTest.cpp の 172 行目に定義があります。

  {
    FirstCode obj;

    for(int i = 0; i < 5; i++) {
      obj.changeRightDigit();
    }
    int expected = obj.getDigit();

    ASSERT_EQ(expected, 5);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom11To5Circumventing6Test
	)

ExplorerTest.cpp の 181 行目に定義があります。

  {
    Explorer obj;
    unsigned long int expectedSize = 4;
    std::vector<int> expectedList = { 11, 10, 9, 5 };

    obj.createBlockArea();
    obj.getBlockAreaNodeList()->at(6)->setHasBlock(true);
    auto actual = obj.searchRoute(11, 5);

    for(unsigned int i = 0; i < expectedSize; i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expectedList[i]);
    }

    ASSERT_EQ(expectedSize, actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		getSomeNodeInRouteWhenRouteIsSetTest
	)

SelectorTest.cpp の 184 行目に定義があります。

  {
    Selector obj;
    std::vector<int> expectedList = { 0, 1, 2, 3, 7, 11, 15, 14, 13, 12, 8, 4, 5, 6, 10, 9 };

    obj.updateRoute(expectedList);
    auto actual = obj.extractRoute();

    ASSERT_EQ(expectedList.size(), actual.size());
    for(unsigned int i = 0; i < actual.size(); i++) EXPECT_EQ(expectedList[i], actual[i]);

    expectedList = { 8, 9, 10, 11 };
    obj.updateRoute(expectedList);
    actual = obj.extractRoute();

    ASSERT_EQ(expectedList.size(), actual.size());
    for(unsigned int i = 0; i < actual.size(); i++) EXPECT_EQ(expectedList[i], actual[i]);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get5WhenOnceChangeLeftDigitNumberAfterTwiceChangeRightDigitNumber
	)

FirstCodeTest.cpp の 185 行目に定義があります。

  {
    FirstCode obj;

    obj.changeRightDigit();
    obj.changeRightDigit();
    obj.changeLeftDigit();
    int expected = obj.getDigit();

    ASSERT_EQ(expected, 4);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	FirstCodeTest	,
		get1WhenOnceChangeLeftDigitNumber
	)

FirstCodeTest.cpp の 198 行目に定義があります。

  {
    FirstCode obj;

    obj.changeLeftDigit();
    int expected = obj.getDigit();

    ASSERT_EQ(expected, 1);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom11To5Circumventing6And10Test
	)

ExplorerTest.cpp の 199 行目に定義があります。

  {
    Explorer obj;
    std::vector<int> expected = { 11, 15, 14, 13, 9, 5 };

    obj.createBlockArea();
    obj.getBlockAreaNodeList()->at(6)->setHasBlock(true);
    obj.getBlockAreaNodeList()->at(10)->setHasBlock(true);
    auto actual = obj.searchRoute(11, 5);

    for(unsigned int i = 0; i < expected.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expected[i]);
    }

    ASSERT_EQ(expected.size(), actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		getNextPositionInCenterIfColorSetInNodeIDTest
	)

SelectorTest.cpp の 204 行目に定義があります。

  {
    Selector obj;

    auto actual = obj.getPositionOfCenterQuadirilateral(Selector::Blue);
    ASSERT_EQ(10, actual);

    actual = obj.getPositionOfCenterQuadirilateral(Selector::Red);
    ASSERT_EQ(6, actual);

    actual = obj.getPositionOfCenterQuadirilateral(Selector::Yellow);
    ASSERT_EQ(9, actual);

    actual = obj.getPositionOfCenterQuadirilateral(Selector::Green);
    ASSERT_EQ(5, actual);

    actual = obj.getPositionOfCenterQuadirilateral(Selector::Undefined);
    ASSERT_EQ(-1, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom13To6Circumventing10Test
	)

ExplorerTest.cpp の 217 行目に定義があります。

  {
    Explorer obj;
    std::vector<int> expected = { 13, 9, 5, 6 };

    obj.createBlockArea();
    obj.getBlockAreaNodeList()->at(6)->setHasBlock(true);
    obj.getBlockAreaNodeList()->at(7)->setHasBlock(true);
    obj.getBlockAreaNodeList()->at(10)->setHasBlock(true);
    obj.getBlockAreaNodeList()->at(11)->setHasBlock(true);
    auto actual = obj.searchRoute(13, 6);

    for(unsigned int i = 0; i < expected.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expected[i]);
    }

    ASSERT_EQ(expected.size(), actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		checkPushingAndPoppingByPseudoStackTest
	)

SelectorTest.cpp の 225 行目に定義があります。

  {
    Selector obj;

    obj.pushEvacuatedBlockPosition(10);
    obj.pushEvacuatedBlockPosition(20);
    obj.pushEvacuatedBlockPosition(30);

    auto actual = obj.popEvacuatedBlockPosition();
    ASSERT_EQ(30, actual);
    actual = obj.popEvacuatedBlockPosition();
    ASSERT_EQ(20, actual);

    obj.pushEvacuatedBlockPosition(40);

    actual = obj.popEvacuatedBlockPosition();
    ASSERT_EQ(40, actual);
    actual = obj.popEvacuatedBlockPosition();
    ASSERT_EQ(10, actual);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteFrom11To5Circumventing6And9And10Test
	)

ExplorerTest.cpp の 237 行目に定義があります。

  {
    Explorer obj;
    std::vector<int> expected = { 11, 7, 3, 2, 1, 5 };

    obj.createBlockArea();
    obj.getBlockAreaNodeList()->at(6)->setHasBlock(true);
    obj.getBlockAreaNodeList()->at(9)->setHasBlock(true);
    obj.getBlockAreaNodeList()->at(10)->setHasBlock(true);
    auto actual = obj.searchRoute(11, 5);

    for(unsigned int i = 0; i < expected.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actual[i])->getNodeID(), expected[i]);
    }

    ASSERT_EQ(expected.size(), actual.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchNodeInSenarioTest
	)

SelectorTest.cpp の 247 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 8, 9, 11, 15 } };

    obj.setBlockPositionList(blockList);

    // 8を探す
    auto actual8 = obj.searchBlockPosition(8);
    ASSERT_EQ(8, actual8);

    // 9を探す
    blockList = { 9, 10, 11, 15 };
    obj.setBlockPositionList(blockList);
    obj.addMovedBlockPosition(10);
    auto actual9 = obj.searchBlockPosition(14);
    ASSERT_EQ(9, actual9);

    // 11を探す
    blockList = { 6, 10, 11, 15 };
    obj.setBlockPositionList(blockList);
    obj.addMovedBlockPosition(6);
    auto actual11 = obj.searchBlockPosition(5);
    ASSERT_EQ(11, actual11);

    // 15を探す
    blockList = { 6, 9, 10, 15 };
    obj.setBlockPositionList(blockList);
    obj.addMovedBlockPosition(5);
    auto actual15 = obj.searchBlockPosition(15);
    ASSERT_EQ(15, actual15);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	ExplorerTest	,
		searchRouteInSenarioTest
	)

ExplorerTest.cpp の 256 行目に定義があります。

  {
    Explorer obj;
    // 8->Blue, 9->Red, 11->Yellow, 15->Green
    std::vector<int> expectedCartingBlue = { 8, 12, 13, 14, 10 };
    std::vector<int> expectedMovingToRed = { 14, 13, 9 };
    std::vector<int> expectedCartingRed = { 9, 5, 6 };
    std::vector<int> expectedMovingToYellow = { 5, 1, 2, 3, 7, 11 };
    std::vector<int> expectedCartingYellow = { 11, 7, 3, 2, 1, 5, 9 };
    std::vector<int> expectedMovingToGreen = { 5, 4, 8, 12, 13, 14, 15 };
    std::vector<int> expectedCartingGreen = { 15, 14, 13, 12, 8, 4, 5 };
    std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };

    obj.createBlockArea();
    obj.resetBlockArea();
    obj.setHasBlockIn(8);
    obj.setHasBlockIn(9);
    obj.setHasBlockIn(11);
    obj.setHasBlockIn(15);

    // Blue 8->10
    auto actualCartingBlue = obj.searchRoute(8, 10);

    for(unsigned int i = 0; i < expectedCartingBlue.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualCartingBlue[i])->getNodeID(),
                expectedCartingBlue[i]);
    }
    EXPECT_EQ(expectedCartingBlue.size(), actualCartingBlue.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(9);
    obj.setHasBlockIn(10);
    obj.setHasBlockIn(11);
    obj.setHasBlockIn(15);

    // 14->9
    auto actualMovingToRed = obj.searchRoute(14, 9);
    for(unsigned int i = 0; i < expectedMovingToRed.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualMovingToRed[i])->getNodeID(),
                expectedMovingToRed[i]);
    }
    EXPECT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(9);
    obj.setHasBlockIn(10);
    obj.setHasBlockIn(11);
    obj.setHasBlockIn(15);

    // Red 9->6
    auto actualCartingRed = obj.searchRoute(9, 6);
    for(unsigned int i = 0; i < expectedCartingRed.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualCartingRed[i])->getNodeID(),
                expectedCartingRed[i]);
    }
    EXPECT_EQ(expectedCartingRed.size(), actualCartingRed.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(6);
    obj.setHasBlockIn(10);
    obj.setHasBlockIn(11);
    obj.setHasBlockIn(15);

    // 5->11
    auto actualMovingToYellow = obj.searchRoute(5, 11);
    for(unsigned int i = 0; i < expectedMovingToYellow.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualMovingToYellow[i])->getNodeID(),
                expectedMovingToYellow[i]);
    }
    EXPECT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(6);
    obj.setHasBlockIn(10);
    obj.setHasBlockIn(11);
    obj.setHasBlockIn(15);

    // Yellow 11->9
    auto actualCartingYellow = obj.searchRoute(11, 9);
    for(unsigned int i = 0; i < expectedCartingYellow.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualCartingYellow[i])->getNodeID(),
                expectedCartingYellow[i]);
    }
    EXPECT_EQ(expectedCartingYellow.size(), actualCartingYellow.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(6);
    obj.setHasBlockIn(9);
    obj.setHasBlockIn(10);
    obj.setHasBlockIn(15);

    // 5->15
    auto actualMovingToGreen = obj.searchRoute(5, 15);
    for(unsigned int i = 0; i < expectedMovingToGreen.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualMovingToGreen[i])->getNodeID(),
                expectedMovingToGreen[i]);
    }
    EXPECT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(6);
    obj.setHasBlockIn(9);
    obj.setHasBlockIn(10);
    obj.setHasBlockIn(15);

    // Green 15->5
    auto actualCartingGreen = obj.searchRoute(15, 5);
    for(unsigned int i = 0; i < expectedCartingGreen.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualCartingGreen[i])->getNodeID(),
                expectedCartingGreen[i]);
    }
    EXPECT_EQ(expectedCartingYellow.size(), actualCartingGreen.size());

    obj.resetBlockArea();
    obj.setHasBlockIn(5);
    obj.setHasBlockIn(6);
    obj.setHasBlockIn(9);
    obj.setHasBlockIn(10);

    // 4->11
    auto actualMovingTo11 = obj.searchRoute(4, 11);
    for(unsigned int i = 0; i < expectedMovingTo11.size(); i++) {
      EXPECT_EQ(obj.getBlockAreaNodeList()->at(actualMovingTo11[i])->getNodeID(),
                expectedMovingTo11[i]);
    }
    EXPECT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfNeighborListOf4x4Test
	)

NodeTest.cpp の 257 行目に定義があります。

  {
    Node node0;
    Node node1(1);
    Node node2(2);
    Node node3(3);
    Node node4(4);
    Node node5(5);
    Node node6(6);
    Node node7(7);
    Node node8(8);
    Node node9(9);
    Node node10(10);
    Node node11(11);
    Node node12(12);
    Node node13(13);
    Node node14(14);
    Node node15(15);

    std::vector<Node*> neighbors0 = {&node1, &node4};
    std::vector<Node*> neighbors1 = {&node0, &node2, &node5};
    std::vector<Node*> neighbors2 = {&node1, &node3, &node6};
    std::vector<Node*> neighbors3 = {&node2, &node7};
    std::vector<Node*> neighbors4 = {&node0, &node5, &node8};
    std::vector<Node*> neighbors5 = {&node1, &node4, &node6, &node9};
    std::vector<Node*> neighbors6 = {&node2, &node5, &node7, &node10};
    std::vector<Node*> neighbors7 = {&node3, &node6, &node11};
    std::vector<Node*> neighbors8 = {&node4, &node9, &node12};
    std::vector<Node*> neighbors9 = {&node5, &node8, &node10, &node13};
    std::vector<Node*> neighbors10 = {&node6, &node9, &node11, &node14};
    std::vector<Node*> neighbors11 = {&node7, &node10, &node15};
    std::vector<Node*> neighbors12 = {&node8, &node13};
    std::vector<Node*> neighbors13 = {&node9, &node12, &node14};
    std::vector<Node*> neighbors14 = {&node10, &node13, &node15};
    std::vector<Node*> neighbors15 = {&node11, &node14};

    node0.setNeighbors(&neighbors0);
    node1.setNeighbors(&neighbors1);
    node2.setNeighbors(&neighbors2);
    node3.setNeighbors(&neighbors3);
    node4.setNeighbors(&neighbors4);
    node5.setNeighbors(&neighbors5);
    node6.setNeighbors(&neighbors6);
    node7.setNeighbors(&neighbors7);
    node8.setNeighbors(&neighbors8);
    node9.setNeighbors(&neighbors9);
    node10.setNeighbors(&neighbors10);
    node11.setNeighbors(&neighbors11);
    node12.setNeighbors(&neighbors12);
    node13.setNeighbors(&neighbors13);
    node14.setNeighbors(&neighbors14);
    node15.setNeighbors(&neighbors15);

    auto actual0 = node0.getNeighbors();
    auto actual1 = node1.getNeighbors();
    auto actual2 = node2.getNeighbors();
    auto actual3 = node3.getNeighbors();
    auto actual4 = node4.getNeighbors();
    auto actual5 = node5.getNeighbors();
    auto actual6 = node6.getNeighbors();
    auto actual7 = node7.getNeighbors();
    auto actual8 = node8.getNeighbors();
    auto actual9 = node9.getNeighbors();
    auto actual10 = node10.getNeighbors();
    auto actual11 = node11.getNeighbors();
    auto actual12 = node12.getNeighbors();
    auto actual13 = node13.getNeighbors();
    auto actual14 = node14.getNeighbors();
    auto actual15 = node15.getNeighbors();

    ASSERT_EQ(&neighbors0, actual0);
    ASSERT_EQ(&neighbors1, actual1);
    ASSERT_EQ(&neighbors2, actual2);
    ASSERT_EQ(&neighbors3, actual3);
    ASSERT_EQ(&neighbors4, actual4);
    ASSERT_EQ(&neighbors5, actual5);
    ASSERT_EQ(&neighbors6, actual6);
    ASSERT_EQ(&neighbors7, actual7);
    ASSERT_EQ(&neighbors8, actual8);
    ASSERT_EQ(&neighbors9, actual9);
    ASSERT_EQ(&neighbors10, actual10);
    ASSERT_EQ(&neighbors11, actual11);
    ASSERT_EQ(&neighbors12, actual12);
    ASSERT_EQ(&neighbors13, actual13);
    ASSERT_EQ(&neighbors14, actual14);
    ASSERT_EQ(&neighbors15, actual15);
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteInSenarioTest
	)

SelectorTest.cpp の 281 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 8, 9, 11, 15 } };
    // 8->Blue, 9->Red, 11->Yellow, 15->Green
    std::vector<int> expectedMovingToBlue = { 8 };
    std::vector<int> expectedCarryingBlue = { 8, 12, 13, 14, 10 };
    std::vector<int> expectedMovingToRed = { 14, 13, 9 };
    std::vector<int> expectedCarryingRed = { 9, 5, 6 };
    std::vector<int> expectedMovingToYellow = { 5, 1, 2, 3, 7, 11 };
    std::vector<int> expectedCarryingYellow = { 11, 7, 3, 2, 1, 5, 9 };
    std::vector<int> expectedMovingToGreen = { 5, 4, 8, 12, 13, 14, 15 };
    std::vector<int> expectedCarryingGreen = { 15, 14, 13, 12, 8, 4, 5 };
    std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };

    obj.setBlockPositionList(blockList);

    // 8に移動する
    auto actualMovingToBlue = obj.exploreNextOperation(8, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToBlue.size(), actualMovingToBlue.size());
    for(unsigned int i = 0; i < actualMovingToBlue.size(); i++)
      EXPECT_EQ(actualMovingToBlue[i], expectedMovingToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(8, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(11, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に運搬する
    auto actualCarryingBlue = obj.exploreNextOperation(8, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
    for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
      EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(11, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に移動する
    auto actualMovingToRed = obj.exploreNextOperation(14, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
    for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
      EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(11, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に運搬する
    auto actualCarryingRed = obj.exploreNextOperation(9, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
    for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
      EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(11, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingToYellow = obj.exploreNextOperation(5, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
    for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
      EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(11, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に運搬する
    auto actualCarryingYellow = obj.exploreNextOperation(11, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
    for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
      EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 15に移動する
    auto actualMovingToGreen = obj.exploreNextOperation(5, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
    for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
      EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(15, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に運搬する
    auto actualCarryingGreen = obj.exploreNextOperation(15, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
    for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
      EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingTo11 = obj.exploreNextOperation(4, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
    for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
      EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(10, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfNeighborListOfETRobocon2018Test
	)

NodeTest.cpp の 346 行目に定義があります。

  {
    std::vector<std::vector<int>> neighborsIDList = {
        {1, 4},
        {0, 2, 5},
        {1, 3, 6},
        {2, 7},
        {0, 5, 8},
        {1, 4, 6, 9},
        {2, 5, 7, 10},
        {3, 6, 11},
        {4, 9, 12},
        {5, 8, 10, 13},
        {6, 9, 11, 14},
        {7, 10, 15},
        {8, 13},
        {9, 12, 14},
        {10, 13, 15},
        {11, 14}};
    int nodeCount = neighborsIDList.size();

    std::vector<Node> nodes(nodeCount);
    std::vector<Node*> nodePtrs(nodeCount);
    for (int i = 0; i < nodeCount; i++)
    {
      nodes[i].setNodeID(i);
      nodePtrs[i] = &nodes[i];
    }

    std::vector<std::vector<Node*>> neighbors(nodeCount);
    for (int i = 0; i < nodeCount; i++)
    {
      for (int nodeID : neighborsIDList[i])
      {
        neighbors[i].push_back(nodePtrs[nodeID]);
      }
    }
    for (int i = 0; i < nodeCount; i++)
    {
      nodePtrs[i]->setNeighbors(&neighbors[i]);
    }

    auto actual0 = nodePtrs[0]->getNeighbors();
    auto actual1 = nodePtrs[1]->getNeighbors();
    auto actual2 = nodePtrs[2]->getNeighbors();
    auto actual3 = nodePtrs[3]->getNeighbors();
    auto actual4 = nodePtrs[4]->getNeighbors();
    auto actual5 = nodePtrs[5]->getNeighbors();
    auto actual6 = nodePtrs[6]->getNeighbors();
    auto actual7 = nodePtrs[7]->getNeighbors();
    auto actual8 = nodePtrs[8]->getNeighbors();
    auto actual9 = nodePtrs[9]->getNeighbors();
    auto actual10 = nodePtrs[10]->getNeighbors();
    auto actual11 = nodePtrs[11]->getNeighbors();
    auto actual12 = nodePtrs[12]->getNeighbors();
    auto actual13 = nodePtrs[13]->getNeighbors();
    auto actual14 = nodePtrs[14]->getNeighbors();
    auto actual15 = nodePtrs[15]->getNeighbors();

    ASSERT_EQ(&neighbors[0], actual0);
    ASSERT_EQ(&neighbors[1], actual1);
    ASSERT_EQ(&neighbors[2], actual2);
    ASSERT_EQ(&neighbors[3], actual3);
    ASSERT_EQ(&neighbors[4], actual4);
    ASSERT_EQ(&neighbors[5], actual5);
    ASSERT_EQ(&neighbors[6], actual6);
    ASSERT_EQ(&neighbors[7], actual7);
    ASSERT_EQ(&neighbors[8], actual8);
    ASSERT_EQ(&neighbors[9], actual9);
    ASSERT_EQ(&neighbors[10], actual10);
    ASSERT_EQ(&neighbors[11], actual11);
    ASSERT_EQ(&neighbors[12], actual12);
    ASSERT_EQ(&neighbors[13], actual13);
    ASSERT_EQ(&neighbors[14], actual14);
    ASSERT_EQ(&neighbors[15], actual15);

    ASSERT_EQ(&neighbors[10], actual0->at(1)->getNeighbors()->at(1)->getNeighbors()->at(2)->getNeighbors()->at(3)->getNeighbors());
  }

etrobocon2018_test::TEST	(	NodeTest	,
		getValueOfNeighborListOfETRobocon2017Test
	)

NodeTest.cpp の 426 行目に定義があります。

  {
    std::vector<std::vector<int>> neighborsIDList = {
        {1, 4, 9},
        {0, 2, 4, 5},
        {1, 3, 5, 6},
        {2, 6, 10},
        {0, 1, 7, 9},
        {1, 2, 7, 8},
        {2, 3, 8, 9},
        {4, 5, 11, 12},
        {5, 6, 13, 14},
        {0, 4, 11},
        {3, 6, 14},
        {7, 9, 12},
        {7, 11, 13},
        {8, 12, 14},
        {8, 10, 13}};
    int nodeCount = neighborsIDList.size();

    std::vector<Node> nodes(nodeCount);
    std::vector<Node*> nodePtrs(nodeCount);
    for (int i = 0; i < nodeCount; i++)
    {
      nodes[i].setNodeID(i);
      nodePtrs[i] = &nodes[i];
    }

    std::vector<std::vector<Node*>> neighbors(nodeCount);
    for (int i = 0; i < nodeCount; i++)
    {
      for (int nodeID : neighborsIDList[i])
      {
        neighbors[i].push_back(nodePtrs[nodeID]);
      }
    }
    for (int i = 0; i < nodeCount; i++)
    {
      nodePtrs[i]->setNeighbors(&neighbors[i]);
    }

    auto actual0 = nodePtrs[0]->getNeighbors();
    auto actual1 = nodePtrs[1]->getNeighbors();
    auto actual2 = nodePtrs[2]->getNeighbors();
    auto actual3 = nodePtrs[3]->getNeighbors();
    auto actual4 = nodePtrs[4]->getNeighbors();
    auto actual5 = nodePtrs[5]->getNeighbors();
    auto actual6 = nodePtrs[6]->getNeighbors();
    auto actual7 = nodePtrs[7]->getNeighbors();
    auto actual8 = nodePtrs[8]->getNeighbors();
    auto actual9 = nodePtrs[9]->getNeighbors();
    auto actual10 = nodePtrs[10]->getNeighbors();
    auto actual11 = nodePtrs[11]->getNeighbors();
    auto actual12 = nodePtrs[12]->getNeighbors();
    auto actual13 = nodePtrs[13]->getNeighbors();
    auto actual14 = nodePtrs[14]->getNeighbors();

    ASSERT_EQ(&neighbors[0], actual0);
    ASSERT_EQ(&neighbors[1], actual1);
    ASSERT_EQ(&neighbors[2], actual2);
    ASSERT_EQ(&neighbors[3], actual3);
    ASSERT_EQ(&neighbors[4], actual4);
    ASSERT_EQ(&neighbors[5], actual5);
    ASSERT_EQ(&neighbors[6], actual6);
    ASSERT_EQ(&neighbors[7], actual7);
    ASSERT_EQ(&neighbors[8], actual8);
    ASSERT_EQ(&neighbors[9], actual9);
    ASSERT_EQ(&neighbors[10], actual10);
    ASSERT_EQ(&neighbors[11], actual11);
    ASSERT_EQ(&neighbors[12], actual12);
    ASSERT_EQ(&neighbors[13], actual13);
    ASSERT_EQ(&neighbors[14], actual14);
  }

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteWhenPathBlocked
	)

SelectorTest.cpp の 453 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 4, 8, 9, 13 } };
    // 8->Blue, 9->Red, 13->Yellow, 4->Green
    // std::vector<int> expectedMovingToBlue = {8};
    std::vector<int> expectedEvacuatingBlue = { 8, 12 };
    std::vector<int> expectedMovingToRed = { 8, 9 };
    std::vector<int> expectedCarryingRed = { 9, 10, 6 };
    std::vector<int> expectedReturningToBlue = { 10, 9, 8, 12 };
    std::vector<int> expectedCarryingBlue = { 12, 8, 9, 10 };
    std::vector<int> expectedMovingToYellow = { 9, 13 };
    std::vector<int> expectedCarryingYellow = { 13, 9 };
    std::vector<int> expectedMovingToGreen = { 13, 12, 8, 4 };
    std::vector<int> expectedCarryingGreen = { 4, 5 };
    std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };

    obj.setBlockPositionList(blockList);

    // 8に移動する
    obj.exploreNextOperation(8, Selector::Undefined);
    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に一時避難する
    auto actualEvacuatingBlue = obj.exploreNextOperation(8, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedEvacuatingBlue.size(), actualEvacuatingBlue.size());
    for(unsigned int i = 0; i < actualEvacuatingBlue.size(); i++)
      EXPECT_EQ(actualEvacuatingBlue[i], expectedEvacuatingBlue[i]);
    ASSERT_TRUE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(12, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(13, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に移動する
    auto actualMovingToRed = obj.exploreNextOperation(8, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
    for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
      EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(12, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(13, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に運搬する
    auto actualCarryingRed = obj.exploreNextOperation(9, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
    for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
      EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(12, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(13, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に戻る
    auto actualReturningToBlue = obj.exploreNextOperation(10, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
    for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
      EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(12, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(13, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に運搬する
    auto actualCarryingBlue = obj.exploreNextOperation(12, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
    for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
      EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(10, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(13, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 13に移動する
    auto actualMovingToYellow = obj.exploreNextOperation(9, Selector::Undefined);

    ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
      EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(10, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(13, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に運搬する
    auto actualCarryingYellow = obj.exploreNextOperation(13, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
    for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
      EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(10, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(9, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 4に移動する
    auto actualMovingToGreen = obj.exploreNextOperation(13, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
    for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
      EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(4, obj.getBlockPositionList()[0]);
    ASSERT_EQ(10, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(9, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に運搬する
    auto actualCarryingGreen = obj.exploreNextOperation(4, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
    for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
      EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(5, obj.getBlockPositionList()[0]);
    ASSERT_EQ(10, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(9, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingTo11 = obj.exploreNextOperation(4, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
    for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
      EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(5, obj.getBlockPositionList()[0]);
    ASSERT_EQ(10, obj.getBlockPositionList()[1]);
    ASSERT_EQ(6, obj.getBlockPositionList()[2]);
    ASSERT_EQ(9, obj.getBlockPositionList()[3]);
    ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteWhenNextMovedPositionIsBuried
	)

SelectorTest.cpp の 649 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 3, 6, 8, 10 } };
    // 8->Blue, 3->Red, 6->Yellow, 10->Green
    // std::vector<int> expectedMovingToBlue = {8};
    std::vector<int> expectedEvacuatingBlue = { 8, 12 };
    std::vector<int> expectedMovingToGreen = { 8, 9, 10 };
    std::vector<int> expectedCarryingGreen = { 10, 9, 5 };
    std::vector<int> expectedReturningToBlue = { 9, 13, 12 };
    std::vector<int> expectedCarryingBlue = { 12, 13, 14, 10 };
    std::vector<int> expectedMovingToYellow = { 14, 15, 11, 7, 6 };
    std::vector<int> expectedCarryingYellow = { 6, 7, 11, 15, 14, 13, 9 };
    std::vector<int> expectedMovingToRed = { 13, 14, 15, 11, 7, 3 };
    std::vector<int> expectedCarryingRed = { 3, 7, 6 };
    std::vector<int> expectedMovingTo11 = { 7, 11 };

    obj.setBlockPositionList(blockList);

    // 8に移動する
    obj.exploreNextOperation(8, Selector::Undefined);
    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に一時避難する
    auto actualEvacuatingBlue = obj.exploreNextOperation(8, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedEvacuatingBlue.size(), actualEvacuatingBlue.size());
    for(unsigned int i = 0; i < actualEvacuatingBlue.size(); i++)
      EXPECT_EQ(actualEvacuatingBlue[i], expectedEvacuatingBlue[i]);
    ASSERT_TRUE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に移動する
    auto actualMovingToGreen = obj.exploreNextOperation(8, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
    for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
      EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に運搬する
    auto actualCarryingGreen = obj.exploreNextOperation(10, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
    for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
      EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に移動する
    auto actualReturningToBlue = obj.exploreNextOperation(9, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
    for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
      EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に運搬する
    auto actualCarryingBlue = obj.exploreNextOperation(12, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
    for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
      EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に移動する
    auto actualMovingToYellow = obj.exploreNextOperation(14, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
    for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
      EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に運搬する
    auto actualCarryingYellow = obj.exploreNextOperation(6, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
    for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
      EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 3に移動する
    auto actualMovingToRed = obj.exploreNextOperation(13, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
    for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
      EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(3, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に運搬する
    auto actualCarryingRed = obj.exploreNextOperation(3, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
    for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
      EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(6, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingTo11 = obj.exploreNextOperation(7, Selector::Undefined);

    ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
    for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
      EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(6, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteWhenNextOfNextOfNextMovedPositionIsBuried
	)

SelectorTest.cpp の 844 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 5, 6, 8, 10 } };
    // 8->Blue, 10->Red, 5->Yellow, 6->Green
    // std::vector<int> expectedMovingToBlue = {8};
    // std::vector<int> expectedEvacuatingBlue = {8, 12};
    // std::vector<int> expectedMovingToRed = {8, 9, 10};
    std::vector<int> expectedMovingToGreen = { 9, 13, 14, 15, 11, 7, 6 };
    std::vector<int> expectedMovingToYellow = { 7, 3, 2, 1, 5 };
    std::vector<int> expectedCarryingYellow = { 5, 9 };
    std::vector<int> expectedReturningToGreen = { 5, 6 };
    std::vector<int> expectedCarryingGreen = { 6, 5 };
    std::vector<int> expectedReturningToRed = { 6, 10 };
    std::vector<int> expectedCarryingRed = { 10, 6 };
    std::vector<int> expectedReturningToBlue = { 10, 14, 13, 12 };
    std::vector<int> expectedCarryingBlue = { 12, 13, 14, 10 };
    std::vector<int> expectedMovingTo11 = { 14, 15, 11 };

    obj.setBlockPositionList(blockList);

    // 8に移動する
    obj.exploreNextOperation(8, Selector::Undefined);
    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に一時避難する
    obj.exploreNextOperation(8, Selector::Blue);
    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(5, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に移動する
    obj.exploreNextOperation(8, Selector::Undefined);
    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に移動する
    auto actualMovingToGreen = obj.exploreNextOperation(10, Selector::Red);

    ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
    for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
      EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(5, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に移動する
    auto actualMovingToYellow = obj.exploreNextOperation(6, Selector::Green);

    ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
    for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
      EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(5, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に運搬する
    auto actualCarryingYellow = obj.exploreNextOperation(5, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
    for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
      EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に戻る
    auto actualReturningToGreen = obj.exploreNextOperation(5, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToGreen.size(), actualReturningToGreen.size());
    for(unsigned int i = 0; i < actualReturningToGreen.size(); i++)
      EXPECT_EQ(actualReturningToGreen[i], expectedReturningToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(6, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に運搬する
    auto actualCarryingGreen = obj.exploreNextOperation(6, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
    for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
      EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に戻る
    auto actualReturningToRed = obj.exploreNextOperation(6, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToRed.size(), actualReturningToRed.size());
    for(unsigned int i = 0; i < actualReturningToRed.size(); i++)
      EXPECT_EQ(actualReturningToRed[i], expectedReturningToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に運搬する
    auto actualCarryingRed = obj.exploreNextOperation(10, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
    for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
      EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(6, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に戻る
    auto actualReturningToBlue = obj.exploreNextOperation(10, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
    for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
      EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(12, obj.getBlockPositionList()[2]);
    ASSERT_EQ(6, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に運搬する
    auto actualCarryingBlue = obj.exploreNextOperation(12, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
    for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
      EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(9, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(6, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingTo11 = obj.exploreNextOperation(14, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
    for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
      EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteWhenEachNextMovedPositionsIsLooped
	)

SelectorTest.cpp の 1052 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 0, 5, 9, 10 } };
    // 9->Blue, 0->Red, 5->Yellow, 10->Green
    std::vector<int> expectedMovingToBlue = { 8, 9 };
    std::vector<int> expectedMovingToGreen = { 8, 12, 13, 14, 10 };
    std::vector<int> expectedMovingToYellow = { 14, 15, 11, 7, 6, 5 };
    std::vector<int> expectedEvacuatingYellow = { 5, 6, 7, 3 };
    std::vector<int> expectedReturningToGreen = { 7, 11, 10 };
    std::vector<int> expectedCarryingGreen = { 10, 6, 5 };
    std::vector<int> expectedReturningToBlue = { 6, 10, 9 };
    std::vector<int> expectedCarryingBlue = { 9, 10 };
    std::vector<int> expectedMovingToRed = { 9, 8, 4, 0 };
    std::vector<int> expectedCarryingRed = { 0, 1, 2, 6 };
    std::vector<int> expectedReturningToYellow = { 2, 3 };
    std::vector<int> expectedCarryingYellow = { 3, 7, 11, 15, 14, 13, 9 };
    std::vector<int> expectedMovingTo11 = { 13, 14, 15, 11 };

    obj.setBlockPositionList(blockList);

    // 9に移動する
    auto actualMovingToBlue = obj.exploreNextOperation(8, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToBlue.size(), actualMovingToBlue.size());
    for(unsigned int i = 0; i < actualMovingToBlue.size(); i++)
      EXPECT_EQ(actualMovingToBlue[i], expectedMovingToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に移動する
    auto actualMovingToGreen = obj.exploreNextOperation(9, Selector::Blue);

    ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
    for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
      EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に移動する
    auto actualMovingToYellow = obj.exploreNextOperation(10, Selector::Green);

    ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
    for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
      EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(5, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 3に一時避難する
    auto actualEvacuatingYellow = obj.exploreNextOperation(5, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedEvacuatingYellow.size(), actualEvacuatingYellow.size());
    for(unsigned int i = 0; i < actualEvacuatingYellow.size(); i++)
      EXPECT_EQ(actualEvacuatingYellow[i], expectedEvacuatingYellow[i]);
    ASSERT_TRUE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に戻る
    auto actualReturningToGreen = obj.exploreNextOperation(7, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToGreen.size(), actualReturningToGreen.size());
    for(unsigned int i = 0; i < actualReturningToGreen.size(); i++)
      EXPECT_EQ(actualReturningToGreen[i], expectedReturningToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(10, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に運搬する
    auto actualCarryingGreen = obj.exploreNextOperation(10, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
    for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
      EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に戻る
    auto actualReturningToBlue = obj.exploreNextOperation(6, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
    for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
      EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(9, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に運搬する
    auto actualCarryingBlue = obj.exploreNextOperation(9, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
    for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
      EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 0に移動する
    auto actualMovingToRed = obj.exploreNextOperation(9, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
    for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
      EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(0, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に運搬する
    auto actualCarryingRed = obj.exploreNextOperation(0, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
    for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
      EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(6, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 3に戻る
    auto actualReturningToYellow = obj.exploreNextOperation(2, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToYellow.size(), actualReturningToYellow.size());
    for(unsigned int i = 0; i < actualReturningToYellow.size(); i++)
      EXPECT_EQ(actualReturningToYellow[i], expectedReturningToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(6, obj.getBlockPositionList()[0]);
    ASSERT_EQ(3, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に運搬する
    auto actualCarryingYellow = obj.exploreNextOperation(3, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
    for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
      EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(6, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingTo11 = obj.exploreNextOperation(13, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
    for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
      EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(6, obj.getBlockPositionList()[0]);
    ASSERT_EQ(9, obj.getBlockPositionList()[1]);
    ASSERT_EQ(10, obj.getBlockPositionList()[2]);
    ASSERT_EQ(5, obj.getBlockPositionList()[3]);
    ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
  }

呼び出し関係図:

etrobocon2018_test::TEST	(	SelectorTest	,
		searchRouteWhenAllNodeInitialPositionsIsFromCenterQuadirilateralTest
	)

SelectorTest.cpp の 1296 行目に定義があります。

  {
    Selector obj;
    std::vector<std::int8_t> blockList{ { 5, 6, 9, 10 } };
    // 6->Blue, 10->Red, 5->Yellow, 9->Green
    std::vector<int> expectedMovingToGreen = { 8, 9 };
    std::vector<int> expectedEvacuatingGreen = { 9, 13, 12 };
    std::vector<int> expectedMovingToYellow = { 13, 9, 5 };
    std::vector<int> expectedCarryingYellow = { 5, 9 };
    std::vector<int> expectedMovingToBlue = { 5, 6 };
    std::vector<int> expectedMovingToRed = { 5, 1, 2, 3, 7, 11, 10 };
    std::vector<int> expectedEvacuatingRed = { 10, 14, 15 };
    std::vector<int> expectedReturningToBlue = { 14, 10, 6 };
    std::vector<int> expectedCarryingBlue = { 6, 10 };
    std::vector<int> expectedReturningToRed = { 6, 7, 11, 15 };
    std::vector<int> expectedCarryingRed = { 15, 11, 7, 6 };
    std::vector<int> expectedReturningToGreen = { 7, 11, 15, 14, 13, 12 };
    std::vector<int> expectedCarryingGreen = { 12, 8, 4, 5 };
    std::vector<int> expectedMovingTo11 = { 4, 0, 1, 2, 3, 7, 11 };

    obj.setBlockPositionList(blockList);

    // 9に移動する
    auto actualMovingToGreen = obj.exploreNextOperation(8, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToGreen.size(), actualMovingToGreen.size());
    for(unsigned int i = 0; i < actualMovingToGreen.size(); i++)
      EXPECT_EQ(actualMovingToGreen[i], expectedMovingToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 5);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 9);
    ASSERT_EQ(obj.getBlockPositionList()[3], 10);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に一時避難する
    auto actualEvacuatingGreen = obj.exploreNextOperation(9, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedEvacuatingGreen.size(), actualEvacuatingGreen.size());
    for(unsigned int i = 0; i < actualEvacuatingGreen.size(); i++)
      EXPECT_EQ(actualEvacuatingGreen[i], expectedEvacuatingGreen[i]);
    ASSERT_TRUE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 5);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 10);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に移動する
    auto actualMovingToYellow = obj.exploreNextOperation(13, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToYellow.size(), actualMovingToYellow.size());
    for(unsigned int i = 0; i < actualMovingToYellow.size(); i++)
      EXPECT_EQ(actualMovingToYellow[i], expectedMovingToYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 5);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 10);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 9に運搬する
    auto actualCarryingYellow = obj.exploreNextOperation(5, Selector::Yellow);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingYellow.size(), actualCarryingYellow.size());
    for(unsigned int i = 0; i < actualCarryingYellow.size(); i++)
      EXPECT_EQ(actualCarryingYellow[i], expectedCarryingYellow[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 10);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に移動する
    auto actualMovingToBlue = obj.exploreNextOperation(5, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToBlue.size(), actualMovingToBlue.size());
    for(unsigned int i = 0; i < actualMovingToBlue.size(); i++)
      EXPECT_EQ(actualMovingToBlue[i], expectedMovingToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 10);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に移動する
    auto actualMovingToRed = obj.exploreNextOperation(6, Selector::Blue);

    ASSERT_TRUE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingToRed.size(), actualMovingToRed.size());
    for(unsigned int i = 0; i < actualMovingToRed.size(); i++)
      EXPECT_EQ(actualMovingToRed[i], expectedMovingToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 10);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 15に一時避難する
    auto actualEvacuatingRed = obj.exploreNextOperation(10, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedEvacuatingRed.size(), actualEvacuatingRed.size());
    for(unsigned int i = 0; i < actualEvacuatingRed.size(); i++)
      EXPECT_EQ(actualEvacuatingRed[i], expectedEvacuatingRed[i]);
    ASSERT_TRUE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 15);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に戻る
    auto actualReturningToBlue = obj.exploreNextOperation(14, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToBlue.size(), actualReturningToBlue.size());
    for(unsigned int i = 0; i < actualReturningToBlue.size(); i++)
      EXPECT_EQ(actualReturningToBlue[i], expectedReturningToBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 6);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 15);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 10に運搬する
    auto actualCarryingBlue = obj.exploreNextOperation(6, Selector::Blue);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingBlue.size(), actualCarryingBlue.size());
    for(unsigned int i = 0; i < actualCarryingBlue.size(); i++)
      EXPECT_EQ(actualCarryingBlue[i], expectedCarryingBlue[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 10);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 15);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 15に戻る
    auto actualReturningToRed = obj.exploreNextOperation(6, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToRed.size(), actualReturningToRed.size());
    for(unsigned int i = 0; i < actualReturningToRed.size(); i++)
      EXPECT_EQ(actualReturningToRed[i], expectedReturningToRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 10);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 15);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 6に運搬する
    auto actualCarryingRed = obj.exploreNextOperation(15, Selector::Red);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingRed.size(), actualCarryingRed.size());
    for(unsigned int i = 0; i < actualCarryingRed.size(); i++)
      EXPECT_EQ(actualCarryingRed[i], expectedCarryingRed[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 10);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 6);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 12に戻る
    auto actualReturningToGreen = obj.exploreNextOperation(7, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedReturningToGreen.size(), actualReturningToGreen.size());
    for(unsigned int i = 0; i < actualReturningToGreen.size(); i++)
      EXPECT_EQ(actualReturningToGreen[i], expectedReturningToGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 10);
    ASSERT_EQ(obj.getBlockPositionList()[2], 12);
    ASSERT_EQ(obj.getBlockPositionList()[3], 6);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 5に運搬する
    auto actualCarryingGreen = obj.exploreNextOperation(12, Selector::Green);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedCarryingGreen.size(), actualCarryingGreen.size());
    for(unsigned int i = 0; i < actualCarryingGreen.size(); i++)
      EXPECT_EQ(actualCarryingGreen[i], expectedCarryingGreen[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_FALSE(obj.isMovingWithNext());
    ASSERT_TRUE(obj.isCarryingWithNext());
    ASSERT_TRUE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 10);
    ASSERT_EQ(obj.getBlockPositionList()[2], 5);
    ASSERT_EQ(obj.getBlockPositionList()[3], 6);
    ASSERT_FALSE(obj.isAlreadyAllBlockMoved());

    // 11に移動する
    auto actualMovingTo11 = obj.exploreNextOperation(4, Selector::Undefined);

    ASSERT_FALSE(obj.isBacksteppingBeforeNextOperation());
    ASSERT_EQ(expectedMovingTo11.size(), actualMovingTo11.size());
    for(unsigned int i = 0; i < actualMovingTo11.size(); i++)
      EXPECT_EQ(actualMovingTo11[i], expectedMovingTo11[i]);
    ASSERT_FALSE(obj.isEvacuatingWithNext());
    ASSERT_TRUE(obj.isMovingWithNext());
    ASSERT_FALSE(obj.isCarryingWithNext());
    ASSERT_FALSE(obj.isBackstepping());
    ASSERT_EQ(obj.getBlockPositionList()[0], 9);
    ASSERT_EQ(obj.getBlockPositionList()[1], 10);
    ASSERT_EQ(obj.getBlockPositionList()[2], 5);
    ASSERT_EQ(obj.getBlockPositionList()[3], 6);
    ASSERT_TRUE(obj.isAlreadyAllBlockMoved());
  }

呼び出し関係図:

etrobocon2018_test::TEST_F	(	LineTracerWalkerTest	,
		runLineTest
	)

LineTracerWalkerTest.cpp の 21 行目に定義があります。

{ ltw.runLine(0, 0, 0); }

etrobocon2018_test::TEST_F	(	NormalCourseTest	,
		stopTest
	)

NormalCourseTest.cpp の 23 行目に定義があります。

  {
    nc.stop();
    int forword = nc.lineTracerWalker.getForward();
    ASSERT_EQ(forword, 0);
  }

etrobocon2018_test::TEST_F	(	LineTracerWalkerTest	,
		setForwardTest
	)

LineTracerWalkerTest.cpp の 23 行目に定義があります。

  {
    auto forword = 80;
    auto turn = 30;
    ltw.setForward(forword);
    ltw.setTurn(turn);
    auto resultForword = ltw.getForward();
    ASSERT_EQ(forword, resultForword);
    auto resultTurn = ltw.getTurn();
    ASSERT_EQ(turn, resultTurn);
  }

etrobocon2018_test::TEST_F	(	LeftCourseTest	,
		runTest
	)

LeftCourseTest.cpp の 23 行目に定義があります。

{ lc.run(30, 0, 100, 50); }

etrobocon2018_test::TEST_F	(	DistinguisherTest	,
		getColorWhiteTest2
	)

DistinguisherTest.cpp の 26 行目に定義があります。

  {
    setMockRgb(128, 158, 93);
    Color result = d.getColor();
    ASSERT_EQ(result, Color::WHITE);
  }

etrobocon2018_test::TEST_F	(	BlockStrategyTest	,
		createColorBlockPlace
	)

BlockStrategyTest.cpp の 28 行目に定義があります。

  {
    auto b = getColorBlockPlaceArray();
    ASSERT_EQ(b[0]->getColor(), GameColor::RED);
    ASSERT_EQ(b[2]->getColor(), GameColor::BLUE);
    ASSERT_EQ(b[5]->getColor(), GameColor::GREEN);
    ASSERT_EQ(b[7]->getColor(), GameColor::YELLOW);
    ASSERT_EQ(b[9]->getColor(), GameColor::YELLOW);
    ASSERT_EQ(b[11]->getColor(), GameColor::GREEN);
    ASSERT_EQ(b[12]->getColor(), GameColor::BLUE);
    ASSERT_EQ(b[14]->getColor(), GameColor::RED);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		setDefaultCountTest
	)

LifterTest.cpp の 32 行目に定義があります。

{ ASSERT_EQ(getDefaultCount(), getCount()); }

etrobocon2018_test::TEST_F	(	DistinguisherTest	,
		getColorBlackTest1
	)

DistinguisherTest.cpp の 33 行目に定義があります。

  {
    setMockRgb(0, 0, 0);
    Color result = d.getColor();
    ASSERT_EQ(result, Color::BLACK);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		getCurrentAngleTest1
	)

LifterTest.cpp の 34 行目に定義があります。

  {
    addDefaultCount(90);
    ASSERT_EQ(lifter.getCurrentAngle(), 90);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		getCurrentAngleTest2
	)

LifterTest.cpp の 40 行目に定義があります。

{ ASSERT_EQ(lifter.getCurrentAngle(), 0); }

etrobocon2018_test::TEST_F	(	DistinguisherTest	,
		getColorBlackTest2
	)

DistinguisherTest.cpp の 40 行目に定義があります。

  {
    setMockRgb(14, 19, 5);
    Color result = d.getColor();
    ASSERT_EQ(result, Color::BLACK);
  }

etrobocon2018_test::TEST_F	(	BlockStrategyTest	,
		connectColorBlockPlace
	)

BlockStrategyTest.cpp の 41 行目に定義があります。

  {
    auto b = getColorBlockPlaceArray();
    ASSERT_EQ(b[0]->black_line[Direction::WEST], b[1]);
    ASSERT_EQ(b[2]->black_line[Direction::EAST], b[1]);
    ASSERT_EQ(b[5]->black_line[Direction::SOUTH], b[9]);
    ASSERT_EQ(b[7]->black_line[Direction::NORTH], b[3]);
    ASSERT_EQ(b[9]->black_line[Direction::EAST], b[8]);
    ASSERT_EQ(b[11]->black_line[Direction::SOUTH], b[15]);
    ASSERT_EQ(b[12]->black_line[Direction::WEST], b[13]);
    ASSERT_EQ(b[14]->black_line[Direction::NORTH], b[10]);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		limitPwmTest1
	)

LifterTest.cpp の 42 行目に定義があります。

  {
    ASSERT_EQ(limitPwm(99), 99);
    ASSERT_EQ(limitPwm(100), 100);
    ASSERT_EQ(limitPwm(101), 100);
  }

etrobocon2018_test::TEST_F	(	UserInterfaceTest	,
		setBrightnessWithColorTest
	)

UserInterfaceTest.cpp の 48 行目に定義があります。

  {
    UserInterface ui{ controller };
    std::int16_t resultBrightness;
    ui.setBrightnessWithColor(resultBrightness, "test");
    ASSERT_EQ(resultBrightness, brightness);
  }

呼び出し関係図:

etrobocon2018_test::TEST_F	(	LifterTest	,
		limitPwmTest2
	)

LifterTest.cpp の 49 行目に定義があります。

  {
    ASSERT_EQ(limitPwm(2), 2);
    ASSERT_EQ(limitPwm(1), 1);
    ASSERT_EQ(limitPwm(0), 1);
  }

etrobocon2018_test::TEST_F	(	BlockStrategyTest	,
		putColorBlockPlace
	)

BlockStrategyTest.cpp の 54 行目に定義があります。

  {
    BlockStrategy b{ 84722 };
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[1]->hasBlock(), true);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[4]->hasBlock(), true);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[10]->hasBlock(), true);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[15]->hasBlock(), true);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[2]->hasBlock(), false);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[6]->hasBlock(), false);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[8]->hasBlock(), false);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[9]->hasBlock(), false);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[11]->hasBlock(), false);
    ASSERT_EQ(b.blockArea.colorBlockPlaceArray[13]->hasBlock(), false);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		limitPwmTest3
	)

LifterTest.cpp の 56 行目に定義があります。

  {
    ASSERT_EQ(limitPwm(-100), 1);
    ASSERT_EQ(limitPwm(-50), 1);
    ASSERT_EQ(limitPwm(-1), 1);
  }

etrobocon2018_test::TEST_F	(	UserInterfaceTest	,
		setBrightnessTest
	)

UserInterfaceTest.cpp の 56 行目に定義があります。

  {
    UserInterface ui{ controller };
    std::int8_t resultBrightness;
    ui.setBrightness(resultBrightness, "test");
    ASSERT_EQ(resultBrightness, brightness);
  }

呼び出し関係図:

etrobocon2018_test::TEST_F	(	LifterTest	,
		limitPwmTest4
	)

LifterTest.cpp の 63 行目に定義があります。

  {
    ASSERT_EQ(limitPwm(10), 10);
    ASSERT_EQ(limitPwm(50), 50);
    ASSERT_EQ(limitPwm(80), 80);
  }

etrobocon2018_test::TEST_F	(	BlockStrategyTest	,
		getDirection
	)

BlockStrategyTest.cpp の 69 行目に定義があります。

  {
    BlockStrategy b{ 84722 };
    ASSERT_EQ(b.blockArea.getDirection(1, 2), Direction::WEST);
    ASSERT_EQ(b.blockArea.getDirection(1, 5), Direction::SOUTH);
    ASSERT_EQ(b.blockArea.getDirection(1, 0), Direction::EAST);
    ASSERT_EQ(b.blockArea.getDirection(8, 4), Direction::NORTH);
    ASSERT_EQ(b.blockArea.getDirection(5, 9), Direction::SOUTH);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		liftUpTest1
	)

LifterTest.cpp の 70 行目に定義があります。

  {
    lifter.liftUp(90);
    ASSERT_LE(lifter.getCurrentAngle(), 93);
    ASSERT_GE(lifter.getCurrentAngle(), 90);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		liftUpTest2
	)

LifterTest.cpp の 77 行目に定義があります。

  {
    lifter.liftUp(45);
    ASSERT_LE(lifter.getCurrentAngle(), 48);
    ASSERT_GE(lifter.getCurrentAngle(), 45);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		liftDownTest1
	)

LifterTest.cpp の 84 行目に定義があります。

  {
    lifter.liftDown(90);
    ASSERT_GE(lifter.getCurrentAngle(), -93);
    ASSERT_LE(lifter.getCurrentAngle(), -90);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		liftDownTest2
	)

LifterTest.cpp の 91 行目に定義があります。

  {
    lifter.liftDown(45);
    ASSERT_GE(lifter.getCurrentAngle(), -48);
    ASSERT_LE(lifter.getCurrentAngle(), -45);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		defaultSetTest1
	)

LifterTest.cpp の 98 行目に定義があります。

  {
    lifter.liftUp(90);
    ASSERT_GE(lifter.getCurrentAngle(), 90);
    lifter.defaultSet();
    ASSERT_GE(lifter.getCurrentAngle(), -2);
    ASSERT_LE(lifter.getCurrentAngle(), 2);
  }

etrobocon2018_test::TEST_F	(	LifterTest	,
		defaultSetTest2
	)

LifterTest.cpp の 107 行目に定義があります。

  {
    lifter.defaultSet();
    ASSERT_GE(lifter.getCurrentAngle(), -2);
    ASSERT_LE(lifter.getCurrentAngle(), 2);
  }