1. Build a Gradle distribution with a fixed timestamp and hash it, but never use this distribution.
     2. Build a Gradle distribution with this hash as a version + fixed timestamp -> dogfood-first
     3. Build a Gradle distribution using dogfood-first with this hash as a version + fixed timestamp different from the one above -> dogfood-second

   * exists, a CAS is tried.  Retries proceed by "double hashing",
   * using a secondary hash (Marsaglia XorShift) to try to find a
   * free slot.
   *
   * The table size is capped because, when there are more threads
   * than CPUs, supposing that each thread were bound to a CPU,
   * there would exist a perfect hash function mapping threads to
   * slots that eliminates collisions. When we reach capacity, we

        addScopeInternal(scope);
    }

    public Set<String> getScopes() {
        return scopes;
    }

    @Override
    public int hashCode() {
        int hash = 17;

        hash = hash * 31 + scopes.hashCode();

        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

      expectedHashCode += hash(entry);
    }

    resetContainer(getSubjectGenerator().create(entries.toArray()));
    assertEquals(
        "A Map's hashCode() should be the sum of those of its entries (where "
            + "a null element in an entry counts as having a hash of zero).",
        expectedHashCode,
        getMap().hashCode());
  }

  private static int hash(Entry<?, ?> e) {

 * the License.
 */

package com.google.common.hash;

import static com.google.common.base.Preconditions.checkNotNull;

import com.google.common.annotations.Beta;
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;

/**
 * An {@link OutputStream} that maintains a hash of the data written to it.
 *
 * @author Zoe Piepmeier
 * @since 16.0
 */

        byte[] expectedHash = preauthService.getCurrentPreauthHash(sessionId);

        // Validation should pass with correct hash
        assertTrue(preauthService.validatePreauthIntegrity(sessionId, expectedHash));

        // Validation should fail with incorrect hash
        byte[] incorrectHash = new byte[expectedHash.length];
        secureRandom.nextBytes(incorrectHash);

//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package hash

import (
	"encoding/base64"
	"encoding/binary"
	"fmt"
	"hash/crc32"
	"hash/crc64"
	"math/bits"
)

// AddPart will merge a part checksum into the current,
// as if the content of each was appended.

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.hash;

import static com.google.common.hash.Hashing.sha512;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.hash;

import static com.google.common.hash.Hashing.sha512;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;

  /** Returns the platform preferred implementation of a map based on a hash table. */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */