Revize bfd5a848

re #8934 Creating unit tests for json parser

Server/ServerApp/DataDownload/DataDownloader.cs

@@ -85 +85 @@
 		}
 
 		/// <summary>
-		/// Downloads json file
+		/// Downloads json file - returns contents of said file
 		/// </summary>
 		/// <returns> Path to file </returns>
-		public string DownloadWeatherPrediction()
+		virtual public string DownloadWeatherPrediction()
 		{
 			// TODO either set this path as attribute or if parameter JsonParser needs an attribute that would be set through constructor
 			string predictionSite = "http://wttr.in/Plzen,czechia?format=j1";
 
 			DateTime now = DateTime.Now;
 			WebClient webClient = new WebClient();
-			webClient.DownloadFile(predictionSite, $"data/{now.Year}{now.Month}{now.Day}.json");
+			string data = webClient.DownloadString(predictionSite);
 
-			return $"data/{now.Year}{now.Month}{now.Day}.json";
+			return data;
 		}
 
 		/// <summary>

Server/ServerApp/Parser/OutputInfo/ValueToConditions.cs

@@ -57 +57 @@
         /// </summary>
         /// <param name="cloudCover">Value expected between 0-100</param>
         /// <returns>WeatherConditions</returns>
-        internal static WeatherConditions CloudCoverToConditions(int cloudCover)
+        public static WeatherConditions CloudCoverToConditions(int cloudCover)
         {
             if (cloudCover >= 66)
                 return WeatherConditions.Overcast;

Server/ServerApp/Parser/OutputInfo/WeatherInfo.cs

@@ -94 +94 @@
         {
             WeatherInfo other = (WeatherInfo) obj;
 
-            if (startTime == other.startTime && temp == other.temp && wind == other.wind && rain == other.rain && condition == other.condition)
-                return true;
+            if (startTime == other.startTime && rain == other.rain && condition == other.condition)
+            {
+                if ((int)(temp * 1000) == (int)(other.temp *1000) && (int)(wind*1000) == (int)(other.wind*1000))
+                    return true;
+            }
 
             return false;
         }

Server/ServerApp/Program.cs

@@ -131 +131 @@
 
             // PARSE DATA
 
-
-
-            JsonParser jsonP = new JsonParser(null);
+            JsonParser jsonP = new JsonParser(dd);
 			jsonP.ParsePrediction();
 
 			var res = jsonP.GetPredictionForTime(jsonP.Predictions[5].startTime, jsonP.Predictions[20].startTime);
@@ -146 +144 @@
 			// TODO nastavit čas
 			IDataParser p = new DataParser(dd);
             IPredictionController predictionController = new PredictionController(p);
-            predictionController.Train();
+            //predictionController.Train();
             //var results = predictionController.Predict()
 			
 

Server/ServerApp/WeatherPredictionParser/JsonParser.cs

@@ -25 +25 @@
         /// <summary> Currently parsed day </summary>
         DateTime currParsedDay;
         /// <summary> Sunrise time of currently parsed day </summary>
-        DateTime sunriseTime;
+        List<DateTime> sunriseTime;
         /// <summary> Sunset time of currently parsed day </summary>
-        DateTime sunsetTime;
+        List<DateTime> sunsetTime;
 
         /// <summary>
         /// Constructor
@@ -103 +103 @@
         /// </summary>
         override public void ParsePrediction()
         {
-            // TODO ask DataDownloader for download said file and return path to it
-            
+            sunriseTime = new List<DateTime>();
+            sunsetTime = new List<DateTime>();
+
             // get file
-            string file = loader.DownloadWeatherPrediction();
+            string data = loader.DownloadWeatherPrediction();
             DateTime now = DateTime.Now;
-            Console.WriteLine(File.Exists(file));
 
             Current = new WeatherInfo();
             Predictions = new List<WeatherInfo>();
 
-            if (!File.Exists(file))
-                return;
-
-            // read file
-            string data = File.ReadAllText(file);
-
             // parse
             JsonDocument doc = JsonDocument.Parse(data);
             JsonElement root = doc.RootElement;
@@ -173 +167 @@
         /// </summary>
         private void EncompassSunRiseSetTimes()
         {
+            if (sunsetTime.Count < 1 || sunriseTime.Count < 0)
+                return;
+
             // change current weather
-            if ((Current.startTime.TimeOfDay > sunsetTime.TimeOfDay) || (Current.startTime.TimeOfDay < sunriseTime.TimeOfDay))
+            if ((Current.startTime.TimeOfDay > sunsetTime[0].TimeOfDay) || (Current.startTime.TimeOfDay < sunriseTime[0].TimeOfDay))
                 Current.condition = WeatherConditions.Dark;
 
             // change prediction
+            int index = 0;
             for (int i = 0; i < Predictions.Count - 1; i++)
             {
                 WeatherInfo w = Predictions[i];
@@ -186 +184 @@
                 // if wNext time < than w time then it is prediction from the next day -> add 24 to correctly calculate timespan
                 int timespan = wNext.startTime.Hour - w.startTime.Hour;
                 if (wNext.startTime.Hour < w.startTime.Hour)
-                    timespan = (wNext.startTime.Hour+24) - w.startTime.Hour;
+                {
+                    timespan = (wNext.startTime.Hour + 24) - w.startTime.Hour;
+                }
                 
                 w.intervalLength = timespan;
 
                 // if start under sunset
-                if (w.startTime.TimeOfDay > sunsetTime.TimeOfDay)
+                if (w.startTime.TimeOfDay > sunsetTime[index].TimeOfDay)
                     w.condition = WeatherConditions.Dark;
 
                 // if start under sunrise
-                if (w.startTime.TimeOfDay < sunriseTime.TimeOfDay)
+                if (w.startTime.TimeOfDay < sunriseTime[index].TimeOfDay)
                 {
-                    double howMuch = ((sunriseTime.Hour * 60 + sunriseTime.Minute) - (w.startTime.Hour * 60 + w.startTime.Minute)) / 60.0;
+                    double howMuch = ((sunriseTime[index].Hour * 60 + sunriseTime[index].Minute) - (w.startTime.Hour * 60 + w.startTime.Minute)) / 60.0;
 
                     if (howMuch >= timespan / 2.0)
                         w.condition = WeatherConditions.Dark;
@@ -205 +205 @@
 
                 // if start under sunrise
                 TimeSpan endTime = new TimeSpan(w.startTime.TimeOfDay.Hours + timespan, w.startTime.TimeOfDay.Minutes, 0);
-                if (endTime > sunsetTime.TimeOfDay)
+                if (endTime > sunsetTime[index].TimeOfDay)
                 {
-                    double howMuch = ((endTime.Hours * 60 + endTime.Minutes) - (sunsetTime.Hour * 60 + sunsetTime.Minute)) / 60.0;
+                    double howMuch = ((endTime.Hours * 60 + endTime.Minutes) - (sunsetTime[index].Hour * 60 + sunsetTime[index].Minute)) / 60.0;
 
                     if (howMuch >= timespan / 2.0)
                         w.condition = WeatherConditions.Dark;
                 }
+
+                if (Predictions[i].startTime.Date !=  Predictions[i + 1].startTime.Date)
+                    index++;
             }
 
             // last prediction
@@ -221 +224 @@
             wLast.intervalLength = timespanLast;
 
             // if start under sunset
-            if (wLast.startTime.TimeOfDay > sunsetTime.TimeOfDay)
+            if (wLast.startTime.TimeOfDay > sunsetTime[sunsetTime.Count-1].TimeOfDay)
                 wLast.condition = WeatherConditions.Dark;
 
             // if start under sunrise
-            if (wLast.startTime.TimeOfDay < sunriseTime.TimeOfDay)
+            if (wLast.startTime.TimeOfDay < sunriseTime[sunriseTime.Count - 1].TimeOfDay)
             {
-                double howMuch = ((sunriseTime.Hour * 60 + sunriseTime.Minute) - (wLast.startTime.Hour * 60 + wLast.startTime.Minute)) / 60.0;
+                double howMuch = ((sunriseTime[sunriseTime.Count - 1].Hour * 60 + sunriseTime[sunriseTime.Count - 1].Minute) - (wLast.startTime.Hour * 60 + wLast.startTime.Minute)) / 60.0;
 
                 if (howMuch >= timespanLast / 2.0)
                     wLast.condition = WeatherConditions.Dark;
             }
 
             // if start under sunrise
-            if (endTimeW > sunsetTime.TimeOfDay)
+            if (endTimeW > sunsetTime[sunsetTime.Count - 1].TimeOfDay)
             {
-                double howMuch = ((endTimeW.Hours * 60 + endTimeW.Minutes) - (sunsetTime.Hour * 60 + sunsetTime.Minute)) / 60.0;
+                double howMuch = ((endTimeW.Hours * 60 + endTimeW.Minutes) - (sunsetTime[sunsetTime.Count - 1].Hour * 60 + sunsetTime[sunsetTime.Count - 1].Minute)) / 60.0;
 
                 if (howMuch >= timespanLast / 2.0)
                     wLast.condition = WeatherConditions.Dark;
@@ -296 +299 @@
                     {
                         case "sunrise":
                             {
-                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out sunriseTime);
-                                Console.WriteLine("\t sunrise time : " + sunriseTime + " " + astrInfo.Current.Value.GetString());
+                                DateTime newSunrise = new DateTime();
+                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out newSunrise);
+                                sunriseTime.Add(newSunrise);
+                                //Console.WriteLine("\t sunrise time : " + sunriseTime + " " + astrInfo.Current.Value.GetString());
                                 break;
                             }
                         case "sunset":
                             {
-                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out sunsetTime);
-                                Console.WriteLine("\t sunset time : " + sunsetTime + " " + astrInfo.Current.Value.GetString());
+                                DateTime newSunset = new DateTime();
+                                DateTime.TryParseExact(astrInfo.Current.Value.GetString(), "hh:mm tt", CultureInfo.InvariantCulture, DateTimeStyles.None, out newSunset);
+                                sunsetTime.Add(newSunset);
+                                //Console.WriteLine("\t sunset time : " + sunsetTime + " " + astrInfo.Current.Value.GetString());
                                 break;
                             }
                     }
@@ -337 +344 @@
                                 int cloudCover;
                                 Int32.TryParse(oneH.Current.Value.GetString(), out cloudCover);
                                 weather.condition = ValueToConditions.CloudCoverToConditions(cloudCover);
+                                weather.lum = ValueToConditions.TransferConditionsToLux(weather.condition);
                                 break;
                             }
                         // take into account highest value from "chanceofrain" and "chaceofsnow"
@@ -355 +363 @@
                                 break;
                             }
                         // wind kmph has to be translated to mps
