resolve conflicts

Author: Reagan Reuben

src/World.Net.UnitTests/Countries/CaymanIslandsTest.cs

@@ -0,0 +1,41 @@
+namespace World.Net.UnitTests.Countries
+{
+    public sealed class CaymanIslandsTest
+    {
+        private const string CAYMAN_ISLANDS_COUNTRY_NAME = "Cayman Islands";
+        private const string CAYMAN_ISLANDS_NATIVE_NAME = "Cayman Islands";
+        private const string CAYMAN_ISLANDS_CAPITAL = "George Town";
+        private const string CAYMAN_ISLANDS_OFFICIAL_NAME = "Cayman Islands";
+        private const string CAYMAN_ISLANDS_ISO2_CODE = "KY";
+        private const string CAYMAN_ISLANDS_ISO3_CODE = "CYM";
+        private const int CAYMAN_ISLANDS_NUMERIC_CODE = 136;
+        private const string CAYMAN_ISLANDS_CALLING_CODE = "+1-345";
+        private const int CAYMAN_ISLANDS_STATE_COUNT = 3;
+        private static readonly string[] VALID_STATE_TYPES = { "District" };
+
+        [Fact]
+        public void GetCountry_ReturnsCorrectInformation_ForCaymanIslands()
+        {
+            // Arrange
+            CountryIdentifier existingCountryId = CountryIdentifier.CaymanIslands;
+
+            // Act
+            var country = CountryProvider.GetCountry(existingCountryId);
+
+            // Assert
+            Assert.NotNull(country);
+            Assert.Equal(existingCountryId, country.Id);
+            Assert.Equal(CAYMAN_ISLANDS_COUNTRY_NAME, country.Name);
+            Assert.Equal(CAYMAN_ISLANDS_OFFICIAL_NAME, country.OfficialName);
+            Assert.Equal(CAYMAN_ISLANDS_NATIVE_NAME, country.NativeName);
+            Assert.Equal(CAYMAN_ISLANDS_CAPITAL, country.Capital);
+            Assert.Equal(CAYMAN_ISLANDS_NUMERIC_CODE, country.NumericCode);
+            Assert.Equal(CAYMAN_ISLANDS_ISO2_CODE, country.ISO2Code);
+            Assert.Equal(CAYMAN_ISLANDS_ISO3_CODE, country.ISO3Code);
+            Assert.Equal(CAYMAN_ISLANDS_CALLING_CODE, country.CallingCode);
+            Assert.NotNull(country.States);
+            Assert.Equal(CAYMAN_ISLANDS_STATE_COUNT, country.States.Count());
+            Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+        }
+    }
+}

src/World.Net.UnitTests/Countries/CentralAfricanRepublicTest.cs

@@ -0,0 +1,42 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class CentralAfricanRepublicTest
+{
+    private const string CAR_COUNTRY_NAME = "Central African Republic";
+    private const string CAR_NATIVE_NAME = "Ködörösêse tî Bêafrîka";
+    private const string CAR_CAPITAL = "Bangui";
+    private const string CAR_OFFICIAL_NAME = "Central African Republic";
+    private const string CAR_ISO2_CODE = "CF";
+    private const string CAR_ISO3_CODE = "CAF";
+    private const int CAR_NUMERIC_CODE = 140;
+    private const string CAR_CALLING_CODE = "+236";
+    private const int CAR_STATE_COUNT = 14;
+    private static readonly string[] VALID_STATE_TYPES = { "Prefecture", "Capital District" };
+
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForCentralAfricanRepublic()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.CentralAfricanRepublic;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CAR_COUNTRY_NAME, country.Name);
+        Assert.Equal(CAR_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CAR_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CAR_CAPITAL, country.Capital);
+        Assert.Equal(CAR_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CAR_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CAR_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CAR_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CAR_STATE_COUNT, country.States.Count());
+
+        // Assert that each state has a valid type
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/ChadTest.cs

