Add files using upload-large-folder tool

testbed/django__django/tests/get_object_or_404/models.py

@@ -0,0 +1,35 @@
+"""
+DB-API Shortcuts
+
+``get_object_or_404()`` is a shortcut function to be used in view functions for
+performing a ``get()`` lookup and raising a ``Http404`` exception if a
+``DoesNotExist`` exception was raised during the ``get()`` call.
+
+``get_list_or_404()`` is a shortcut function to be used in view functions for
+performing a ``filter()`` lookup and raising a ``Http404`` exception if a
+``DoesNotExist`` exception was raised during the ``filter()`` call.
+"""
+
+from django.db import models
+
+
+class Author(models.Model):
+    name = models.CharField(max_length=50)
+
+
+class ArticleManager(models.Manager):
+    def get_queryset(self):
+        return super().get_queryset().filter(authors__name__icontains="sir")
+
+
+class AttributeErrorManager(models.Manager):
+    def get_queryset(self):
+        raise AttributeError("AttributeErrorManager")
+
+
+class Article(models.Model):
+    authors = models.ManyToManyField(Author)
+    title = models.CharField(max_length=50)
+    objects = models.Manager()
+    by_a_sir = ArticleManager()
+    attribute_error_objects = AttributeErrorManager()

testbed/django__django/tests/gis_tests/data/cities/cities.prj

@@ -0,0 +1 @@
+GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]

testbed/django__django/tests/gis_tests/data/gas_lines/gas_leitung.prj

@@ -0,0 +1 @@
+PROJCS["MGI_Ferro_Austria_GK_East",GEOGCS["GCS_MGI_Ferro",DATUM["D_MGI",SPHEROID["Bessel_1841",6377397.155,299.1528128]],PRIMEM["Ferro",-17.66666666666667],UNIT["Degree",0.0174532925199433]],PROJECTION["Transverse_Mercator"],PARAMETER["False_Easting",0.0],PARAMETER["False_Northing",-5000000.0],PARAMETER["Central_Meridian",34.0],PARAMETER["Scale_Factor",1.0],PARAMETER["Latitude_Of_Origin",0.0],UNIT["Meter",1.0]]

testbed/django__django/tests/gis_tests/data/geometries.json

@@ -0,0 +1,141 @@
+{
+  "polygons": [
+    {"wkt": "POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0), (10 10, 10 90, 90 90, 90 10, 10 10))", "n_i": 1, "ext_ring_cs": [[0, 0], [0, 100], [100, 100], [100, 0], [0, 0]], "n_p": 10, "area": 3600.0, "centroid": [50.0, 50.0]},
+    {"wkt": "POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0), (10 10, 10 20, 20 20, 20 10, 10 10), (80 80, 80 90, 90 90, 90 80, 80 80))", "n_i": 2, "ext_ring_cs": [[0, 0], [0, 100], [100, 100], [100, 0], [0, 0]], "n_p": 15, "area": 9800.0, "centroid": [50.0, 50.0]},
+    {"wkt": "POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))", "n_i": 0, "ext_ring_cs": [[0, 0], [0, 100], [100, 100], [100, 0], [0, 0]], "n_p": 5, "area": 10000.0, "centroid": [50.0, 50.0]},
+    {"wkt": "POLYGON ((-95.3848703124799471 29.7056021479768511, -95.3851905195191847 29.7046588196500281, -95.3859356966379011 29.7025053545605502, -95.3860723000647539 29.7020963367038391, -95.3871517697222089 29.6989779021280995, -95.3865578518265522 29.6990856888057202, -95.3862634205175226 29.6999471753441782, -95.3861991779541967 29.6999591988978615, -95.3856773799358137 29.6998323107113578, -95.3856209915427229 29.6998005235473741, -95.3855833545501639 29.6996619391729801, -95.3855776331865002 29.6996232659570047, -95.3850162731712885 29.6997236706530536, -95.3831047357410284 29.7000847603095082, -95.3829800724914776 29.7000676365023502, -95.3828084594470909 29.6999969684031200, -95.3828131504821499 29.6999090511531065, -95.3828022942979601 29.6998152117366025, -95.3827893930918833 29.6997790953076759, -95.3825174668099862 29.6998267772748825, -95.3823521544804862 29.7000451723151606, -95.3820491918785223 29.6999682034582335, -95.3817932841505893 29.6999640407204772, -95.3815438924600443 29.7005983712500630, -95.3807812390843424 29.7007538492921590, -95.3778578936435935 29.7012966201172048, -95.3770817300034679 29.7010555145969093, -95.3772763716395957 29.7004995005932031, -95.3769891024414420 29.7005797730360186, -95.3759855007185990 29.7007754783987821, -95.3759516423090474 29.7007305400669388, -95.3765252155960042 29.6989549173240874, -95.3766842746727832 29.6985134987163164, -95.3768510987262914 29.6980530300744938, -95.3769198676258014 29.6977137204527573, -95.3769616670751930 29.6973351617272172, -95.3770309229297766 29.6969821084304186, -95.3772352596880637 29.6959751305871613, -95.3776232419333354 29.6945439060847463, -95.3776849628727064 29.6943364710766069, -95.3779699491714723 29.6926548349458947, -95.3781945479573494 29.6920088336742545, -95.3785807118394189 29.6908279316076005, -95.3787441368896651 29.6908846275832197, -95.3787903214163890 29.6907152912461640, -95.3791765069353659 29.6893335376821526, -95.3794935959513026 29.6884781789101595, -95.3796592071232112 29.6880066681407619, -95.3799788182090111 29.6873687353035081, -95.3801545516183893 29.6868782380716993, -95.3801258908302145 29.6867756621337762, -95.3801104284899566 29.6867229678809572, -95.3803803523746154 29.6863753372986459, -95.3821028558287622 29.6837392961470421, -95.3827289584682205 29.6828097375216160, -95.3827494698109035 29.6790739156259278, -95.3826022014838486 29.6776502228345507, -95.3825047356438063 29.6765773006280753, -95.3823473035336917 29.6750405250369127, -95.3824540163482055 29.6750076408228587, -95.3838984230304305 29.6745679207378679, -95.3916547074937426 29.6722459226508377, -95.3926154662749468 29.6719609085105489, -95.3967246645118081 29.6707316485589736, -95.3974588054406780 29.6705065336410989, -95.3978523748756828 29.6703795547846845, -95.3988598162279970 29.6700874981900853, -95.3995628600665952 29.6698505300412414, -95.4134721665944170 29.6656841279906232, -95.4143262068232616 29.6654291174019278, -95.4159685142480214 29.6649750989232288, -95.4180067396277565 29.6643253024318021, -95.4185886692196590 29.6641482768691063, -95.4234155309609662 29.6626925393704788, -95.4287785503196346 29.6611023620959706, -95.4310287312749352 29.6604222580752648, -95.4320295629628959 29.6603361318136720, -95.4332899683975739 29.6600560661713608, -95.4342675748811047 29.6598454934599900, -95.4343110414310871 29.6598411486215490, -95.4345576779282538 29.6598147020668499, -95.4348823041721630 29.6597875803673112, -95.4352827715209457 29.6597762346946681, -95.4355290431309982 29.6597827926562374, -95.4359197997999331 29.6598014511782715, -95.4361907884752156 29.6598444333523368, -95.4364608955807228 29.6598901433108217, -95.4367250147512323 29.6599494499910712, -95.4364898759758091 29.6601880616540186, -95.4354501111810691 29.6616378572201107, -95.4381459623171224 29.6631265631655126, -95.4367852490863129 29.6642266600024023, -95.4370040894557263 29.6643425389568769, -95.4367078350812648 29.6645492592343238, -95.4366081749871285 29.6646291473027297, -95.4358539359938192 29.6652308742342932, -95.4350327668927889 29.6658995989314462, -95.4350580905272921 29.6678812477895271, -95.4349710541447536 29.6680054925936965, -95.4349500440473548 29.6671410080890006, -95.4341492724148850 29.6678790545191688, -95.4340248868274728 29.6680353198492135, -95.4333227845797438 29.6689245624945990, -95.4331325652123326 29.6691616138940901, -95.4321314741096955 29.6704473333237253, -95.4320435792664341 29.6702578985411982, -95.4320147929883547 29.6701800936425109, -95.4319764538662980 29.6683246590817085, -95.4317490976340679 29.6684974372577166, -95.4305958185342718 29.6694049049170374, -95.4296600735653016 29.6701723430938493, -95.4284928989940937 29.6710931793380972, -95.4274630532378580 29.6719378813640091, -95.4273056811974811 29.6720684984625791, -95.4260554084574864 29.6730668861566969, -95.4253558063699643 29.6736342467365724, -95.4249278826026028 29.6739557343648919, -95.4248648873821423 29.6745400910786152, -95.4260016131471929 29.6750987014005858, -95.4258567183010911 29.6753452063069929, -95.4260238081486847 29.6754322077221353, -95.4258707374502393 29.6756647377294307, -95.4257951755816691 29.6756407098663360, -95.4257701599566985 29.6761077719536068, -95.4257726684792260 29.6761711204603955, -95.4257980187195614 29.6770219651929423, -95.4252712669032519 29.6770161558853758, -95.4249234392992065 29.6770068683962300, -95.4249574272905789 29.6779707498635759, -95.4244725881033702 29.6779825646764159, -95.4222269476429545 29.6780711474441716, -95.4223032371999267 29.6796029391538809, -95.4239133706588945 29.6795331493690355, -95.4224579084327331 29.6813706893847780, -95.4224290108823965 29.6821953228763924, -95.4230916478977349 29.6822130268724109, -95.4222928279595521 29.6832041816675343, -95.4228763710016352 29.6832087677714505, -95.4223401691637179 29.6838987872753748, -95.4211655906087088 29.6838784024852984, -95.4201984153205558 29.6851319258758082, -95.4206156387716362 29.6851623398125319, -95.4213438084897660 29.6851763011334739, -95.4212071118618752 29.6853679931624974, -95.4202651399651245 29.6865313962980508, -95.4172061157659783 29.6865816431043932, -95.4182217951255183 29.6872251197301544, -95.4178664826439160 29.6876750901471631, -95.4180678442928780 29.6877960336377207, -95.4188763472917572 29.6882826379510938, -95.4185374500596311 29.6887137897831934, -95.4182121713132290 29.6885097429738813, -95.4179857231741551 29.6888118367840086, -95.4183106010563620 29.6890048676118212, -95.4179489865331334 29.6894546700979056, -95.4175581746284820 29.6892323606815438, -95.4173439957341571 29.6894990139807007, -95.4177411199311081 29.6897435034738422, -95.4175789200209721 29.6899207529979208, -95.4170598559864800 29.6896042165807508, -95.4166733682539814 29.6900891174451367, -95.4165941362704331 29.6900347214235047, -95.4163537218065301 29.6903529467753238, -95.4126843270708775 29.6881086357212780, -95.4126604121378392 29.6880942378803496, -95.4126672298953338 29.6885951670109982, -95.4126680884821923 29.6887052446594275, -95.4158080137241882 29.6906382377959339, -95.4152061403821961 29.6910871045531586, -95.4155842583188161 29.6917382915894308, -95.4157426793520358 29.6920726941677096, -95.4154520563662203 29.6922052332446427, -95.4151389936167078 29.6923261661269571, -95.4148649784384872 29.6924343866430256, -95.4144051352401590 29.6925623927348106, -95.4146792019416665 29.6926770338507744, -95.4148824479948985 29.6928117893696388, -95.4149851734360226 29.6929823719519774, -95.4140436551925291 29.6929626643100946, -95.4140465993023241 29.6926545917254892, -95.4137269186733334 29.6927395764256090, -95.4137372859685513 29.6935432485666624, -95.4135702836218655 29.6933186678088283, -95.4133925235973237 29.6930415229852152, -95.4133017035615580 29.6928685062036166, -95.4129588921634593 29.6929391128977862, -95.4125107395559695 29.6930481664661485, -95.4102647423187307 29.6935850183258019, -95.4081931340840157 29.6940907430947760, -95.4078783596459772 29.6941703429951609, -95.4049213975000043 29.6948723732981961, -95.4045944244127071 29.6949626434239207, -95.4045865139788134 29.6954109019001358, -95.4045953345484037 29.6956972800496963, -95.4038879332535146 29.6958296089365490, -95.4040366394459340 29.6964389004769842, -95.4032774779020798 29.6965643341263892, -95.4026066501239853 29.6966646227683881, -95.4024991226393837 29.6961389766619703, -95.4011781398631911 29.6963566063186377, -95.4011524097636112 29.6962596176762190, -95.4018184046368276 29.6961399466727336, -95.4016995838361908 29.6956442609415099, -95.4007100753964608 29.6958900524002978, -95.4008032469935188 29.6962639900781404, -95.3995660267125487 29.6965636449370329, -95.3996140564775601 29.6967877962763644, -95.3996364430014410 29.6968901984825280, -95.3984003269631842 29.6968679634805746, -95.3981442026887265 29.6983660679730335, -95.3980178461957706 29.6990890276252415, -95.3977097967130163 29.7008526152273049, -95.3962347157626027 29.7009697553607630, -95.3951949050136250 29.7004740386619019, -95.3957564950617183 29.6990281830553187, -95.3965927101519924 29.6968771129030706, -95.3957496517238184 29.6970800358387095, -95.3957720559467361 29.6972264611230727, -95.3957391586571788 29.6973548894558732, -95.3956286413405365 29.6974949857280883, -95.3955111053256957 29.6975661086270186, -95.3953215342724121 29.6976022763384790, -95.3951795558443365 29.6975846977491038, -95.3950369632041060 29.6975175779330200, -95.3949401089966500 29.6974269267953304, -95.3948740281415581 29.6972903308506346, -95.3946650813866910 29.6973397326847923, -95.3947654059391112 29.6974882560192022, -95.3949627316619768 29.6980355864961858, -95.3933200807862249 29.6984590863712796, -95.3932606497523494 29.6984464798710839, -95.3932983699113350 29.6983154306484352, -95.3933058014696655 29.6982165816983610, -95.3932946347785133 29.6981089778195759, -95.3931780601756287 29.6977068906794841, -95.3929928222970602 29.6977541771878180, -95.3930873169846478 29.6980676264932946, -95.3932743746374570 29.6981249406449663, -95.3929512584706316 29.6989526513922222, -95.3919850280655197 29.7014358632108646, -95.3918950918929056 29.7014169320765724, -95.3916928317890296 29.7019232352846423, -95.3915424614970959 29.7022988712928289, -95.3901530441668939 29.7058519502930061, -95.3899656322116698 29.7059156823562418, -95.3897628748670883 29.7059900058266777, -95.3896062677805787 29.7060738276384946, -95.3893941800512266 29.7061891695242046, -95.3892150365492455 29.7062641292949436, -95.3890502563035199 29.7063339729630940, -95.3888717930715586 29.7063896908080736, -95.3886925428988945 29.7064453871994978, -95.3885376849411983 29.7064797304524149, -95.3883284158984139 29.7065153575050189, -95.3881046767627794 29.7065368368267357, -95.3878809284696132 29.7065363048447537, -95.3876046356120924 29.7065288525102424, -95.3873060894974714 29.7064822806001452, -95.3869851943158409 29.7063993367575350, -95.3865967896568065 29.7062870572919202, -95.3861785624983156 29.7061492099008184, -95.3857375009733488 29.7059887337478798, -95.3854573290902152 29.7058683664514618, -95.3848703124799471 29.7056021479768511))", "n_i": 0, "ext_ring_cs": false, "n_p": 264, "area": 0.00129917360654, "centroid": [-95.403569179437341, 29.681772571690402]}
+  ],
+  "multipolygons": [
+    {"wkt": "MULTIPOLYGON (((100 20, 180 20, 180 100, 100 100, 100 20)), ((20 100, 100 100, 100 180, 20 180, 20 100)), ((100 180, 180 180, 180 260, 100 260, 100 180)), ((180 100, 260 100, 260 180, 180 180, 180 100)))","valid": true, "num_geom":4, "n_p":20},
+    {"wkt": "MULTIPOLYGON (((60 300, 320 220, 260 60, 60 100, 60 300)), ((60 300, 320 220, 260 60, 60 100, 60 300)))", "valid": false},
+    {"wkt": "MULTIPOLYGON (((180 60, 240 160, 300 60, 180 60)), ((80 80, 180 60, 160 140, 240 160, 360 140, 300 60, 420 100, 320 280, 120 260, 80 80)))", "valid": true, "num_geom": 2, "n_p": 14}
+  ],
+  "errors": [
+    {"wkt": "GEOMETR##!@#%#............a32515", "bad": true, "hex": false},
+    {"wkt": "Foo.Bar", "bad": true, "hex": false},
+    {"wkt": "POINT (5, 23)", "bad": true, "hex": false},
+    {"wkt": "AAABBBDDDAAD##@#1113511111-098111111111111111533333333333333", "bad": true, "hex": true},
+    {"wkt": "FFFFFFFFFFFFFFFFF1355555555555555555565111", "bad": true, "hex": true},
+    {"wkt": "", "bad": true, "hex": false}
+  ],
+  "wkt_out": [
+    {"wkt": "POINT (110 130)", "ewkt": "POINT (110 130)", "kml": "<Point><coordinates>110.0,130.0,0</coordinates></Point>", "gml": "<gml:Point><gml:coordinates>110,130</gml:coordinates></gml:Point>"},
+    {"wkt": "POINT (110 130 85)", "ewkt": "POINT Z (110 130 85)", "kml": "<Point><coordinates>110.0,130.0,85.0</coordinates></Point>", "gml": "<gml:Point><gml:coordinates>110,130,85</gml:coordinates></gml:Point>"},
+    {"wkt": "LINESTRING (40 40,50 130,130 130)", "ewkt": "LINESTRING (40 40, 50 130, 130 130)", "kml": "<LineString><coordinates>40.0,40.0,0 50.0,130.0,0 130.0,130.0,0</coordinates></LineString>", "gml": "<gml:LineString><gml:coordinates>40,40 50,130 130,130</gml:coordinates></gml:LineString>"},
+    {"wkt": "POLYGON ((150 150,410 150,280 20,20 20,150 150),(170 120,330 120,260 50,100 50,170 120))", "ewkt": "POLYGON ((150 150, 410 150, 280 20, 20 20, 150 150), (170 120, 330 120, 260 50, 100 50, 170 120))", "kml": "<Polygon><outerBoundaryIs><LinearRing><coordinates>150.0,150.0,0 410.0,150.0,0 280.0,20.0,0 20.0,20.0,0 150.0,150.0,0</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>170.0,120.0,0 330.0,120.0,0 260.0,50.0,0 100.0,50.0,0 170.0,120.0,0</coordinates></LinearRing></innerBoundaryIs></Polygon>", "gml": "<gml:Polygon><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>150,150 410,150 280,20 20,20 150,150</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs><gml:innerBoundaryIs><gml:LinearRing><gml:coordinates>170,120 330,120 260,50 100,50 170,120</gml:coordinates></gml:LinearRing></gml:innerBoundaryIs></gml:Polygon>"},
+    {"wkt": "MULTIPOINT (10 80,110 170,110 120)", "ewkt": "MULTIPOINT (10 80, 110 170, 110 120)", "kml": "<MultiGeometry><Point><coordinates>10.0,80.0,0</coordinates></Point><Point><coordinates>110.0,170.0,0</coordinates></Point><Point><coordinates>110.0,120.0,0</coordinates></Point></MultiGeometry>", "gml": "<gml:MultiPoint><gml:pointMember><gml:Point><gml:coordinates>10,80</gml:coordinates></gml:Point></gml:pointMember><gml:pointMember><gml:Point><gml:coordinates>110,170</gml:coordinates></gml:Point></gml:pointMember><gml:pointMember><gml:Point><gml:coordinates>110,120</gml:coordinates></gml:Point></gml:pointMember></gml:MultiPoint>"},
+    {"wkt": "MULTILINESTRING ((110 100,40 30,180 30),(170 30,110 90,50 30))", "ewkt": "MULTILINESTRING ((110 100, 40 30, 180 30), (170 30, 110 90, 50 30))", "kml": "<MultiGeometry><LineString><coordinates>110.0,100.0,0 40.0,30.0,0 180.0,30.0,0</coordinates></LineString><LineString><coordinates>170.0,30.0,0 110.0,90.0,0 50.0,30.0,0</coordinates></LineString></MultiGeometry>", "gml": "<gml:MultiLineString><gml:lineStringMember><gml:LineString><gml:coordinates>110,100 40,30 180,30</gml:coordinates></gml:LineString></gml:lineStringMember><gml:lineStringMember><gml:LineString><gml:coordinates>170,30 110,90 50,30</gml:coordinates></gml:LineString></gml:lineStringMember></gml:MultiLineString>"},
+    {"wkt": "MULTIPOLYGON (((110 110,70 200,150 200,110 110),(110 110,100 180,120 180,110 110)),((110 110,150 20,70 20,110 110),(110 110,120 40,100 40,110 110)))", "ewkt": "MULTIPOLYGON (((110 110, 70 200, 150 200, 110 110), (110 110, 100 180, 120 180, 110 110)), ((110 110, 150 20, 70 20, 110 110), (110 110, 120 40, 100 40, 110 110)))", "kml": "<MultiGeometry><Polygon><outerBoundaryIs><LinearRing><coordinates>110.0,110.0,0 70.0,200.0,0 150.0,200.0,0 110.0,110.0,0</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>110.0,110.0,0 100.0,180.0,0 120.0,180.0,0 110.0,110.0,0</coordinates></LinearRing></innerBoundaryIs></Polygon><Polygon><outerBoundaryIs><LinearRing><coordinates>110.0,110.0,0 150.0,20.0,0 70.0,20.0,0 110.0,110.0,0</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>110.0,110.0,0 120.0,40.0,0 100.0,40.0,0 110.0,110.0,0</coordinates></LinearRing></innerBoundaryIs></Polygon></MultiGeometry>", "gml": "<gml:MultiPolygon><gml:polygonMember><gml:Polygon><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>110,110 70,200 150,200 110,110</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs><gml:innerBoundaryIs><gml:LinearRing><gml:coordinates>110,110 100,180 120,180 110,110</gml:coordinates></gml:LinearRing></gml:innerBoundaryIs></gml:Polygon></gml:polygonMember><gml:polygonMember><gml:Polygon><gml:outerBoundaryIs><gml:LinearRing><gml:coordinates>110,110 150,20 70,20 110,110</gml:coordinates></gml:LinearRing></gml:outerBoundaryIs><gml:innerBoundaryIs><gml:LinearRing><gml:coordinates>110,110 120,40 100,40 110,110</gml:coordinates></gml:LinearRing></gml:innerBoundaryIs></gml:Polygon></gml:polygonMember></gml:MultiPolygon>"},
+    {"wkt": "GEOMETRYCOLLECTION (POINT (110 260),LINESTRING (110 0,110 60))", "ewkt": "GEOMETRYCOLLECTION (POINT (110 260), LINESTRING (110 0, 110 60))", "kml": "<MultiGeometry><Point><coordinates>110.0,260.0,0</coordinates></Point><LineString><coordinates>110.0,0.0,0 110.0,60.0,0</coordinates></LineString></MultiGeometry>", "gml": "<gml:MultiGeometry><gml:geometryMember><gml:Point><gml:coordinates>110,260</gml:coordinates></gml:Point></gml:geometryMember><gml:geometryMember><gml:LineString><gml:coordinates>110,0 110,60</gml:coordinates></gml:LineString></gml:geometryMember></gml:MultiGeometry>"}
+  ],
+  "hex_wkt": [
+    {"wkt": "POINT(0 1)", "hex": "01010000000000000000000000000000000000F03F"},
+    {"wkt": "POINT(0 1 5)", "hex": "01010000800000000000000000000000000000F03F0000000000001440"},
+    {"wkt": "LINESTRING(0 1, 2 3, 4 5)", "hex": "0102000000030000000000000000000000000000000000F03F0000000000000040000000000000084000000000000010400000000000001440"},
+    {"wkt": "POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))", "hex": "010300000001000000050000000000000000000000000000000000000000000000000024400000000000000000000000000000244000000000000024400000000000000000000000000000244000000000000000000000000000000000"},
+    {"wkt": "MULTIPOINT(0 0, 10 0, 10 10, 0 10, 0 0)", "hex": "010400000005000000010100000000000000000000000000000000000000010100000000000000000024400000000000000000010100000000000000000024400000000000002440010100000000000000000000000000000000002440010100000000000000000000000000000000000000"},
+    {"wkt": "MULTILINESTRING((0 0, 10 0, 10 10, 0 10),(20 20, 30 20))", "hex": "01050000000200000001020000000400000000000000000000000000000000000000000000000000244000000000000000000000000000002440000000000000244000000000000000000000000000002440010200000002000000000000000000344000000000000034400000000000003E400000000000003440"},
+    {"wkt": "MULTIPOLYGON(((0 0, 10 0, 10 10, 0 10, 0 0)),((20 20, 20 30, 30 30, 30 20, 20 20),(25 25, 25 26, 26 26, 26 25, 25 25)))", "hex": "010600000002000000010300000001000000050000000000000000000000000000000000000000000000000024400000000000000000000000000000244000000000000024400000000000000000000000000000244000000000000000000000000000000000010300000002000000050000000000000000003440000000000000344000000000000034400000000000003E400000000000003E400000000000003E400000000000003E40000000000000344000000000000034400000000000003440050000000000000000003940000000000000394000000000000039400000000000003A400000000000003A400000000000003A400000000000003A40000000000000394000000000000039400000000000003940"},
+    {"wkt": "GEOMETRYCOLLECTION(MULTIPOLYGON(((0 0, 10 0, 10 10, 0 10, 0 0)),((20 20, 20 30, 30 30, 30 20, 20 20),(25 25, 25 26, 26 26, 26 25, 25 25))),MULTILINESTRING((0 0, 10 0, 10 10, 0 10),(20 20, 30 20)),MULTIPOINT(0 0, 10 0, 10 10, 0 10, 0 0))", "hex": "010700000003000000010600000002000000010300000001000000050000000000000000000000000000000000000000000000000024400000000000000000000000000000244000000000000024400000000000000000000000000000244000000000000000000000000000000000010300000002000000050000000000000000003440000000000000344000000000000034400000000000003E400000000000003E400000000000003E400000000000003E40000000000000344000000000000034400000000000003440050000000000000000003940000000000000394000000000000039400000000000003A400000000000003A400000000000003A400000000000003A4000000000000039400000000000003940000000000000394001050000000200000001020000000400000000000000000000000000000000000000000000000000244000000000000000000000000000002440000000000000244000000000000000000000000000002440010200000002000000000000000000344000000000000034400000000000003E400000000000003440010400000005000000010100000000000000000000000000000000000000010100000000000000000024400000000000000000010100000000000000000024400000000000002440010100000000000000000000000000000000002440010100000000000000000000000000000000000000"}
+  ],
+  "json_geoms": [
+    {"wkt": "POINT(100 0)", "json": "{ \"type\": \"Point\", \"coordinates\": [ 100.000000, 0.000000 ] }"},
+    {"wkt": "POLYGON((0 0, -10 0, -10 -10, 0 -10, 0 0))", "json": "{ \"type\": \"Polygon\", \"coordinates\": [ [ [ 0.000000, 0.000000 ], [ -10.000000, 0.000000 ], [ -10.000000, -10.000000 ], [ 0.000000, -10.000000 ], [ 0.000000, 0.000000 ] ] ] }"},
+    {"wkt": "MULTIPOLYGON(((102 2, 103 2, 103 3, 102 3, 102 2)), ((100.0 0.0, 101.0 0.0, 101.0 1.0, 100.0 1.0, 100.0 0.0), (100.2 0.2, 100.8 0.2, 100.8 0.8, 100.2 0.8, 100.2 0.2)))", "json": "{ \"type\": \"MultiPolygon\", \"coordinates\": [ [ [ [ 102.000000, 2.000000 ], [ 103.000000, 2.000000 ], [ 103.000000, 3.000000 ], [ 102.000000, 3.000000 ], [ 102.000000, 2.000000 ] ] ], [ [ [ 100.000000, 0.000000 ], [ 101.000000, 0.000000 ], [ 101.000000, 1.000000 ], [ 100.000000, 1.000000 ], [ 100.000000, 0.000000 ] ], [ [ 100.200000, 0.200000 ], [ 100.800000, 0.200000 ], [ 100.800000, 0.800000 ], [ 100.200000, 0.800000 ], [ 100.200000, 0.200000 ] ] ] ] }"},
+    {"wkt": "GEOMETRYCOLLECTION(POINT(100 0),LINESTRING(101.0 0.0, 102.0 1.0))", "json": "{ \"type\": \"GeometryCollection\", \"geometries\": [ { \"type\": \"Point\", \"coordinates\": [ 100.000000, 0.000000 ] }, { \"type\": \"LineString\", \"coordinates\": [ [ 101.000000, 0.000000 ], [ 102.000000, 1.000000 ] ] } ] }"},
+    {"wkt": "MULTILINESTRING((100.0 0.0, 101.0 1.0),(102.0 2.0, 103.0 3.0))", "json": "\\n\\n{ \"type\": \"MultiLineString\",\\n  \"coordinates\": [\\n      [ [100.0, 0.0], [101.0, 1.0] ],\\n      [ [102.0, 2.0], [103.0, 3.0] ]\\n    ]\\n  }\\n\\n", "not_equal": true}
+  ],
+  "points": [
+    {"wkt": "POINT (5 23)", "x": 5.0, "y": 23.0, "centroid": [5.0, 23.0]},
+    {"wkt": "POINT (-95.338492 29.723893)", "x": -95.338492, "y": 29.723893, "centroid": [-95.338492, 29.723893]},
+    {"wkt": "POINT(1.234 5.678)", "x": 1.234, "y": 5.678, "centroid": [1.234, 5.678]},
+    {"wkt": "POINT(4.321 8.765)", "x": 4.321, "y": 8.765, "centroid": [4.321, 8.765]},
+    {"wkt": "POINT(10 10)", "x": 10, "y": 10, "centroid": [10.0, 10.0]},
+    {"wkt": "POINT (5 23 8)", "x": 5.0, "y": 23.0, "z": 8.0, "centroid": [5.0, 23.0]}
+  ],
+  "multipoints":[
+    {"wkt": "MULTIPOINT(10 10, 20 20 )", "n_p": 2, "coords": [[10.0, 10.0], [20.0, 20.0]], "centroid": [15.0, 15.0]},
+    {"wkt": "MULTIPOINT(10 10, 20 20, 10 20, 20 10)", "n_p": 4, "coords": [[10.0, 10.0], [20.0, 20.0], [10.0, 20.0], [20.0, 10.0]], "centroid": [15.0, 15.0]}
+  ],
+  "linestrings": [
+    {"wkt": "LINESTRING (60 180, 120 100, 180 180)", "n_p": 3, "centroid": [120.0, 140.0], "coords": [[60.0, 180.0], [120.0, 100.0], [180.0, 180.0]]},
+    {"wkt": "LINESTRING (0 0, 5 5, 10 5, 10 10)", "n_p": 4, "centroid": [6.1611652351681556, 4.6966991411008934], "coords": [[0.0, 0.0], [5.0, 5.0], [10.0, 5.0], [10.0, 10.0]]}
+  ],
+  "linearrings": [
+    {"wkt": "LINEARRING (649899.3065171393100172 4176512.3807915160432458, 649902.7294133581453934 4176512.7834989596158266, 649906.5550170192727819 4176514.3942507002502680, 649910.5820134161040187 4176516.0050024418160319, 649914.4076170771149918 4176518.0184616246260703, 649917.2264131171396002 4176519.4278986593708396, 649920.0452871860470623 4176521.6427505780011415, 649922.0587463703704998 4176522.8507948759943247, 649924.2735982896992937 4176524.4616246484220028, 649926.2870574744883925 4176525.4683542405255139, 649927.8978092158213258 4176526.8777912775985897, 649929.3072462501004338 4176528.0858355751261115, 649930.1126611357321963 4176529.4952726080082357, 649927.4951798024121672 4176506.9444361114874482, 649899.3065171393100172 4176512.3807915160432458)", "n_p": 15}
+  ],
+  "multilinestrings": [
+    {"wkt": "MULTILINESTRING ((0 0, 0 100), (100 0, 100 100))", "n_p": 4, "centroid": [50.0, 50.0], "coords": [[[0, 0], [0, 100]], [[100, 0], [100, 100]]]},
+    {"wkt": "MULTILINESTRING ((20 20, 60 60), (20 -20, 60 -60), (-20 -20, -60 -60), (-20 20, -60 60), (-80 0, 0 80, 80 0, 0 -80, -80 0), (-40 20, -40 -20), (-20 40, 20 40), (40 20, 40 -20), (20 -40, -20 -40))", "n_p": 21, "centroid": [0.0, 0.0], "coords": [[[20.0, 20.0], [60.0, 60.0]], [[20.0, -20.0], [60.0, -60.0]], [[-20.0, -20.0], [-60.0, -60.0]], [[-20.0, 20.0], [-60.0, 60.0]], [[-80.0, 0.0], [0.0, 80.0], [80.0, 0.0], [0.0, -80.0], [-80.0, 0.0]], [[-40.0, 20.0], [-40.0, -20.0]], [[-20.0, 40.0], [20.0, 40.0]], [[40.0, 20.0], [40.0, -20.0]], [[20.0, -40.0], [-20.0, -40.0]]]}
+  ],
+  "buffer_geoms": [
+      {"wkt": "POINT(0 0)",
+       "buffer_wkt": "POLYGON ((5 0,4.903926402016153 -0.97545161008064,4.619397662556435 -1.913417161825447,4.157348061512728 -2.777851165098009,3.53553390593274 -3.535533905932735,2.777851165098015 -4.157348061512724,1.913417161825454 -4.619397662556431,0.975451610080648 -4.903926402016151,0.000000000000008 -5.0,-0.975451610080632 -4.903926402016154,-1.913417161825439 -4.619397662556437,-2.777851165098002 -4.157348061512732,-3.53553390593273 -3.535533905932746,-4.157348061512719 -2.777851165098022,-4.619397662556429 -1.913417161825462,-4.903926402016149 -0.975451610080656,-5.0 -0.000000000000016,-4.903926402016156 0.975451610080624,-4.619397662556441 1.913417161825432,-4.157348061512737 2.777851165097995,-3.535533905932752 3.535533905932723,-2.777851165098029 4.157348061512714,-1.913417161825468 4.619397662556426,-0.975451610080661 4.903926402016149,-0.000000000000019 5.0,0.975451610080624 4.903926402016156,1.913417161825434 4.61939766255644,2.777851165097998 4.157348061512735,3.535533905932727 3.535533905932748,4.157348061512719 2.777851165098022,4.619397662556429 1.91341716182546,4.90392640201615 0.975451610080652,5 0))",
+       "width": 5.0, "quadsegs": 8
+      },
+      {"wkt": "POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))",
+       "buffer_wkt": "POLYGON ((-2 0,-2 10,-1.961570560806461 10.390180644032258,-1.847759065022573 10.765366864730179,-1.662939224605091 11.111140466039204,-1.414213562373095 11.414213562373096,-1.111140466039204 11.662939224605092,-0.765366864730179 11.847759065022574,-0.390180644032256 11.961570560806461,0 12,10 12,10.390180644032256 11.961570560806461,10.765366864730179 11.847759065022574,11.111140466039204 11.66293922460509,11.414213562373096 11.414213562373096,11.66293922460509 11.111140466039204,11.847759065022574 10.765366864730179,11.961570560806461 10.390180644032256,12 10,12 0,11.961570560806461 -0.390180644032256,11.847759065022574 -0.76536686473018,11.66293922460509 -1.111140466039204,11.414213562373096 -1.414213562373095,11.111140466039204 -1.66293922460509,10.765366864730179 -1.847759065022573,10.390180644032256 -1.961570560806461,10 -2,0.0 -2.0,-0.390180644032255 -1.961570560806461,-0.765366864730177 -1.847759065022575,-1.1111404660392 -1.662939224605093,-1.41421356237309 -1.4142135623731,-1.662939224605086 -1.111140466039211,-1.84775906502257 -0.765366864730189,-1.961570560806459 -0.390180644032268,-2 0))",
+       "width": 2.0, "quadsegs": 8
+      }
+  ],
+  "buffer_with_style_geoms": [
+      {"wkt": "POINT (0 0)",
+       "buffer_wkt": "POLYGON EMPTY",
+       "width": 5.0, "end_cap_style": 2, "join_style": 2
+      },
+      {"wkt": "POLYGON ((0 0, 10 0, 10 10, 0 10, 0 0))",
+       "buffer_wkt": "POLYGON ((-2 -2, -2 12, 12 12, 12 -2, -2 -2))",
+       "width": 2.0, "end_cap_style": 2, "join_style": 2
+      },
+      {"wkt": "LINESTRING (0 0, 10 0)",
+       "buffer_wkt": "POLYGON ((10 2, 10 -2, 0 -2, 0 2, 10 2))",
+       "width": 2.0, "end_cap_style": 2, "join_style": 2
+      },
+      {"wkt": "LINESTRING (0 0, 10 0, 10 10, 0 10)",
+       "buffer_wkt": "POLYGON ((8 2, 8 8, 0 8, 0 12, 12 12, 12 -2, 0 -2, 0 2, 8 2))",
+       "width": 2.0, "end_cap_style": 2, "join_style": 2
+      }
+  ],
+  "relate_geoms": [
+      {"wkt_a": "MULTIPOINT(80 70, 20 20, 200 170, 140 120)",
+       "wkt_b": "MULTIPOINT(80 170, 140 120, 200 80, 80 70)",
+       "pattern": "0F0FFF0F2", "result": true
+      },
+      {"wkt_a": "POINT(20 20)",
+       "wkt_b": "POINT(40 60)",
+       "pattern": "FF0FFF0F2", "result": true
+      },
+      {"wkt_a": "POINT(110 110)",
+       "wkt_b": "LINESTRING(200 200, 110 110, 200 20, 20 20, 110 110, 20 200, 200 200)",
+       "pattern": "0FFFFF1F2", "result": true
+      },
+      {"wkt_a": "MULTILINESTRING((20 20, 90 20, 170 20), (90 20, 90 80, 90 140))",
+       "wkt_b": "MULTILINESTRING((90 20, 170 100, 170 140), (130 140, 130 60, 90 20, 20 90, 90 20))",
+       "pattern": "FF10F0102", "result": true
+      }
+  ],
+  "topology_geoms": [
+      {"wkt_a": "POLYGON ((-5.0 0.0, -5.0 10.0, 5.0 10.0, 5.0 0.0, -5.0 0.0))",
+       "wkt_b": "POLYGON ((0.0 -5.0, 0.0 5.0, 10.0 5.0, 10.0 -5.0, 0.0 -5.0))"
+      },
+      {"wkt_a": "POLYGON ((2 0, 18 0, 18 15, 2 15, 2 0))",
+       "wkt_b": "POLYGON ((10 1, 11 3, 13 4, 15 6, 16 8, 16 10, 15 12, 13 13, 11 12, 10 10, 9 12, 7 13, 5 12, 4 10, 4 8, 5 6, 7 4, 9 3, 10 1))"
+      }
+  ],
+  "diff_geoms": [
+      {"wkt": "POLYGON ((-5 0,-5 10,5 10,5 5,0 5,0 0,-5 0))"},
+      {"wkt": "POLYGON ((2 0, 2 15, 18 15, 18 0, 2 0), (10 1, 11 3, 13 4, 15 6, 16 8, 16 10, 15 12, 13 13, 11 12, 10 10, 9 12, 7 13, 5 12, 4 10, 4 8, 5 6, 7 4, 9 3, 10 1))"}
+  ],
+  "sdiff_geoms": [
+      {"wkt": "MULTIPOLYGON (((-5 0,-5 10,5 10,5 5,0 5,0 0,-5 0)),((0 0,5 0,5 5,10 5,10 -5,0 -5,0 0)))"},
+      {"wkt": "POLYGON ((2 0, 2 15, 18 15, 18 0, 2 0), (10 1, 11 3, 13 4, 15 6, 16 8, 16 10, 15 12, 13 13, 11 12, 10 10, 9 12, 7 13, 5 12, 4 10, 4 8, 5 6, 7 4, 9 3, 10 1))"}
+  ],
+  "intersect_geoms": [
+      {"wkt": "POLYGON ((5 5,5 0,0 0,0 5,5 5))"},
+      {"wkt": "POLYGON ((10 1, 9 3, 7 4, 5 6, 4 8, 4 10, 5 12, 7 13, 9 12, 10 10, 11 12, 13 13, 15 12, 16 10, 16 8, 15 6, 13 4, 11 3, 10 1))"}
+  ],
+  "union_geoms": [
+      {"wkt": "POLYGON ((-5 0,-5 10,5 10,5 5,10 5,10 -5,0 -5,0 0,-5 0))"},
+      {"wkt": "POLYGON ((2 0, 2 15, 18 15, 18 0, 2 0))"}
+  ]
+}

