public void setExistNextPage(final boolean existNextPage) {
        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of items per page.
     * If the page size is not set or is zero or negative, returns the default page size.
     *
     * @return the number of items per page
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();

			trimLen:  3,
			expected: []int{},
		},
		{
			name:     "Trim length greater than slice length",
			input:    []int{1, 2, 3},
			trimLen:  5,
			expected: []int{},
		},
		{
			name:     "Zero trim length",
			input:    []int{1, 2, 3},
			trimLen:  0,
			expected: []int{1, 2, 3},
		},
		{
			name:     "Trim one element from end",
			input:    []int{1, 2, 3},
			trimLen:  1,

		return errTransitionDateNotMidnight
	}

	*tDate = TransitionDate{trnDate}
	return nil
}

// MarshalXML encodes expiration date if it is non-zero and encodes
// empty string otherwise
func (tDate TransitionDate) MarshalXML(e *xml.Encoder, startElement xml.StartElement) error {
	if tDate.IsZero() {
		return nil
	}

    for (int a : TEST_INTS) {
      assertThrows(
          ArithmeticException.class,
          () -> {
            UnsignedInteger unused = UnsignedInteger.fromIntBits(a).dividedBy(UnsignedInteger.ZERO);
          });
    }
  }

  public void testMod() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        if (b != 0) {

            synchronized (this) {
                log.debug("Usage dropped to zero, release session");
                if (this.sessionAcquired.compareAndSet(true, false)) {
                    this.session.release();
                }
            }
        } else if (usage < 0) {
            log.error("Usage count dropped below zero " + this);
            dumpResource();

    sortedMultiset = (SortedMultiset<E>) getMultiset();
  }

  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetFirst() {
    assertNull(sortedMultiset.firstEntry());
    assertThrows(NoSuchElementException.class, () -> sortedMultiset.elementSet().first());
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(ZERO)
  public void testEmptyMultisetPollFirst() {

  private enum TimeoutsToUse {
    ANY(Timeout.values()),
    PAST(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO),
    FUTURE(Timeout.SMALL, Timeout.MAX),
    SMALL(Timeout.SMALL),
    FINITE(Timeout.MIN, Timeout.MINUS_SMALL, Timeout.ZERO, Timeout.SMALL),
    INFINITE(Timeout.LARGE, Timeout.MAX);

    final ImmutableList<Timeout> timeouts;

    TimeoutsToUse(Timeout... timeouts) {

    try {
      long remainingNanos = unit.toNanos(timeout);
      long end = System.nanoTime() + remainingNanos;

      while (true) {
        try {
          // CountDownLatch treats negative timeouts just like zero.
          return latch.await(remainingNanos, NANOSECONDS);
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }

            return BIGINTEGER_ITEM;
        }

        @Override
        public boolean isNull() {
            return BigInteger.ZERO.equals(value);
        }

        @Override
        public int compareTo(Item item) {
            if (item == null) {
                return BigInteger.ZERO.equals(value) ? 0 : 1; // 1.0 == 1, 1.1 > 1
            }

            return switch (item.getType()) {

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package bpool

import "sync"

// Pool is a single type sync.Pool with a few extra properties:
// If New is not set Get may return the zero value of T.
type Pool[T any] struct {
	New func() T
	p   sync.Pool
}

// Get will retuen a new T
func (p *Pool[T]) Get() T {
	v, ok := p.p.Get().(T)
	if ok {
		return v
	}
	if p.New == nil {