def test_valid_unicode_removed(self):
        q = '/?page=2345&q=%E6%9F%A5%E8%AF%A2'
        key = 'page'
        value = '2345'
        removed_key = 'q'

        assert key in remove_query_param(q, removed_key)
        assert value in remove_query_param(q, removed_key)
        assert '%' not in remove_query_param(q, removed_key)

    def page_number_query(self, url, page_number):
        """
        Builds uri and adds page param.
        """
        url = remove_query_param(self.request.build_absolute_uri(url), '_')
        paginated_url = replace_query_param(url, self.page_query_param, page_number)

        if page_number == 1:
            return remove_query_param(paginated_url, self.page_query_param)

        return paginated_url

 def get_first_link(self, display_page_query_param=True):
     url = self.request.build_absolute_uri()
     if display_page_query_param:
         page_number = self.page.paginator.validate_number(1)
         return replace_query_param(url, self.page_query_param, page_number)
     else:
         return remove_query_param(url, self.page_query_param)

 def get_previous_link(self):
     if not self.page.has_previous():
         return None
     url = self.request.build_absolute_uri()
     page_number = self.page.previous_page_number()
     if page_number == 1:
         return remove_query_param(url, self.page_query_param)
     return replace_query_param(url, self.page_query_param, page_number)

    def get_first_link(self):
        """ Return the URL of the first paginated page """

        if not self.get_previous_link():
            return None

        return remove_query_param(
            self.request.build_absolute_uri(),
            self.offset_query_param
        )

    def get_previous_link(self):
        if self.offset <= 0:
            return None

        url = self.request.build_absolute_uri()

        if self.offset - self.limit <= 0:
            return remove_query_param(url, self.offset_query_param)

        offset = self.offset - self.limit
        return replace_query_param(url, self.offset_query_param, offset)

    def get_last_link(self):
        if self.count == 0:
            return None

        url = self.request.build_absolute_uri()
        url = replace_query_param(url, self.limit_query_param, self.limit)

        offset = self.count - self.limit

        if offset <= 0:
            return remove_query_param(url, self.offset_query_param)

        return replace_query_param(url, self.offset_query_param, offset)

    def _get_paginate_link(self, page_number) -> str:
        """
        Args:
            page_number: int

        Returns:
            string: URL of the requested page

        """
        try:
            self.pagination.validate_number(page_number)
        except EmptyPage:
            return ''

        url = self.request.build_absolute_uri()
        if page_number == 1:
            return remove_query_param(url, 'page')
        return replace_query_param(url, 'page', page_number)

 def get_all_links(self):
     paginator = self.page.paginator
     links = []
     base_url = self.request.build_absolute_uri()
     for page_number in paginator.page_range:
         s_link = ""
         if page_number == 1:
             s_link = remove_query_param(
                 base_url,
                 self.page_query_param
             )
         else:
             s_link = replace_query_param(
                 base_url,
                 self.page_query_param,
                 page_number
             )
         links.append({
             'page': page_number,
             'url': s_link
         })
     return links

 def page_number_to_url(page_number):
     if page_number == 1:
         return remove_query_param(base_url, self.offset_query_param)
     else:
         offset = self.offset + ((page_number - current) * self.limit)
         return replace_query_param(base_url, self.offset_query_param, offset)

 def get_first_link(self):
     if self.count == 0:
         return None
     
     url = self.request.build_absolute_uri()
     return remove_query_param(url, self.offset_query_param)

 def get_first_link(self):
     if not self.page.has_previous():
         return None
     url = self.request.build_absolute_uri()
     return remove_query_param(url, self.page_query_param)

 def get_first_link(self):
     url = self.request.build_absolute_uri()
     return remove_query_param(url, self.page_query_param)

    def test_invalid_unicode(self):
        q = '/?from=login&page=2&%FF%FE%3C%73%63%72%69%70%74%3E%61%6C%65%72%74%28%33%31%33%29%3C%2F%73%63%72%69%70%74%3E=1'
        key = 'from'
        removed_key = 'page'

        assert key in remove_query_param(q, removed_key)