testbed/django__django/tests/gis_tests/data/has_nulls/has_nulls.geojson

@@ -0,0 +1,139 @@
+{
+  "type": "FeatureCollection",
+  "name": "has_nulls",
+  "crs": {
+    "type": "name",
+    "properties": {
+      "name": "urn:ogc:def:crs:OGC:1.3:CRS84"
+    }
+  },
+  "features": [
+    {
+      "type": "Feature",
+      "properties": {
+        "uuid": "1378c26f-cbe6-44b0-929f-eb330d4991f5",
+        "boolean": true,
+        "datetime": "1994-08-14T11:32:14+0000",
+        "name": "Philadelphia",
+        "integer": 5,
+        "num": 1.001
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -75.14923095703125,
+              39.8928799002948
+            ],
+            [
+              -75.25772094726562,
+              39.889718875996685
+            ],
+            [
+              -75.201416015625,
+              40.03076909369051
+            ],
+            [
+              -75.07644653320312,
+              39.99500778093748
+            ],
+            [
+              -75.14785766601562,
+              39.95291166179976
+            ],
+            [
+              -75.135498046875,
+              39.91605629078665
+            ],
+            [
+              -75.14923095703125,
+              39.8928799002948
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "uuid": "fa2ba67c-a135-4338-b924-a9622b5d869f",
+        "integer": null,
+        "num": null
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -75.11215209960938,
+              39.94870062390347
+            ],
+            [
+              -75.02838134765625,
+              39.990799335838034
+            ],
+            [
+              -74.959716796875,
+              39.920269337633975
+            ],
+            [
+              -75.025634765625,
+              39.8465036024177
+            ],
+            [
+              -75.12725830078125,
+              39.871803651624425
+            ],
+            [
+              -75.11215209960938,
+              39.94870062390347
+            ]
+          ]
+        ]
+      }
+    },
+    {
+      "type": "Feature",
+      "properties": {
+        "uuid": "4494c1f3-55ab-4256-b365-12115cb388d5",
+        "datetime": "2018-11-29T03:02:52+0000",
+        "name": "north",
+        "integer": 8,
+        "num": 0.0,
+        "boolean": false
+      },
+      "geometry": {
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -75.24948120117188,
+              39.99395569397331
+            ],
+            [
+              -75.27420043945312,
+              40.0507451947963
+            ],
+            [
+              -75.20553588867188,
+              40.119040222688795
+            ],
+            [
+              -75.08193969726562,
+              40.03287211677227
+            ],
+            [
+              -75.16433715820312,
+              39.97396296240704
+            ],
+            [
+              -75.24948120117188,
+              39.99395569397331
+            ]
+          ]
+        ]
+      }
+    }
+  ]
+}

testbed/django__django/tests/gis_tests/data/interstates/interstates.prj

@@ -0,0 +1 @@
+GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]

testbed/django__django/tests/gis_tests/data/rasters/textrasters.py

@@ -0,0 +1,16 @@
+"""
+Text-based test rasters
+"""
+
+JSON_RASTER = """{
+    "srid": 4326,
+    "origin": [0, 0],
+    "scale": [-1, 1],
+    "skew": [0, 0],
+    "width": 5,
+    "height": 5,
+    "nr_of_bands": 1,
+    "bands": [{"data": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+                        15, 16, 17, 18, 19, 20, 21, 22, 23, 24]}]
+}
+"""

testbed/django__django/tests/gis_tests/data/test_point/test_point.prj

@@ -0,0 +1 @@
+GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]

testbed/django__django/tests/gis_tests/data/test_poly/test_poly.prj

@@ -0,0 +1 @@
+GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",0.017453292519943295]]

testbed/django__django/tests/gis_tests/data/test_vrt/test_vrt.csv

@@ -0,0 +1,4 @@
+POINT_X,POINT_Y,NUM
+1.0,2.0,5
+5.0,23.0,17
+100.0,523.5,23

testbed/django__django/tests/gis_tests/data/test_vrt/test_vrt.vrt

@@ -0,0 +1,7 @@
+<OGRVRTDataSource>
+<OGRVRTLayer name="test_vrt">
+<SrcDataSource relativeToVRT="1">test_vrt.csv</SrcDataSource>
+<GeometryType>wkbPoint25D</GeometryType>
+<GeometryField encoding="PointFromColumns" x="POINT_X" y="POINT_Y" z="NUM"/>
+</OGRVRTLayer>
+</OGRVRTDataSource>

testbed/django__django/tests/gis_tests/distapp/fixtures/initial.json

