import org.gradle.internal.Actions;
import org.gradle.internal.Pair;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DefaultBuildableCompositeBuildContext implements CompositeBuildContext {
    // TODO: Synchronization
    private final Set<Pair<ModuleVersionIdentifier, ProjectComponentIdentifier>> availableModules = new HashSet<>();

        run 'copy'
        then:
        file('dest').assertHasDescendants('someDir/1.txt')
    }

    def "knows compression of the tar"() {
        given:
        buildFile << '''
            task myTar(type: Tar) {
                destinationDirectory = buildDir

                assert compression == Compression.NONE

                compression = Compression.GZIP

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.util.ports

import org.gradle.internal.Pair

class FixedAvailablePortAllocator extends AbstractAvailablePortAllocator {
    static final String WORKER_ID_SYS_PROPERTY = "org.gradle.test.worker"
    static final String AGENT_NUM_SYS_PROPERTY = "org.gradle.ci.agentNum"

                                  StringRef(content.data(), content.size()));
}

LogicalResult BuildOption(flexbuffers::Builder* fbb, Operation* op,
                          NamedAttribute pair) {
  const char* key = pair.getName().data();
  const auto attr = pair.getValue();

  if (mlir::isa<::mlir::IntegerAttr>(attr)) {
    fbb->Int(key, mlir::dyn_cast<mlir::IntegerAttr>(attr).getInt());
    return success();
  }

            assertNotClosed();
            IndexedCache<?, ?> indexedCache = caches.get(Pair.of(cacheDir, name));
            if (indexedCache == null) {
                indexedCache = new TestInMemoryIndexedCache<K, V>(valueSerializer);
                caches.put(Pair.of(cacheDir, name), indexedCache);
            }
            return Cast.uncheckedCast(indexedCache);
        }

  for (const auto& pair : clusters) {
    if (pair.first == kNoCluster) {
      absl::StrAppend(&result, "unclustered");
    } else {
      absl::StrAppend(&result, "cluster ", pair.first);
    }

    absl::StrAppend(&result, " size ", cluster_size[pair.first], "\n");

    for (const auto& ops_and_counts : pair.second) {
      absl::StrAppend(&result, " ", ops_and_counts.first, " ",

                value = value.replace("${" + entry.getKey() + "}", entry.getValue());
            }
            return new Pair<>(key, value);
        }).collect(Collectors.toMap(Pair<String, String>::getFirst, Pair<String, String>::getSecond));
        final Map<String, String> configScriptMap = config.getHandlerScriptMap();

        initParamMap.putAll(configParamMap);

    }

    @Override
    @Nullable
    public MetaProperty getMetaProperty(String name) {
        MetaProperty original = adaptee.getMetaProperty(name);
        Pair<String, CallInterceptor> getterCallerAndInterceptor = findGetterCallerAndInterceptor(name);
        Pair<String, CallInterceptor> setterCallerAndInterceptor = getterCallerAndInterceptor != null ? null : findSetterCallerAndInterceptor(name);

    }

    def "partitioning"() {
        when:
        def pair = partition([1, 2, 3], { it % 2 == 0 })

        then:
        pair.left == [2]
        pair.right == [1, 3]
    }

    def "partitioning empty collection"() {
        when:
        def pair = partition([], { it })

        then:
        pair.left == []
        pair.right == []
    }

   * }
   * ```
   *
   * The first property of the pair is the adapter that was used, the second property is the value.
   */
  internal val generalNameDnsName = Adapters.IA5_STRING.withTag(tag = 2L)
  internal val generalNameIpAddress = Adapters.OCTET_STRING.withTag(tag = 7L)
  internal val generalName: DerAdapter<Pair<DerAdapter<*>, Any?>> =
    Adapters.choice(
      generalNameDnsName,