Merge pull request #29 from LeeCampbell/TestRefactor

Test refactor

Author: LeeCampbell

src/HdrHistogram.Examples/RecorderExample.cs

@@ -14,10 +14,10 @@ namespace HdrHistogram.Examples
     /// </summary>
     static class RecorderExample
     {
-        private static readonly Recorder Recorder = new Recorder(1, TimeSpan.TicksPerHour, 3, (id, low, high, sf) => new LongHistogram(id, low, high, sf));
+        private static readonly Recorder Recorder = new Recorder(1, TimeStamp.Hours(1), 3, (id, low, high, sf) => new LongHistogram(id, low, high, sf));
         private static readonly Lazy<AddressFamily> AddressFamily = new Lazy<AddressFamily>(() => GetAddressFamily("google.com"));
         private static readonly TimeSpan RunPeriod = TimeSpan.FromSeconds(10);
-        private static readonly LongHistogram AccumulatingHistogram = new LongHistogram(TimeSpan.TicksPerHour, 3);
+        private static readonly LongHistogram AccumulatingHistogram = new LongHistogram(TimeStamp.Hours(1), 3);
         private const string LogPath = "DatagramSocket.histogram.log";        
         private static HistogramLogWriter _logWriter;
         private static FileStream _outputStream;

src/HdrHistogram.Examples/SimpleHistogramExample.cs

@@ -49,7 +49,7 @@ private static void RecordMeasurements()
         }
 
         /// <summary>
-        /// Write to the console the Memory footprint of the histogram instance and
+        /// Write to the console the memory footprint of the histogram instance and
         /// the percentile distribution of all the recorded values.
         /// </summary>
         private static void OutputMeasurements()

src/HdrHistogram.UnitTests/HdrHistogram.UnitTests.csproj

@@ -64,8 +64,12 @@
     <Compile Include="Persistence\ShortHistogramLogReaderWriterTests.cs" />
     <Compile Include="Persistence\TestCaseGenerator.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RecorderTests.cs" />
+    <Compile Include="Recording\RecorderTestsBase.cs" />
+    <Compile Include="Recording\RecorderTestWithIntHistogram.cs" />
+    <Compile Include="Recording\RecorderTestWithLongHistogram.cs" />
+    <Compile Include="Recording\RecorderTestWithLShortHistogram.cs" />
     <Compile Include="ShortHistogramTests.cs" />
+    <Compile Include="TimeStampTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />

src/HdrHistogram.UnitTests/HistogramAssert.cs

@@ -13,15 +13,15 @@ public static void AreEqual(HistogramBase expected, HistogramBase actual)
 
         public static void AreValueEqual(HistogramBase expected, HistogramBase actual)
         {
-            Assert.AreEqual(expected.TotalCount, actual.TotalCount);
-            Assert.AreEqual(expected.StartTimeStamp, actual.StartTimeStamp);
-            Assert.AreEqual(expected.EndTimeStamp, actual.EndTimeStamp);
-            Assert.AreEqual(expected.LowestTrackableValue, actual.LowestTrackableValue);
-            Assert.AreEqual(expected.HighestTrackableValue, actual.HighestTrackableValue);
-            Assert.AreEqual(expected.NumberOfSignificantValueDigits, actual.NumberOfSignificantValueDigits);
+            Assert.AreEqual(expected.TotalCount, actual.TotalCount, "TotalCount property is not equal.");
+            Assert.AreEqual(expected.StartTimeStamp, actual.StartTimeStamp, "StartTimeStamp property is not equal.");
+            Assert.AreEqual(expected.EndTimeStamp, actual.EndTimeStamp, "EndTimeStamp property is not equal.");
+            Assert.AreEqual(expected.LowestTrackableValue, actual.LowestTrackableValue, "LowestTrackableValue property is not equal.");
+            Assert.AreEqual(expected.HighestTrackableValue, actual.HighestTrackableValue, "HighestTrackableValue property is not equal.");
+            Assert.AreEqual(expected.NumberOfSignificantValueDigits, actual.NumberOfSignificantValueDigits, "NumberOfSignificantValueDigits property is not equal.");
             var expectedValues = expected.AllValues().ToArray();
             var actualValues = actual.AllValues().ToArray();
-            CollectionAssert.AreEqual(expectedValues, actualValues, HistogramIterationValueComparer.Instance);
+            CollectionAssert.AreEqual(expectedValues, actualValues, HistogramIterationValueComparer.Instance, "Recorded values differ");
         }
     }
 }

