nextOrNull = forward().lowerEntry(nextOrNull.getKey());
          }
        }

        @Override
        public void remove() {
          if (toRemove == null) {
            throw new IllegalStateException("no calls to next() since the last call to remove()");
          }
          forward().remove(toRemove.getKey());
          toRemove = null;
        }
      };
    }
  }

            nextOrNull = forward().lowerEntry(nextOrNull.getKey());
          }
        }

        @Override
        public void remove() {
          if (toRemove == null) {
            throw new IllegalStateException("no calls to next() since the last call to remove()");
          }
          forward().remove(toRemove.getKey());
          toRemove = null;
        }
      };
    }
  }

      for (Object element : elements) {
        @SuppressWarnings("unchecked")
        Entry<String, Integer> entry = (Entry<String, Integer>) element;
        multimap.put(entry.getKey(), entry.getValue());
      }
      return multimap.entries();
    }

    abstract Multimap<String, Integer> createMultimap();

    @Override
    @SuppressWarnings("unchecked")

      Map<K, V> map, ObjectOutputStream stream) throws IOException {
    stream.writeInt(map.size());
    for (Map.Entry<K, V> entry : map.entrySet()) {
      stream.writeObject(entry.getKey());
      stream.writeObject(entry.getValue());
    }
  }

  /**
   * Populates a map by reading an input stream, as part of deserialization. See {@link #writeMap}
   * for the data format.
   */

                buf.append('{');
                boolean first2 = true;
                for (final Map.Entry<String, Object> entry : doc.entrySet()) {
                    final String name = entry.getKey();
                    if (StringUtil.isNotBlank(name) && entry.getValue() != null) {
                        if (!first2) {
                            buf.append(',');
                        } else {

                if (now - entry.getValue().getLastAccessTime() > maxAgeMillis) {
                    leases.remove(entry.getKey());
                    pathToLease.remove(entry.getValue().getPath());
                    cleaned++;
                    log.debug("Cleaned up expired lease: {}", entry.getKey());
                }
            }

            if (cleaned > 0) {

                    .filter(k -> !sys.contains(k.getKey()))
                    .peek(k -> context.pushedUserProperties.add(k.getKey()))
                    .forEach(k -> System.setProperty(k.getKey(), k.getValue()));
        } else {
            protoSession.getUserProperties().entrySet().stream()
                    .filter(k -> context.pushedUserProperties.contains(k.getKey()) || !sys.contains(k.getKey()))

      if (testAsCharSource) {
        suite.addTest(suiteForString(factory, entry.getValue(), name, entry.getKey()));
      } else {
        suite.addTest(
            suiteForBytes(factory, entry.getValue().getBytes(UTF_8), name, entry.getKey(), true));
      }
    }
    return suite;
  }

  static TestSuite suiteForString(

                        result.addException(exception);
                    }
                }
            } else {
                String key = SNAPSHOT + getKey(artifact.getClassifier(), artifact.getExtension());
                merge(infos, SNAPSHOT, key);
                if (!resolve(result, infos, key)) {
                    result.setVersion(version);
                }

      @Override
      protected @Nullable E computeNext() {
        while (entries.hasNext()) {
          Entry<E, ?> entry = entries.next();
          if (targetNode.equals(entry.getValue())) {
            return entry.getKey();
          }
        }
        return endOfData();
      }
    };
  }

  @Override
  public boolean contains(@Nullable Object edge) {
    return targetNode.equals(outEdgeToNode.get(edge));
  }