def buildOperationRunner = new TestBuildOperationRunner()
    def context = new DefaultUserCodeApplicationContext()
    def decorator = new DefaultListenerBuildOperationDecorator(buildOperationRunner, context)

    def 'ignores implementers of InternalListener'() {
        given:
        def action = Mock(InternalAction)
        def buildListener = new InternalBuildAdapter()
        def projectEvaluationListener = Mock(InternalProjectEvaluationListener)

        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ignored-keyType">
        <xs:attribute type="xs:string" name="id" use="required"/>
        <xs:attribute type="xs:string" name="reason"/>
    </xs:complexType>
    <xs:complexType name="ignored-keysType">
        <xs:sequence>
            <xs:element type="ignored-keyType" name="ignored-key"/>
        </xs:sequence>
    </xs:complexType>

      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <ignored-keys>
         <ignored-key id="abcdef1234567890" reason="Key is not available in any key server"/>
      </ignored-keys>
   </configuration>
</verification-metadata>
----

As soon as a key is ignored, it will not be used for verification, even if the signature file mentions it.

//                    |<- width ->|<- ignored ->|  |
//                    |           |             |  |
// [---processed---tab------------<tag>...</tag>...]
// ^                  ^                         ^
// |                  |                         |
// buf                start of incomplete cell  pos

// Formatting can be controlled with these flags.
const (
	// Ignore html tags and treat entities (starting with '&'

         * Indicates if this repository only contains artifacts.
         *
         * @since 6.4
         */
        boolean isArtifactEnabled();

        /**
         * Indicates if this repository ignores Gradle module metadata redirection markers.
         *
         * @since 6.4
         */
        boolean isIgnoreGradleMetadataRedirectionEnabled();
    }

    /**

        1 * registry.markState(address, Canceled)
    }

    def "ignores empty cache on marking busy"() {
        given:
        updater.onStart(address)
        registry.markState(address, Busy) >> { throw new EmptyRegistryException("") }

        when:
        updater.onStartActivity()

        then:
        noExceptionThrown()
    }

    def "ignores empty cache on stopping"() {
        given:

foo=a,b
empty=c
""".denormalize()
        !lockDir.exists()
    }

    def 'reads a legacy lock file'() {
        given:
        def lockFile = lockDir.file('conf.lockfile')
        lockFile << """#Ignored
line1

line2"""

        when:
        def result = lockFileReaderWriter.readLockFile('conf')

        then:
        result == ['line1', 'line2']

        1 * listener.fileObserved(lockFile)

		stmp, e := ListxattrNS(file, nsid, dest[pos:])

		/* Errors accessing system attrs are ignored so that
		 * we can implement the Linux-like behavior of omitting errors that
		 * we don't have read permissions on
		 *
		 * Linux will still error if we ask for user attributes on a file that
		 * we don't have read permissions on, so don't ignore those errors
		 */
		if e != nil {
			if e == EPERM && nsid != EXTATTR_NAMESPACE_USER {

        }
    }

    @Override
    public void testIgnored(Description description) throws Exception {
        if (methodName(description) == null) {
            // An @Ignored class, ignore the event. We don't get testIgnored events for each method, so we have
            // generate them on our own
            processIgnoredClass(description);
        } else {

        </xs:sequence>
    </xs:complexType>
    <xs:complexType name="ignored-keyType">
        <xs:attribute type="xs:string" name="id" use="required"/>
        <xs:attribute type="xs:string" name="reason"/>
    </xs:complexType>
    <xs:complexType name="ignored-keysType">
        <xs:sequence>
            <xs:element type="ignored-keyType" name="ignored-key"/>
        </xs:sequence>
    </xs:complexType>