};

struct TF_Function {
  tensorflow::FunctionRecord* record;
};

struct TF_ApiDefMap {
  explicit TF_ApiDefMap(const tensorflow::OpList& op_list)
      :
#if !defined(IS_MOBILE_PLATFORM) && !defined(IS_SLIM_BUILD)
        api_def_map(op_list),
#endif  // !defined(IS_MOBILE_PLATFORM) && !defined(IS_SLIM_BUILD)
        update_docs_called(false) {
  }

        .testEquals();
  }

  public void testIsInOrder() {
    assertFalse(isInOrder(asList(5, 3, 0, 9), Ordering.natural()));
    assertFalse(isInOrder(asList(0, 5, 3, 9), Ordering.natural()));
    assertTrue(isInOrder(asList(0, 3, 5, 9), Ordering.natural()));
    assertTrue(isInOrder(asList(0, 0, 3, 3), Ordering.natural()));
    assertTrue(isInOrder(asList(0, 3), Ordering.natural()));
    assertTrue(isInOrder(singleton(1), Ordering.natural()));

    public boolean equals(@Nullable Object object) {
      if (object instanceof AsList) {
        AsList that = (AsList) object;
        return this.parent.equals(that.parent);
      }
      // We could delegate to super now but it would still box too much
      if (!(object instanceof List)) {
        return false;
      }
      List<?> that = (List<?>) object;
      if (this.size() != that.size()) {
        return false;

    public boolean equals(@Nullable Object object) {
      if (object instanceof AsList) {
        AsList that = (AsList) object;
        return this.parent.equals(that.parent);
      }
      // We could delegate to super now but it would still box too much
      if (!(object instanceof List)) {
        return false;
      }
      List<?> that = (List<?>) object;
      if (this.size() != that.size()) {
        return false;

        }
    }

    public void test_startProcess_replaceExistingProcess() {
        String sessionId = "test_replace";
        List<String> cmdList1 = Arrays.asList("echo", "first");
        List<String> cmdList2 = Arrays.asList("echo", "second");
        Consumer<ProcessBuilder> pbCall = pb -> {
            pb.redirectErrorStream(true);
        };

        try {

        return artifact -> false;
    }

    @Test
    void testEquals() {
        AndArtifactFilter filter1 = new AndArtifactFilter();

        AndArtifactFilter filter2 = new AndArtifactFilter(Arrays.asList(newSubFilter()));

        assertFalse(filter1.equals(null));
        assertTrue(filter1.equals(filter1));
        assertEquals(filter1.hashCode(), filter1.hashCode());

        assertFalse(filter1.equals(filter2));

@NullUnmarked
public class MapsMemoryBenchmark {
  static final Map<String, MapsImplEnum> mapEnums =
      uniqueIndex(
          Iterables.<MapsImplEnum>concat(
              asList(MapImpl.values()), asList(SortedMapImpl.values()), asList(BiMapImpl.values())),
          toStringFunction());

  @Param({
    "HashMapImpl",
    "LinkedHashMapImpl",
    "ConcurrentHashMapImpl",
    "CompactHashMapImpl",

    ImmutableSet.Builder<Double> fractionalBuilder = ImmutableSet.builder();
    integralBuilder.addAll(Doubles.asList(0.0, -0.0, Double.MAX_VALUE, -Double.MAX_VALUE));
    // Add small multiples of MIN_VALUE and MIN_NORMAL
    for (int scale = 1; scale <= 4; scale++) {
      for (double d : Doubles.asList(Double.MIN_VALUE, Double.MIN_NORMAL)) {
        fractionalBuilder.add(d * scale).add(-d * scale);
      }
    }

    }
  }

  public void testAssertEqualInOrder() {
    List<?> list = asList("a", "b", "c");
    assertEqualInOrder(list, list);

    List<?> fewer = asList("a", "b");
    try {
      assertEqualInOrder(list, fewer);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertEqualInOrder(fewer, list);
      throw new Error();
    } catch (AssertionFailedError expected) {

    }
  }

  public void testAssertEqualInOrder() {
    List<?> list = asList("a", "b", "c");
    assertEqualInOrder(list, list);

    List<?> fewer = asList("a", "b");
    try {
      assertEqualInOrder(list, fewer);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }

    try {
      assertEqualInOrder(fewer, list);
      throw new Error();
    } catch (AssertionFailedError expected) {