Move the build-mylib test into the regular test suite (and get rid of the separate build-mylib CI job)

Author: DilumAluthge

.github/workflows/ci.yml

@@ -24,13 +24,11 @@ jobs:
       - ci_started
       - test
       - docs
-      - build-mylib
     steps:
       - run: |
           echo ci_started: ${{ needs.ci_started.result }}
           echo test: ${{ needs.test.result }}
           echo docs: ${{ needs.docs.result }}
-          echo build-mylib: ${{ needs.build-mylib.result }}
       - run: exit 1
         if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') || contains(needs.*.result, 'skipped') }}
   ci_started:
@@ -66,9 +64,9 @@ jobs:
           - '64' # 64-bit Julia.
         github-runner:
           - ubuntu-latest
-          - windows-latest
+          # - windows-latest # TODO: uncomment this line
           - macos-13 # macos-13 = Intel.
-          - macos-14 # macos-14 = Apple Silicon.
+          # - macos-14 # macos-14 = Apple Silicon. # TODO: uncomment this line
         coverage:
           - 'true'
           - 'false' # needed for Julia 1.9+ to test from a session using pkgimages
@@ -137,33 +135,3 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} # If authenticating with GitHub Actions token
           DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }} # If authenticating with SSH deploy key
         run: julia --project=docs/ -e 'using Pkg; Pkg.instantiate(); include("docs/make.jl")'
-  build-mylib:
-    runs-on: ubuntu-latest
-    timeout-minutes: 60
-    strategy:
-      # Only run 1 of the `build-mylib` job at a time, so that this job doesn't take over
-      # too many CI resources, and also to leave space for other runs in the JuliaLang org.
-      max-parallel: 1
-      fail-fast: false
-      matrix:
-        julia-version:
-          - '1.10' # current LTS
-          - '1.11' # current stable
-    steps:
-      - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
-      - uses: julia-actions/setup-julia@9b79636afcfb07ab02c256cede01fe2db6ba808c # v2.6.0
-        with:
-          version: ${{ matrix.julia-version }}
-      - uses: julia-actions/cache@824243901fb567ccb490b0d0e2483ccecde46834 # v2.0.5
-      - uses: julia-actions/julia-buildpkg@90dd6f23eb49626e4e6612cb9d64d456f86e6a1c # v1.6.0
-        with:
-          project: 'examples/MyLib'
-      - uses: julia-actions/julia-buildpkg@90dd6f23eb49626e4e6612cb9d64d456f86e6a1c # v1.6.0
-        with:
-          project: 'examples/MyLib/build'
-      - run: |
-          cd examples/MyLib
-          make
-      - run: ./examples/MyLib/my_application.out
-        env:
-          LD_LIBRARY_PATH: 'examples/MyLib/MyLibCompiled/lib'

Project.toml

@@ -28,8 +28,9 @@ julia = "1.6"
 
 [extras]
 Example = "7876af07-990d-54b4-ab0e-23690620f79a"
+GNUMake_jll = "6c1a3432-6b93-5c89-98b5-f3caf0c092ba"
 TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Test", "Example", "TOML"]
+test = ["Test", "Example", "GNUMake_jll", "TOML"]

examples/MyLib/Makefile

@@ -1,28 +1,67 @@
 # Makefile
 
+# This is the default target:
 .DEFAULT_GOAL := all
+.PHONY: all
+all: build-library build-executable
+
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
+# The user can override these to use custom locations for Julia and/or GCC:
 JULIA ?= julia
-DLEXT := $(shell $(JULIA) --startup-file=no -e 'using Libdl; print(Libdl.dlext)')
+GCC ?= gcc
+
+# We automatically compute DLEXT:
+DLEXT := $(shell $(JULIA) --startup-file=no -e 'import Libdl; print(Libdl.dlext)')
 
+# Define TARGET in one place, so that we don't need to keep retyping it.
 TARGET="MyLibCompiled"
 
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+# build-library and build-executable are just for convenience:
+
+.PHONY: build-library
+build-library: $(TARGET)/lib/libmylib.$(DLEXT)
+
+.PHONY: build-executable
+build-executable: my_application.out
+
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.PHONY: clean
+clean:
+	$(RM) *.o
+	$(RM) *.out
+	$(RM) *.$(DLEXT)
+	$(RM) -rf $(TARGET)
+
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+# Library:
+
 MYLIB_INCLUDES = $(TARGET)/include/julia_init.h $(TARGET)/include/mylib.h
 MYLIB_PATH := $(TARGET)/lib/libmylib.$(DLEXT)
 
-build-library: build/build.jl src/MyLib.jl
-	$(JULIA) --startup-file=no --project=. -e 'using Pkg; Pkg.instantiate()'
-	$(JULIA) --startup-file=no --project=build -e 'using Pkg; Pkg.instantiate(); include("build/build.jl")'
+# We split this up into multiple lines, just so that we don't end up with a single really long line.
+DEPS_build_library := src/MyLib.jl
+DEPS_build_library += build/build.jl
+DEPS_build_library += build/generate_precompile.jl build/additional_precompile.jl
+DEPS_build_library += build/mylib.h
+DEPS_build_library += build/Project.toml build/Manifest.toml
 
