super(map);
  }

  @Override
  public SortedMap<K, Collection<V>> asMap() {
    return (SortedMap<K, Collection<V>>) super.asMap();
  }

  @Override
  SortedMap<K, Collection<V>> backingMap() {
    return (SortedMap<K, Collection<V>>) super.backingMap();
  }

  @Override
  public SortedSet<K> keySet() {
    return (SortedSet<K>) super.keySet();
  }

                     "log": 2,
                     "type": "log"
                  },
                  "showPoints": "never"
               },
               "unit": "bytes"
            },
            "overrides": [
               {
                  "matcher": {
                     "id": "byRegexp",
                     "options": "/(virtual|resident)/i"
                  },
                  "properties": [

    // Needs to go away
    private Set<Artifact> artifactDependencies;

    private ArtifactRepository localRepository;

    private List<ArtifactRepository> remoteRepositories;

    // This is like a filter but overrides all transitive versions
    private Map managedVersionMap;

    /** result type - flat list; the default */
    private boolean asList = true;

    /** result type - dirty tree */

         "datasource": {
            "type": "datasource",
            "uid": "-- Mixed --"
         },
         "description": "Request information for HTTP services",
         "fieldConfig": {
            "overrides": [
               {
                  "matcher": {
                     "id": "byName",
                     "options": "Value #requests"
                  },
                  "properties": [

    return (List<E>) collection;
  }

  /**
   * {@inheritDoc}
   *
   * <p>The {@code AbstractListTester} implementation overrides {@link
   * AbstractCollectionTester#expectContents(Collection)} to verify that the order of the elements
   * in the list under test matches what is expected.
   */
  @Override
  protected void expectContents(Collection<E> expectedCollection) {
    List<E> expectedList = copyToList(expectedCollection);

        assertTrue(a.getScope().equals("test"), "Incorrect scope for " + a.getDependencyConflictId());

        // transitive dep, overridden b depMgmt
        assertTrue(b.getScope().equals("runtime"), "Incorrect scope for " + b.getDependencyConflictId());

        // direct dep, overrides depMgmt
        assertTrue(c.getScope().equals("runtime"), "Incorrect scope for " + c.getDependencyConflictId());
    }

  /** Returns an unmodifiable iterator across the elements in this collection. */
  @Override
  public abstract UnmodifiableIterator<E> iterator();

  @Override
  public Spliterator<E> spliterator() {
    return Spliterators.spliterator(this, SPLITERATOR_CHARACTERISTICS);
  }

  private static final Object[] EMPTY_ARRAY = {};

  @Override

# Testando Dependências com Sobreposição (Overrides)

## Sobrepondo dependências durante os testes

Existem alguns cenários onde você deseje sobrepor uma dependência durante os testes.

Você não quer que a dependência original execute (e nenhuma das subdependências que você possa ter).

    #; isSuppressBatchUpdate = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o objectTypeTargetList: (NotRequired - Default databaseInfoMap's)
    #  This property overrides databaseInfoMap's one for ReplaceSchema.
    #    e.g. Synonym of Oracle --> list:{TABLE ; VIEW ; SYNONYM}
    #
    #; objectTypeTargetList = list:{TABLE ; VIEW}
    # - - - - - - - - - -/

- **Focus**:
  1. Deployment of Istio using Helm charts.
  1. Verification of Helm chart configurations.
  1. Testing of Helm chart upgrades and rollbacks.
  1. Validation of custom Helm values and overrides.
  1. Ensuring compatibility with different Kubernetes versions.
- **Setup**: The main test setup in this folder initializes the Istio control plane using Helm charts.

### Security Integration Tests