-                        case "WindGustKmph":
+                        case "windspeedKmph":
                             {
                                 double windkmh;
                                 Double.TryParse(oneH.Current.Value.GetString(), out windkmh);
@@ -388 +396 @@
         private WeatherInfo ParseCurrentWeather(ArrayEnumerator currentWeather)
         {
             WeatherInfo res = new WeatherInfo();
+            res.intervalLength = 0;
             //res.current = true;
 
             while (currentWeather.MoveNext())
@@ -434 +443 @@
 
             }
 
+            res.lum = ValueToConditions.TransferConditionsToLux(res.condition);
             return res;
         }
 

Server/TestProject/ParserTests/TestingParser.cs

@@ -8 +8 @@
 using ServerApp.WeatherPredictionParser;
 using ServerApp.DataDownload;
 
-// 1h
-// 0.5h to edit parsers 
-
 namespace TestProject
 {
 
@@ -1012 +1009 @@
 
         #region Json parser
 
+        #region Parsing
+
+        string SetBasicData()
+        {
+            return
+@"{
+    ""current_condition"": [
+        {
+            ""FeelsLikeC"": ""4"",
+            ""cloudcover"": ""100"",
+            ""localObsDateTime"": ""2021-05-25 01:29 PM"",
+            ""observation_time"": ""11:29 AM"",
+            ""precipMM"": ""0.1"",
+            ""temp_C"": ""8"",
+            ""windspeedKmph"": ""13""
+        }
+    ],
+    ""weather"": [
+        {
+                ""astronomy"": [
+                    {
+                    ""sunrise"": ""05:10 AM"",
+                    ""sunset"": ""08:58 PM""
+                    }
+            ],
+            ""date"": ""2021-05-25"",
+            ""hourly"": [
+                {
+                    ""FeelsLikeC"": ""7"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""87"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""92"",
+                    ""precipMM"": ""4.5"",
+                    ""tempC"": ""9"",
+                    ""time"": ""0"",
+                    ""windspeedKmph"": ""19""
+                },
+                {
+                    ""FeelsLikeC"": ""8"",
+                    ""WindGustKmph"": ""10"",
+                    ""chanceofrain"": ""50"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""60"",
+                    ""precipMM"": ""2.0"",
+                    ""tempC"": ""9"",
+                    ""time"": ""1200"",
+                    ""windspeedKmph"": ""10""
+                }
+            ]
+        },
+        {
+                ""astronomy"": [
+                    {
+                    ""sunrise"": ""05:09 AM"",
+                    ""sunset"": ""08:59 PM""
+                    }
+            ],
+            ""date"": ""2021-05-26"",
+            ""hourly"": [
+                {
+                    ""FeelsLikeC"": ""10"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""0"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""0"",
+                    ""precipMM"": ""0"",
+                    ""tempC"": ""12"",
+                    ""time"": ""1200"",
+                    ""windspeedKmph"": ""19""
+                },
+                                {
+                    ""FeelsLikeC"": ""12"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""0"",
+                    ""chanceofsnow"": ""80"",
+                    ""cloudcover"": ""92"",
+                    ""precipMM"": ""4.5"",
+                    ""tempC"": ""19"",
+                    ""time"": ""2100"",
+                    ""windspeedKmph"": ""19""
+                }
+            ]
+        },
+        {
+                ""astronomy"": [
+                    {
+                    ""sunrise"": ""05:08 AM"",
+                    ""sunset"": ""09:00 PM""
+                    }
+            ],
+            ""date"": ""2021-05-27"",
+            ""hourly"": [
+                {
+                    ""FeelsLikeC"": ""17"",
+                    ""WindGustKmph"": ""3"",
+                    ""chanceofrain"": ""7"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""10"",
+                    ""precipMM"": ""0"",
+                    ""tempC"": ""20"",
+                    ""time"": ""1800"",
+                    ""windspeedKmph"": ""9""
+                },
+                {
+                    ""FeelsLikeC"": ""9"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""87"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""32"",
+                    ""precipMM"": ""4.5"",
+                    ""tempC"": ""9"",
+                    ""time"": ""2100"",
+                    ""windspeedKmph"": ""10""
+                }
+            ]
+        }
+    ]
+}";
+        }
+
+        string SetAstronomyData()
+        {
+            return
+    @"{
+    ""current_condition"": [
+        {
+            ""FeelsLikeC"": ""4"",
+            ""cloudcover"": ""100"",
+            ""localObsDateTime"": ""2021-05-25 01:29 PM"",
+            ""observation_time"": ""11:29 AM"",
+            ""precipMM"": ""0.1"",
+            ""temp_C"": ""8"",
+            ""windspeedKmph"": ""13""
+        }
+    ],
+    ""weather"": [
+        {
+                ""astronomy"": [
+                    {
+                    ""sunrise"": ""08:10 AM"",
+                    ""sunset"": ""06:58 PM""
+                    }
+            ],
+            ""date"": ""2021-05-25"",
+            ""hourly"": [
+                {
+                    ""FeelsLikeC"": ""7"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""87"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""92"",
+                    ""precipMM"": ""4.5"",
+                    ""tempC"": ""9"",
+                    ""time"": ""0"",
+                    ""windspeedKmph"": ""19""
+                },
+                {
+                    ""FeelsLikeC"": ""8"",
+                    ""WindGustKmph"": ""10"",
+                    ""chanceofrain"": ""50"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""60"",
+                    ""precipMM"": ""2.0"",
+                    ""tempC"": ""9"",
+                    ""time"": ""300"",
+                    ""windspeedKmph"": ""10""
+                },
+                {
+                    ""FeelsLikeC"": ""8"",
+                    ""WindGustKmph"": ""10"",
+                    ""chanceofrain"": ""50"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""60"",
+                    ""precipMM"": ""2.0"",
+                    ""tempC"": ""9"",
+                    ""time"": ""600"",
+                    ""windspeedKmph"": ""10""
+                },
+                {
+                    ""FeelsLikeC"": ""8"",
+                    ""WindGustKmph"": ""10"",
+                    ""chanceofrain"": ""50"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""60"",
+                    ""precipMM"": ""2.0"",
+                    ""tempC"": ""9"",
+                    ""time"": ""1500"",
+                    ""windspeedKmph"": ""10""
+                },
+                {
+                    ""FeelsLikeC"": ""8"",
+                    ""WindGustKmph"": ""10"",
+                    ""chanceofrain"": ""50"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""60"",
+                    ""precipMM"": ""2.0"",
+                    ""tempC"": ""9"",
+                    ""time"": ""1800"",
+                    ""windspeedKmph"": ""10""
+                },
+                {
+                    ""FeelsLikeC"": ""8"",
+                    ""WindGustKmph"": ""10"",
+                    ""chanceofrain"": ""50"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""60"",
+                    ""precipMM"": ""2.0"",
+                    ""tempC"": ""9"",
+                    ""time"": ""2100"",
+                    ""windspeedKmph"": ""10""
+                }
+            ]
+        },
+        {
+                ""astronomy"": [
+                    {
+                    ""sunrise"": ""05:09 AM"",
+                    ""sunset"": ""08:59 PM""
+                    }
+            ],
+            ""date"": ""2021-05-26"",
+            ""hourly"": [
+                {
+                    ""FeelsLikeC"": ""10"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""0"",
+                    ""chanceofsnow"": ""0"",
+                    ""cloudcover"": ""0"",
+                    ""precipMM"": ""0"",
+                    ""tempC"": ""12"",
+                    ""time"": ""1200"",
+                    ""windspeedKmph"": ""19""
+                },
+                                {
+                    ""FeelsLikeC"": ""12"",
+                    ""WindGustKmph"": ""31"",
+                    ""chanceofrain"": ""0"",
+                    ""chanceofsnow"": ""80"",
+                    ""cloudcover"": ""92"",
+                    ""precipMM"": ""4.5"",
+                    ""tempC"": ""19"",
+                    ""time"": ""2100"",
+                    ""windspeedKmph"": ""19""
+                }
+            ]
+        }
+    ]
+}";
+        }
+
         [TestMethod]
