Hierarchy For Package org.hamcrest.internal Package Hierarchies: All Packages Class Hierarchy java.lang.Object org.hamcrest.internal.ArrayIterator (implements java.util.Iterator<E>) org.hamcrest.internal.ReflectiveTypeFinder org.hamcrest.internal.SelfDescribingValue<T> (implements org.hamcrest.SelfDescribing) org.hamcrest.internal.SelfDescribingValueI<T> (implements java.util.Iterator<E>) Overview Package Class Use Tree Deprecated Index Help PREV NEXT FRAMES NO FRAMES All Classes org/hamcrest/internal/package-use.html...

				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z BaseOptions) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 0
	_ = z
	err = en.Append(0x80)
	if err != nil {
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z BaseOptions) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())

	return
}

// DecodeMsg implements msgp.Decodable
func (z *dataUsageHash) DecodeMsg(dc *msgp.Reader) (err error) {
	{
		var zb0001 string
		zb0001, err = dc.ReadString()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = dataUsageHash(zb0001)
	}
	return
}

// EncodeMsg implements msgp.Encodable

	String string
	Valid  bool // Valid is true if String is not NULL
}

// Scan implements the [Scanner] interface.
func (ns *NullString) Scan(value any) error {
	if value == nil {
		ns.String, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return convertAssign(&ns.String, value)
}

// Value implements the [driver.Valuer] interface.
func (ns NullString) Value() (driver.Value, error) {

    }

    def "can use custom type that does not implement equals() for transform configuration"() {
        given:
        buildFile << declareAttributes() << withJarTasks() << """
            class CustomType implements Serializable {
                String value
            }

            abstract class TransformWithMultipleTargets implements TransformAction<Parameters> {

synchronized class NewestConflictResolv implements ConflictResolver { public void NewestConflictResolv(); public org.apache.maven.artifact.resolver.ResolutionNode resolveConflict(org.apache.maven.artifact.resolver.ResolutionNode, org.apache.maven.artifact.resolver.ResolutionNode); } org/apache/maven/artifact/resolver/conflict/OldestConflictResolv.class package org.apache.maven.artifact.resolver.conflict; public synchronized class OldestConflictResolv implements ConflictResolver { public void OldestConflictResolv();...

import org.hamcrest.Matcher
import spock.lang.Issue

import static org.gradle.util.Matchers.matchesRegexp

class ArtifactTransformIntegrationTest extends AbstractHttpDependencyResolutionTest implements ArtifactTransformTestFixture {
    def setup() {
        createDirs("lib", "app")
        settingsFile << """
            rootProject.name = 'root'
            include 'lib'
            include 'app'
        """

DefaultContext$1 { } org/codehaus/plexus/context/DefaultContext$Hidden.class package org.codehaus.plexus.context; synchronized class DefaultContext$Hidden implements java.io.Serializable { private void DefaultContext$Hidden(); } org/codehaus/plexus/context/DefaultContext.class package org.codehaus.plexus.context; public synchronized class DefaultContext implements Context { private static DefaultContext$Hidden HIDDEN_MAKER; private java.util.Map contextData; private Context parent; private boolean readOnly;...

   * its capacity threshold.
   *
   * The Least Recently Used page replacement algorithm was chosen due to its simplicity, high hit
   * rate, and ability to be implemented with O(1) time complexity. The initial LRU implementation
   * operates per-segment rather than globally for increased implementation simplicity. We expect
   * the cache hit rate to be similar to that of a global LRU algorithm.

   * its capacity threshold.
   *
   * The Least Recently Used page replacement algorithm was chosen due to its simplicity, high hit
   * rate, and ability to be implemented with O(1) time complexity. The initial LRU implementation
   * operates per-segment rather than globally for increased implementation simplicity. We expect
   * the cache hit rate to be similar to that of a global LRU algorithm.