def testRollAxisMustBeScalarOrVectorRaises(self):
   tensor = [[1, 2], [3, 4]]
   shift = 1
   axis = [[0, 1]]
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "axis must be a scalar or a 1-D vector"):
       manip_ops.roll(tensor, shift, axis).eval()

 def testRollAxisOutOfRangeRaises(self):
   tensor = [1, 2]
   shift = 1
   axis = 1
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "is out of range"):
       manip_ops.roll(tensor, shift, axis).eval()

 def testRollInputMustVectorHigherRaises(self):
   tensor = 7
   shift = 1
   axis = 0
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "input must be 1-D or higher"):
       manip_ops.roll(tensor, shift, axis).eval()

 def testRollShiftAndAxisMustBeSameSizeRaises(self):
   tensor = [[1, 2], [3, 4]]
   shift = [1]
   axis = [0, 1]
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "shift and axis must have the same size"):
       manip_ops.roll(tensor, shift, axis).eval()

 def testNegativeAxis(self):
   self._testAll(np.random.randint(-100, 100, (5)).astype(np.int32), 3, -1)
   self._testAll(np.random.randint(-100, 100, (4, 4)).astype(np.int32), 3, -2)
   # Make sure negative axis should be 0 <= axis + dims < dims
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "is out of range"):
       manip_ops.roll(np.random.randint(-100, 100, (4, 4)).astype(np.int32),
                      3, -10).eval()

 def testRollShiftMustBeScalarOrVectorRaises(self):
   # The shift should be a scalar or 1-D, checked in kernel.
   tensor = [[1, 2], [3, 4]]
   shift = array_ops.placeholder(dtype=dtypes.int32)
   axis = 1
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "shift must be a scalar or a 1-D vector"):
       manip_ops.roll(tensor, shift, axis).eval(feed_dict={shift: [[0, 1]]})

 def testRollShiftAndAxisMustBeSameSizeRaises(self):
   # The shift and axis must be same size, checked in kernel.
   tensor = [[1, 2], [3, 4]]
   shift = array_ops.placeholder(dtype=dtypes.int32)
   axis = [0, 1]
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "shift and axis must have the same size"):
       manip_ops.roll(tensor, shift, axis).eval(feed_dict={shift: [1]})

 def testRollInputMustVectorHigherRaises(self):
   # The input should be 1-D or higher, checked in kernel.
   tensor = array_ops.placeholder(dtype=dtypes.int32)
   shift = 1
   axis = 0
   with self.test_session():
     with self.assertRaisesRegexp(errors_impl.InvalidArgumentError,
                                  "input must be 1-D or higher"):
       manip_ops.roll(tensor, shift, axis).eval(feed_dict={tensor: 7})

 def _testGradient(self, np_input, shift, axis):
   with self.test_session():
     inx = constant_op.constant(np_input.tolist())
     xs = list(np_input.shape)
     y = manip_ops.roll(inx, shift, axis)
     # Expected y's shape to be the same
     ys = xs
     jacob_t, jacob_n = gradient_checker.compute_gradient(
         inx, xs, y, ys, x_init_value=np_input)
     self.assertAllClose(jacob_t, jacob_n, rtol=1e-5, atol=1e-5)

 def _testRoll(self, np_input, shift, axis):
   expected_roll = np.roll(np_input, shift, axis)
   with self.test_session():
     roll = manip_ops.roll(np_input, shift, axis)
     self.assertAllEqual(roll.eval(), expected_roll)

 def testInvalidShiftAndAxisNotEqualShape(self):
   # The shift and axis must be same size, checked in shape function.
   with self.assertRaisesRegexp(ValueError, "both shapes must be equal"):
     manip_ops.roll([[1, 2], [3, 4]], [1], [0, 1])

 def testInvalidShiftShape(self):
   # The shift should be a scalar or 1-D, checked in shape function.
   with self.assertRaisesRegexp(
       ValueError, "Shape must be at most rank 1 but is rank 2"):
     manip_ops.roll([[1, 2], [3, 4]], [[0, 1]], 1)

 def testInvalidInputShape(self):
   # The input should be 1-D or higher, checked in shape function.
   with self.assertRaisesRegexp(
       ValueError, "Shape must be at least rank 1 but is rank 0"):
     manip_ops.roll(7, 1, 0)

def _RollGrad(op, grad):
  # The gradient is just the roll reversed
  shift = op.inputs[1]
  axis = op.inputs[2]
  roll_grad = manip_ops.roll(grad, -shift, axis)
  return roll_grad, None, None