- Client-go uses the same HTTP client for all the generated groups and versions, allowing to share customized transports for multiple groups versions. ([#105490](https://github.com/kubernetes/kubernetes/pull/105490), [@aojea](https://github.com/aojea))

                "id", "string://url", new ArtifactRepositoryLayoutStub(), policy, policy);

        Artifact artifact = new DefaultArtifact(
                "sample.group",
                "sample-art",
                VersionRange.createFromVersion("1.0"),
                "scope",
                "jar",
                "classifier",
                null);

    )

LARGE_ITEMS: list[dict[str, Any]] = [
    {
        "id": i,
        "name": f"item-{i}",
        "values": list(range(25)),
        "meta": {
            "active": True,
            "group": i % 10,
            "tag": f"t{i % 5}",
        },
    }
    for i in range(300)
]

LARGE_METADATA: dict[str, Any] = {
    "source": "benchmark",
    "version": 1,

    /** The key of the message: Geo */
    public static final String LABELS_GEO = "{labels.geo}";

    /** The key of the message: Groups */
    public static final String LABELS_GROUPS = "{labels.groups}";

    /** The key of the message: Hash */
    public static final String LABELS_HASH = "{labels.hash}";

    /** The key of the message: Max Size */

                            + "\". You must specify a valid lifecycle phase"
                            + " or a goal in the format <plugin-prefix>:<goal> or"
                            + " <plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available lifecycle phases are: "
                            + defaultLifecycles.getLifecyclePhaseList() + ".",
                    lifecyclePhase);
        }

	for i := range 10 {
		resource := fmt.Sprintf("bucket/delete-object-%d", i)
		lri := lockRequesterInfo{
			Name:   resource,
			Writer: true,
			UID:    uuid,
			Owner:  owners[i%len(owners)],
			Group:  true,
			Quorum: 3,
		}
		lris = append(lris, lri)
		locksHeld[resource] = []lockRequesterInfo{lri}
	}

	// Add a few concurrent read locks to the mix
	for i := range 50 {

        when(logonInfo.getUserFlags()).thenReturn(PacConstants.LOGON_EXTRA_SIDS);
        assertEquals(PacConstants.LOGON_EXTRA_SIDS, logonInfo.getUserFlags());

        // Test with resource groups flag
        when(logonInfo.getUserFlags()).thenReturn(PacConstants.LOGON_RESOURCE_GROUPS);
        assertEquals(PacConstants.LOGON_RESOURCE_GROUPS, logonInfo.getUserFlags());

        // Test with combined flags

  /**
   * Configures this builder to produce tests appropriate for the given features. This method may be
   * called more than once to add features in multiple groups.
   */
  @CanIgnoreReturnValue
  public B withFeatures(Feature<?>... features) {
    return withFeatures(asList(features));
  }

  @CanIgnoreReturnValue

          <version>1.0.0+</version>
          <description>Description of the plugin.</description>
          <type>String</type>
        </field>
        <field>
          <name>groupId</name>
          <version>1.0.0+</version>
          <description>The group id of the plugin.</description>
          <type>String</type>
          <required>true</required>
        </field>
        <field>
          <name>artifactId</name>

}

// LoadGroup - loads a specific group on all peers.
func (sys *NotificationSys) LoadGroup(ctx context.Context, group string) []NotificationPeerErr {
	ng := WithNPeers(len(sys.peerClients)).WithRetries(1)
	for idx, client := range sys.peerClients {
		ng.Go(ctx, func() error {
			if client == nil {
				return errPeerNotReachable
			}
			return client.LoadGroup(ctx, group)
		}, idx, *client.host)
	}