// If the conversion is successful, ok will be true and conn will be the converted object;
	// otherwise, ok will be false and conn will be nil.
	conn, ok := tx.ConnPool.(*gorm.PreparedStmtDB)
	// Get the number of statement keys stored in the PreparedStmtDB.
	lens := len(conn.Stmts.Keys())
	// Check if the number of stored statement keys is 0.
	if lens == 0 {

            throw new IllegalArgumentException("Lease key must be 16 bytes, got " + key.length);
        }
        this.key = Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**
     * Get the lease key bytes
     *
     * @return copy of the 16-byte lease key
     */
    public byte[] getKey() {
        return Arrays.copyOf(key, LEASE_KEY_SIZE);
    }

    /**

    return map().size();
  }

  @Override
  public boolean contains(@Nullable Object object) {
    if (object instanceof Entry) {
      Entry<?, ?> entry = (Entry<?, ?>) object;
      V value = map().get(entry.getKey());
      return value != null && value.equals(entry.getValue());
    }
    return false;
  }

  @Override
  boolean isPartialView() {
    return map().isPartialView();
  }

      checkState(adjacentNodes.add(node));
    }
  }

  private static <T> @Nullable T getReference(@Nullable Reference<T> reference) {
    return (reference == null) ? null : reference.get();
  }

    ImmutableSet<E> result = elementSet;
    return (result == null) ? elementSet = new ElementSet<>(entries, this) : result;
  }

  @Override
  Entry<E> getEntry(int index) {
    return entries.get(index);
  }

  @Override
  boolean isPartialView() {
    return false;
  }

  @Override
  public int size() {
    return Ints.saturatedCast(size);
  }

}

func readKeyEtcd(ctx context.Context, client *etcd.Client, key string) ([]byte, error) {
	timeoutCtx, cancel := context.WithTimeout(ctx, defaultContextTimeout)
	defer cancel()
	resp, err := client.Get(timeoutCtx, key)
	if err != nil {
		etcdLogOnceIf(ctx, err, "etcd-retrieve-keys")
		return nil, etcdErrToErr(err, client.Endpoints())
	}
	if resp.Count == 0 {
		return nil, errConfigNotFound
	}

}
javaComponent.withVariantsFromConfiguration(testFixturesApiElements) {
    skip()
}

plugins.withType<IdeaPlugin> {
    configure<IdeaModel> {
        module {
            val testFixtures = sourceSets.testFixtures.get()
            testSources.from(testFixtures.java.srcDirs)
            testSources.from(testFixtures.groovy.srcDirs)
            testResources.from(testFixtures.resources.srcDirs)
        }
    }

        final SitemapAlternateLink link1 = sitemapUrl.getAlternateLinks().get(0);
        assertEquals("en", link1.getHreflang());
        assertEquals("http://www.example.com/en/page.html", link1.getHref());

        final SitemapAlternateLink link2 = sitemapUrl.getAlternateLinks().get(1);
        assertEquals("ja", link2.getHreflang());

    for (Thread thread : threads) {
      assertTrue(thread.isAlive());
    }
  }

  /** Checks that future.get times out, with the default timeout of {@code timeoutMillis()}. */
  void assertFutureTimesOut(Future<?> future) {
    assertFutureTimesOut(future, timeoutMillis());
  }

  /** Checks that future.get times out, with the given millisecond timeout. */
  void assertFutureTimesOut(Future<?> future, long timeoutMillis) {

		vc, err = globalBucketVersioningSys.Get(bi.Name)
		if err != nil {
			return err
		}

		// Check if the current bucket has a configured lifecycle policy
		lc, err = globalLifecycleSys.Get(bi.Name)
		if err != nil && !errors.Is(err, BucketLifecycleNotFound{Bucket: bi.Name}) {
			return err
		}

		// Check if bucket is object locked.
		lr, err = globalBucketObjectLockSys.Get(bi.Name)
		if err != nil {