@@ -0,0 +1,314 @@
+[
+  {
+    "pk": 1,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Downtown Houston",
+      "point": "SRID=32140;POINT (951640.5473284651525319 4219369.2617166414856911)"
+    }
+  },
+  {
+    "pk": 2,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "West University Place",
+      "point": "SRID=32140;POINT (943547.9223275661934167 4213623.6534501984715462)"
+    }
+  },
+  {
+    "pk": 3,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Southside Place",
+      "point": "SRID=32140;POINT (944704.6433068963233382 4212768.8761719493195415)"
+    }
+  },
+  {
+    "pk": 4,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Bellaire",
+      "point": "SRID=32140;POINT (942595.6691285020206124 4212686.7258348800241947)"
+    }
+  },
+  {
+    "pk": 5,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Pearland",
+      "point": "SRID=32140;POINT (959674.6165056140162051 4197465.6525986101478338)"
+    }
+  },
+  {
+    "pk": 6,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Galveston",
+      "point": "SRID=32140;POINT (1008151.1600717274704948 4170027.4765489147976041)"
+    }
+  },
+  {
+    "pk": 7,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Sealy",
+      "point": "SRID=32140;POINT (874859.2868079885374755 4219186.8640952249988914)"
+    }
+  },
+  {
+    "pk": 8,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "San Antonio",
+      "point": "SRID=32140;POINT (649173.9104827501578256 4176413.2778564509935677)"
+    }
+  },
+  {
+    "pk": 9,
+    "model": "distapp.southtexascity",
+    "fields": {
+      "name": "Saint Hedwig",
+      "point": "SRID=32140;POINT (677644.6499522707890719 4175467.0674387565813959)"
+    }
+  },
+  {
+    "pk": 1,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Downtown Houston",
+      "point": "SRID=2278;POINT (3122174.0290268082171679 13843047.3191486913710833)"
+    }
+  },
+  {
+    "pk": 2,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "West University Place",
+      "point": "SRID=2278;POINT (3095623.4751696921885014 13824196.9360278695821762)"
+    }
+  },
+  {
+    "pk": 3,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Southside Place",
+      "point": "SRID=2278;POINT (3099418.4839160442352295 13821392.5542408134788275)"
+    }
+  },
+  {
+    "pk": 4,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Bellaire",
+      "point": "SRID=2278;POINT (3092499.2911324291490018 13821123.0326766129583120)"
+    }
+  },
+  {
+    "pk": 5,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Pearland",
+      "point": "SRID=2278;POINT (3148532.4709855038672686 13771185.2282339502125978)"
+    }
+  },
+  {
+    "pk": 6,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Galveston",
+      "point": "SRID=2278;POINT (3307575.9310019947588444 13681165.1456442419439554)"
+    }
+  },
+  {
+    "pk": 7,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Sealy",
+      "point": "SRID=2278;POINT (2870267.5101358774118125 13842448.9029524270445108)"
+    }
+  },
+  {
+    "pk": 8,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "San Antonio",
+      "point": "SRID=2278;POINT (2129831.4046421577222645 13702115.8954340498894453)"
+    }
+  },
+  {
+    "pk": 9,
+    "model": "distapp.southtexascityft",
+    "fields": {
+      "name": "Saint Hedwig",
+      "point": "SRID=2278;POINT (2223239.1557184099219739 13699011.5367553308606148)"
+    }
+  },
+  {
+    "pk": 1,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Wollongong",
+      "point": "SRID=4326;POINT (150.9019999999999868 -34.4245000000000019)"
+    }
+  },
+  {
+    "pk": 2,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Shellharbour",
+      "point": "SRID=4326;POINT (150.8700000000000045 -34.5788999999999973)"
+    }
+  },
+  {
+    "pk": 3,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Thirroul",
+      "point": "SRID=4326;POINT (150.9240000000000066 -34.3147000000000020)"
+    }
+  },
+  {
+    "pk": 4,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Mittagong",
+      "point": "SRID=4326;POINT (150.4490000000000123 -34.4508999999999972)"
+    }
+  },
+  {
+    "pk": 5,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Batemans Bay",
+      "point": "SRID=4326;POINT (150.1750000000000114 -35.7081999999999979)"
+    }
+  },
+  {
+    "pk": 6,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Canberra",
+      "point": "SRID=4326;POINT (144.9629999999999939 -37.8143000000000029)"
+    }
+  },
+  {
+    "pk": 7,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Melbourne",
+      "point": "SRID=4326;POINT (145.9629999999999939 -37.8143000000000029)"
+    }
+  },
+  {
+    "pk": 8,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Sydney",
+      "point": "SRID=4326;POINT (151.2607099999999889 -33.8870339999999999)"
+    }
+  },
+  {
+    "pk": 9,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Hobart",
+      "point": "SRID=4326;POINT (147.3300000000000125 -42.8826999999999998)"
+    }
+  },
+  {
+    "pk": 10,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Adelaide",
+      "point": "SRID=4326;POINT (138.5999999999999943 -34.9258000000000024)"
+    }
+  },
+  {
+    "pk": 11,
+    "model": "distapp.australiacity",
+    "fields": {
+      "name": "Hillsdale",
+      "point": "SRID=4326;POINT (151.2313409999999863 -33.9526850000000024)"
+    }
+  },
+  {
+    "pk": 1,
+    "model": "distapp.censuszipcode",
+    "fields": {
+      "name": "77002",
+      "poly": "SRID=4269;POLYGON ((-95.3650149999999996 29.7723270000000007, -95.3624149999999986 29.7723270000000007, -95.3609150000000056 29.7718269999999983, -95.3546149999999955 29.7718269999999983, -95.3515150000000062 29.7725270000000002, -95.3509150000000005 29.7653269999999992, -95.3510150000000039 29.7624360000000010, -95.3501150000000024 29.7603280000000012, -95.3475150000000014 29.7585279999999983, -95.3523150000000044 29.7539279999999984, -95.3564149999999984 29.7563279999999999, -95.3582150000000013 29.7540280000000017, -95.3602149999999966 29.7563279999999999, -95.3634150000000034 29.7571280000000016, -95.3640139999999974 29.7563800000000001, -95.3634150000000034 29.7539279999999984, -95.3600150000000042 29.7518279999999997, -95.3618150000000071 29.7495280000000015, -95.3627149999999943 29.7500280000000004, -95.3675159999999948 29.7441279999999999, -95.3693159999999978 29.7451280000000011, -95.3739159999999941 29.7441279999999999, -95.3801160000000010 29.7380279999999999, -95.3879160000000041 29.7279289999999996, -95.3885159999999956 29.7296289999999992, -95.3879160000000041 29.7321290000000005, -95.3829159999999945 29.7374280000000013, -95.3766159999999985 29.7422280000000008, -95.3726159999999936 29.7472279999999998, -95.3786010000000033 29.7508459999999992, -95.3786159999999938 29.7520279999999993, -95.3786159999999938 29.7544280000000008, -95.3760160000000070 29.7545280000000005, -95.3746160000000032 29.7598279999999988, -95.3736159999999984 29.7611279999999994, -95.3719159999999988 29.7639279999999999, -95.3723159999999979 29.7687269999999984, -95.3658839999999941 29.7679100000000005, -95.3660150000000044 29.7671269999999986, -95.3587150000000037 29.7653269999999992, -95.3586150000000004 29.7663270000000004, -95.3591150000000027 29.7672269999999983, -95.3602149999999966 29.7670269999999988, -95.3627829999999932 29.7682670000000016, -95.3653149999999954 29.7705270000000013, -95.3650149999999996 29.7723270000000007))"
+    }
+  },
+  {
+    "pk": 2,
+    "model": "distapp.censuszipcode",
+    "fields": {
+      "name": "77005",
+      "poly": "SRID=4269;POLYGON ((-95.4479180000000014 29.7272749999999988, -95.4280169999999970 29.7287290000000013, -95.4211169999999953 29.7290290000000006, -95.4186169999999976 29.7276290000000003, -95.4185169999999943 29.7264289999999995, -95.4021170000000041 29.7266289999999991, -95.4021170000000041 29.7257290000000012, -95.3953159999999940 29.7257290000000012, -95.3919159999999948 29.7262290000000000, -95.3897160000000071 29.7258290000000009, -95.3965170000000029 29.7154290000000003, -95.3975169999999935 29.7159289999999991, -95.4009170000000069 29.7114289999999990, -95.4114170000000001 29.7150290000000012, -95.4184170000000051 29.7147289999999984, -95.4183170000000018 29.7062300000000015, -95.4408179999999930 29.7059299999999986, -95.4450180000000046 29.7068300000000001, -95.4466180000000008 29.7076300000000018, -95.4474179999999990 29.7100299999999997, -95.4479180000000014 29.7272749999999988))"
+    }
+  },
+  {
+    "pk": 3,
+    "model": "distapp.censuszipcode",
+    "fields": {
+      "name": "77025",
+      "poly": "SRID=4269;POLYGON ((-95.4183170000000018 29.7062300000000015, -95.4147169999999960 29.7061290000000007, -95.4146170000000069 29.7053300000000000, -95.4182169999999985 29.7053300000000000, -95.4198169999999948 29.6953299999999984, -95.4194839999999971 29.6941960000000016, -95.4171659999999946 29.6909010000000002, -95.4145170000000036 29.6943300000000008, -95.4133170000000064 29.6926300000000012, -95.4126169999999973 29.6897300000000008, -95.4128170000000040 29.6875299999999989, -95.4140869999999950 29.6850549999999984, -95.4191650000000067 29.6854280000000017, -95.4216169999999977 29.6851300000000009, -95.4257170000000059 29.6798299999999990, -95.4250169999999969 29.6792300000000004, -95.4245169999999945 29.6776300000000006, -95.4274180000000030 29.6776300000000006, -95.4380179999999996 29.6646310000000000, -95.4367129999999975 29.6644110000000012, -95.4401179999999982 29.6622309999999985, -95.4392179999999968 29.6610310000000013, -95.4377180000000038 29.6601309999999998, -95.4357179999999943 29.6597310000000007, -95.4318180000000069 29.6603309999999993, -95.4414179999999988 29.6566310000000009, -95.4413179999999954 29.6563310000000016, -95.4418179999999978 29.6561309999999985, -95.4417179999999945 29.6590309999999988, -95.4411180000000030 29.6610310000000013, -95.4467180000000042 29.6564310000000013, -95.4465179999999975 29.6734310000000008, -95.4469179999999966 29.6901299999999999, -95.4474179999999990 29.7100299999999997, -95.4466180000000008 29.7076300000000018, -95.4450180000000046 29.7068300000000001, -95.4408179999999930 29.7059299999999986, -95.4183170000000018 29.7062300000000015))"
+    }
+  },
+  {
+    "pk": 4,
+    "model": "distapp.censuszipcode",
+    "fields": {
+      "name": "77401",
+      "poly": "SRID=4269;POLYGON ((-95.4479180000000014 29.7272749999999988, -95.4474179999999990 29.7100299999999997, -95.4469179999999966 29.6901299999999999, -95.4543180000000007 29.6889299999999992, -95.4758190000000013 29.6890299999999989, -95.4758190000000013 29.6911300000000011, -95.4844190000000026 29.6910300000000014, -95.4845190000000059 29.6990300000000005, -95.4804189999999977 29.7013299999999987, -95.4804189999999977 29.6983299999999986, -95.4741190000000017 29.6983299999999986, -95.4741190000000017 29.7045299999999983, -95.4727189999999979 29.7128300000000003, -95.4680189999999982 29.7129300000000001, -95.4682190000000048 29.7202289999999998, -95.4640179999999958 29.7202289999999998, -95.4641179999999991 29.7245290000000004, -95.4630180000000053 29.7259290000000007, -95.4598179999999985 29.7261290000000002, -95.4599180000000018 29.7203289999999996, -95.4514180000000039 29.7204289999999993, -95.4517749999999978 29.7263030000000015, -95.4513180000000006 29.7270290000000017, -95.4479180000000014 29.7272749999999988))"
+    }
+  },
+  {
+    "pk": 1,
+    "model": "distapp.southtexaszipcode",
+    "fields": {
+      "name": "77002",
+      "poly": "SRID=32140;POLYGON ((951429.5409192872466519 4220355.4988148519769311, 951680.8273045794339851 4220363.3144243787974119, 951827.5242763287387788 4220312.4344643373042345, 952436.4125371500849724 4220331.4033580468967557, 952733.6038219904294237 4220418.2972162021324039, 952816.4884229446761310 4219622.4721539746969938, 952816.8189755391795188 4219301.8983748322352767, 952911.1013538520783186 4219071.0846072295680642, 953168.6460092773195356 4218879.5251544509083033, 952720.5711025173077360 4218355.4412181628867984, 952315.9552874444052577 4218608.9603398498147726, 952149.8976783070247620 4218348.7396276174113154, 951948.6335086676990613 4218597.5187743240967393, 951636.5529057731619105 4218676.5191153362393379, 951581.2288653708528727 4218591.8528460673987865, 951647.5797480825567618 4218322.0148884318768978, 951983.4872268696781248 4218099.5997478468343616, 951817.4139249715954065 4217839.3842275496572256, 951728.6875000044237822 4217892.0683275610208511, 951284.8837139783427119 4217224.0225605471059680, 951107.4276299364864826 4217329.3996630022302270, 950666.1605060384608805 4217204.8158583818003535, 950087.6947283914778382 4216510.4676794996485114, 949368.1435158180538565 4215368.3503736928105354, 949304.3111934799235314 4215554.8883790764957666, 949353.7683630869723856 4215833.6369291869923472, 949819.0428102404111996 4216435.6196845080703497, 950411.6597438841126859 4216986.2362841432914138, 950781.1835370573680848 4217552.1403498277068138, 950190.1823301381664351 4217935.0160658890381455, 950184.6762747208122164 4218065.9165289513766766, 950176.4407065160339698 4218331.7956013763323426, 950427.4286870528012514 4218350.6616439744830132, 950544.5537801468744874 4218942.0070019531995058, 950636.7473976470064372 4219089.0227092057466507, 950791.4425049067940563 4219404.3132666023448110, 950736.2833876821678132 4219934.7619700236245990, 951360.7634590273955837 4219863.5588980689644814, 951350.7981466529890895 4219776.4222313342615962, 952062.5793334231711924 4219598.9663440436124802, 952068.7943994677625597 4219710.0501319468021393, 952017.3623401129152626 4219808.2495522042736411, 951911.7334559946320951 4219782.7825336037203670, 951659.2534216577187181 4219912.4288446288555861, 951406.7457121167099103 4220155.1877524554729462, 951429.5409192872466519 4220355.4988148519769311))"
+    }
+  },
+  {
+    "pk": 2,
+    "model": "distapp.southtexaszipcode",
+    "fields": {
+      "name": "77005",
+      "poly": "SRID=32140;POLYGON ((943568.6284788220655173 4215118.1416417406871915, 945487.9980521594407037 4215337.8481928687542677, 946154.1517634749179706 4215391.4863748690113425, 946400.6304061285918579 4215243.7918130923062563, 946414.3720398070290685 4215111.1480321725830436, 947999.4599494948051870 4215181.9933486394584179, 948002.5282293657073751 4215082.2888173414394259, 948660.1417131680063903 4215102.5451732110232115, 948987.1902349996380508 4215168.0774542130529881, 949201.2831489123636857 4215130.3313774159178138, 948579.1820738224778324 4213957.9057207889854908, 948480.7719409475103021 4214010.3167602103203535, 948167.3284030471695587 4213501.6696778312325478, 947139.6595406322740018 4213869.2741038342937827, 946463.7483147600432858 4213815.2817387804389000, 946502.2630172523204237 4212874.0348161971196532, 944327.1378451543860137 4212774.3432321334257722, 943917.9093748427694663 4212861.6900106100365520, 943760.4753683793824166 4212945.6127811912447214, 943675.0267053353600204 4213209.1422286527231336, 943568.6284788220655173 4215118.1416417406871915))"
+    }
+  },
+  {
+    "pk": 3,
+    "model": "distapp.southtexaszipcode",
+    "fields": {
+      "name": "77025",
+      "poly": "SRID=32140;POLYGON ((946502.2630172523204237 4212874.0348161971196532, 946850.7713855113834143 4212873.5172070376574993, 946863.1571223458740860 4212785.2985141929239035, 946514.9888159723486751 4212774.6266902117058635, 946394.1713412774261087 4211662.0614421153441072, 946430.2274363302858546 4211537.4205564847216010, 946665.6199423221405596 4211179.2615583632141352, 946910.2001898437738419 4211566.9887375179678202, 947032.0462735339533538 4211382.2191729480400681, 947109.6117705166107044 4211063.0284381639212370, 947097.7440171607304364 4210818.7144018746912479, 946983.3062754627317190 4210540.7604114022105932, 946490.8323894963832572 4210567.0268272040411830, 946254.6550409919582307 4210526.7516811080276966, 945876.0008902740664780 4209927.4740557167679071, 945945.7498299231519923 4209863.0751969292759895, 945999.5397084732539952 4209687.3030018107965589, 945718.8972609748598188 4209678.7238750727847219, 944737.3260139031335711 4208207.3771017007529736, 944864.3308290732093155 4208186.8525157077237964, 944542.2412279490381479 4207935.3116904916241765, 944633.3693750606616959 4207805.0250262534245849, 944781.5411592419259250 4207709.7424235185608268, 944976.4055775101296604 4207671.3274960424751043, 945351.7294723913073540 4207749.3068800456821918, 944435.3426235395018011 4207311.1031644716858864, 944446.0302430286537856 4207278.1630970388650894, 944398.3243151376955211 4207254.5342014739289880, 944398.2226623257156461 4207576.0964536992833018, 944449.5330111491493881 4207799.4275652254000306, 943923.1866919576423243 4207273.3492023386061192, 943885.2983187574427575 4209157.2369952416047454, 943790.3796654250472784 4211006.0231411391869187, 943675.0267053353600204 4213209.1422286527231336, 943760.4753683793824166 4212945.6127811912447214, 943917.9093748427694663 4212861.6900106100365520, 944327.1378451543860137 4212774.3432321334257722, 946502.2630172523204237 4212874.0348161971196532))"
+    }
+  },
+  {
+    "pk": 4,
+    "model": "distapp.southtexaszipcode",
+    "fields": {
+      "name": "77401",
+      "poly": "SRID=32140;POLYGON ((943568.6284788220655173 4215118.1416417406871915, 943675.0267053353600204 4213209.1422286527231336, 943790.3796654250472784 4211006.0231411391869187, 943078.6190994082717225 4210851.3527729213237762, 940998.4896008004434407 4210799.5486384732648730, 940991.4769605984911323 4211032.1947893090546131, 940159.9452393862884492 4210996.0721307108178735, 940123.6234478773549199 4211882.0554536599665880, 940512.5092238665092736 4212148.7901582065969706, 940522.5142344047781080 4211816.4372764797881246, 941131.8601800086908042 4211834.7971962466835976, 941111.1461491615045816 4212521.6589920166879892, 941218.8068687882041559 4213445.2531420132145286, 941672.9982470837421715 4213470.0535286460071802, 941629.2300919098779559 4214278.0848444234579802, 942035.4691281586419791 4214290.3638116680085659, 942011.3920782012864947 4214766.4446664610877633, 942113.0660258040297776 4214924.7603673832491040, 942421.8192426580935717 4214956.2823535148054361, 942431.6055385319050401 4214313.4400705620646477, 943253.2209875346161425 4214349.4362764349207282, 943198.9497700630454347 4214999.1347201215103269, 943240.6978847808204591 4215080.9052637927234173, 943568.6284788220655173 4215118.1416417406871915))"
+    }
+  },
+  {
+    "pk": 1,
+    "model": "distapp.interstate",
+    "fields": {
+      "path": "SRID=4326;LINESTRING (-104.4780170766107972 36.6669879187069370, -104.4468522338494978 36.7992540939338610, -104.4621269262599981 36.9372149776075034, -104.5126119783767962 37.0816326882088703, -104.5247764602161027 37.2930049989204804, -104.7084397427667994 37.4915025992539768, -104.8126599016281943 37.6951428562186308, -104.8452887035466006 37.8761339565947921, -104.7160169341002955 38.0595176333779932, -104.6165437927668052 38.3043204585510608, -104.6437227858174026 38.5397998656473675, -104.7596170387259065 38.7322907594295032, -104.8380078676821938 38.8999846060434109, -104.8501253693505930 39.0998018921335770, -104.8791648316464062 39.2436877645750286, -104.8635041274215070 39.3785278162751027, -104.8894471170052043 39.5929228239604996, -104.9721242843343987 39.6952848241968468, -105.0112104500356054 39.7273080432393968, -105.0010368577104032 39.7667760781157114, -104.9818356189999946 39.8146650412196692, -104.9858891550477011 39.8880691125083189, -104.9873548059578070 39.9811723457101635, -104.9766220487419019 40.0979642345069180, -104.9818565932953049 40.3605653066288426, -104.9912746373996981 40.7490448444765576)",
+      "name": "I-25"
+    }
+  },
+  {
+    "pk": 1,
+    "model": "distapp.southtexasinterstate",
+    "fields": {
+      "path": "SRID=32140;LINESTRING (924952.5000000000000000 4220931.5999999996274710, 925065.3000000000465661 4220931.5999999996274710, 929568.4000000000232831 4221057.7999999998137355)",
+      "name": "I-10"
+    }
+  }
+]

testbed/django__django/tests/gis_tests/distapp/models.py

@@ -0,0 +1,52 @@
+from django.contrib.gis.db import models
+
+from ..utils import gisfield_may_be_null
+
+
+class NamedModel(models.Model):
+    name = models.CharField(max_length=30)
+
+    class Meta:
+        abstract = True
+
+    def __str__(self):
+        return self.name
+
+
+class SouthTexasCity(NamedModel):
+    "City model on projected coordinate system for South Texas."
+    point = models.PointField(srid=32140)
+    radius = models.IntegerField(default=10000)
+
+
+class SouthTexasCityFt(NamedModel):
+    "Same City model as above, but U.S. survey feet are the units."
+    point = models.PointField(srid=2278)
+
+
+class AustraliaCity(NamedModel):
+    "City model for Australia, using WGS84."
+    point = models.PointField()
+    radius = models.IntegerField(default=10000)
+    allowed_distance = models.FloatField(default=0.5)
+    ref_point = models.PointField(null=True)
+
+
+class CensusZipcode(NamedModel):
+    "Model for a few South Texas ZIP codes (in original Census NAD83)."
+    poly = models.PolygonField(srid=4269)
+
+
+class SouthTexasZipcode(NamedModel):
+    "Model for a few South Texas ZIP codes."
+    poly = models.PolygonField(srid=32140, null=gisfield_may_be_null)
+
+
+class Interstate(NamedModel):
+    "Geodetic model for U.S. Interstates."
+    path = models.LineStringField()
+
+
+class SouthTexasInterstate(NamedModel):
+    "Projected model for South Texas Interstates."
+    path = models.LineStringField(srid=32140)

testbed/django__django/tests/gis_tests/distapp/tests.py

