code: def test_boolean_binops(self):
      f, g, h = self.f, self.g, self.h
  
      # Add a non-numexpr filter to ensure that we correctly handle
      # delegation to NumericalExpression.
      custom_filter = NonExprFilter()
      custom_filter_mask = array(
          [
              [0, 1, 0, 1, 0],
              [0, 0, 1, 0, 0],
              [1, 0, 0, 0, 0],
              [0, 0, 1, 1, 0],
              [0, 0, 0, 1, 0],
          ],
          dtype=bool,
      )
  
      self.fake_raw_data = {
          f: arange(25, dtype=float).reshape(5, 5),
          g: arange(25, dtype=float).reshape(5, 5) - eye(5),
          h: full((5, 5), 5, dtype=float),
          custom_filter: custom_filter_mask,
      }
  
      # Should be True on the diagonal.
      eye_filter = f > g
  
      # Should be True in the first row only.
      first_row_filter = f < h
  
      eye_mask = eye(5, dtype=bool)
  
      first_row_mask = zeros((5, 5), dtype=bool)
      first_row_mask[0] = 1
  
      self.check_output(eye_filter, eye_mask)
      self.check_output(first_row_filter, first_row_mask)
  
      def gen_boolops(x, y, z):
          """
          Generate all possible interleavings of & and | between all possible
          orderings of x, y, and z.
          """
          for a, b, c in permutations([x, y, z]):
              yield (a & b) & c
              yield (a & b) | c
              yield (a | b) & c
              yield (a | b) | c
              yield a & (b & c)
              yield a & (b | c)
              yield a | (b & c)
              yield a | (b | c)
  
      exprs = gen_boolops(eye_filter, custom_filter, first_row_filter)
      arrays = gen_boolops(eye_mask, custom_filter_mask, first_row_mask)
  
      for expr, expected in zip(exprs, arrays):
          self.check_output(expr, expected)
  
imports: from itertools import permutations
  from operator import add, ge, gt, le, lt, methodcaller, mul, ne, sub
  from string import ascii_uppercase
  from unittest import TestCase
  import numpy
  from numpy import arange, array, eye, float64, full, isnan, zeros
  from pandas import DataFrame, date_range, Int64Index
  from catalyst.pipeline import Factor, Filter
  from catalyst.pipeline.expression import NumericalExpression, NUMEXPR_MATH_FUNCS
  from catalyst.testing import check_allclose
  from catalyst.utils.numpy_utils import datetime64ns_dtype, float64_dtype
label_desc: Use image node_id 19 for calling the NumericalExpressionTestCase obj's underlying member method code with example usage: obj.test_boolean_binops() without return types