def testExecuteListTypeListShapeAttr(self):
   execute.execute(
       'Barrier',
       num_outputs=1,
       inputs=[],
       attrs=('component_types', [dtypes.float64.as_datatype_enum], 'shapes',
              [[1, 2]], 'capacity', -1, 'container', '', 'shared_name', ''))

 def testExecuteListFloatAttrBadValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         'Bucketize',
         num_outputs=1,
         inputs=[tensor.Tensor([3.0, 5.0, 7.0])],
         attrs=('T', dtypes.float32.as_datatype_enum, 'boundaries', 4.0))

 def testExecuteListIntAttrBadValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         'Squeeze',
         num_outputs=1,
         inputs=[tensor.Tensor([[[3.0]]])],
         attrs=('T', dtypes.float32.as_datatype_enum, 'squeeze_dims', 0))

 def testExecuteShapeAttr(self):
   execute.execute(
       'VarHandleOp',
       num_outputs=1,
       inputs=[],
       attrs=('shape', [1, 2], 'dtype', dtypes.int32.as_datatype_enum,
              'container', '', 'shared_name', ''))

 def testExecuteUnknownAttr(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         'Identity',
         num_outputs=1,
         inputs=[tensor.Tensor(3)],
         attrs=('T', dtypes.int32.as_datatype_enum, 'unknown_attr', 'blah'))

 def testExecuteListTypeAttrBadListValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         b'Barrier',
         num_outputs=1,
         inputs=[],
         attrs=('component_types', '1', 'shapes', [[1, 2]], 'capacity', -1,
                'container', '', 'shared_name', ''))

 def testExecuteListIntAttrBadListValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         b'Squeeze',
         num_outputs=1,
         inputs=[constant_op.constant([[[3.0]]])],
         attrs=('T', dtypes.float32.as_datatype_enum, 'squeeze_dims',
                ['0', '2']))

 def testExecuteListFloatAttrBadListValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         b'Bucketize',
         num_outputs=1,
         inputs=[constant_op.constant([3.0, 5.0, 7.0])],
         attrs=('T', dtypes.float32.as_datatype_enum, 'boundaries',
                ['4.0', '6.0']))

 def testExecuteListShapeAttrBadListValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         'Barrier',
         num_outputs=1,
         inputs=[],
         attrs=('component_types', [dtypes.float64.as_datatype_enum], 'shapes',
                [1], 'capacity', -1, 'container', '', 'shared_name', ''))

 def testExecuteListStringAttrBadListValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         'TensorSummary',
         num_outputs=1,
         inputs=[tensor.Tensor(3.0)],
         attrs=('T', dtypes.float32.as_datatype_enum, 'description', '',
                'labels', [3], 'display_name', 'test'))

 def testExecuteListStringAttr(self):
   execute.execute(
       'TensorSummary',
       num_outputs=1,
       inputs=[tensor.Tensor(3.0)],
       attrs=('T', dtypes.float32.as_datatype_enum, 'description',
              'tensor_summary', 'labels', ['3',
                                           'summary'], 'display_name', 'test'))

 def testExecuteShapeAttrBadValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     execute.execute(
         'VarHandleOp',
         num_outputs=1,
         inputs=[],
         attrs=('shape', 1, 'dtype', dtypes.int32.as_datatype_enum,
                'container', '', 'shared_name', ''))

  def testOperationWithNoInputsRunsOnDevice(self):
    if not context.context().num_gpus():
      self.skipTest('No GPUs found')
    shape = tensor.Tensor([], dtype=dtypes.int32)

    # x: Run the "TruncatedNormal" op CPU and copy result to GPU.
    x = truncated_normal(shape).as_gpu_tensor()
    # y: Explicitly run the "TruncatedNormal" op on GPU.
    with context.device('gpu:0'):
      y = truncated_normal(shape)
    # Add would fail if x and y were not on the same device.
    execute.execute(
        'Add', 1, inputs=[x, y], attrs=('T', x.dtype.as_datatype_enum))

