this.inverse = inverse;
    }

    @Override
    public boolean isVertical() {
      return false;
    }

    @Override
    public boolean isHorizontal() {
      return slope == 0.0;
    }

    @Override
    public double slope() {
      return slope;
    }

    @Override
    public double transform(double x) {
      return x * slope + yIntercept;
    }

    @Override
    public FavoriteLogDbm asDBMeta() {
        return FavoriteLogDbm.getInstance();
    }

    @Override
    public String asTableDbName() {
        return "favorite_log";
    }

    @Override
    public boolean hasSpecifiedColumn() {
        return _specification != null;
    }

    @Override
    public ConditionQuery localCQ() {
        return doGetConditionQuery();

  AbstractRangeSet() {}

  @Override
  public boolean contains(C value) {
    return rangeContaining(value) != null;
  }

  @Override
  public abstract @Nullable Range<C> rangeContaining(C value);

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

  @Override
  public void add(Range<C> range) {
    throw new UnsupportedOperationException();
  }

  @Override
  public boolean add(@Nullable E o) {
    assertTrue(Thread.holdsLock(mutex));
    return super.add(o);
  }

  @Override
  public boolean addAll(Collection<? extends E> c) {
    assertTrue(Thread.holdsLock(mutex));
    return super.addAll(c);
  }

  @Override
  public void clear() {
    assertTrue(Thread.holdsLock(mutex));
    super.clear();
  }

  @Override

 */
public final class SlackApi {
  private final HttpUrl baseUrl = HttpUrl.get("https://slack.com/api/");
  private final OkHttpClient httpClient;
  private final Moshi moshi;

  public final String clientId;
  public final String clientSecret;
  public final int port;

  public SlackApi(String clientId, String clientSecret, int port) {

 */
@NullUnmarked
public class InternersTest extends TestCase {

  public void testStrong_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Interner<String> pool = Interners.newStrongInterner();
    assertThat(pool.intern(canonical)).isSameInstanceAs(canonical);
    assertThat(pool.intern(not)).isSameInstanceAs(canonical);
  }

  public void testStrong_null() {

        boolean generateCalled = false;

        @Override
        public String getName() {
            return "testGenerator";
        }

        @Override
        public boolean generate(String thumbnailId, File outputFile) {
            generateCalled = true;
            return generateResult;
        }

        @Override
        public boolean isAvailable() {
            return available;
        }

/**
 * Tests for MoreExecutors.
 *
 * @author Kyle Littlefield (klittle)
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class MoreExecutorsTest extends JSR166TestCase {

  private static final Runnable EMPTY_RUNNABLE = () -> {};

  public void testDirectExecutorServiceServiceInThreadExecution() throws Exception {
    ListeningExecutorService executor = newDirectExecutorService();

                "test5\n";
    }

    @Test
    public void test_getType() {
        assertEquals("protwords", protwordsFile.getType());
    }

    @Test
    public void test_getPath() {
        assertEquals(testFile.getAbsolutePath(), protwordsFile.getPath());
    }

    @Test
    public void test_getSimpleName() {
        String expected = testFile.getName();

  }

  @Override
  public <E extends T> E max(Iterator<E> iterator) {
    return forwardOrder.min(iterator);
  }

  @Override
  public <E extends T> E max(Iterable<E> iterable) {
    return forwardOrder.min(iterable);
  }

  @Override
  public int hashCode() {
    return -forwardOrder.hashCode();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;