Initial code commit, build fails

Author: matt-lethargic

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+open_collective: geojson-net

.github/workflows/ci-build.yml

@@ -0,0 +1,27 @@
+name: Build and Tests
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    env: 
+      VSTEST_CONNECTION_TIMEOUT: 900
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Setup .NET Core
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: '6.0.x'
+    - name: Install dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --configuration Release --no-restore
+    - name: Test
+      run: dotnet test --no-restore --verbosity normal

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jörg Battermann & Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

src/Directory.Build.props

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>$(SolutionDir)key.snk</AssemblyOriginatorKeyFile>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+</Project>

src/GeoJSON.Net.Tests/CoordinateReferenceSystem/DefaultCrsTests.cs

@@ -0,0 +1,69 @@
+using GeoJSON.Net.CoordinateReferenceSystem;
+using GeoJSON.Net.Feature;
+using GeoJSON.Net.Geometry;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+namespace GeoJSON.Net.Tests.CoordinateReferenceSystem
+{
+    [TestFixture]
+    public class DefaultCrsTests : TestBase
+    {
+        [Test]
+        public void Can_Serialize_Does_Not_Output_Crs_Property()
+        {
+            var collection = new FeatureCollection();
+
+            var json = JsonConvert.SerializeObject(collection);
+
+            Assert.IsTrue(!json.Contains("\"crs\""));
+        }
+
+        [Test]
+        public void Can_Deserialize_When_Json_Does_Not_Contain_Crs_Property()
+        {
+            var json = "{\"coordinates\":[90.65464646,53.2455662,200.4567],\"type\":\"Point\"}";
+
+            var point = JsonConvert.DeserializeObject<Point>(json);
+
+            Assert.IsNull(point.CRS);
+        }
+
+        [Test]
+        public void Can_Deserialize_CRS_issue_89()
+        {
+            var json = "{\"coordinates\": [ 90.65464646, 53.2455662, 200.4567 ], \"type\": \"Point\", \"crs\": { \"type\": \"name\", \"properties\": { \"name\": \"urn:ogc:def:crs:OGC:1.3:CRS84\" }}}";
+
+            var point = JsonConvert.DeserializeObject<Point>(json);
+
+            Assert.IsNotNull(point.CRS);
+            Assert.AreEqual(CRSType.Name, point.CRS.Type);
+        }
+
+        [Test]
+        public void Can_Serialize_CRS_issue_89()
+        {
+            var expected =
+                "{\"type\":\"Point\",\"coordinates\":[34.56,12.34],\"crs\":{\"properties\":{\"name\":\"TEST NAME\"},\"type\":\"name\"}}";
+            var point = new Point(new Position(12.34, 34.56)) { CRS = new NamedCRS("TEST NAME") };
+
+            var json = JsonConvert.SerializeObject(point);
+
+            Assert.IsNotNull(json);
+            Assert.AreEqual(expected, json);
+        }
+
+        [Test]
+        public void Can_Serialize_DefaultCRS_issue_89()
+        {
+            var expected =
+                "{\"type\":\"Point\",\"coordinates\":[34.56,12.34],\"crs\":{\"properties\":{\"name\":\"urn:ogc:def:crs:OGC::CRS84\"},\"type\":\"name\"}}";
+            var point = new Point(new Position(12.34, 34.56)) { CRS = new NamedCRS("urn:ogc:def:crs:OGC::CRS84") };
+
+            var json = JsonConvert.SerializeObject(point);
+
+            Assert.IsNotNull(json);
+            Assert.AreEqual(expected, json);
+        }
+    }
+}

src/GeoJSON.Net.Tests/CoordinateReferenceSystem/LinkedCRSTests.cs

