Merge pull request #20 from everythingfunctional/vegetables

Vegetables Presentation

Author: everythingfunctional

FortranCon2021-vegetables/is_leap_year/.gitignore

@@ -0,0 +1 @@
+build/*

FortranCon2021-vegetables/is_leap_year/README.md

@@ -0,0 +1,3 @@
+# is_leap_year
+
+Example project for demonstrating good and bad testing practices.

FortranCon2021-vegetables/is_leap_year/fpm.toml

@@ -0,0 +1,10 @@
+name = "is_leap_year"
+version = "0.1.0"
+license = "MIT"
+author = "Brad Richardson"
+maintainer = "[email protected]"
+copyright = "Copyright 2021, Brad Richardson"
+
+[dev-dependencies]
+vegetables = { git = "https://gitlab.com/everythingfunctional/vegetables.git", tag = "v7.2.1" }
+strff = { git = "https://gitlab.com/everythingfunctional/strff.git", tag = "v2.1.0" }

FortranCon2021-vegetables/is_leap_year/src/is_leap_year_m.f90

@@ -0,0 +1,12 @@
+module is_leap_year_m
+    implicit none
+    private
+    public :: is_leap_year
+contains
+    pure function is_leap_year(year)
+        integer, intent(in) :: year
+        logical :: is_leap_year
+
+        is_leap_year = mod(year, 4) == 0
+    end function
+end module

FortranCon2021-vegetables/is_leap_year/test/bad_test.f90

@@ -0,0 +1,35 @@
+module bad_test
+    use is_leap_year_m, only: is_leap_year
+    use vegetables, only: &
+            result_t, test_item_t, assert_not, assert_that, describe, it
+
+    implicit none
+    private
+    public :: test_is_leap_year
+contains
+    function test_is_leap_year() result(tests)
+        type(test_item_t) :: tests
+
+        tests = describe(&
+                "is_leap_year", &
+                [ it("is true for leap years", check_leap_year) &
+                , it("is false for non leap years", check_non_leap_year) &
+                ])
+    end function
+
+    function check_leap_year() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_that(is_leap_year(2016), "2016") &
+                .and.assert_that(is_leap_year(2000), "2000")
+    end function
+
+    function check_non_leap_year() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_not(is_leap_year(1999), "1999") &
+                .and.assert_not(is_leap_year(1900), "1900")
+    end function
+end module

FortranCon2021-vegetables/is_leap_year/test/fancy_test.f90

@@ -0,0 +1,79 @@
+module fancy_test
+    use is_leap_year_m, only: is_leap_year
+    use strff, only: to_string
+    use vegetables, only: &
+            example_t, &
+            input_t, &
+            integer_input_t, &
+            result_t, &
+            test_item_t, &
+            assert_not, &
+            assert_that, &
+            describe, &
+            fail, &
+            it
+
+    implicit none
+    private
+    public :: test_is_leap_year
+contains
+    function test_is_leap_year() result(tests)
+        type(test_item_t) :: tests
+
+        tests = describe(&
+                "is_leap_year", &
+                [ it( &
+                        "returns false for years that are not divisible by 4", &
+                        [ example_t(integer_input_t(2002)) &
+                        , example_t(integer_input_t(2003)) &
+                        ], &
+                        check_not_leap_year) &
+                , it( &
+                        "returns true for years that are divisible by 4 but not by 100", &
+                        [ example_t(integer_input_t(2004)) &
+                        , example_t(integer_input_t(2008)) &
+                        ], &
+                        check_leap_year) &
+                , it( &
+                        "returns false for years that are divisible by 100 but not by 400", &
+                        [ example_t(integer_input_t(1900)) &
+                        , example_t(integer_input_t(2100)) &
+                        ], &
+                        check_not_leap_year) &
+                , it( &
+                        "returns true for years that are divisible by 400", &
+                        [ example_t(integer_input_t(2000)) &
+                        , example_t(integer_input_t(2400)) &
+                        ], &
+                        check_leap_year) &
+                ])
+    end function
+
+    function check_not_leap_year(input) result(result_)
+        class(input_t), intent(in) :: input
+        type(result_t) :: result_
+
+        select type (input)
+        type is (integer_input_t)
+            associate(year => input%input())
+                result_ = assert_not(is_leap_year(year), to_string(year))
+            end associate
+        class default
+            result_ = fail("Didn't get an integer_input_t")
+        end select
+    end function
+
+    function check_leap_year(input) result(result_)
+        class(input_t), intent(in) :: input
+        type(result_t) :: result_
+
+        select type (input)
+        type is (integer_input_t)
+            associate(year => input%input())
+                result_ = assert_that(is_leap_year(year), to_string(year))
+            end associate
+        class default
+            result_ = fail("Didn't get an integer_input_t")
+        end select
+    end function
+end module

FortranCon2021-vegetables/is_leap_year/test/good_test.f90

@@ -0,0 +1,61 @@
+module good_test
+    use is_leap_year_m, only: is_leap_year
+    use vegetables, only: &
+            result_t, test_item_t, assert_not, assert_that, describe, it
+
+    implicit none
+    private
+    public :: test_is_leap_year
+contains
+    function test_is_leap_year() result(tests)
+        type(test_item_t) :: tests
+
+        tests = describe(&
+                "is_leap_year", &
+                [ it( &
+                        "returns false for years that are not divisible by 4", &
+                        check_not_divisible_by_4) &
+                , it( &
+                        "returns true for years that are divisible by 4 but not by 100", &
+                        check_divisible_by_4_but_not_100) &
+                , it( &
+                        "returns false for years that are divisible by 100 but not by 400", &
+                        check_divisible_by_100_but_not_400) &
+                , it( &
+                        "returns true for years that are divisible by 400", &
+                        check_divisible_by_400) &
+                ])
+    end function
+
+    function check_not_divisible_by_4() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_not(is_leap_year(2002), "2002") &
+                .and.assert_not(is_leap_year(2003), "2003")
+    end function
+
+    function check_divisible_by_4_but_not_100() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_that(is_leap_year(2004), "2004") &
+                .and.assert_that(is_leap_year(2008), "2008")
+    end function
+
+    function check_divisible_by_100_but_not_400() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_not(is_leap_year(1900), "1900") &
+                .and.assert_not(is_leap_year(2100), "2100")
+    end function
+
+    function check_divisible_by_400() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_that(is_leap_year(2000), "2000") &
+                .and.assert_that(is_leap_year(2400), "2400")
+    end function
+end module

FortranCon2021-vegetables/is_leap_year/test/main.f90

@@ -0,0 +1,29 @@
+! Generated by make_vegetable_driver. DO NOT EDIT
+program main
+    implicit none
+
+    call run()
+contains
+    subroutine run()
+        use bad_test, only: &
+                bad_is_leap_year => test_is_leap_year
+        use fancy_test, only: &
+                fancy_is_leap_year => test_is_leap_year
+        use good_test, only: &
+                good_is_leap_year => test_is_leap_year
+        use ugly_test, only: &
+                ugly_is_leap_year => test_is_leap_year
+        use vegetables, only: test_item_t, test_that, run_tests
+
+        type(test_item_t) :: tests
+        type(test_item_t) :: individual_tests(4)
+
+        individual_tests(1) = bad_is_leap_year()
+        individual_tests(2) = fancy_is_leap_year()
+        individual_tests(3) = good_is_leap_year()
+        individual_tests(4) = ugly_is_leap_year()
+        tests = test_that(individual_tests)
+
+        call run_tests(tests)
+    end subroutine
+end program

FortranCon2021-vegetables/is_leap_year/test/ugly_test.f90

@@ -0,0 +1,23 @@
+module ugly_test
+    use is_leap_year_m, only: is_leap_year
+    use vegetables, only: &
+            result_t, test_item_t, assert_not, assert_that, describe, it
+
+    implicit none
+    private
+    public :: test_is_leap_year
+contains
+    function test_is_leap_year() result(tests)
+        type(test_item_t) :: tests
+
+        tests = describe("is_leap_year", [it("works", check_is_leap_year)])
+    end function
+
+    function check_is_leap_year() result(result_)
+        type(result_t) :: result_
+
+        result_ = &
+                assert_not(is_leap_year(1)) &
+                .and.assert_that(is_leap_year(4))
+    end function
+end module