}

    /**
     * Test method for
     * {@link org.codelibs.core.collection.CollectionsUtil#isNotEmpty(java.util.Collection)}
     * .
     */
    @Test
    public void testIsNotEmptyCollectionOfQ() {
        final Collection<String> c = new ArrayList<String>();
        c.add("hoge");
        assertThat(CollectionsUtil.isNotEmpty(c), is(true));
    }

    /**
     * Test method for

""",
            )
            if (performanceTestProject.performanceTests.any { it.testProjects.isNotEmpty() }) {
                val dependencyBuildIds =
                    performanceTestProject.performanceTests
                        .filter { it.testProjects.isNotEmpty() }
                        .joinToString(",") { "%dep.${it.id}.env.BUILD_ID%" }

                val dependencyBaselines =

    when {
        isNotEmpty() -> this
        type?.typeParameters?.isNotEmpty() == true -> List(type.typeParameters.size) { starProjectionTypeUsage }
        else -> emptyList()
    }


private
fun <T> List<T>?.joinInAngleBrackets(transform: (T) -> CharSequence = { it.toString() }) =
    this?.takeIf { it.isNotEmpty() }

                } catch (e: Exception) {
                    exceptions.add(e)
                }
            }
        when {
            exceptions.size == 1 -> throw exceptions.first()
            exceptions.isNotEmpty() -> throw DefaultMultiCauseException("Test files cleanup verification failed", exceptions)
            else -> {
            }
        }
    }

    private

        // https://github.com/google/conscrypt/issues/985
        // assertThat(directSessionIds).containsExactlyInAnyOrder(sessionIds[0], sessionIds[1])
      } else {
        assertThat(sessionIds[0]).isNotEmpty()
        assertThat(sessionIds[1]).isNotEmpty()

        assertThat(directSessionIds).containsExactlyInAnyOrder(sessionIds[1])
      }
    } else {
      if (tlsVersion == TlsVersion.TLS_1_3) {

                    if (StringUtil.isNotEmpty(role)) {
                        roleSet.add(role);
                    }
                }
            }
        } else {
            final String[] roles = rolesStr.split(roleSeparator);
            for (final String role : roles) {
                if (StringUtil.isNotEmpty(role)) {
                    roleSet.add(role);
                }

        }

        val mismatches = originalChanges.mapValues {
            findMismatches(it.value, sortedChanges[it.key]!!)
        }.filterValues {
            it.isNotEmpty()
        }

        if (mismatches.isNotEmpty()) {
            val formattedMismatches = mismatches.mapValues { mismatch ->
                mismatch.value.joinToString(separator = "\n", transform = { "\t" + it })
            }

                if (projectsToEnableNullaway.isNotEmpty()) {
                    println("${toEnableCount} ${projectS(toEnableCount)} with checked dependencies are ready to be worked on:")
                    projectsToEnableNullaway.sorted().forEach {
                        println("  * $it")
                    }
                } else if (projectsWithUncheckedDeps.isNotEmpty()) {

        }
      }
    }

  internal fun kickCoordinator(taskQueue: TaskQueue) {
    assertLockHeld()

    if (taskQueue.activeTask == null) {
      if (taskQueue.futureTasks.isNotEmpty()) {
        readyQueues.addIfAbsent(taskQueue)
      } else {
        readyQueues.remove(taskQueue)
      }
    }

    if (coordinatorWaiting) {
      backend.coordinatorNotify(this@TaskRunner)

 * limitations under the License.
 */
package okhttp3.containers

import assertk.assertThat
import assertk.assertions.contains
import assertk.assertions.isEmpty
import assertk.assertions.isNotEmpty
import java.io.ByteArrayOutputStream
import java.io.PrintStream
import java.util.concurrent.ExecutorService
import java.util.concurrent.Executors
import okhttp3.Dispatcher
import okhttp3.HttpUrl.Companion.toHttpUrl