text: """
  unit tests for restframework_gis
  """
  
  import json
  import pickle
  import sys
  from unittest import skipIf
  
  import django
  from django.contrib.gis.geos import GEOSGeometry, Point
  from django.test import TestCase
  
  try:
      from django.urls import reverse
  except ImportError:
      from django.core.urlresolvers import reverse
  
  import rest_framework
  from django.core.exceptions import ImproperlyConfigured
  
  from rest_framework_gis import serializers as gis_serializers
  from rest_framework_gis.fields import GeoJsonDict
  
  from .models import LocatedFile, Location, Nullable
  from .serializers import LocationGeoSerializer
  
  is_pre_drf_39 = not rest_framework.VERSION.startswith('3.9')
  
  
  class TestRestFrameworkGis(TestCase):
      def setUp(self):
          self.location_list_url = reverse('api_location_list')
          self.geojson_location_list_url = reverse('api_geojson_location_list')
          self.geos_error_message = (
              'Invalid format: string or unicode input unrecognized as GeoJSON,'
              ' WKT EWKT or HEXEWKB.'
          )
          self.gdal_error_message = (
              'Unable to convert to python object:'
              ' Invalid geometry pointer returned from "OGR_G_CreateGeometryFromJson".'
          )
          if django.VERSION >= (2, 0, 0):
              self.value_error_message = (
                  "Unable to convert to python object:"
                  " String input unrecognized as WKT EWKT, and HEXEWKB."
              )
          else:
              self.value_error_message = (
                  "Unable to convert to python object:"
                  " String or unicode input unrecognized as WKT EWKT, and HEXEWKB."
              )
          self.type_error_message = (
              "Unable to convert to python object: Improper geometry input type:"
          )
  
      def _create_locations(self):
          self.l1 = Location.objects.create(
              id=1,
              name='l1',
              slug='l1',
              geometry='POINT (13.0078125000020002 42.4234565179379999)',
          )
          self.l2 = Location.objects.create(
              id=2,
              name='l2',
              slug='l2',
              geometry='POINT (12.0078125000020002 43.4234565179379999)',
          )
  
      def test_get_location_list(self):
          response = self.client.get(self.location_list_url)
          self.assertEqual(response.status_code, 200)
  
      def test_post_location_list_geojson(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "name": "geojson input test",
              "geometry": {
                  "type": "GeometryCollection",
                  "geometries": [
                      {"type": "Point", "coordinates": [12.492324113849, 41.890307434153]}
                  ],
              },
          }
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          data = {
              "name": "geojson input test2",
              "geometry": {
                  "type": "Point",
                  "coordinates": [12.492324113849, 41.890307434153],
              },
          }
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 2)
  
      def test_post_location_list_geojson_as_multipartformdata(self):
          """ emulate sending geojson string in webform """
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "name": "geojson input test",
              "geometry": json.dumps(
                  {
                      "type": "GeometryCollection",
                      "geometries": [
                          {
                              "type": "Point",
                              "coordinates": [12.492324113849, 41.890307434153],
                          }
                      ],
                  }
              ),
          }
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
  
      def test_post_HTML_browsable_api(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "name": "geojson input test2",
              "slug": "prova",
              "geometry": json.dumps(
                  {
                      "type": "GeometryCollection",
                      "geometries": [
                          {
                              "type": "Point",
                              "coordinates": [12.492324113849, 41.890307434153],
                          }
                      ],
                  }
              ),
          }
          response = self.client.post(
              self.location_list_url, data, HTTP_ACCEPT='text/html'
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          location = Location.objects.all()[0]
          self.assertEqual(location.name, 'geojson input test2')
          self.assertEqual(location.slug, 'prova')
  
      def test_post_location_list_WKT(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              'name': 'WKT input test',
              'geometry': 'POINT (12.492324113849 41.890307434153)',
          }
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
  
      def test_post_location_list_EWKT(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              'name': 'EWKT input test',
              'geometry': 'SRID=28992;POINT(221160 600204)',
          }
          response = self.client.post(self.location_list_url, data)
          expected_coords = (6.381495826183805, 53.384066927384985)
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          for lat, lon in zip(
              Location.objects.get(name='EWKT input test').geometry.coords,
              expected_coords,
          ):
              self.assertAlmostEqual(lat, lon, places=5)
  
      def test_post_location_list_WKT_as_json(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              'name': 'WKT input test',
              'geometry': 'POINT (12.492324113849 41.890307434153)',
          }
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
  
      def test_post_location_list_empty_geometry(self):
          data = {'name': 'empty input test'}
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.data['geometry'][0], 'This field is required.')
          data = {'name': 'empty input test', 'geometry': ''}
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.data['geometry'][0], 'This field is required.')
          data = {'name': 'empty input test'}
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0], 'This field is required.')
          data = {'name': 'empty input test', 'geometry': ''}
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0], 'This field is required.')
  
      def test_post_location_list_invalid_WKT(self):
          data = {'name': 'WKT wrong input test', 'geometry': 'I AM OBVIOUSLY WRONG'}
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 400)
          self.assertEqual(Location.objects.count(), 0)
          self.assertEqual(response.data['geometry'][0], self.value_error_message)
          # repeat as multipart form data
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.data['geometry'][0], self.value_error_message)
          data = {
              'name': 'I AM MODERATELY WRONG',
              'geometry': 'POINT (12.492324113849, 41.890307434153)',
          }
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0], self.geos_error_message)
          # repeat as multipart form data
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.data['geometry'][0], self.geos_error_message)
  
      def test_post_location_list_invalid_geojson(self):
          data = {
              "name": "quite wrong",
              "geometry": {
                  "type": "ARRRR",
                  "dasdas": [{"STtype": "PTUAMAoint", "NNAare": "rgon"}],
              },
          }
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0], self.gdal_error_message)
          data = {"name": "very wrong", "geometry": ['a', 'b', 'c']}
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0][0:65], self.type_error_message)
          data = {"name": "very wrong", "geometry": False}
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0][0:65], self.type_error_message)
          data = {"name": "very wrong", "geometry": {"value": {"nested": ["yo"]}}}
          response = self.client.post(
              self.location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.data['geometry'][0], self.gdal_error_message)
  
      def test_geojson_format(self):
          """ test geojson format """
          location = Location.objects.create(
              name='geojson test', geometry='POINT (135.0 45.0)'
          )
          url = reverse('api_geojson_location_details', args=[location.id])
          expected = {
              'id': location.id,
              'type': 'Feature',
              'properties': {
                  'details': "http://testserver/geojson/%s/" % location.id,
                  'name': 'geojson test',
                  'fancy_name': 'Kool geojson test',
                  'timestamp': None,
                  'slug': 'geojson-test',
              },
              'geometry': {'type': 'Point', 'coordinates': [135.0, 45.0]},
          }
          response = self.client.get(url)
          if sys.version_info > (3, 0, 0):
              self.assertCountEqual(json.dumps(response.data), json.dumps(expected))
          else:
              self.assertItemsEqual(json.dumps(response.data), json.dumps(expected))
          response = self.client.get(url, HTTP_ACCEPT='text/html')
          self.assertContains(response, "Kool geojson test")
  
      def test_geojson_id_attribute(self):
          location = Location.objects.create(
              name='geojson test', geometry='POINT (10.1 10.1)'
          )
          url = reverse('api_geojson_location_details', args=[location.id])
          response = self.client.get(url)
          self.assertEqual(response.data['id'], location.id)
  
      def test_geojson_id_attribute_slug(self):
          location = Location.objects.create(
              name='geojson test', geometry='POINT (10.1 10.1)'
          )
          url = reverse('api_geojson_location_slug_details', args=[location.slug])
          response = self.client.get(url)
          self.assertEqual(response.data['id'], location.slug)
  
      def test_geojson_false_id_attribute_slug(self):
          location = Location.objects.create(
              name='falseid test', geometry='POINT (10.1 10.1)'
          )
          url = reverse('api_geojson_location_falseid_details', args=[location.id])
          response = self.client.get(url)
          self.assertEqual(response.data['properties']['name'], 'falseid test')
          with self.assertRaises(KeyError):
              response.data['id']
  
      def test_geojson_no_id_attribute_slug(self):
          location = Location.objects.create(
              name='noid test', geometry='POINT (10.1 10.1)'
          )
          url = reverse('api_geojson_location_noid_details', args=[location.id])
          response = self.client.get(url)
          self.assertEqual(response.data['properties']['name'], 'noid test')
          with self.assertRaises(KeyError):
              response.data['id']
  
      def test_geojson_filefield_attribute(self):
          located_file = LocatedFile.objects.create(
              name='geojson filefield test', geometry='POINT (10.1 10.1)'
          )
          url = reverse('api_geojson_located_file_details', args=[located_file.id])
          response = self.client.get(url)
          self.assertEqual(response.data['properties']['file'], None)
  
      def test_post_geojson_location_list(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "type": "Feature",
              "properties": {"name": "point?", "details": "ignore this"},
              "geometry": {"type": "Point", "coordinates": [10.1, 10.1]},
          }
          response = self.client.post(
              self.geojson_location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          url = reverse(
              'api_geojson_location_details',
              args=[Location.objects.order_by('-id')[0].id],
          )
          response = self.client.get(url)
          self.assertEqual(response.data['properties']['name'], "point?")
          self.assertEqual(response.data['geometry']['type'], "Point")
          self.assertEqual(
              json.dumps(response.data['geometry']['coordinates']), "[10.1, 10.1]"
          )
          self.assertNotEqual(response.data['properties']['details'], "ignore this")
  
      def test_post_geojson_location_list_HTML(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "type": "Feature",
              "properties": {"name": "point?", "details": "ignore this"},
              "geometry": {"type": "Point", "coordinates": [10.1, 10.1]},
          }
          response = self.client.post(
              self.geojson_location_list_url,
              data=json.dumps(data),
              content_type='application/json',
              HTTP_ACCEPT='text/html',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          url = reverse(
              'api_geojson_location_details',
              args=[Location.objects.order_by('-id')[0].id],
          )
          response = self.client.get(url)
          self.assertEqual(response.data['properties']['name'], "point?")
          self.assertEqual(response.data['geometry']['type'], "Point")
          self.assertEqual(
              json.dumps(response.data['geometry']['coordinates']), "[10.1, 10.1]"
          )
          self.assertNotEqual(response.data['properties']['details'], "ignore this")
  
      def test_post_invalid_geojson_location_list(self):
          data = {
              "type": "Feature",
              "properties": {"details": "ignore this"},
              "geometry": {"type": "Point", "coordinates": [10.1, 10.1]},
          }
          response = self.client.post(
              self.geojson_location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 400)
          self.assertEqual(Location.objects.count(), 0)
          self.assertEqual(response.data['name'][0], "This field is required.")
          data = {
              "type": "Feature",
              "properties": {"name": "point?"},
              "geometry": {"type": "Point", "WRONG": {}},
          }
          response = self.client.post(
              self.geojson_location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 400)
          self.assertEqual(Location.objects.count(), 0)
          self.assertEqual(response.data['geometry'][0], self.gdal_error_message)
  
      def test_post_geojson_location_list_WKT(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "type": "Feature",
              "properties": {"name": "point?"},
              "geometry": "POINT (10.1 10.1)",
          }
          response = self.client.post(
              self.geojson_location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          url = reverse(
              'api_geojson_location_details',
              args=[Location.objects.order_by('-id')[0].id],
          )
          response = self.client.get(url)
          self.assertEqual(response.data['properties']['name'], "point?")
          self.assertEqual(response.data['geometry']['type'], "Point")
          self.assertEqual(
              json.dumps(response.data['geometry']['coordinates']), "[10.1, 10.1]"
          )
  
      def test_geofeatured_model_serializer_compatible_with_geomodel_serializer(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "name": "geojson input test",
              "geometry": {
                  "type": "GeometryCollection",
                  "geometries": [
                      {"type": "Point", "coordinates": [12.492324113849, 41.890307434153]}
                  ],
              },
          }
          response = self.client.post(
              self.geojson_location_list_url,
              data=json.dumps(data),
              content_type='application/json',
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
  
      def test_geofeatured_model_post_as_multipartformdata(self):
          """ emulate sending geojson string in webform """
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "name": "geojson input test",
              "geometry": json.dumps(
                  {"type": "Point", "coordinates": [12.492324113849, 41.890307434153]}
              ),
          }
          response = self.client.post(self.location_list_url, data)
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          self.assertEqual(response.data['geometry']['type'], "Point")
  
      def test_HTML_browsable_geojson_location_list(self):
          response = self.client.get(
              self.geojson_location_list_url, HTTP_ACCEPT='text/html'
          )
          self.assertEqual(response.status_code, 200)
          self._create_locations()
          response = self.client.get(
              self.geojson_location_list_url, HTTP_ACCEPT='text/html'
          )
          self.assertContains(response, 'l1')
          self.assertContains(response, 'l2')
  
      def test_post_geojson_location_list_HTML_web_form(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {
              "name": "HTML test",
              "geometry": json.dumps({"type": "Point", "coordinates": [10.1, 10.1]}),
          }
          response = self.client.post(
              self.geojson_location_list_url, data, HTTP_ACCEPT='text/html'
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          location = Location.objects.all()[0]
          self.assertEqual(location.name, "HTML test")
          self.assertEqual(location.geometry.geom_type, "Point")
  
      def test_post_geojson_location_list_HTML_web_form_WKT(self):
          self.assertEqual(Location.objects.count(), 0)
          data = {"name": "HTML test WKT", "geometry": "POINT (10.1 10.1)"}
          response = self.client.post(
              self.geojson_location_list_url, data, HTTP_ACCEPT='text/html'
          )
          self.assertEqual(response.status_code, 201)
          self.assertEqual(Location.objects.count(), 1)
          location = Location.objects.all()[0]
          self.assertEqual(location.name, "HTML test WKT")
  
      @skipIf(is_pre_drf_39, 'Skip this test if DRF < 3.9')
      def test_geojson_HTML_widget_value(self):
          self._create_locations()
          response = self.client.get(
              self.geojson_location_list_url, HTTP_ACCEPT='text/html'
          )
          self.assertContains(response, '<textarea name="geometry"')
          self.assertContains(response, '"type": "Point"')
          self.assertContains(response, '"coordinates": [')
  
      @skipIf(not is_pre_drf_39, 'Skip this test if DRF >= 3.9')
      def test_geojson_HTML_widget_value_pre_drf_39(self):
          self._create_locations()
          response = self.client.get(
              self.geojson_location_list_url, HTTP_ACCEPT='text/html'
          )
          self.assertContains(response, '<textarea name="geometry"')
          self.assertContains(response, '&quot;type&quot;: &quot;Point&quot;')
          self.assertContains(response, '&quot;coordinates&quot;: [')
          # TODO: remove this when python 2 will be deprecated
          self.assertNotContains(
              response, 'u&#39;type&#39;: u&#39;Point&#39;, u&#39;coordinates&#39;:'
          )
  
      def test_patch_geojson_location(self):
          location = Location.objects.create(
              name='geojson patch test', geometry='POINT (135.0 45.0)'
          )
          url = reverse('api_geojson_location_details', args=[location.id])
          data = {
              "properties": {"name": "geojson successful patch test"},
              "geometry": {"type": "Point", "coordinates": [10.1, 10.1]},
          }
          response = self.client.generic(
              'PATCH', url, json.dumps(data), content_type='application/json'
          )
          self.assertEqual(response.status_code, 200)
          location_reloaded = Location.objects.get(pk=location.id)
          self.assertEqual(location_reloaded.name, 'geojson successful patch test')
          self.assertEqual(
              location_reloaded.geometry, Point(10.1, 10.1, srid=location.geometry.srid)
          )
  
      def test_patch_geojson_location_wo_changing_geometry(self):
          location = Location.objects.create(
              name='geojson patch test', geometry='POINT (135.0 45.0)'
          )
          url = reverse('api_geojson_location_details', args=[location.id])
          data = {"properties": {"name": "geojson successful patch test"}}
          response = self.client.generic(
              'PATCH', url, json.dumps(data), content_type='application/json'
          )
          self.assertEqual(response.status_code, 200)
          location_reloaded = Location.objects.get(pk=location.id)
          self.assertEqual(location_reloaded.name, 'geojson successful patch test')
          self.assertEqual(
              location_reloaded.geometry, Point(135.0, 45.0, srid=location.geometry.srid)
          )
  
      def test_geometry_serializer_method_field(self):
          location = Location.objects.create(
              name='geometry serializer method test', geometry='POINT (135.0 45.0)'
          )
          location_loaded = Location.objects.get(pk=location.id)
          self.assertEqual(location_loaded.name, 'geometry serializer method test')
          self.assertEqual(
              location_loaded.geometry, Point(135.0, 45.0, srid=location.geometry.srid)
          )
          url = reverse('api_geojson_location_details_hidden', args=[location.id])
          data = {"properties": {"name": "hidden geometry"}}
          response = self.client.generic(
              'PATCH', url, json.dumps(data), content_type='application/json'
          )
          self.assertEqual(response.status_code, 200)
          self.assertEqual(response.data['properties']['name'], 'hidden geometry')
          self.assertEqual(response.data['geometry']['type'], 'Point')
          self.assertEqual(response.data['geometry']['coordinates'], [0.0, 0.0])
  
      def test_geometry_serializer_method_field_none(self):
          location = Location.objects.create(
              name='None value', geometry='POINT (135.0 45.0)'
          )
          location_loaded = Location.objects.get(pk=location.id)
          self.assertEqual(
              location_loaded.geometry, Point(135.0, 45.0, srid=location.geometry.srid)
          )
          url = reverse('api_geojson_location_details_none', args=[location.id])
          response = self.client.generic('GET', url, content_type='application/json')
          self.assertEqual(response.status_code, 200)
          self.assertEqual(response.data['properties']['name'], 'None value')
          self.assertEqual(response.data['geometry'], None)
  
      def test_nullable_empty_geometry(self):
          empty = Nullable(name='empty', geometry='POINT EMPTY')
          empty.full_clean()
          empty.save()
          url = reverse('api_geojson_nullable_details', args=[empty.id])
          response = self.client.generic('GET', url, content_type='application/json')
          self.assertIsNotNone(response.data['geometry'])
          self.assertEqual(response.data['geometry']['coordinates'], [])
  
      def test_nullable_null_geometry(self):
          empty = Nullable(name='empty', geometry=None)
          empty.full_clean()
          empty.save()
          url = reverse('api_geojson_nullable_details', args=[empty.id])
          response = self.client.generic('GET', url, content_type='application/json')
          self.assertIsNone(response.data['geometry'])
  
      def test_geometry_field_to_representation_none(self):
          self._create_locations()
          f = LocationGeoSerializer(instance=self.l1).fields['geometry']
          self.assertIsNone(f.to_representation(None))
  
      def test_geometry_empty_representation(self):
          self._create_locations()
          f = LocationGeoSerializer(instance=self.l1).fields['geometry']
          geom_types = (
              'POINT',
              'LINESTRING',
              'LINEARRING',
              'POLYGON',
              'MULTIPOINT',
              'MULTILINESTRING',
              'MULTIPOLYGON',
          )
          for geom_type in geom_types:
              with self.subTest(geom_type=geom_type):
                  value = f.to_representation(GEOSGeometry('{} EMPTY'.format(geom_type)))
                  self.assertIsNotNone(value)
                  if geom_type == 'LINEARRING':
                      geom_type = 'LINESTRING'
                  self.assertEqual(value['type'].upper(), geom_type)
                  self.assertEqual(value['coordinates'], [])
          # GEOMETRYCOLLECTION needs different handling
          value = f.to_representation(GEOSGeometry('GEOMETRYCOLLECTION EMPTY'))
          self.assertIsNotNone(value)
          self.assertEqual(value['type'].upper(), 'GEOMETRYCOLLECTION')
          self.assertEqual(value['geometries'], [])
  
      def test_no_geo_field_improperly_configured(self):
          class LocationGeoFeatureSerializer(gis_serializers.GeoFeatureModelSerializer):
              class Meta:
                  model = Location
  
          with self.assertRaises(ImproperlyConfigured):
              LocationGeoFeatureSerializer()
  
      def test_exclude_geo_field_improperly_configured(self):
          self._create_locations()
  
          class LocationGeoFeatureSerializer(gis_serializers.GeoFeatureModelSerializer):
              class Meta:
                  model = Location
                  geo_field = 'geometry'
                  exclude = ('geometry',)
  
          with self.assertRaises(ImproperlyConfigured):
              LocationGeoFeatureSerializer(instance=self.l1)
  
      def test_geojson_pagination(self):
          self._create_locations()
          response = self.client.get(self.geojson_location_list_url)
          self.assertEqual(response.data['type'], 'FeatureCollection')
          self.assertEqual(len(response.data['features']), 2)
          response = self.client.get(
              '{0}?page_size=1'.format(self.geojson_location_list_url)
          )
          self.assertEqual(response.data['type'], 'FeatureCollection')
          self.assertEqual(len(response.data['features']), 1)
          self.assertIn('next', response.data)
          self.assertIn('previous', response.data)
  
      def test_pickle(self):
          geometry = GEOSGeometry('POINT (30 10)')
          geojsondict = GeoJsonDict(
              (('type', geometry.geom_type), ('coordinates', geometry.coords),)
          )
          pickled = pickle.dumps(geojsondict)
          restored = pickle.loads(pickled)
          self.assertEqual(restored, geojsondict)
  
      def test_geometrycollection_geojson(self):
          """ test geometry collection geojson behaviour """
          location = Location.objects.create(
              name='geometry collection geojson test',
              geometry='GEOMETRYCOLLECTION ('
              'POINT (135.0 45.0),'
              'LINESTRING (135.0 45.0,140.0 50.0,145.0 55.0),'
              'POLYGON ((135.0 45.0,140.0 50.0,145.0 55.0,135.0 45.0)))',
          )
          url = reverse('api_geojson_location_details', args=[location.id])
          expected = {
              'id': location.id,
              'type': 'Feature',
              'properties': {
                  'details': "http://testserver/geojson/%s/" % location.id,
                  'name': 'geometry collection geojson test',
                  'fancy_name': 'Kool geometry collection geojson test',
                  'timestamp': None,
                  'slug': 'geometry-collection-geojson-test',
              },
              'geometry': {
                  'type': 'GeometryCollection',
                  'geometries': [
                      {'type': 'Point', 'coordinates': [135.0, 45.0]},
                      {
                          'type': 'LineString',
                          'coordinates': [[135.0, 45.0], [140.0, 50.0], [145.0, 55.0]],
                      },
                      {
                          'type': 'Polygon',
                          'coordinates': [
                              [
                                  [135.0, 45.0],
                                  [140.0, 50.0],
                                  [145.0, 55.0],
                                  [135.0, 45.0],
                              ]
                          ],
                      },
                  ],
              },
          }
          response = self.client.get(url)
          if sys.version_info > (3, 0, 0):
              self.assertCountEqual(json.dumps(response.data), json.dumps(expected))
          else:
              self.assertItemsEqual(json.dumps(response.data), json.dumps(expected))
          self.assertContains(response, "Kool geometry collection geojson test")
  