arduino_ci 0.3.0 → 0.4.0

data/cpp/arduino/avr/pgmspace.h

@@ -14,8 +14,10 @@ out = externs.map {|l| l.split("(")[0].split(" ")[-1].gsub("*", "") }.uniq
 out.each { |l| puts d(l) }
 */
 
-#include <avr/io.h>
 #include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
 
 #define PROGMEM
 
@@ -27,6 +29,11 @@ out.each { |l| puts d(l) }
 #define PGM_VOID_P const void *
 #endif
 
+// These are normally 32-bit, but here use (u)intptr_t to ensure a pointer can
+// always be safely cast to these types.
+typedef intptr_t int_farptr_t;
+typedef uintptr_t uint_farptr_t;
+
 // everything's a no-op
 #define PSTR(s) ((const char *)(s))
 
@@ -34,13 +41,13 @@ out.each { |l| puts d(l) }
 #define pgm_read_word_near(address_short)  (* (const uint16_t *) (address_short) )
 #define pgm_read_dword_near(address_short) (* (const uint32_t *) (address_short) )
 #define pgm_read_float_near(address_short) (* (const float *)    (address_short) )
-#define pgm_read_ptr_near(address_short)   (* (const void *)     (address_short) )
+#define pgm_read_ptr_near(address_short)   (* (const void **)    (address_short) )
 
 #define pgm_read_byte_far(address_long)    (* (const uint8_t *)  (address_long) )
 #define pgm_read_word_far(address_long)    (* (const uint16_t *) (address_long) )
 #define pgm_read_dword_far(address_long)   (* (const uint32_t *) (address_long) )
 #define pgm_read_float_far(address_long)   (* (const float *)    (address_long) )
-#define pgm_read_ptr_far(address_long)     (* (const void *)     (address_long) )
+#define pgm_read_ptr_far(address_long)     (* (const void **)    (address_long) )
 
 #define pgm_read_byte(address_short)   pgm_read_byte_near(address_short)
 #define pgm_read_word(address_short)   pgm_read_word_near(address_short)
@@ -50,46 +57,69 @@ out.each { |l| puts d(l) }
 
 #define pgm_get_far_address(var) ( (uint_farptr_t) (&(var)) )
 
