Ambient Upgrade - Strategies.png...

        ImmutableList.Builder<DaemonExpirationStrategy> strategies = ImmutableList.<DaemonExpirationStrategy>builder();

        // Expire under high JVM memory or GC pressure
        strategies.add(healthExpirationStrategy);

        // Expire compatible, idle, not recently used Daemons after a short time
        strategies.add(new AllDaemonExpirationStrategy(ImmutableList.of(

    private final List<? extends ModelSchemaExtractionStrategy> strategies;

    public static DefaultModelSchemaExtractor withDefaultStrategies(List<? extends ModelSchemaExtractionStrategy> strategies, ModelSchemaAspectExtractor aspectExtractor) {
        return new DefaultModelSchemaExtractor(ImmutableList.<ModelSchemaExtractionStrategy>builder()
            .addAll(strategies)
            .add(new PrimitiveStrategy())

    private final List<ModelSchemaAspectExtractionStrategy> strategies;

    public ModelSchemaAspectExtractor() {
        this(Collections.<ModelSchemaAspectExtractionStrategy>emptyList());
    }

    public ModelSchemaAspectExtractor(Collection<ModelSchemaAspectExtractionStrategy> strategies) {
        this.strategies = ImmutableList.copyOf(strategies);
    }

        AttributeMatchingStrategy<T> strategy = Cast.uncheckedCast(strategies.get(attribute));
        if (strategy == null) {
            strategy = Cast.uncheckedCast(instantiatorFactory.decorateLenient().newInstance(DefaultAttributeMatchingStrategy.class, instantiatorFactory, isolatableFactory));
            strategies.put(attribute, strategy);
            attributesByName.put(attribute.getName(), attribute);
        }

 *
 * <p>On different platforms AggregateFutureState uses different strategies for its core
 * synchronization primitives. The strategies are all implemented as subtypes of AtomicHelper and
 * the strategy is selected in the static initializer of AggregateFutureState. This is convenient
 * and performant but introduces some testing difficulties. This test exercises the two fallback
 * strategies.
 *
 * <ul>

    private final Map<String, DependentBinariesResolutionStrategy> strategies = new LinkedHashMap<>();


    @Override
    public void register(DependentBinariesResolutionStrategy strategy) {
        checkNotNull(strategy, "strategy must not be null");
        strategies.put(strategy.getName(), strategy);
    }

    @Override

import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Tests our AtomicHelper fallback strategies in AbstractFuture.
 *
 * <p>On different platforms AbstractFuture uses different strategies for its core synchronization
 * primitives. The strategies are all implemented as subtypes of AtomicHelper and the strategy is

import junit.framework.TestCase;
import junit.framework.TestSuite;

/**
 * Tests our AtomicHelper fallback strategies in AbstractFuture.
 *
 * <p>On different platforms AbstractFuture uses different strategies for its core synchronization
 * primitives. The strategies are all implemented as subtypes of AtomicHelper and the strategy is

from tensorflow.python.framework import test_util

strategies = [
    strategy_combinations.one_device_strategy,
    strategy_combinations.one_device_strategy_gpu,
    strategy_combinations.tpu_strategy,
]


class MnistTrainTest(test_util.TensorFlowTestCase, parameterized.TestCase):

  @combinations.generate(combinations.combine(strategy=strategies))
  def testMnistTrain(self, strategy):