*/

package org.gradle.api.provider;

import javax.annotation.Nullable;
import java.util.Set;

/**
 * Represents a property whose type is a {@link Set} of elements of type {@link T}. Retains iteration order.
 *
 * <p>
 * You can create a {@link SetProperty} instance using factory method {@link org.gradle.api.model.ObjectFactory#setProperty(Class)}.
 * </p>
 *

	b := pos.base
	for b != nil && b != b.pos.base {
		b = b.pos.base
	}
	// b == nil || b == b.pos.base
	return b
}

func (pos Pos) RelFilename() string { return pos.base.Filename() }

func (pos Pos) RelLine() uint {
	b := pos.base
	if b.Line() == 0 {
		// base line is unknown => relative line is unknown
		return 0
	}
	return b.Line() + (pos.Line() - b.Pos().Line())
}

func (pos Pos) RelCol() uint {

    @Inject
    CustomPlugin(ToolingModelBuilderRegistry registry) {
        registry.register(new CustomBuilder())
    }

    public void apply(Project project) {
    }
}
"""
    }

    def "retains underlying object identity in model returned to client"() {
        when:
        def model = withConnection { connection ->
            connection.model(CustomModel).get()
        }

        then:

 * limitations under the License.
 */

package org.gradle.internal.normalization.java

class ApiClassExtractorAnnotationsTest extends ApiClassExtractorTestSupport {

    void "annotations on class are retained"() {
        given:
        def api = toApi([
            A  : '@Ann public class A {}',
            Ann: '''
                import java.lang.annotation.ElementType;

}

// getLine results the first \r\n or \n delineated line from the given byte
// array. The line does not include trailing whitespace or the trailing new
// line bytes. The remainder of the byte array (also not including the new line
// bytes) is also returned and this will always be smaller than the original
// argument.
func getLine(data []byte) (line, rest []byte) {
	i := bytes.IndexByte(data, '\n')

              enum:
                - Delete
                - Retain
              type: string
            driver:

        "a.b.c.1.2"       | "a.b.c.1.2" | false
        "1b2.1.2.3"       | "1"         | true
        "b1-2-3.3"        | "b"         | true
    }

    def "handles empty parts and retains whitespace"() {
        expect:
        def version = parse(versionStr)
        version.parts as List == parts

        where:
        versionStr  | parts
        ''          | []
        'a b c'     | ['a b c']

	policy := getPersistentVolumeClaimRetentionPolicy(set)
	const retain = apps.RetainPersistentVolumeClaimRetentionPolicyType
	if policy.WhenScaled == retain && policy.WhenDeleted == retain {
		// On a retain policy, it's not a problem for different controller to be managing the claims.
		return false
	}
	for _, ownerRef := range claim.GetOwnerReferences() {

// EachListItemWithAlloc works like EachListItem, but avoids retaining references to the items slice in obj.
// It does this by making a shallow copy of non-pointer items in obj.
//
// If the items passed to fn are not retained, or are retained for the same duration, use EachListItem instead for memory efficiency.
func EachListItemWithAlloc(obj runtime.Object, fn func(runtime.Object) error) error {
	return eachListItem(obj, fn, true)
}

		// relative info
		if got := pos.RelFilename(); got != test.relFilename {
			t.Errorf("%s: got relFilename %q; want %q", test.string, got, test.relFilename)
		}
		if got := pos.RelLine(); got != test.relLine {
			t.Errorf("%s: got relLine %d; want %d", test.string, got, test.relLine)
		}
		if got := pos.RelCol(); got != test.relCol {
			t.Errorf("%s: got relCol %d; want %d", test.string, got, test.relCol)
		}
	}
}