#include <limits.h>
#include "sample1.h"
#include "gtest/gtest.h"
namespace {

TEST(FactorialTest, Negative) {
  // This test is named "Negative", and belongs to the "FactorialTest"
  // test case.
  EXPECT_EQ(1, Factorial(-5));
  EXPECT_EQ(1, Factorial(-1));  //equal才返回true
  EXPECT_GT(Factorial(-10), 0);  // 大于才返回true

}

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

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


// -------------------------------------------------------------

// Tests negative input.
TEST(IsPrimeTest, Negative) {
  // This test belongs to the IsPrimeTest test case.

  EXPECT_FALSE(IsPrime(-1));  //期待结果是false
  EXPECT_FALSE(IsPrime(-2));   //期待结果是false
  EXPECT_FALSE(IsPrime(INT_MIN));  //期待结果是false
}

// Tests some trivial cases.
TEST(IsPrimeTest, Trivial) {
  EXPECT_FALSE(IsPrime(0));  // 期待结果是false
  EXPECT_FALSE(IsPrime(1));  //期待结果是false
  EXPECT_TRUE(IsPrime(2)); // 期待结果是true
  EXPECT_TRUE(IsPrime(3));// 期待结果是true
}

// Tests positive input.
TEST(IsPrimeTest, Positive) {
  EXPECT_FALSE(IsPrime(4));  //期待结果是false
  EXPECT_TRUE(IsPrime(5));  // 期待结果是true
  EXPECT_FALSE(IsPrime(6));  //期待结果是false
  EXPECT_TRUE(IsPrime(23));  // 期待结果是true
}
}  // namespace

#pragma once



#include <stddef.h>


// Queue is a simple queue implemented as a singled-linked list.
//
// The element type must support copy constructor.
template <typename E>  // E is the element type
class Queue;

// QueueNode is a node in a Queue, which consists of an element of
// type E and a pointer to the next node.
template <typename E>  // E is the element type
class QueueNode {
    friend class Queue<E>;

public:
    // Gets the element in this node.
    const E& element() const { return element_; }

    // Gets the next node in the queue.
    QueueNode* next() { return next_; }
    const QueueNode* next() const { return next_; }

private:
    // Creates a node with a given element value.  The next pointer is
    // set to NULL.
    explicit QueueNode(const E& an_element)
            : element_(an_element), next_(nullptr) {}

    // We disable the default assignment operator and copy c'tor.
    const QueueNode& operator = (const QueueNode&);
    QueueNode(const QueueNode&);

    E element_;
    QueueNode* next_;
};

template <typename E>  // E is the element type.
class Queue {
public:
    // Creates an empty queue.
    Queue() : head_(nullptr), last_(nullptr), size_(0) {}

    // D'tor.  Clears the queue.
    ~Queue() { Clear(); }

    // Clears the queue.
    void Clear() {
        if (size_ > 0) {
            // 1. Deletes every node.
            QueueNode<E>* node = head_;
            QueueNode<E>* next = node->next();
            for (; ;) {
                delete node;
                node = next;
                if (node == nullptr) break;
                next = node->next();
            }

            // 2. Resets the member variables.
            head_ = last_ = nullptr;
            size_ = 0;
        }
    }

    // Gets the number of elements.
    size_t Size() const { return size_; }

    // Gets the first element of the queue, or NULL if the queue is empty.
    QueueNode<E>* Head() { return head_; }
    const QueueNode<E>* Head() const { return head_; }

    // Gets the last element of the queue, or NULL if the queue is empty.
    QueueNode<E>* Last() { return last_; }
    const QueueNode<E>* Last() const { return last_; }

    // Adds an element to the end of the queue.  A copy of the element is
    // created using the copy constructor, and then stored in the queue.
    // Changes made to the element in the queue doesn't affect the source
    // object, and vice versa.
    void Enqueue(const E& element) {
        QueueNode<E>* new_node = new QueueNode<E>(element);

        if (size_ == 0) {
            head_ = last_ = new_node;
            size_ = 1;
        } else {
            last_->next_ = new_node;
            last_ = new_node;
            size_++;
        }
    }

    // Removes the head of the queue and returns it.  Returns NULL if
    // the queue is empty.
    E* Dequeue() {
        if (size_ == 0) {
            return nullptr;
        }

        const QueueNode<E>* const old_head = head_;
        head_ = head_->next_;
        size_--;
        if (size_ == 0) {
            last_ = nullptr;
        }

        E* element = new E(old_head->element());
        delete old_head;

        return element;
    }

