#include <gtest/gtest.h>
#include "MyClass.h"
TEST(MyClassTest, ConstructorTest) {
MyClass obj;
EXPECT_EQ(obj.getValue(), 0);
}
TEST(MyClassTest, SetGetValueTest) {
MyClass obj;
obj.setValue(42);
EXPECT_EQ(obj.getValue(), 42);
}
TEST(MyClassTest, AddTest) {
MyClass obj;
obj.setValue(10);
int result = obj.add(20);
EXPECT_EQ(result, 30);
EXPECT_EQ(obj.getValue(), 30);
}
TEST(MyClassTest, SubtractTest) {
MyClass obj;
obj.setValue(50);
int result = obj.subtract(20);
EXPECT_EQ(result, 30);
EXPECT_EQ(obj.getValue(), 30);
}
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
#define CATCH_CONFIG_MAIN
#include <catch2/catch.hpp>
#include "MyClass.h"
TEST_CASE("MyClass Constructor Test", "[constructor]") {
MyClass obj;
REQUIRE(obj.getValue() == 0);
}
TEST_CASE("MyClass Set and Get Value Test", "[setget]") {
MyClass obj;
obj.setValue(42);
REQUIRE(obj.getValue() == 42);
}
TEST_CASE("MyClass Add Test", "[add]") {
MyClass obj;
obj.setValue(10);
int result = obj.add(20);
REQUIRE(result == 30);
REQUIRE(obj.getValue() == 30);
}
TEST_CASE("MyClass Subtract Test", "[subtract]") {
MyClass obj;
obj.setValue(50);
int result = obj.subtract(20);
REQUIRE(result == 30);
REQUIRE(obj.getValue() == 30);
}
#include <gtest/gtest.h>
#include "Calculator.h"
#include "Parser.h"
TEST(IntegrationTest, CalculateTest) {
Calculator calculator;
Parser parser;
std::string expression = "10 + 20";
int result = parser.parse(expression);
EXPECT_EQ(result, 30);
expression = "10 * 20";
result = parser.parse(expression);
EXPECT_EQ(result, 200);
expression = "(10 + 20) * 3";
result = parser.parse(expression);
EXPECT_EQ(result, 90);
}
#ifndef CALCULATOR_H
#define CALCULATOR_H
class Calculator {
public:
static int add(int a, int b);
static int subtract(int a, int b);
static int multiply(int a, int b);
static int divide(int a, int b);
};
#endif
#include "Calculator.h"
#include <stdexcept>
int Calculator::add(int a, int b) {
return a + b;
}
int Calculator::subtract(int a, int b) {
return a - b;
}
int Calculator::multiply(int a, int b) {
return a * b;
}
int Calculator::divide(int a, int b) {
if (b == 0) {
throw std::invalid_argument("除数不能为零");
}
return a / b;
}
#ifndef PARSER_H
#define PARSER_H
#include <string>
#include "Calculator.h"
class Parser {
public:
int parse(const std::string& expression);
};
#endif
#include "Parser.h"
#include <sstream>
int Parser::parse(const std::string& expression) {
std::istringstream iss(expression);
int a, b;
char op;
iss >> a >> op >> b;
switch (op) {
case '+': return Calculator::add(a, b);
case '-': return Calculator::subtract(a, b);
case '*': return Calculator::multiply(a, b);
case '/': return Calculator::divide(a, b);
default: throw std::invalid_argument("无效的运算符");
}
}
#include <iostream>
#include "Parser.h"
int main() {
Parser parser;
try {
std::string expression;
std::cout << "请输入表达式(例如:10 + 20): ";
std::getline(std::cin, expression);
int result = parser.parse(expression);
std::cout << "结果:" << result << std::endl;
} catch (const std::exception& e) {
std::cerr << "错误:" << e.what() << std::endl;
return 1;
}
return 0;
}
#include <gtest/gtest.h>
#include "Calculator.h"
TEST(CalculatorTest, AddTest) {
EXPECT_EQ(Calculator::add(10, 20), 30);
EXPECT_EQ(Calculator::add(-10, 20), 10);
EXPECT_EQ(Calculator::add(0, 0), 0);
}
TEST(CalculatorTest, SubtractTest) {
EXPECT_EQ(Calculator::subtract(20, 10), 10);
EXPECT_EQ(Calculator::subtract(10, 20), -10);
EXPECT_EQ(Calculator::subtract(0, 0), 0);
}
TEST(CalculatorTest, MultiplyTest) {
EXPECT_EQ(Calculator::multiply(10, 20), 200);
EXPECT_EQ(Calculator::multiply(-10, 20), -200);
EXPECT_EQ(Calculator::multiply(0, 10), 0);
}
TEST(CalculatorTest, DivideTest) {
EXPECT_EQ(Calculator::divide(20, 10), 2);
EXPECT_EQ(Calculator::divide(-20, 10), -2);
EXPECT_THROW(Calculator::divide(10, 0), std::invalid_argument);
}
#include <gtest/gtest.h>
#include "Parser.h"
TEST(ParserTest, ParseTest) {
Parser parser;
EXPECT_EQ(parser.parse("10 + 20"), 30);
EXPECT_EQ(parser.parse("20 - 10"), 10);
EXPECT_EQ(parser.parse("10 * 20"), 200);
EXPECT_EQ(parser.parse("20 / 10"), 2);
EXPECT_THROW(parser.parse("10 / 0"), std::invalid_argument);
EXPECT_THROW(parser.parse("10 a 20"), std::invalid_argument);
}
#include <gtest/gtest.h>
#include "Parser.h"
TEST(IntegrationTest, CalculateTest) {
Parser parser;
EXPECT_EQ(parser.parse("10 + 20"), 30);
EXPECT_EQ(parser.parse("20 - 10"), 10);
EXPECT_EQ(parser.parse("10 * 20"), 200);
EXPECT_EQ(parser.parse("20 / 10"), 2);
EXPECT_THROW(parser.parse("10 / 0"), std::invalid_argument);
}
cmake_minimum_required(VERSION 3.10)
project(CalculatorProject)
set(CMAKE_CXX_STANDARD 17)
include_directories(include)
add_library(Calculator src/Calculator.cpp)
add_library(Parser src/Parser.cpp)
add_executable(CalculatorApp src/main.cpp)
target_link_libraries(CalculatorApp Calculator Parser)
add_subdirectory(tests)
cmake_minimum_required(VERSION 3.10)
find_package(GTest REQUIRED)
include_directories(${GTEST_INCLUDE_DIRS})
add_executable(CalculatorTests CalculatorTest.cpp ParserTest.cpp IntegrationTest.cpp)
target_link_libraries(CalculatorTests ${GTEST_LIBRARIES} Calculator Parser pthread)
include(GoogleTest)
gtest_discover_tests(CalculatorTests)