const string& composite_op_name) const {
  if (impl()->op_name_.empty() && composite_op_name.empty()) {
    UpdateStatus(errors::InvalidArgument(
        "Cannot create composite op scopes with empty name"));
    return {*this, *this};
  }
  if (!impl()->single_use_scope()) {
    Scope child = NewSubScope(impl()->op_name_.empty() ? composite_op_name

        assert mavenModule.parsedModuleMetadata.variants*.name as Set == ['apiElements', 'runtimeElements'] as Set
        assert mavenModule.parsedModuleMetadata.variant('apiElements').files.empty
        assert mavenModule.parsedModuleMetadata.variant('runtimeElements').files.empty

        // Verify POM particulars
        assert mavenModule.parsedPom.packaging == 'pom'
    }

    void assertNoDependencies() {

        then:
        outputContains("Could not set executable permissions")
    }

    def "wrapper prints error and fails build if downloaded zip is empty"() {
        given: "empty distribution"
        TestFile tempUnzipDir = temporaryFolder.createDir("empty-distribution")
        TestFile malformedDistZip = new TestFile(tempUnzipDir, "gradle-${distribution.version.version}-bin.zip") << ""

            final SAXParser parser = factory.newSAXParser();
            parser.setProperty(XMLConstants.ACCESS_EXTERNAL_DTD, StringUtil.EMPTY);
            parser.setProperty(XMLConstants.ACCESS_EXTERNAL_SCHEMA, StringUtil.EMPTY);
            parser.parse(is, this);
        } catch (final Exception e) {
            throw new GsaConfigException("Failed to parse XML file.", e);
        }
    }

   */
  @CheckForNull
  Range<C> rangeContaining(C value);

  /**
   * Returns {@code true} if there exists a non-empty range enclosed by both a member range in this
   * range set and the specified range. This is equivalent to calling {@code
   * subRangeSet(otherRange)} and testing whether the resulting range set is non-empty.
   *
   * @since 20.0
   */
  boolean intersects(Range<C> otherRange);

  /**

		// change from: onMatch -> map (empty with fallback) to onMatch -> fallback
		// that fallback may be an empty map, so we re-queue onMatch in case it still needs fixing
		onMatch.OnMatch = fallback.OnMatch
		return []*matcher.Matcher_OnMatch{onMatch} // the inner mapper is gone
	}

	// envoy will nack this eventually
	log.Warnf("empty mapper %v with no fallback", innerMapper.Matcher)

            ClassPath classpath = ClassPath.EMPTY;
            classpath = classpath.plus(moduleRegistry.getModule("gradle-scala").getImplementationClasspath());
            classpath = addJavaCompilerModules(classpath);
            return classpath;
        }
        if (name.equals("JAVA-COMPILER")) {
            return addJavaCompilerModules(ClassPath.EMPTY);
        }

		// Test listing an empty directory in recursive mode (62)
		{"test-bucket-empty-dir", "", "", "", 10, resultCases[31], nil, true},
		// Test listing an empty directory in a non recursive mode (63)
		{"test-bucket-empty-dir", "", "", SlashSeparator, 10, resultCases[32], nil, true},
		// Test listing a directory which contains an empty directory (64)

        def operations = getLocalStoreOperationsForTask(taskPath)
        assert !operations.empty && operations[0].result["stored"] == true
    }

    void assertNotStoredToLocalCacheForTask(String taskPath) {
        def operations = getLocalStoreOperationsForTask(taskPath)
        assert operations.empty
    }

    void assertStoredToRemoteCacheForTask(String taskPath) {

        v1.addDependency("g1", "m1", v("v1"), [], null, ImmutableAttributes.EMPTY, [], false, null)
        v1.addDependency("g2", "m2", v("v2"), [], "v2 is tested", ImmutableAttributes.EMPTY, [], true, null)
        def v2 = metadata.addVariant("runtime", attributes(usage: "runtime"))
        v2.addDependency("g1", "m1", v("v1"), [], null, ImmutableAttributes.EMPTY, [], false, null)

        expect:
        metadata.variants.size() == 2