* <ul>
     * <li>collect all the vertices for the projects that we want to build.</li>
     * <li>iterate through the deps of each project and if that dep is within
     * the set of projects we want to build then add an edge, otherwise throw
     * the edge away because that dependency is not within the set of projects
     * we are trying to build. we assume a closed set.</li>
     * <li>do a topo sort on the graph that remains.</li>

  # Do a sanity check to make sure that we using the correct Python version
  python --version
fi

# TFCI Mac VM images do not have twine installed by default so we need to
# install it manually. We use Twine in nightly builds to upload Python packages
# to PyPI.
if [[ "$TFCI_MACOS_TWINE_INSTALL_ENABLE" == 1 ]]; then
  pip install twine==3.6.0
fi

# When cross-compiling with RBE, we need to copy the macOS sysroot to be

  </plugin>
  .
  .
  .
</plugins>

	m.mu.Lock()
	defer m.mu.Unlock()
	// See if someone else fetched it while we waited for the lock.
	b, ok = m.buckets[bucket]
	if ok {
		if b.bucket != bucket {
			logger.Info("getBucket: newly cached bucket %s does not match this bucket %s", b.bucket, bucket)
			debug.PrintStack()
		}
		return b
	}

	// New bucket. If we fail return the transient bucket.
	b = newBucketMetacache(bucket, true)

      tmp += UnsignedLongs.remainder(longs[j], divisors[j]);
    }
    return tmp;
  }

  @Benchmark
  long parseUnsignedLong(int reps) {
    long tmp = 0;
    // Given that we make three calls per pass, we scale reps down in order
    // to do a comparable amount of work to other measurements.
    int scaledReps = reps / 3 + 1;
    for (int i = 0; i < scaledReps; i++) {
      int j = i & ARRAY_MASK;

        triggers {
            val triggerHour = branch.determineNightlyPromotionTriggerHour() ?: return@triggers
            // for master/release branch, we trigger them on midnight (with pending change only, i.e. if there is no change, don't rigger it)
            // for old release branches, we trigger them on midnight if there is change, or unconditionally on weekends
            when {
                branch.isMaster || branch.isRelease ->

    }

    /**
     * Tests the isCredentialTypeCorrect method with a null byte array.
     * This test is indirect as the constructor would throw an exception.
     * We can't instantiate the class with null, so we can't directly test this method's behavior with null.
     * However, the constructor logic `!isCredentialTypeCorrect()` covers this.

                    artifact.setRepository(repository);
                    break;
                }
            } catch (ResourceDoesNotExistException e) {
                // This one we will eat when looking through remote repositories
                // because we want to cycle through them all before squawking.

                logger.debug(

          // otherwise try to presize a StringBuilder
          // it is kind of lame that we need to construct a decoder to access this value.
          // if this is a concern we could add special cases for some known charsets (like utf8)
          // or we could avoid inputstreamreader and use the decoder api directly
          // TODO(lukes): in a real implementation we would need to handle overflow conditions

## Decision

We do not use Java serialization.
Instead, we use custom serialization where we explicitly describe how data objects should be serialized and deserialized.

For internal purposes, we use binary formats for their brevity.
We use the `Serializer` abstraction to separate the actual implementation of serialization from its uses.

When sharing data with external tools, we use JSON.

## Status

ACCEPTED