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
    }

                String msg = str + " aggregator mojo is already being executed "
                        + "in this parallel build, those kind of mojos require exclusive access to "
                        + "reactor to prevent race conditions. This mojo execution will be blocked "
                        + "until the aggregator mojo is done.";
                warn(msg);
                acquiredAggregatorLock.lock();
            }

  }

  /**
   * Returns a view of a slice of this byte source that is at most {@code length} bytes long
   * starting at the given {@code offset}. If {@code offset} is greater than the size of this
   * source, the returned source will be empty. If {@code offset + length} is greater than the size
   * of this source, the returned source will contain the slice starting at {@code offset} and
   * ending at the end of this source.
   *

        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

        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

 * @since 11.0
 */
@GwtCompatible
public final class LongMath {
  @VisibleForTesting static final long MAX_SIGNED_POWER_OF_TWO = 1L << (Long.SIZE - 2);

  /**
   * Returns the smallest power of two greater than or equal to {@code x}. This is equivalent to
   * {@code checkedPow(2, log2(x, CEILING))}.
   *
   * @throws IllegalArgumentException if {@code x <= 0}

      SortedSet<Integer> set = nullCheckedTreeSet(elements);
      if (set.isEmpty()) {
        /*
         * The (tooLow + 1, tooHigh) arguments below would be invalid because tooLow would be
         * greater than tooHigh.
         */
        return ContiguousSet.create(Range.openClosed(0, 1), DiscreteDomain.integers()).subSet(0, 1);
      }
      int tooHigh = set.last() + 1;
      int tooLow = set.first() - 1;

// occurs maximum number of times, the error value returned depends on how
// golang's map orders keys. This doesn't affect correctness as long as quorum
// value is greater than or equal to simple majority, since none of the equally
// maximal values would occur quorum or more number of times.
func reduceErrs(errs []error, ignoredErrs []error) (maxCount int, maxErr error) {

        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;

   *
   * <p>The {@link SortedSet#headSet} documentation states that a subset of a subset throws an
   * {@link IllegalArgumentException} if passed a {@code toElement} greater than an earlier {@code
   * toElement}. However, this method doesn't throw an exception in that situation, but instead
   * keeps the original {@code toElement}.
   */
  @Override