@@ -0,0 +1,42 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class ChadTest
+{
+    private const string CHAD_COUNTRY_NAME = "Chad";
+    private const string CHAD_NATIVE_NAME = "Tchad";
+    private const string CHAD_CAPITAL = "N'Djamena";
+    private const string CHAD_OFFICIAL_NAME = "Republic of Chad";
+    private const string CHAD_ISO2_CODE = "TD";
+    private const string CHAD_ISO3_CODE = "TCD";
+    private const int CHAD_NUMERIC_CODE = 148;
+    private const string CHAD_CALLING_CODE = "+235";
+    private const int CHAD_STATE_COUNT = 23;
+    private static readonly string[] VALID_STATE_TYPES = { "Region" };
+
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForChad()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.Chad;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CHAD_COUNTRY_NAME, country.Name);
+        Assert.Equal(CHAD_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CHAD_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CHAD_CAPITAL, country.Capital);
+        Assert.Equal(CHAD_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CHAD_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CHAD_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CHAD_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CHAD_STATE_COUNT, country.States.Count());
+
+        // Assert that each state has a valid type
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/ChileTest.cs

@@ -0,0 +1,42 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class ChileTest
+{
+    private const string CHILE_COUNTRY_NAME = "Chile";
+    private const string CHILE_NATIVE_NAME = "República de Chile";
+    private const string CHILE_CAPITAL = "Santiago";
+    private const string CHILE_OFFICIAL_NAME = "Republic of Chile";
+    private const string CHILE_ISO2_CODE = "CL";
+    private const string CHILE_ISO3_CODE = "CHL";
+    private const int CHILE_NUMERIC_CODE = 152;
+    private const string CHILE_CALLING_CODE = "+56";
+    private const int CHILE_STATE_COUNT = 16;
+    private static readonly string[] VALID_STATE_TYPES = { "Region" };
+
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForChile()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.Chile;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CHILE_COUNTRY_NAME, country.Name);
+        Assert.Equal(CHILE_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CHILE_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CHILE_CAPITAL, country.Capital);
+        Assert.Equal(CHILE_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CHILE_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CHILE_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CHILE_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CHILE_STATE_COUNT, country.States.Count());
+
+        // Assert that each state has a valid type
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/ChinaTest.cs

@@ -0,0 +1,42 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class ChinaTest
+{
+    private const string CHINA_COUNTRY_NAME = "China";
+    private const string CHINA_NATIVE_NAME = "中国";
+    private const string CHINA_CAPITAL = "Beijing";
+    private const string CHINA_OFFICIAL_NAME = "People's Republic of China";
+    private const string CHINA_ISO2_CODE = "CN";
+    private const string CHINA_ISO3_CODE = "CHN";
+    private const int CHINA_NUMERIC_CODE = 156;
+    private const string CHINA_CALLING_CODE = "+86";
+    private const int CHINA_STATE_COUNT = 34; // 23 Provinces, 4 Municipalities, 5 Autonomous Regions, 2 SAR
+    private static readonly string[] VALID_STATE_TYPES = { "Province", "Municipality", "Autonomous Region", "Special Administrative Region" };
+
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForChina()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.China;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CHINA_COUNTRY_NAME, country.Name);
+        Assert.Equal(CHINA_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CHINA_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CHINA_CAPITAL, country.Capital);
+        Assert.Equal(CHINA_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CHINA_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CHINA_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CHINA_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CHINA_STATE_COUNT, country.States.Count());
+
+        // Assert that each state has a valid type
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/CroatiaTest.cs

@@ -0,0 +1,40 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class CroatiaTest
+{
+    private const string CROATIA_COUNTRY_NAME = "Croatia";
+    private const string CROATIA_NATIVE_NAME = "Hrvatska";
+    private const string CROATIA_CAPITAL = "Zagreb";
+    private const string CROATIA_OFFICIAL_NAME = "Republic of Croatia";
+    private const string CROATIA_ISO2_CODE = "HR";
+    private const string CROATIA_ISO3_CODE = "HRV";
+    private const int CROATIA_NUMERIC_CODE = 191;
+    private const string CROATIA_CALLING_CODE = "+385";
+    private const int CROATIA_STATE_COUNT = 21;
+    private static readonly string[] VALID_STATE_TYPES = { "City", "County" };
+    
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForCroatia()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.Croatia;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CROATIA_COUNTRY_NAME, country.Name);
+        Assert.Equal(CROATIA_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CROATIA_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CROATIA_CAPITAL, country.Capital);
+        Assert.Equal(CROATIA_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CROATIA_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CROATIA_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CROATIA_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CROATIA_STATE_COUNT, country.States.Count());
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/CubaTest.cs

