Cause the real one doesn't work.
322599
public function get_search_query($escaped = true)
    {
        $s     = isset($_REQUEST['s']) ? $_REQUEST['s'] : '';
        $query = apply_filters('get_search_query', $s);

        if ($escaped) {
            $query = esc_attr($query);
        }

        return $query;
    }
1218492
def exists(self):
        
        t = self.wait_timeout
        self.wait_timeout = 0
        try:
            self.reload()
            return True
        except NoSuchElementException:
            return False
        finally:
            self.wait_timeout = t
168131
function real(object, key) {
  return own.call(object, key) && object[key] !== undefined
}
356270
def dup(self, other=None, **kwds):
        '''
        '''
        if other is None:
            d = _dict_typedef.kwds()
        else:
            d =  other.kwds()
        d.update(kwds)
        self.reset(**d)
677484
def wait_for_exists(self, timeout=0, *args, **selectors):
        
        return self.device(**selectors).wait.exists(timeout=timeout)
123804
def clone_(self, quiet=False):
        
        ds2 = self._duplicate_(quiet=True)
        if ds2 is None:
            self.err("Can not clone instance")
        else:
            if quiet is False:
                self.ok("Instance cloned")
        return ds2
923066
def identical(self, other):
        
        try:
            return (self.name == other.name and
                    self._all_compat(other, 'identical'))
        except (TypeError, AttributeError):
            return False
727247
def failMeasurement(self, measurementId, deviceName, failureReason=None):
        
        am, handler = self.getDataHandler(measurementId, deviceName)
        if handler is not None:
            am.updateDeviceStatus(deviceName, RecordStatus.FAILED, reason=failureReason)
            handler.stop(measurementId)
            return True
        else:
            return False
497358
def check_valid_device(self, path, run_as_root=True):
        """"""
        if self.im_root:
            try:
                with open(path, 'r') as f:
                    f.read(4096)
            except Exception:
                return False
            return True

        try:
            self._execute('dd', 'if=' + path, 'of=/dev/null', 'bs=4096',
                          'count=1', root_helper=self._root_helper,
                          run_as_root=True)
        except putils.ProcessExecutionError:
            return False
        return True
1114944
def fix_e301(self, result):
        """"""
        cr = '\n'
        self.source[result['line'] - 1] = cr + self.source[result['line'] - 1]
859888
def do_fake( formatter, *args, **kwargs ):
    
    return Faker.getGenerator().format( formatter, *args, **kwargs )
1355445
def duplicate(self):
        '''
        
        '''
        return self.__class__(amount=self.amount, date=self.date,
                              method=self.method, ref=self.ref)
967276
private static boolean isNookDevice() {
        String brand = Build.BRAND;
        String manufacturer = System.getProperty("ro.nook.manufacturer");
        return ((brand != null && brand.equalsIgnoreCase("nook")) ||
                manufacturer != null && manufacturer.equalsIgnoreCase("nook"));
    }
23202
def duplicate(self):
        '''
        
        '''
        return self.__class__(name=self.name, identifier=self.identifier,
                              phone=self.phone, require_id=self.__require_id,
                              address=self.address.duplicate())
265306
def _ob_maybe_repl(v: nil, dupit: nil, oc: nil, patch: {})
      if v.respond_to? :_replicate
        v._replicate(oc: oc, dupit: dupit, patch: patch)
      else
        v
      end
    end
1340672
def get_original(self):
        
        pk_value = self._get_pk_value()

        if isinstance(pk_value, int) and not self._original:
            self._original = (
                self.select().where(self.__class__.id == pk_value).get()
            )

        return self._original
645542
def copy(self):
        '''
        
        '''
        dup = super(Conditional, self).copy()
        condition = self._condition.copy()
        condition.invalidate(self)
        dup._condition = condition
        return dup