- pkg: go.opencensus.io
            desc: "do not use OpenCensus; use OpenTelemetry instead"
          - pkg: golang.org/x/exp/maps
            desc: "do not use golang.org/x/exp/maps; use istio.io/istio/pkg/maps instead"
          - pkg: maps
            desc: "do not use maps; use istio.io/istio/pkg/maps instead"
          - pkg: golang.org/x/exp/slices
            desc: "do not use golang.org/x/exp/slices; use istio.io/istio/pkg/slices instead"

* **FastAPI**:
    * Da mesma forma que o Starlette utiliza o Uvicorn e não consegue ser mais rápido que ele, o **FastAPI** utiliza o Starlette, portanto, ele não consegue ser mais rápido que ele.

        return new DefaultInputFileChanges(
            Maps.filterKeys(previous, propertyName -> !incrementalInputProperties.containsKey(propertyName)),
            Maps.filterKeys(current, propertyName -> !incrementalInputProperties.containsKey(propertyName))
        );

    }

    @Override

    Map<C, V> row = Maps.safeGet(rowMap(), rowKey);
    return row != null && Maps.safeContainsKey(row, columnKey);
  }

  @Override
  @CheckForNull
  public V get(@CheckForNull Object rowKey, @CheckForNull Object columnKey) {
    Map<C, V> row = Maps.safeGet(rowMap(), rowKey);
    return (row == null) ? null : Maps.safeGet(row, columnKey);
  }

  @Override

        return Collections.emptyList();
    }

    /**
     * Maps the descriptor for the given build operation.
     */
    TO createDescriptor(DETAILS details, BuildOperationDescriptor buildOperation, @Nullable OperationIdentifier parent);

    /**
     * Maps the start event for the given build operation.
     */

/**
 * An object representing the differences between two maps.
 *
 * @author Kevin Bourrillion
 * @since 2.0
 */
@DoNotMock("Use Maps.difference")
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface MapDifference<K extends @Nullable Object, V extends @Nullable Object> {
  /**
   * Returns {@code true} if there are no differences between the two maps; that is, if the maps are
   * equal.
   */
  boolean areEqual();

  @CheckForNull
  public K lowerKey(@ParametricNullness K key) {
    return Maps.keyOrNull(lowerEntry(key));
  }

  @Override
  @CheckForNull
  public K floorKey(@ParametricNullness K key) {
    return Maps.keyOrNull(floorEntry(key));
  }

  @Override
  @CheckForNull
  public K ceilingKey(@ParametricNullness K key) {
    return Maps.keyOrNull(ceilingEntry(key));
  }

  @Override
  @CheckForNull

		}
	}
}

// setTrackMass sets the mass to track the inverse cumulative sum for.
//
// Specifically, mass is a cumulative duration, and the mutator
// utilization bounds for this duration can be queried using
// approxInvCumulativeSum.
func (d *mud) setTrackMass(mass float64) {
	d.trackMass = mass

	// Find the bucket currently containing trackMass by computing
	// the cumulative sum.
	sum := 0.0

            class MyTest extends groovy.test.GroovyTestCase {

                void testImplIsHidden() {
                    try {
                        getClass().classLoader.loadClass("$Maps.name")
                        assert false : "expected $Maps.name not to be visible"
                    } catch (ClassNotFoundException ignore) {
                        // expected
                    }
                }
            }
        """

            .should()
            .callMethod(com.google.common.collect.Maps.class, "newConcurrentMap")
            .orShould()
            .callMethod(com.google.common.collect.Maps.class, "newHashMap")
            .orShould()
            .callMethod(com.google.common.collect.Maps.class, "newLinkedHashMap")
            .orShould()
            .callMethod(com.google.common.collect.Maps.class, "newIdentityHashMap")
            .orShould()