arduino_ci 0.2.0 → 1.1.0

data/lib/arduino_ci/arduino_installation.rb

@@ -1,16 +1,10 @@
 require 'pathname'
 require "arduino_ci/host"
-require "arduino_ci/arduino_cmd_osx"
-require "arduino_ci/arduino_cmd_linux"
-require "arduino_ci/arduino_cmd_windows"
-require "arduino_ci/arduino_cmd_linux_builder"
+require "arduino_ci/arduino_backend"
 require "arduino_ci/arduino_downloader_osx"
 require "arduino_ci/arduino_downloader_linux"
-
 require "arduino_ci/arduino_downloader_windows" if ArduinoCI::Host.os == :windows
 
-DESIRED_ARDUINO_IDE_VERSION = "1.8.6".freeze
-
 module ArduinoCI
 
   class ArduinoInstallationError < StandardError; end
@@ -18,85 +12,29 @@ module ArduinoCI
   # Manage the OS-specific install location of Arduino
   class ArduinoInstallation
 
+    DESIRED_ARDUINO_CLI_VERSION = "0.13.0".freeze
+
     class << self
 
       # attempt to find a workable Arduino executable across platforms
       #
       # Autolocation assumed to be an expensive operation
-      # @return [ArduinoCI::ArduinoCmd] an instance of the command or nil if it can't be found
+      # @return [ArduinoCI::ArduinoBackend] an instance of the command or nil if it can't be found
       def autolocate
-        ret = nil
-        case Host.os
-        when :osx then
-          ret = autolocate_osx
-        when :linux then
-          loc = ArduinoDownloaderLinux.autolocated_executable
-          return nil if loc.nil?
-
-          ret = ArduinoCmdLinux.new
-          ret.base_cmd = [loc]
-          ret.binary_path = Pathname.new(loc)
-        when :windows then
-          loc = ArduinoDownloaderWindows.autolocated_executable
-          return nil if loc.nil?
-
-          ret = ArduinoCmdWindows.new
-          ret.base_cmd = [loc]
-          ret.binary_path = Pathname.new(loc)
+        downloader_class = case Host.os
+        when :osx     then ArduinoDownloaderOSX
+        when :linux   then ArduinoDownloaderLinux
+        when :windows then ArduinoDownloaderWindows
         end
-        ret
-      end
 
-      # @return [ArduinoCI::ArduinoCmdOSX] an instance of the command or nil if it can't be found
-      def autolocate_osx
-        osx_root = ArduinoDownloaderOSX.autolocated_installation
-        return nil if osx_root.nil?
-        return nil unless File.exist? osx_root
+        loc = downloader_class.autolocated_executable
+        return nil if loc.nil?
 
-        launchers = [
-          # try a hack that skips splash screen
-          # from https://github.com/arduino/Arduino/issues/1970#issuecomment-321975809
-          [
-            "java",
-            "-cp",
-            "#{osx_root}/Contents/Java/*",
-            "-DAPP_DIR=#{osx_root}/Contents/Java",
-            "-Dfile.encoding=UTF-8",
-            "-Dapple.awt.UIElement=true",
-            "-Xms128M",
-            "-Xmx512M",
-            "processing.app.Base",
-          ],
-          # failsafe way
-          [File.join(osx_root, "Contents", "MacOS", "Arduino")]
-        ]
-
-        # create return and find a command launcher that works
-        ret = ArduinoCmdOSX.new
-        launchers.each do |launcher|
-          # test whether this method successfully launches the IDE
-          # note that "successful launch" involves a command that will fail,
-          # because that's faster than any command which succeeds.  what we
-          # don't want to see is a java error.
-          args = launcher + ["--bogus-option"]
-          result = Host.run_and_capture(*args)
-
-          # NOTE: Was originally searching for "Error: unknown option: --bogus-option"
-          #           but also need to find "Erreur: option inconnue : --bogus-option"
-          #           and who knows how many other languages.
-          # For now, just search for the end of the error and hope that the java-style
-          #  launch of this won't include a similar string in it
-          next unless result[:err].include? ": --bogus-option"
-
-          ret.base_cmd = launcher
-          ret.binary_path = Pathname.new(osx_root)
-          return ret
-        end
-        nil
+        ArduinoBackend.new(loc)
       end
 
       # Attempt to find a workable Arduino executable across platforms, and install it if we don't
