Exemple #1
0
        public void HydrometricDataValueExtraB_Every_Property_Has_Get_Set_Test()
        {
            string val1 = "Some text";

            hydrometricDataValueExtraB.HydrometricDataValueReportTest = val1;
            Assert.AreEqual(val1, hydrometricDataValueExtraB.HydrometricDataValueReportTest);
            string val2 = "Some text";

            hydrometricDataValueExtraB.LastUpdateContactText = val2;
            Assert.AreEqual(val2, hydrometricDataValueExtraB.LastUpdateContactText);
            string val3 = "Some text";

            hydrometricDataValueExtraB.StorageDataTypeText = val3;
            Assert.AreEqual(val3, hydrometricDataValueExtraB.StorageDataTypeText);
            int val4 = 45;

            hydrometricDataValueExtraB.HydrometricDataValueID = val4;
            Assert.AreEqual(val4, hydrometricDataValueExtraB.HydrometricDataValueID);
            int val5 = 45;

            hydrometricDataValueExtraB.HydrometricSiteID = val5;
            Assert.AreEqual(val5, hydrometricDataValueExtraB.HydrometricSiteID);
            DateTime val6 = new DateTime(2010, 3, 4);

            hydrometricDataValueExtraB.DateTime_Local = val6;
            Assert.AreEqual(val6, hydrometricDataValueExtraB.DateTime_Local);
            bool val7 = true;

            hydrometricDataValueExtraB.Keep = val7;
            Assert.AreEqual(val7, hydrometricDataValueExtraB.Keep);
            StorageDataTypeEnum val8 = (StorageDataTypeEnum)3;

            hydrometricDataValueExtraB.StorageDataType = val8;
            Assert.AreEqual(val8, hydrometricDataValueExtraB.StorageDataType);
            bool val9 = true;

            hydrometricDataValueExtraB.HasBeenRead = val9;
            Assert.AreEqual(val9, hydrometricDataValueExtraB.HasBeenRead);
            double val10 = 87.9D;

            hydrometricDataValueExtraB.Discharge_m3_s = val10;
            Assert.AreEqual(val10, hydrometricDataValueExtraB.Discharge_m3_s);
            double val11 = 87.9D;

            hydrometricDataValueExtraB.DischargeEntered_m3_s = val11;
            Assert.AreEqual(val11, hydrometricDataValueExtraB.DischargeEntered_m3_s);
            double val12 = 87.9D;

            hydrometricDataValueExtraB.Level_m = val12;
            Assert.AreEqual(val12, hydrometricDataValueExtraB.Level_m);
            string val13 = "Some text";

            hydrometricDataValueExtraB.HourlyValues = val13;
            Assert.AreEqual(val13, hydrometricDataValueExtraB.HourlyValues);
            DateTime val14 = new DateTime(2010, 3, 4);

            hydrometricDataValueExtraB.LastUpdateDate_UTC = val14;
            Assert.AreEqual(val14, hydrometricDataValueExtraB.LastUpdateDate_UTC);
            int val15 = 45;

            hydrometricDataValueExtraB.LastUpdateContactTVItemID = val15;
            Assert.AreEqual(val15, hydrometricDataValueExtraB.LastUpdateContactTVItemID);
            bool val16 = true;

            hydrometricDataValueExtraB.HasErrors = val16;
            Assert.AreEqual(val16, hydrometricDataValueExtraB.HasErrors);
            IEnumerable <ValidationResult> val51 = new List <ValidationResult>()
            {
                new ValidationResult("First CSSPError Message")
            }.AsEnumerable();

            hydrometricDataValueExtraB.ValidationResults = val51;
            Assert.AreEqual(val51, hydrometricDataValueExtraB.ValidationResults);
        }
        public void TideDataValueExtraB_Every_Property_Has_Get_Set_Test()
        {
            string val1 = "Some text";

            tideDataValueExtraB.TideDataValueReportTest = val1;
            Assert.AreEqual(val1, tideDataValueExtraB.TideDataValueReportTest);
            string val2 = "Some text";

            tideDataValueExtraB.TideSiteText = val2;
            Assert.AreEqual(val2, tideDataValueExtraB.TideSiteText);
            string val3 = "Some text";

            tideDataValueExtraB.LastUpdateContactText = val3;
            Assert.AreEqual(val3, tideDataValueExtraB.LastUpdateContactText);
            string val4 = "Some text";

            tideDataValueExtraB.TideDataTypeText = val4;
            Assert.AreEqual(val4, tideDataValueExtraB.TideDataTypeText);
            string val5 = "Some text";

            tideDataValueExtraB.StorageDataTypeText = val5;
            Assert.AreEqual(val5, tideDataValueExtraB.StorageDataTypeText);
            string val6 = "Some text";

            tideDataValueExtraB.TideStartText = val6;
            Assert.AreEqual(val6, tideDataValueExtraB.TideStartText);
            string val7 = "Some text";

            tideDataValueExtraB.TideEndText = val7;
            Assert.AreEqual(val7, tideDataValueExtraB.TideEndText);
            int val8 = 45;

            tideDataValueExtraB.TideDataValueID = val8;
            Assert.AreEqual(val8, tideDataValueExtraB.TideDataValueID);
            int val9 = 45;

            tideDataValueExtraB.TideSiteTVItemID = val9;
            Assert.AreEqual(val9, tideDataValueExtraB.TideSiteTVItemID);
            DateTime val10 = new DateTime(2010, 3, 4);

            tideDataValueExtraB.DateTime_Local = val10;
            Assert.AreEqual(val10, tideDataValueExtraB.DateTime_Local);
            bool val11 = true;

            tideDataValueExtraB.Keep = val11;
            Assert.AreEqual(val11, tideDataValueExtraB.Keep);
            TideDataTypeEnum val12 = (TideDataTypeEnum)3;

            tideDataValueExtraB.TideDataType = val12;
            Assert.AreEqual(val12, tideDataValueExtraB.TideDataType);
            StorageDataTypeEnum val13 = (StorageDataTypeEnum)3;

            tideDataValueExtraB.StorageDataType = val13;
            Assert.AreEqual(val13, tideDataValueExtraB.StorageDataType);
            double val14 = 87.9D;

            tideDataValueExtraB.Depth_m = val14;
            Assert.AreEqual(val14, tideDataValueExtraB.Depth_m);
            double val15 = 87.9D;

            tideDataValueExtraB.UVelocity_m_s = val15;
            Assert.AreEqual(val15, tideDataValueExtraB.UVelocity_m_s);
            double val16 = 87.9D;

            tideDataValueExtraB.VVelocity_m_s = val16;
            Assert.AreEqual(val16, tideDataValueExtraB.VVelocity_m_s);
            TideTextEnum val17 = (TideTextEnum)3;

            tideDataValueExtraB.TideStart = val17;
            Assert.AreEqual(val17, tideDataValueExtraB.TideStart);
            TideTextEnum val18 = (TideTextEnum)3;

            tideDataValueExtraB.TideEnd = val18;
            Assert.AreEqual(val18, tideDataValueExtraB.TideEnd);
            DateTime val19 = new DateTime(2010, 3, 4);

            tideDataValueExtraB.LastUpdateDate_UTC = val19;
            Assert.AreEqual(val19, tideDataValueExtraB.LastUpdateDate_UTC);
            int val20 = 45;

            tideDataValueExtraB.LastUpdateContactTVItemID = val20;
            Assert.AreEqual(val20, tideDataValueExtraB.LastUpdateContactTVItemID);
            bool val21 = true;

            tideDataValueExtraB.HasErrors = val21;
            Assert.AreEqual(val21, tideDataValueExtraB.HasErrors);
            IEnumerable <ValidationResult> val66 = new List <ValidationResult>()
            {
                new ValidationResult("First CSSPError Message")
            }.AsEnumerable();

            tideDataValueExtraB.ValidationResults = val66;
            Assert.AreEqual(val66, tideDataValueExtraB.ValidationResults);
        }
        public void ClimateDataValueExtraB_Every_Property_Has_Get_Set_Test()
        {
            string val1 = "Some text";

            climateDataValueExtraB.ClimateDataValueReportTest = val1;
            Assert.AreEqual(val1, climateDataValueExtraB.ClimateDataValueReportTest);
            string val2 = "Some text";

            climateDataValueExtraB.LastUpdateContactText = val2;
            Assert.AreEqual(val2, climateDataValueExtraB.LastUpdateContactText);
            string val3 = "Some text";

            climateDataValueExtraB.StorageDataTypeEnumText = val3;
            Assert.AreEqual(val3, climateDataValueExtraB.StorageDataTypeEnumText);
            int val4 = 45;

            climateDataValueExtraB.ClimateDataValueID = val4;
            Assert.AreEqual(val4, climateDataValueExtraB.ClimateDataValueID);
            int val5 = 45;

            climateDataValueExtraB.ClimateSiteID = val5;
            Assert.AreEqual(val5, climateDataValueExtraB.ClimateSiteID);
            DateTime val6 = new DateTime(2010, 3, 4);

            climateDataValueExtraB.DateTime_Local = val6;
            Assert.AreEqual(val6, climateDataValueExtraB.DateTime_Local);
            bool val7 = true;

            climateDataValueExtraB.Keep = val7;
            Assert.AreEqual(val7, climateDataValueExtraB.Keep);
            StorageDataTypeEnum val8 = (StorageDataTypeEnum)3;

            climateDataValueExtraB.StorageDataType = val8;
            Assert.AreEqual(val8, climateDataValueExtraB.StorageDataType);
            bool val9 = true;

            climateDataValueExtraB.HasBeenRead = val9;
            Assert.AreEqual(val9, climateDataValueExtraB.HasBeenRead);
            double val10 = 87.9D;

            climateDataValueExtraB.Snow_cm = val10;
            Assert.AreEqual(val10, climateDataValueExtraB.Snow_cm);
            double val11 = 87.9D;

            climateDataValueExtraB.Rainfall_mm = val11;
            Assert.AreEqual(val11, climateDataValueExtraB.Rainfall_mm);
            double val12 = 87.9D;

            climateDataValueExtraB.RainfallEntered_mm = val12;
            Assert.AreEqual(val12, climateDataValueExtraB.RainfallEntered_mm);
            double val13 = 87.9D;

            climateDataValueExtraB.TotalPrecip_mm_cm = val13;
            Assert.AreEqual(val13, climateDataValueExtraB.TotalPrecip_mm_cm);
            double val14 = 87.9D;

            climateDataValueExtraB.MaxTemp_C = val14;
            Assert.AreEqual(val14, climateDataValueExtraB.MaxTemp_C);
            double val15 = 87.9D;

            climateDataValueExtraB.MinTemp_C = val15;
            Assert.AreEqual(val15, climateDataValueExtraB.MinTemp_C);
            double val16 = 87.9D;

            climateDataValueExtraB.HeatDegDays_C = val16;
            Assert.AreEqual(val16, climateDataValueExtraB.HeatDegDays_C);
            double val17 = 87.9D;

            climateDataValueExtraB.CoolDegDays_C = val17;
            Assert.AreEqual(val17, climateDataValueExtraB.CoolDegDays_C);
            double val18 = 87.9D;

            climateDataValueExtraB.SnowOnGround_cm = val18;
            Assert.AreEqual(val18, climateDataValueExtraB.SnowOnGround_cm);
            double val19 = 87.9D;

            climateDataValueExtraB.DirMaxGust_0North = val19;
            Assert.AreEqual(val19, climateDataValueExtraB.DirMaxGust_0North);
            double val20 = 87.9D;

            climateDataValueExtraB.SpdMaxGust_kmh = val20;
            Assert.AreEqual(val20, climateDataValueExtraB.SpdMaxGust_kmh);
            string val21 = "Some text";

            climateDataValueExtraB.HourlyValues = val21;
            Assert.AreEqual(val21, climateDataValueExtraB.HourlyValues);
            DateTime val22 = new DateTime(2010, 3, 4);

            climateDataValueExtraB.LastUpdateDate_UTC = val22;
            Assert.AreEqual(val22, climateDataValueExtraB.LastUpdateDate_UTC);
            int val23 = 45;

            climateDataValueExtraB.LastUpdateContactTVItemID = val23;
            Assert.AreEqual(val23, climateDataValueExtraB.LastUpdateContactTVItemID);
            bool val24 = true;

            climateDataValueExtraB.HasErrors = val24;
            Assert.AreEqual(val24, climateDataValueExtraB.HasErrors);
            IEnumerable <ValidationResult> val75 = new List <ValidationResult>()
            {
                new ValidationResult("First CSSPError Message")
            }.AsEnumerable();

            climateDataValueExtraB.ValidationResults = val75;
            Assert.AreEqual(val75, climateDataValueExtraB.ValidationResults);
        }
        public void TideDataValue_Every_Property_Has_Get_Set_Test()
        {
            int val1 = 45;

            tideDataValue.TideDataValueID = val1;
            Assert.AreEqual(val1, tideDataValue.TideDataValueID);
            int val2 = 45;

            tideDataValue.TideSiteTVItemID = val2;
            Assert.AreEqual(val2, tideDataValue.TideSiteTVItemID);
            DateTime val3 = new DateTime(2010, 3, 4);

            tideDataValue.DateTime_Local = val3;
            Assert.AreEqual(val3, tideDataValue.DateTime_Local);
            bool val4 = true;

            tideDataValue.Keep = val4;
            Assert.AreEqual(val4, tideDataValue.Keep);
            TideDataTypeEnum val5 = (TideDataTypeEnum)3;

            tideDataValue.TideDataType = val5;
            Assert.AreEqual(val5, tideDataValue.TideDataType);
            StorageDataTypeEnum val6 = (StorageDataTypeEnum)3;

            tideDataValue.StorageDataType = val6;
            Assert.AreEqual(val6, tideDataValue.StorageDataType);
            double val7 = 87.9D;

            tideDataValue.Depth_m = val7;
            Assert.AreEqual(val7, tideDataValue.Depth_m);
            double val8 = 87.9D;

            tideDataValue.UVelocity_m_s = val8;
            Assert.AreEqual(val8, tideDataValue.UVelocity_m_s);
            double val9 = 87.9D;

            tideDataValue.VVelocity_m_s = val9;
            Assert.AreEqual(val9, tideDataValue.VVelocity_m_s);
            TideTextEnum val10 = (TideTextEnum)3;

            tideDataValue.TideStart = val10;
            Assert.AreEqual(val10, tideDataValue.TideStart);
            TideTextEnum val11 = (TideTextEnum)3;

            tideDataValue.TideEnd = val11;
            Assert.AreEqual(val11, tideDataValue.TideEnd);
            DateTime val12 = new DateTime(2010, 3, 4);

            tideDataValue.LastUpdateDate_UTC = val12;
            Assert.AreEqual(val12, tideDataValue.LastUpdateDate_UTC);
            int val13 = 45;

            tideDataValue.LastUpdateContactTVItemID = val13;
            Assert.AreEqual(val13, tideDataValue.LastUpdateContactTVItemID);
            bool val14 = true;

            tideDataValue.HasErrors = val14;
            Assert.AreEqual(val14, tideDataValue.HasErrors);
            IEnumerable <ValidationResult> val45 = new List <ValidationResult>()
            {
                new ValidationResult("First CSSPError Message")
            }.AsEnumerable();

            tideDataValue.ValidationResults = val45;
            Assert.AreEqual(val45, tideDataValue.ValidationResults);
        }