@@ -0,0 +1,130 @@
+using System;
+using GeoJSON.Net.CoordinateReferenceSystem;
+using GeoJSON.Net.Geometry;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+namespace GeoJSON.Net.Tests.CoordinateReferenceSystem
+{
+    [TestFixture]
+    public class LinkedCRSTests : TestBase
+    {
+        private const string Href = "http://localhost";
+
+        [Test]
+        public void Has_Correct_Type()
+        {
+            var crs = new LinkedCRS(Href);
+            Assert.AreEqual(CRSType.Link, crs.Type);
+        }
+
+        [Test]
+        public void Has_Href_Property_With_Href()
+        {
+            var crs = new LinkedCRS(Href);
+
+            Assert.IsTrue(crs.Properties.ContainsKey("href"));
+            Assert.AreEqual(Href, crs.Properties["href"]);
+        }
+
+        [Test]
+        public void Has_Type_Property()
+        {
+            const string type = "ogcwkt";
+            var crs = new LinkedCRS(Href, type);
+
+            Assert.IsTrue(crs.Properties.ContainsKey("type"));
+            Assert.AreEqual(type, crs.Properties["type"]);
+        }
+
+        [Test]
+        public void Can_Serialize()
+        {
+            var collection = new Point(new Position(1, 2, 3)) { CRS = new LinkedCRS(Href) };
+            var actualJson = JsonConvert.SerializeObject(collection);
+
+            JsonAssert.Contains("{\"properties\":{\"href\":\"http://localhost\"},\"type\":\"link\"}", actualJson);
+        }
+
+        [Test]
+        public void Can_Deserialize_CRS_issue_101()
+        {
+            const string pointJson = "{\"type\":\"Point\",\"coordinates\":[2.0,1.0,3.0],\"crs\":{\"properties\":{\"href\":\"http://localhost\"},\"type\":\"link\"}}";
+            var pointWithCRS = JsonConvert.DeserializeObject<Point>(pointJson);
+            var linkCRS = pointWithCRS.CRS as LinkedCRS;
+
+            Assert.IsNotNull(linkCRS);
+            Assert.AreEqual(CRSType.Link, linkCRS.Type);
+            Assert.AreEqual(Href, linkCRS.Properties["href"]);
+        }
+
+        [Test]
+        public void Ctor_Throws_ArgumentNullExpection_When_Href_String_Is_Null()
+        {
+            Assert.Throws<ArgumentNullException>(() => { var crs = new LinkedCRS((string)null); });
+        }
+
+        [Test]
+        public void Ctor_Throws_ArgumentNullExpection_When_Href_Uri_Is_Null()
+        {
+            Assert.Throws<ArgumentNullException>(() => { var crs = new LinkedCRS((Uri)null); });
+        }
+
+        [Test]
+        public void Ctor_Throws_ArgumentExpection_When_Href_Is_Not_Dereferencable_Uri()
+        {
+#if NETCOREAPP1_1
+            System.Globalization.CultureInfo.CurrentUICulture = new System.Globalization.CultureInfo("en-US");
+#else
+            System.Threading.Thread.CurrentThread.CurrentUICulture = new System.Globalization.CultureInfo("en-US");
+#endif
+
+            var argumentExpection = Assert.Throws<ArgumentException>(() => { var crs = new LinkedCRS("http://not-a-valid-<>-url"); });
+            Assert.AreEqual($"must be a dereferenceable URI{Environment.NewLine}Parameter name: href", argumentExpection.Message);
+        }
+
+        [Test]
+        public void Ctor_Does_Not_Throw_When_Href_Is_Dereferencable_Uri()
+        {
+            Assert.DoesNotThrow(() => { var crs = new LinkedCRS("data.crs"); });
+        }
+
+        [Test]
+        public void Ctor_Throws_ArgumentNullExpection_When_Name_Is_Empty()
+        {
+            Assert.Throws<ArgumentException>(() => { var crs = new LinkedCRS(string.Empty); });
+        }
+
+        [Test]
+        public void Equals_GetHashCode_Contract()
+        {
+            var left = new LinkedCRS(Href);
+            var right = new LinkedCRS(Href);
+
+            Assert.AreEqual(left, right);
+
+            Assert.IsTrue(left == right);
+            Assert.IsTrue(right == left);
+
+            Assert.IsTrue(left.Equals(right));
+            Assert.IsTrue(right.Equals(left));
+
+            Assert.IsTrue(left.Equals(left));
+            Assert.IsTrue(right.Equals(right));
+
+            Assert.AreEqual(left.GetHashCode(), right.GetHashCode());
+
+            right = new LinkedCRS(Href + "?query=null");
+
+            Assert.AreNotEqual(left, right);
+
+            Assert.IsFalse(left == right);
+            Assert.IsFalse(right == left);
+
+            Assert.IsFalse(left.Equals(right));
+            Assert.IsFalse(right.Equals(left));
+
+            Assert.AreNotEqual(left.GetHashCode(), right.GetHashCode());
+        }
+    }
+}