-      # @return [ArduinoCI::ArduinoCmd] an instance of a command
+      # @return [ArduinoCI::ArduinoBackend] an instance of a command
       def autolocate!(output = $stdout)
         candidate = autolocate
         return candidate unless candidate.nil?
@@ -109,12 +47,12 @@ module ArduinoCI
 
       # Forcibly install Arduino from the web
       # @return [bool] Whether the command succeeded
-      def force_install(output = $stdout, version = DESIRED_ARDUINO_IDE_VERSION)
-        worker_class =  case Host.os
-                        when :osx then ArduinoDownloaderOSX
-                        when :windows then ArduinoDownloaderWindows
-                        when :linux then ArduinoDownloaderLinux
-                        end
+      def force_install(output = $stdout, version = DESIRED_ARDUINO_CLI_VERSION)
+        worker_class = case Host.os
+        when :osx then ArduinoDownloaderOSX
+        when :windows then ArduinoDownloaderWindows
+        when :linux then ArduinoDownloaderLinux
+        end
         worker = worker_class.new(version, output)
         worker.execute
       end

data/lib/arduino_ci/ci_config.rb

@@ -28,6 +28,7 @@ UNITTEST_SCHEMA = {
   compilers: Array,
   platforms: Array,
   libraries: Array,
+  exclude_dirs: Array,
   testfiles: {
     select: Array,
     reject: Array,
@@ -65,6 +66,7 @@ module ArduinoCI
     attr_accessor :platform_info
     attr_accessor :compile_info
     attr_accessor :unittest_info
+
     def initialize
       @package_info = {}
       @platform_info = {}
@@ -106,7 +108,7 @@ module ArduinoCI
       good_data = {}
       source.each do |key, value|
         ksym = key.to_sym
-        expected_type = schema[ksym].class == Class ? schema[ksym] : Hash
+        expected_type = schema[ksym].instance_of?(Class) ? schema[ksym] : Hash
         if !schema.include?(ksym)
           puts "Warning: unknown field '#{ksym}' under definition for #{rootname}"
         elsif value.nil?
@@ -114,7 +116,7 @@ module ArduinoCI
         elsif value.class != expected_type
           puts "Warning: expected field '#{ksym}' of #{rootname} to be '#{expected_type}', got '#{value.class}'"
         else
-          good_data[ksym] = value.class == Hash ? validate_data(key, value, schema[ksym]) : value
+          good_data[ksym] = value.instance_of?(Hash) ? validate_data(key, value, schema[ksym]) : value
         end
       end
       good_data
@@ -231,13 +233,6 @@ module ArduinoCI
       deep_clone(defn)
     end
 
-    # Whether a package is built-in to arduino
-    # @param package [String] the package name (e.g. "arduino:avr")
-    # @return [bool]
-    def package_builtin?(package)
-      package.start_with?("arduino:")
-    end
-
     # the URL that gives the download info for a given package (a JSON file).
     # this is NOT where the package comes from.
     # @param package [String] the package name (e.g. "arduino:avr")
@@ -256,6 +251,14 @@ module ArduinoCI
       @unittest_info[:compilers]
     end
 
+    # paths to exclude all files in for building and unitttests
+    # @return [Array<String>] The directories (relative to base dir) to exclude
+    def exclude_dirs
+      return [] if @unittest_info[:exclude_dirs].nil?
+
+      @unittest_info[:exclude_dirs]
+    end
+
     # platforms to build [the examples on]
     # @return [Array<String>] The platforms to build
     def platforms_to_build
@@ -293,9 +296,12 @@ module ArduinoCI
       return paths if @unittest_info[:testfiles].nil?
 
       ret = paths
+      # Check for array emptiness, otherwise nothing will be selected!
       unless @unittest_info[:testfiles][:select].nil? || @unittest_info[:testfiles][:select].empty?
         ret.select! { |p| unittest_info[:testfiles][:select].any? { |glob| p.basename.fnmatch(glob) } }
       end
+
+      # It's OK for the :reject array to be empty, that means nothing will be rejected by default
       unless @unittest_info[:testfiles][:reject].nil?
         ret.reject! { |p| unittest_info[:testfiles][:reject].any? { |glob| p.basename.fnmatch(glob) } }
       end

data/lib/arduino_ci/cpp_library.rb

@@ -14,15 +14,21 @@ module ArduinoCI
   # Information about an Arduino CPP library, specifically for compilation purposes
   class CppLibrary
 
-    # @return [Pathname] The path to the library being tested
-    attr_reader :base_dir
+    # @return [String] The official library properties file name
+    LIBRARY_PROPERTIES_FILE = "library.properties".freeze
 
-    # @return [Pathname] The path to the Arduino 3rd-party library directory
-    attr_reader :arduino_lib_dir
+    # @return [String] The "official" name of the library, which can include spaces (in a way that the lib dir won't)
+    attr_reader :name
+
+    # @return [ArduinoBackend] The backend support for this library
+    attr_reader :backend
 
     # @return [Array<Pathname>] The set of artifacts created by this class (note: incomplete!)
     attr_reader :artifacts
 
+    # @return [Array<Pathname>] The set of directories that should be excluded from compilation
+    attr_reader :exclude_dirs
+
     # @return [String] STDERR from the last command
     attr_reader :last_err
 
@@ -35,20 +41,138 @@ module ArduinoCI
     # @return [Array<Pathname>] Directories suspected of being vendor-bundle
     attr_reader :vendor_bundle_cache
 
-    # @param base_dir [Pathname] The path to the library being tested
-    # @param arduino_lib_dir [Pathname] The path to the libraries directory
-    def initialize(base_dir, arduino_lib_dir)
-      raise ArgumentError, 'base_dir is not a Pathname' unless base_dir.is_a? Pathname
-      raise ArgumentError, 'arduino_lib_dir is not a Pathname' unless arduino_lib_dir.is_a? Pathname
+    # @param friendly_name [String] The "official" name of the library, which can contain spaces
+    # @param backend [ArduinoBackend] The support backend
+    def initialize(friendly_name, backend)
+      raise ArgumentError, "friendly_name is not a String (got #{friendly_name.class})" unless friendly_name.is_a? String
+      raise ArgumentError, 'backend is not a ArduinoBackend' unless backend.is_a? ArduinoBackend
 
-      @base_dir = base_dir
-      @arduino_lib_dir = arduino_lib_dir.expand_path
+      @name = friendly_name
+      @backend = backend
+      @info_cache = nil
       @artifacts = []
       @last_err = ""
       @last_out = ""
       @last_msg = ""
       @has_libasan_cache = {}
       @vendor_bundle_cache = nil
+      @exclude_dirs = []
+    end
+
+    # Generate a guess as to the on-disk (coerced character) name of this library
+    #
+    # @TODO: delegate this to the backend in some way? It uses "official" names for install, but dir names in lists :(
+    # @param friendly_name [String] The library name as it might appear in library manager
+    # @return [String] How the path will be stored on disk -- spaces are coerced to underscores
+    def self.library_directory_name(friendly_name)
+      friendly_name.tr(" ", "_")
+    end
+
+    # Generate a guess as to the on-disk (coerced character) name of this library
+    #
+    # @TODO: delegate this to the backend in some way? It uses "official" names for install, but dir names in lists :(
+    # @return [String] How the path will be stored on disk -- spaces are coerced to underscores
+    def name_on_disk
+      self.class.library_directory_name(@name)
+    end
+
+    # Get the path to this library, whether or not it exists
+    # @return [Pathname] The fully qualified library path
+    def path
+      @backend.lib_dir + name_on_disk
+    end
+
+    # @return [String] The parent directory of all examples
+    def examples_dir
+      path + "examples"
+    end
+
+    # Determine whether a library is present in the lib dir
+    #
+    # Note that `true` doesn't guarantee that the library is valid/installed
+    #  and `false` doesn't guarantee that the library isn't built-in
+    #
+    # @return [bool]
+    def installed?
+      path.exist?
+    end
+
+    # install a library by name
+    # @param version [String] the version to install
+    # @param recursive [bool] whether to also install its dependencies
+    # @return [bool] whether the command succeeded
+    def install(version = nil, recursive = false)
+      return true if installed? && !recursive
+
+      fqln = version.nil? ? @name : "#{@name}@#{version}"
+      result = if recursive
+        @backend.run_and_capture("lib", "install", fqln)
+      else
+        @backend.run_and_capture("lib", "install", "--no-deps", fqln)
+      end
+      result[:success]
+    end
+
+    # information about the library as reported by the backend
+    # @return [Hash] the metadata object
+    def info
+      return nil unless installed?
+
+      # note that if the library isn't found, we're going to do a lot of cache attempts...
+      if @info_cache.nil?
+        @info_cache = @backend.installed_libraries.find do |l|
+          lib_info = l["library"]
+          Pathname.new(lib_info["install_dir"]).realpath == path.realpath
+        end
+      end
+
+      @info_cache
+    end
+
+    # @param installed_library_path [String] The library to query
+    # @return [Array<String>] Example sketch files
+    def example_sketches
+      reported_dirs = info["library"]["examples"].map(&Pathname::method(:new))
+      reported_dirs.map { |e| e + e.basename.sub_ext(".ino") }.select(&:exist?).sort_by(&:to_s)
+    end
+
+    # The expected path to the library.properties file (i.e. even if it does not exist)
+    # @return [Pathname]
+    def library_properties_path
+      path + LIBRARY_PROPERTIES_FILE
+    end
+
+    # Whether library.properties definitions for this library exist
+    # @return [bool]
+    def library_properties?
+      lib_props = library_properties_path
+      lib_props.exist? && lib_props.file?
+    end
+
+    # Library properties
+    # @return [LibraryProperties] The library.properties metadata wrapper for this library
+    def library_properties
+      return nil unless library_properties?
+
+      LibraryProperties.new(library_properties_path)
+    end
+
+    # Set directories that should be excluded from compilation
+    # @param rval [Array] Array of strings or pathnames that will be coerced to pathnames
+    def exclude_dirs=(rval)
+      @exclude_dirs = rval.map { |d| d.is_a?(Pathname) ? d : Pathname.new(d) }
+    end
+
+    # Decide whether this is a 1.5-compatible library
+    #
+    # This should be according to https://arduino.github.io/arduino-cli/latest/library-specification
+    # but we rely on the cli to decide for us
+    # @return [bool]
+    def one_point_five?
+      return false unless library_properties?
+
+      src_dir = path + "src"
+      src_dir.exist? && src_dir.directory?
     end
 
     # Guess whether a file is part of the vendor bundle (indicating we should ignore it).
@@ -58,9 +182,9 @@ module ArduinoCI
     #   That gets us the vendor directory (or multiple directories). We can check
     #   if the given path is contained by any of those.
     #
-    # @param path [Pathname] The path to check
+    # @param some_path [Pathname] The path to check
     # @return [bool]
-    def vendor_bundle?(path)
+    def vendor_bundle?(some_path)
       # Cache bundle information, as it is (1) time consuming to fetch and (2) not going to change while we run
       if @vendor_bundle_cache.nil?
         bundle_info = Host.run_and_capture("bundle show --paths")
@@ -95,7 +219,7 @@ module ArduinoCI
 
       # With vendor bundles located, check this file against those
       @vendor_bundle_cache.any? do |gem_path|
-        path.ascend do |part|
+        some_path.ascend do |part|
           break true if gem_path == part
         end
       end
@@ -105,29 +229,41 @@ module ArduinoCI
     #
     # @param path [Pathname] The path to check
     # @return [bool]
-    def in_tests_dir?(path)
+    def in_tests_dir?(sourcefile_path)
+      return false unless tests_dir.exist?
+
       tests_dir_aliases = [tests_dir, tests_dir.realpath]
       # we could do this but some rubies don't return an enumerator for ascend
       # path.ascend.any? { |part| tests_dir_aliases.include?(part) }
-      path.ascend do |part|
+      sourcefile_path.ascend do |part|
         return true if tests_dir_aliases.include?(part)
       end
       false
     end
 
+    # Guess whether a file is part of any @excludes_dir dir (indicating library compilation should ignore it).
+    #
+    # @param path [Pathname] The path to check
+    # @return [bool]
+    def in_exclude_dir?(sourcefile_path)
+      # we could do this but some rubies don't return an enumerator for ascend
+      # path.ascend.any? { |part| tests_dir_aliases.include?(part) }
+      sourcefile_path.ascend do |part|
+        return true if exclude_dir.any? { |p| p.realpath == part.realpath }
+      end
+      false
+    end
+
     # Check whether libasan (and by extension -fsanitizer=address) is supported
     #
     # This requires compilation of a sample program, and will be cached
     # @param gcc_binary [String]
     def libasan?(gcc_binary)
       unless @has_libasan_cache.key?(gcc_binary)
-        file = Tempfile.new(["arduino_ci_libasan_check", ".cpp"])
-        begin
+        Tempfile.create(["arduino_ci_libasan_check", ".cpp"]) do |file|
           file.write "int main(){}"
           file.close
           @has_libasan_cache[gcc_binary] = run_gcc(gcc_binary, "-o", "/dev/null", "-fsanitize=address", file.path)
-        ensure
-          file.delete
         end
       end
       @has_libasan_cache[gcc_binary]
@@ -135,62 +271,102 @@ module ArduinoCI
 
     # Get a list of all CPP source files in a directory and its subdirectories
     # @param some_dir [Pathname] The directory in which to begin the search
+    # @param extensions [Array<Sring>] The set of allowable file extensions
     # @return [Array<Pathname>] The paths of the found files
-    def cpp_files_in(some_dir)
+    def code_files_in(some_dir, extensions)
       raise ArgumentError, 'some_dir is not a Pathname' unless some_dir.is_a? Pathname
-      return [] unless some_dir.exist? && some_dir.directory?
 
-      real = some_dir.realpath
-      files = Find.find(real).map { |p| Pathname.new(p) }.reject(&:directory?)
-      cpp = files.select { |path| CPP_EXTENSIONS.include?(path.extname.downcase) }
+      full_dir = path + some_dir
+      return [] unless full_dir.exist? && full_dir.directory?
+
+      files = full_dir.children.reject(&:directory?)
+      cpp = files.select { |path| extensions.include?(path.extname.downcase) }
       not_hidden = cpp.reject { |path| path.basename.to_s.start_with?(".") }
       not_hidden.sort_by(&:to_s)
     end
 
+    # Get a list of all CPP source files in a directory and its subdirectories
+    # @param some_dir [Pathname] The directory in which to begin the search
+    # @param extensions [Array<Sring>] The set of allowable file extensions
+    # @return [Array<Pathname>] The paths of the found files
+    def code_files_in_recursive(some_dir, extensions)
+      raise ArgumentError, 'some_dir is not a Pathname' unless some_dir.is_a? Pathname
+      return [] unless some_dir.exist? && some_dir.directory?
+
+      Find.find(some_dir).map { |p| Pathname.new(p) }.select(&:directory?).map { |d| code_files_in(d, extensions) }.flatten
+    end
+
+    # Source files that are part of the library under test
+    # @param extensions [Array<String>] the allowed extensions (or, the ones we're looking for)
+    # @return [Array<Pathname>]
+    def source_files(extensions)
+      source_dir = Pathname.new(info["library"]["source_dir"])
+      ret = if one_point_five?
+        code_files_in_recursive(source_dir, extensions)
+      else
+        [source_dir, source_dir + "utility"].map { |d| code_files_in(d, extensions) }.flatten
+      end
+
+      # note to future troubleshooter: some of these tests may not be relevant, but at the moment at
+      # least some of them are tied to existing features
+      ret.reject { |p| vendor_bundle?(p) || in_tests_dir?(p) || in_exclude_dir?(p) }
+    end
+
+    # Header files that are part of the project library under test
+    # @return [Array<Pathname>]
+    def header_files
+      source_files(HPP_EXTENSIONS)
+    end
+
     # CPP files that are part of the project library under test
     # @return [Array<Pathname>]
     def cpp_files
-      cpp_files_in(@base_dir).reject { |p| vendor_bundle?(p) || in_tests_dir?(p) }
+      source_files(CPP_EXTENSIONS)
     end
 
     # CPP files that are part of the arduino mock library we're providing
     # @return [Array<Pathname>]
     def cpp_files_arduino
-      cpp_files_in(ARDUINO_HEADER_DIR)
+      code_files_in(ARDUINO_HEADER_DIR, CPP_EXTENSIONS)
     end
 
     # CPP files that are part of the unit test library we're providing
     # @return [Array<Pathname>]
     def cpp_files_unittest
-      cpp_files_in(UNITTEST_HEADER_DIR)
+      code_files_in(UNITTEST_HEADER_DIR, CPP_EXTENSIONS)
     end
 
     # CPP files that are part of the 3rd-party libraries we're including
     # @param [Array<String>] aux_libraries
     # @return [Array<Pathname>]
     def cpp_files_libraries(aux_libraries)
-      arduino_library_src_dirs(aux_libraries).map { |d| cpp_files_in(d) }.flatten.uniq
+      arduino_library_src_dirs(aux_libraries).map { |d| code_files_in(d, CPP_EXTENSIONS) }.flatten.uniq
+    end
+
+    # Returns the Pathnames for all paths to exclude from testing and compilation
+    # @return [Array<Pathname>]
+    def exclude_dir
+      @exclude_dirs.map { |p| Pathname.new(path) + p }.select(&:exist?)
     end
 
     # The directory where we expect to find unit test defintions provided by the user
     # @return [Pathname]
     def tests_dir
-      Pathname.new(@base_dir) + "test"
+      Pathname.new(path) + "test"
     end
 
     # The files provided by the user that contain unit tests
     # @return [Array<Pathname>]
     def test_files
-      cpp_files_in(tests_dir)
+      code_files_in(tests_dir, CPP_EXTENSIONS)
     end
 
     # Find all directories in the project library that include C++ header files
     # @return [Array<Pathname>]
     def header_dirs
-      real = @base_dir.realpath
-      all_files = Find.find(real).map { |f| Pathname.new(f) }.reject(&:directory?)
-      unbundled = all_files.reject { |path| vendor_bundle?(path) }
-      files = unbundled.select { |path| HPP_EXTENSIONS.include?(path.extname.downcase) }
+      unbundled = header_files.reject { |path| vendor_bundle?(path) }
+      unexcluded = unbundled.reject { |path| in_exclude_dir?(path) }
+      files = unexcluded.select { |path| HPP_EXTENSIONS.include?(path.extname.downcase) }
       files.map(&:dirname).uniq
     end
 
@@ -212,20 +388,38 @@ module ArduinoCI
       @last_err
     end
 
-    # Arduino library directories containing sources
-    # @return [Array<Pathname>]
-    def arduino_library_src_dirs(aux_libraries)
+    # Get a list of all dependencies as defined in library.properties
+    # @return [Array<String>] The library names of the dependencies (not the paths)
+    def arduino_library_dependencies
+      return [] unless library_properties?
+      return [] if library_properties.depends.nil?
+
+      library_properties.depends
+    end
+
+    # Arduino library dependencies all the way down, installing if they are not present
+    # @return [Array<String>] The library names of the dependencies (not the paths)
+    def all_arduino_library_dependencies!(additional_libraries = [])
       # Pull in all possible places that headers could live, according to the spec:
       # https://github.com/arduino/Arduino/wiki/Arduino-IDE-1.5:-Library-specification
-      # TODO: be smart and implement library spec (library.properties, etc)?
-      subdirs = ["", "src", "utility"]
-      all_aux_include_dirs_nested = aux_libraries.map do |libdir|
-        subdirs.map { |subdir| Pathname.new(@arduino_lib_dir) + libdir + subdir }
-      end
-      all_aux_include_dirs_nested.flatten.select(&:exist?).select(&:directory?)
+      recursive = (additional_libraries + arduino_library_dependencies).map do |n|
+        other_lib = self.class.new(n, @backend)
+        other_lib.install unless other_lib.installed?
+        other_lib.all_arduino_library_dependencies!
+      end.flatten
+      (additional_libraries + recursive).uniq
+    end
+
+    # Arduino library directories containing sources -- only those of the dependencies
+    # @return [Array<Pathname>]
+    def arduino_library_src_dirs(aux_libraries)
+      all_arduino_library_dependencies!(aux_libraries).map { |l| self.class.new(l, @backend).header_dirs }.flatten.uniq
     end
 
     # GCC command line arguments for including aux libraries
+    #
+    # This function recursively collects the library directores of the dependencies
+    #
     # @param aux_libraries [Array<Pathname>] The external Arduino libraries required by this project
     # @return [Array<String>] The GCC command-line flags necessary to include those libraries
     def include_args(aux_libraries)
@@ -288,6 +482,9 @@ module ArduinoCI
     end
 
     # build a file for running a test of the given unit test file
+    #
+    # The dependent libraries configuration is appended with data from library.properties internal to the library under test
+    #
     # @param test_file [Pathname] The path to the file containing the unit tests
     # @param aux_libraries [Array<Pathname>] The external Arduino libraries required by this project
     # @param ci_gcc_config [Hash] The GCC config object
@@ -306,8 +503,12 @@ module ArduinoCI
           "-fsanitize=address"
         ]
       end
-      arg_sets << test_args(aux_libraries, ci_gcc_config)
-      arg_sets << cpp_files_libraries(aux_libraries).map(&:to_s)
+
+      # combine library.properties defs (if existing) with config file.
+      # TODO: as much as I'd like to rely only on the properties file(s), I think that would prevent testing 1.0-spec libs
+      full_dependencies = all_arduino_library_dependencies!(aux_libraries)
+      arg_sets << test_args(full_dependencies, ci_gcc_config)
+      arg_sets << cpp_files_libraries(full_dependencies).map(&:to_s)
       arg_sets << [test_file.to_s]
       args = arg_sets.flatten(1)
       return nil unless run_gcc(gcc_binary, *args)
@@ -316,14 +517,31 @@ module ArduinoCI
       executable
     end
 
+    # print any found stack dumps
+    # @param executable [Pathname] the path to the test file
+    def print_stack_dump(executable)
+      possible_dumpfiles = [
+        executable.sub_ext("#{executable.extname}.stackdump")
+      ]
+      possible_dumpfiles.select(&:exist?).each do |dump|
+        puts "========== Stack dump from #{dump}:"
+        File.foreach(dump) { |line| print "    #{line}" }
+      end
+    end
+
     # run a test file
-    # @param [Pathname] the path to the test file
+    # @param executable [Pathname] the path to the test file
     # @return [bool] whether all tests were successful
     def run_test_file(executable)
       @last_cmd = executable
       @last_out = ""
       @last_err = ""
-      Host.run_and_output(executable.to_s.shellescape)
+      ret = Host.run_and_output(executable.to_s.shellescape)
+
+      # print any stack traces found during a failure
+      print_stack_dump(executable) unless ret
+
+      ret
     end
 
   end