public void DoubleConverter(object input, double?expected) { var converter = new DoubleConverter(); var result = converter.Convert(input); Assert.AreEqual(expected, result); }
public void DoubleConverterFromDecimal() { var converter = new DoubleConverter(); var result = converter.Convert(4m / 5m); Assert.AreEqual(System.Convert.ToDouble(4m / 5m), result); }
public void Convert_ThrowsException_WhenNotDouble() { var py = Python.Instance(); var pyStr = py.Eval("\"omershelef\""); var converter = new DoubleConverter(); Assert.Throws<ConversionException>(() => converter.Convert(pyStr)); }
public void Convert_SanityCheck() { var py = Python.Instance(); var pyFloat = py.Eval("123.456789"); var converter = new DoubleConverter(); Assert.AreEqual(123.456789, converter.Convert(pyFloat)); }
public void ConvertTest() { DoubleConverter converter = new DoubleConverter(); var value = converter.Convert(10.25, typeof(object), null, CultureInfo.CurrentCulture); double d = 10.25; Assert.AreEqual(d, value); }
public void DoubleConverter_CorrectConversionTest() { Array[] data = new double[][] { new double[] { 0, 1 }, new double[] { 0.4, 0.6 }, }; var converter = new DoubleConverter(); var sut = converter.Convert(data, 2, 2); var expectation = new ushort[] { 0, ushort.MaxValue, 26214, 39321 }; sut.Should().BeEquivalentTo(expectation); }
public void Conversion() { // Arrange IConverter converter = new DoubleConverter(); var value = "42,35"; var expectedValue = 42.35; // Act using (new LangageSwitcher("fr-fr")) { var actualValue = converter.Convert(value, converter.TargetType); // Assert Assert.NotNull(actualValue); Assert.IsType <double>(actualValue); Assert.Equal(expectedValue, (Double)actualValue); } }
public List <TS> CreateEntities <T>(IEnumerable <string> resultsets, IDictionary <string, TsMetadata> metas, int period, bool skipLastPoint) where T : TS, new() { var deserializedResultsets = resultsets.Select(rs => JsonConvert.DeserializeObject <InfluxDbResultset>(rs)).ToList(); var entities = new List <TS>(); foreach (var resultset in deserializedResultsets) { foreach (var result in resultset.Results.Where(r => r.Series != null)) { var serie = result.Series.Single(); var timeseriesEntities = new List <TS>(); var meta = metas[serie.Tags.Tag]; bool valueFound = false; foreach (var value in serie.Values) { var entity = new T { Timestamp = (DateTime)value[0], AVG = DoubleConverter.Convert(value[1]), MAX = DoubleConverter.Convert(value[2]), MIN = DoubleConverter.Convert(value[3]), STD = DoubleConverter.Convert(value[4]), Id = _tagToId[serie.Tags != null ? serie.Tags.Tag : (string)value[5]], Period = period }; if (entity.AVG != null) { valueFound = true; } else if (!valueFound) { entity.AVG = meta.LastValueBeforeWatermark; entity.MAX = meta.LastValueBeforeWatermark; entity.MIN = meta.LastValueBeforeWatermark; } else { throw new Exception($"Tag has unexpected nulls: {serie.Tags.Tag}"); } if ((meta.Watermark.HasValue && entity.Timestamp > meta.Watermark) || (entity.AVG != null)) { timeseriesEntities.Add(entity); } } if (skipLastPoint) { if (timeseriesEntities.Count == 1 && (timeseriesEntities.Single().Timestamp < DateTime.UtcNow.AddDays(-1) || !meta.Watermark.HasValue)) { entities.Add(timeseriesEntities.Single()); } else { // The last point is not based on a full interval, so it should be written to SQL later. entities.AddRange(OrderByTimestamp(timeseriesEntities).Take(timeseriesEntities.Count - 1)); } } else { entities.AddRange(timeseriesEntities); } } } return(entities); }
private static async Task <IDictionary <string, (DateTime timestamp, double value)> > GetOutliers(InfluxQueryExecutor influxQueryExecutor, List <TsMetadataDto> metas, string retentionPolicy, string measurement, TagTypes tagType, string defaultTime, bool doAdHocResampling, TraceWriter log, bool beforeWatermark, int batchSize = 256, int parallelism = 32) { var dict = new Dictionary <string, (DateTime timestamp, double value)>(); int skip = 0; while (skip < metas.Count) { var tasks = new List <Task <string> >(parallelism); for (int a = 0; a < parallelism; a++) { if (skip >= metas.Count) { break; } var batchBuilder = new StringBuilder(); var batch = metas.Skip(skip).Take(batchSize); skip += batchSize; foreach (var metaInBatch in batch) { if (beforeWatermark && !metaInBatch.Timestamp.HasValue) { continue; } string tag = TagCleaner.Clean(metaInBatch.Tag); string query = beforeWatermark ? QueryBuilder.CreateFindLastPointBeforeWatermarkQuery(retentionPolicy, measurement, tagType, metaInBatch.Timestamp.Value, defaultTime, tag) : QueryBuilder.CreateFindLastPointQuery(retentionPolicy, measurement, tagType, metaInBatch.Timestamp, defaultTime, tag); batchBuilder.Append(query); } string batchedQuery = batchBuilder.ToString(); batchBuilder.Clear(); if (!string.IsNullOrWhiteSpace(batchedQuery)) { tasks.Add(influxQueryExecutor.Query(batchedQuery, log)); } } await Task.WhenAll(tasks); var deserializedResultsets = tasks.Select(t => JsonConvert.DeserializeObject <InfluxDbResultset>(t.Result)).ToList(); foreach (var resultset in deserializedResultsets) { foreach (var result in resultset.Results.Where(r => r.Series != null)) { var serie = result.Series.Single(); foreach (var value in serie.Values) { var timestamp = (DateTime)value[0]; var val = DoubleConverter.Convert(value[1]).Value; var tag = (string)value[2]; dict.Add(tag, (timestamp, val)); } } } } return(dict); }
public void Convert_test(double value, string expectedResult) { string actualResult = doubleConverter.Convert(value); Assert.AreEqual(expectedResult, actualResult); }
public void BadValueConversion() { // Arrange IConverter converter = new DoubleConverter(); var value = "Hello"; var expectedExceptionMessage = Constants.ExceptionMessages.FormatConverterUnableConvert(value, typeof(double)); var expectedInnerExceptionMessage = "Input string was not in a correct format."; // Act using (new LangageSwitcher("en-us")) { var actualException = Assert.Throws <CommandLineParserException>(() => converter.Convert(value, converter.TargetType)); // Assert Assert.Equal(expectedExceptionMessage, actualException.Message); Assert.NotNull(actualException.InnerException); var actualInnerExecption = Assert.IsAssignableFrom <FormatException>(actualException.InnerException); Assert.Equal(expectedInnerExceptionMessage, actualInnerExecption.Message); } }