@@ -0,0 +1,796 @@
+from django.contrib.gis.db.models.functions import (
+    Area,
+    Distance,
+    Length,
+    Perimeter,
+    Transform,
+    Union,
+)
+from django.contrib.gis.geos import GEOSGeometry, LineString, Point
+from django.contrib.gis.measure import D  # alias for Distance
+from django.db import NotSupportedError, connection
+from django.db.models import (
+    Case,
+    Count,
+    Exists,
+    F,
+    IntegerField,
+    OuterRef,
+    Q,
+    Value,
+    When,
+)
+from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
+
+from ..utils import FuncTestMixin
+from .models import (
+    AustraliaCity,
+    CensusZipcode,
+    Interstate,
+    SouthTexasCity,
+    SouthTexasCityFt,
+    SouthTexasInterstate,
+    SouthTexasZipcode,
+)
+
+
+class DistanceTest(TestCase):
+    fixtures = ["initial"]
+
+    def setUp(self):
+        # A point we are testing distances with -- using a WGS84
+        # coordinate that'll be implicitly transformed to that to
+        # the coordinate system of the field, EPSG:32140 (Texas South Central
+        # w/units in meters)
+        self.stx_pnt = GEOSGeometry(
+            "POINT (-95.370401017314293 29.704867409475465)", 4326
+        )
+        # Another one for Australia
+        self.au_pnt = GEOSGeometry("POINT (150.791 -34.4919)", 4326)
+
+    def get_names(self, qs):
+        cities = [c.name for c in qs]
+        cities.sort()
+        return cities
+
+    def test_init(self):
+        """
+        Test initialization of distance models.
+        """
+        self.assertEqual(9, SouthTexasCity.objects.count())
+        self.assertEqual(9, SouthTexasCityFt.objects.count())
+        self.assertEqual(11, AustraliaCity.objects.count())
+        self.assertEqual(4, SouthTexasZipcode.objects.count())
+        self.assertEqual(4, CensusZipcode.objects.count())
+        self.assertEqual(1, Interstate.objects.count())
+        self.assertEqual(1, SouthTexasInterstate.objects.count())
+
+    @skipUnlessDBFeature("supports_dwithin_lookup")
+    def test_dwithin(self):
+        """
+        Test the `dwithin` lookup type.
+        """
+        # Distances -- all should be equal (except for the
+        # degree/meter pair in au_cities, that's somewhat
+        # approximate).
+        tx_dists = [(7000, 22965.83), D(km=7), D(mi=4.349)]
+        au_dists = [(0.5, 32000), D(km=32), D(mi=19.884)]
+
+        # Expected cities for Australia and Texas.
+        tx_cities = ["Downtown Houston", "Southside Place"]
+        au_cities = ["Mittagong", "Shellharbour", "Thirroul", "Wollongong"]
+
+        # Performing distance queries on two projected coordinate systems one
+        # with units in meters and the other in units of U.S. survey feet.
+        for dist in tx_dists:
+            if isinstance(dist, tuple):
+                dist1, dist2 = dist
+            else:
+                dist1 = dist2 = dist
+            qs1 = SouthTexasCity.objects.filter(point__dwithin=(self.stx_pnt, dist1))
+            qs2 = SouthTexasCityFt.objects.filter(point__dwithin=(self.stx_pnt, dist2))
+            for qs in qs1, qs2:
+                with self.subTest(dist=dist, qs=qs):
+                    self.assertEqual(tx_cities, self.get_names(qs))
+
+        # With a complex geometry expression
+        self.assertFalse(
+            SouthTexasCity.objects.exclude(point__dwithin=(Union("point", "point"), 0))
+        )
+
+        # Now performing the `dwithin` queries on a geodetic coordinate system.
+        for dist in au_dists:
+            with self.subTest(dist=dist):
+                type_error = isinstance(dist, D) and not connection.ops.oracle
+                if isinstance(dist, tuple):
+                    if connection.ops.oracle or connection.ops.spatialite:
+                        # Result in meters
+                        dist = dist[1]
+                    else:
+                        # Result in units of the field
+                        dist = dist[0]
+
+                # Creating the query set.
+                qs = AustraliaCity.objects.order_by("name")
+                if type_error:
+                    # A ValueError should be raised on PostGIS when trying to
+                    # pass Distance objects into a DWithin query using a
+                    # geodetic field.
+                    with self.assertRaises(ValueError):
+                        AustraliaCity.objects.filter(
+                            point__dwithin=(self.au_pnt, dist)
+                        ).count()
+                else:
+                    self.assertEqual(
+                        au_cities,
+                        self.get_names(qs.filter(point__dwithin=(self.au_pnt, dist))),
+                    )
+
+    @skipUnlessDBFeature("supports_distances_lookups")
+    def test_distance_lookups(self):
+        # Retrieving the cities within a 20km 'donut' w/a 7km radius 'hole'
+        # (thus, Houston and Southside place will be excluded as tested in
+        # the `test02_dwithin` above).
+        for model in [SouthTexasCity, SouthTexasCityFt]:
+            stx_pnt = self.stx_pnt.transform(
+                model._meta.get_field("point").srid, clone=True
+            )
+            qs = model.objects.filter(point__distance_gte=(stx_pnt, D(km=7))).filter(
+                point__distance_lte=(stx_pnt, D(km=20)),
+            )
+            cities = self.get_names(qs)
+            self.assertEqual(cities, ["Bellaire", "Pearland", "West University Place"])
+
+        # Doing a distance query using Polygons instead of a Point.
+        z = SouthTexasZipcode.objects.get(name="77005")
+        qs = SouthTexasZipcode.objects.exclude(name="77005").filter(
+            poly__distance_lte=(z.poly, D(m=275))
+        )
+        self.assertEqual(["77025", "77401"], self.get_names(qs))
+        # If we add a little more distance 77002 should be included.
+        qs = SouthTexasZipcode.objects.exclude(name="77005").filter(
+            poly__distance_lte=(z.poly, D(m=300))
+        )
+        self.assertEqual(["77002", "77025", "77401"], self.get_names(qs))
+
+    @skipUnlessDBFeature("supports_distances_lookups", "supports_distance_geodetic")
+    def test_geodetic_distance_lookups(self):
+        """
+        Test distance lookups on geodetic coordinate systems.
+        """
+        # Line is from Canberra to Sydney.  Query is for all other cities within
+        # a 100km of that line (which should exclude only Hobart & Adelaide).
+        line = GEOSGeometry("LINESTRING(144.9630 -37.8143,151.2607 -33.8870)", 4326)
+        dist_qs = AustraliaCity.objects.filter(point__distance_lte=(line, D(km=100)))
+        expected_cities = [
+            "Batemans Bay",
+            "Canberra",
+            "Hillsdale",
+            "Melbourne",
+            "Mittagong",
+            "Shellharbour",
+            "Sydney",
+            "Thirroul",
+            "Wollongong",
+        ]
+        if connection.ops.spatialite:
+            # SpatiaLite is less accurate and returns 102.8km for Batemans Bay.
+            expected_cities.pop(0)
+        self.assertEqual(expected_cities, self.get_names(dist_qs))
+
+        msg = "2, 3, or 4-element tuple required for 'distance_lte' lookup."
+        with self.assertRaisesMessage(ValueError, msg):  # Too many params.
+            len(
+                AustraliaCity.objects.filter(
+                    point__distance_lte=(
+                        "POINT(5 23)",
+                        D(km=100),
+                        "spheroid",
+                        "4",
+                        None,
+                    )
+                )
+            )
+
+        with self.assertRaisesMessage(ValueError, msg):  # Too few params.
+            len(AustraliaCity.objects.filter(point__distance_lte=("POINT(5 23)",)))
+
+        msg = "For 4-element tuples the last argument must be the 'spheroid' directive."
+        with self.assertRaisesMessage(ValueError, msg):
+            len(
+                AustraliaCity.objects.filter(
+                    point__distance_lte=("POINT(5 23)", D(km=100), "spheroid", "4")
+                )
+            )
+
+        # Getting all cities w/in 550 miles of Hobart.
+        hobart = AustraliaCity.objects.get(name="Hobart")
+        qs = AustraliaCity.objects.exclude(name="Hobart").filter(
+            point__distance_lte=(hobart.point, D(mi=550))
+        )
+        cities = self.get_names(qs)
+        self.assertEqual(cities, ["Batemans Bay", "Canberra", "Melbourne"])
+
+        # Cities that are either really close or really far from Wollongong --
+        # and using different units of distance.
+        wollongong = AustraliaCity.objects.get(name="Wollongong")
+        d1, d2 = D(yd=19500), D(nm=400)  # Yards (~17km) & Nautical miles.
+
+        # Normal geodetic distance lookup (uses `distance_sphere` on PostGIS.
+        gq1 = Q(point__distance_lte=(wollongong.point, d1))
+        gq2 = Q(point__distance_gte=(wollongong.point, d2))
+        qs1 = AustraliaCity.objects.exclude(name="Wollongong").filter(gq1 | gq2)
+
+        # Geodetic distance lookup but telling GeoDjango to use `distance_spheroid`
+        # instead (we should get the same results b/c accuracy variance won't matter
+        # in this test case).
+        querysets = [qs1]
+        if connection.features.has_DistanceSpheroid_function:
+            gq3 = Q(point__distance_lte=(wollongong.point, d1, "spheroid"))
+            gq4 = Q(point__distance_gte=(wollongong.point, d2, "spheroid"))
+            qs2 = AustraliaCity.objects.exclude(name="Wollongong").filter(gq3 | gq4)
+            querysets.append(qs2)
+
+        for qs in querysets:
+            cities = self.get_names(qs)
+            self.assertEqual(cities, ["Adelaide", "Hobart", "Shellharbour", "Thirroul"])
+
+    @skipUnlessDBFeature("supports_distances_lookups")
+    def test_distance_lookups_with_expression_rhs(self):
+        stx_pnt = self.stx_pnt.transform(
+            SouthTexasCity._meta.get_field("point").srid, clone=True
+        )
+        qs = SouthTexasCity.objects.filter(
+            point__distance_lte=(stx_pnt, F("radius")),
+        ).order_by("name")
+        self.assertEqual(
+            self.get_names(qs),
+            [
+                "Bellaire",
+                "Downtown Houston",
+                "Southside Place",
+                "West University Place",
+            ],
+        )
+
+        # With a combined expression
+        qs = SouthTexasCity.objects.filter(
+            point__distance_lte=(stx_pnt, F("radius") * 2),
+        ).order_by("name")
+        self.assertEqual(len(qs), 5)
+        self.assertIn("Pearland", self.get_names(qs))
+
+        # With spheroid param
+        if connection.features.supports_distance_geodetic:
+            hobart = AustraliaCity.objects.get(name="Hobart")
+            AustraliaCity.objects.update(ref_point=hobart.point)
+            for ref_point in [hobart.point, F("ref_point")]:
+                qs = AustraliaCity.objects.filter(
+                    point__distance_lte=(ref_point, F("radius") * 70, "spheroid"),
+                ).order_by("name")
+                self.assertEqual(
+                    self.get_names(qs), ["Canberra", "Hobart", "Melbourne"]
+                )
+
+        # With a complex geometry expression
+        self.assertFalse(
+            SouthTexasCity.objects.filter(
+                point__distance_gt=(Union("point", "point"), 0)
+            )
+        )
+        self.assertEqual(
+            SouthTexasCity.objects.filter(
+                point__distance_lte=(Union("point", "point"), 0)
+            ).count(),
+            SouthTexasCity.objects.count(),
+        )
+
+    @skipUnlessDBFeature("supports_distances_lookups")
+    def test_distance_annotation_group_by(self):
+        stx_pnt = self.stx_pnt.transform(
+            SouthTexasCity._meta.get_field("point").srid,
+            clone=True,
+        )
+        qs = (
+            SouthTexasCity.objects.annotate(
+                relative_distance=Case(
+                    When(point__distance_lte=(stx_pnt, D(km=20)), then=Value(20)),
+                    default=Value(100),
+                    output_field=IntegerField(),
+                ),
+            )
+            .values("relative_distance")
+            .annotate(count=Count("pk"))
+        )
+        self.assertCountEqual(
+            qs,
+            [
+                {"relative_distance": 20, "count": 5},
+                {"relative_distance": 100, "count": 4},
+            ],
+        )
+
+    def test_mysql_geodetic_distance_error(self):
+        if not connection.ops.mysql:
+            self.skipTest("This is a MySQL-specific test.")
+        msg = (
+            "Only numeric values of degree units are allowed on geodetic distance "
+            "queries."
+        )
+        with self.assertRaisesMessage(ValueError, msg):
+            AustraliaCity.objects.filter(
+                point__distance_lte=(Point(0, 0), D(m=100))
+            ).exists()
+
+    @skipUnlessDBFeature("supports_dwithin_lookup")
+    def test_dwithin_subquery(self):
+        """dwithin lookup in a subquery using OuterRef as a parameter."""
+        qs = CensusZipcode.objects.annotate(
+            annotated_value=Exists(
+                SouthTexasCity.objects.filter(
+                    point__dwithin=(OuterRef("poly"), D(m=10)),
+                )
+            )
+        ).filter(annotated_value=True)
+        self.assertEqual(self.get_names(qs), ["77002", "77025", "77401"])
+
+    @skipUnlessDBFeature("supports_dwithin_lookup", "supports_dwithin_distance_expr")
+    def test_dwithin_with_expression_rhs(self):
+        # LineString of Wollongong and Adelaide coords.
+        ls = LineString(((150.902, -34.4245), (138.6, -34.9258)), srid=4326)
+        qs = AustraliaCity.objects.filter(
+            point__dwithin=(ls, F("allowed_distance")),
+        ).order_by("name")
+        self.assertEqual(
+            self.get_names(qs),
+            ["Adelaide", "Mittagong", "Shellharbour", "Thirroul", "Wollongong"],
+        )
+
+    @skipIfDBFeature("supports_dwithin_distance_expr")
+    def test_dwithin_with_expression_rhs_not_supported(self):
+        ls = LineString(((150.902, -34.4245), (138.6, -34.9258)), srid=4326)
+        msg = (
+            "This backend does not support expressions for specifying "
+            "distance in the dwithin lookup."
+        )
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            list(
+                AustraliaCity.objects.filter(
+                    point__dwithin=(ls, F("allowed_distance")),
+                )
+            )
+
+
+"""
+=============================
+Distance functions on PostGIS
+=============================
+
+                                              | Projected Geometry | Lon/lat Geometry | Geography (4326)
+
+ST_Distance(geom1, geom2)                     |    OK (meters)     |   :-( (degrees)  |    OK (meters)
+
+ST_Distance(geom1, geom2, use_spheroid=False) |    N/A             |   N/A            |    OK (meters), less accurate, quick
+
+Distance_Sphere(geom1, geom2)                 |    N/A             |   OK (meters)    |    N/A
+
+Distance_Spheroid(geom1, geom2, spheroid)     |    N/A             |   OK (meters)    |    N/A
+
+ST_Perimeter(geom1)                           |    OK              |   :-( (degrees)  |    OK
+
+
+================================
+Distance functions on SpatiaLite
+================================
+
+                                                | Projected Geometry | Lon/lat Geometry
+
+ST_Distance(geom1, geom2)                       |    OK (meters)     |      N/A
+
+ST_Distance(geom1, geom2, use_ellipsoid=True)   |    N/A             |      OK (meters)
+
+ST_Distance(geom1, geom2, use_ellipsoid=False)  |    N/A             |      OK (meters), less accurate, quick
+
+Perimeter(geom1)                                |    OK              |      :-( (degrees)
+
+"""  # NOQA
+
+
+class DistanceFunctionsTests(FuncTestMixin, TestCase):
+    fixtures = ["initial"]
+
+    @skipUnlessDBFeature("has_Area_function")
+    def test_area(self):
+        # Reference queries:
+        # SELECT ST_Area(poly) FROM distapp_southtexaszipcode;
+        area_sq_m = [
+            5437908.90234375,
+            10183031.4389648,
+            11254471.0073242,
+            9881708.91772461,
+        ]
+        # Tolerance has to be lower for Oracle
+        tol = 2
+        for i, z in enumerate(
+            SouthTexasZipcode.objects.annotate(area=Area("poly")).order_by("name")
+        ):
+            self.assertAlmostEqual(area_sq_m[i], z.area.sq_m, tol)
+
+    @skipUnlessDBFeature("has_Distance_function")
+    def test_distance_simple(self):
+        """
+        Test a simple distance query, with projected coordinates and without
+        transformation.
+        """
+        lagrange = GEOSGeometry("POINT(805066.295722839 4231496.29461335)", 32140)
+        houston = (
+            SouthTexasCity.objects.annotate(dist=Distance("point", lagrange))
+            .order_by("id")
+            .first()
+        )
+        tol = 2 if connection.ops.oracle else 5
+        self.assertAlmostEqual(houston.dist.m, 147075.069813, tol)
+
+    @skipUnlessDBFeature("has_Distance_function", "has_Transform_function")
+    def test_distance_projected(self):
+        """
+        Test the `Distance` function on projected coordinate systems.
+        """
+        # The point for La Grange, TX
+        lagrange = GEOSGeometry("POINT(-96.876369 29.905320)", 4326)
+        # Reference distances in feet and in meters. Got these values from
+        # using the provided raw SQL statements.
+        #  SELECT ST_Distance(
+        #      point,
+        #      ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 32140)
+        #  )
+        #  FROM distapp_southtexascity;
+        m_distances = [
+            147075.069813,
+            139630.198056,
+            140888.552826,
+            138809.684197,
+            158309.246259,
+            212183.594374,
+            70870.188967,
+            165337.758878,
+            139196.085105,
+        ]
+        #  SELECT ST_Distance(
+        #      point,
+        #      ST_Transform(ST_GeomFromText('POINT(-96.876369 29.905320)', 4326), 2278)
+        #  )
+        #  FROM distapp_southtexascityft;
+        ft_distances = [
+            482528.79154625,
+            458103.408123001,
+            462231.860397575,
+            455411.438904354,
+            519386.252102563,
+            696139.009211594,
+            232513.278304279,
+            542445.630586414,
+            456679.155883207,
+        ]
+
+        # Testing using different variations of parameters and using models
+        # with different projected coordinate systems.
+        dist1 = SouthTexasCity.objects.annotate(
+            distance=Distance("point", lagrange)
+        ).order_by("id")
+        dist2 = SouthTexasCityFt.objects.annotate(
+            distance=Distance("point", lagrange)
+        ).order_by("id")
+        dist_qs = [dist1, dist2]
+
+        # Ensuring expected distances are returned for each distance queryset.
+        for qs in dist_qs:
+            for i, c in enumerate(qs):
+                with self.subTest(c=c):
+                    self.assertAlmostEqual(m_distances[i], c.distance.m, -1)
+                    self.assertAlmostEqual(ft_distances[i], c.distance.survey_ft, -1)
+
+    @skipUnlessDBFeature("has_Distance_function", "supports_distance_geodetic")
+    def test_distance_geodetic(self):
+        """
+        Test the `Distance` function on geodetic coordinate systems.
+        """
+        # Testing geodetic distance calculation with a non-point geometry
+        # (a LineString of Wollongong and Shellharbour coords).
+        ls = LineString(((150.902, -34.4245), (150.87, -34.5789)), srid=4326)
+
+        # Reference query:
+        #  SELECT ST_distance_sphere(
+        #      point,
+        #      ST_GeomFromText('LINESTRING(150.9020 -34.4245,150.8700 -34.5789)', 4326)
+        #  )
+        #  FROM distapp_australiacity ORDER BY name;
+        distances = [
+            1120954.92533513,
+            140575.720018241,
+            640396.662906304,
+            60580.9693849269,
+            972807.955955075,
+            568451.8357838,
+            40435.4335201384,
+            0,
+            68272.3896586844,
+            12375.0643697706,
+            0,
+        ]
+        qs = AustraliaCity.objects.annotate(distance=Distance("point", ls)).order_by(
+            "name"
+        )
+        for city, distance in zip(qs, distances):
+            with self.subTest(city=city, distance=distance):
+                # Testing equivalence to within a meter (kilometer on SpatiaLite).
+                tol = -3 if connection.ops.spatialite else 0
+                self.assertAlmostEqual(distance, city.distance.m, tol)
+
+    @skipUnlessDBFeature("has_Distance_function", "supports_distance_geodetic")
+    def test_distance_geodetic_spheroid(self):
+        tol = 2 if connection.ops.oracle else 4
+
+        # Got the reference distances using the raw SQL statements:
+        #  SELECT ST_distance_spheroid(
+        #      point,
+        #      ST_GeomFromText('POINT(151.231341 -33.952685)', 4326),
+        #      'SPHEROID["WGS 84",6378137.0,298.257223563]'
+        #  )
+        #  FROM distapp_australiacity WHERE (NOT (id = 11));
+        #  SELECT ST_distance_sphere(
+        #      point,
+        #      ST_GeomFromText('POINT(151.231341 -33.952685)', 4326)
+        #  )
+        #  FROM distapp_australiacity WHERE (NOT (id = 11));  st_distance_sphere
+        spheroid_distances = [
+            60504.0628957201,
+            77023.9489850262,
+            49154.8867574404,
+            90847.4358768573,
+            217402.811919332,
+            709599.234564757,
+            640011.483550888,
+            7772.00667991925,
+            1047861.78619339,
+            1165126.55236034,
+        ]
+        sphere_distances = [
+            60580.9693849267,
+            77144.0435286473,
+            49199.4415344719,
+            90804.7533823494,
+            217713.384600405,
+            709134.127242793,
+            639828.157159169,
+            7786.82949717788,
+            1049204.06569028,
+            1162623.7238134,
+        ]
+        # Testing with spheroid distances first.
+        hillsdale = AustraliaCity.objects.get(name="Hillsdale")
+        qs = (
+            AustraliaCity.objects.exclude(id=hillsdale.id)
+            .annotate(distance=Distance("point", hillsdale.point, spheroid=True))
+            .order_by("id")
+        )
+        for i, c in enumerate(qs):
+            with self.subTest(c=c):
+                self.assertAlmostEqual(spheroid_distances[i], c.distance.m, tol)
+        if connection.ops.postgis or connection.ops.spatialite:
+            # PostGIS uses sphere-only distances by default, testing these as well.
+            qs = (
+                AustraliaCity.objects.exclude(id=hillsdale.id)
+                .annotate(distance=Distance("point", hillsdale.point))
+                .order_by("id")
+            )
+            for i, c in enumerate(qs):
+                with self.subTest(c=c):
+                    self.assertAlmostEqual(sphere_distances[i], c.distance.m, tol)
+
+    @skipIfDBFeature("supports_distance_geodetic")
+    @skipUnlessDBFeature("has_Distance_function")
+    def test_distance_function_raw_result(self):
+        distance = (
+            Interstate.objects.annotate(
+                d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)),
+            )
+            .first()
+            .d
+        )
+        self.assertEqual(distance, 1)
+
+    @skipUnlessDBFeature("has_Distance_function")
+    def test_distance_function_d_lookup(self):
+        qs = Interstate.objects.annotate(
+            d=Distance(Point(0, 0, srid=3857), Point(0, 1, srid=3857)),
+        ).filter(d=D(m=1))
+        self.assertTrue(qs.exists())
+
+    @skipUnlessDBFeature("supports_tolerance_parameter")
+    def test_distance_function_tolerance_escaping(self):
+        qs = (
+            Interstate.objects.annotate(
+                d=Distance(
+                    Point(500, 500, srid=3857),
+                    Point(0, 0, srid=3857),
+                    tolerance="0.05) = 1 OR 1=1 OR (1+1",
+                ),
+            )
+            .filter(d=D(m=1))
+            .values("pk")
+        )
+        msg = "The tolerance parameter has the wrong type"
+        with self.assertRaisesMessage(TypeError, msg):
+            qs.exists()
+
+    @skipUnlessDBFeature("supports_tolerance_parameter")
+    def test_distance_function_tolerance(self):
+        # Tolerance is greater than distance.
+        qs = (
+            Interstate.objects.annotate(
+                d=Distance(
+                    Point(0, 0, srid=3857),
+                    Point(1, 1, srid=3857),
+                    tolerance=1.5,
+                ),
+            )
+            .filter(d=0)
+            .values("pk")
+        )
+        self.assertIs(qs.exists(), True)
+
+    @skipIfDBFeature("supports_distance_geodetic")
+    @skipUnlessDBFeature("has_Distance_function")
+    def test_distance_function_raw_result_d_lookup(self):
+        qs = Interstate.objects.annotate(
+            d=Distance(Point(0, 0, srid=4326), Point(0, 1, srid=4326)),
+        ).filter(d=D(m=1))
+        msg = "Distance measure is supplied, but units are unknown for result."
+        with self.assertRaisesMessage(ValueError, msg):
+            list(qs)
+
+    @skipUnlessDBFeature("has_Distance_function", "has_Transform_function")
+    def test_distance_transform(self):
+        """
+        Test the `Distance` function used with `Transform` on a geographic field.
+        """
+        # We'll be using a Polygon (created by buffering the centroid
+        # of 77005 to 100m) -- which aren't allowed in geographic distance
+        # queries normally, however our field has been transformed to
+        # a non-geographic system.
+        z = SouthTexasZipcode.objects.get(name="77005")
+
+        # Reference query:
+        # SELECT ST_Distance(ST_Transform("distapp_censuszipcode"."poly", 32140),
+        #   ST_GeomFromText('<buffer_wkt>', 32140))
+        # FROM "distapp_censuszipcode";
+        dists_m = [3553.30384972258, 1243.18391525602, 2186.15439472242]
+
+        # Having our buffer in the SRID of the transformation and of the field
+        # -- should get the same results. The first buffer has no need for
+        # transformation SQL because it is the same SRID as what was given
+        # to `transform()`.  The second buffer will need to be transformed,
+        # however.
+        buf1 = z.poly.centroid.buffer(100)
+        buf2 = buf1.transform(4269, clone=True)
+        ref_zips = ["77002", "77025", "77401"]
+
+        for buf in [buf1, buf2]:
+            qs = (
+                CensusZipcode.objects.exclude(name="77005")
+                .annotate(distance=Distance(Transform("poly", 32140), buf))
+                .order_by("name")
+            )
+            self.assertEqual(ref_zips, sorted(c.name for c in qs))
+            for i, z in enumerate(qs):
+                self.assertAlmostEqual(z.distance.m, dists_m[i], 5)
+
+    @skipUnlessDBFeature("has_Distance_function")
+    def test_distance_order_by(self):
+        qs = (
+            SouthTexasCity.objects.annotate(
+                distance=Distance("point", Point(3, 3, srid=32140))
+            )
+            .order_by("distance")
+            .values_list("name", flat=True)
+            .filter(name__in=("San Antonio", "Pearland"))
+        )
+        self.assertSequenceEqual(qs, ["San Antonio", "Pearland"])
+
+    @skipUnlessDBFeature("has_Length_function")
+    def test_length(self):
+        """
+        Test the `Length` function.
+        """
+        # Reference query (should use `length_spheroid`).
+        #  SELECT ST_length_spheroid(
+        #      ST_GeomFromText('<wkt>', 4326)
+        #      'SPHEROID["WGS 84",6378137,298.257223563, AUTHORITY["EPSG","7030"]]'
+        #  );
+        len_m1 = 473504.769553813
+        len_m2 = 4617.668
+
+        if connection.features.supports_length_geodetic:
+            qs = Interstate.objects.annotate(length=Length("path"))
+            tol = 2 if connection.ops.oracle else 3
+            self.assertAlmostEqual(len_m1, qs[0].length.m, tol)
+            # TODO: test with spheroid argument (True and False)
+        else:
+            # Does not support geodetic coordinate systems.
+            with self.assertRaises(NotSupportedError):
+                list(Interstate.objects.annotate(length=Length("path")))
+
+        # Now doing length on a projected coordinate system.
+        i10 = SouthTexasInterstate.objects.annotate(length=Length("path")).get(
+            name="I-10"
+        )
+        self.assertAlmostEqual(len_m2, i10.length.m, 2)
+        self.assertTrue(
+            SouthTexasInterstate.objects.annotate(length=Length("path"))
+            .filter(length__gt=4000)
+            .exists()
+        )
+        # Length with an explicit geometry value.
+        qs = Interstate.objects.annotate(length=Length(i10.path))
+        self.assertAlmostEqual(qs.first().length.m, len_m2, 2)
+
+    @skipUnlessDBFeature("has_Perimeter_function")
+    def test_perimeter(self):
+        """
+        Test the `Perimeter` function.
+        """
+        # Reference query:
+        #  SELECT ST_Perimeter(distapp_southtexaszipcode.poly)
+        #  FROM distapp_southtexaszipcode;
+        perim_m = [
+            18404.3550889361,
+            15627.2108551001,
+            20632.5588368978,
+            17094.5996143697,
+        ]
+        tol = 2 if connection.ops.oracle else 7
+        qs = SouthTexasZipcode.objects.annotate(perimeter=Perimeter("poly")).order_by(
+            "name"
+        )
+        for i, z in enumerate(qs):
+            self.assertAlmostEqual(perim_m[i], z.perimeter.m, tol)
+
+        # Running on points; should return 0.
+        qs = SouthTexasCity.objects.annotate(perim=Perimeter("point"))
+        for city in qs:
+            self.assertEqual(0, city.perim.m)
+
+    @skipUnlessDBFeature("has_Perimeter_function")
+    def test_perimeter_geodetic(self):
+        # Currently only Oracle supports calculating the perimeter on geodetic
+        # geometries (without being transformed).
+        qs1 = CensusZipcode.objects.annotate(perim=Perimeter("poly"))
+        if connection.features.supports_perimeter_geodetic:
+            self.assertAlmostEqual(qs1[0].perim.m, 18406.3818954314, 3)
+        else:
+            with self.assertRaises(NotSupportedError):
+                list(qs1)
+        # But should work fine when transformed to projected coordinates
+        qs2 = CensusZipcode.objects.annotate(
+            perim=Perimeter(Transform("poly", 32140))
+        ).filter(name="77002")
+        self.assertAlmostEqual(qs2[0].perim.m, 18404.355, 3)
+
+    @skipUnlessDBFeature(
+        "supports_null_geometries", "has_Area_function", "has_Distance_function"
+    )
+    def test_measurement_null_fields(self):
+        """
+        Test the measurement functions on fields with NULL values.
+        """
+        # Creating SouthTexasZipcode w/NULL value.
+        SouthTexasZipcode.objects.create(name="78212")
+        # Performing distance/area queries against the NULL PolygonField,
+        # and ensuring the result of the operations is None.
+        htown = SouthTexasCity.objects.get(name="Downtown Houston")
+        z = SouthTexasZipcode.objects.annotate(
+            distance=Distance("poly", htown.point), area=Area("poly")
+        ).get(name="78212")
+        self.assertIsNone(z.distance)
+        self.assertIsNone(z.area)

testbed/django__django/tests/gis_tests/gdal_tests/test_driver.py

