* be reached.
     */

    @Override
    protected A doForward(B b) {
      throw new AssertionError();
    }

    @Override
    protected B doBackward(A a) {
      throw new AssertionError();
    }

    @Override
    @Nullable A correctedDoForward(@Nullable B b) {
      return original.correctedDoBackward(b);
    }

    @Override

        BigInteger x2 = x.pow(2);
        int logX2Floor = x2.bitLength() - 1;
        return (logX2Floor < 2 * logFloor + 1) ? logFloor : logFloor + 1;
    }
    throw new AssertionError();
  }

  /*
   * The maximum number of bits in a square root for which we'll precompute an explicit half power
   * of two. This can be any value, but higher values incur more class load time and linearly

            source.skip(lineEnd)
            source.select(options)
          } else {
            return false // No more newlines.
          }
        }

        else -> throw AssertionError()
      }
    }
  }

  @Throws(IOException::class)
  private fun completeEvent(
    id: String?,
    type: String?,
    data: Buffer,
  ) {
    if (data.size != 0L) {

        fail();
      } catch (IllegalArgumentException expected) {
      }
    } catch (NoSuchAlgorithmException nsae) {
      throw new AssertionError(nsae);
    }
  }

              @Override
              public void run() {
                try {
                  unit.sleep(time);
                } catch (InterruptedException wontHappen) {
                  throw new AssertionError(wontHappen);
                }
                interruptee.interrupt();
              }
            })
        .start();
  }

  static void repeatedlyInterruptTestThread(

      while (true) {
        val event = takeEvent()
        if (eventClass.isInstance(event)) {
          return eventClass.cast(event)
        }
      }
    } catch (e: NoSuchElementException) {
      throw AssertionError("full event sequence: $fullEventSequence", e)
    }
  }

  inline fun <reified T : CallEvent> removeUpToEvent(): T = removeUpToEvent(T::class.java)

      join();
    } catch (ReflectiveOperationException e) {
      // stop() threw or did not exist. Don't join() the thread, which might hang forever.
    }

    if (uncaughtThrowable != null) {
      throw new AssertionError("Uncaught throwable in " + getName(), uncaughtThrowable);
    }
  }

  /**
   * Causes this thread to call the named void method, and asserts that the call returns normally.
   */

        try {
            Field f = SmbTreeConnection.class.getDeclaredField("tree");
            f.setAccessible(true);
            f.set(c, tree);
        } catch (Exception e) {
            throw new AssertionError(e);
        }
    }

    // Helper to set private flag 'treeAcquired'
    private static void setTreeAcquired(SmbTreeConnection c, boolean val) {
        try {

              called = true;
            }
          }
        };
    addCallback(f, callback, directExecutor());
    f.cancel(true);
  }

  public void testThrowErrorFromGet() {
    Error error = new AssertionError("ASSERT!");
    ListenableFuture<String> f = UncheckedThrowingFuture.throwingError(error);
    MockCallback callback = new MockCallback(error);
    addCallback(f, callback, directExecutor());
  }

              public Integer call() throws Exception {
                enterLatch.countDown();
                try {
                  new CountDownLatch(1).await(); // wait forever
                  throw new AssertionError();
                } catch (InterruptedException e) {
                  interruptedExceptionThrown.set(true);
                  throw e;
                } finally {
                }
              }