if uint64(size) >= quotaSize { // check if file size already exceeds the quota
			return BucketQuotaExceeded{Bucket: bucket}
		}

		bui := sys.GetBucketUsageInfo(ctx, bucket)
		if bui.Size > 0 && ((bui.Size + uint64(size)) >= quotaSize) {
			return BucketQuotaExceeded{Bucket: bucket}
		}
	}

	return nil
}

func enforceBucketQuotaHard(ctx context.Context, bucket string, size int64) error {
	if globalBucketQuotaSys == nil {

    }

    @Test
    @DisplayName("Test size calculation with empty dialects array")
    void testSizeWithEmptyDialects() {
        int[] emptyDialects = new int[0];
        ValidateNegotiateInfoRequest request =
                new ValidateNegotiateInfoRequest(DEFAULT_CAPABILITIES, defaultClientGuid, DEFAULT_SECURITY_MODE, emptyDialects);

        // Expected size: 24 (fixed) + 0
        assertEquals(24, request.size());

        List<String> elements = project.getCompileClasspathElements();
        assertEquals(2, elements.size());

        @SuppressWarnings("deprecation")
        List<Artifact> artifacts = project.getCompileArtifacts();
        assertEquals(1, artifacts.size());
        assertTrue(artifacts.get(0).getFile().getName().endsWith("tools.jar"));
    }

    }
  }

  private fun headersToList(response: MockResponse): List<String> {
    val headers = response.headers
    val size = headers.size
    val headerList: MutableList<String> = ArrayList(size)
    for (i in 0 until size) {
      headerList.add(headers.name(i) + ": " + headers.value(i))
    }
    return headerList
  }

  @Test
  fun shutdownWithoutStart() {

        assertEquals("DHnQ", new String(request.getName()));
        assertTrue(request.size() > 0);

        // Test encoding
        byte[] buffer = new byte[request.size()];
        int encoded = request.encode(buffer, 0);
        assertEquals(request.size(), encoded);
    }

    @Test
    public void testDurableHandleV2Request() {

    int[] axesSizeProduct = new int[axes.size() + 1];
    axesSizeProduct[axes.size()] = 1;
    try {
      for (int i = axes.size() - 1; i >= 0; i--) {
        axesSizeProduct[i] = Math.multiplyExact(axesSizeProduct[i + 1], axes.get(i).size());
      }
    } catch (ArithmeticException e) {
      throw new IllegalArgumentException(
          "Cartesian product too large; must have size at most Integer.MAX_VALUE");
    }

    @Required
    @Size(max = 100)
    public String username;

    /** The password for file authentication (maximum 100 characters). */
    @Size(max = 100)
    public String password;

    /** Additional parameters for file authentication (maximum 1000 characters). */
    @Size(max = 1000)
    public String parameters;

  private static final int BYTE_MAX_SIZE = 1 << Byte.SIZE; // 2^8 = 256
  private static final int BYTE_MASK = (1 << Byte.SIZE) - 1; // 2^8 - 1 = 255

  private static final int SHORT_MAX_SIZE = 1 << Short.SIZE; // 2^16 = 65_536
  private static final int SHORT_MASK = (1 << Short.SIZE) - 1; // 2^16 - 1 = 65_535

  /**
   * Returns the power of 2 hashtable size required to hold the expected number of items or the

    assertEquals(map.size(), oldSize - 1);
    assertFalse(map.containsKey(key));
    assertEquals(subMap.size(), oldSize - 2);
  }

  public void testTailMapClearThrough() {
    SortedMap<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int oldSize = map.size();
    if (map.size() < 2 || !supportsClear) {
      return;

    assertEquals(map.size(), oldSize - 1);
    assertFalse(map.containsKey(key));
    assertEquals(subMap.size(), oldSize - 2);
  }

  public void testTailMapClearThrough() {
    SortedMap<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }
    int oldSize = map.size();
    if (map.size() < 2 || !supportsClear) {
      return;