src/GeoJSON.Net.Tests/CoordinateReferenceSystem/NamedCrsTests.cs

@@ -0,0 +1,87 @@
+using System;
+using GeoJSON.Net.CoordinateReferenceSystem;
+using GeoJSON.Net.Feature;
+using Newtonsoft.Json;
+using NUnit.Framework;
+
+namespace GeoJSON.Net.Tests.CoordinateReferenceSystem
+{
+    [TestFixture]
+    public class NamedCRSTests : TestBase
+    {
+        [Test]
+        public void Has_Correct_Type()
+        {
+            var name = "EPSG:31370";
+            var crs = new NamedCRS(name);
+
+            Assert.AreEqual(CRSType.Name, crs.Type);
+        }
+
+        [Test]
+        public void Has_Name_Property_With_Name()
+        {
+            var name = "EPSG:31370";
+            var crs = new NamedCRS(name);
+
+            Assert.IsTrue(crs.Properties.ContainsKey("name"));
+            Assert.AreEqual(name, crs.Properties["name"]);
+        }
+
+        [Test]
+        public void Can_Serialize()
+        {
+            var collection = new FeatureCollection() { CRS = new NamedCRS("EPSG:31370") };
+            var actualJson = JsonConvert.SerializeObject(collection);
+
+            JsonAssert.Contains("{\"properties\":{\"name\":\"EPSG:31370\"},\"type\":\"name\"}", actualJson);
+        }
+
+        [Test]
+        public void Ctor_Throws_ArgumentNullExpection_When_Name_Is_Null()
+        {
+            Assert.Throws<ArgumentNullException>(() => { var collection = new FeatureCollection() { CRS = new NamedCRS(null) }; });
+        }
+
+        [Test]
+        public void Ctor_Throws_ArgumentNullExpection_When_Name_Is_Empty()
+        {
+            Assert.Throws<ArgumentException>(() => { var collection = new FeatureCollection() { CRS = new NamedCRS(string.Empty) }; });
+        }
+
+        [Test]
+        public void Equals_GetHashCode_Contract()
+        {
+            var name = "EPSG:31370";
+
+            var left = new NamedCRS(name);
+            var right = new NamedCRS(name);
+
+            Assert.AreEqual(left, right);
+
+            Assert.IsTrue(left == right);
+            Assert.IsTrue(right == left);
+
+            Assert.IsTrue(left.Equals(right));
+            Assert.IsTrue(right.Equals(left));
+
+            Assert.IsTrue(left.Equals(left));
+            Assert.IsTrue(right.Equals(right));
+
+            Assert.AreEqual(left.GetHashCode(), right.GetHashCode());
+
+            name = "EPSG:25832";
+            right = new NamedCRS(name);
+
+            Assert.AreNotEqual(left, right);
+
+            Assert.IsFalse(left == right);
+            Assert.IsFalse(right == left);
+
+            Assert.IsFalse(left.Equals(right));
+            Assert.IsFalse(right.Equals(left));
+
+            Assert.AreNotEqual(left.GetHashCode(), right.GetHashCode());
+        }
+    }
+}