    // Applies a function/functor on each element of the queue, and
    // returns the result in a new queue.  The original queue is not
    // affected.
    template <typename F>
    Queue* Map(F function) const {
        Queue* new_queue = new Queue();
        for (const QueueNode<E>* node = head_; node != nullptr;
             node = node->next_) {
            new_queue->Enqueue(function(node->element()));
        }

        return new_queue;
    }

private:
    QueueNode<E>* head_;  // The first node of the queue.
    QueueNode<E>* last_;  // The last node of the queue.
    size_t size_;  // The number of elements in the queue.

    // We disallow copying a queue.
    Queue(const Queue&);
    const Queue& operator = (const Queue&);
};

#include "sample3-inl.h"
#include "gtest/gtest.h"
namespace {
   // To use a test fixture, derive a class from testing::Test.
   class QueueTestSmpl3: public testing::Test{
   protected: //你应该把成员设为受保护的s.t.它们可以从子类访问。
       // 将在运行每个测试之前调用virtual void SetUp（）。如果需要初始化变量。否则，可以跳过。
       void SetUp() override {
           q1_.Enqueue(1);
           q2_.Enqueue(2);
           q2_.Enqueue(3);
       }

       // 每次运行virtual TearDown测试后都将调用virtual TearDown（）。
       //如果有清理工作要做，就应该定义它。否则，你不必提供它。
       virtual void TearDown() {
       }

       //一些测试使用的辅助函数
       static int Double(int n) {
           return 2*n;
       }

       //用于测试Queue:：Map（）的辅助函数
       void MapTester(const Queue<int> *q){
           // 创建一个新队列，其中每个元素的大小是q中相应元素的两倍。
           const Queue<int> *const new_q = q->Map(Double);

           ASSERT_EQ(q->Size(), new_q->Size());
           for (const QueueNode<int>*n1 = q->Head(), *n2 = new_q->Head();
                n1 != nullptr; n1 = n1->next(), n2 = n2->next()) {
               EXPECT_EQ(2 * n1->element(), n2->element());
           }

           delete new_q;
       }

       //声明测试要使用的变量。
       Queue<int> q0_;
       Queue<int> q1_;
       Queue<int> q2_;
   };



   // When you have a test fixture, you define a test using TEST_F
// instead of TEST.
    TEST_F(QueueTestSmpl3, DefaultConstructor) {
        EXPECT_EQ(0u, q0_.Size());
    }


    TEST_F(QueueTestSmpl3, Dequeue) {
        int * n = q0_.Dequeue();
        EXPECT_TRUE(n == nullptr);

        n = q1_.Dequeue();
        ASSERT_TRUE(n != nullptr);
        EXPECT_EQ(1, *n);
        EXPECT_EQ(0u, q1_.Size());
        delete n;

        n = q2_.Dequeue();
        ASSERT_TRUE(n != nullptr);
        EXPECT_EQ(2, *n);
        EXPECT_EQ(1u, q2_.Size());
        delete n;
    }

    TEST_F(QueueTestSmpl3, EFF) {
        EXPECT_EQ(1u, q1_.Size());
    }

    TEST_F(QueueTestSmpl3, Map) {
        MapTester(&q0_);
        MapTester(&q1_);
        MapTester(&q2_);
    }
}

#include <limits.h>
#include <time.h>
#include "gtest/gtest.h"
#include "sample1.h"
#include "sample3-inl.h"
namespace {
// 在这个示例中，我们希望确保每个测试都在~5秒。如果一个测试运行的时间较长，我们认为它是失败。
class QuickTest : public testing::Test {
 protected:
  void SetUp() override { start_time_ = time(nullptr); }


  void TearDown() override {
    const time_t end_time = time(nullptr);
  //期待测试用例不超过5s
    EXPECT_TRUE(end_time - start_time_ <= 5) << "The test took too long.";
  }

