import static org.junit.Assert.assertTrue;

import org.junit.Test;

public class SuggestRequestTest {
    @Test
    public void test_isHiraganaQuery() throws Exception {
        SuggestRequest request = new SuggestRequest();
        assertTrue(request.isHiraganaQuery("あ"));
        assertTrue(request.isHiraganaQuery("あおぞら"));
        assertTrue(request.isHiraganaQuery("けんさく"));

    assertSame(dummyValue, segment.get(key, hash));
    assertTrue(segment.containsKey(key, hash));
    assertTrue(segment.containsValue(value));
    assertTrue(segment.containsValue(dummyValue));

    // expired
    dummy.setAccessTime(ticker.read() - 2);
    assertNull(segment.get(key, hash));
    assertFalse(segment.containsKey(key, hash));
    assertTrue(segment.containsValue(value));

    assertSame(dummyValue, segment.get(key, hash));
    assertTrue(segment.containsKey(key, hash));
    assertTrue(segment.containsValue(value));
    assertTrue(segment.containsValue(dummyValue));

    // expired
    dummy.setAccessTime(ticker.read() - 2);
    assertNull(segment.get(key, hash));
    assertFalse(segment.containsKey(key, hash));
    assertTrue(segment.containsValue(value));

    @Override
    public String toString() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.toString();
    }

    @Override
    public boolean equals(@Nullable Object o) {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.equals(o);
    }

    @Override
    public int hashCode() {
      assertTrue(Thread.holdsLock(mutex));
      return delegate.hashCode();
    }

    assertFalse(invokable.isPublic());
    assertTrue(invokable.isProtected());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testFinalMethod() throws Exception {
    Invokable<?, Object> invokable = A.method("publicFinalMethod");
    assertFalse(invokable.isAbstract());
    assertFalse(invokable.isPrivate());
    assertTrue(invokable.isFinal());
    assertTrue(invokable.isPublic());

    assertFalse(invokable.isPublic());
    assertTrue(invokable.isProtected());
    assertTrue(invokable.isAnnotationPresent(Tested.class));
  }

  public void testFinalMethod() throws Exception {
    Invokable<?, Object> invokable = A.method("publicFinalMethod");
    assertFalse(invokable.isAbstract());
    assertFalse(invokable.isPrivate());
    assertTrue(invokable.isFinal());
    assertTrue(invokable.isPublic());

    assertTrue(isNumber.apply(Integer.class));
    assertTrue(isNumber.apply(Float.class));
  }

  @J2ktIncompatible
  @GwtIncompatible // Predicates.subtypeOf
  public void testSubtypeOf_interface() {
    Predicate<Class<?>> isComparable = Predicates.subtypeOf(Comparable.class);

    assertTrue(isComparable.apply(Integer.class));
    assertTrue(isComparable.apply(Float.class));
  }

  }

  public void testContentEquals() throws IOException {
    assertTrue(source.contentEquals(source));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    ByteSource equalSource = new TestByteSource(bytes);
    assertTrue(source.contentEquals(equalSource));
    assertTrue(new TestByteSource(bytes).contentEquals(source));

                functionalTests.forEachIndexed { index, it ->
                    if (index == functionalTests.size - 1) {
                        assertTrue(it.getGradleParams().contains("-PexcludeTestClasses"))
                    } else {
                        assertTrue(it.getGradleParams().contains("-PincludeTestClasses"))
                    }
                }
            }
        }

    int oldSize = getNumElements();

    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));

    assertFalse(multimap().containsKey(k0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEmpty(result);

    assertTrue(result.add(v1()));
    assertTrue(result.add(v2()));

    assertContentsAnyOrder(result, v1(), v2());