}

  public void testEmpty_tailSet() {
    SortedSet<String> set = of();
    assertSame(set, set.tailSet("f"));
  }

  public void testEmpty_subSet() {
    SortedSet<String> set = of();
    assertSame(set, set.subSet("c", "f"));
  }

  public void testEmpty_first() {
    SortedSet<String> set = of();
    assertThrows(NoSuchElementException.class, () -> set.first());
  }

  public void testEmpty_last() {

  interface Interface1 {
    @Subscribe
    void annotatedIn1(Object o);

    @Subscribe
    void annotatedIn1And2(Object o);

    @Subscribe
    void annotatedIn1And2AndClass(Object o);

    void declaredIn1AnnotatedIn2(Object o);

    void declaredIn1AnnotatedInClass(Object o);

    void nowhereAnnotated(Object o);
  }

  interface Interface2 extends Interface1 {

 *
 * @author Kevin Bourrillion
 */
@GwtCompatible(emulated = true)
public class PrimitivesTest extends TestCase {
  public void testIsWrapperType() {
    assertThat(Primitives.isWrapperType(Void.class)).isTrue();
    assertThat(Primitives.isWrapperType(void.class)).isFalse();
  }

  public void testWrap() {
    assertThat(Primitives.wrap(int.class)).isSameInstanceAs(Integer.class);

  }

  public void testOf() {
    assertEquals("training", Optional.of("training").get());
  }

  public void testOf_null() {
    assertThrows(NullPointerException.class, () -> Optional.of(null));
  }

  public void testFromNullable() {
    Optional<String> optionalName = Optional.fromNullable("bob");
    assertEquals("bob", optionalName.get());
  }

  public void testFromNullable_null() {

            .createTestSuite());
    suite.addTestSuite(ImmutableListMultimapTest.class);
    return suite;
  }

  public void testBuilderWithExpectedKeysNegative() {
    assertThrows(
        IllegalArgumentException.class, () -> ImmutableListMultimap.builderWithExpectedKeys(-1));
  }

  public void testBuilderWithExpectedKeysZero() {
    ImmutableListMultimap.Builder<String, String> builder =

public class DefaultCorsHandler extends CorsHandler {

    @PostConstruct
    public void register() {
        final CorsHandlerFactory factory = ComponentUtil.getCorsHandlerFactory();
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        fessConfig.getApiCorsAllowOriginList().forEach(s -> factory.add(s, this));
    }

    @Override

import java.io.IOException;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

public final class AccessHeaders {
  private final OkHttpClient client = new OkHttpClient();

  public void run() throws Exception {
    Request request = new Request.Builder()
        .url("https://api.github.com/repos/square/okhttp/issues")
        .header("User-Agent", "OkHttp Headers.java")

     * 
     * @throws SmbException
     */
    void treeConnectLogon () throws SmbException;


    /**
     * @param share
     * @param service
     * @return tree instance
     */
    SmbTree getSmbTree ( String share, String service );


    /**
     * Initiate reauthentication
     * 
     * @throws CIFSException
     */
    void reauthenticate () throws CIFSException;

import java.io.StringReader;

import org.junit.Test;

/**
 * @author koichik
 */
public class LineIteratorTest {

    /**
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        final StringReader reader = new StringReader("aaa\nbbb\nccc\n");
        final LineIterator it = new LineIterator(reader);
        assertThat(it.hasNext(), is(true));

            return userData[key]
        }

        void putUserData(String key, Object value) {
            userData[key] = value
        }
    }

    ClassPool instanceScopedPool = new ClassPool()

    JApiClass apiClass = Stub(JApiClass)

    def setup() {
        instanceScopedPool.appendSystemPath()
    }

    void noViolation(def rule) {
        assert rule.maybeViolation(apiClass) == null