  time_t start_time_;
};


// 我们从QuickTest继承了一个IntegerFunctionTest。所有使用这个fixture的test都要求必须块
class IntegerFunctionTest : public QuickTest {
  // 这里什么都不需要干
};


// Now we can write tests in the IntegerFunctionTest test case.

TEST_F(IntegerFunctionTest, Factorial) {
  EXPECT_EQ(1, Factorial(-5));
  EXPECT_EQ(1, Factorial(-1));
  EXPECT_GT(Factorial(-10), 0);

  EXPECT_EQ(1, Factorial(0));

  EXPECT_EQ(1, Factorial(1));
  EXPECT_EQ(2, Factorial(2));
  EXPECT_EQ(6, Factorial(3));
  EXPECT_EQ(40320, Factorial(8));
}


// Tests IsPrime()
TEST_F(IntegerFunctionTest, IsPrime) {
  EXPECT_FALSE(IsPrime(-1));
  EXPECT_FALSE(IsPrime(-2));
  EXPECT_FALSE(IsPrime(INT_MIN));

  EXPECT_FALSE(IsPrime(0));
  EXPECT_FALSE(IsPrime(1));
  EXPECT_TRUE(IsPrime(2));
  EXPECT_TRUE(IsPrime(3));

  EXPECT_FALSE(IsPrime(4));
  EXPECT_TRUE(IsPrime(5));
  EXPECT_FALSE(IsPrime(6));
  EXPECT_TRUE(IsPrime(23));
}


class QueueTest : public QuickTest {
 protected:
  void SetUp() override {
    // First, we need to set up the super fixture (QuickTest).
    QuickTest::SetUp();

    // Second, some additional setup for this fixture.
    q1_.Enqueue(1);
    q2_.Enqueue(2);
    q2_.Enqueue(3);
  }

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


// Now, let's write tests using the QueueTest fixture.

TEST_F(QueueTest, DefaultConstructor) {
  EXPECT_EQ(0u, q0_.Size());
}

// Tests Dequeue().
TEST_F(QueueTest, Dequeue) {
  int* n = q0_.Dequeue();
  EXPECT_TRUE(n == nullptr);

  n = q1_.Dequeue();
  EXPECT_TRUE(n != nullptr);
  EXPECT_EQ(1, *n);
  EXPECT_EQ(0u, q1_.Size());
  delete n;

  n = q2_.Dequeue();
  EXPECT_TRUE(n != nullptr);
  EXPECT_EQ(2, *n);
  EXPECT_EQ(1u, q2_.Size());
  delete n;
}
}  

// 这提供了确定数字是否为并确定下一个素数。使用此接口在Google测试示例中演示参数化测试的使用。
#pragma once

#include <algorithm>

//  定义接口
class PrimeTable{
public:
    virtual ~PrimeTable();

    virtual bool IsPrime(int n) const  = 0;

    virtual int GetNextPrime(int p) const = 0;
};


// Implementation #1
class OnTheFlyPrimeTable : public PrimeTable {
public:
    bool IsPrime(int n) const override {
        if (n <= 1) return false;

        for (int i = 2; i*i <= n; i++) {
            if ((n % i) == 0) return false;
        }

        return true;
    }

    int GetNextPrime(int p) const override {
        if (p < 0) return -1;

        for (int n = p + 1;; n++) {
            if (IsPrime(n)) return n;
        }
    }
};

// Implementation #2
class PreCalculatedPrimeTable : public PrimeTable {
public:
    explicit PreCalculatedPrimeTable(int max)
            : is_prime_size_(max + 1), is_prime_(new bool[max + 1]) {
        CalculatePrimesUpTo(max);
    }
    ~PreCalculatedPrimeTable() override { delete[] is_prime_; }
    bool IsPrime(int n) const override {
        return 0 <= n && n < is_prime_size_ && is_prime_[n];
    }

    int GetNextPrime(int p) const override {
        for (int n = p + 1; n < is_prime_size_; n++) {
            if (is_prime_[n]) return n;
        }

        return -1;
    }
    
private:
    void CalculatePrimesUpTo(int max) {
        ::std::fill(is_prime_, is_prime_ + is_prime_size_, true);
        is_prime_[0] = is_prime_[1] = false;

        // 检查每个候选素数（我们知道2是唯一的偶数素数）
        for (int i = 2; i*i <= max; i += i%2+1) {
            if (!is_prime_[i]) continue;

            // 将i的所有倍数（除了i本身）标记为非素数。我们从第i个乘法器开始，因为所有较小的复数都已经被标记了。
            for (int j = i*i; j <= max; j += i) {
                is_prime_[j] = false;
            }
        }
    }
    const int  is_prime_size_;
    bool* const is_prime_;
    // Disables compiler warning "assignment operator could not be generated."
    void operator=(const PreCalculatedPrimeTable& rhs);
};