void Verify(const RuntimeMetadata* result, const RuntimeMetadata* expected) {
  EXPECT_EQ(result->subgraph_metadata()->size(),
            expected->subgraph_metadata()->size());
  for (int i = 0; i < result->subgraph_metadata()->size(); ++i) {
    auto result_subgraph_metadata =
        result->subgraph_metadata()->GetAs<SubgraphMetadata>(i);
    auto expected_subgraph_metadata =
        expected->subgraph_metadata()->GetAs<SubgraphMetadata>(i);

  reader.parse(metrics::SavedModelReadFingerprint().value(), fingerprint);
  EXPECT_EQ(fingerprint["saved_model_checksum"].asUInt64(),
            15788619162413586750ULL);
  EXPECT_EQ(fingerprint["graph_def_program_hash"].asUInt64(),
            706963557435316516ULL);
  EXPECT_EQ(fingerprint["signature_def_hash"].asUInt64(),
            5693392539583495303ULL);
  EXPECT_EQ(fingerprint["saved_object_graph_hash"].asUInt64(),

				}
				if !strings.Contains(err.Error(), tc.ExpectErr) {
					t.Fatalf("expected error %s, got %v", tc.ExpectErr, err)
				}
				return
			}
			if len(tc.ExpectErr) > 0 {
				t.Fatalf("expected error %s, got none", tc.ExpectErr)
			}
			if !reflect.DeepEqual(tc.Out, tc.ExpectOut) {
				t.Fatalf("unexpected result:\n %s", cmp.Diff(tc.ExpectOut, tc.Out))
			}
		})
	}

				}
				if !strings.Contains(err.Error(), tc.ExpectErr) {
					t.Fatalf("expected error %s, got %v", tc.ExpectErr, err)
				}
				return
			}
			if len(tc.ExpectErr) > 0 {
				t.Fatalf("expected error %s, got none", tc.ExpectErr)
			}
			if !reflect.DeepEqual(tc.Out, tc.ExpectOut) {
				t.Fatalf("unexpected result:\n %s", cmp.Diff(tc.ExpectOut, tc.Out))
			}
		})
	}

  }

  EXPECT_EQ(listener()->jit_compilation_activity().cluster_name(), "cluster_0");
  EXPECT_EQ(listener()->jit_compilation_activity().compile_count(), 2);

  EXPECT_GT(listener()->jit_compilation_activity().compile_time_us(), 0);
  EXPECT_EQ(listener()->jit_compilation_activity().cumulative_compile_time_us(),
            first_compile_time +
                listener()->jit_compilation_activity().compile_time_us());
}

}  // namespace

    TF_ASSERT_OK(scope_.status());
    float max_error;
    TF_ASSERT_OK((ComputeGradientError<float, float, float>(
        scope_, xs, x_shapes, ys, y_shapes, &max_error)));
    EXPECT_LT(max_error, 1e-4);
  }

  Scope scope_;
};

TEST_F(DataFlowGradTest, DynamicPartitionGrad) {
  TensorShape data_shape({2, 3, 2});
  auto data = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(data_shape));

              ::testing::Contains(fingerprint_pb.graph_def_program_hash()));
  EXPECT_EQ(fingerprint_pb.signature_def_hash(), 1043582354059066488U);
  EXPECT_THAT(absl::flat_hash_set<uint64_t>(
                  {2766043449526180728U, 11894619660760763927U}),
              ::testing::Contains(fingerprint_pb.saved_object_graph_hash()));
  EXPECT_EQ(fingerprint_pb.checkpoint_hash(), 0);
}

}  // namespace

    ASSERT_TRUE(node->while_ctx() != nullptr) << i;
    if (i == 0) {
      while_ctx = node->while_ctx();
      EXPECT_EQ(while_ctx->frame_name(), kFrameName);
    } else {
      EXPECT_EQ(node->while_ctx(), while_ctx) << i;
    }
  }

  // Run the loop and test we get the expected results
  Run<int>({1}, {10});
  Run<int>({11}, {11});
}

TEST_F(WhileLoopTest, WrongCondOutputType) {
  Init(1);

  SourceCode code;
  TestRenderer(code).Render();

  string expected = R"(// File level comment.
#include "header.h"

void TestFunction() {
   int i = 1;

   while (i == 1) {
      // Do nothing, really....
#if 0
      call();
#endif
   }
}  // comment ending TestFunction
)";

  code.SetSpacesPerIndent(3);
  EXPECT_EQ(expected, code.Render());
}

}  // namespace
}  // namespace cpp

}
)";

void ExpectHasSubstr(StringPiece s, StringPiece expected) {
  EXPECT_TRUE(absl::StrContains(s, expected))
      << "'" << s << "' does not contain '" << expected << "'";
}

void ExpectDoesNotHaveSubstr(StringPiece s, StringPiece expected) {
  EXPECT_FALSE(absl::StrContains(s, expected))
      << "'" << s << "' contains '" << expected << "'";
}

void ExpectSubstrOrder(const string& s, const string& before,