}
          }
        };

    assertTrue(iter.hasNext());
    assertEquals(0, (int) iter.next());

    // verify idempotence of hasNext()
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertTrue(iter.hasNext());
    assertEquals(1, (int) iter.next());

    assertFalse(iter.hasNext());

    // Make sure computeNext() doesn't get invoked again

     * @param sqlState
     *            SQL state
     * @param vendorCode
     *            Vendor code
     */
    public ClSQLException(final String messageCode, final Object[] args, final String sqlState, final int vendorCode) {
        this(messageCode, args, sqlState, vendorCode, null, null);
    }

    /**
     * Creates a {@link ClSQLException}.
     *
     * @param messageCode
     *            Message code

        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);
        byte[] dest = new byte[5];

        int encodedLen = encodable.encode(dest, 0);

        // Verify encoded length
        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content

        this.id(testCoverage.asId(model))
        this.name = testCoverage.asName()
    }) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)

    init {
        functionalTests.forEach(this::buildType)
    }

app = FastAPI()


fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


class CommonQueryParams:
    def __init__(self, q: str | None = None, skip: int = 0, limit: int = 100):
        self.q = q
        self.skip = skip
        self.limit = limit


@app.get("/items/")
async def read_items(commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]):
    response = {}

        }
      } catch (e: NoClassDefFoundError) {
        false
      } catch (e: ClassNotFoundException) {
        false
      }

    fun atLeastVersion(
      major: Int,
      minor: Int = 0,
      patch: Int = 0,
    ): Boolean {
      val conscryptVersion = Conscrypt.version() ?: return false

      if (conscryptVersion.major() != major) {
        return conscryptVersion.major() > major
      }

import javax.net.ssl.SSLSessionContext
import javax.security.cert.X509Certificate

class FakeSSLSession(
  vararg val certificates: Certificate,
) : SSLSession {
  override fun getApplicationBufferSize(): Int = throw UnsupportedOperationException()

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

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

    return forward.floor(element);
  }

  @Override
  public @Nullable E higher(E element) {
    return forward.lower(element);
  }

  @Override
  int indexOf(@Nullable Object target) {
    int index = forward.indexOf(target);
    if (index == -1) {
      return index;
    } else {
      return size() - 1 - index;
    }
  }

  @Override
  boolean isPartialView() {

    }

    class Hoge {
        private int i;

        private String s;

        /**
         * @param i
         *            the i to set
         */
        public void setI(final int i) {
            this.i = i;
        }

        /**
         * @return the i
         */
        public int getI() {
            return i;
        }

        /**

    }

    /**
     * Gets the return code.
     *
     * @return the return code
     */
    public int getReturnCode() {
        return returnCode;
    }

    /**
     * Sets the return code.
     *
     * @param returnCode the return code
     */
    public void setReturnCode(int returnCode) {
        this.returnCode = returnCode;
    }

    /**
     * Gets the recommended heartbeat interval.