@@ -0,0 +1,40 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class CubaTest
+{
+    private const string CUBA_COUNTRY_NAME = "Cuba";
+    private const string CUBA_NATIVE_NAME = "Cuba";
+    private const string CUBA_CAPITAL = "Havana";
+    private const string CUBA_OFFICIAL_NAME = "Republic of Cuba";
+    private const string CUBA_ISO2_CODE = "CU";
+    private const string CUBA_ISO3_CODE = "CUB";
+    private const int CUBA_NUMERIC_CODE = 192;
+    private const string CUBA_CALLING_CODE = "+53";
+    private const int CUBA_STATE_COUNT = 16;
+    private static readonly string[] VALID_STATE_TYPES = { "Province", "Special Municipality" };
+    
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForCuba()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.Cuba;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CUBA_COUNTRY_NAME, country.Name);
+        Assert.Equal(CUBA_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CUBA_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CUBA_CAPITAL, country.Capital);
+        Assert.Equal(CUBA_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CUBA_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CUBA_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CUBA_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CUBA_STATE_COUNT, country.States.Count());
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/CuraçaoTest.cs

@@ -0,0 +1,40 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class CuraçaoTest
+{
+    private const string CURACAO_COUNTRY_NAME = "Curaçao";
+    private const string CURACAO_NATIVE_NAME = "Kòrsou";
+    private const string CURACAO_CAPITAL = "Willemstad";
+    private const string CURACAO_OFFICIAL_NAME = "Country of Curaçao";
+    private const string CURACAO_ISO2_CODE = "CW";
+    private const string CURACAO_ISO3_CODE = "CUW";
+    private const int CURACAO_NUMERIC_CODE = 531;
+    private const string CURACAO_CALLING_CODE = "+599";
+    private const int CURACAO_STATE_COUNT = 1;
+    private static readonly string[] VALID_STATE_TYPES = { "Country" };
+    
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForCuracao()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.Curacao;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CURACAO_COUNTRY_NAME, country.Name);
+        Assert.Equal(CURACAO_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CURACAO_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CURACAO_CAPITAL, country.Capital);
+        Assert.Equal(CURACAO_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CURACAO_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CURACAO_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CURACAO_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.NotEmpty(country.States);
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}

src/World.Net.UnitTests/Countries/CyprusTest.cs

@@ -0,0 +1,40 @@
+namespace World.Net.UnitTests.Countries;
+
+public sealed class CyprusTest
+{
+    private const string CYPRUS_COUNTRY_NAME = "Cyprus";
+    private const string CYPRUS_NATIVE_NAME = "Κύπρος";
+    private const string CYPRUS_CAPITAL = "Nicosia";
+    private const string CYPRUS_OFFICIAL_NAME = "Republic of Cyprus";
+    private const string CYPRUS_ISO2_CODE = "CY";
+    private const string CYPRUS_ISO3_CODE = "CYP";
+    private const int CYPRUS_NUMERIC_CODE = 196;
+    private const string CYPRUS_CALLING_CODE = "+357";
+    private const int CYPRUS_STATE_COUNT = 6;
+    private static readonly string[] VALID_STATE_TYPES = { "District" };
+    
+    [Fact]
+    public void GetCountry_ReturnsCorrectInformation_ForCyprus()
+    {
+        // Arrange
+        CountryIdentifier existingCountryId = CountryIdentifier.Cyprus;
+
+        // Act
+        var country = CountryProvider.GetCountry(existingCountryId);
+
+        // Assert
+        Assert.NotNull(country);
+        Assert.Equal(existingCountryId, country.Id);
+        Assert.Equal(CYPRUS_COUNTRY_NAME, country.Name);
+        Assert.Equal(CYPRUS_OFFICIAL_NAME, country.OfficialName);
+        Assert.Equal(CYPRUS_NATIVE_NAME, country.NativeName);
+        Assert.Equal(CYPRUS_CAPITAL, country.Capital);
+        Assert.Equal(CYPRUS_NUMERIC_CODE, country.NumericCode);
+        Assert.Equal(CYPRUS_ISO2_CODE, country.ISO2Code);
+        Assert.Equal(CYPRUS_ISO3_CODE, country.ISO3Code);
+        Assert.Equal(CYPRUS_CALLING_CODE, country.CallingCode);
+        Assert.NotNull(country.States);
+        Assert.Equal(CYPRUS_STATE_COUNT, country.States.Count());
+        Assert.All(country.States, state => Assert.Contains(state.Type, VALID_STATE_TYPES));
+    }
+}