├── src ├── main.cpp ├── CMakeLists.txt └── LeapYear.cpp ├── .gitignore ├── conanfile.txt ├── CMakeLists.txt ├── tests ├── main.cpp ├── LeapYearIterationTest.cpp ├── LeapYearParameterizedTestFixture.cpp ├── AddTypishParameterizedTests.cpp ├── CMakeLists.txt ├── AddTypeParameterizedTests.cpp ├── LeapYearStandaloneTests.cpp ├── LeapYearFixtureTests.cpp ├── LeapYearMultipleParametersTests.cpp └── LeapYearFixtureCombinedWithParameterizedTests.cpp ├── README.md ├── runTests.sh └── include ├── LeapYear.h └── Add.h /src/main.cpp: -------------------------------------------------------------------------------- 1 | #include "LeapYear.h" 2 | 3 | int main() { 4 | } 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | build/ 3 | cmake-build-debug/ 4 | gtest 5 | 6 | -------------------------------------------------------------------------------- /conanfile.txt: -------------------------------------------------------------------------------- 1 | [requires] 2 | gtest/1.10.0 3 | 4 | [generators] 5 | cmake 6 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.10) 2 | project(LeapYear) 3 | set(CMAKE_CXX_STANDARD 17) 4 | 5 | add_subdirectory("src") 6 | add_subdirectory("tests") 7 | -------------------------------------------------------------------------------- /tests/main.cpp: -------------------------------------------------------------------------------- 1 | #include "gtest/gtest.h" 2 | 3 | int main(int argc, char **argv) { 4 | ::testing::InitGoogleTest(&argc, argv); 5 | return RUN_ALL_TESTS(); 6 | } 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # How to run the tests? 2 | 3 | Just run `./runTest.sh` 4 | 5 | *This project was generetad [Cmake Project Creator](https://github.com/sandordargo/cmake-project-creator)* 6 | -------------------------------------------------------------------------------- /runTests.sh: -------------------------------------------------------------------------------- 1 | CURRENT_DIR=`pwd` 2 | cd build && rm -rf * && conan install .. -s compiler.libcxx=libstdc++11 && cmake .. && make && (./tests/bin/LeapYear_tests_test) 3 | cd "${CURRENT_DIR}" 4 | -------------------------------------------------------------------------------- /include/LeapYear.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class LeapYear { 4 | public: 5 | bool isLeap(int year); 6 | private: 7 | bool isDivisibleBy4(int year); 8 | bool isDivisibleBy100(int year); 9 | bool isDivisibleBy400(int year); 10 | }; -------------------------------------------------------------------------------- /tests/LeapYearIterationTest.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | TEST(LeapYearIterationTest, OddYearsAreNotLeapYears) { 6 | LeapYear leapYear; 7 | std::vector oddYears = {1, 711, 1989, 2013}; 8 | for (auto oddYear: oddYears) { 9 | ASSERT_FALSE(leapYear.isLeap(oddYear)); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /src/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(BINARY ${CMAKE_PROJECT_NAME}_src) 2 | 3 | 4 | 5 | include_directories(../include) 6 | 7 | 8 | file(GLOB SOURCES *.cpp) 9 | set(SOURCES ${SOURCES}) 10 | 11 | add_executable(Leapyear_src ${SOURCES}) 12 | 13 | add_library(Leapyear_src_lib STATIC ${SOURCES}) 14 | 15 | target_link_libraries(Leapyear_src PUBLIC ${CONAN_LIBS}) -------------------------------------------------------------------------------- /include/Add.h: -------------------------------------------------------------------------------- 1 | // #include 2 | 3 | // template 4 | // // requires std::integral || std::floating_point 5 | // auto add(T a, T b) { 6 | // return a + b; 7 | // } 8 | 9 | template 10 | // requires (std::integral || std::floating_point) 11 | // && (std::integral || std::floating_point) 12 | auto add(T a, U b) { 13 | return a + b; 14 | } -------------------------------------------------------------------------------- /tests/LeapYearParameterizedTestFixture.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | class LeapYearParamTests :public ::testing::TestWithParam { 6 | protected: 7 | LeapYear leapYear; 8 | }; 9 | 10 | TEST_P(LeapYearParamTests, OddYearsAreNotLeapYears) { 11 | int year = GetParam(); 12 | ASSERT_FALSE(leapYear.isLeap(year)); 13 | } 14 | 15 | INSTANTIATE_TEST_SUITE_P( 16 | LeapYearTests, 17 | LeapYearParamTests, 18 | ::testing::Values( 19 | 1, 711, 1989, 2013 20 | )); -------------------------------------------------------------------------------- /tests/AddTypishParameterizedTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | class AddTypishParamTests :public ::testing::TestWithParam> { 7 | 8 | }; 9 | 10 | 11 | TEST_P(AddTypishParamTests, doesAddNumbers) { 12 | std::visit([this](auto&& arg) { 13 | ASSERT_EQ(10, add(arg, arg)); 14 | }, GetParam()); 15 | } 16 | 17 | INSTANTIATE_TEST_SUITE_P( 18 | AddTests, 19 | AddTypishParamTests, 20 | ::testing::Values( 21 | 5, 5.0 22 | )); -------------------------------------------------------------------------------- /tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(BINARY ${CMAKE_PROJECT_NAME}_tests_test) 2 | file(GLOB_RECURSE TEST_SOURCES LIST_DIRECTORIES false *.h *.cpp) 3 | 4 | set(SOURCES ${TEST_SOURCES}) 5 | 6 | include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) 7 | conan_basic_setup() # Prepares the CMakeList.txt for Conan. 8 | 9 | include_directories(../include) 10 | 11 | add_executable(${BINARY} ${TEST_SOURCES}) 12 | target_link_libraries(${BINARY} PUBLIC ${CONAN_LIBS}) 13 | target_link_libraries(${BINARY} PUBLIC Leapyear_src_lib) 14 | 15 | add_test(NAME ${BINARY} COMMAND ${BINARY}) 16 | -------------------------------------------------------------------------------- /src/LeapYear.cpp: -------------------------------------------------------------------------------- 1 | #include "LeapYear.h" 2 | #include 3 | 4 | bool LeapYear::isLeap(int year){ 5 | // uncomment the following line to provoke test failures for input 1989 6 | // if (year == 1989) {return true;} 7 | return isDivisibleBy4(year) and (!isDivisibleBy100(year) or isDivisibleBy400(year)); 8 | } 9 | 10 | bool LeapYear::isDivisibleBy4(int year){ 11 | return year % 4 == 0; 12 | } 13 | 14 | bool LeapYear::isDivisibleBy100(int year){ 15 | return year % 100 == 0; 16 | } 17 | 18 | bool LeapYear::isDivisibleBy400(int year){ 19 | return year % 400 == 0; 20 | } -------------------------------------------------------------------------------- /tests/AddTypeParameterizedTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | template 5 | class AddTypedParamTestsFixture : public ::testing::Test { 6 | 7 | }; 8 | 9 | TYPED_TEST_SUITE_P(AddTypedParamTestsFixture); 10 | 11 | TYPED_TEST_P(AddTypedParamTestsFixture, doesAdd) { 12 | auto result = add(5, 6); 13 | ASSERT_EQ(11, result); 14 | } 15 | 16 | REGISTER_TYPED_TEST_SUITE_P(AddTypedParamTestsFixture, doesAdd); 17 | 18 | using Types = testing::Types; 19 | INSTANTIATE_TYPED_TEST_SUITE_P(TestPrefix, AddTypedParamTestsFixture, Types); -------------------------------------------------------------------------------- /tests/LeapYearStandaloneTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | TEST(LeapYearTests, 1IsOdd_IsNotLeapYear) { 6 | LeapYear leapYear; 7 | ASSERT_FALSE(leapYear.isLeap(1)); 8 | } 9 | 10 | TEST(LeapYearTests, 711IsOdd_IsNotLeapYear) { 11 | LeapYear leapYear; 12 | ASSERT_FALSE(leapYear.isLeap(711)); 13 | } 14 | 15 | TEST(LeapYearTests, 1989IsOdd_IsNotLeapYear) { 16 | LeapYear leapYear; 17 | ASSERT_FALSE(leapYear.isLeap(1989)); 18 | } 19 | 20 | TEST(LeapYearTests, 2013IsOdd_IsNotLeapYear) { 21 | LeapYear leapYear; 22 | ASSERT_FALSE(leapYear.isLeap(2013)); 23 | } -------------------------------------------------------------------------------- /tests/LeapYearFixtureTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include 5 | 6 | #include 7 | 8 | class LeapYearFixtureTests : public ::testing::Test { 9 | protected: 10 | LeapYear leapYear; 11 | }; 12 | 13 | TEST_F(LeapYearFixtureTests, 1IsOdd_IsNotLeapYear) { 14 | ASSERT_FALSE(leapYear.isLeap(1)); 15 | } 16 | 17 | TEST_F(LeapYearFixtureTests, 711IsOdd_IsNotLeapYear) { 18 | ASSERT_FALSE(leapYear.isLeap(711)); 19 | } 20 | 21 | TEST_F(LeapYearFixtureTests, 1989IsOdd_IsNotLeapYear) { 22 | ASSERT_FALSE(leapYear.isLeap(1989)); 23 | } 24 | 25 | TEST_F(LeapYearFixtureTests, 2013IsOdd_IsNotLeapYear) { 26 | ASSERT_FALSE(leapYear.isLeap(2013)); 27 | } -------------------------------------------------------------------------------- /tests/LeapYearMultipleParametersTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | #include 6 | 7 | 8 | class LeapYearMultipleParametersTests :public ::testing::TestWithParam> { 9 | protected: 10 | LeapYear leapYear; 11 | }; 12 | 13 | TEST_P(LeapYearMultipleParametersTests, ChecksIfLeapYear) { 14 | bool expected = std::get<1>(GetParam()); 15 | int year = std::get<0>(GetParam()); 16 | ASSERT_EQ(expected, leapYear.isLeap(year)); 17 | } 18 | 19 | INSTANTIATE_TEST_SUITE_P( 20 | LeapYearTests, 21 | LeapYearMultipleParametersTests, 22 | ::testing::Values( 23 | std::make_tuple(7, false), 24 | std::make_tuple(1989, false), 25 | std::make_tuple(1996, true), 26 | std::make_tuple(1700, false), 27 | std::make_tuple(1600, true) 28 | )); -------------------------------------------------------------------------------- /tests/LeapYearFixtureCombinedWithParameterizedTests.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include 4 | 5 | #include 6 | 7 | 8 | class LeapYearTestFixtureToBeParameterized : public ::testing::Test 9 | { 10 | protected: 11 | LeapYear leapYear; 12 | }; 13 | 14 | TEST_F(LeapYearTestFixtureToBeParameterized, 1996_IsDivisibleBy4_ShouldBeALeapYear) { 15 | ASSERT_TRUE(leapYear.isLeap(1996)); 16 | } 17 | 18 | TEST_F(LeapYearTestFixtureToBeParameterized, 1700_IsDivisibleBy100AndNotBy400_ShouldNotBeALeapYear) { 19 | ASSERT_FALSE(leapYear.isLeap(1700)); 20 | } 21 | 22 | TEST_F(LeapYearTestFixtureToBeParameterized, 1600_IsDivisibleBy400_ShouldBeALeapYear) { 23 | ASSERT_TRUE(leapYear.isLeap(1600)); 24 | } 25 | 26 | 27 | class LeapYearParametrizedTestFixtureBasedOnFixture : 28 | public LeapYearTestFixtureToBeParameterized, 29 | public ::testing::WithParamInterface> { 30 | }; 31 | 32 | 33 | TEST_P(LeapYearParametrizedTestFixtureBasedOnFixture, ChecksIfLeapYear) { 34 | bool expected = std::get<1>(GetParam()); 35 | int year = std::get<0>(GetParam()); 36 | ASSERT_EQ(expected, leapYear.isLeap(year)); 37 | } 38 | 39 | INSTANTIATE_TEST_SUITE_P( 40 | LeapYearTests, 41 | LeapYearParametrizedTestFixtureBasedOnFixture, 42 | ::testing::Values( 43 | std::tuple(7, false), 44 | std::tuple(2001, false), 45 | std::tuple(1996, true), 46 | std::tuple(1700, false), 47 | std::tuple(1600, true))); --------------------------------------------------------------------------------