}
  }

  private ListenerCallQueue.Event<Object> incrementingEvent(
      Multiset<Object> counters, Object expectedListener, int expectedCount) {
    return incrementingEvent(counters, multiset(expectedListener, expectedCount));
  }

  private ListenerCallQueue.Event<Object> incrementingEvent(
      final Multiset<Object> counters, final Multiset<Object> expected) {
    return new ListenerCallQueue.Event<Object>() {

    final List<Object> annotatedIn1And2AndClassEvents = Lists.newArrayList();
    final List<Object> declaredIn1AnnotatedIn2Events = Lists.newArrayList();
    final List<Object> declaredIn1AnnotatedInClassEvents = Lists.newArrayList();
    final List<Object> declaredIn2AnnotatedInClassEvents = Lists.newArrayList();
    final List<Object> annotatedIn2Events = Lists.newArrayList();

// optimalPartInfo - calculate the optimal part info for a given
// object size.
//
// NOTE: Assumption here is that for any object to be uploaded to any S3 compatible
// object storage it will have the following parameters as constants.
//
//	maxPartsCount - 10000
//	maxMultipartPutObjectSize - 5TiB
func optimalPartSize(objectSize int64) (partSize int64, err error) {
	// object size is '-1' set it to 5TiB.
	if objectSize == -1 {

		content.LastModified = amztime.ISO8601Format(object.ModTime.UTC())
		if object.ETag != "" {
			content.ETag = "\"" + object.ETag + "\""
		}
		content.Size = object.Size
		if object.StorageClass != "" {
			content.StorageClass = filterStorageClass(ctx, object.StorageClass)
		} else {
			content.StorageClass = globalMinioDefaultStorageClass
		}
		if tagErr == ErrNone {

    }

    @Override
    protected Map<String, Object> createTestParam(int id) {
        fail(); // Unreachable
        return null;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        fail(); // Unreachable
        return null;
    }

    @Override
    protected void testRead() {
        final Map<String, Object> searchBody = new HashMap<>();

@SuppressWarnings("serial")
@ElementTypesAreNonnullByDefault
abstract class ImmutableAsList<E> extends ImmutableList<E> {
  abstract ImmutableCollection<E> delegateCollection();

  @Override
  public boolean contains(@CheckForNull Object target) {
    // The collection's contains() is at least as fast as ImmutableList's
    // and is often faster.
    return delegateCollection().contains(target);
  }

  @Override
  public int size() {

                        # TODO: remove when deprecating Pydantic v1
                        ["name", "price"],
                    ),
                    "type": "object",
                    "properties": {
                        "name": {"title": "Name", "type": "string"},
                        "price": {"title": "Price", "type": "number"},
                        "description": IsDict(

		expectErr   bool
	}{
		{"", nil, true},
		{"arn:minio:s3-object-lambda:::", nil, true},
		{"arn:minio:s3-object-lambda::1:webhook:remote", nil, true},
		{"arn:aws:s3-object-lambda::1:webhook", nil, true},
		{"arn:minio:sns::1:webhook", nil, true},
		{"arn:minio:s3-object-lambda::1:webhook", &ARN{TargetID{"1", "webhook"}, ""}, false},
		{"arn:minio:s3-object-lambda:us-east-1:1:webhook", &ARN{TargetID{"1", "webhook"}, "us-east-1"}, false},

   */

  public static List<BlockingQueue<Object>> blockingQueues() {
    return ImmutableList.<BlockingQueue<Object>>of(
        new LinkedBlockingQueue<Object>(),
        new LinkedBlockingQueue<Object>(10),
        new SynchronousQueue<Object>(),
        new ArrayBlockingQueue<Object>(10),
        new LinkedBlockingDeque<Object>(),
        new LinkedBlockingDeque<Object>(10),

    if (length == 0) {
      return new Object[0];
    }
    @Nullable Object[] result = new Object[length];
    arraycopy(elements, offset, result, 0, length);
    return result;
  }

  @CanIgnoreReturnValue
  private static @Nullable Object[] fillArray(Iterable<?> elements, @Nullable Object[] array) {
    int i = 0;
    for (Object element : elements) {
      array[i++] = element;
    }