Root level array with minimum and maximum size where each item must match the provided matcher
@param minSize minimum size
@param maxSize maximum size
511773
public static PactDslJsonArray arrayMinMaxLike(int minSize, int maxSize, PactDslJsonRootValue value) {
    return arrayMinMaxLike(minSize, maxSize, minSize, value);
  }
27399
public E popWithLimit(int minSize) {
        StackNode<E> oldTop, newTop;

        while (true) {
            oldTop = top.get();
            if (oldTop == null)
                return null;

            if (oldTop.index + 1 <= minSize)
                return null;

            newTop = oldTop.next;
            if (top.compareAndSet(oldTop, newTop))
                break;
        }

        return oldTop.data;
    }
823731
public void init(String st, int minsize, int maxsize) {
        super.init(check(st), minsize, maxsize);
    }
15512
protected function setMaxSize($maxSize)
    {
        $this->maxSize = $this->toBytes($maxSize);
        $this->maxSizeString = $this->fromBytes($this->maxSize);
        return $this;
    }
995550
public static PactDslJsonArray arrayMaxLike(int maxSize, int numberExamples, PactDslJsonRootValue value) {
    if (numberExamples > maxSize) {
      throw new IllegalArgumentException(String.format("Number of example %d is more than the maximum size of %d",
        numberExamples, maxSize));
    }
    PactDslJsonArray parent = new PactDslJsonArray("", "", null, true);
    parent.setNumberExamples(numberExamples);
    parent.matchers.addRule("", parent.matchMax(maxSize));
    parent.putObject(value);
    return parent;
  }
24749
public function resizeTable(int $maxSize = null) {
        if ($maxSize !== null) {
            $this->maxSize = $maxSize;
        }

        while ($this->size > $this->maxSize) {
            list($name, $value) = \array_pop($this->headers);
            $this->size -= 32 + \strlen($name) + \strlen($value);
        }
    }
203640
public void setFill(double val, double min, double max) {
    this.val = val;
    this.min = min;
    this.max = max;
  }
996503
public static Pattern atMost(final int max, final CharPredicate predicate) {
    Checks.checkMax(max);
    return new Pattern() {
      @Override
      public int match(CharSequence src, int begin, int end) {
        return matchSome(max, predicate, src, end, begin, 0);
      }
    };
  }
361128
@SuppressWarnings("unchecked")
  protected final void initialize(int maxSize) {
    size = 0;
    int heapSize = maxSize + 1;
    heap = (T[]) new Object[heapSize];
    this.maxSize = maxSize;
  }
752214
protected boolean nestedMatch(Matcher<?> matcher, Object item, Description mismatch) {
        return Nested.matches(this, matcher, item, mismatch);
    }
917764
public static Pattern atLeast(final int min, final CharPredicate predicate) {
    Checks.checkMin(min);
    return new Pattern() {
      @Override public int match(CharSequence src, int begin, int end) {
        int minLen = RepeatCharPredicatePattern.matchRepeat(min, predicate, src, end, begin, 0);
        if (minLen == MISMATCH) return MISMATCH;
        return matchMany(predicate, src, end, begin + minLen, minLen);
      }
      @Override public String toString() {
        return (min > 1) ? (predicate + "{" + min + ",}") : (predicate + "+");
      }
    };
  }
586211
public char[] getSmallCBuffer(int minSize)
    {
        char[] result = null;
        if (mSmallCBuffer != null && mSmallCBuffer.length >= minSize) {
            result = mSmallCBuffer;
            mSmallCBuffer = null;
        }
//System.err.println("DEBUG: Alloc CSmall: "+result);
        return result;
    }
693224
@ExperimentalApi("https://github.com/grpc/grpc-java/issues/2563")
  public CallOptions withMaxInboundMessageSize(int maxSize) {
    checkArgument(maxSize >= 0, "invalid maxsize %s", maxSize);
    CallOptions newOptions = new CallOptions(this);
    newOptions.maxInboundMessageSize = maxSize;
    return newOptions;
  }
795750
@Override
    public PactDslJsonBody maxArrayLike(Integer size, int numberExamples) {
      if (numberExamples > size) {
        throw new IllegalArgumentException(String.format("Number of example %d is more than the maximum size of %d",
          numberExamples, size));
      }
      matchers.addRule(rootPath + appendArrayIndex(1), matchMax(size));
      PactDslJsonArray parent = new PactDslJsonArray("", "", this, true);
      parent.setNumberExamples(numberExamples);
      return new PactDslJsonBody(".", "", parent);
    }
1120572
public static <E> Matcher<Iterable<E>> hasSize(final int size) {
        checkArgument(size >= 0, "Size cannot be negative");

        return new IsIterableWithSize(size);
    }
323919
public EasyRandomParameters collectionSizeRange(final int minCollectionSize, final int maxCollectionSize) {
        if (minCollectionSize < 0) {
            throw new IllegalArgumentException("minCollectionSize must be >= 0");
        }
        if (minCollectionSize > maxCollectionSize) {
            throw new IllegalArgumentException(format("minCollectionSize (%s) must be <= than maxCollectionSize (%s)",
                    minCollectionSize, maxCollectionSize));
        }
        setCollectionSizeRange(new Range<>(minCollectionSize, maxCollectionSize));
        return this;
    }
635677
public static String phrase(int minSize, int maxSize) {
        maxSize = Math.max(minSize, maxSize);
        int size = RandomInteger.nextInteger(minSize, maxSize);
        if (size <= 0) return "";
        
        StringBuilder result = new StringBuilder();
        result.append(RandomString.pick(_allWords));
        while (result.length() < size) {
            result.append(" ").append(RandomString.pick(_allWords).toLowerCase());
        }

        return result.toString();
    }