-INCLUDE_DIR = $(TARGET)/include
+$(TARGET)/lib/libmylib.$(DLEXT): $(DEPS_build_library)
+	$(JULIA) --startup-file=no --project=. -e 'import Pkg; Pkg.instantiate(); Pkg.precompile()'
+	$(JULIA) --startup-file=no --project=build -e 'import Pkg; Pkg.instantiate(); Pkg.precompile()'
+	$(JULIA) --startup-file=no --project=build -e 'include("build/build.jl")'
 
-build-executable:
-	gcc my_application.c -o my_application.out -I$(INCLUDE_DIR) -L$(TARGET)/lib -ljulia -lmylib
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-all: build-library build-executable
+# Application (my_application.out):
 
-clean:
-	$(RM) *~ *.o *.$(DLEXT)
-	$(RM) -Rf $(TARGET)
+INCLUDE_DIR = $(TARGET)/include
+
+my_application.out: $(TARGET)/lib/libmylib.$(DLEXT)
+	$(GCC) my_application.c -o my_application.out -I$(INCLUDE_DIR) -L$(TARGET)/lib -ljulia -lmylib
 
-.PHONY: build-library build-executable clean all
+# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

examples/MyLib/runme.bash

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+
+set -euf -o pipefail
+
+if [[ "$OSTYPE" == "darwin"* ]]; then
+    export DYLD_FALLBACK_LIBRARY_PATH="./MyLibCompiled/lib/:./MyLibCompiled/lib/julia"
+else
+    export LD_LIBRARY_PATH="./MyLibCompiled/lib/"
+fi
+
+./my_application.out "$@"

test/runtests.jl

@@ -3,6 +3,7 @@ using Test
 using Libdl
 using Pkg
 
+import GNUMake_jll
 import TOML
 
 ENV["JULIA_DEBUG"] = "PackageCompiler"
@@ -242,4 +243,70 @@ end
         hello = read(`$(Base.julia_cmd()) -J $(sysimage_path) -e 'print("hello, world")'`, String)
         @test hello == "hello, world"
     end
-end
+
+    @testset "examples/MyLib" begin
+        # This testset makes sure that the `examples/MyLib` example does not bitrot.
+
+        if Sys.iswindows()
+            @info "Skipping the examples/MyLib test on Windows"
+            @test_skip false
+            # TODO: Figure out how to get this testset to work on Windows.
+        else
+            rootdir_testdir = @__DIR__
+            rootdir = dirname(rootdir_testdir)
+            rootdir_examples = joinpath(rootdir, "examples")
+            rootdir_examples_MyLib = joinpath(rootdir_examples, "MyLib")
+
+            my_run = (cmd::Cmd) -> begin
+                env2 = copy(ENV)
+
+                # The `JULIA` environment variable is used by our `MyLib/Makefile`.
+                # The `GCC` environment variable is used by our `MyLib/Makefile`.
+                env2["JULIA"] = Base.julia_cmd()[1]
+                env2["GCC"] = PackageCompiler.get_compiler_cmd()[1]
+
+                return run(cmd)
+            end
+
+            cd(rootdir_examples_MyLib) do
+                # We need to go into examples/MyLib/build/ and dev this copy of PackageCompiler.jl
+                code = """
+                    import Pkg
+                    Pkg.develop(;path = "$(rootdir)")
+                """
+                cmd = `$(Base.julia_cmd()[1]) --project="./build" -e "$(code)"`
+                run(cmd)
+
+
+                # We don't want to assume that the machine running the tests has `make` installed
+                # and available in the PATH. Therefore, we use the `GNUMake_jll.jl`` package.
+                my_run(`$(GNUMake_jll.make())`)
+
+                env2 = copy(ENV)
+                if Sys.isapple()
+                    env2["DYLD_FALLBACK_LIBRARY_PATH"] = "./MyLibCompiled/lib/:./MyLibCompiled/lib/julia"
+                else
+                    # env2["LD_LIBRARY_PATH"] = "./MyLibCompiled/lib/:./MyLibCompiled/lib/julia"
+                    env2["LD_LIBRARY_PATH"] = "./MyLibCompiled/lib/"
+                end
+                cmd = `./my_application.out`
+                run(setenv(cmd, env2))
+                observed_str = strip(read(setenv(cmd, env2), String))
+                expected_str = "Incremented count: 4 (Cint)\nIncremented value: 4"
+                @test observed_str == expected_str
+
+                # Yes, we do have a convenience wrapper script at `examples/MyLib/runme.bash`
+                # However, for the PackageCompiler test suite, we don't want to make any assumptions
+                # about Bash being available on the machine that's running the tests.
+                # So instead, we manaully run the `./my_application.out` executable ourselves.
+
+                # Finally, exercise a few more `Makefile` targets, to make sure that they
+                # don't bitrot.
+                my_run(`$(GNUMake_jll.make()) all`)
+                my_run(`$(GNUMake_jll.make()) build-library`)
+                my_run(`$(GNUMake_jll.make()) build-executable`)
+                my_run(`$(GNUMake_jll.make()) clean`)
+            end # cd
+        end # if-elseif-else-end
+    end # testset "examples/MyLib"
+end # testset "PackageCompiler.jl"