if (found == null) {
                    throw new SmbException("Server does advertise any supported mechanism");
                }
            }
        } else if (spToken instanceof final NegTokenTarg targ) {
            if (this.firstResponse) {
                if (!this.mechContext.isSupported(targ.getMechanism())) {

            int expectedLength = (Math.min(65536, 65536) - Smb2QueryInfoResponse.OVERHEAD) & ~0x7;
            assertEquals(expectedLength, actualOutputBufferLength);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @Test
    @DisplayName("Test constructor with Configuration and FileId")
    void testConstructorWithConfigAndFileId() {

        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos token");
        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {
            content = ASN1Util.readUnparsedTagged(0, 0x8000, stream);
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }

        // Fail 3 times to open circuit
        for (int i = 0; i < 3; i++) {
            final int index = i;
            try {
                circuitBreaker.executeWithCircuitBreaker(() -> {
                    throw new RuntimeException("Test failure " + index);
                });
                fail("Should have thrown exception");
            } catch (CIFSException e) {
                // Expected
            }
        }

            throw new UnsupportedOperationException();
        }

        @Override
        public String getLocalName() {
            throw new UnsupportedOperationException();
        }

        @Override
        public String getLocalAddr() {
            throw new UnsupportedOperationException();
        }

        @Override
        public int getLocalPort() {

) : SSLSession {
  override fun getApplicationBufferSize(): Int = throw UnsupportedOperationException()

  override fun getCipherSuite(): String = throw UnsupportedOperationException()

  override fun getCreationTime(): Long = throw UnsupportedOperationException()

  override fun getId(): ByteArray = throw UnsupportedOperationException()

  override fun getLastAccessedTime(): Long = throw UnsupportedOperationException()

        assertTrue("Should contain converted reading", queryString.contains("test_reading"));
    }

    @Test
    public void test_buildQuery_threeWords() {
        QueryBuilder result = request.buildQuery("one two three", Collections.emptyList());
        assertNotNull(result);

        String queryString = result.toString();
        assertTrue("Should query reading_0", queryString.contains("reading_0"));

          throw exceptionSupplier.get();
        } else {
          throw new NoSuchElementException();
        }
      } else if (extras.isEmpty()) {
        return uncheckedCastNullableTToT(element);
      } else {
        throw multiples(false);
      }
    }
  }

  private MoreCollectors() {}

                }
                if (line ==~ /\/\/\s*AUTOSENSE\s*/) {
                    throw new InvalidUserDataException("$file:$lineNumber: "
                        + "AUTOSENSE has been replaced by CONSOLE.")
                }
                if (line ==~ /\/\/\s*CONSOLE\s*/) {
                    if (snippet == null) {
                        throw new InvalidUserDataException("$file:$lineNumber: "

      cause.setStackTrace(combined);
    }
    if (cause instanceof Exception) {
      throw (Exception) cause;
    }
    if (cause instanceof Error) {
      throw (Error) cause;
    }
    // The cause is a weird kind of Throwable, so throw the outer exception.
    throw e;
  }

  private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) {