}
      if (newCapacity != entriesSize) {
        resizeEntries(newCapacity);
      }
    }
  }

  /**
   * Resizes the internal entries array to the specified capacity, which may be greater or less than
   * the current capacity.
   */
  void resizeEntries(int newCapacity) {
    this.keys = Arrays.copyOf(keys, newCapacity);
    this.values = Arrays.copyOf(values, newCapacity);

                }
            }
        }
        return null;
    }

    private boolean isSafelyCacheable(RepositorySystemSession session, Artifact artifact) {
        /*
         * The workspace/reactor is in flux so we better not assume definitive information for any of its
         * artifacts/projects.
         */

        WorkspaceReader workspace = session.getWorkspaceReader();
        if (workspace == null) {

        MessageBuilder builder = new DefaultMessageBuilder();
        format.formatRate(builder, 45.0); // 45 B/s
        assertEquals("45.0 B/s", builder.build());

        // Test value greater than or equal to 10
        builder = new DefaultMessageBuilder();
        format.formatRate(builder, 15000.0); // 15 kB/s
        assertEquals("15.0 kB/s", builder.build());

        // Test value between 0.05 and 10

        return taskNames.contains("promotionBuild") ||
            taskNames.any { it.contains("updateReleasedVersions") }
    }


/**
 * Override the version of Groovy bundled by Gradle. Must be greater than or equal to the major version of Groovy used by Gradle.
 */
val Project.bundleGroovyMajor: Int
    get() = systemProperty(BUNDLE_GROOVY_MAJOR).orNull?.toInt() ?: 4

val Project.daemonDebuggingIsEnabled: Boolean

     *   where multiple modules in the reactor have the same artifactId.
     * <p>
     * {@code -rf :artifactId} will pick up the first module which matches, but when multiple modules in the reactor
     *   have the same artifactId, effective failed module might be later in build reactor.

	instructions["JE"] = x86.AJEQ   /* alternate */
	instructions["JEQ"] = x86.AJEQ  /* equal (ZF = 1) */
	instructions["JG"] = x86.AJGT   /* alternate */
	instructions["JGE"] = x86.AJGE  /* greater than or equal (signed) (SF = OF) */
	instructions["JGT"] = x86.AJGT  /* greater than (signed) (ZF = 0 && SF = OF) */
	instructions["JHI"] = x86.AJHI  /* higher (unsigned) (CF = 0 && ZF = 0) */
	instructions["JHS"] = x86.AJCC  /* alternate */

        assertTrue(request.getDialects().length > 0);
        assertEquals(2, request.getNegotiateContexts().length);
    }

    @Test
    @DisplayName("Should handle minimum version greater than SMB202")
    void testMinimumVersionHigherThanSMB202() {
        // Given
        when(mockConfig.getMinimumVersion()).thenReturn(DialectVersion.SMB300);

        ComparableVersion seven = new ComparableVersion("7");
        ComparableVersion capitalJ = new ComparableVersion("J");
        ComparableVersion lowerCaseC = new ComparableVersion("c");
        // Digits are greater than letters
        assertTrue(seven.compareTo(capitalJ) > 0, "expected 7 > J");
        assertTrue(capitalJ.compareTo(seven) < 0, "expected J < 1");
        assertTrue(seven.compareTo(lowerCaseC) > 0, "expected 7 > c");

        SuggestItem item = new SuggestItem(text, readings, null, 0L, 0L, 0.5f, null, null, null, SuggestItem.Kind.QUERY);
        assertEquals(1.0f, item.getUserBoost(), 0.001f); // Should be set to 1

        // Test with boost greater than 1
        SuggestItem item2 = new SuggestItem(text, readings, null, 0L, 0L, 2.5f, null, null, null, SuggestItem.Kind.QUERY);
        assertEquals(2.5f, item2.getUserBoost(), 0.001f); // Should keep the value
    }

        ArtifactVersion matched = null;
        for (ArtifactVersion version : versions) {
            if (containsVersion(version)) {
                // valid - check if it is greater than the currently matched version
                if (matched == null || version.compareTo(matched) > 0) {
                    matched = version;
                }
            }
        }
        return matched;