def xla_launch_eager_fallback(constants, args, resources, Tresults, function, name=None, ctx=None):
  r"""This is the slowpath function for Eager mode.
  This is for function xla_launch
  """
  _ctx = ctx if ctx else _context.context()
  if not isinstance(resources, (list, tuple)):
    raise TypeError(
        "Expected list for 'resources' argument to "
        "'xla_launch' Op, not %r." % resources)
  _attr_Nresources = len(resources)
  if not isinstance(Tresults, (list, tuple)):
    raise TypeError(
        "Expected list for 'Tresults' argument to "
        "'xla_launch' Op, not %r." % Tresults)
  Tresults = [_execute.make_type(_t, "Tresults") for _t in Tresults]
  _attr_Tconstants, constants = _execute.convert_to_mixed_eager_tensors(constants, _ctx)
  _attr_Targs, args = _execute.convert_to_mixed_eager_tensors(args, _ctx)
  resources = _ops.convert_n_to_tensor(resources, _dtypes.resource)
  _inputs_flat = list(constants) + list(args) + list(resources)
  _attrs = ("Tconstants", _attr_Tconstants, "Targs", _attr_Targs,
  "Nresources", _attr_Nresources, "Tresults", Tresults, "function", function)
  _result = _execute.execute(b"XlaLaunch", len(Tresults), inputs=_inputs_flat,
                             attrs=_attrs, ctx=_ctx, name=name)
  _execute.record_gradient(
      "XlaLaunch", _inputs_flat, _attrs, _result, name)
  return _result

 def _capture_by_value(
     self,
     op_type,
     inputs,
     dtypes,  # pylint: disable=redefined-outer-name
     input_types=None,
     name=None,
     attrs=None,
     op_def=None,
     compute_shapes=True,
     compute_device=True):
   # When capturing by value, do the read outside
   reverse_captures = dict((v, k) for k, v in self.captures.items())
   uncaptured_inputs = [reverse_captures.get(t, t) for t in inputs]
   with ops.init_scope():
     if context.executing_eagerly():
       attr_list = ("dtype", int(attrs["dtype"].type))
       value, = execute.execute(
           compat.as_bytes(op_type), 1, uncaptured_inputs, attr_list,
           context.context())
     else:
       op = ops.get_default_graph().create_op(
           op_type, uncaptured_inputs, dtypes, input_types, name, attrs,
           op_def, compute_shapes, compute_device)
       value = op.outputs[0]
   captured_value = self.capture(value)
   return captured_value.op

 def testExecuteIntAttr(self):
   total = execute.execute(
       b'AddN',
       num_outputs=1,
       inputs=[constant_op.constant(3), constant_op.constant(4)],
       attrs=('T', dtypes.int32.as_datatype_enum, 'N', 2))[0]
   self.assertEqual(7, total.numpy())

 def testExecuteIntAttr(self):
   total = execute.execute(
       'AddN',
       num_outputs=1,
       inputs=[tensor.Tensor(3), tensor.Tensor(4)],
       attrs=('T', dtypes.int32.as_datatype_enum, 'N', 2))[0]
   self.assertEqual(7, total.numpy())

 def testExecuteFloatAttrBadValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     _ = execute.execute(
         'ApproximateEqual',
         num_outputs=1,
         inputs=[tensor.Tensor(3.0), tensor.Tensor(2.9)],
         attrs=('tolerance', '0.3', 'T', dtypes.float32.as_datatype_enum))

 def testExecuteFloatAttr(self):
   almost_equal = execute.execute(
       'ApproximateEqual',
       num_outputs=1,
       inputs=[tensor.Tensor(3.0), tensor.Tensor(2.9)],
       attrs=('tolerance', 0.3, 'T', dtypes.float32.as_datatype_enum))[0]
   self.assertTrue(almost_equal.numpy())

 def testExecuteStringAttrBadValue(self):
   with self.assertRaises(errors.InvalidArgumentError):
     _ = execute.execute(
         'CheckNumerics',
         num_outputs=1,
         inputs=[tensor.Tensor(3.)],
         attrs=('message', 1, 'T', dtypes.float32.as_datatype_enum))