* You can also add exclude rules per-dependency. See [ModuleDependency.exclude].
 *
 * @param group the optional group identifying the dependencies to be excluded.
 * @param module the optional module name identifying the dependencies to be excluded.
 * @return this
 */
fun Configuration.exclude(group: String? = null, module: String? = null): Configuration =

releaseNotes:
- |
  **Added** canonical service tags to Envoy-generated trace spans.
upgradeNotes:
  - title: Service Tags added to trace spans
    content: |
      Istio now configures Envoy to include tags identifying the canonical service for a workload in generated trace spans.

      This will lead to a small increase in storage per span for tracing backends.

import junit.framework.ComparisonFailure;

public class CustomComparisonFailure extends ComparisonFailure {

    /**
     * Constructs a comparison failure.
     *
     * @param message  the identifying message or null
     * @param expected the expected string value
     * @param actual   the actual string value
     */
    public CustomComparisonFailure(String message, String expected, String actual) {

package v1

import (
	"encoding/json"
	"fmt"
	"strings"

	"k8s.io/apimachinery/pkg/runtime/schema"
)

// GroupResource specifies a Group and a Resource, but does not force a version.  This is useful for identifying
// concepts during lookup stages without having partially valid types
//
// +protobuf.options.(gogoproto.goproto_stringer)=false
type GroupResource struct {
	Group    string `json:"group" protobuf:"bytes,1,opt,name=group"`

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

package org.gradle.caching;

/**
 * Cache key identifying an entry in the build cache.
 *
 * @since 3.3
 */
public interface BuildCacheKey {
    /**
     * Returns the string representation of the cache key.
     */
    String getHashCode();

    /**

	var c cbc
	c.b = b
	c.enc = cbcDecrypt
	copy(c.iv[:], iv)
	return &c
}

func (x *cbc) BlockSize() int { return BlockSize }

// cryptBlocksChain invokes the cipher message identifying encrypt or decrypt.
//
//go:noescape
func cryptBlocksChain(src, dst *byte, length int, key *uint32, iv *byte, enc int, nr int)

func (x *cbc) CryptBlocks(dst, src []byte) {
	if len(src)%BlockSize != 0 {

//     but the most common mechanism is to hash some kind of identifying information
//     like the file and line number where the change might be applied.
//     [Hash] hashes its arguments to compute an ID.
//
//  3. Enable each change that the pattern says should be enabled.
//     The [Matcher.ShouldEnable] method answers this question for a given change ID.
//
//  4. Print a report identifying each change that the pattern says should be printed.

import java.io.OutputStream;

/**
 * A signatory is an object capable of providing a signature for an arbitrary stream of bytes.
 * @since 4.5
 */
public interface Signatory {

    /**
     * <p>An identifying name for this signatory.</p>
     *
     * <p>The name must be constant for the life of the signatory and should uniquely identify it within a project.</p>
     */
    @Internal
    String getName();

    /**

 * without risking method collision.
 *
 * @since 4.0
 */
@UsedByScanPlugin
public interface BuildOperationStartedNotification {

    /**
     * A unique, opaque, value identifying this operation.
     */
    Object getNotificationOperationId();

    /**
     * The ID of the parent of this notification.
     *

func NewResourceBuilderFlags() *ResourceBuilderFlags {
	filenames := []string{}

	return &ResourceBuilderFlags{
		FileNameFlags: &FileNameFlags{
			Usage:     "identifying the resource.",
			Filenames: &filenames,
			Recursive: boolPtr(true),
		},
	}
}

// WithFile sets the FileNameFlags.