busser-bats 0.6.0 → 0.7.0

data/vendor/bats/lib/bats-core/common.bash

@@ -0,0 +1,278 @@
+#!/usr/bin/env bash
+
+bats_prefix_lines_for_tap_output() {
+  while IFS= read -r line; do
+    printf '# %s\n' "$line" || break # avoid feedback loop when errors are redirected into BATS_OUT (see #353)
+  done
+  if [[ -n "$line" ]]; then
+    printf '# %s\n' "$line"
+  fi
+}
+
+function bats_replace_filename() {
+  local line
+  while read -r line; do
+    printf "%s\n" "${line//$BATS_TEST_SOURCE/$BATS_TEST_FILENAME}"
+  done
+  if [[ -n "$line" ]]; then
+    printf "%s\n" "${line//$BATS_TEST_SOURCE/$BATS_TEST_FILENAME}"
+  fi
+}
+
+bats_quote_code() { # <var> <code>
+  printf -v "$1" -- "%s%s%s" "$BATS_BEGIN_CODE_QUOTE" "$2" "$BATS_END_CODE_QUOTE"
+}
+
+bats_check_valid_version() {
+  if [[ ! $1 =~ [0-9]+.[0-9]+.[0-9]+ ]]; then
+    printf "ERROR: version '%s' must be of format <major>.<minor>.<patch>!\n" "$1" >&2
+    exit 1
+  fi
+}
+
+# compares two versions. Return 0 when version1 < version2
+bats_version_lt() { # <version1> <version2>
+  bats_check_valid_version "$1"
+  bats_check_valid_version "$2"
+
+  local -a version1_parts version2_parts
+  IFS=. read -ra version1_parts <<<"$1"
+  IFS=. read -ra version2_parts <<<"$2"
+
+  local -i i
+  for i in {0..2}; do
+    if ((version1_parts[i] < version2_parts[i])); then
+      return 0
+    elif ((version1_parts[i] > version2_parts[i])); then
+      return 1
+    fi
+  done
+  # if we made it this far, they are equal -> also not less then
+  return 2 # use other failing return code to distinguish equal from gt
+}
+
+# ensure a minimum version of bats is running or exit with failure
+bats_require_minimum_version() { # <required version>
+  local required_minimum_version=$1
+
+  if bats_version_lt "$BATS_VERSION" "$required_minimum_version"; then
+    printf "BATS_VERSION=%s does not meet required minimum %s\n" "$BATS_VERSION" "$required_minimum_version"
+    exit 1
+  fi
+
+  if bats_version_lt "$BATS_GUARANTEED_MINIMUM_VERSION" "$required_minimum_version"; then
+    BATS_GUARANTEED_MINIMUM_VERSION="$required_minimum_version"
+  fi
+}
+
+# returns 0 when search-value is found in array
+bats_linear_reverse_search() { # <search-value> <array-name>
+  local -r search_value=$1 array_name=$2
+  eval "local -ri array_length=\${#${array_name}[@]}"
+  # shellcheck disable=SC2154
+  for ((i=array_length - 1; i >=0; --i)); do
+    eval "local value=\"\${${array_name}[i]}\""
+    # shellcheck disable=SC2154
+    if [[ $value == "$search_value" ]]; then
+      return 0
+    fi
+  done
+  return 1
+}
+
+# returns 0 when search-value is found in array
+bats_binary_search() { # <search-value> <array-name>
+  if [[ $# -ne 2 ]]; then
+    printf "ERROR: bats_binary_search requires exactly 2 arguments: <search value> <array name>\n" >&2
+    return 2
+  fi
+
+  local -r search_value=$1 array_name=$2
+
+  # we'd like to test if array is set but we cannot distinguish unset from empty arrays, so we need to skip that
+
+  local start=0 mid end mid_value
+  # start is inclusive, end is exclusive ...
+  eval "end=\${#${array_name}[@]}"
+
+  # so start == end means empty search space
+  while ((start < end)); do
+    mid=$(((start + end) / 2))
+    eval "mid_value=\${${array_name}[$mid]}"
+    if [[ "$mid_value" == "$search_value" ]]; then
+      return 0
+    elif [[ "$mid_value" < "$search_value" ]]; then
+      # This branch excludes equality -> +1 to skip the mid element.
+      # This +1 also avoids endless recursion on odd sized search ranges.
+      start=$((mid + 1))
+    else
+      end=$mid
+    fi
+  done
+
+  # did not find it -> its not there
+  return 1
+}
+
+# store the values in ascending (string!) order in result array
+# Intended for short lists! (uses insertion sort)
+bats_sort() { # <result-array-name> <values to sort...>
+  local -r result_name=$1
+  shift
+
+  if (($# == 1)) && [[ $1 == "" ]]; then
+    shift # remove leading "" to deal with bash 3 expanding "${empty_array[@]}" to one ""
+  fi
+
+  if (($# == 0)); then
+    eval "$result_name=()"
+    return 0
+  fi
+
+  local -a sorted_array=()
+  local -i i
+  while (( $# > 0 )); do # loop over input values
+    local current_value="$1"
+    shift
+    for ((i = ${#sorted_array[@]}; i >= 0; --i)); do # loop over output array from end
+      if (( i == 0 )) || [[ ${sorted_array[i - 1]} < $current_value ]]; then
+        # insert new element at (freed) desired location
+        sorted_array[i]=$current_value
+        break
+      else
+        # shift bigger elements one position to the end
+        sorted_array[i]=${sorted_array[i - 1]}
+      fi
+    done
+  done
+
+  eval "$result_name=(\"\${sorted_array[@]}\")"
+}
+
+# check if all search values (must be sorted!) are in the (sorted!) array
+# Intended for short lists/arrays!
+bats_all_in() { # <sorted-array> <sorted search values...>
+  local -r haystack_array=$1
+  shift
+
+  local -i haystack_length # just to appease shellcheck
+  eval "local -r haystack_length=\${#${haystack_array}[@]}"
+
+  local -i haystack_index=0         # initialize only here to continue from last search position
+  local search_value haystack_value # just to appease shellcheck
+  local -i i
+  for ((i = 1; i <= $#; ++i)); do
+    eval "local search_value=${!i}"
+    for (( ; haystack_index < haystack_length; ++haystack_index)); do
+      eval "local haystack_value=\${${haystack_array}[$haystack_index]}"
+      if [[ $haystack_value > "$search_value" ]]; then
+        # we passed the location this value would have been at -> not found
+        return 1
+      elif [[ $haystack_value == "$search_value" ]]; then
+        continue 2 # search value found  -> try the next one
+      fi
+    done
+    return 1 # we ran of the end of the haystack without finding the value!
+  done
+
+  # did not return from loop above -> all search values were found
+  return 0
+}
+
+# check if any search value (must be sorted!) is in the (sorted!) array
+# intended for short lists/arrays
+bats_any_in() { # <sorted-array> <sorted search values>
+  local -r haystack_array=$1
+  shift
+
+  local -i haystack_length # just to appease shellcheck
+  eval "local -r haystack_length=\${#${haystack_array}[@]}"
+
+  local -i haystack_index=0         # initialize only here to continue from last search position
+  local search_value haystack_value # just to appease shellcheck
+  local -i i
+  for ((i = 1; i <= $#; ++i)); do
+    eval "local search_value=${!i}"
+    for (( ; haystack_index < haystack_length; ++haystack_index)); do
+      eval "local haystack_value=\${${haystack_array}[$haystack_index]}"
+      if [[ $haystack_value > "$search_value" ]]; then
+        continue 2 # search value not in array! -> try next
+      elif [[ $haystack_value == "$search_value" ]]; then
+        return 0 # search value found
+      fi
+    done
+  done
+
+  # did not return from loop above -> no search value was found
+  return 1
+}
+
+bats_trim() {                                            # <output-variable> <string>
+  local -r bats_trim_ltrimmed=${2#"${2%%[![:space:]]*}"} # cut off leading whitespace
+  # shellcheck disable=SC2034 # used in eval!
+  local -r bats_trim_trimmed=${bats_trim_ltrimmed%"${bats_trim_ltrimmed##*[![:space:]]}"} # cut off trailing whitespace
+  eval "$1=\$bats_trim_trimmed"
+}
+
+# a helper function to work around unbound variable errors with ${arr[@]} on Bash 3
+bats_append_arrays_as_args() { # <array...> -- <command ...>
+  local -a trailing_args=()
+  while (($# > 0)) && [[ $1 != -- ]]; do
+    local array=$1
+    shift
+
+    if eval "(( \${#${array}[@]} > 0 ))"; then
+      eval "trailing_args+=(\"\${${array}[@]}\")"
+    fi
+  done
+  shift # remove -- separator
+
+  if (($# == 0)); then
+    printf "Error: append_arrays_as_args is missing a command or -- separator\n" >&2
+    return 1
+  fi
+
+  if ((${#trailing_args[@]} > 0)); then
+    "$@" "${trailing_args[@]}"
+  else
+    "$@"
+  fi
+}
+
+bats_format_file_line_reference() { # <output> <file> <line>
+  # shellcheck disable=SC2034 # will be used in subimplementation
+  local output="${1?}"
+  shift
+  "bats_format_file_line_reference_${BATS_LINE_REFERENCE_FORMAT?}" "$@"
+}
+
+bats_format_file_line_reference_comma_line() {
+  printf -v "$output" "%s, line %d" "$@"
+}
+
+bats_format_file_line_reference_colon() {
+  printf -v "$output" "%s:%d" "$@"
+}
+
+# approximate realpath without subshell
+bats_approx_realpath() { # <output-variable> <path>
+  local output=$1 path=$2
+  if [[ $path != /* ]]; then
+    path="$PWD/$path"
+  fi
+  # x/./y -> x/y
+  path=${path//\/.\//\/}
+  printf -v "$output" "%s" "$path"
+}
+
+bats_format_file_line_reference_uri() {
+  local filename=${1?} line=${2?}
+  bats_approx_realpath filename "$filename"
+  printf -v "$output" "file://%s:%d" "$filename" "$line"
+}
+
+# execute command with backed up path
+# to prevent path mocks from interfering with our internals
+bats_execute() { # <command...>
+  PATH="${BATS_SAVED_PATH?}" "$@"
+}

data/vendor/bats/lib/bats-core/formatter.bash

@@ -0,0 +1,151 @@
+#!/usr/bin/env bash
+
+# reads (extended) bats tap streams from stdin and calls callback functions for each line
+#
+# Segmenting functions
+# ====================
+# bats_tap_stream_plan <number of tests>                                      -> when the test plan is encountered
+# bats_tap_stream_suite <file name>                                           -> when a new file is begun WARNING: extended only
+# bats_tap_stream_begin <test index> <test name>                              -> when a new test is begun WARNING: extended only
+#
+# Test result functions
+# =====================
+# If timing was enabled, BATS_FORMATTER_TEST_DURATION will be set to their duration in milliseconds
+# bats_tap_stream_ok <test index> <test name>                                 -> when a test was successful
+# bats_tap_stream_not_ok <test index> <test name>                             -> when a test has failed. If the failure was due to a timeout,
+#                                                                                BATS_FORMATTER_TEST_TIMEOUT is set to the timeout duration in seconds
+# bats_tap_stream_skipped <test index> <test name> <skip reason>              -> when a test was skipped
+#
+# Context functions
+# =================
+# bats_tap_stream_comment <comment text without leading '# '> <scope>         -> when a comment line was encountered,
+#                                                                                scope tells the last encountered of plan, begin, ok, not_ok, skipped, suite
+# bats_tap_stream_unknown <full line> <scope>                                 -> when a line is encountered that does not match the previous entries,
+#                                                                                scope @see bats_tap_stream_comment
+# forwards all input as is, when there is no TAP test plan header
+function bats_parse_internal_extended_tap() {
+  local header_pattern='[0-9]+\.\.[0-9]+'
+  IFS= read -r header
+
+  if [[ "$header" =~ $header_pattern ]]; then
+    bats_tap_stream_plan "${header:3}"
+  else
+    # If the first line isn't a TAP plan, print it and pass the rest through
+    printf '%s\n' "$header"
+    exec cat
+  fi
+
+  ok_line_regexpr="ok ([0-9]+) (.*)"
+  skip_line_regexpr="ok ([0-9]+) (.*) # skip( (.*))?$"
+  timeout_line_regexpr="not ok ([0-9]+) (.*) # timeout after ([0-9]+)s$"
+  not_ok_line_regexpr="not ok ([0-9]+) (.*)"
+
+  timing_expr="in ([0-9]+)ms$"
+  local test_name begin_index last_begin_index try_index ok_index not_ok_index index scope
+  begin_index=0
+  last_begin_index=-1
+  try_index=0
+  index=0
+  scope=plan
+  while IFS= read -r line; do
+    unset BATS_FORMATTER_TEST_DURATION BATS_FORMATTER_TEST_TIMEOUT
+    case "$line" in
+    'begin '*) # this might only be called in extended tap output
+      scope=begin
+      begin_index=${line#begin }
+      begin_index=${begin_index%% *}
+      if [[ $begin_index == "$last_begin_index" ]]; then
+        (( ++try_index ))
+      else
+        try_index=0
+      fi
+      test_name="${line#begin "$begin_index" }"
+      bats_tap_stream_begin "$begin_index" "$test_name"
+      ;;
+    'ok '*)
+      ((++index))
+      if [[ "$line" =~ $ok_line_regexpr ]]; then
+        ok_index="${BASH_REMATCH[1]}"
+        test_name="${BASH_REMATCH[2]}"
+        if [[ "$line" =~ $skip_line_regexpr ]]; then
+          scope=skipped
+          test_name="${BASH_REMATCH[2]}" # cut off name before "# skip"
+          local skip_reason="${BASH_REMATCH[4]}"
+          if [[ "$test_name" =~ $timing_expr ]]; then
+            local BATS_FORMATTER_TEST_DURATION="${BASH_REMATCH[1]}"
+            test_name="${test_name% in "${BATS_FORMATTER_TEST_DURATION}"ms}"
+            bats_tap_stream_skipped "$ok_index" "$test_name" "$skip_reason"
+          else
+            bats_tap_stream_skipped "$ok_index" "$test_name" "$skip_reason"
+          fi
+        else
+          scope=ok
+          if [[ "$line" =~ $timing_expr ]]; then
+            local BATS_FORMATTER_TEST_DURATION="${BASH_REMATCH[1]}"
+            bats_tap_stream_ok "$ok_index" "${test_name% in "${BASH_REMATCH[1]}"ms}"
+          else
+            bats_tap_stream_ok "$ok_index" "$test_name"
+          fi
+        fi
+      else
+        printf "ERROR: could not match ok line: %s" "$line" >&2
+        exit 1
+      fi
+      ;;
+    'not ok '*)
+      ((++index))
+      scope=not_ok
+      if [[ "$line" =~ $not_ok_line_regexpr ]]; then
+        not_ok_index="${BASH_REMATCH[1]}"
+        test_name="${BASH_REMATCH[2]}"
+        if [[ "$line" =~ $timeout_line_regexpr ]]; then
+          not_ok_index="${BASH_REMATCH[1]}"
+          test_name="${BASH_REMATCH[2]}"
+          # shellcheck disable=SC2034 # used in bats_tap_stream_ok
+          local BATS_FORMATTER_TEST_TIMEOUT="${BASH_REMATCH[3]}"
+        fi
+        if [[ "$test_name" =~ $timing_expr ]]; then
+          # shellcheck disable=SC2034 # used in bats_tap_stream_ok
+          local BATS_FORMATTER_TEST_DURATION="${BASH_REMATCH[1]}"
+          test_name="${test_name% in "${BASH_REMATCH[1]}"ms}"
+        fi
+        bats_tap_stream_not_ok "$not_ok_index" "$test_name"
+      else
+        printf "ERROR: could not match not ok line: %s" "$line" >&2
+        exit 1
+      fi
+      ;;
+    '# '*)
+      bats_tap_stream_comment "${line:2}" "$scope"
+      ;;
+    '#')
+      bats_tap_stream_comment "" "$scope"
+      ;;
+    'suite '*)
+      scope=suite
+      # pass on the
+      bats_tap_stream_suite "${line:6}"
+      ;;
+    *)
+      bats_tap_stream_unknown "$line" "$scope"
+      ;;
+    esac
+  done
+}
+
+normalize_base_path() { # <target variable> <base path>
+  # the relative path root to use for reporting filenames
+  # this is mainly intended for suite mode, where this will be the suite root folder
+  local base_path="$2"
+  # use the containing directory when --base-path is a file
+  if [[ ! -d "$base_path" ]]; then
+    base_path="$(dirname "$base_path")"
+  fi
+  # get the absolute path
+  base_path="$(cd "$base_path" && pwd)"
+  # ensure the path ends with / to strip that later on
+  if [[ "${base_path}" != *"/" ]]; then
+    base_path="$base_path/"
+  fi
+  printf -v "$1" "%s" "$base_path"
+}

data/vendor/bats/lib/bats-core/preprocessing.bash

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+bats_export_preprocess_source_BATS_TEST_SOURCE() {
+  # export to make it visible to bats_evaluate_preprocessed_source
+  # since the latter runs in bats-exec-test's bash while this runs in bats-exec-file's
+  export BATS_TEST_SOURCE="$BATS_RUN_TMPDIR/${BATS_TEST_FILE_NUMBER?}-${BATS_TEST_FILENAME##*/}.src"
+}
+
+bats_preprocess_source() { # index
+  bats_export_preprocess_source_BATS_TEST_SOURCE
+  # shellcheck disable=SC2153
+  CHECK_BATS_COMMENT_COMMANDS=1 "$BATS_ROOT/libexec/bats-core/bats-preprocess" "$BATS_TEST_FILENAME" >"$BATS_TEST_SOURCE"
+}
+
+bats_evaluate_preprocessed_source() {
+  # Dynamically loaded user files provided outside of Bats.
+  # shellcheck disable=SC1090
+  source "${BATS_TEST_SOURCE?}"
+}

data/vendor/bats/lib/bats-core/semaphore.bash

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+
+bats_run_under_flock() {
+  flock "$BATS_SEMAPHORE_DIR" "$@"
+}
+
+bats_run_under_shlock() {
+      local lockfile="$BATS_SEMAPHORE_DIR/shlock.lock"
+      while ! shlock -p $$ -f "$lockfile"; do
+        sleep 1
+      done
+      # we got the lock now, execute the command
+      "$@"
+      local status=$?
+      # free the lock
+      rm -f "$lockfile"
+      return $status
+    }
+
+# setup the semaphore environment for the loading file
+bats_semaphore_setup() {
+  export -f bats_semaphore_get_free_slot_count
+  export -f bats_semaphore_acquire_while_locked
+  export BATS_SEMAPHORE_DIR="$BATS_RUN_TMPDIR/semaphores"
+
+  if command -v flock >/dev/null; then
+    BATS_LOCKING_IMPLEMENTATION=flock
+  elif command -v shlock >/dev/null; then
+    BATS_LOCKING_IMPLEMENTATION=shlock
+  else
+    printf "ERROR: flock/shlock is required for parallelization within files!\n" >&2
+    exit 1
+  fi
+}
+
+# $1 - output directory for stdout/stderr
+# $@ - command to run
+# run the given command in a semaphore
+# block when there is no free slot for the semaphore
+# when there is a free slot, run the command in background
+# gather the output of the command in files in the given directory
+bats_semaphore_run() {
+  local output_dir=$1
+  shift
+  local semaphore_slot
+  semaphore_slot=$(bats_semaphore_acquire_slot)
+  bats_semaphore_release_wrapper "$output_dir" "$semaphore_slot" "$@" &
+  printf "%d\n" "$!"
+}
+
+# $1 - output directory for stdout/stderr
+# $@ - command to run
+# this wraps the actual function call to install some traps on exiting
+bats_semaphore_release_wrapper() {
+  local output_dir="$1"
+  local semaphore_name="$2"
+  shift 2 # all other parameters will be use for the command to execute
+
+  # shellcheck disable=SC2064 # we want to expand the semaphore_name right now!
+  trap "status=$?; bats_semaphore_release_slot '$semaphore_name'; exit $status" EXIT
+
+  mkdir -p "$output_dir"
+  "$@" 2>"$output_dir/stderr" >"$output_dir/stdout"
+  local status=$?
+
+  # bash bug: the exit trap is not called for the background process
+  bats_semaphore_release_slot "$semaphore_name"
+  trap - EXIT # avoid calling release twice
+  return $status
+}
+
+bats_semaphore_acquire_while_locked() {
+  if [[ $(bats_semaphore_get_free_slot_count) -gt 0 ]]; then
+    local slot=0
+    while [[ -e "$BATS_SEMAPHORE_DIR/slot-$slot" ]]; do
+      ((++slot))
+    done
+    if [[ $slot -lt $BATS_SEMAPHORE_NUMBER_OF_SLOTS ]]; then
+      touch "$BATS_SEMAPHORE_DIR/slot-$slot" && printf "%d\n" "$slot" && return 0
+    fi
+  fi
+  return 1
+}
+
+# block until a semaphore slot becomes free
+# prints the number of the slot that it received
+bats_semaphore_acquire_slot() {
+  mkdir -p "$BATS_SEMAPHORE_DIR"
+  # wait for a slot to become free
+  # TODO: avoid busy waiting by using signals -> this opens op prioritizing possibilities as well
+  while true; do
+    # don't lock for reading, we are fine with spuriously getting no free slot
+    if [[ $(bats_semaphore_get_free_slot_count) -gt 0 ]]; then
+      bats_run_under_"$BATS_LOCKING_IMPLEMENTATION" \
+        bash -c bats_semaphore_acquire_while_locked \
+      && break
+    fi
+    sleep 1
+  done
+}
+
+bats_semaphore_release_slot() {
+  # we don't need to lock this, since only our process owns this file
+  # and freeing a semaphore cannot lead to conflicts with others
+  rm "$BATS_SEMAPHORE_DIR/slot-$1" # this will fail if we had not acquired a semaphore!
+}
+
+bats_semaphore_get_free_slot_count() {
+  # find might error out without returning something useful when a file is deleted,
+  # while the directory is traversed ->  only continue when there was no error
+  until used_slots=$(find "$BATS_SEMAPHORE_DIR" -name 'slot-*' 2>/dev/null | wc -l); do :; done
+  echo $((BATS_SEMAPHORE_NUMBER_OF_SLOTS - used_slots))
+}