-#define memchr_P(...) ::memchr(__VA_ARGS__)
-#define memcmp_P(...) ::memcmp(__VA_ARGS__)
-#define memccpy_P(...) ::memccpy(__VA_ARGS__)
-#define memcpy_P(...) ::memcpy(__VA_ARGS__)
-#define memmem_P(...) ::memmem(__VA_ARGS__)
-#define memrchr_P(...) ::memrchr(__VA_ARGS__)
-#define strcat_P(...) ::strcat(__VA_ARGS__)
-#define strchr_P(...) ::strchr(__VA_ARGS__)
-#define strchrnul_P(...) ::strchrnul(__VA_ARGS__)
-#define strcmp_P(...) ::strcmp(__VA_ARGS__)
-#define strcpy_P(...) ::strcpy(__VA_ARGS__)
-#define strcasecmp_P(...) ::strcasecmp(__VA_ARGS__)
-#define strcasestr_P(...) ::strcasestr(__VA_ARGS__)
-#define strcspn_P(...) ::strcspn(__VA_ARGS__)
-#define strlcat_P(...) ::strlcat(__VA_ARGS__)
-#define strlcpy_P(...) ::strlcpy(__VA_ARGS__)
-#define strnlen_P(...) ::strnlen(__VA_ARGS__)
-#define strncmp_P(...) ::strncmp(__VA_ARGS__)
-#define strncasecmp_P(...) ::strncasecmp(__VA_ARGS__)
-#define strncat_P(...) ::strncat(__VA_ARGS__)
-#define strncpy_P(...) ::strncpy(__VA_ARGS__)
-#define strpbrk_P(...) ::strpbrk(__VA_ARGS__)
-#define strrchr_P(...) ::strrchr(__VA_ARGS__)
-#define strsep_P(...) ::strsep(__VA_ARGS__)
-#define strspn_P(...) ::strspn(__VA_ARGS__)
-#define strstr_P(...) ::strstr(__VA_ARGS__)
-#define strtok_P(...) ::strtok(__VA_ARGS__)
-#define strtok_P(...) ::strtok(__VA_ARGS__)
-#define strlen_P(...) ::strlen(__VA_ARGS__)
-#define strnlen_P(...) ::strnlen(__VA_ARGS__)
-#define memcpy_P(...) ::memcpy(__VA_ARGS__)
-#define strcpy_P(...) ::strcpy(__VA_ARGS__)
-#define strncpy_P(...) ::strncpy(__VA_ARGS__)
-#define strcat_P(...) ::strcat(__VA_ARGS__)
-#define strlcat_P(...) ::strlcat(__VA_ARGS__)
-#define strncat_P(...) ::strncat(__VA_ARGS__)
-#define strcmp_P(...) ::strcmp(__VA_ARGS__)
-#define strncmp_P(...) ::strncmp(__VA_ARGS__)
-#define strcasecmp_P(...) ::strcasecmp(__VA_ARGS__)
-#define strncasecmp_P(...) ::strncasecmp(__VA_ARGS__)
-#define strstr_P(...) ::strstr(__VA_ARGS__)
-#define strlcpy_P(...) ::strlcpy(__VA_ARGS__)
-#define memcmp_P(...) ::memcmp(__VA_ARGS__)
+inline const void * memchr_P(const void *s, int val, size_t len) { return memchr(s, val, len); }
+inline int memcmp_P(const void *s1, const void *s2, size_t len) { return memcmp(s1, s2, len); }
+inline void *memcpy_P(void *dest, const void *src, size_t n) { return memcpy(dest, src, n); }
+inline char *strcat_P(char *dest, const char *src) { return strcat(dest, src); }
+inline const char *strchr_P(const char *s, int val) { return strchr(s, val); }
+inline int strcmp_P(const char *s1, const char *s2) { return strcmp(s1, s2); }
+inline char *strcpy_P(char *dest, const char *src) { return strcpy(dest, src); }
+inline size_t strcspn_P(const char *s, const char *reject) { return strcspn(s, reject); }
+// strlcat and strlcpy are AVR-specific and not entirely trivial to reimplement using strncat it seems
+//inline size_t strlcat_P(char *dst, const char *src, size_t siz) { return strlcat(dst, src, siz); }
+//inline size_t strlcpy_P(char *dst, const char *src, size_t siz) { return strlcpy(dst, src, siz); }
+//inline size_t strlcat_PF(char *dst, uint_farptr_t src, size_t n) { return strlcat(dst, (const char*)src, n); }
+//inline size_t strlcpy_PF(char *dst, uint_farptr_t src, size_t siz) { return strlcpy(dst, (const char*)src, siz); }
+inline int strncmp_P(const char *s1, const char *s2, size_t n) { return strncmp(s1, s2, n); }
+inline char *strncat_P(char *dest, const char *src, size_t len) { return strncat(dest, src, len); }
+inline char *strncpy_P(char *dest, const char *src, size_t n) { return strncpy(dest, src, n); }
+inline char *strpbrk_P(const char *s, const char *accept) { return (char*)strpbrk(s, accept); }
+inline const char *strrchr_P(const char *s, int val) { return strrchr(s, val); }
+inline size_t strspn_P(const char *s, const char *accept) { return strspn(s, accept); }
+inline char *strstr_P(const char *s1, const char *s2) { return (char*)strstr(s1, s2); }
+inline char *strtok_P(char *s, const char * delim) { return strtok(s, delim); }
+inline size_t strlen_PF(uint_farptr_t s) { return strlen((char*)s); }
+inline void *memcpy_PF(void *dest, uint_farptr_t src, size_t n) { return memcpy(dest, (const char*)src, n); }
+inline char *strcpy_PF(char *dst, uint_farptr_t src) { return strcpy(dst, (const char*)src); }
+inline char *strncpy_PF(char *dst, uint_farptr_t src, size_t n) { return strncpy(dst, (const char*)src, n); }
+inline char *strcat_PF(char *dst, uint_farptr_t src) { return strcat(dst, (const char*)src); }
+inline char *strncat_PF(char *dst, uint_farptr_t src, size_t n) { return strncat(dst, (const char*)src, n); }
+inline int strcmp_PF(const char *s1, uint_farptr_t s2) { return strcmp(s1, (const char*)s2); }
+inline int strncmp_PF(const char *s1, uint_farptr_t s2, size_t n) { return strncmp(s1, (const char*)s2, n); }
+inline char *strstr_PF(const char *s1, uint_farptr_t s2) { return (char*)strstr(s1, (const char*)s2); }
+inline int memcmp_PF(const void *s1, uint_farptr_t s2, size_t len) { return memcmp(s1, (const char*)s2, len); }
+inline size_t strlen_P(const char *src) { return strlen(src); }
+
+// TODO: These functions cannot be found on the CYGWIN test build for
+// some reason, so disable them for now. Most of these are less common
+// and/or GNU-specific addons anyway
+//inline void *memccpy_P(void *dest, const void *src, int val, size_t len) { return memccpy(dest, src, val, len); }
+//inline void *memmem_P(const void *s1, size_t len1, const void *s2, size_t len2) { return memmem(s1, len1, s2, len2); }
+//inline const void *memrchr_P(const void *src, int val, size_t len) { return memrchr(src, val, len); }
+//inline const char *strchrnul_P(const char *s, int c) { return strchrnul(s, c); }
+//inline int strcasecmp_P(const char *s1, const char *s2) { return strcasecmp(s1, s2); }
+//inline char *strcasestr_P(const char *s1, const char *s2) { return (char*)strcasestr(s1, s2); }
+//inline int strncasecmp_P(const char *s1, const char *s2, size_t n) { return strncasecmp(s1, s2, n); }
+//inline char *strsep_P(char **sp, const char *delim) { return strsep(sp, delim); }
+//inline char *strtok_r_P(char *string, const char *delim, char **last) { return strtok_r(string, delim, last); }
+//inline int strcasecmp_PF(const char *s1, uint_farptr_t s2) { return strcasecmp(s1, (const char*)s2); }
+//inline int strncasecmp_PF(const char *s1, uint_farptr_t s2, size_t n) { return strncasecmp(s1, (const char*)s2, n); }
+//inline size_t strnlen_P(uint_farptr_t s, size_t len) { return strnlen((char*)s, len); }
+
+// These are normally defined by stdio.h on AVR, but we cannot override that
+// include file (at least not without no longer being able to include the
+// original as well), so just define these here. It seems likely that any
+// sketch that uses these progmem-stdio functions will also include pgmspace.h
+inline int  vfprintf_P(FILE *stream, const char *__fmt, va_list __ap) { return vfprintf(stream, __fmt, __ap); }
+inline int  printf_P(const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vprintf(__fmt, args); va_end(args); }
+inline int  sprintf_P(char *s, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return sprintf(s, __fmt, args); va_end(args); }
+inline int  snprintf_P(char *s, size_t __n, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vsnprintf(s, __n, __fmt, args); va_end(args); }
+inline int  vsprintf_P(char *s, const char *__fmt, va_list ap) { return vsprintf(s, __fmt, ap); }
+inline int  vsnprintf_P(char *s, size_t __n, const char *__fmt, va_list ap) { return vsnprintf(s, __n, __fmt, ap); }
+inline int  fprintf_P(FILE *stream, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vfprintf(stream, __fmt, args); va_end(args); }
+inline int  fputs_P(const char *str, FILE *__stream) { return fputs(str, __stream); }
+inline int  puts_P(const char *str) { return puts(str); }
+inline int  vfscanf_P(FILE *stream, const char *__fmt, va_list __ap) { return vfscanf(stream, __fmt, __ap); }
+inline int  fscanf_P(FILE *stream, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vfscanf(stream, __fmt, args); va_end(args); }
+inline int  scanf_P(const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vscanf(__fmt, args); va_end(args); }
+inline int  sscanf_P(const char *buf, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vsscanf(buf, __fmt, args); va_end(args); }

