// benchmark with max_iters, and ensure we end up with that many iter stats.
TEST(Benchmark, Benchmark) {
  AddComp add;

  Options options;
  options.max_iters = 1;
  Stats stats1;
  Benchmark(options, [&] { add.Run(); }, &stats1);
  EXPECT_EQ(stats1.per_iter_us.size(), 1);

  options.max_iters = 5;
  Stats stats5;
  Benchmark(options, [&] { add.Run(); }, &stats5);

           g.second);
  }
}

void Benchmark(const Options& options, const BenchmarkFn& fn, Stats* stats) {
  // If neither max_seconds or max_iters is set, stop at kDefaultMicros.
  const int64_t max_us = (options.max_micros <= 0 && options.max_iters <= 0)
                             ? Options::kDefaultMicros
                             : options.max_micros;
  // NOLINTNEXTLINE

struct Options {
  // kDefaultMicros specifies the default time to run the benchmark, and is used
  // if neither max_iters nor max_micros is set.
  static constexpr int64_t kDefaultMicros = 3000000;

  int64_t max_iters = 0;   // Maximum iterations to run, ignored if <= 0.
  int64_t max_micros = 0;  // Maximum microseconds to run, ignored if <= 0.
};

                                "schema": IsDict(
                                    {
                                        "title": "Square",
                                        "maxItems": 2,
                                        "minItems": 2,
                                        "type": "array",
                                        "prefixItems": [

    private final LinkedList<String> content;
    private final int maxItems;

    public LimitedDescription(int maxItems) {
        this.maxItems = maxItems;
        this.content = new LinkedList<String>();
    }

    public LimitedDescription append(String line) {
        content.add(0, line);
        if (content.size() > maxItems) {
            content.removeLast();
        }
        return this;
    }

    static final int FLAGS_FIND_WITH_BACKUP_INTENT = 0x10;

    private int searchAttributes;
    private int tflags;
    private int informationLevel;
    private int searchStorageType = 0;
    private int maxItems;
    private String wildcard;

    // information levels

    static final int SMB_INFO_STANDARD = 1;
    static final int SMB_INFO_QUERY_EA_SIZE = 2;
    static final int SMB_INFO_QUERY_EAS_FROM_LIST = 3;

		// each occurrence of the object they are fields of
		return uint64ptr(1)
	case "array":
		if schema.MaxItems != nil {
			maxItems := uint64(zeroIfNegative(*schema.MaxItems))
			return &maxItems
		}
		return unbounded
	default:
		return uint64ptr(1)
	}
}

func zeroIfNegative(v int64) int64 {
	if v < 0 {
		return 0
	}
	return v

import jcifs.util.Hexdump;


/**
 * 
 */
public class Trans2FindNext2 extends SmbComTransaction {

    private int sid, informationLevel, resumeKey, tflags;
    private String filename;
    private long maxItems;


    /**
     * 
     * @param config
     * @param sid
     * @param resumeKey
     * @param filename
     * @param batchCount
     * @param batchSize
     */

		}
	}

	if in.MinLength != nil {
		in, out := &in.MinLength, &out.MinLength
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}
	if in.MaxItems != nil {
		in, out := &in.MaxItems, &out.MaxItems
		if *in == nil {
			*out = nil
		} else {
			*out = new(int64)
			**out = **in
		}
	}

	if in.MinItems != nil {
		in, out := &in.MinItems, &out.MinItems
		if *in == nil {

			if itemsType == nil {
				return nil
			}
			var maxItems int64
			if s.MaxItems() != nil {
				maxItems = zeroIfNegative(*s.MaxItems())
			} else {
				maxItems = estimateMaxArrayItemsFromMinSize(itemsType.MinSerializedSize)
			}
			return apiservercel.NewListType(itemsType, maxItems)
		}
		return nil
	case "object":