}

func (z *erasureServerPools) listAndSave(ctx context.Context, o *listPathOptions) (entries metaCacheEntriesSorted, err error) {
	// Use ID as the object name...
	o.pool = z.getAvailablePoolIdx(ctx, minioMetaBucket, o.ID, 10<<20)
	if o.pool < 0 {
		// No space or similar, don't persist the listing.
		o.pool = 0
		o.Create = false
		o.ID = ""
		o.Transient = true
		return entries, errDiskFull
	}

        }

        @Test
        @DisplayName("file size and space operations should return valid values")
        void testSizeAndSpace() throws CIFSException {
            // Given
            long expectedLength = 1024L;
            long expectedFreeSpace = 1048576L;
            when(mockResource.length()).thenReturn(expectedLength);
            when(mockResource.getDiskFreeSpace()).thenReturn(expectedFreeSpace);

            // When

	blockSizeStr := r.Form.Get("blocksize")
	fileSizeStr := r.Form.Get("filesize")

	blockSize, err := strconv.ParseUint(blockSizeStr, 10, 64)
	if err != nil {
		blockSize = 4 * humanize.MiByte // default value
	}

	fileSize, err := strconv.ParseUint(fileSizeStr, 10, 64)
	if err != nil {
		fileSize = 1 * humanize.GiByte // default value
	}

	opts := madmin.DriveSpeedTestOpts{
		Serial:    serial,

        |  -H 'Content-Type: application/octet-stream' \
        |  --data-binary '00010203'
        """.trimMargin(),
      )
  }

  @Test
  fun curlPostWithBinaryBodyOmitted() {
    val binaryData = "1020".decodeHex()
    val body = binaryData.toRequestBody("application/octet-stream".toMediaType())

    val request =
      Request
        .Builder()
        .url("https://api.example.com/upload")

      }
    }
  }

  @GwtIncompatible // DoubleMath.isPowerOfTwo, DoubleMath.log2(double, RoundingMode), StrictMath
  public void testIsPowerOfTwoYes() {
    for (int i = -1074; i <= 1023; i++) {
      assertTrue(DoubleMath.isPowerOfTwo(StrictMath.pow(2.0, i)));
    }
  }

  @GwtIncompatible // DoubleMath.isPowerOfTwo, DoubleMath.log2(double, RoundingMode), StrictMath

    void testOverConstrainedVersionException()
            throws ArtifactResolutionException, InvalidVersionSpecificationException {
        ArtifactSpec a = createArtifactSpec("a", "1.0");
        a.addDependency("b", "[1.0, 2.0)");
        a.addDependency("c", "[3.3.0,4.0.0)");

        ArtifactSpec b = createArtifactSpec("b", "1.0.0");
        b.addDependency("c", "3.3.0-v3346");

				schema.err = fmt.Errorf("invalid serializer type %v", serializerName)
			}
		}
	}

	if num, ok := field.TagSettings["AUTOINCREMENTINCREMENT"]; ok {
		field.AutoIncrementIncrement, _ = strconv.ParseInt(num, 10, 64)
	}

	if v, ok := field.TagSettings["DEFAULT"]; ok {
		field.HasDefaultValue = true
		field.DefaultValue = v
	}

	if num, ok := field.TagSettings["SIZE"]; ok {

        domainInfo.name = new rpc.unicode_string(); // Initialize name
        domainInfo.sid = mock(rpc.sid_t.class); // Initialize sid

        when(mockNdrBuffer.dec_ndr_short()).thenReturn(10, 20);
        when(mockNdrBuffer.dec_ndr_long()).thenReturn(1, 2);
        // The implementation uses maximum_length/2 for _name_buffers, not length

   * }
   *
   * The alternative natural refactorings into void or Exception-returning methods are much slower.
   * This is a big deal - we're talking factors of 2-8 in microbenchmarks, not just 10-20%. (This is
   * a hotspot optimizer bug, which should be fixed, but that's a separate, big project).
   *
   * The coding pattern above is heavily used in java.util, e.g. in ArrayList. There is a

    }

    private abstract class SubOuter extends BaseOuter {
      private abstract class SubInner extends BaseInner {}
    }
  }

  // For Guava bug https://github.com/google/guava/issues/1025
  public void testDespiteGenericSignatureFormatError() {
    ImmutableSet<?> unused =
        ImmutableSet.copyOf(
            TypeToken.of(ToReproduceGenericSignatureFormatError.SubOuter.SubInner.class)