return new Identifier(NON_PRECOMPOSED_NON_ASCII, "non-ascii");
        }
        return new Identifier(NON_ASCII_CHARS, "non-ascii");
    }

    public static Identifier getFileSystemReserved() {
        return new Identifier(FILESYSTEM_RESERVED_CHARS, "filesystem");
    }

    public static Identifier getXmlMarkup() {
        return new Identifier(XML_MARKUP_CHARS, "xml markup");
    }

        def version = identifier.safeForFileName().decorate("revision")
        def extraValue = identifier.decorate("extra")
        def resolver = identifier.decorate("description")
        def branch = identifier.safeForBranch().decorate("branch")
        def status = identifier.safeForFileName().decorate("status")
        def module = ivyRepo.module(organisation, moduleName, version)

        when:
        def result = serialize(identifier, serializer)

        then:
        result.identityPath == identifier.identityPath
        result.projectPath == identifier.projectPath
        result.buildTreePath == identifier.buildTreePath
        result.projectPath() == identifier.projectPath()
        result.projectName == identifier.projectName
    }

	encoder    runtime.Encoder
	serializer runtime.Serializer
	identifier runtime.Identifier
}

func newStripVersionEncoder(e runtime.Encoder, s runtime.Serializer) runtime.Encoder {
	return stripVersionEncoder{
		encoder:    e,
		serializer: s,
		identifier: identifier(e),
	}
}

func identifier(e runtime.Encoder) runtime.Identifier {
	result := map[string]string{
		"name": "stripVersion",
	}
	if e != nil {

)

func principalAny() *rbacpb.Principal {
	return &rbacpb.Principal{
		Identifier: &rbacpb.Principal_Any{
			Any: true,
		},
	}
}

func principalOr(principals []*rbacpb.Principal) *rbacpb.Principal {
	return &rbacpb.Principal{
		Identifier: &rbacpb.Principal_OrIds{
			OrIds: &rbacpb.Principal_Set{
				Ids: principals,
			},
		},
	}
}

	switch g {
{{- range .Entries }}
	{{- if not (or (eq .Resource.Identifier "Address") (eq .Resource.Identifier "DNSName")) }}
		case gvk.{{.Resource.Identifier}}:
			return {{.Resource.Identifier}}
	{{- end }}
{{- end }}
	}

	panic("unknown kind: " + g.String())

        given:
        def identifier = newId(mid, '1.1')
        startWithoutLockState()
        addVisitedChangingNode(identifier)

        when:
        visitor.writeLocks()

        then:
        1 * dependencyLockingProvider.persistResolvedDependencies(lockId, _, singleton(identifier), singleton(identifier))

    }

    def 'ignores visited node that is to be ignored'() {

                    // Matches: task <name-value-pairs>, <identifier>, <arg>?
                    // Map to: task(<name-value-pairs>, '<identifier>', <arg>?)
                    transformVariableExpression(call, 1);
                } else if (args.getExpression(0) instanceof VariableExpression) {
                    // Matches: task <identifier>, <arg>?
                    transformVariableExpression(call, 0);
                }

public interface ModelBuildingResult {

    /**
     * Gets the sequence of model identifiers that denote the lineage of models from which the effective model was
     * constructed. Model identifiers have the form {@code <groupId>:<artifactId>:<version>}. The first identifier from
     * the list denotes the model on which the model builder was originally invoked. The last identifier will always be
     * an empty string that by definition denotes the super POM.

			w.watchCount[*identifier] += incr
		}
	}
}

func (w *watchTracker) forgetWatch(identifier *watchIdentifier, index *indexValue) ForgetWatchFunc {
	return func() {
		w.lock.Lock()
		defer w.lock.Unlock()

		w.updateIndexLocked(identifier, index, -1)
		if w.watchCount[*identifier] == 0 {
			delete(w.watchCount, *identifier)
		}
	}
}