taskRunner = taskRunner,
        maxIdleConnections = 2,
      )
    factory.newConnection(pool, routeA1)
    // Racy causing flaky tests
    // assertThat(taskRunner.activeQueues()).isNotEmpty()
    assertThat(taskRunnerThreads).isNotEmpty()
    Thread.sleep(100)
    for (t in taskRunnerThreads) {
      t.interrupt()
    }
    Thread.sleep(100)
    assertThat(taskRunner.activeQueues()).isEmpty()
  }

        if (file == null) {
            return false;
        }

        String path;
        boolean missing;

        if (StringUtils.isNotEmpty(file.getExists())) {
            path = file.getExists();
            missing = false;
        } else if (StringUtils.isNotEmpty(file.getMissing())) {
            path = file.getMissing();
            missing = true;
        } else {
            return false;
        }

     * @param arrays
     *            the array
     * @return {@literal true} if the array is not {@literal null} and its length is not 0
     */
    public static <T> boolean isNotEmpty(final T[] arrays) {
        return arrays != null && arrays.length != 0;
    }

    /**
     * Returns {@literal true} if the array is {@literal null} or has a length of 0.
     *
     * @param arrays

        if (sysValue == null) {
            sysValue = context.getSystemProperties().get(name);
        }

        String propValue = property.getValue();
        if (StringUtils.isNotEmpty(propValue)) {
            boolean reverseValue = false;
            if (propValue.startsWith("!")) {
                reverseValue = true;
                propValue = propValue.substring(1);
            }

        }

        in 8..9 -> {
          id = source.readUtf8LineStrict().takeIf { it.isNotEmpty() }
        }

        in 10..12 -> {
          id = null // 'id' on a line of its own.
        }

        in 13..14 -> {
          type = source.readUtf8LineStrict().takeIf { it.isNotEmpty() }
        }

        in 15..17 -> {
          type = null // 'event' on a line of its own
        }

            final String resourceName = params != null ? params.get(ExtractData.RESOURCE_NAME_KEY) : null;

            String value = null;
            if (StringUtil.isNotEmpty(url)) {
                value = url;
            } else if (StringUtil.isNotEmpty(resourceName)) {
                value = resourceName;
            }

            if (value != null) {

    }

    /**
     *
     */
    @Test
    public void testIsNotEmpty() {
        assertFalse(StringUtil.isNotEmpty(null));
        assertFalse(StringUtil.isNotEmpty(""));
        assertTrue(StringUtil.isNotEmpty(" "));
    }

    /**
     *
     */
    @Test
    public void testDefaultString() {
        assertThat(StringUtil.defaultString(null), is(""));

import static java.text.DateFormat.getDateInstance;
import static org.codelibs.core.collection.MultiIterator.iterable;
import static org.codelibs.core.lang.StringUtil.isEmpty;
import static org.codelibs.core.lang.StringUtil.isNotEmpty;
import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.text.DateFormat;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;

    val functions = collectKtFunctionsFor(qualifiedBaseName, method)
    if (functions.isNotEmpty()) {
        return functions.all(predicate)
    }

    val properties = collectKtPropertiesFor(qualifiedBaseName, method)
    return properties.isNotEmpty() && properties.all(predicate)
}


private

 */
package okhttp3

import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.containsExactly
import assertk.assertions.isEqualTo
import assertk.assertions.isNotEmpty
import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import mockwebserver3.MockResponse
import mockwebserver3.MockWebServer
import mockwebserver3.junit5.StartStop
import okhttp3.TestUtil.assumeNetwork