@@ -0,0 +1,85 @@
+import unittest
+from unittest import mock
+
+from django.contrib.gis.gdal import Driver, GDALException
+
+valid_drivers = (
+    # vector
+    "ESRI Shapefile",
+    "MapInfo File",
+    "TIGER",
+    "S57",
+    "DGN",
+    "Memory",
+    "CSV",
+    "GML",
+    "KML",
+    # raster
+    "GTiff",
+    "JPEG",
+    "MEM",
+    "PNG",
+)
+
+invalid_drivers = ("Foo baz", "clucka", "ESRI Shp", "ESRI rast")
+
+aliases = {
+    "eSrI": "ESRI Shapefile",
+    "TigER/linE": "TIGER",
+    "SHAPE": "ESRI Shapefile",
+    "sHp": "ESRI Shapefile",
+    "tiFf": "GTiff",
+    "tIf": "GTiff",
+    "jPEg": "JPEG",
+    "jpG": "JPEG",
+}
+
+
+class DriverTest(unittest.TestCase):
+    def test01_valid_driver(self):
+        "Testing valid GDAL/OGR Data Source Drivers."
+        for d in valid_drivers:
+            dr = Driver(d)
+            self.assertEqual(d, str(dr))
+
+    def test02_invalid_driver(self):
+        "Testing invalid GDAL/OGR Data Source Drivers."
+        for i in invalid_drivers:
+            with self.assertRaises(GDALException):
+                Driver(i)
+
+    def test03_aliases(self):
+        "Testing driver aliases."
+        for alias, full_name in aliases.items():
+            dr = Driver(alias)
+            self.assertEqual(full_name, str(dr))
+
+    @mock.patch("django.contrib.gis.gdal.driver.vcapi.get_driver_count")
+    @mock.patch("django.contrib.gis.gdal.driver.rcapi.get_driver_count")
+    @mock.patch("django.contrib.gis.gdal.driver.vcapi.register_all")
+    @mock.patch("django.contrib.gis.gdal.driver.rcapi.register_all")
+    def test_registered(self, rreg, vreg, rcount, vcount):
+        """
+        Prototypes are registered only if their respective driver counts are
+        zero.
+        """
+
+        def check(rcount_val, vcount_val):
+            vreg.reset_mock()
+            rreg.reset_mock()
+            rcount.return_value = rcount_val
+            vcount.return_value = vcount_val
+            Driver.ensure_registered()
+            if rcount_val:
+                self.assertFalse(rreg.called)
+            else:
+                rreg.assert_called_once_with()
+            if vcount_val:
+                self.assertFalse(vreg.called)
+            else:
+                vreg.assert_called_once_with()
+
+        check(0, 0)
+        check(120, 0)
+        check(0, 120)
+        check(120, 120)

testbed/django__django/tests/gis_tests/gdal_tests/test_ds.py

@@ -0,0 +1,355 @@
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+
+from django.contrib.gis.gdal import DataSource, Envelope, GDALException, OGRGeometry
+from django.contrib.gis.gdal.field import OFTDateTime, OFTInteger, OFTReal, OFTString
+from django.contrib.gis.geos import GEOSGeometry
+from django.test import SimpleTestCase
+
+from ..test_data import TEST_DATA, TestDS, get_ds_file
+
+wgs_84_wkt = (
+    'GEOGCS["GCS_WGS_1984",DATUM["WGS_1984",SPHEROID["WGS_1984",'
+    '6378137,298.257223563]],PRIMEM["Greenwich",0],UNIT["Degree",'
+    "0.017453292519943295]]"
+)
+# Using a regex because of small differences depending on GDAL versions.
+wgs_84_wkt_regex = r'^GEOGCS\["(GCS_)?WGS[ _](19)?84".*$'
+
+datetime_format = "%Y-%m-%dT%H:%M:%S"
+
+# List of acceptable data sources.
+ds_list = (
+    TestDS(
+        "test_point",
+        nfeat=5,
+        nfld=3,
+        geom="POINT",
+        gtype=1,
+        driver="ESRI Shapefile",
+        fields={"dbl": OFTReal, "int": OFTInteger, "str": OFTString},
+        extent=(-1.35011, 0.166623, -0.524093, 0.824508),  # Got extent from QGIS
+        srs_wkt=wgs_84_wkt,
+        field_values={
+            "dbl": [float(i) for i in range(1, 6)],
+            "int": list(range(1, 6)),
+            "str": [str(i) for i in range(1, 6)],
+        },
+        fids=range(5),
+    ),
+    TestDS(
+        "test_vrt",
+        ext="vrt",
+        nfeat=3,
+        nfld=3,
+        geom="POINT",
+        gtype="Point25D",
+        driver="OGR_VRT",
+        fields={
+            "POINT_X": OFTString,
+            "POINT_Y": OFTString,
+            "NUM": OFTString,
+        },  # VRT uses CSV, which all types are OFTString.
+        extent=(1.0, 2.0, 100.0, 523.5),  # Min/Max from CSV
+        field_values={
+            "POINT_X": ["1.0", "5.0", "100.0"],
+            "POINT_Y": ["2.0", "23.0", "523.5"],
+            "NUM": ["5", "17", "23"],
+        },
+        fids=range(1, 4),
+    ),
+    TestDS(
+        "test_poly",
+        nfeat=3,
+        nfld=3,
+        geom="POLYGON",
+        gtype=3,
+        driver="ESRI Shapefile",
+        fields={"float": OFTReal, "int": OFTInteger, "str": OFTString},
+        extent=(-1.01513, -0.558245, 0.161876, 0.839637),  # Got extent from QGIS
+        srs_wkt=wgs_84_wkt,
+    ),
+    TestDS(
+        "has_nulls",
+        nfeat=3,
+        nfld=6,
+        geom="POLYGON",
+        gtype=3,
+        driver="GeoJSON",
+        ext="geojson",
+        fields={
+            "uuid": OFTString,
+            "name": OFTString,
+            "num": OFTReal,
+            "integer": OFTInteger,
+            "datetime": OFTDateTime,
+            "boolean": OFTInteger,
+        },
+        extent=(-75.274200, 39.846504, -74.959717, 40.119040),  # Got extent from QGIS
+        field_values={
+            "uuid": [
+                "1378c26f-cbe6-44b0-929f-eb330d4991f5",
+                "fa2ba67c-a135-4338-b924-a9622b5d869f",
+                "4494c1f3-55ab-4256-b365-12115cb388d5",
+            ],
+            "name": ["Philadelphia", None, "north"],
+            "num": [1.001, None, 0.0],
+            "integer": [5, None, 8],
+            "boolean": [True, None, False],
+            "datetime": [
+                datetime.strptime("1994-08-14T11:32:14", datetime_format),
+                None,
+                datetime.strptime("2018-11-29T03:02:52", datetime_format),
+            ],
+        },
+        fids=range(3),
+    ),
+)
+
+bad_ds = (TestDS("foo"),)
+
+
+class DataSourceTest(SimpleTestCase):
+    def test01_valid_shp(self):
+        "Testing valid SHP Data Source files."
+
+        for source in ds_list:
+            # Loading up the data source
+            ds = DataSource(source.ds)
+
+            # The layer count is what's expected (only 1 layer in a SHP file).
+            self.assertEqual(1, len(ds))
+
+            # Making sure GetName works
+            self.assertEqual(source.ds, ds.name)
+
+            # Making sure the driver name matches up
+            self.assertEqual(source.driver, str(ds.driver))
+
+            # Making sure indexing works
+            msg = "Index out of range when accessing layers in a datasource: %s."
+            with self.assertRaisesMessage(IndexError, msg % len(ds)):
+                ds.__getitem__(len(ds))
+
+            with self.assertRaisesMessage(
+                IndexError, "Invalid OGR layer name given: invalid."
+            ):
+                ds.__getitem__("invalid")
+
+    def test_ds_input_pathlib(self):
+        test_shp = Path(get_ds_file("test_point", "shp"))
+        ds = DataSource(test_shp)
+        self.assertEqual(len(ds), 1)
+
+    def test02_invalid_shp(self):
+        "Testing invalid SHP files for the Data Source."
+        for source in bad_ds:
+            with self.assertRaises(GDALException):
+                DataSource(source.ds)
+
+    def test03a_layers(self):
+        "Testing Data Source Layers."
+        for source in ds_list:
+            ds = DataSource(source.ds)
+
+            # Incrementing through each layer, this tests DataSource.__iter__
+            for layer in ds:
+                self.assertEqual(layer.name, source.name)
+                self.assertEqual(str(layer), source.name)
+                # Making sure we get the number of features we expect
+                self.assertEqual(len(layer), source.nfeat)
+
+                # Making sure we get the number of fields we expect
+                self.assertEqual(source.nfld, layer.num_fields)
+                self.assertEqual(source.nfld, len(layer.fields))
+
+                # Testing the layer's extent (an Envelope), and its properties
+                self.assertIsInstance(layer.extent, Envelope)
+                self.assertAlmostEqual(source.extent[0], layer.extent.min_x, 5)
+                self.assertAlmostEqual(source.extent[1], layer.extent.min_y, 5)
+                self.assertAlmostEqual(source.extent[2], layer.extent.max_x, 5)
+                self.assertAlmostEqual(source.extent[3], layer.extent.max_y, 5)
+
+                # Now checking the field names.
+                flds = layer.fields
+                for f in flds:
+                    self.assertIn(f, source.fields)
+
+                # Negative FIDs are not allowed.
+                with self.assertRaisesMessage(
+                    IndexError, "Negative indices are not allowed on OGR Layers."
+                ):
+                    layer.__getitem__(-1)
+                with self.assertRaisesMessage(IndexError, "Invalid feature id: 50000."):
+                    layer.__getitem__(50000)
+
+                if hasattr(source, "field_values"):
+                    # Testing `Layer.get_fields` (which uses Layer.__iter__)
+                    for fld_name, fld_value in source.field_values.items():
+                        self.assertEqual(fld_value, layer.get_fields(fld_name))
+
+                    # Testing `Layer.__getitem__`.
+                    for i, fid in enumerate(source.fids):
+                        feat = layer[fid]
+                        self.assertEqual(fid, feat.fid)
+                        # Maybe this should be in the test below, but we might
+                        # as well test the feature values here while in this
+                        # loop.
+                        for fld_name, fld_value in source.field_values.items():
+                            self.assertEqual(fld_value[i], feat.get(fld_name))
+
+                        msg = (
+                            "Index out of range when accessing field in a feature: %s."
+                        )
+                        with self.assertRaisesMessage(IndexError, msg % len(feat)):
+                            feat.__getitem__(len(feat))
+
+                        with self.assertRaisesMessage(
+                            IndexError, "Invalid OFT field name given: invalid."
+                        ):
+                            feat.__getitem__("invalid")
+
+    def test03b_layer_slice(self):
+        "Test indexing and slicing on Layers."
+        # Using the first data-source because the same slice
+        # can be used for both the layer and the control values.
+        source = ds_list[0]
+        ds = DataSource(source.ds)
+
+        sl = slice(1, 3)
+        feats = ds[0][sl]
+
+        for fld_name in ds[0].fields:
+            test_vals = [feat.get(fld_name) for feat in feats]
+            control_vals = source.field_values[fld_name][sl]
+            self.assertEqual(control_vals, test_vals)
+
+    def test03c_layer_references(self):
+        """
+        Ensure OGR objects keep references to the objects they belong to.
+        """
+        source = ds_list[0]
+
+        # See ticket #9448.
+        def get_layer():
+            # This DataSource object is not accessible outside this
+            # scope.  However, a reference should still be kept alive
+            # on the `Layer` returned.
+            ds = DataSource(source.ds)
+            return ds[0]
+
+        # Making sure we can call OGR routines on the Layer returned.
+        lyr = get_layer()
+        self.assertEqual(source.nfeat, len(lyr))
+        self.assertEqual(source.gtype, lyr.geom_type.num)
+
+        # Same issue for Feature/Field objects, see #18640
+        self.assertEqual(str(lyr[0]["str"]), "1")
+
+    def test04_features(self):
+        "Testing Data Source Features."
+        for source in ds_list:
+            ds = DataSource(source.ds)
+
+            # Incrementing through each layer
+            for layer in ds:
+                # Incrementing through each feature in the layer
+                for feat in layer:
+                    # Making sure the number of fields, and the geometry type
+                    # are what's expected.
+                    self.assertEqual(source.nfld, len(list(feat)))
+                    self.assertEqual(source.gtype, feat.geom_type)
+
+                    # Making sure the fields match to an appropriate OFT type.
+                    for k, v in source.fields.items():
+                        # Making sure we get the proper OGR Field instance, using
+                        # a string value index for the feature.
+                        self.assertIsInstance(feat[k], v)
+                    self.assertIsInstance(feat.fields[0], str)
+
+                    # Testing Feature.__iter__
+                    for fld in feat:
+                        self.assertIn(fld.name, source.fields)
+
+    def test05_geometries(self):
+        "Testing Geometries from Data Source Features."
+        for source in ds_list:
+            ds = DataSource(source.ds)
+
+            # Incrementing through each layer and feature.
+            for layer in ds:
+                geoms = layer.get_geoms()
+                geos_geoms = layer.get_geoms(geos=True)
+                self.assertEqual(len(geoms), len(geos_geoms))
+                self.assertEqual(len(geoms), len(layer))
+                for feat, geom, geos_geom in zip(layer, geoms, geos_geoms):
+                    g = feat.geom
+                    self.assertEqual(geom, g)
+                    self.assertIsInstance(geos_geom, GEOSGeometry)
+                    self.assertEqual(g, geos_geom.ogr)
+                    # Making sure we get the right Geometry name & type
+                    self.assertEqual(source.geom, g.geom_name)
+                    self.assertEqual(source.gtype, g.geom_type)
+
+                    # Making sure the SpatialReference is as expected.
+                    if hasattr(source, "srs_wkt"):
+                        self.assertIsNotNone(re.match(wgs_84_wkt_regex, g.srs.wkt))
+
+    def test06_spatial_filter(self):
+        "Testing the Layer.spatial_filter property."
+        ds = DataSource(get_ds_file("cities", "shp"))
+        lyr = ds[0]
+
+        # When not set, it should be None.
+        self.assertIsNone(lyr.spatial_filter)
+
+        # Must be set a/an OGRGeometry or 4-tuple.
+        with self.assertRaises(TypeError):
+            lyr._set_spatial_filter("foo")
+
+        # Setting the spatial filter with a tuple/list with the extent of
+        # a buffer centering around Pueblo.
+        with self.assertRaises(ValueError):
+            lyr._set_spatial_filter(list(range(5)))
+        filter_extent = (-105.609252, 37.255001, -103.609252, 39.255001)
+        lyr.spatial_filter = (-105.609252, 37.255001, -103.609252, 39.255001)
+        self.assertEqual(OGRGeometry.from_bbox(filter_extent), lyr.spatial_filter)
+        feats = [feat for feat in lyr]
+        self.assertEqual(1, len(feats))
+        self.assertEqual("Pueblo", feats[0].get("Name"))
+
+        # Setting the spatial filter with an OGRGeometry for buffer centering
+        # around Houston.
+        filter_geom = OGRGeometry(
+            "POLYGON((-96.363151 28.763374,-94.363151 28.763374,"
+            "-94.363151 30.763374,-96.363151 30.763374,-96.363151 28.763374))"
+        )
+        lyr.spatial_filter = filter_geom
+        self.assertEqual(filter_geom, lyr.spatial_filter)
+        feats = [feat for feat in lyr]
+        self.assertEqual(1, len(feats))
+        self.assertEqual("Houston", feats[0].get("Name"))
+
+        # Clearing the spatial filter by setting it to None.  Now
+        # should indicate that there are 3 features in the Layer.
+        lyr.spatial_filter = None
+        self.assertEqual(3, len(lyr))
+
+    def test07_integer_overflow(self):
+        "Testing that OFTReal fields, treated as OFTInteger, do not overflow."
+        # Using *.dbf from Census 2010 TIGER Shapefile for Texas,
+        # which has land area ('ALAND10') stored in a Real field
+        # with no precision.
+        ds = DataSource(os.path.join(TEST_DATA, "texas.dbf"))
+        feat = ds[0][0]
+        # Reference value obtained using `ogrinfo`.
+        self.assertEqual(676586997978, feat.get("ALAND10"))
+
+    def test_nonexistent_field(self):
+        source = ds_list[0]
+        ds = DataSource(source.ds)
+        msg = "invalid field name: nonexistent"
+        with self.assertRaisesMessage(GDALException, msg):
+            ds[0].get_fields("nonexistent")

testbed/django__django/tests/gis_tests/gdal_tests/test_envelope.py

@@ -0,0 +1,93 @@
+import unittest
+
+from django.contrib.gis.gdal import Envelope, GDALException
+
+
+class TestPoint:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+
+class EnvelopeTest(unittest.TestCase):
+    def setUp(self):
+        self.e = Envelope(0, 0, 5, 5)
+
+    def test01_init(self):
+        "Testing Envelope initialization."
+        e1 = Envelope((0, 0, 5, 5))
+        Envelope(0, 0, 5, 5)
+        Envelope(0, "0", "5", 5)  # Thanks to ww for this
+        Envelope(e1._envelope)
+        with self.assertRaises(GDALException):
+            Envelope((5, 5, 0, 0))
+        with self.assertRaises(GDALException):
+            Envelope(5, 5, 0, 0)
+        with self.assertRaises(GDALException):
+            Envelope((0, 0, 5, 5, 3))
+        with self.assertRaises(GDALException):
+            Envelope(())
+        with self.assertRaises(ValueError):
+            Envelope(0, "a", 5, 5)
+        with self.assertRaises(TypeError):
+            Envelope("foo")
+        with self.assertRaises(GDALException):
+            Envelope((1, 1, 0, 0))
+        # Shouldn't raise an exception for min_x == max_x or min_y == max_y
+        Envelope(0, 0, 0, 0)
+
+    def test02_properties(self):
+        "Testing Envelope properties."
+        e = Envelope(0, 0, 2, 3)
+        self.assertEqual(0, e.min_x)
+        self.assertEqual(0, e.min_y)
+        self.assertEqual(2, e.max_x)
+        self.assertEqual(3, e.max_y)
+        self.assertEqual((0, 0), e.ll)
+        self.assertEqual((2, 3), e.ur)
+        self.assertEqual((0, 0, 2, 3), e.tuple)
+        self.assertEqual("POLYGON((0.0 0.0,0.0 3.0,2.0 3.0,2.0 0.0,0.0 0.0))", e.wkt)
+        self.assertEqual("(0.0, 0.0, 2.0, 3.0)", str(e))
+
+    def test03_equivalence(self):
+        "Testing Envelope equivalence."
+        e1 = Envelope(0.523, 0.217, 253.23, 523.69)
+        e2 = Envelope((0.523, 0.217, 253.23, 523.69))
+        self.assertEqual(e1, e2)
+        self.assertEqual((0.523, 0.217, 253.23, 523.69), e1)
+
+    def test04_expand_to_include_pt_2_params(self):
+        "Testing Envelope expand_to_include -- point as two parameters."
+        self.e.expand_to_include(2, 6)
+        self.assertEqual((0, 0, 5, 6), self.e)
+        self.e.expand_to_include(-1, -1)
+        self.assertEqual((-1, -1, 5, 6), self.e)
+
+    def test05_expand_to_include_pt_2_tuple(self):
+        "Testing Envelope expand_to_include -- point as a single 2-tuple parameter."
+        self.e.expand_to_include((10, 10))
+        self.assertEqual((0, 0, 10, 10), self.e)
+        self.e.expand_to_include((-10, -10))
+        self.assertEqual((-10, -10, 10, 10), self.e)
+
+    def test06_expand_to_include_extent_4_params(self):
+        "Testing Envelope expand_to_include -- extent as 4 parameters."
+        self.e.expand_to_include(-1, 1, 3, 7)
+        self.assertEqual((-1, 0, 5, 7), self.e)
+
+    def test06_expand_to_include_extent_4_tuple(self):
+        "Testing Envelope expand_to_include -- extent as a single 4-tuple parameter."
+        self.e.expand_to_include((-1, 1, 3, 7))
+        self.assertEqual((-1, 0, 5, 7), self.e)
+
+    def test07_expand_to_include_envelope(self):
+        "Testing Envelope expand_to_include with Envelope as parameter."
+        self.e.expand_to_include(Envelope(-1, 1, 3, 7))
+        self.assertEqual((-1, 0, 5, 7), self.e)
+
+    def test08_expand_to_include_point(self):
+        "Testing Envelope expand_to_include with Point as parameter."
+        self.e.expand_to_include(TestPoint(-1, 1))
+        self.assertEqual((-1, 0, 5, 5), self.e)
+        self.e.expand_to_include(TestPoint(10, 10))
+        self.assertEqual((-1, 0, 10, 10), self.e)

testbed/django__django/tests/gis_tests/gdal_tests/test_geom.py