-        public void JsonParser()
+        public void JsonParserTestCurrent()
         {
-            /*
             TagInfo.CreateDictionaries();
 
-            // TODO make an input file
-            string data = "";
+            string data = SetBasicData();
 
-            Mock<DataDownloader> dl = new Mock<DataDownloader>();
+            Mock<DataDownloader> dl = new Mock<DataDownloader>("", "", "");
             dl.Setup(m => m.DownloadWeatherPrediction()).Returns(data);
 
             JsonParser target = new JsonParser(dl.Object);
 
             target.ParsePrediction();
             WeatherInfo current = target.Current;
+
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 25, 13, 29, 0), 4, 0, 3.611, ValueToConditions.CloudCoverToConditions(100), 0), current);
+        }
+
+        [TestMethod]
+        public void JsonParserTestPrediction()
+        {
+            string data = SetBasicData();
+
+            Mock<DataDownloader> dl = new Mock<DataDownloader>("", "", "");
+            dl.Setup(m => m.DownloadWeatherPrediction()).Returns(data);
+
+            JsonParser target = new JsonParser(dl.Object);
+
+            target.ParsePrediction();
+            List<WeatherInfo> retVal = target.Predictions;
+
+            Assert.AreEqual(6, retVal.Count);
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 25, 0, 0, 0), 7, 87, 5.277, ValueToConditions.CloudCoverToConditions(92), 12), retVal[0]);
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 25, 12, 0, 0), 8, 50, 2.77778, ValueToConditions.CloudCoverToConditions(60), 24), retVal[1]);
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 26, 12, 0, 0), 10, 0, 5.27778, ValueToConditions.CloudCoverToConditions(0), 9), retVal[2]);
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 26, 21, 0, 0), 12, 80, 5.27778, ValueToConditions.CloudCoverToConditions(92), 21), retVal[3]);
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 27, 18, 0, 0), 17, 7, 2.5, ValueToConditions.CloudCoverToConditions(10), 3), retVal[4]);
+            Assert.AreEqual(new WeatherInfo(new DateTime(2021, 5, 27, 21, 0, 0), 9, 87, 2.77778, WeatherConditions.Dark, 24), retVal[5]);
+        }
+
+        [TestMethod]
+        public void JsonParserEncompassSunRiseSetTimes()
+        {
+            string data = SetAstronomyData();
+
+            Mock<DataDownloader> dl = new Mock<DataDownloader>("", "", "");
+            dl.Setup(m => m.DownloadWeatherPrediction()).Returns(data);
+
+            JsonParser target = new JsonParser(dl.Object);
+
+            target.ParsePrediction();
             List<WeatherInfo> retVal = target.Predictions;
 
             Assert.AreEqual(8, retVal.Count);
-            Assert.AreEqual(new ActivityInfo("FDU", 2, new DateTime(2000, 1, 1, 9, 0, 0), 2), retVal[0]);
-            Assert.AreEqual(new ActivityInfo("FEL", 1, new DateTime(2000, 1, 1, 9, 0, 0), 2), retVal[1]);
-            Assert.AreEqual(new ActivityInfo("FDU", 2, new DateTime(2000, 1, 1, 13, 0, 0), 2), retVal[2]);
-            Assert.AreEqual(new ActivityInfo("FAV", 5, new DateTime(2000, 1, 1, 13, 0, 0), 2), retVal[3]);
-            Assert.AreEqual(new ActivityInfo("FDU", 7, new DateTime(2000, 1, 1, 17, 0, 0), 2), retVal[4]);
-            Assert.AreEqual(new ActivityInfo("FDU", 7, new DateTime(2000, 1, 1, 17, 0, 0), 2), retVal[5]);
-            Assert.AreEqual(new ActivityInfo("FDU", 7, new DateTime(2000, 1, 1, 17, 0, 0), 2), retVal[6]);
-            Assert.AreEqual(new ActivityInfo("FDU", 7, new DateTime(2000, 1, 1, 17, 0, 0), 2), retVal[7]);
-            */
+            Assert.AreEqual(WeatherConditions.Dark, retVal[0].condition);
+            Assert.AreEqual(WeatherConditions.Dark, retVal[1].condition);
+            Assert.AreNotEqual(WeatherConditions.Dark, retVal[2].condition);
+            Assert.AreNotEqual(WeatherConditions.Dark, retVal[3].condition);
+            Assert.AreEqual(WeatherConditions.Dark, retVal[4].condition);
+            Assert.AreEqual(WeatherConditions.Dark, retVal[5].condition);
+
+            Assert.AreNotEqual(WeatherConditions.Dark, retVal[6].condition);
+            Assert.AreEqual(WeatherConditions.Dark, retVal[7].condition);
         }
 
+        #endregion
 
+        #region GetPredictionForTime
         [TestMethod]
         public void GetPredictionForTimeFilter()
         {
@@ -1193 +1478 @@
             Assert.AreEqual(new WeatherInfo(new DateTime(2000, 1, 2, 6, 0, 0), 8, 1, 2, 60_000, 3), retVal[4]);
         }
         #endregion
+
+        #endregion
     }
 }