.execute()
                    .actionGet(settings.getIndicesTimeout());

            final List<AnalyzeToken> termTokenList = termResponse.getTokens();
            if (termTokenList.isEmpty()) {
                return text;
            }

            return termTokenList.get(0).getTerm();
        }
    }

        Assertions.assertNotEquals(
                "${session.rootDirectory}", invokerRequest.userProperties().get("foo"));
        Assertions.assertFalse(invokerRequest.userProperties().get("foo").trim().isEmpty());
    }

            String msg = "Cannot register null or empty query: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidQueryCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {

            String msg = "Cannot register null or empty query: name=" + name + " value=" + value;
            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidQueryCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {

    }
    return null;
  }

  public @Nullable E ceiling(E e) {
    ImmutableSortedSet<E> set = tailSet(e, true);
    return !set.isEmpty() ? set.first() : null;
  }

  public @Nullable E floor(E e) {
    ImmutableSortedSet<E> set = headSet(e, true);
    return !set.isEmpty() ? set.last() : null;
  }

  public ImmutableSortedSet<E> headSet(E toElement, boolean inclusive) {
    checkNotNull(toElement);

     */
    @Test
    public void testClass() throws Exception {
        final Map<TypeVariable<?>, Type> map = GenericsUtil.getTypeVariableMap(Foo.class);
        assertThat(map, is(notNullValue()));
        assertThat(map.isEmpty(), is(false));
        assertThat(map.get(Foo.class.getTypeParameters()[0]), is(sameClass(Object.class)));
    }

    /**
     * @throws Exception
     */
    public void testGenericMethod() throws Exception {

        // Execute
        List<FileNotifyInformation> result = watchHandle.watch();

        // Verify
        assertNotNull(result);
        assertTrue(result.isEmpty());
        verify(watchHandle, times(1)).watch();
    }

    /**
     * Test watch() method throwing CIFSException
     */
    @Test
    void testWatchThrowsCIFSException() throws CIFSException {

 * limitations under the License.
 */
package okhttp3

import assertk.assertThat
import assertk.assertions.containsExactly
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import assertk.assertions.isSameAs
import assertk.assertions.isTrue
import kotlin.test.Test
import kotlin.test.assertFailsWith

        // MavenProject instance.
        // ----------------------------------------------------------------------

        if (expression == null || expression.isEmpty() || !Character.isJavaIdentifierStart(expression.charAt(0))) {
            return null;
        }

        boolean hasDots = expression.indexOf(PROPERTY_START) >= 0;

        final Tokenizer tokenizer;

      throw new IllegalArgumentException(e);
    }

    boolean empty;
    if (effectiveRange.isEmpty()) {
      empty = true;
    } else {
      /*
       * requireNonNull is safe because the effectiveRange operations above would have thrown or
       * effectiveRange.isEmpty() would have returned true.
       */
      C afterLower = requireNonNull(range.lowerBound.leastValueAbove(domain));