auto s = GetValue(t, &analytical_tensor);
  ASSERT_EQ(errors::OK, s.code()) << s.message();

  int64_t num_elem_analytical = 1;
  auto num_dims_analytical = TF_NumDims(analytical_tensor);
  ASSERT_EQ(dims.size(), num_dims_analytical);
  for (int j = 0; j < num_dims_analytical; j++) {
    auto dim_analytical = TF_Dim(analytical_tensor, j);
    ASSERT_EQ(dims[j], dim_analytical);
    num_elem_analytical *= dim_analytical;

  TFE_Execute(func, &retvals[0], &num_retvals, status);
  ASSERT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  ASSERT_EQ(1, num_retvals);
  TF_Tensor* t = TFE_TensorHandleResolve(retvals[0], status);
  ASSERT_EQ(TF_OK, TF_GetCode(status)) << TF_Message(status);
  TFE_DeleteTensorHandle(retvals[0]);
  float sum = 0;
  ASSERT_EQ(sizeof(sum), TF_TensorByteSize(t));
  memcpy(&sum, TF_TensorData(t), TF_TensorByteSize(t));

    status_ = StatusFromTF_Status(status.get());
    ASSERT_EQ(errors::OK, status_.code()) << status_.message();

    {
      AbstractContext* ctx_raw = nullptr;
      status_ =
          BuildImmediateExecutionContext(std::get<1>(GetParam()), &ctx_raw);
      ASSERT_EQ(errors::OK, status_.code()) << status_.message();
      immediate_execution_ctx_.reset(ctx_raw);
    }

  std::stringstream stream;
  stream << x;
  ASSERT_EQ(stream.str(), "42");
}

TEST(OStreamTest, TestFloat32) {
  Float32 x(0.375);  // Exactly representable as a float.
  std::stringstream stream;
  stream << x;
  ASSERT_EQ(stream.str(), "0.375");
}

TEST(OStreamTest, TestString) {
  String s("foo");
  std::stringstream stream;
  stream << s;
  ASSERT_EQ(stream.str(), "foo");
}

          tensorflow::unwrap(saved_model));
  tensorflow::Variable* uninitialized_variable;
  ASSERT_EQ(absl::OkStatus(), model_api->GetVariable("uninitialized_variable",
                                                     &uninitialized_variable));
  ASSERT_EQ(tensorflow::DT_FLOAT, uninitialized_variable->dtype());

  ASSERT_EQ(absl::OkStatus(),
            model_api->GetVariable("sub_module.uninitialized_variable",

  (*module_ref)->setAttr("tf.devices", device_dict);

  mlir::TF::RuntimeDevices devices;
  EXPECT_TRUE(mlir::succeeded(GetDevicesFromOp(*module_ref, &devices)));

  ASSERT_EQ(devices.NumDevices(), 1);
  ASSERT_EQ(devices.device_names().size(), 1);
  ASSERT_EQ(DeviceNameUtils::ParsedNameToString(devices.device_names()[0]),
            "/job:worker/replica:0/task:0/device:CPU:0");
}

TEST(DeviceUtilTest, GetGpuDeviceMetadata) {

      }));

  ASSERT_EQ(inputs.size(), 1);
  EXPECT_EQ(inputs[0], "x");
  ASSERT_EQ(outputs.size(), 1);
  EXPECT_EQ(outputs[0], "r");

  ASSERT_EQ(in_specs.size(), 1);
  ASSERT_EQ(in_specs[0].first, tensorflow::DT_INT32);
  ASSERT_TRUE(in_specs[0].second.IsIdenticalTo(PartialTensorShape({1, 3})));

  ASSERT_EQ(out_specs.size(), 1);
  ASSERT_EQ(out_specs[0].first, tensorflow::DT_INT32);

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures.server

interface ServerExpectation {
    void assertMet()

 */

package org.gradle.test.fixtures.server

import groovy.transform.CompileStatic

@CompileStatic
abstract class ForbidOne extends OneRequestServerExpectation {

    void assertMet() {
        if (run) {
            throw new AssertionError(notMetMessage as Object)
        }
    }

    abstract String getNotMetMessage()

 */

package org.gradle.test.fixtures.server

import groovy.transform.CompileStatic

@CompileStatic
abstract class ExpectOne extends OneRequestServerExpectation {

    @Override
    void assertMet() {
        if (!run) {
            throw new AssertionError(notMetMessage as Object)
        }
    }

    abstract String getNotMetMessage()