@@ -0,0 +1,634 @@
+import json
+import pickle
+
+from django.contrib.gis.gdal import (
+    CoordTransform,
+    GDALException,
+    OGRGeometry,
+    OGRGeomType,
+    SpatialReference,
+)
+from django.template import Context
+from django.template.engine import Engine
+from django.test import SimpleTestCase
+
+from ..test_data import TestDataMixin
+
+
+class OGRGeomTest(SimpleTestCase, TestDataMixin):
+    "This tests the OGR Geometry."
+
+    def test_geomtype(self):
+        "Testing OGRGeomType object."
+
+        # OGRGeomType should initialize on all these inputs.
+        OGRGeomType(1)
+        OGRGeomType(7)
+        OGRGeomType("point")
+        OGRGeomType("GeometrycollectioN")
+        OGRGeomType("LINearrING")
+        OGRGeomType("Unknown")
+
+        # Should throw TypeError on this input
+        with self.assertRaises(GDALException):
+            OGRGeomType(23)
+        with self.assertRaises(GDALException):
+            OGRGeomType("fooD")
+        with self.assertRaises(GDALException):
+            OGRGeomType(9)
+
+        # Equivalence can take strings, ints, and other OGRGeomTypes
+        self.assertEqual(OGRGeomType(1), OGRGeomType(1))
+        self.assertEqual(OGRGeomType(7), "GeometryCollection")
+        self.assertEqual(OGRGeomType("point"), "POINT")
+        self.assertNotEqual(OGRGeomType("point"), 2)
+        self.assertEqual(OGRGeomType("unknown"), 0)
+        self.assertEqual(OGRGeomType(6), "MULtiPolyGON")
+        self.assertEqual(OGRGeomType(1), OGRGeomType("point"))
+        self.assertNotEqual(OGRGeomType("POINT"), OGRGeomType(6))
+
+        # Testing the Django field name equivalent property.
+        self.assertEqual("PointField", OGRGeomType("Point").django)
+        self.assertEqual("GeometryField", OGRGeomType("Geometry").django)
+        self.assertEqual("GeometryField", OGRGeomType("Unknown").django)
+        self.assertIsNone(OGRGeomType("none").django)
+
+        # 'Geometry' initialization implies an unknown geometry type.
+        gt = OGRGeomType("Geometry")
+        self.assertEqual(0, gt.num)
+        self.assertEqual("Unknown", gt.name)
+
+    def test_geomtype_25d(self):
+        "Testing OGRGeomType object with 25D types."
+        wkb25bit = OGRGeomType.wkb25bit
+        self.assertEqual(OGRGeomType(wkb25bit + 1), "Point25D")
+        self.assertEqual(OGRGeomType("MultiLineString25D"), (5 + wkb25bit))
+        self.assertEqual(
+            "GeometryCollectionField", OGRGeomType("GeometryCollection25D").django
+        )
+
+    def test_wkt(self):
+        "Testing WKT output."
+        for g in self.geometries.wkt_out:
+            geom = OGRGeometry(g.wkt)
+            self.assertEqual(g.wkt, geom.wkt)
+
+    def test_ewkt(self):
+        "Testing EWKT input/output."
+        for ewkt_val in ("POINT (1 2 3)", "LINEARRING (0 0,1 1,2 1,0 0)"):
+            # First with ewkt output when no SRID in EWKT
+            self.assertEqual(ewkt_val, OGRGeometry(ewkt_val).ewkt)
+            # No test consumption with an SRID specified.
+            ewkt_val = "SRID=4326;%s" % ewkt_val
+            geom = OGRGeometry(ewkt_val)
+            self.assertEqual(ewkt_val, geom.ewkt)
+            self.assertEqual(4326, geom.srs.srid)
+
+    def test_gml(self):
+        "Testing GML output."
+        for g in self.geometries.wkt_out:
+            geom = OGRGeometry(g.wkt)
+            exp_gml = g.gml
+            self.assertEqual(exp_gml, geom.gml)
+
+    def test_hex(self):
+        "Testing HEX input/output."
+        for g in self.geometries.hex_wkt:
+            geom1 = OGRGeometry(g.wkt)
+            self.assertEqual(g.hex.encode(), geom1.hex)
+            # Constructing w/HEX
+            geom2 = OGRGeometry(g.hex)
+            self.assertEqual(geom1, geom2)
+
+    def test_wkb(self):
+        "Testing WKB input/output."
+        for g in self.geometries.hex_wkt:
+            geom1 = OGRGeometry(g.wkt)
+            wkb = geom1.wkb
+            self.assertEqual(wkb.hex().upper(), g.hex)
+            # Constructing w/WKB.
+            geom2 = OGRGeometry(wkb)
+            self.assertEqual(geom1, geom2)
+
+    def test_json(self):
+        "Testing GeoJSON input/output."
+        for g in self.geometries.json_geoms:
+            geom = OGRGeometry(g.wkt)
+            if not hasattr(g, "not_equal"):
+                # Loading jsons to prevent decimal differences
+                self.assertEqual(json.loads(g.json), json.loads(geom.json))
+                self.assertEqual(json.loads(g.json), json.loads(geom.geojson))
+            self.assertEqual(OGRGeometry(g.wkt), OGRGeometry(geom.json))
+        # Test input with some garbage content (but valid json) (#15529)
+        geom = OGRGeometry(
+            '{"type": "Point", "coordinates": [ 100.0, 0.0 ], "other": "<test>"}'
+        )
+        self.assertIsInstance(geom, OGRGeometry)
+
+    def test_points(self):
+        "Testing Point objects."
+
+        OGRGeometry("POINT(0 0)")
+        for p in self.geometries.points:
+            if not hasattr(p, "z"):  # No 3D
+                pnt = OGRGeometry(p.wkt)
+                self.assertEqual(1, pnt.geom_type)
+                self.assertEqual("POINT", pnt.geom_name)
+                self.assertEqual(p.x, pnt.x)
+                self.assertEqual(p.y, pnt.y)
+                self.assertEqual((p.x, p.y), pnt.tuple)
+
+    def test_multipoints(self):
+        "Testing MultiPoint objects."
+        for mp in self.geometries.multipoints:
+            mgeom1 = OGRGeometry(mp.wkt)  # First one from WKT
+            self.assertEqual(4, mgeom1.geom_type)
+            self.assertEqual("MULTIPOINT", mgeom1.geom_name)
+            mgeom2 = OGRGeometry("MULTIPOINT")  # Creating empty multipoint
+            mgeom3 = OGRGeometry("MULTIPOINT")
+            for g in mgeom1:
+                mgeom2.add(g)  # adding each point from the multipoints
+                mgeom3.add(g.wkt)  # should take WKT as well
+            self.assertEqual(mgeom1, mgeom2)  # they should equal
+            self.assertEqual(mgeom1, mgeom3)
+            self.assertEqual(mp.coords, mgeom2.coords)
+            self.assertEqual(mp.n_p, mgeom2.point_count)
+
+    def test_linestring(self):
+        "Testing LineString objects."
+        prev = OGRGeometry("POINT(0 0)")
+        for ls in self.geometries.linestrings:
+            linestr = OGRGeometry(ls.wkt)
+            self.assertEqual(2, linestr.geom_type)
+            self.assertEqual("LINESTRING", linestr.geom_name)
+            self.assertEqual(ls.n_p, linestr.point_count)
+            self.assertEqual(ls.coords, linestr.tuple)
+            self.assertEqual(linestr, OGRGeometry(ls.wkt))
+            self.assertNotEqual(linestr, prev)
+            msg = "Index out of range when accessing points of a line string: %s."
+            with self.assertRaisesMessage(IndexError, msg % len(linestr)):
+                linestr.__getitem__(len(linestr))
+            prev = linestr
+
+            # Testing the x, y properties.
+            x = [tmpx for tmpx, tmpy in ls.coords]
+            y = [tmpy for tmpx, tmpy in ls.coords]
+            self.assertEqual(x, linestr.x)
+            self.assertEqual(y, linestr.y)
+
+    def test_multilinestring(self):
+        "Testing MultiLineString objects."
+        prev = OGRGeometry("POINT(0 0)")
+        for mls in self.geometries.multilinestrings:
+            mlinestr = OGRGeometry(mls.wkt)
+            self.assertEqual(5, mlinestr.geom_type)
+            self.assertEqual("MULTILINESTRING", mlinestr.geom_name)
+            self.assertEqual(mls.n_p, mlinestr.point_count)
+            self.assertEqual(mls.coords, mlinestr.tuple)
+            self.assertEqual(mlinestr, OGRGeometry(mls.wkt))
+            self.assertNotEqual(mlinestr, prev)
+            prev = mlinestr
+            for ls in mlinestr:
+                self.assertEqual(2, ls.geom_type)
+                self.assertEqual("LINESTRING", ls.geom_name)
+            msg = "Index out of range when accessing geometry in a collection: %s."
+            with self.assertRaisesMessage(IndexError, msg % len(mlinestr)):
+                mlinestr.__getitem__(len(mlinestr))
+
+    def test_linearring(self):
+        "Testing LinearRing objects."
+        prev = OGRGeometry("POINT(0 0)")
+        for rr in self.geometries.linearrings:
+            lr = OGRGeometry(rr.wkt)
+            # self.assertEqual(101, lr.geom_type.num)
+            self.assertEqual("LINEARRING", lr.geom_name)
+            self.assertEqual(rr.n_p, len(lr))
+            self.assertEqual(lr, OGRGeometry(rr.wkt))
+            self.assertNotEqual(lr, prev)
+            prev = lr
+
+    def test_polygons(self):
+        "Testing Polygon objects."
+
+        # Testing `from_bbox` class method
+        bbox = (-180, -90, 180, 90)
+        p = OGRGeometry.from_bbox(bbox)
+        self.assertEqual(bbox, p.extent)
+
+        prev = OGRGeometry("POINT(0 0)")
+        for p in self.geometries.polygons:
+            poly = OGRGeometry(p.wkt)
+            self.assertEqual(3, poly.geom_type)
+            self.assertEqual("POLYGON", poly.geom_name)
+            self.assertEqual(p.n_p, poly.point_count)
+            self.assertEqual(p.n_i + 1, len(poly))
+            msg = "Index out of range when accessing rings of a polygon: %s."
+            with self.assertRaisesMessage(IndexError, msg % len(poly)):
+                poly.__getitem__(len(poly))
+
+            # Testing area & centroid.
+            self.assertAlmostEqual(p.area, poly.area, 9)
+            x, y = poly.centroid.tuple
+            self.assertAlmostEqual(p.centroid[0], x, 9)
+            self.assertAlmostEqual(p.centroid[1], y, 9)
+
+            # Testing equivalence
+            self.assertEqual(poly, OGRGeometry(p.wkt))
+            self.assertNotEqual(poly, prev)
+
+            if p.ext_ring_cs:
+                ring = poly[0]
+                self.assertEqual(p.ext_ring_cs, ring.tuple)
+                self.assertEqual(p.ext_ring_cs, poly[0].tuple)
+                self.assertEqual(len(p.ext_ring_cs), ring.point_count)
+
+            for r in poly:
+                self.assertEqual("LINEARRING", r.geom_name)
+
+    def test_polygons_templates(self):
+        # Accessing Polygon attributes in templates should work.
+        engine = Engine()
+        template = engine.from_string("{{ polygons.0.wkt }}")
+        polygons = [OGRGeometry(p.wkt) for p in self.geometries.multipolygons[:2]]
+        content = template.render(Context({"polygons": polygons}))
+        self.assertIn("MULTIPOLYGON (((100", content)
+
+    def test_closepolygons(self):
+        "Testing closing Polygon objects."
+        # Both rings in this geometry are not closed.
+        poly = OGRGeometry("POLYGON((0 0, 5 0, 5 5, 0 5), (1 1, 2 1, 2 2, 2 1))")
+        self.assertEqual(8, poly.point_count)
+        with self.assertRaises(GDALException):
+            poly.centroid
+
+        poly.close_rings()
+        self.assertEqual(
+            10, poly.point_count
+        )  # Two closing points should've been added
+        self.assertEqual(OGRGeometry("POINT(2.5 2.5)"), poly.centroid)
+
+    def test_multipolygons(self):
+        "Testing MultiPolygon objects."
+        OGRGeometry("POINT(0 0)")
+        for mp in self.geometries.multipolygons:
+            mpoly = OGRGeometry(mp.wkt)
+            self.assertEqual(6, mpoly.geom_type)
+            self.assertEqual("MULTIPOLYGON", mpoly.geom_name)
+            if mp.valid:
+                self.assertEqual(mp.n_p, mpoly.point_count)
+                self.assertEqual(mp.num_geom, len(mpoly))
+                msg = "Index out of range when accessing geometry in a collection: %s."
+                with self.assertRaisesMessage(IndexError, msg % len(mpoly)):
+                    mpoly.__getitem__(len(mpoly))
+                for p in mpoly:
+                    self.assertEqual("POLYGON", p.geom_name)
+                    self.assertEqual(3, p.geom_type)
+            self.assertEqual(mpoly.wkt, OGRGeometry(mp.wkt).wkt)
+
+    def test_srs(self):
+        "Testing OGR Geometries with Spatial Reference objects."
+        for mp in self.geometries.multipolygons:
+            # Creating a geometry w/spatial reference
+            sr = SpatialReference("WGS84")
+            mpoly = OGRGeometry(mp.wkt, sr)
+            self.assertEqual(sr.wkt, mpoly.srs.wkt)
+
+            # Ensuring that SRS is propagated to clones.
+            klone = mpoly.clone()
+            self.assertEqual(sr.wkt, klone.srs.wkt)
+
+            # Ensuring all children geometries (polygons and their rings) all
+            # return the assigned spatial reference as well.
+            for poly in mpoly:
+                self.assertEqual(sr.wkt, poly.srs.wkt)
+                for ring in poly:
+                    self.assertEqual(sr.wkt, ring.srs.wkt)
+
+            # Ensuring SRS propagate in topological ops.
+            a = OGRGeometry(self.geometries.topology_geoms[0].wkt_a, sr)
+            b = OGRGeometry(self.geometries.topology_geoms[0].wkt_b, sr)
+            diff = a.difference(b)
+            union = a.union(b)
+            self.assertEqual(sr.wkt, diff.srs.wkt)
+            self.assertEqual(sr.srid, union.srs.srid)
+
+            # Instantiating w/an integer SRID
+            mpoly = OGRGeometry(mp.wkt, 4326)
+            self.assertEqual(4326, mpoly.srid)
+            mpoly.srs = SpatialReference(4269)
+            self.assertEqual(4269, mpoly.srid)
+            self.assertEqual("NAD83", mpoly.srs.name)
+
+            # Incrementing through the multipolygon after the spatial reference
+            # has been re-assigned.
+            for poly in mpoly:
+                self.assertEqual(mpoly.srs.wkt, poly.srs.wkt)
+                poly.srs = 32140
+                for ring in poly:
+                    # Changing each ring in the polygon
+                    self.assertEqual(32140, ring.srs.srid)
+                    self.assertEqual("NAD83 / Texas South Central", ring.srs.name)
+                    ring.srs = str(SpatialReference(4326))  # back to WGS84
+                    self.assertEqual(4326, ring.srs.srid)
+
+                    # Using the `srid` property.
+                    ring.srid = 4322
+                    self.assertEqual("WGS 72", ring.srs.name)
+                    self.assertEqual(4322, ring.srid)
+
+            # srs/srid may be assigned their own values, even when srs is None.
+            mpoly = OGRGeometry(mp.wkt, srs=None)
+            mpoly.srs = mpoly.srs
+            mpoly.srid = mpoly.srid
+
+    def test_srs_transform(self):
+        "Testing transform()."
+        orig = OGRGeometry("POINT (-104.609 38.255)", 4326)
+        trans = OGRGeometry("POINT (992385.4472045 481455.4944650)", 2774)
+
+        # Using an srid, a SpatialReference object, and a CoordTransform object
+        # or transformations.
+        t1, t2, t3 = orig.clone(), orig.clone(), orig.clone()
+        t1.transform(trans.srid)
+        t2.transform(SpatialReference("EPSG:2774"))
+        ct = CoordTransform(SpatialReference("WGS84"), SpatialReference(2774))
+        t3.transform(ct)
+
+        # Testing use of the `clone` keyword.
+        k1 = orig.clone()
+        k2 = k1.transform(trans.srid, clone=True)
+        self.assertEqual(k1, orig)
+        self.assertNotEqual(k1, k2)
+
+        # Different PROJ versions use different transformations, all are
+        # correct as having a 1 meter accuracy.
+        prec = -1
+        for p in (t1, t2, t3, k2):
+            self.assertAlmostEqual(trans.x, p.x, prec)
+            self.assertAlmostEqual(trans.y, p.y, prec)
+
+    def test_transform_dim(self):
+        "Testing coordinate dimension is the same on transformed geometries."
+        ls_orig = OGRGeometry("LINESTRING(-104.609 38.255)", 4326)
+        ls_trans = OGRGeometry("LINESTRING(992385.4472045 481455.4944650)", 2774)
+
+        # Different PROJ versions use different transformations, all are
+        # correct as having a 1 meter accuracy.
+        prec = -1
+        ls_orig.transform(ls_trans.srs)
+        # Making sure the coordinate dimension is still 2D.
+        self.assertEqual(2, ls_orig.coord_dim)
+        self.assertAlmostEqual(ls_trans.x[0], ls_orig.x[0], prec)
+        self.assertAlmostEqual(ls_trans.y[0], ls_orig.y[0], prec)
+
+    def test_difference(self):
+        "Testing difference()."
+        for i in range(len(self.geometries.topology_geoms)):
+            a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
+            b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
+            d1 = OGRGeometry(self.geometries.diff_geoms[i].wkt)
+            d2 = a.difference(b)
+            self.assertTrue(d1.geos.equals(d2.geos))
+            self.assertTrue(
+                d1.geos.equals((a - b).geos)
+            )  # __sub__ is difference operator
+            a -= b  # testing __isub__
+            self.assertTrue(d1.geos.equals(a.geos))
+
+    def test_intersection(self):
+        "Testing intersects() and intersection()."
+        for i in range(len(self.geometries.topology_geoms)):
+            a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
+            b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
+            i1 = OGRGeometry(self.geometries.intersect_geoms[i].wkt)
+            self.assertTrue(a.intersects(b))
+            i2 = a.intersection(b)
+            self.assertTrue(i1.geos.equals(i2.geos))
+            self.assertTrue(
+                i1.geos.equals((a & b).geos)
+            )  # __and__ is intersection operator
+            a &= b  # testing __iand__
+            self.assertTrue(i1.geos.equals(a.geos))
+
+    def test_symdifference(self):
+        "Testing sym_difference()."
+        for i in range(len(self.geometries.topology_geoms)):
+            a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
+            b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
+            d1 = OGRGeometry(self.geometries.sdiff_geoms[i].wkt)
+            d2 = a.sym_difference(b)
+            self.assertTrue(d1.geos.equals(d2.geos))
+            self.assertTrue(
+                d1.geos.equals((a ^ b).geos)
+            )  # __xor__ is symmetric difference operator
+            a ^= b  # testing __ixor__
+            self.assertTrue(d1.geos.equals(a.geos))
+
+    def test_union(self):
+        "Testing union()."
+        for i in range(len(self.geometries.topology_geoms)):
+            a = OGRGeometry(self.geometries.topology_geoms[i].wkt_a)
+            b = OGRGeometry(self.geometries.topology_geoms[i].wkt_b)
+            u1 = OGRGeometry(self.geometries.union_geoms[i].wkt)
+            u2 = a.union(b)
+            self.assertTrue(u1.geos.equals(u2.geos))
+            self.assertTrue(u1.geos.equals((a | b).geos))  # __or__ is union operator
+            a |= b  # testing __ior__
+            self.assertTrue(u1.geos.equals(a.geos))
+
+    def test_add(self):
+        "Testing GeometryCollection.add()."
+        # Can't insert a Point into a MultiPolygon.
+        mp = OGRGeometry("MultiPolygon")
+        pnt = OGRGeometry("POINT(5 23)")
+        with self.assertRaises(GDALException):
+            mp.add(pnt)
+
+        # GeometryCollection.add may take an OGRGeometry (if another collection
+        # of the same type all child geoms will be added individually) or WKT.
+        for mp in self.geometries.multipolygons:
+            mpoly = OGRGeometry(mp.wkt)
+            mp1 = OGRGeometry("MultiPolygon")
+            mp2 = OGRGeometry("MultiPolygon")
+            mp3 = OGRGeometry("MultiPolygon")
+
+            for poly in mpoly:
+                mp1.add(poly)  # Adding a geometry at a time
+                mp2.add(poly.wkt)  # Adding WKT
+            mp3.add(mpoly)  # Adding a MultiPolygon's entire contents at once.
+            for tmp in (mp1, mp2, mp3):
+                self.assertEqual(mpoly, tmp)
+
+    def test_extent(self):
+        "Testing `extent` property."
+        # The xmin, ymin, xmax, ymax of the MultiPoint should be returned.
+        mp = OGRGeometry("MULTIPOINT(5 23, 0 0, 10 50)")
+        self.assertEqual((0.0, 0.0, 10.0, 50.0), mp.extent)
+        # Testing on the 'real world' Polygon.
+        poly = OGRGeometry(self.geometries.polygons[3].wkt)
+        ring = poly.shell
+        x, y = ring.x, ring.y
+        xmin, ymin = min(x), min(y)
+        xmax, ymax = max(x), max(y)
+        self.assertEqual((xmin, ymin, xmax, ymax), poly.extent)
+
+    def test_25D(self):
+        "Testing 2.5D geometries."
+        pnt_25d = OGRGeometry("POINT(1 2 3)")
+        self.assertEqual("Point25D", pnt_25d.geom_type.name)
+        self.assertEqual(3.0, pnt_25d.z)
+        self.assertEqual(3, pnt_25d.coord_dim)
+        ls_25d = OGRGeometry("LINESTRING(1 1 1,2 2 2,3 3 3)")
+        self.assertEqual("LineString25D", ls_25d.geom_type.name)
+        self.assertEqual([1.0, 2.0, 3.0], ls_25d.z)
+        self.assertEqual(3, ls_25d.coord_dim)
+
+    def test_pickle(self):
+        "Testing pickle support."
+        g1 = OGRGeometry("LINESTRING(1 1 1,2 2 2,3 3 3)", "WGS84")
+        g2 = pickle.loads(pickle.dumps(g1))
+        self.assertEqual(g1, g2)
+        self.assertEqual(4326, g2.srs.srid)
+        self.assertEqual(g1.srs.wkt, g2.srs.wkt)
+
+    def test_ogrgeometry_transform_workaround(self):
+        "Testing coordinate dimensions on geometries after transformation."
+        # A bug in GDAL versions prior to 1.7 changes the coordinate
+        # dimension of a geometry after it has been transformed.
+        # This test ensures that the bug workarounds employed within
+        # `OGRGeometry.transform` indeed work.
+        wkt_2d = "MULTILINESTRING ((0 0,1 1,2 2))"
+        wkt_3d = "MULTILINESTRING ((0 0 0,1 1 1,2 2 2))"
+        srid = 4326
+
+        # For both the 2D and 3D MultiLineString, ensure _both_ the dimension
+        # of the collection and the component LineString have the expected
+        # coordinate dimension after transform.
+        geom = OGRGeometry(wkt_2d, srid)
+        geom.transform(srid)
+        self.assertEqual(2, geom.coord_dim)
+        self.assertEqual(2, geom[0].coord_dim)
+        self.assertEqual(wkt_2d, geom.wkt)
+
+        geom = OGRGeometry(wkt_3d, srid)
+        geom.transform(srid)
+        self.assertEqual(3, geom.coord_dim)
+        self.assertEqual(3, geom[0].coord_dim)
+        self.assertEqual(wkt_3d, geom.wkt)
+
+    # Testing binary predicates, `assertIs` is used to check that bool is returned.
+
+    def test_equivalence_regression(self):
+        "Testing equivalence methods with non-OGRGeometry instances."
+        self.assertIsNotNone(OGRGeometry("POINT(0 0)"))
+        self.assertNotEqual(OGRGeometry("LINESTRING(0 0, 1 1)"), 3)
+
+    def test_contains(self):
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").contains(OGRGeometry("POINT(0 0)")), True
+        )
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").contains(OGRGeometry("POINT(0 1)")), False
+        )
+
+    def test_crosses(self):
+        self.assertIs(
+            OGRGeometry("LINESTRING(0 0, 1 1)").crosses(
+                OGRGeometry("LINESTRING(0 1, 1 0)")
+            ),
+            True,
+        )
+        self.assertIs(
+            OGRGeometry("LINESTRING(0 0, 0 1)").crosses(
+                OGRGeometry("LINESTRING(1 0, 1 1)")
+            ),
+            False,
+        )
+
+    def test_disjoint(self):
+        self.assertIs(
+            OGRGeometry("LINESTRING(0 0, 1 1)").disjoint(
+                OGRGeometry("LINESTRING(0 1, 1 0)")
+            ),
+            False,
+        )
+        self.assertIs(
+            OGRGeometry("LINESTRING(0 0, 0 1)").disjoint(
+                OGRGeometry("LINESTRING(1 0, 1 1)")
+            ),
+            True,
+        )
+
+    def test_equals(self):
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").contains(OGRGeometry("POINT(0 0)")), True
+        )
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").contains(OGRGeometry("POINT(0 1)")), False
+        )
+
+    def test_intersects(self):
+        self.assertIs(
+            OGRGeometry("LINESTRING(0 0, 1 1)").intersects(
+                OGRGeometry("LINESTRING(0 1, 1 0)")
+            ),
+            True,
+        )
+        self.assertIs(
+            OGRGeometry("LINESTRING(0 0, 0 1)").intersects(
+                OGRGeometry("LINESTRING(1 0, 1 1)")
+            ),
+            False,
+        )
+
+    def test_overlaps(self):
+        self.assertIs(
+            OGRGeometry("POLYGON ((0 0, 0 2, 2 2, 2 0, 0 0))").overlaps(
+                OGRGeometry("POLYGON ((1 1, 1 5, 5 5, 5 1, 1 1))")
+            ),
+            True,
+        )
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").overlaps(OGRGeometry("POINT(0 1)")), False
+        )
+
+    def test_touches(self):
+        self.assertIs(
+            OGRGeometry("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))").touches(
+                OGRGeometry("LINESTRING(0 2, 2 0)")
+            ),
+            True,
+        )
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").touches(OGRGeometry("POINT(0 1)")), False
+        )
+
+    def test_within(self):
+        self.assertIs(
+            OGRGeometry("POINT(0.5 0.5)").within(
+                OGRGeometry("POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))")
+            ),
+            True,
+        )
+        self.assertIs(
+            OGRGeometry("POINT(0 0)").within(OGRGeometry("POINT(0 1)")), False
+        )
+
+    def test_from_gml(self):
+        self.assertEqual(
+            OGRGeometry("POINT(0 0)"),
+            OGRGeometry.from_gml(
+                '<gml:Point gml:id="p21" '
+                'srsName="http://www.opengis.net/def/crs/EPSG/0/4326">'
+                '    <gml:pos srsDimension="2">0 0</gml:pos>'
+                "</gml:Point>"
+            ),
+        )
+
+    def test_empty(self):
+        self.assertIs(OGRGeometry("POINT (0 0)").empty, False)
+        self.assertIs(OGRGeometry("POINT EMPTY").empty, True)
+
+    def test_empty_point_to_geos(self):
+        p = OGRGeometry("POINT EMPTY", srs=4326)
+        self.assertEqual(p.geos.ewkt, p.ewkt)

testbed/django__django/tests/gis_tests/gdal_tests/test_raster.py

