Exemple #1
0
        public void CheckMeasuredValue()
        {
            var mv = new MeasuredValue();

            mv.Name = "test";
            Assert.AreEqual(true, mv.IsValueNull());
            Assert.AreEqual(false, mv.IsValid());
            mv.Value = 1;
            Assert.AreEqual(false, mv.IsValueNull());
            Assert.AreEqual(false, mv.IsValid());
            Assert.AreEqual(TypeCode.Int32, mv.GetTypeCode());

            mv.TimeStamp = DateTime.Now;
            Assert.AreEqual(false, mv.IsValueNull());
            Assert.AreEqual(true, mv.IsValid());

            mv.Value = "text";
            Assert.AreEqual(TypeCode.String, mv.GetTypeCode());

            int value = 2;

            mv.Value = value;
            Assert.AreEqual("2", mv.Value.ToString());
            Assert.AreEqual(2, mv.Value);

            /*string test = JsonConvert.SerializeObject(mv);
             * MeasuredValue mv2 = JsonConvert.DeserializeObject<MeasuredValue>(test);
             * Assert.AreEqual(2, mv2.Value);
             *
             * mv.Value = "Test";
             * test = JsonConvert.SerializeObject(mv);
             * MeasuredValue mv3 = JsonConvert.DeserializeObject<MeasuredValue>(test);
             * Assert.AreEqual("Test", mv3.Value);*/
        }
Exemple #2
0
        public static int SaveValueWhenConditionsAreMet(MeasuredValue currentValue, CompressionCondition condition)
        {
            if (currentValue == null)
            {
                throw new ArgumentNullException("currentValue");
            }
            if (condition == null)
            {
                throw new ArgumentNullException("condition");
            }

            // if the current value has the OPCQuality of "NoValue"
            // return without writting the value
            if (currentValue.Quality == OPCQuality.NoValue)
            {
                _logger.DebugFormat("current value {0} has the OPCQuality of \"NoValue\"", currentValue.Name);
                return(0);
            }

            TypeCode      typeCode      = currentValue.GetTypeCode();
            MeasuredValue previousValue = ReadLastMeasuredValueFromLocalDB(currentValue.Name, typeCode);

            if (false == condition.ShouldCurrentValueBeWritten(currentValue, previousValue))
            {
                return(0);
            }
            int rowAffected = InsertIntoDatabase(currentValue, typeCode);

            return(rowAffected);
        }
Exemple #3
0
        public void CheckMeasuredValueConverter()
        {
            string   name  = "TestName";
            string   value = "Text";
            DateTime dt    = DateTime.Now;

            MeasuredValue mv = MeasuredValueConverter.ConvertTo(name, dt, value, TypeCode.String);

            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(value, mv.Value);
            Assert.AreEqual(TypeCode.String, mv.GetTypeCode());

            TypeCode tc         = TypeCode.Int16;
            short    shortValue = 100;

            value = shortValue.ToString();
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(shortValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            tc = TypeCode.Int32;
            int intValue = 110;

            value = intValue.ToString();
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(intValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            tc = TypeCode.Int64;
            long longValue = 120;

            value = longValue.ToString();
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(longValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            tc = TypeCode.Single;
            float floatValue = 1002.2f;

            value = floatValue.ToString(System.Globalization.CultureInfo.InvariantCulture);
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(floatValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            tc = TypeCode.Double;
            double doubleValue = 2002.2;

            value = doubleValue.ToString(System.Globalization.CultureInfo.InvariantCulture);
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(doubleValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            value = doubleValue.ToString(System.Globalization.CultureInfo.CreateSpecificCulture("de"));
            MeasuredValueConverter.UsedCultureInfo = System.Globalization.CultureInfo.CreateSpecificCulture("de");
            mv = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(doubleValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            MeasuredValueConverter.UsedCultureInfo = System.Globalization.CultureInfo.InvariantCulture;
            tc = TypeCode.Boolean;
            bool boolValue = true;

            value = boolValue.ToString();
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(name, mv.Name);
            Assert.AreEqual(dt, mv.TimeStamp);
            Assert.AreEqual(boolValue, mv.Value);
            Assert.AreEqual(tc, mv.GetTypeCode());
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            value = "True";
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(boolValue, mv.Value);
            Assert.AreEqual(OPCQuality.Good, mv.Quality);

            value = "TRUE";
            mv    = MeasuredValueConverter.ConvertTo(name, dt, value, tc);
            Assert.AreEqual(boolValue, mv.Value);
            Assert.AreEqual(OPCQuality.Good, mv.Quality);
        }