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

      this.function = checkNotNull(function);
    }

    @Override
    public void clear() {
      fromCollection.clear();
    }

    @Override
    public boolean isEmpty() {
      return fromCollection.isEmpty();
    }

    @Override
    public Iterator<T> iterator() {
      return Iterators.transform(fromCollection.iterator(), function);
    }

    @Override

        assertEquals("c", result.get(2));

        List<String> empty = MapValueExtractor.getStringList(map, "empty");
        assertTrue(empty.isEmpty());

        assertTrue(MapValueExtractor.getStringList(map, "missing").isEmpty());
    }

    @Test
    public void testGetMap() {
        Map<String, Object> inner = new HashMap<>();
        inner.put("innerKey", "innerValue");

                    .toArtifactType();
        }

        boolean system = dependency.getSystemPath() != null
                && !dependency.getSystemPath().isEmpty();

        Map<String, String> props = null;
        if (system) {
            props = Collections.singletonMap(MavenArtifactProperties.LOCAL_PATH, dependency.getSystemPath());
        }

        for (int i = 0; i < NUM; i++) {
            tokens.add(accessTokenHelper.generateAccessToken());
        }
        for (int i = 0; i < NUM; i++) {
            assertFalse(tokens.get(i).isEmpty());
            for (int j = i + 1; j < NUM; j++) {
                assertFalse(tokens.get(i).equals(tokens.get(j)));
            }
        }
    }

    @Test
    public void test_getAccessTokenFromRequest_ok0() {

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

import assertk.assertThat
import assertk.assertions.hasMessage
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import assertk.assertions.isNull
import com.squareup.zstd.okio.zstdCompress
import java.io.IOException
import kotlin.test.assertFailsWith
import okhttp3.CompressionInterceptor

    JavadocScanner(String rawCommentText) {
        pushText(rawCommentText);
    }

    @Override
    public String toString() {
        return input.substring(pos);
    }

    public boolean isEmpty() {
        return pos == input.length();
    }

    public void mark() {
        markPos = pos;
    }

    public void next() {
        next(1);
    }

    public void next(int n) {

  }

  @Override
  public @Nullable E higher(E e) {
    return delegate.higher(checkValid(e));
  }

  @Override
  public boolean isEmpty() {
    return delegate.isEmpty();
  }

  @Override
  public Iterator<E> iterator() {
    return delegate.iterator();
  }

  @Override
  public E last() {
    return delegate.last();
  }

    bimap = EnumHashBiMap.create(emptyBimap);
    assertTrue(bimap.isEmpty());

    /* Map can be empty if it's an EnumBiMap. */
    Map<Currency, Country> emptyBimap2 = EnumBiMap.create(Currency.class, Country.class);
    EnumHashBiMap<Currency, Country> bimap2 = EnumHashBiMap.create(emptyBimap2);
    assertTrue(bimap2.isEmpty());
  }

  public void testEnumHashBiMapConstructor() {

        map.put(keyOne, valueOne);
        assertThat(segment.recencyQueue.isEmpty()).isTrue();

        for (int i = 0; i < DRAIN_THRESHOLD / 2; i++) {
          map.get(keyOne);
        }
        assertThat(segment.recencyQueue.isEmpty()).isFalse();

        map.put(keyTwo, valueTwo);
        assertThat(segment.recencyQueue.isEmpty()).isTrue();
      }
    }
  }