import org.apache.maven.lifecycle.internal.ReactorContext;
import org.apache.maven.lifecycle.internal.TaskSegment;

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 * </p>

import org.apache.maven.lifecycle.internal.TaskSegment;
import org.apache.maven.lifecycle.internal.builder.Builder;

/**
 * <p>
 * A {@link Builder} encapsulates a strategy for building a set of Maven projects. The default strategy in Maven builds
 * the projects serially, but a {@link Builder} can employ any type of concurrency model to build the projects.
 */
@Named("singlethreaded")
@Singleton

import org.jspecify.annotations.NullUnmarked;

/**
 * Tests our AtomicHelper fallback strategy in AggregateFutureState.
 *
 * <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

 */
package org.apache.maven.repository.legacy.resolver.conflict;

import javax.inject.Named;
import javax.inject.Singleton;

/**
 * The default conflict resolver that delegates to the nearest strategy.
 *
 * @see NearestConflictResolver
 * @deprecated As of 3.0, use a specific implementation instead, e.g. {@link NearestConflictResolver}
 */
@Deprecated
@Named
@Singleton

  cancel-in-progress: true

permissions:
  contents: read

jobs:
  build:
    name: Go ${{ matrix.go-version }} on ${{ matrix.os }} - healing
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        go-version: [1.24.x]
        os: [ubuntu-latest]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: ${{ matrix.go-version }}

                LoadBalancingStrategy.WEIGHTED_RANDOM, LoadBalancingStrategy.AFFINITY_BASED, LoadBalancingStrategy.ADAPTIVE };

        for (LoadBalancingStrategy strategy : strategies) {
            loadBalancer.setStrategy(strategy);
            assertEquals(strategy, loadBalancer.getStrategy());
        }

        // Test channel selection with mock request when no channels available

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository.legacy;

import javax.inject.Named;

/**
 * Wagon with per-lookup instantiation strategy.
 */
@Named("perlookup")
public class PerLookupWagon extends WagonMock {

    public String[] getSupportedProtocols() {
        return new String[] {"perlookup"};
    }

        }
      }
    };

    abstract String read(ByteSource byteSource, Charset cs) throws IOException;
  }

  @Param({"UTF-8"})
  String charsetName;

  @Param ReadStrategy strategy;

  @Param({"10", "1024", "1048576"})
  int size;

  Charset charset;
  ByteSource data;

  @BeforeExperiment
  public void setUp() {
    charset = Charset.forName(charsetName);

        }
      }
    };

    abstract String read(ByteSource byteSource, Charset cs) throws IOException;
  }

  @Param({"UTF-8"})
  String charsetName;

  @Param ReadStrategy strategy;

  @Param({"10", "1024", "1048576"})
  int size;

  Charset charset;
  ByteSource data;

  @BeforeExperiment
  public void setUp() {
    charset = Charset.forName(charsetName);

                    "4.0.0" // --model (conflicts with --all)
                    ));

            // --all should take precedence and make strategy applicable
            assertTrue(
                    strategy.isApplicable(context),
                    "Strategy should be applicable when --all is set, regardless of other options");
        }
    }

    @Nested
    @DisplayName("Model Version Upgrades")