*
     * @param name An identifier for the cache, used to identify the cache across builds. All instances created using the same identifier will share the same backing store.
     * @param normalizedCacheSize The maximum number of entries to cache in-heap, given a 'typical' heap size. The actual size may vary based on the actual heap available.
     * @param calculator The calculator to use to compute the value for a given file.

<module name="Checker">
    <module name="RegexpSingleline">
       <property name="format" value="\\s+\$"/>
       <property name="minimum" value="0"/>
       <property name="maximum" value="0"/>
       <property name="message" value="Line has trailing spaces."/>
    </module>
</module>
        """

        projectDir.file("src/main/java/org/gradle/Class1.java") <<

	return b
}

// WithMaximum sets the Maximum field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Maximum field is set to the value of the last call.
func (b *JSONSchemaPropsApplyConfiguration) WithMaximum(value float64) *JSONSchemaPropsApplyConfiguration {
	b.Maximum = &value
	return b
}

                        {
                            "required": True,
                            "schema": {
                                "title": "Item Id",
                                "maximum": 3.0,
                                "type": "number",
                            },
                            "name": "item_id",
                            "in": "path",
                        }

    // Round down to the nearest power of 2.
    expectedEntries = Math.max(expectedEntries, 2);
    int tableSize = Integer.highestOneBit(expectedEntries);
    // Check to make sure that we will not exceed the maximum load factor.
    if (expectedEntries > (int) (loadFactor * tableSize)) {
      tableSize <<= 1;
      return (tableSize > 0) ? tableSize : MAX_TABLE_SIZE;
    }
    return tableSize;
  }

        nonHeapStats.valid
        nonHeapStats.eventCount == 5
        nonHeapStats.gcRate == 0
        nonHeapStats.maxSizeInBytes == 1000
        nonHeapStats.usedPercent == 70
    }

    def "reports invalid when maximum memory cannot be determined"() {
        expect:
        !stats.valid
        stats.maxSizeInBytes == -1

        where:
        stats << [
                GarbageCollectionStats.forHeap(withoutMaxMemory(heapEvents)),

  // maximum duration they will honor per the --cluster-signing-duration CLI
  // flag to the Kubernetes controller manager.
  //
  // Certificate signers may not honor this field for various reasons:
  //
  //   1. Old signer that is unaware of the field (such as the in-tree
  //      implementations prior to v1.22)
  //   2. Signer whose configured maximum is shorter than the requested duration

)

// mostResourceScorer favors nodes with most requested resources.
// It calculates the percentage of memory and CPU requested by pods scheduled on the node, and prioritizes
// based on the maximum of the average of the fraction of requested to capacity.
//
// Details:
// (cpu(MaxNodeScore * requested * cpuWeight / capacity) + memory(MaxNodeScore * requested * memoryWeight / capacity) + ...) / weightSum

// `SeatSeconds(n)` represents `n/ssScale` seat-seconds.
// The `ssScale` constant is private to the implementation here,
// no other code should use it.
type SeatSeconds uint64

// MaxSeatsSeconds is the maximum representable value of SeatSeconds
const MaxSeatSeconds = SeatSeconds(math.MaxUint64)

// MinSeatSeconds is the lowest representable value of SeatSeconds
const MinSeatSeconds = SeatSeconds(0)

	// A negative value means to always dispatch immediately upon arrival
	// (i.e., the requests are "exempt" from limitation).
	DesiredNumQueues int

	// QueueLengthLimit is the maximum number of requests that may be waiting in a given queue at a time
	QueueLengthLimit int

	// HandSize is a parameter of shuffle sharding.  Upon arrival of a request, a queue is chosen by randomly