*/
    public static void sleep(final long millis) {
        if (millis < 1L) {
            return;
        }
        try {
            Thread.sleep(millis);
        } catch (final InterruptedException e) {
            throw new InterruptedRuntimeException(e);
        }
    }

    /**

        when(mockAllocInfo.getFree()).thenReturn(400L);

        assertEquals(1000L, mockAllocInfo.getCapacity(), "capacity should match stubbed value");
        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**

        fail("Expected IllegalStateException");
      } catch (IllegalStateException expected) {
      }
      try {
        actualStats.populationVariance();
        fail("Expected IllegalStateException");
      } catch (IllegalStateException expected) {
      }
      try {
        actualStats.min();
        fail("Expected IllegalStateException");
      } catch (IllegalStateException expected) {
      }
      try {

            AvPair decoded = decodedPairs.get(i);

            assertEquals(original.getType(), decoded.getType(), "Type should match at index " + i);
            assertTrue(Arrays.equals(original.getRaw(), decoded.getRaw()), "Raw data should match at index " + i);
        }
    }

    /**
     * Test decode with AvSingleHost type
     */
    @Test

                        badWordBhv.update(badWord);
                    }
                } catch (final Exception e) {
                    logger.warn("Failed to read a suggest bad word: {}", list, e);
                }
            }
            searchEngineClient.refresh("_all"); // TODO replace _all
        } catch (final IOException e) {
            logger.warn("Failed to read a suggest bad word.", e);
        }
    }

    }

    @Override
    public boolean hasNext() {
      return iterator.hasNext();
    }

    @Override
    public T next() {
      try {
        return iterator.next();
      } catch (NoSuchElementException e) {
        nextThrewException = true;
        throw e;
      }
    }

    @Override
    public void remove() {
      if (nextThrewException) {

#!/usr/bin/env bash

echo "Running $0"

set -x

trap 'catch $LINENO' ERR

# shellcheck disable=SC2120
catch() {
	if [ $# -ne 0 ]; then
		echo "error on line $1"
		for site in sitea siteb; do
			echo "$site server logs ========="
			cat "/tmp/${site}_1.log"
			echo "==========================="
			cat "/tmp/${site}_2.log"
		done
	fi

	echo "Cleaning up instances of MinIO"
	pkill minio
	pkill -9 minio

    return new CompositionPredicate<>(predicate, function);
  }

  /**
   * Returns a predicate that evaluates to {@code true} if the {@code CharSequence} being tested
   * contains any match for the given regular expression pattern. The test used is equivalent to
   * {@code Pattern.compile(pattern).matcher(arg).find()}
   *
   * @throws IllegalArgumentException if the pattern is invalid
   * @since 3.0
   */

      try {
        helper = new UnsafeAtomicHelper();
      } catch (Exception | Error unsafeFailure) { // sneaky checked exception
        thrownUnsafeFailure = unsafeFailure;
        // Catch absolutely everything and fall through to AtomicReferenceFieldUpdaterAtomicHelper.
        try {
          helper = new AtomicReferenceFieldUpdaterAtomicHelper();
        } catch (Exception // sneaky checked exception

          }
        }
        if (f != null) {
          --active;
          try {
            return f.get();
          } catch (ExecutionException eex) {
            ee = eex;
          } catch (InterruptedException iex) {
            throw iex;
          } catch (Exception rex) { // sneaky checked exception
            ee = new ExecutionException(rex);
          }
        }
      }