public void testTransformEquals() {
    Map<String, Integer> underlying = ImmutableMap.of("a", 0, "b", 1, "c", 2);
    Map<String, Integer> expected = transformValues(underlying, Functions.<Integer>identity());

    assertMapsEqual(expected, expected);

    Map<String, Integer> equalToUnderlying = Maps.newTreeMap();
    equalToUnderlying.putAll(underlying);

        return this;
    }

    public void setDepth_Equal(Integer depth) {
        setDepth_Term(depth, null);
    }

    public void setDepth_Equal(Integer depth, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setDepth_Term(depth, opLambda);
    }

    public void setDepth_Term(Integer depth) {
        setDepth_Term(depth, null);
    }

  // the CacheBuilder default).
  private Set<Integer> concurrencyLevels = Sets.newHashSet((Integer) null);
  private Set<Integer> initialCapacities = Sets.newHashSet((Integer) null);
  private Set<Integer> maximumSizes = Sets.newHashSet((Integer) null);
  private Set<DurationSpec> expireAfterWrites = Sets.newHashSet((DurationSpec) null);

@NullUnmarked
public class FilteredMultimapTest extends TestCase {

  private static final Predicate<Entry<String, Integer>> ENTRY_PREDICATE =
      entry ->
          !Objects.equals(entry.getKey(), "badkey") && !Objects.equals(entry.getValue(), 55556);

  protected Multimap<String, Integer> create() {
    Multimap<String, Integer> unfiltered = HashMultimap.create();
    unfiltered.put("foo", 55556);
    unfiltered.put("badkey", 1);

  }

  public void testComplexBuilder() {
    List<Integer> colorElem = asList(0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF);
    ImmutableList.Builder<Integer> webSafeColorsBuilder = ImmutableList.builder();
    for (Integer red : colorElem) {
      for (Integer green : colorElem) {
        for (Integer blue : colorElem) {
          webSafeColorsBuilder.add((red << 16) + (green << 8) + blue);
        }

  }

  private Multimap<String, Integer> createMultimap() {
    Multimap<String, Integer> unfiltered = HashMultimap.create();
    unfiltered.put("zero", 55556);
    unfiltered.put("one", 55556);
    unfiltered.put("badkey", 1);
    return Multimaps.filterEntries(unfiltered, PREDICATE);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    Multimap<String, Integer> multimap = createMultimap();

      serializer.submit(Callables.<Void>returning(null), directExecutor()).cancel(true);
    }
    ListenableFuture<Integer> stackDepthCheck =
        serializer.submit(
            new Callable<Integer>() {
              @Override
              public Integer call() {
                return Thread.currentThread().getStackTrace().length;
              }
            },
            directExecutor());

                    | Smb2Constants.SMB2_GLOBAL_CAP_DIRECTORY_LEASING | Smb2Constants.SMB2_GLOBAL_CAP_ENCRYPTION;

            assertTrue(maxCap > 0 && maxCap < Integer.MAX_VALUE, "Combined capabilities should fit in positive 32-bit integer");
        }
    }

		<key>.*</key>
		<true/>
		<key>Info.plist</key>
		<dict>
			<key>omit</key>
			<true/>
			<key>weight</key>
			<integer>10</integer>
		</dict>
		<key>ResourceRules.plist</key>
		<dict>
			<key>omit</key>
			<true/>
			<key>weight</key>
			<integer>100</integer>
		</dict>
	</dict>
</dict>
</plist>

@RunWith(Parameterized.class)
@NullUnmarked
public final class GraphEquivalenceTest {
  private static final Integer N1 = 1;
  private static final Integer N2 = 2;
  private static final Integer N3 = 3;

  private final EdgeType edgeType;
  private final MutableGraph<Integer> graph;

  // add parameters: directed/undirected
  @Parameters
  public static Collection<Object[]> parameters() {