*
     * @since 4.9
     */
    void attributes(Action<? super AttributeContainer> attributesConfiguration);

    /**
     * Returns the attributes of the component.
     * @return the attributes of the component, guaranteed to be mutable.
     *
     * @since 4.9
     */
    AttributeContainer getAttributes();

    public Set<Attribute<?>> keySet() {
        return delegate.keySet();
    }

    @Override
    public <T> AttributeContainer attribute(Attribute<T> key, T value) {
        assertMutable();
        delegate.attribute(key, value);
        return this;
    }

    @Override
    public <T> AttributeContainer attributeProvider(Attribute<T> key, Provider<? extends T> provider) {
        assertMutable();

            return configurationAttributes;
        }

        private AttributeContainer concat(AttributeContainer configAttributes, AttributeContainer dependencyAttributes) {
            return attributesFactory.concat(
                ((AttributeContainerInternal) configAttributes).asImmutable(),
                ((AttributeContainerInternal) dependencyAttributes).asImmutable()
            );
        }

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

package org.gradle.api.internal.artifacts.transform;

import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.internal.artifacts.ivyservice.resolveengine.artifact.ResolvableArtifact;
import org.gradle.internal.id.ConfigurationCacheableIdFactory;
import org.gradle.internal.model.CalculatedValueContainerFactory;

import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.internal.attributes.ImmutableAttributes;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;
import org.gradle.internal.serialize.Serializer;

import java.io.IOException;

public interface AttributeContainerSerializer extends Serializer<AttributeContainer> {
    @Override

    }

    private static final class VariantIdentity {
        private final AttributeContainer attributes;
        private final Set<? extends Capability> capabilities;

        private VariantIdentity(AttributeContainer attributes, Set<? extends Capability> capabilities) {
            this.attributes = attributes;
            this.capabilities = capabilities;
        }

    private val attributesFactory: ImmutableAttributesFactory,
    private val managedFactories: ManagedFactoryRegistry
) : Codec<AttributeContainer> {

    override suspend fun WriteContext.encode(value: AttributeContainer) {
        writeAttributes(value)
    }

    override suspend fun ReadContext.decode(): AttributeContainer? =
        readAttributesUsing(attributesFactory, managedFactories)
}


class ImmutableAttributesCodec(

    public static final String DEFAULT_TEST_VARIANT = "test variant";
    private final DisplayName variantName;
    private final AttributeContainer variant;
    private final ImmutableSet<ResolvedArtifact> artifacts;

    private TestArtifactSet(String variantName, AttributeContainer variant, Collection<? extends ResolvedArtifact> artifacts) {
        this.variantName = Describables.of(variantName);
        this.variant = variant;

     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getFrom();

    /**
     * Attributes that match the variant that is produced.
     *
     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getTo();

    /**
     * The parameters for the transform action.
     *

 * limitations under the License.
 */

package org.gradle.api.internal.attributes

import com.google.common.collect.ImmutableMap
import org.gradle.api.attributes.Attribute
import org.gradle.api.attributes.AttributeContainer
import org.gradle.api.attributes.Usage
import org.gradle.internal.component.model.AttributeSelectionSchema
import org.gradle.util.AttributeTestUtil
import org.gradle.util.SnapshotTestUtil
import org.gradle.util.TestUtil