src/HdrHistogram.UnitTests/HistogramTestBase.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using NUnit.Framework;
 
@@ -11,6 +13,14 @@ public abstract class HistogramTestBase
         private const int NumberOfSignificantValueDigits = 3;
         private const long TestValueLevel = 4;
 
+        private static readonly IDictionary<int, Func<long, long, int, HistogramBase>> WordSizeToFactory =
+            new Dictionary<int, Func<long, long, int, HistogramBase>>()
+            {
+                { 2, (low, high, sf) => new ShortHistogram(low, high, sf) },
+                { 4, (low,high,sf) => new IntHistogram(low, high, sf) },
+                { 8, (low,high,sf) => new LongHistogram(low, high, sf) }
+            };
+
         [TestCase(0, 1, NumberOfSignificantValueDigits, "lowestTrackableValue", "lowestTrackableValue must be >= 1")]
         [TestCase(1, 1, NumberOfSignificantValueDigits, "highestTrackableValue", "highestTrackableValue must be >= 2 * lowestTrackableValue")]
         [TestCase(1, HighestTrackableValue, 6, "numberOfSignificantValueDigits", "numberOfSignificantValueDigits must be between 0 and 5")]
@@ -92,6 +102,37 @@ public void RecordValue_Overflow_ShouldThrowException()
             Assert.Throws<IndexOutOfRangeException>(() => longHistogram.RecordValue(HighestTrackableValue * 3));
         }
 
+        [TestCase(5)]
+        [TestCase(100)]
+        public void RecordValueWithCount_increments_TotalCount(long multiplier)
+        {
+            var histogram = Create(HighestTrackableValue, NumberOfSignificantValueDigits);
+            for (int i = 1; i < 5; i++)
+            {
+                histogram.RecordValueWithCount(i, multiplier);
+                Assert.AreEqual(i * multiplier, histogram.TotalCount);
+            }
+        }
+
+        [TestCase(5)]
+        [TestCase(100)]
+        public void RecordValueWithCount_increments_CountAtValue(long multiplier)
+        {
+            var histogram = Create(HighestTrackableValue, NumberOfSignificantValueDigits);
+            for (int i = 1; i < 5; i++)
+            {
+                histogram.RecordValueWithCount(TestValueLevel, multiplier);
+                Assert.AreEqual(i * multiplier, histogram.GetCountAtValue(TestValueLevel));
+            }
+        }
+
+        [Test]
+        public void RecordValueWithCount_Overflow_ShouldThrowException()
+        {
+            var histogram = Create(HighestTrackableValue, NumberOfSignificantValueDigits);
+            Assert.Throws<IndexOutOfRangeException>(() => histogram.RecordValueWithCount(HighestTrackableValue * 3, 10));
+        }
+
 
         [Test]
         public void RecordValueWithExpectedInterval()
@@ -269,6 +310,34 @@ public void When_more_items_are_recorded_than_totalCount_can_hold_Then_set_HasOv
             Assert.True(histogram.HasOverflowed());
         }
 
