code: def test_order_rejection(self):
      blotter = Blotter(self.sim_params.data_frequency)
  
      # Reject a nonexistent order -> no order appears in new_order,
      # no exceptions raised out
      blotter.reject(56)
      self.assertEqual(blotter.new_orders, [])
  
      # Basic tests of open order behavior
      open_order_id = blotter.order(self.asset_24, 100, MarketOrder())
      second_order_id = blotter.order(self.asset_24, 50, MarketOrder())
      self.assertEqual(len(blotter.open_orders[self.asset_24]), 2)
      open_order = blotter.open_orders[self.asset_24][0]
      self.assertEqual(open_order.status, ORDER_STATUS.OPEN)
      self.assertEqual(open_order.id, open_order_id)
      self.assertIn(open_order, blotter.new_orders)
  
      # Reject that order immediately (same bar, i.e. still in new_orders)
      blotter.reject(open_order_id)
      self.assertEqual(len(blotter.new_orders), 2)
      self.assertEqual(len(blotter.open_orders[self.asset_24]), 1)
      still_open_order = blotter.new_orders[0]
      self.assertEqual(still_open_order.id, second_order_id)
      self.assertEqual(still_open_order.status, ORDER_STATUS.OPEN)
      rejected_order = blotter.new_orders[1]
      self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED)
      self.assertEqual(rejected_order.reason, "")
  
      # Do it again, but reject it at a later time (after tradesimulation
      # pulls it from new_orders)
      blotter = Blotter(self.sim_params.data_frequency)
      new_open_id = blotter.order(self.asset_24, 10, MarketOrder())
      new_open_order = blotter.open_orders[self.asset_24][0]
      self.assertEqual(new_open_id, new_open_order.id)
      # Pretend that the trade simulation did this.
      blotter.new_orders = []
  
      rejection_reason = "Not enough cash on hand."
      blotter.reject(new_open_id, reason=rejection_reason)
      rejected_order = blotter.new_orders[0]
      self.assertEqual(rejected_order.id, new_open_id)
      self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED)
      self.assertEqual(rejected_order.reason, rejection_reason)
  
      # You can't reject a filled order.
      # Reset for paranoia
      blotter = Blotter(self.sim_params.data_frequency)
      blotter.slippage_models[Equity] = FixedSlippage()
      filled_id = blotter.order(self.asset_24, 100, MarketOrder())
      filled_order = None
      blotter.current_dt = self.sim_params.sessions[-1]
      bar_data = self.create_bardata(
          simulation_dt_func=lambda: self.sim_params.sessions[-1],
      )
      txns, _, closed_orders = blotter.get_transactions(bar_data)
      for txn in txns:
          filled_order = blotter.orders[txn.order_id]
      blotter.prune_orders(closed_orders)
  
      self.assertEqual(filled_order.id, filled_id)
      self.assertIn(filled_order, blotter.new_orders)
      self.assertEqual(filled_order.status, ORDER_STATUS.FILLED)
      self.assertNotIn(filled_order, blotter.open_orders[self.asset_24])
  
      blotter.reject(filled_id)
      updated_order = blotter.orders[filled_id]
      self.assertEqual(updated_order.status, ORDER_STATUS.FILLED)
  
imports: from nose_parameterized import parameterized
  import pandas
  from catalyst.assets import Equity
  from catalyst.finance.blotter import Blotter
  from catalyst.finance.cancel_policy import EODCancel, NeverCancel
  from catalyst.finance.commission import PerTrade
  from catalyst.finance.execution import LimitOrder, MarketOrder, StopLimitOrder, StopOrder
  from catalyst.finance.order import ORDER_STATUS, Order
  from catalyst.finance.slippage import DEFAULT_EQUITY_VOLUME_SLIPPAGE_BAR_LIMIT, FixedSlippage
  from catalyst.gens.sim_engine import BAR, SESSION_END
  from catalyst.testing.fixtures import WithCreateBarData, WithDataPortal, WithLogger, WithSimParams, CatalystTestCase
  from catalyst.utils.classproperty import classproperty
label_desc: Use image node_id 9 for calling the BlotterTestCase obj's underlying member method code with example usage: obj.test_order_rejection() without return types