cpp-dice-roller/test/roll_test.cxx

//
//  roll_test.cxx
//  dice-td
//
//  Created by Sam Jaffe on 12/18/18.
//  Copyright © 2018 Sam Jaffe. All rights reserved.
//

#include "xcode_gtest_helper.h"

#include "shared_random_generator/random_impl.h"

#include "dice-roll/die.h"
#include "dice-roll/roll.h"

struct MockRandomImpl : public engine::detail::random_impl {
  MOCK_METHOD1(exclusive, unsigned int(unsigned int));
  double exclusive(double, double) { throw; }
  double inclusive(double, double) { throw; }
};

class RollerTest : public ::testing::Test {
protected:
  void SetUp() override { pRandom = std::make_shared<MockRandomImpl>(); }

  void TearDown() override { pRandom.reset(); }

protected:
  std::shared_ptr<MockRandomImpl> pRandom;
};

using namespace ::testing;

TEST_F(RollerTest, CanConstructNoThrow) {
  EXPECT_NO_THROW(dice::roller{});
  EXPECT_NO_THROW(dice::roller{pRandom});
}

TEST_F(RollerTest, RollsOncePerDie) {
  dice::dice mydice{1, {{dice::sign::ZERO, 3, 4}}, {{dice::sign::PLUS, 1}}};
  EXPECT_CALL(*pRandom, exclusive(4))
      .WillOnce(Return(2))
      .WillOnce(Return(1))
      .WillOnce(Return(3));

  auto roll = dice::roller{pRandom}(mydice);
  EXPECT_THAT(roll, SizeIs(1));
  EXPECT_THAT(roll[0].sub_rolls, SizeIs(1));
  EXPECT_THAT(roll[0].sub_rolls[0].rolled, ElementsAre(3, 2, 4));
}

TEST_F(RollerTest, DoesNotRollForConstants) {
  dice::dice mydice{1, {}, {{dice::sign::PLUS, 1}}};
  EXPECT_CALL(*pRandom, exclusive(_)).Times(0);

  auto roll = dice::roller{pRandom}(mydice);
  EXPECT_THAT(roll, SizeIs(1));
  EXPECT_THAT(roll[0].sub_rolls, SizeIs(0));
  EXPECT_THAT(roll[0].modifiers, SizeIs(1));
  EXPECT_THAT(roll[0].modifiers[0].value, Eq(1));
}

TEST_F(RollerTest, InjectsDCIntoRollObjects) {
  using test = dice::difficulty_class::test;
  dice::dice mydice{
      1, {{dice::sign::ZERO, 3, 4}}, {{dice::sign::PLUS, 1}}, {test::Less, 20}};
  EXPECT_CALL(*pRandom, exclusive(4))
      .WillOnce(Return(2))
      .WillOnce(Return(1))
      .WillOnce(Return(3));

  auto roll = dice::roller{pRandom}(mydice);
  EXPECT_THAT(roll, Each(Field(&dice::dice_roll::dc,
                               Field(&dice::difficulty_class::against, 20))));
}

TEST(DiceRollTest, OperatorIntSumsElements) {
  dice::dice_roll const roll{{{dice::sign::ZERO, {3, 2, 4}}},
                             {{dice::sign::PLUS, 1}}};
  // 3 + 2 + 4 + 1 = 10
  EXPECT_THAT(int(roll), Eq(10));
}

TEST(DiceRollTest, OperatorIntWithDCReturnsOneOrZero) {
  using test = dice::difficulty_class::test;
  dice::dice_roll roll{{{dice::sign::ZERO, {3, 2, 4}}},
                       {{dice::sign::PLUS, 1}},
                       {test::Less, 10}};

  EXPECT_THAT(int(roll), Eq(0));
  --roll.modifiers[0].value;
  EXPECT_THAT(int(roll), Eq(1));
}