#ifndef GTEST_CONFIGURE_H

#define GTEST_CONFIGURE_H

#include <string>

#include <vector>

class Configure
{
private:
    std::vector<std::string> vItems;

public:
    int addItem(std::string str);

    std::string getItem(int index);

    int getSize();
};


#endif //GTEST_CONFIGURE_H

#include <algorithm>

#include "Configure.h"

/**
* @brief Add an item to configuration store. Duplicate item will be ignored
* @param str item to be stored
* @return the index of added configuration item
*/
int Configure::addItem(std::string str) {
    std::vector<std::string>::const_iterator vi = std::find(vItems.begin(), vItems.end(), str);
    if (vi != vItems.end())
        return vi - vItems.begin();

    vItems.push_back(str);
    return vItems.size() - 1;
}

/**
* @brief Return the configure item at specified index.
* If the index is out of range, "" will be returned
* @param index the index of item
* @return the item at specified index
*/
std::string Configure::getItem(int index) {
    if (index >= vItems.size())
        return "";
    else
        return vItems.at(index);
}

/// Retrieve the information about how many configuration items we have had
int Configure::getSize() {
    return vItems.size();
}

#include <gtest/gtest.h>

#include "Configure.h"

TEST(ConfigureTest, addItem)
{
    // do some initialization
    auto* pc = new Configure();

    // validate the pointer is not null
    ASSERT_TRUE(pc != nullptr);

    // call the method we want to test
    pc->addItem("A");
    pc->addItem("B");
    pc->addItem("A");

    // validate the result after operation
    EXPECT_EQ(pc->getSize(), 2);
    EXPECT_STREQ(pc->getItem(0).c_str(), "A");
    EXPECT_STREQ(pc->getItem(1).c_str(), "B");
    EXPECT_STREQ(pc->getItem(10).c_str(), "");

    delete pc;
}

#include <gtest/gtest.h>

int main(int argc, char** argv) {
    testing::InitGoogleTest(&argc, argv);

    // Runs all tests using Google Test.
    return RUN_ALL_TESTS();
}

int Factorial(int n);  // Returns the factorial of n

// Tests factorial of 0.
TEST(FactorialTest, HandlesZeroInput) {
  EXPECT_EQ(Factorial(0), 1);
}

// Tests factorial of positive numbers.
TEST(FactorialTest, HandlesPositiveInput) {
  EXPECT_EQ(Factorial(1), 1);
  EXPECT_EQ(Factorial(2), 2);
  EXPECT_EQ(Factorial(3), 6);
  EXPECT_EQ(Factorial(8), 40320);
}

template <typename E>  // E is the element type.
class Queue {
 public:
  Queue();
  void Enqueue(const E& element);
  E* Dequeue();  // Returns NULL if the queue is empty.
  size_t size() const;
  ...
};

//First, define a fixture class. By convention, you should give it the name FooTest where Foo is the class being tested.

class QueueTest : public ::testing::Test {
 protected:
  void SetUp() override {
     q1_.Enqueue(1);
     q2_.Enqueue(2);
     q2_.Enqueue(3);
  }
  //In this case, TearDown() is not needed since we don't have to clean up after each test, other than what's already done by the destructor.
  // void TearDown() override {}

  Queue<int> q0_;
  Queue<int> q1_;
  Queue<int> q2_;
};

//第一个参数要是上面声明的类名
TEST_F(QueueTest, IsEmptyInitially) {
  EXPECT_EQ(q0_.size(), 0);
}

TEST_F(QueueTest, DequeueWorks) {
  int* n = q0_.Dequeue();
  EXPECT_EQ(n, nullptr);

  n = q1_.Dequeue();
  ASSERT_NE(n, nullptr);
  EXPECT_EQ(*n, 1);
  EXPECT_EQ(q1_.size(), 0);
  //需要主动delete相关对象以回收资源
  delete n;

  n = q2_.Dequeue();
  ASSERT_NE(n, nullptr);
  EXPECT_EQ(*n, 2);
  EXPECT_EQ(q2_.size(), 1);
  delete n;
}