data/cpp/unittest/OstreamHelpers.h

@@ -2,4 +2,8 @@
 
 #include <ostream>
 
+#if (defined __apple_build_version__) && (__apple_build_version__ >= 12000000)
+// defined in /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/../include/c++/v1/ostream:223:20
+#else
 inline std::ostream& operator << (std::ostream& out, const std::nullptr_t &np) { return out << "nullptr"; }
+#endif

data/exe/arduino_ci.rb

@@ -0,0 +1,401 @@
+#!/usr/bin/env ruby
+require 'arduino_ci'
+require 'set'
+require 'pathname'
+require 'optparse'
+
+WIDTH = 80
+FIND_FILES_INDENT = 4
+
+@failure_count = 0
+@passfail = proc { |result| result ? "✓" : "✗" }
+
+# Use some basic parsing to allow command-line overrides of config
+class Parser
+  def self.parse(options)
+    unit_config = {}
+    output_options = {
+      skip_unittests: false,
+      skip_compilation: false,
+      ci_config: {
+        "unittest" => unit_config
+      },
+    }
+
+    opt_parser = OptionParser.new do |opts|
+      opts.banner = "Usage: #{File.basename(__FILE__)} [options]"
+
+      opts.on("--skip-unittests", "Don't run unit tests") do |p|
+        output_options[:skip_unittests] = p
+      end
+
+      opts.on("--skip-compilation", "Don't compile example sketches (deprecated)") do |p|
+        puts "The option --skip-compilation has been deprecated in favor of --skip-examples-compilation"
+        output_options[:skip_compilation] = p
+      end
+
+      opts.on("--skip-examples-compilation", "Don't compile example sketches") do |p|
+        output_options[:skip_compilation] = p
+      end
+
+      opts.on("--testfile-select=GLOB", "Unit test file (or glob) to select") do |p|
+        unit_config["testfiles"] ||= {}
+        unit_config["testfiles"]["select"] ||= []
+        unit_config["testfiles"]["select"] << p
+      end
+
+      opts.on("--testfile-reject=GLOB", "Unit test file (or glob) to reject") do |p|
+        unit_config["testfiles"] ||= {}
+        unit_config["testfiles"]["reject"] ||= []
+        unit_config["testfiles"]["reject"] << p
+      end
+
+      opts.on("-h", "--help", "Prints this help") do
+        puts opts
+        exit
+      end
+    end
+
+    opt_parser.parse!(options)
+    output_options
+  end
+end
+
+# Read in command line options and make them read-only
+@cli_options = (Parser.parse ARGV).freeze
+
+# terminate after printing any debug info.  TODO: capture debug info
+def terminate(final = nil)
+  puts "Failures: #{@failure_count}"
+  unless @failure_count.zero? || final
+    puts "Last message: #{@arduino_cmd.last_msg}"
+    puts "========== Stdout:"
+    puts @arduino_cmd.last_out
+    puts "========== Stderr:"
+    puts @arduino_cmd.last_err
+  end
+  retcode = @failure_count.zero? ? 0 : 1
+  exit(retcode)
+end
+
+# make a nice status line for an action and react to the action
+# TODO / note to self: inform_multline is tougher to write
+#   without altering the signature because it only leaves space
+#   for the checkmark _after_ the multiline, it doesn't know how
+#   to make that conditionally the body
+# @param message String the text of the progress indicator
+# @param multiline boolean whether multiline output is expected
+# @param mark_fn block (string) -> string that says how to describe the result
+# @param on_fail_msg String custom message for failure
+# @param tally_on_fail boolean whether to increment @failure_count
+# @param abort_on_fail boolean whether to abort immediately on failure (i.e. if this is a fatal error)
+def perform_action(message, multiline, mark_fn, on_fail_msg, tally_on_fail, abort_on_fail)
+  line = "#{message}... "
+  endline = "...#{message} "
+  if multiline
+    puts line
+  else
+    print line
+  end
+  STDOUT.flush
+  result = yield
+  mark = mark_fn.nil? ? "" : mark_fn.call(result)
+  # if multline, put checkmark at full width
+  print endline if multiline
+  puts mark.to_s.rjust(WIDTH - line.length, " ")
+  unless result
+    puts on_fail_msg unless on_fail_msg.nil?
+    @failure_count += 1 if tally_on_fail
+    # print out error messaging here if we've captured it
+    terminate if abort_on_fail
+  end
+  result
+end
+
+# Make a nice status for something that defers any failure code until script exit
+def attempt(message, &block)
+  perform_action(message, false, @passfail, nil, true, false, &block)
+end
+
+# Make a nice status for something that defers any failure code until script exit
+def attempt_multiline(message, &block)
+  perform_action(message, true, @passfail, nil, true, false, &block)
+end
+
+# Make a nice status for something that kills the script immediately on failure
+FAILED_ASSURANCE_MESSAGE = "This may indicate a problem with ArduinoCI, or your configuration".freeze
+def assure(message, &block)
+  perform_action(message, false, @passfail, FAILED_ASSURANCE_MESSAGE, true, true, &block)
+end
+
+def assure_multiline(message, &block)
+  perform_action(message, true, @passfail, FAILED_ASSURANCE_MESSAGE, true, true, &block)
+end
+
+def inform(message, &block)
+  perform_action(message, false, proc { |x| x }, nil, false, false, &block)
+end
+
+def inform_multiline(message, &block)
+  perform_action(message, true, nil, nil, false, false, &block)
+end
+
+# Assure that a platform exists and return its definition
+def assured_platform(purpose, name, config)
+  platform_definition = config.platform_definition(name)
+  assure("Requested #{purpose} platform '#{name}' is defined in 'platforms' YML") do
+    !platform_definition.nil?
+  end
+  platform_definition
+end
+
+# Return true if the file (or one of the dirs containing it) is hidden
+def file_is_hidden_somewhere?(path)
+  # this is clunkly but pre-2.2-ish ruby doesn't return ascend as an enumerator
+  path.ascend do |part|
+    return true if part.basename.to_s.start_with? "."
+  end
+  false
+end
+
+# print out some files
+def display_files(pathname)
+  # `find` doesn't follow symlinks, so we should instead
+  realpath = pathname.symlink? ? pathname.readlink : pathname
+
+  # suppress directories and dotfile-based things
+  all_files = realpath.find.select(&:file?)
+  non_hidden = all_files.reject { |path| file_is_hidden_somewhere?(path) }
+
+  # print files with an indent
+  margin = " " * FIND_FILES_INDENT
+  non_hidden.each { |p| puts "#{margin}#{p}" }
+end
+
+def install_arduino_library_dependencies(aux_libraries)
+  aux_libraries.each do |l|
+    if @arduino_cmd.library_present?(l)
+      inform("Using pre-existing library") { l.to_s }
+    else
+      assure("Installing aux library '#{l}'") { @arduino_cmd.install_library(l) }
+    end
+  end
+end
+
+def perform_unit_tests(file_config)
+  if @cli_options[:skip_unittests]
+    inform("Skipping unit tests") { "as requested via command line" }
+    return
+  end
+  config = file_config.with_override_config(@cli_options[:ci_config])
+  cpp_library = ArduinoCI::CppLibrary.new(Pathname.new("."),
+                                          @arduino_cmd.lib_dir,
+                                          config.exclude_dirs.map(&Pathname.method(:new)))
+
+  # check GCC
+  compilers = config.compilers_to_use
+  assure("The set of compilers (#{compilers.length}) isn't empty") { !compilers.empty? }
+  compilers.each do |gcc_binary|
+    attempt_multiline("Checking #{gcc_binary} version") do
+      version = cpp_library.gcc_version(gcc_binary)
+      next nil unless version
+
+      puts version.split("\n").map { |l| "    #{l}" }.join("\n")
+      version
+    end
+    inform("libasan availability for #{gcc_binary}") { cpp_library.libasan?(gcc_binary) }
+  end
+
+  # Ensure platforms exist for unit test, and save their info in all_platform_info keyed by name
+  all_platform_info = {}
+  config.platforms_to_unittest.each { |p| all_platform_info[p] = assured_platform("unittest", p, config) }
+
+  inform("Library conforms to Arduino library specification") { cpp_library.one_point_five? ? "1.5" : "1.0" }
+
+  # iterate boards / tests
+  if !cpp_library.tests_dir.exist?
+    inform_multiline("Skipping unit tests; no tests dir at #{cpp_library.tests_dir}") do
+      puts "  In case that's an error, this is what was found in the library:"
+      display_files(cpp_library.tests_dir.parent)
+      true
+    end
+  elsif cpp_library.test_files.empty?
+    inform_multiline("Skipping unit tests; no test files were found in #{cpp_library.tests_dir}") do
+      puts "  In case that's an error, this is what was found in the tests directory:"
+      display_files(cpp_library.tests_dir)
+      true
+    end
+  elsif config.platforms_to_unittest.empty?
+    inform("Skipping unit tests") { "no platforms were requested" }
+  else
+    install_arduino_library_dependencies(config.aux_libraries_for_unittest)
+
+    config.platforms_to_unittest.each do |p|
+      config.allowable_unittest_files(cpp_library.test_files).each do |unittest_path|
+        unittest_name = unittest_path.basename.to_s
+        compilers.each do |gcc_binary|
+          attempt_multiline("Unit testing #{unittest_name} with #{gcc_binary} for #{p}") do
+            exe = cpp_library.build_for_test_with_configuration(
+              unittest_path,
+              config.aux_libraries_for_unittest,
+              gcc_binary,
+              config.gcc_config(p)
+            )
+            puts
+            unless exe
+              puts "Last command: #{cpp_library.last_cmd}"
+              puts cpp_library.last_out
+              puts cpp_library.last_err
+              next false
+            end
+            cpp_library.run_test_file(exe)
+          end
+        end
+      end
+    end
+  end
+end
+
+def perform_compilation_tests(config)
+  if @cli_options[:skip_compilation]
+    inform("Skipping compilation of examples") { "as requested via command line" }
+    return
+  end
+
+  # index the existing libraries
+  attempt("Indexing libraries") { @arduino_cmd.index_libraries } unless @arduino_cmd.libraries_indexed
+
+  # initialize library under test
+  installed_library_path = attempt("Installing library under test") do
+    @arduino_cmd.install_local_library(Pathname.new("."))
+  end
+
+  if !installed_library_path.nil? && installed_library_path.exist?
+    inform("Library installed at") { installed_library_path.to_s }
+  else
+    assure_multiline("Library installed successfully") do
+      if installed_library_path.nil?
+        puts @arduino_cmd.last_msg
+      else
+        # print out the contents of the deepest directory we actually find
+        @arduino_cmd.lib_dir.ascend do |path_part|
+          next unless path_part.exist?
+
+          break display_files(path_part)
+        end
+        false
+      end
+    end
+  end
+  library_examples = @arduino_cmd.library_examples(installed_library_path)
+
+  # gather up all required boards for compilation so we can install them up front.
+  # start with the "platforms to unittest" and add the examples
+  # while we're doing that, get the aux libraries as well
+  example_platform_info = {}
+  board_package_url = {}
+  aux_libraries = Set.new(config.aux_libraries_for_build)
+  # while collecting the platforms, ensure they're defined
+
+  library_examples.each do |path|
+    ovr_config = config.from_example(path)
+    ovr_config.platforms_to_build.each do |platform|
+      # assure the platform if we haven't already
+      next if example_platform_info.key?(platform)
+
+      platform_info = assured_platform("library example", platform, config)
+      next if platform_info.nil?
+
+      example_platform_info[platform] = platform_info
+      package = platform_info[:package]
+      board_package_url[package] = ovr_config.package_url(package)
+    end
+    aux_libraries.merge(ovr_config.aux_libraries_for_build)
+  end
+
+  # with all platform info, we can extract unique packages and their urls
+  # do that, set the URLs, and download the packages
+  all_packages = example_platform_info.values.map { |v| v[:package] }.uniq.reject(&:nil?)
+
+  # inform about builtin packages
+  all_packages.select { |p| config.package_builtin?(p) }.each do |p|
+    inform("Using built-in board package") { p }
+  end
+
+  # make sure any non-builtin package has a URL defined
+  all_packages.reject { |p| config.package_builtin?(p) }.each do |p|
+    assure("Board package #{p} has a defined URL") { board_package_url[p] }
+  end
+
+  # set up all the board manager URLs.
+  # we can safely reject nils now, they would be for the builtins
+  all_urls = all_packages.map { |p| board_package_url[p] }.uniq.reject(&:nil?)
+
+  unless all_urls.empty?
+    assure("Setting board manager URLs") do
+      @arduino_cmd.board_manager_urls = all_urls
+    end
+  end
+
+  all_packages.each do |p|
+    assure("Installing board package #{p}") do
+      @arduino_cmd.install_boards(p)
+    end
+  end
+
+  install_arduino_library_dependencies(aux_libraries)
+
+  last_board = nil
+  if config.platforms_to_build.empty?
+    inform("Skipping builds") { "no platforms were requested" }
+    return
+  elsif library_examples.empty?
+    inform_multiline("Skipping builds; no examples found in #{installed_library_path}") do
+      display_files(installed_library_path)
+    end
+    return
+  end
+
+  attempt("Setting compiler warning level")  { @arduino_cmd.set_pref("compiler.warning_level", "all") }
+
+  # switching boards takes time, so iterate board first
+  # _then_ whichever examples match it
+  examples_by_platform = library_examples.each_with_object({}) do |example_path, acc|
+    ovr_config = config.from_example(example_path)
+    ovr_config.platforms_to_build.each do |p|
+      acc[p] = [] unless acc.key?(p)
+      acc[p] << example_path
+    end
+  end
+
+  examples_by_platform.each do |platform, example_paths|
+    board = example_platform_info[platform][:board]
+    assure("Switching to board for #{platform} (#{board})") { @arduino_cmd.use_board(board) } unless last_board == board
+    last_board = board
+
+    example_paths.each do |example_path|
+      example_name = File.basename(example_path)
+      attempt("Verifying #{example_name}") do
+        ret = @arduino_cmd.verify_sketch(example_path)
+        unless ret
+          puts
+          puts "Last command: #{@arduino_cmd.last_msg}"
+          puts @arduino_cmd.last_err
+        end
+        ret
+      end
+    end
+  end
+
+end
+
+# initialize command and config
+config = ArduinoCI::CIConfig.default.from_project_library
+
+@arduino_cmd = ArduinoCI::ArduinoInstallation.autolocate!
+inform("Located Arduino binary") { @arduino_cmd.binary_path.to_s }
+
+perform_unit_tests(config)
+perform_compilation_tests(config)
+
+terminate(true)