* {@code view} returned by this method will be invalidated, and will throw {@code
   * IllegalStateException} if it is accessed in any way, with the following exceptions:
   *
   * <ul>
   *   <li>{@code view.equals(view)} evaluates to {@code true} (but any other `equals()` expression
   *       involving {@code view} will throw)
   *   <li>{@code hashCode()} does not throw

                    }
                    throw new ThumbnailGenerationException(e.getMessage());
                } catch (final Exception e) {
                    throw new ThumbnailGenerationException("Failed to process a thumbnail content: " + url, e);
                }
            }
            throw new ThumbnailGenerationException("Failed to process a thumbnail content: " + url + " (Redirect Loop)");
        });

            throw unexpected();
        }

        @Override
        public S explicitValue(S value, S defaultValue) {
            throw unexpected();
        }

        @Override
        public S applyConvention(S value, S convention) {
            throw unexpected();
        }

        @Override
        public S implicitValue() {
            throw unexpected();
        }

        @Override

  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(

        throw UnsupportedOperationException("Should not be called")
    }

    override fun visit(visitor: ResolvedArtifactSet.Visitor) {
        throw UnsupportedOperationException("Should not be called")
    }

    override fun visitTransformSources(visitor: ResolvedArtifactSet.TransformSourceVisitor) {
        throw UnsupportedOperationException("Should not be called")
    }

		// rank recording for it, since print/println are used when
		// printing out a lock ordering problem below.
		//
		// paniclk is only used for fatal throw/panic. Don't do lock
		// ranking recording for it, since we throw after reporting a
		// lock ordering problem. Additionally, paniclk may be taken
		// after effectively any lock (anywhere we might panic), which
		// the partial order doesn't cover.
		//

    if (t != null) {
      if (t instanceof Error) throw (Error) t;
      else if (t instanceof RuntimeException) throw (RuntimeException) t;
      else if (t instanceof Exception) throw (Exception) t;
      else {
        AssertionFailedError afe = new AssertionFailedError(t.toString());
        afe.initCause(t);
        throw afe;
      }
    }

            if (state != expected) {
                throw new IllegalStateException("Expected " + displayName.getDisplayName() + " to be in state " + expected + " but is in state " + state + ".");
            }
        }

        @Override
        public void assertNotInState(T forbidden) {
            if (state == forbidden) {

        } else if (version != null) {
            throw throwUnexpectedVersionSyntax(alias, version);
        }
        if (group == null) {
            // ProblemIds for "subtypes" of a problem
            throw throwVersionCatalogAliasException(alias, "group");
        }
        if (name == null) {
            throw throwVersionCatalogAliasException(alias, "name");
        }

        throw new UnsupportedOperationException()
    }

    ConnectionMetaDataVersion1 getMetaData() {
        return new TestMetaData('2.6')
    }
}

class TestR22Connection extends TestR21Connection implements StoppableConnection {
    @Override
    void shutdown(ShutdownParameters parameters) {
        throw new UnsupportedOperationException()
    }