// replacements for modules that did not have any packages to vendor.
				} else {
					vendErrorf(r.Old, "is replaced in %s, but not marked as replaced in vendor/modules.txt", base.ShortPath(replacementSource))
				}
			} else if vr != rNewCanonical {
				vendErrorf(r.Old, "is replaced by %s in %s, but marked as replaced by %s in vendor/modules.txt", describe(rNew), base.ShortPath(replacementSource), describe(vr))
			}
		}
	}

   *       correctly, including surrogate character pairs. If the input is badly formed the escaper
   *       should throw {@link IllegalArgumentException}.
   *   <li>{@link CharEscaper} handles Java characters independently and does not verify the input
   *       for well formed characters. A {@code CharEscaper} should not be used in situations where

        this(cause, Describables.of(cause.getDefaultReason()), false, cause == ComponentSelectionCause.FORCED);
    }

    public DefaultComponentSelectionDescriptor(ComponentSelectionCause cause, Describable description) {
        this(cause, description, true, cause == ComponentSelectionCause.FORCED);
    }

        }
        return false;
    }

    @Override
    public ForcingDependencyMetadata forced() {
        if (delegate instanceof ForcingDependencyMetadata) {
            return ((ForcingDependencyMetadata) delegate).forced();
        }
        return this;
    }

 * limitations under the License.
 */

package org.gradle.internal.xml

import spock.lang.Specification

class XmlValidationTest extends Specification {
    def "catches poorly formed xml names"() {
        expect:
        !XmlValidation.isValidXmlName(name)

        where:
        name        | _
        ''          | _
        'foo\t'     | _
        'foo\\n'    | _

                            // source sets with 'test' in their name are marked as test on the Eclipse classpath
                            testSourceSetsConvention.add(sourceSet);

                            // resolved dependencies from the source sets with 'test' in their name are marked as test on the Eclipse classpath

        coordinationService.withStateLock(unlock(resourceLock))

        then:
        !resourceLock.doIsLocked()
        !resourceLock.doIsLockedByCurrentThread()
    }

    def "can lock a resource that is already locked"() {
        given:
        assert coordinationService.withStateLock(tryLock(resourceLock))
        assert resourceLock.doIsLocked()

        when:
        coordinationService.withStateLock(tryLock(resourceLock))

// RUN:        -split-input-file -tf-resource-analyzer-test %s \
// RUN:   | FileCheck %s

// TODO(b/269548549): Add tests to cover more patterns.

// Test that VarHandleOp is not marked as "potentially written" if it is not
// assigned inside the function called by "tf.BatchFunction".

module {
// CHECK-LABEL: @serving_default
  func.func @serving_default() -> (tensor<*xi32>) {

            def changes = delegateContext.changes.get()
            assert delegateContext.rebuildReasons == ImmutableList.of("Forced rebuild.")
            assert !changes.createInputChanges().incremental
            return delegateResult
        }
        _ * context.nonIncrementalReason >> Optional.of("Forced rebuild.")
        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)
        0 * _
    }

     * released by calling {@link FileLock#close()}. This method blocks until the lock can be acquired.
     *
     * @param target The file to be locked.
     * @param options The lock options.
     * @param targetDisplayName A display name for the target file. This is used in log and error messages.
     */