@@ -0,0 +1,991 @@
+import os
+import shutil
+import struct
+import tempfile
+import zipfile
+from pathlib import Path
+from unittest import mock
+
+from django.contrib.gis.gdal import GDAL_VERSION, GDALRaster, SpatialReference
+from django.contrib.gis.gdal.error import GDALException
+from django.contrib.gis.gdal.raster.band import GDALBand
+from django.contrib.gis.shortcuts import numpy
+from django.core.files.temp import NamedTemporaryFile
+from django.test import SimpleTestCase
+
+from ..data.rasters.textrasters import JSON_RASTER
+
+
+class GDALRasterTests(SimpleTestCase):
+    """
+    Test a GDALRaster instance created from a file (GeoTiff).
+    """
+
+    def setUp(self):
+        self.rs_path = os.path.join(
+            os.path.dirname(__file__), "../data/rasters/raster.tif"
+        )
+        self.rs = GDALRaster(self.rs_path)
+
+    def test_gdalraster_input_as_path(self):
+        rs_path = Path(__file__).parent.parent / "data" / "rasters" / "raster.tif"
+        rs = GDALRaster(rs_path)
+        self.assertEqual(str(rs_path), rs.name)
+
+    def test_rs_name_repr(self):
+        self.assertEqual(self.rs_path, self.rs.name)
+        self.assertRegex(repr(self.rs), r"<Raster object at 0x\w+>")
+
+    def test_rs_driver(self):
+        self.assertEqual(self.rs.driver.name, "GTiff")
+
+    def test_rs_size(self):
+        self.assertEqual(self.rs.width, 163)
+        self.assertEqual(self.rs.height, 174)
+
+    def test_rs_srs(self):
+        self.assertEqual(self.rs.srs.srid, 3086)
+        self.assertEqual(self.rs.srs.units, (1.0, "metre"))
+
+    def test_rs_srid(self):
+        rast = GDALRaster(
+            {
+                "width": 16,
+                "height": 16,
+                "srid": 4326,
+            }
+        )
+        self.assertEqual(rast.srid, 4326)
+        rast.srid = 3086
+        self.assertEqual(rast.srid, 3086)
+
+    def test_geotransform_and_friends(self):
+        # Assert correct values for file based raster
+        self.assertEqual(
+            self.rs.geotransform,
+            [511700.4680706557, 100.0, 0.0, 435103.3771231986, 0.0, -100.0],
+        )
+        self.assertEqual(self.rs.origin, [511700.4680706557, 435103.3771231986])
+        self.assertEqual(self.rs.origin.x, 511700.4680706557)
+        self.assertEqual(self.rs.origin.y, 435103.3771231986)
+        self.assertEqual(self.rs.scale, [100.0, -100.0])
+        self.assertEqual(self.rs.scale.x, 100.0)
+        self.assertEqual(self.rs.scale.y, -100.0)
+        self.assertEqual(self.rs.skew, [0, 0])
+        self.assertEqual(self.rs.skew.x, 0)
+        self.assertEqual(self.rs.skew.y, 0)
+        # Create in-memory rasters and change gtvalues
+        rsmem = GDALRaster(JSON_RASTER)
+        # geotransform accepts both floats and ints
+        rsmem.geotransform = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0]
+        self.assertEqual(rsmem.geotransform, [0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
+        rsmem.geotransform = range(6)
+        self.assertEqual(rsmem.geotransform, [float(x) for x in range(6)])
+        self.assertEqual(rsmem.origin, [0, 3])
+        self.assertEqual(rsmem.origin.x, 0)
+        self.assertEqual(rsmem.origin.y, 3)
+        self.assertEqual(rsmem.scale, [1, 5])
+        self.assertEqual(rsmem.scale.x, 1)
+        self.assertEqual(rsmem.scale.y, 5)
+        self.assertEqual(rsmem.skew, [2, 4])
+        self.assertEqual(rsmem.skew.x, 2)
+        self.assertEqual(rsmem.skew.y, 4)
+        self.assertEqual(rsmem.width, 5)
+        self.assertEqual(rsmem.height, 5)
+
+    def test_geotransform_bad_inputs(self):
+        rsmem = GDALRaster(JSON_RASTER)
+        error_geotransforms = [
+            [1, 2],
+            [1, 2, 3, 4, 5, "foo"],
+            [1, 2, 3, 4, 5, 6, "foo"],
+        ]
+        msg = "Geotransform must consist of 6 numeric values."
+        for geotransform in error_geotransforms:
+            with self.subTest(i=geotransform), self.assertRaisesMessage(
+                ValueError, msg
+            ):
+                rsmem.geotransform = geotransform
+
+    def test_rs_extent(self):
+        self.assertEqual(
+            self.rs.extent,
+            (
+                511700.4680706557,
+                417703.3771231986,
+                528000.4680706557,
+                435103.3771231986,
+            ),
+        )
+
+    def test_rs_bands(self):
+        self.assertEqual(len(self.rs.bands), 1)
+        self.assertIsInstance(self.rs.bands[0], GDALBand)
+
+    def test_memory_based_raster_creation(self):
+        # Create uint8 raster with full pixel data range (0-255)
+        rast = GDALRaster(
+            {
+                "datatype": 1,
+                "width": 16,
+                "height": 16,
+                "srid": 4326,
+                "bands": [
+                    {
+                        "data": range(256),
+                        "nodata_value": 255,
+                    }
+                ],
+            }
+        )
+
+        # Get array from raster
+        result = rast.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+
+        # Assert data is same as original input
+        self.assertEqual(result, list(range(256)))
+
+    def test_file_based_raster_creation(self):
+        # Prepare tempfile
+        rstfile = NamedTemporaryFile(suffix=".tif")
+
+        # Create file-based raster from scratch
+        GDALRaster(
+            {
+                "datatype": self.rs.bands[0].datatype(),
+                "driver": "tif",
+                "name": rstfile.name,
+                "width": 163,
+                "height": 174,
+                "nr_of_bands": 1,
+                "srid": self.rs.srs.wkt,
+                "origin": (self.rs.origin.x, self.rs.origin.y),
+                "scale": (self.rs.scale.x, self.rs.scale.y),
+                "skew": (self.rs.skew.x, self.rs.skew.y),
+                "bands": [
+                    {
+                        "data": self.rs.bands[0].data(),
+                        "nodata_value": self.rs.bands[0].nodata_value,
+                    }
+                ],
+            }
+        )
+
+        # Reload newly created raster from file
+        restored_raster = GDALRaster(rstfile.name)
+        # Presence of TOWGS84 depend on GDAL/Proj versions.
+        self.assertEqual(
+            restored_raster.srs.wkt.replace("TOWGS84[0,0,0,0,0,0,0],", ""),
+            self.rs.srs.wkt.replace("TOWGS84[0,0,0,0,0,0,0],", ""),
+        )
+        self.assertEqual(restored_raster.geotransform, self.rs.geotransform)
+        if numpy:
+            numpy.testing.assert_equal(
+                restored_raster.bands[0].data(), self.rs.bands[0].data()
+            )
+        else:
+            self.assertEqual(restored_raster.bands[0].data(), self.rs.bands[0].data())
+
+    def test_nonexistent_file(self):
+        msg = 'Unable to read raster source input "nonexistent.tif".'
+        with self.assertRaisesMessage(GDALException, msg):
+            GDALRaster("nonexistent.tif")
+
+    def test_vsi_raster_creation(self):
+        # Open a raster as a file object.
+        with open(self.rs_path, "rb") as dat:
+            # Instantiate a raster from the file binary buffer.
+            vsimem = GDALRaster(dat.read())
+        # The data of the in-memory file is equal to the source file.
+        result = vsimem.bands[0].data()
+        target = self.rs.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+            target = target.flatten().tolist()
+        self.assertEqual(result, target)
+
+    def test_vsi_raster_deletion(self):
+        path = "/vsimem/raster.tif"
+        # Create a vsi-based raster from scratch.
+        vsimem = GDALRaster(
+            {
+                "name": path,
+                "driver": "tif",
+                "width": 4,
+                "height": 4,
+                "srid": 4326,
+                "bands": [
+                    {
+                        "data": range(16),
+                    }
+                ],
+            }
+        )
+        # The virtual file exists.
+        rst = GDALRaster(path)
+        self.assertEqual(rst.width, 4)
+        # Delete GDALRaster.
+        del vsimem
+        del rst
+        # The virtual file has been removed.
+        msg = 'Could not open the datasource at "/vsimem/raster.tif"'
+        with self.assertRaisesMessage(GDALException, msg):
+            GDALRaster(path)
+
+    def test_vsi_invalid_buffer_error(self):
+        msg = "Failed creating VSI raster from the input buffer."
+        with self.assertRaisesMessage(GDALException, msg):
+            GDALRaster(b"not-a-raster-buffer")
+
+    def test_vsi_buffer_property(self):
+        # Create a vsi-based raster from scratch.
+        rast = GDALRaster(
+            {
+                "name": "/vsimem/raster.tif",
+                "driver": "tif",
+                "width": 4,
+                "height": 4,
+                "srid": 4326,
+                "bands": [
+                    {
+                        "data": range(16),
+                    }
+                ],
+            }
+        )
+        # Do a round trip from raster to buffer to raster.
+        result = GDALRaster(rast.vsi_buffer).bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        # Band data is equal to nodata value except on input block of ones.
+        self.assertEqual(result, list(range(16)))
+        # The vsi buffer is None for rasters that are not vsi based.
+        self.assertIsNone(self.rs.vsi_buffer)
+
+    def test_vsi_vsizip_filesystem(self):
+        rst_zipfile = NamedTemporaryFile(suffix=".zip")
+        with zipfile.ZipFile(rst_zipfile, mode="w") as zf:
+            zf.write(self.rs_path, "raster.tif")
+        rst_path = "/vsizip/" + os.path.join(rst_zipfile.name, "raster.tif")
+        rst = GDALRaster(rst_path)
+        self.assertEqual(rst.driver.name, self.rs.driver.name)
+        self.assertEqual(rst.name, rst_path)
+        self.assertIs(rst.is_vsi_based, True)
+        self.assertIsNone(rst.vsi_buffer)
+
+    def test_offset_size_and_shape_on_raster_creation(self):
+        rast = GDALRaster(
+            {
+                "datatype": 1,
+                "width": 4,
+                "height": 4,
+                "srid": 4326,
+                "bands": [
+                    {
+                        "data": (1,),
+                        "offset": (1, 1),
+                        "size": (2, 2),
+                        "shape": (1, 1),
+                        "nodata_value": 2,
+                    }
+                ],
+            }
+        )
+        # Get array from raster.
+        result = rast.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        # Band data is equal to nodata value except on input block of ones.
+        self.assertEqual(result, [2, 2, 2, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 2, 2, 2])
+
+    def test_set_nodata_value_on_raster_creation(self):
+        # Create raster filled with nodata values.
+        rast = GDALRaster(
+            {
+                "datatype": 1,
+                "width": 2,
+                "height": 2,
+                "srid": 4326,
+                "bands": [{"nodata_value": 23}],
+            }
+        )
+        # Get array from raster.
+        result = rast.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        # All band data is equal to nodata value.
+        self.assertEqual(result, [23] * 4)
+
+    def test_set_nodata_none_on_raster_creation(self):
+        # Create raster without data and without nodata value.
+        rast = GDALRaster(
+            {
+                "datatype": 1,
+                "width": 2,
+                "height": 2,
+                "srid": 4326,
+                "bands": [{"nodata_value": None}],
+            }
+        )
+        # Get array from raster.
+        result = rast.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        # Band data is equal to zero because no nodata value has been specified.
+        self.assertEqual(result, [0] * 4)
+
+    def test_raster_metadata_property(self):
+        data = self.rs.metadata
+        self.assertEqual(data["DEFAULT"], {"AREA_OR_POINT": "Area"})
+        self.assertEqual(data["IMAGE_STRUCTURE"], {"INTERLEAVE": "BAND"})
+
+        # Create file-based raster from scratch
+        source = GDALRaster(
+            {
+                "datatype": 1,
+                "width": 2,
+                "height": 2,
+                "srid": 4326,
+                "bands": [{"data": range(4), "nodata_value": 99}],
+            }
+        )
+        # Set metadata on raster and on a band.
+        metadata = {
+            "DEFAULT": {"OWNER": "Django", "VERSION": "1.0", "AREA_OR_POINT": "Point"},
+        }
+        source.metadata = metadata
+        source.bands[0].metadata = metadata
+        self.assertEqual(source.metadata["DEFAULT"], metadata["DEFAULT"])
+        self.assertEqual(source.bands[0].metadata["DEFAULT"], metadata["DEFAULT"])
+        # Update metadata on raster.
+        metadata = {
+            "DEFAULT": {"VERSION": "2.0"},
+        }
+        source.metadata = metadata
+        self.assertEqual(source.metadata["DEFAULT"]["VERSION"], "2.0")
+        # Remove metadata on raster.
+        metadata = {
+            "DEFAULT": {"OWNER": None},
+        }
+        source.metadata = metadata
+        self.assertNotIn("OWNER", source.metadata["DEFAULT"])
+
+    def test_raster_info_accessor(self):
+        infos = self.rs.info
+        # Data
+        info_lines = [line.strip() for line in infos.split("\n") if line.strip() != ""]
+        for line in [
+            "Driver: GTiff/GeoTIFF",
+            "Files: {}".format(self.rs_path),
+            "Size is 163, 174",
+            "Origin = (511700.468070655711927,435103.377123198588379)",
+            "Pixel Size = (100.000000000000000,-100.000000000000000)",
+            "Metadata:",
+            "AREA_OR_POINT=Area",
+            "Image Structure Metadata:",
+            "INTERLEAVE=BAND",
+            "Band 1 Block=163x50 Type=Byte, ColorInterp=Gray",
+            "NoData Value=15",
+        ]:
+            self.assertIn(line, info_lines)
+        for line in [
+            r"Upper Left  \(  511700.468,  435103.377\) "
+            r'\( 82d51\'46.1\d"W, 27d55\' 1.5\d"N\)',
+            r"Lower Left  \(  511700.468,  417703.377\) "
+            r'\( 82d51\'52.0\d"W, 27d45\'37.5\d"N\)',
+            r"Upper Right \(  528000.468,  435103.377\) "
+            r'\( 82d41\'48.8\d"W, 27d54\'56.3\d"N\)',
+            r"Lower Right \(  528000.468,  417703.377\) "
+            r'\( 82d41\'55.5\d"W, 27d45\'32.2\d"N\)',
+            r"Center      \(  519850.468,  426403.377\) "
+            r'\( 82d46\'50.6\d"W, 27d50\'16.9\d"N\)',
+        ]:
+            self.assertRegex(infos, line)
+        # CRS (skip the name because string depends on the GDAL/Proj versions).
+        self.assertIn("NAD83 / Florida GDL Albers", infos)
+
+    def test_compressed_file_based_raster_creation(self):
+        rstfile = NamedTemporaryFile(suffix=".tif")
+        # Make a compressed copy of an existing raster.
+        compressed = self.rs.warp(
+            {"papsz_options": {"compress": "packbits"}, "name": rstfile.name}
+        )
+        # Check physically if compression worked.
+        self.assertLess(os.path.getsize(compressed.name), os.path.getsize(self.rs.name))
+        # Create file-based raster with options from scratch.
+        papsz_options = {
+            "compress": "packbits",
+            "blockxsize": 23,
+            "blockysize": 23,
+        }
+        if GDAL_VERSION < (3, 7):
+            datatype = 1
+            papsz_options["pixeltype"] = "signedbyte"
+        else:
+            datatype = 14
+        compressed = GDALRaster(
+            {
+                "datatype": datatype,
+                "driver": "tif",
+                "name": rstfile.name,
+                "width": 40,
+                "height": 40,
+                "srid": 3086,
+                "origin": (500000, 400000),
+                "scale": (100, -100),
+                "skew": (0, 0),
+                "bands": [
+                    {
+                        "data": range(40 ^ 2),
+                        "nodata_value": 255,
+                    }
+                ],
+                "papsz_options": papsz_options,
+            }
+        )
+        # Check if options used on creation are stored in metadata.
+        # Reopening the raster ensures that all metadata has been written
+        # to the file.
+        compressed = GDALRaster(compressed.name)
+        self.assertEqual(
+            compressed.metadata["IMAGE_STRUCTURE"]["COMPRESSION"],
+            "PACKBITS",
+        )
+        self.assertEqual(compressed.bands[0].datatype(), datatype)
+        if GDAL_VERSION < (3, 7):
+            self.assertEqual(
+                compressed.bands[0].metadata["IMAGE_STRUCTURE"]["PIXELTYPE"],
+                "SIGNEDBYTE",
+            )
+        self.assertIn("Block=40x23", compressed.info)
+
+    def test_raster_warp(self):
+        # Create in memory raster
+        source = GDALRaster(
+            {
+                "datatype": 1,
+                "driver": "MEM",
+                "name": "sourceraster",
+                "width": 4,
+                "height": 4,
+                "nr_of_bands": 1,
+                "srid": 3086,
+                "origin": (500000, 400000),
+                "scale": (100, -100),
+                "skew": (0, 0),
+                "bands": [
+                    {
+                        "data": range(16),
+                        "nodata_value": 255,
+                    }
+                ],
+            }
+        )
+
+        # Test altering the scale, width, and height of a raster
+        data = {
+            "scale": [200, -200],
+            "width": 2,
+            "height": 2,
+        }
+        target = source.warp(data)
+        self.assertEqual(target.width, data["width"])
+        self.assertEqual(target.height, data["height"])
+        self.assertEqual(target.scale, data["scale"])
+        self.assertEqual(target.bands[0].datatype(), source.bands[0].datatype())
+        self.assertEqual(target.name, "sourceraster_copy.MEM")
+        result = target.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        self.assertEqual(result, [5, 7, 13, 15])
+
+        # Test altering the name and datatype (to float)
+        data = {
+            "name": "/path/to/targetraster.tif",
+            "datatype": 6,
+        }
+        target = source.warp(data)
+        self.assertEqual(target.bands[0].datatype(), 6)
+        self.assertEqual(target.name, "/path/to/targetraster.tif")
+        self.assertEqual(target.driver.name, "MEM")
+        result = target.bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        self.assertEqual(
+            result,
+            [
+                0.0,
+                1.0,
+                2.0,
+                3.0,
+                4.0,
+                5.0,
+                6.0,
+                7.0,
+                8.0,
+                9.0,
+                10.0,
+                11.0,
+                12.0,
+                13.0,
+                14.0,
+                15.0,
+            ],
+        )
+
+    def test_raster_warp_nodata_zone(self):
+        # Create in memory raster.
+        source = GDALRaster(
+            {
+                "datatype": 1,
+                "driver": "MEM",
+                "width": 4,
+                "height": 4,
+                "srid": 3086,
+                "origin": (500000, 400000),
+                "scale": (100, -100),
+                "skew": (0, 0),
+                "bands": [
+                    {
+                        "data": range(16),
+                        "nodata_value": 23,
+                    }
+                ],
+            }
+        )
+        # Warp raster onto a location that does not cover any pixels of the original.
+        result = source.warp({"origin": (200000, 200000)}).bands[0].data()
+        if numpy:
+            result = result.flatten().tolist()
+        # The result is an empty raster filled with the correct nodata value.
+        self.assertEqual(result, [23] * 16)
+
+    def test_raster_clone(self):
+        rstfile = NamedTemporaryFile(suffix=".tif")
+        tests = [
+            ("MEM", "", 23),  # In memory raster.
+            ("tif", rstfile.name, 99),  # In file based raster.
+        ]
+        for driver, name, nodata_value in tests:
+            with self.subTest(driver=driver):
+                source = GDALRaster(
+                    {
+                        "datatype": 1,
+                        "driver": driver,
+                        "name": name,
+                        "width": 4,
+                        "height": 4,
+                        "srid": 3086,
+                        "origin": (500000, 400000),
+                        "scale": (100, -100),
+                        "skew": (0, 0),
+                        "bands": [
+                            {
+                                "data": range(16),
+                                "nodata_value": nodata_value,
+                            }
+                        ],
+                    }
+                )
+                clone = source.clone()
+                self.assertNotEqual(clone.name, source.name)
+                self.assertEqual(clone._write, source._write)
+                self.assertEqual(clone.srs.srid, source.srs.srid)
+                self.assertEqual(clone.width, source.width)
+                self.assertEqual(clone.height, source.height)
+                self.assertEqual(clone.origin, source.origin)
+                self.assertEqual(clone.scale, source.scale)
+                self.assertEqual(clone.skew, source.skew)
+                self.assertIsNot(clone, source)
+
+    def test_raster_transform(self):
+        tests = [
+            3086,
+            "3086",
+            SpatialReference(3086),
+        ]
+        for srs in tests:
+            with self.subTest(srs=srs):
+                # Prepare tempfile and nodata value.
+                rstfile = NamedTemporaryFile(suffix=".tif")
+                ndv = 99
+                # Create in file based raster.
+                source = GDALRaster(
+                    {
+                        "datatype": 1,
+                        "driver": "tif",
+                        "name": rstfile.name,
+                        "width": 5,
+                        "height": 5,
+                        "nr_of_bands": 1,
+                        "srid": 4326,
+                        "origin": (-5, 5),
+                        "scale": (2, -2),
+                        "skew": (0, 0),
+                        "bands": [
+                            {
+                                "data": range(25),
+                                "nodata_value": ndv,
+                            }
+                        ],
+                    }
+                )
+
+                target = source.transform(srs)
+
+                # Reload data from disk.
+                target = GDALRaster(target.name)
+                self.assertEqual(target.srs.srid, 3086)
+                self.assertEqual(target.width, 7)
+                self.assertEqual(target.height, 7)
+                self.assertEqual(target.bands[0].datatype(), source.bands[0].datatype())
+                self.assertAlmostEqual(target.origin[0], 9124842.791079799, 3)
+                self.assertAlmostEqual(target.origin[1], 1589911.6476407414, 3)
+                self.assertAlmostEqual(target.scale[0], 223824.82664250192, 3)
+                self.assertAlmostEqual(target.scale[1], -223824.82664250192, 3)
+                self.assertEqual(target.skew, [0, 0])
+
+                result = target.bands[0].data()
+                if numpy:
+                    result = result.flatten().tolist()
+                # The reprojection of a raster that spans over a large area
+                # skews the data matrix and might introduce nodata values.
+                self.assertEqual(
+                    result,
+                    [
+                        ndv,
+                        ndv,
+                        ndv,
+                        ndv,
+                        4,
+                        ndv,
+                        ndv,
+                        ndv,
+                        ndv,
+                        2,
+                        3,
+                        9,
+                        ndv,
+                        ndv,
+                        ndv,
+                        1,
+                        2,
+                        8,
+                        13,
+                        19,
+                        ndv,
+                        0,
+                        6,
+                        6,
+                        12,
+                        18,
+                        18,
+                        24,
+                        ndv,
+                        10,
+                        11,
+                        16,
+                        22,
+                        23,
+                        ndv,
+                        ndv,
+                        ndv,
+                        15,
+                        21,
+                        22,
+                        ndv,
+                        ndv,
+                        ndv,
+                        ndv,
+                        20,
+                        ndv,
+                        ndv,
+                        ndv,
+                        ndv,
+                    ],
+                )
+
+    def test_raster_transform_clone(self):
+        with mock.patch.object(GDALRaster, "clone") as mocked_clone:
+            # Create in file based raster.
+            rstfile = NamedTemporaryFile(suffix=".tif")
+            source = GDALRaster(
+                {
+                    "datatype": 1,
+                    "driver": "tif",
+                    "name": rstfile.name,
+                    "width": 5,
+                    "height": 5,
+                    "nr_of_bands": 1,
+                    "srid": 4326,
+                    "origin": (-5, 5),
+                    "scale": (2, -2),
+                    "skew": (0, 0),
+                    "bands": [
+                        {
+                            "data": range(25),
+                            "nodata_value": 99,
+                        }
+                    ],
+                }
+            )
+            # transform() returns a clone because it is the same SRID and
+            # driver.
+            source.transform(4326)
+            self.assertEqual(mocked_clone.call_count, 1)
+
+    def test_raster_transform_clone_name(self):
+        # Create in file based raster.
+        rstfile = NamedTemporaryFile(suffix=".tif")
+        source = GDALRaster(
+            {
+                "datatype": 1,
+                "driver": "tif",
+                "name": rstfile.name,
+                "width": 5,
+                "height": 5,
+                "nr_of_bands": 1,
+                "srid": 4326,
+                "origin": (-5, 5),
+                "scale": (2, -2),
+                "skew": (0, 0),
+                "bands": [
+                    {
+                        "data": range(25),
+                        "nodata_value": 99,
+                    }
+                ],
+            }
+        )
+        clone_name = rstfile.name + "_respect_name.GTiff"
+        target = source.transform(4326, name=clone_name)
+        self.assertEqual(target.name, clone_name)
+
+
+class GDALBandTests(SimpleTestCase):
+    rs_path = os.path.join(os.path.dirname(__file__), "../data/rasters/raster.tif")
+
+    def test_band_data(self):
+        rs = GDALRaster(self.rs_path)
+        band = rs.bands[0]
+        self.assertEqual(band.width, 163)
+        self.assertEqual(band.height, 174)
+        self.assertEqual(band.description, "")
+        self.assertEqual(band.datatype(), 1)
+        self.assertEqual(band.datatype(as_string=True), "GDT_Byte")
+        self.assertEqual(band.color_interp(), 1)
+        self.assertEqual(band.color_interp(as_string=True), "GCI_GrayIndex")
+        self.assertEqual(band.nodata_value, 15)
+        if numpy:
+            data = band.data()
+            assert_array = numpy.loadtxt(
+                os.path.join(
+                    os.path.dirname(__file__), "../data/rasters/raster.numpy.txt"
+                )
+            )
+            numpy.testing.assert_equal(data, assert_array)
+            self.assertEqual(data.shape, (band.height, band.width))
+
+    def test_band_statistics(self):
+        with tempfile.TemporaryDirectory() as tmp_dir:
+            rs_path = os.path.join(tmp_dir, "raster.tif")
+            shutil.copyfile(self.rs_path, rs_path)
+            rs = GDALRaster(rs_path)
+            band = rs.bands[0]
+            pam_file = rs_path + ".aux.xml"
+            smin, smax, smean, sstd = band.statistics(approximate=True)
+            self.assertEqual(smin, 0)
+            self.assertEqual(smax, 9)
+            self.assertAlmostEqual(smean, 2.842331288343558)
+            self.assertAlmostEqual(sstd, 2.3965567248965356)
+
+            smin, smax, smean, sstd = band.statistics(approximate=False, refresh=True)
+            self.assertEqual(smin, 0)
+            self.assertEqual(smax, 9)
+            self.assertAlmostEqual(smean, 2.828326634228898)
+            self.assertAlmostEqual(sstd, 2.4260526986669095)
+
+            self.assertEqual(band.min, 0)
+            self.assertEqual(band.max, 9)
+            self.assertAlmostEqual(band.mean, 2.828326634228898)
+            self.assertAlmostEqual(band.std, 2.4260526986669095)
+
+            # Statistics are persisted into PAM file on band close
+            rs = band = None
+            self.assertTrue(os.path.isfile(pam_file))
+
+    def _remove_aux_file(self):
+        pam_file = self.rs_path + ".aux.xml"
+        if os.path.isfile(pam_file):
+            os.remove(pam_file)
+
+    def test_read_mode_error(self):
+        # Open raster in read mode
+        rs = GDALRaster(self.rs_path, write=False)
+        band = rs.bands[0]
+        self.addCleanup(self._remove_aux_file)
+
+        # Setting attributes in write mode raises exception in the _flush method
+        with self.assertRaises(GDALException):
+            setattr(band, "nodata_value", 10)
+
+    def test_band_data_setters(self):
+        # Create in-memory raster and get band
+        rsmem = GDALRaster(
+            {
+                "datatype": 1,
+                "driver": "MEM",
+                "name": "mem_rst",
+                "width": 10,
+                "height": 10,
+                "nr_of_bands": 1,
+                "srid": 4326,
+            }
+        )
+        bandmem = rsmem.bands[0]
+
+        # Set nodata value
+        bandmem.nodata_value = 99
+        self.assertEqual(bandmem.nodata_value, 99)
+
+        # Set data for entire dataset
+        bandmem.data(range(100))
+        if numpy:
+            numpy.testing.assert_equal(
+                bandmem.data(), numpy.arange(100).reshape(10, 10)
+            )
+        else:
+            self.assertEqual(bandmem.data(), list(range(100)))
+
+        # Prepare data for setting values in subsequent tests
+        block = list(range(100, 104))
+        packed_block = struct.pack("<" + "B B B B", *block)
+
+        # Set data from list
+        bandmem.data(block, (1, 1), (2, 2))
+        result = bandmem.data(offset=(1, 1), size=(2, 2))
+        if numpy:
+            numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
+        else:
+            self.assertEqual(result, block)
+
+        # Set data from packed block
+        bandmem.data(packed_block, (1, 1), (2, 2))
+        result = bandmem.data(offset=(1, 1), size=(2, 2))
+        if numpy:
+            numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
+        else:
+            self.assertEqual(result, block)
+
+        # Set data from bytes
+        bandmem.data(bytes(packed_block), (1, 1), (2, 2))
+        result = bandmem.data(offset=(1, 1), size=(2, 2))
+        if numpy:
+            numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
+        else:
+            self.assertEqual(result, block)
+
+        # Set data from bytearray
+        bandmem.data(bytearray(packed_block), (1, 1), (2, 2))
+        result = bandmem.data(offset=(1, 1), size=(2, 2))
+        if numpy:
+            numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
+        else:
+            self.assertEqual(result, block)
+
+        # Set data from memoryview
+        bandmem.data(memoryview(packed_block), (1, 1), (2, 2))
+        result = bandmem.data(offset=(1, 1), size=(2, 2))
+        if numpy:
+            numpy.testing.assert_equal(result, numpy.array(block).reshape(2, 2))
+        else:
+            self.assertEqual(result, block)
+
+        # Set data from numpy array
+        if numpy:
+            bandmem.data(numpy.array(block, dtype="int8").reshape(2, 2), (1, 1), (2, 2))
+            numpy.testing.assert_equal(
+                bandmem.data(offset=(1, 1), size=(2, 2)),
+                numpy.array(block).reshape(2, 2),
+            )
+
+        # Test json input data
+        rsmemjson = GDALRaster(JSON_RASTER)
+        bandmemjson = rsmemjson.bands[0]
+        if numpy:
+            numpy.testing.assert_equal(
+                bandmemjson.data(), numpy.array(range(25)).reshape(5, 5)
+            )
+        else:
+            self.assertEqual(bandmemjson.data(), list(range(25)))
+
+    def test_band_statistics_automatic_refresh(self):
+        rsmem = GDALRaster(
+            {
+                "srid": 4326,
+                "width": 2,
+                "height": 2,
+                "bands": [{"data": [0] * 4, "nodata_value": 99}],
+            }
+        )
+        band = rsmem.bands[0]
+        # Populate statistics cache
+        self.assertEqual(band.statistics(), (0, 0, 0, 0))
+        # Change data
+        band.data([1, 1, 0, 0])
+        # Statistics are properly updated
+        self.assertEqual(band.statistics(), (0.0, 1.0, 0.5, 0.5))
+        # Change nodata_value
+        band.nodata_value = 0
+        # Statistics are properly updated
+        self.assertEqual(band.statistics(), (1.0, 1.0, 1.0, 0.0))
+
+    def test_band_statistics_empty_band(self):
+        rsmem = GDALRaster(
+            {
+                "srid": 4326,
+                "width": 1,
+                "height": 1,
+                "bands": [{"data": [0], "nodata_value": 0}],
+            }
+        )
+        self.assertEqual(rsmem.bands[0].statistics(), (None, None, None, None))
+
+    def test_band_delete_nodata(self):
+        rsmem = GDALRaster(
+            {
+                "srid": 4326,
+                "width": 1,
+                "height": 1,
+                "bands": [{"data": [0], "nodata_value": 1}],
+            }
+        )
+        rsmem.bands[0].nodata_value = None
+        self.assertIsNone(rsmem.bands[0].nodata_value)
+
+    def test_band_data_replication(self):
+        band = GDALRaster(
+            {
+                "srid": 4326,
+                "width": 3,
+                "height": 3,
+                "bands": [{"data": range(10, 19), "nodata_value": 0}],
+            }
+        ).bands[0]
+
+        # Variations for input (data, shape, expected result).
+        combos = (
+            ([1], (1, 1), [1] * 9),
+            (range(3), (1, 3), [0, 0, 0, 1, 1, 1, 2, 2, 2]),
+            (range(3), (3, 1), [0, 1, 2, 0, 1, 2, 0, 1, 2]),
+        )
+        for combo in combos:
+            band.data(combo[0], shape=combo[1])
+            if numpy:
+                numpy.testing.assert_equal(
+                    band.data(), numpy.array(combo[2]).reshape(3, 3)
+                )
+            else:
+                self.assertEqual(band.data(), list(combo[2]))

testbed/django__django/tests/gis_tests/gdal_tests/test_srs.py

@@ -0,0 +1,403 @@
+from unittest import skipIf
+
+from django.contrib.gis.gdal import (
+    GDAL_VERSION,
+    AxisOrder,
+    CoordTransform,
+    GDALException,
+    SpatialReference,
+    SRSException,
+)
+from django.contrib.gis.geos import GEOSGeometry
+from django.test import SimpleTestCase
+
+
+class TestSRS:
+    def __init__(self, wkt, **kwargs):
+        self.wkt = wkt
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+# Some Spatial Reference examples
+srlist = (
+    TestSRS(
+        'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,'
+        'AUTHORITY["EPSG","7030"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6326"]],'
+        'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",'
+        '0.0174532925199433,AUTHORITY["EPSG","9122"]],AXIS["Latitude",NORTH],'
+        'AXIS["Longitude",EAST],AUTHORITY["EPSG","4326"]]',
+        epsg=4326,
+        projected=False,
+        geographic=True,
+        local=False,
+        lin_name="unknown",
+        ang_name="degree",
+        lin_units=1.0,
+        ang_units=0.0174532925199,
+        auth={
+            None: ("EPSG", "4326"),  # Top-level authority.
+            "GEOGCS": ("EPSG", "4326"),
+            "spheroid": ("EPSG", "7030"),
+        },
+        attr=(
+            ("DATUM", "WGS_1984"),
+            (("SPHEROID", 1), "6378137"),
+            ("primem|authority", "EPSG"),
+        ),
+    ),
+    TestSRS(
+        'PROJCS["NAD83 / Texas South Central",'
+        'GEOGCS["NAD83",DATUM["North_American_Datum_1983",'
+        'SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],'
+        'AUTHORITY["EPSG","6269"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+        'UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],'
+        'AUTHORITY["EPSG","4269"]],PROJECTION["Lambert_Conformal_Conic_2SP"],'
+        'PARAMETER["standard_parallel_1",30.2833333333333],'
+        'PARAMETER["standard_parallel_2",28.3833333333333],'
+        'PARAMETER["latitude_of_origin",27.8333333333333],'
+        'PARAMETER["central_meridian",-99],PARAMETER["false_easting",600000],'
+        'PARAMETER["false_northing",4000000],UNIT["metre",1,AUTHORITY["EPSG","9001"]],'
+        'AXIS["Easting",EAST],AXIS["Northing",NORTH],AUTHORITY["EPSG","32140"]]',
+        epsg=32140,
+        projected=True,
+        geographic=False,
+        local=False,
+        lin_name="metre",
+        ang_name="degree",
+        lin_units=1.0,
+        ang_units=0.0174532925199,
+        auth={
+            None: ("EPSG", "32140"),  # Top-level authority.
+            "PROJCS": ("EPSG", "32140"),
+            "spheroid": ("EPSG", "7019"),
+            "unit": ("EPSG", "9001"),
+        },
+        attr=(
+            ("DATUM", "North_American_Datum_1983"),
+            (("SPHEROID", 2), "298.257222101"),
+            ("PROJECTION", "Lambert_Conformal_Conic_2SP"),
+        ),
+    ),
+    TestSRS(
+        'PROJCS["NAD83 / Texas South Central (ftUS)",'
+        'GEOGCS["NAD83",DATUM["North_American_Datum_1983",'
+        'SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],'
+        'AUTHORITY["EPSG","6269"]],'
+        'PRIMEM["Greenwich",0],'
+        'UNIT["Degree",0.0174532925199433]],PROJECTION["Lambert_Conformal_Conic_2SP"],'
+        'PARAMETER["false_easting",1968500],'
+        'PARAMETER["false_northing",13123333.3333333],'
+        'PARAMETER["central_meridian",-99],'
+        'PARAMETER["standard_parallel_1",28.3833333333333],'
+        'PARAMETER["standard_parallel_2",30.2833333333333],'
+        'PARAMETER["latitude_of_origin",27.8333333333333],'
+        'UNIT["US survey foot",0.304800609601219],AXIS["Easting",EAST],'
+        'AXIS["Northing",NORTH]]',
+        epsg=None,
+        projected=True,
+        geographic=False,
+        local=False,
+        lin_name="US survey foot",
+        ang_name="Degree",
+        lin_units=0.3048006096012192,
+        ang_units=0.0174532925199,
+        auth={
+            None: (None, None),  # Top-level authority.
+            "PROJCS": (None, None),
+        },
+        attr=(
+            ("PROJCS|GeOgCs|spheroid", "GRS 1980"),
+            (("projcs", 9), "UNIT"),
+            (("projcs", 11), "AXIS"),
+        ),
+    ),
+    # This is really ESRI format, not WKT -- but the import should work the same
+    TestSRS(
+        'LOCAL_CS["Non-Earth (Meter)",LOCAL_DATUM["Local Datum",32767],'
+        'UNIT["Meter",1],AXIS["X",EAST],AXIS["Y",NORTH]]',
+        esri=True,
+        epsg=None,
+        projected=False,
+        geographic=False,
+        local=True,
+        lin_name="Meter",
+        ang_name="degree",
+        lin_units=1.0,
+        ang_units=0.0174532925199,
+        attr=(("LOCAL_DATUM", "Local Datum"),),
+    ),
+)
+
+# Well-Known Names
+well_known = (
+    TestSRS(
+        'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,'
+        'AUTHORITY["EPSG","7030"]],TOWGS84[0,0,0,0,0,0,0],AUTHORITY["EPSG","6326"]],'
+        'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+        'UNIT["degree",0.01745329251994328,'
+        'AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]',
+        wk="WGS84",
+        name="WGS 84",
+        attrs=(("GEOGCS|AUTHORITY", 1, "4326"), ("SPHEROID", "WGS 84")),
+    ),
+    TestSRS(
+        'GEOGCS["WGS 72",DATUM["WGS_1972",SPHEROID["WGS 72",6378135,298.26,'
+        'AUTHORITY["EPSG","7043"]],AUTHORITY["EPSG","6322"]],'
+        'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+        'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
+        'AUTHORITY["EPSG","4322"]]',
+        wk="WGS72",
+        name="WGS 72",
+        attrs=(("GEOGCS|AUTHORITY", 1, "4322"), ("SPHEROID", "WGS 72")),
+    ),
+    TestSRS(
+        'GEOGCS["NAD27",DATUM["North_American_Datum_1927",'
+        'SPHEROID["Clarke 1866",6378206.4,294.9786982138982,'
+        'AUTHORITY["EPSG","7008"]],AUTHORITY["EPSG","6267"]],'
+        'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+        'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
+        'AUTHORITY["EPSG","4267"]]',
+        wk="NAD27",
+        name="NAD27",
+        attrs=(("GEOGCS|AUTHORITY", 1, "4267"), ("SPHEROID", "Clarke 1866")),
+    ),
+    TestSRS(
+        'GEOGCS["NAD83",DATUM["North_American_Datum_1983",'
+        'SPHEROID["GRS 1980",6378137,298.257222101,'
+        'AUTHORITY["EPSG","7019"]],AUTHORITY["EPSG","6269"]],'
+        'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+        'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
+        'AUTHORITY["EPSG","4269"]]',
+        wk="NAD83",
+        name="NAD83",
+        attrs=(("GEOGCS|AUTHORITY", 1, "4269"), ("SPHEROID", "GRS 1980")),
+    ),
+    TestSRS(
+        'PROJCS["NZGD49 / Karamea Circuit",GEOGCS["NZGD49",'
+        'DATUM["New_Zealand_Geodetic_Datum_1949",'
+        'SPHEROID["International 1924",6378388,297,'
+        'AUTHORITY["EPSG","7022"]],'
+        "TOWGS84[59.47,-5.04,187.44,0.47,-0.1,1.024,-4.5993],"
+        'AUTHORITY["EPSG","6272"]],PRIMEM["Greenwich",0,'
+        'AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,'
+        'AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4272"]],'
+        'PROJECTION["Transverse_Mercator"],'
+        'PARAMETER["latitude_of_origin",-41.28991152777778],'
+        'PARAMETER["central_meridian",172.1090281944444],'
+        'PARAMETER["scale_factor",1],PARAMETER["false_easting",300000],'
+        'PARAMETER["false_northing",700000],'
+        'UNIT["metre",1,AUTHORITY["EPSG","9001"]],AUTHORITY["EPSG","27216"]]',
+        wk="EPSG:27216",
+        name="NZGD49 / Karamea Circuit",
+        attrs=(
+            ("PROJECTION", "Transverse_Mercator"),
+            ("SPHEROID", "International 1924"),
+        ),
+    ),
+)
+
+bad_srlist = (
+    "Foobar",
+    'OOJCS["NAD83 / Texas South Central",GEOGCS["NAD83",'
+    'DATUM["North_American_Datum_1983",'
+    'SPHEROID["GRS 1980",6378137,298.257222101,AUTHORITY["EPSG","7019"]],'
+    'AUTHORITY["EPSG","6269"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+    'UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],'
+    'AUTHORITY["EPSG","4269"]],PROJECTION["Lambert_Conformal_Conic_2SP"],'
+    'PARAMETER["standard_parallel_1",30.28333333333333],'
+    'PARAMETER["standard_parallel_2",28.38333333333333],'
+    'PARAMETER["latitude_of_origin",27.83333333333333],'
+    'PARAMETER["central_meridian",-99],PARAMETER["false_easting",600000],'
+    'PARAMETER["false_northing",4000000],UNIT["metre",1,'
+    'AUTHORITY["EPSG","9001"]],AUTHORITY["EPSG","32140"]]',
+)
+
+
+class SpatialRefTest(SimpleTestCase):
+    def test01_wkt(self):
+        "Testing initialization on valid OGC WKT."
+        for s in srlist:
+            SpatialReference(s.wkt)
+
+    def test02_bad_wkt(self):
+        "Testing initialization on invalid WKT."
+        for bad in bad_srlist:
+            try:
+                srs = SpatialReference(bad)
+                srs.validate()
+            except (SRSException, GDALException):
+                pass
+            else:
+                self.fail('Should not have initialized on bad WKT "%s"!')
+
+    def test03_get_wkt(self):
+        "Testing getting the WKT."
+        for s in srlist:
+            srs = SpatialReference(s.wkt)
+            # GDAL 3 strips UNIT part in the last occurrence.
+            self.assertEqual(
+                s.wkt.replace(',UNIT["Meter",1]', ""),
+                srs.wkt.replace(',UNIT["Meter",1]', ""),
+            )
+
+    def test04_proj(self):
+        """PROJ import and export."""
+        proj_parts = [
+            "+proj=longlat",
+            "+ellps=WGS84",
+            "+towgs84=0,0,0,0,0,0,0",
+            "+datum=WGS84",
+            "+no_defs",
+        ]
+        srs1 = SpatialReference(srlist[0].wkt)
+        srs2 = SpatialReference("+proj=longlat +datum=WGS84 +no_defs")
+        self.assertTrue(all(part in proj_parts for part in srs1.proj.split()))
+        self.assertTrue(all(part in proj_parts for part in srs2.proj.split()))
+
+    def test05_epsg(self):
+        "Test EPSG import."
+        for s in srlist:
+            if s.epsg:
+                srs1 = SpatialReference(s.wkt)
+                srs2 = SpatialReference(s.epsg)
+                srs3 = SpatialReference(str(s.epsg))
+                srs4 = SpatialReference("EPSG:%d" % s.epsg)
+                for srs in (srs1, srs2, srs3, srs4):
+                    for attr, expected in s.attr:
+                        self.assertEqual(expected, srs[attr])
+
+    def test07_boolean_props(self):
+        "Testing the boolean properties."
+        for s in srlist:
+            srs = SpatialReference(s.wkt)
+            self.assertEqual(s.projected, srs.projected)
+            self.assertEqual(s.geographic, srs.geographic)
+
+    def test08_angular_linear(self):
+        "Testing the linear and angular units routines."
+        for s in srlist:
+            srs = SpatialReference(s.wkt)
+            self.assertEqual(s.ang_name, srs.angular_name)
+            self.assertEqual(s.lin_name, srs.linear_name)
+            self.assertAlmostEqual(s.ang_units, srs.angular_units, 9)
+            self.assertAlmostEqual(s.lin_units, srs.linear_units, 9)
+
+    def test09_authority(self):
+        "Testing the authority name & code routines."
+        for s in srlist:
+            if hasattr(s, "auth"):
+                srs = SpatialReference(s.wkt)
+                for target, tup in s.auth.items():
+                    self.assertEqual(tup[0], srs.auth_name(target))
+                    self.assertEqual(tup[1], srs.auth_code(target))
+
+    def test10_attributes(self):
+        "Testing the attribute retrieval routines."
+        for s in srlist:
+            srs = SpatialReference(s.wkt)
+            for tup in s.attr:
+                att = tup[0]  # Attribute to test
+                exp = tup[1]  # Expected result
+                self.assertEqual(exp, srs[att])
+
+    def test11_wellknown(self):
+        "Testing Well Known Names of Spatial References."
+        for s in well_known:
+            srs = SpatialReference(s.wk)
+            self.assertEqual(s.name, srs.name)
+            for tup in s.attrs:
+                if len(tup) == 2:
+                    key = tup[0]
+                    exp = tup[1]
+                elif len(tup) == 3:
+                    key = tup[:2]
+                    exp = tup[2]
+                self.assertEqual(srs[key], exp)
+
+    def test12_coordtransform(self):
+        "Testing initialization of a CoordTransform."
+        target = SpatialReference("WGS84")
+        CoordTransform(SpatialReference(srlist[0].wkt), target)
+
+    def test13_attr_value(self):
+        "Testing the attr_value() method."
+        s1 = SpatialReference("WGS84")
+        with self.assertRaises(TypeError):
+            s1.__getitem__(0)
+        with self.assertRaises(TypeError):
+            s1.__getitem__(("GEOGCS", "foo"))
+        self.assertEqual("WGS 84", s1["GEOGCS"])
+        self.assertEqual("WGS_1984", s1["DATUM"])
+        self.assertEqual("EPSG", s1["AUTHORITY"])
+        self.assertEqual(4326, int(s1["AUTHORITY", 1]))
+        self.assertIsNone(s1["FOOBAR"])
+
+    def test_unicode(self):
+        wkt = (
+            'PROJCS["DHDN / Soldner 39 Langschoß",'
+            'GEOGCS["DHDN",DATUM["Deutsches_Hauptdreiecksnetz",'
+            'SPHEROID["Bessel 1841",6377397.155,299.1528128,AUTHORITY["EPSG","7004"]],'
+            'AUTHORITY["EPSG","6314"]],'
+            'PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],'
+            'UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],'
+            'AUTHORITY["EPSG","4314"]],PROJECTION["Cassini_Soldner"],'
+            'PARAMETER["latitude_of_origin",50.66738711],'
+            'PARAMETER["central_meridian",6.28935703],'
+            'PARAMETER["false_easting",0],PARAMETER["false_northing",0],'
+            'UNIT["metre",1,AUTHORITY["EPSG","9001"]],AXIS["X",NORTH],AXIS["Y",EAST],'
+            'AUTHORITY["mj10777.de","187939"]]'
+        )
+        srs = SpatialReference(wkt)
+        srs_list = [srs, srs.clone()]
+        srs.import_wkt(wkt)
+
+        for srs in srs_list:
+            self.assertEqual(srs.name, "DHDN / Soldner 39 Langschoß")
+            self.assertEqual(srs.wkt, wkt)
+            self.assertIn("Langschoß", srs.pretty_wkt)
+            self.assertIn("Langschoß", srs.xml)
+
+    @skipIf(GDAL_VERSION < (3, 0), "GDAL >= 3.0 is required")
+    def test_axis_order(self):
+        wgs84_trad = SpatialReference(4326, axis_order=AxisOrder.TRADITIONAL)
+        wgs84_auth = SpatialReference(4326, axis_order=AxisOrder.AUTHORITY)
+        # Coordinate interpretation may depend on the srs axis predicate.
+        pt = GEOSGeometry("POINT (992385.4472045 481455.4944650)", 2774)
+        pt_trad = pt.transform(wgs84_trad, clone=True)
+        self.assertAlmostEqual(pt_trad.x, -104.609, 3)
+        self.assertAlmostEqual(pt_trad.y, 38.255, 3)
+        pt_auth = pt.transform(wgs84_auth, clone=True)
+        self.assertAlmostEqual(pt_auth.x, 38.255, 3)
+        self.assertAlmostEqual(pt_auth.y, -104.609, 3)
+        # clone() preserves the axis order.
+        pt_auth = pt.transform(wgs84_auth.clone(), clone=True)
+        self.assertAlmostEqual(pt_auth.x, 38.255, 3)
+        self.assertAlmostEqual(pt_auth.y, -104.609, 3)
+
+    def test_axis_order_invalid(self):
+        msg = "SpatialReference.axis_order must be an AxisOrder instance."
+        with self.assertRaisesMessage(ValueError, msg):
+            SpatialReference(4326, axis_order="other")
+
+    @skipIf(GDAL_VERSION > (3, 0), "GDAL < 3.0 doesn't support authority.")
+    def test_axis_order_non_traditional_invalid(self):
+        msg = "AxisOrder.AUTHORITY is not supported in GDAL < 3.0."
+        with self.assertRaisesMessage(ValueError, msg):
+            SpatialReference(4326, axis_order=AxisOrder.AUTHORITY)
+
+    def test_esri(self):
+        srs = SpatialReference("NAD83")
+        pre_esri_wkt = srs.wkt
+        srs.to_esri()
+        self.assertNotEqual(srs.wkt, pre_esri_wkt)
+        self.assertIn('DATUM["D_North_American_1983"', srs.wkt)
+        srs.from_esri()
+        self.assertIn('DATUM["North_American_Datum_1983"', srs.wkt)
+
+    def test_srid(self):
+        """The srid property returns top-level authority code."""
+        for s in srlist:
+            if hasattr(s, "epsg"):
+                srs = SpatialReference(s.wkt)
+                self.assertEqual(srs.srid, s.epsg)

testbed/django__django/tests/gis_tests/gdal_tests/tests.py

@@ -0,0 +1,16 @@
+import unittest
+
+from django.contrib.gis.gdal import GDAL_VERSION, gdal_full_version, gdal_version
+
+
+class GDALTest(unittest.TestCase):
+    def test_gdal_version(self):
+        if GDAL_VERSION:
+            self.assertEqual(gdal_version(), ("%s.%s.%s" % GDAL_VERSION).encode())
+        else:
+            self.assertIn(b".", gdal_version())
+
+    def test_gdal_full_version(self):
+        full_version = gdal_full_version()
+        self.assertIn(gdal_version(), full_version)
+        self.assertTrue(full_version.startswith(b"GDAL"))