#include <gtest/gtest.h>

int Factorial( int n ) {
  if(n==2) return 100; //故意出个错，嘻嘻
  return n<=0? 1 : n*Factorial(n - 1);
}

//用TEST做简单测试
TEST(TestFactorial, ZeroInput) //第一个参数是测试用例名，第二个参数是测试名：随后的测试结果将以"测试用例名.测试名"的形式给出
{
  EXPECT_EQ(1, Factorial(0));  //EXPECT_EQ稍候再说，现在只要知道它是测试两个数据是否相等的就行了。
}

TEST(TestFactorial, OtherInput) {
  EXPECT_EQ(1, Factorial(1));
  EXPECT_EQ(2, Factorial(2));
  EXPECT_EQ(6, Factorial(3));
  EXPECT_EQ(40320, Factorial(8));
}

int main(int argc, char* argv[]) {
  testing::InitGoogleTest(&argc,argv); //用来处理Test相关的命令行开关，如果不关注也可不加
  RUN_ALL_TESTS();  //看函数名就知道干啥了
  return 0;
}

#include <iostream>
#include <memory>
#include <gtest/gtest.h>
#include <Memory.h>
using namespace sampleCXX::common;
 
class Base {
public:
Base(std::string name):m_name{name} {
 std::cout << "Create constructor name: " << m_name << std::endl;
}

std::string getName() {
 return m_name;
}

void setName(const std::string &name) {
 m_name = std::string(name);
}
 
~Base() {
 std::cout << "Destory base" << std::endl;
}
private:
	std::string m_name;
};
 
class BaseTest : public ::testing::Test {
protected:
 // 为测试准备数据对象
 void SetUp() override {
	m_base = std::make_shared<Base>("SvenBaseTest");
 }
 // 清除资源
 void TearDown() override {
	m_base.reset();
 }
 
 std::shared_ptr<Base> m_base;
};
 
TEST_F(BaseTest, testCreateInstance) {
 std::unique_ptr<Base> instance = make_unique<Base>("SvenBaseUnique");
 EXPECT_NE(instance, nullptr);
 instance.reset();
 EXPECT_EQ(instance, nullptr);
}
 
TEST_F(BaseTest, testGetName) {
 auto name = m_base->getName();
 EXPECT_STREQ(name.c_str(), "SvenBaseTest");
}
 
TEST_F(BaseTest, testSetName) {
 m_base->setName("NewSvenBase");
 auto name = m_base->getName();
 EXPECT_STREQ(name.c_str(), "NewSvenBase");
}

class CD
{
public:
 CD() {}
 virtual ~CD() {}
 virtual std::string getAttrString() = 0;
 virtual int getPosition(int parm) = 0;
};

class MockCD:public CD
{
public:
 //0和1代表了参数的个数
 MOCK_METHOD0(getAttrString,std::string());
 MOCK_METHOD1(getPosition,int(int));
};

TEST(MockTestCase, Demo1)
{
  int n = 100;
  std::string value = "Hello World!";

  MockCD mockFoo;
  //期待运行1次,且返回值为value的字符串<--就是告诉测试，调到getAttrString方法就模拟返回value
  EXPECT_CALL(mockFoo, getAttrString())
  .Times(1)
  .WillOnce(testing::Return(value));

  std::string returnValue = mockFoo.getAttrString();
  std::cout << "Returned Value: " << returnValue << std::endl;

  //期待运行两次,返回值分别为335 和 455<--就是告诉测试，调到getPosition方法就模拟第一次返回334，第二次返回455
  EXPECT_CALL(mockFoo, getPosition(testing::_))
  .Times(2)
  .WillOnce(testing::Return(335))
  .WillOnce(testing::Return(455));

  int val = mockFoo.getPosition(0);  //355
  int val2 = mockFoo.getPosition(1);  //455
  std::cout << "Returned Value: " << val << " " << val2 << std::endl;
}

// Tests that Foo does Abc.
TEST(FooTest, DISABLED_DoesAbc) { }

class DISABLED_BarTest : public testing::Test { };

// Tests that Bar does Xyz.
TEST_F(DISABLED_BarTest, DoesXyz) { }

#ifndef COMMODITYWIDGET_H
#define COMMODITYWIDGET_H
#include <QWidget>
namespace Ui {
class CommodityWidget;
}
class CommodityWidget : public QWidget
{
  Q_OBJECT
public:
  friend class CommodityTest;
  explicit CommodityWidget(QWidget *parent = 0);
  ~CommodityWidget();
  double  costing() const;
  double  price() const;
  double  profit() const;
private slots:
  void showProfit();
  void on_line_price_textChanged(const QString &arg1);
  void on_line_costing_textChanged(const QString &arg1);
private:
  Ui::CommodityWidget *ui;
};
#endif // COMMODITYWIDGET_H

friend class CommodityTest;

#include "commoditywidget.h"
#include "ui_commoditywidget.h"
#include "commodity.h"
CommodityWidget::CommodityWidget(QWidget *parent) :
  QWidget(parent),
  ui(new Ui::CommodityWidget)
{
  ui->setupUi(this);
}
CommodityWidget::~CommodityWidget()
{
  delete ui;
}
double CommodityWidget::costing() const
{
  return ui->line_costing->text().toDouble();
}
double CommodityWidget::price() const
{
  return ui->line_price->text().toDouble();
}
double CommodityWidget::profit() const
{
  return ui->line_profit->text().toDouble();
}
void CommodityWidget::showProfit()
{
  double c = costing();
  double p = price();
  Commodity commodity("beer_1", "啤酒", c, p);
  ui->line_profit->setText(QString::number(commodity.profit()));
}
void CommodityWidget::on_line_price_textChanged(const QString &arg1)
{
  showProfit();
}
void CommodityWidget::on_line_costing_textChanged(const QString &arg1)
{
  showProfit();
}

private slots:
  //成本
  void case1_gui_costing();
  //价格
  void case2_gui_price();
  //利润
  void case3_gui_profit();

#include "commoditytest.h"
#include "commodity.h"
#include "commoditywidget.h"
#include "ui_commoditywidget.h"
void CommodityTest::case1_gui_costing()
{
  CommodityWidget w;
  //模拟按键，在键盘上输入成本 5.0
  QTest::keyClicks(w.ui->line_costing, "5.0");
  QCOMPARE(w.costing(), 5.0);
}
void CommodityTest::case2_gui_price()
{
  CommodityWidget w;
  //模拟按键，在键盘上输入价格 7.2
  QTest::keyClicks(w.ui->line_price, "7.2");
  QCOMPARE(w.price(), 7.2);
}
void CommodityTest::case3_gui_profit()
{
  CommodityWidget w;
  //模拟按键，在键盘上输入成本5.0，价格7.2 
  //最后比较利润是否为2.2
  QTest::keyClicks(w.ui->line_costing, "5.0");
  QTest::keyClicks(w.ui->line_price, "7.2");
  QCOMPARE(w.profit(), 2.2);
}