namespace tensorflow {

class ImmediateExecutionContext;
class AbstractOpAttrs;

// Abstract interface to an operation.
class ImmediateExecutionOperation : public AbstractOperation {
 public:
  virtual void Clear() = 0;

  // Returns the inputs of this op.
  virtual absl::Span<ImmediateExecutionTensorHandle* const> GetInputs()
      const = 0;
  virtual absl::Status SetInput(size_t index,

    // Set<Object> keys = map.keySet();
    // assertThat(keys).containsExactly(one, three);
    // Collection<Object> values = map.values();
    // assertThat(values).containsExactly(one, two);

    map.clear();

    assertThat(cache.stats()).isEqualTo(EMPTY_STATS);
  }

  public void testNoStats() {
    CacheBuilder<Object, Object> builder =
        CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(2);

    // Set<Object> keys = map.keySet();
    // assertThat(keys).containsExactly(one, three);
    // Collection<Object> values = map.values();
    // assertThat(values).containsExactly(one, two);

    map.clear();

    assertThat(cache.stats()).isEqualTo(EMPTY_STATS);
  }

  public void testNoStats() {
    CacheBuilder<Object, Object> builder =
        CacheBuilder.newBuilder().concurrencyLevel(1).maximumSize(2);

   *
   * <p>This is equivalent to {@code remove(Range.all())}.
   *
   * @throws UnsupportedOperationException if this range set does not support the {@code clear}
   *     operation
   */
  void clear();

  /**
   * Adds all of the ranges from the specified range set to this range set (optional operation).
   * After this operation, this range set is the minimal range set that {@linkplain

                ipAttempts.size());
    }

    /**
     * Reset all rate limiting state
     */
    public void reset() {
        accountAttempts.clear();
        ipAttempts.clear();
        globalAttemptsInCurrentWindow.set(0);
        currentWindowStart.set(System.currentTimeMillis());
        totalAttemptsBlocked.set(0);
        totalAccountsLocked.set(0);

        last = null;
      }
    };
  }

  @Override
  public Iterator<E> iterator() {
    return Multisets.iteratorImpl(this);
  }

  @Override
  public void clear() {
    countMap.clear();
  }

  @WeakOuter
  private final class EntrySet extends AbstractMultiset<E>.EntrySet {
    @Override
    ConcurrentHashMultiset<E> multiset() {
      return ConcurrentHashMultiset.this;

          {new MapRetrievalCache<String, String>(new TreeMap<String, String>(nullsLast))}
        });
  }

  @Before
  public void init() {
    mapCache.clear();
  }

  @Test
  public void testKeySetIterator() {
    mapCache.put("A", "A_value");
    mapCache.put("B", "B_value");
    mapCache.put("C", "C_value");

                    this.witnessClient = null;
                    this.witnessEnabled = false;
                }

                // Clear trees collection atomically
                if (this.trees != null) {
                    this.trees.clear();
                }
            }
        } else if (usage < 0) {
            throw new RuntimeCIFSException("Usage count dropped below zero");
        }

			if err != nil {
				err = msgp.WrapError(err, "ErrCounts")
				return
			}
			if z.ErrCounts == nil {
				z.ErrCounts = make(map[string]int, zb0003)
			} else if len(z.ErrCounts) > 0 {
				clear(z.ErrCounts)
			}
			for zb0003 > 0 {
				zb0003--
				var za0001 string
				za0001, err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "ErrCounts")
					return
				}

        }

        @Override
        public boolean retainAll(final Collection<?> c) {
            return parent.retainAll(c);
        }

        @Override
        public void clear() {
            parent.clear();
        }

        @Override
        public E get(final int index) {
            return parent.get(index);
        }

        @Override