+        [Test]
+        public void Can_add_Histograms_with_larger_wordSize_when_values_are_in_range()
+        {
+            var largerHistogramFactory = WordSizeToFactory.Where(kvp => kvp.Key >= WordSize).Select(kvp => kvp.Value);
+            foreach (var sourceFactory in largerHistogramFactory)
+            {
+                CreateAndAdd(sourceFactory(1, HighestTrackableValue, NumberOfSignificantValueDigits));
+            }
+        }
+
+        [Test]
+        public void Copy_retains_all_public_properties()
+        {
+            var source = Create(1, HighestTrackableValue, NumberOfSignificantValueDigits);
+            var copy = source.Copy();
+            HistogramAssert.AreValueEqual(source, copy);
+        }
+
+        private void CreateAndAdd(HistogramBase source)
+        {
+            source.RecordValueWithCount(1, 100);
+            source.RecordValueWithCount(int.MaxValue - 1, 1000);
+
+            var target = Create(source.LowestTrackableValue, source.HighestTrackableValue, source.NumberOfSignificantValueDigits);
+            target.Add(source);
+
+            HistogramAssert.AreValueEqual(source, target);
+        }
 
         private static int GetBucketsNeededToCoverValue(int subBucketSize, long value)
         {

src/HdrHistogram.UnitTests/IntHistogramTests.cs

@@ -16,18 +16,5 @@ protected override HistogramBase Create(long lowestTrackableValue, long highestT
         {
             return new IntHistogram(lowestTrackableValue, highestTrackableValue, numberOfSignificantValueDigits);
         }
-        
-        [Test]
-        public void Can_add_LongHistogram_with_values_in_range()
-        {
-            var longHistogram = new LongHistogram(int.MaxValue - 1, 3);
-            longHistogram.RecordValueWithCount(1, 100);
-            longHistogram.RecordValueWithCount(int.MaxValue - 1, 1000);
-
-            var shortHistogram = new ShortHistogram(int.MaxValue - 1, 3);
-            shortHistogram.Add(longHistogram);
-
-            HistogramAssert.AreValueEqual(longHistogram, shortHistogram);
-        }
     }
 }

src/HdrHistogram.UnitTests/Persistence/HistogramLogReaderWriterTestBase.cs

@@ -78,6 +78,32 @@ public void CanRoundTripSingleHistogramsWithSparseValues()
             HistogramAssert.AreValueEqual(histogram, actualHistograms.Single());
         }
 
+        [Test]
+        public void CanAppendHistogram()
+        {
+            var histogram1 = Create(highestTrackableValue: long.MaxValue - 1, numberOfSignificantValueDigits: 3);
+            histogram1.RecordValue(1);
+            histogram1.RecordValue((long.MaxValue / 2) + 1);
+            histogram1.SetTimes();
+            var histogram2 = Create(highestTrackableValue: long.MaxValue - 1, numberOfSignificantValueDigits: 3);
+            histogram2.RecordValue(2);
+            histogram2.SetTimes();
+
+            byte[] data;
+            using (var writerStream = new MemoryStream())
+            using(var log = new HistogramLogWriter(writerStream))
+            {
+                log.Append(histogram1);
+                log.Append(histogram2);
+                data = writerStream.ToArray();
+            }
+            var actualHistograms = data.ReadHistograms();
+
+            Assert.AreEqual(2, actualHistograms.Length);
+            HistogramAssert.AreValueEqual(histogram1, actualHistograms.First());
+            HistogramAssert.AreValueEqual(histogram2, actualHistograms.Skip(1).First());
+        }
+        
         [TestCase("jHiccup-2.0.7S.logV2.hlog")]
         public void CanReadv2Logs(string logPath)
         {

src/HdrHistogram.UnitTests/Recording/RecorderTestWithIntHistogram.cs

@@ -0,0 +1,13 @@
+using NUnit.Framework;
+
+namespace HdrHistogram.UnitTests.Recording
+{
+    [TestFixture]
+    public sealed class RecorderTestWithIntHistogram : RecorderTestsBase
+    {
+        protected override HistogramBase Create(long id, long min, long max, int sf)
+        {
+            return new IntHistogram(id, min, max, sf);
+        }
+    }
+}

src/HdrHistogram.UnitTests/Recording/RecorderTestWithLShortHistogram.cs

@@ -0,0 +1,13 @@
+using NUnit.Framework;
+
+namespace HdrHistogram.UnitTests.Recording
+{
+    [TestFixture]
+    public sealed class RecorderTestWithLShortHistogram : RecorderTestsBase
+    {
+        protected override HistogramBase Create(long id, long min, long max, int sf)
+        {
+            return new ShortHistogram(id, min, max, sf);
+        }
+    }
+}

src/HdrHistogram.UnitTests/Recording/RecorderTestWithLongHistogram.cs

@@ -0,0 +1,13 @@
+using NUnit.Framework;
+
+namespace HdrHistogram.UnitTests.Recording
+{
+    [TestFixture]
+    public sealed class RecorderTestWithLongHistogram : RecorderTestsBase
+    {
+        protected override HistogramBase Create(long id, long min, long max, int sf)
+        {
+            return new LongHistogram(id, min, max, sf);
+        }
+    }
+}