示例#1
0
        public void CompressTest_SingleTime()
        {
            DataAtomGenerator gen    = new DataAtomGenerator();
            Compressor        target = new Compressor();

            gen.Time      = DateTime.Now;
            gen.Process   = "Foo";
            gen.Title     = "Title";
            gen.Frequency = 1;
            int count = 4;

            var sequence = gen.RandomDataStreamTakeNow(count);

            var actual = target.Compress(sequence, a => a);

            Assert.AreEqual(1, actual.Count());
            Assert.AreEqual(gen.Frequency * count, actual.ElementAt(0).Frequency);
        }
示例#2
0
        public void CompressTest_TwoTypesOneIdle_IgnoresIdle()
        {
            DataAtomGenerator gen    = new DataAtomGenerator();
            Compressor        target = new Compressor();

            gen.Time    = DateTime.Now;
            gen.Process = "Foo";
            gen.Title   = "Title";

            var sequence = gen.RandomDataStreamTakeNow(10);

            gen.Process = "Idle";
            gen.Title   = string.Empty;
            sequence    = sequence.Union(gen.RandomDataStreamTakeNow(20)).ToArray();

            var actual = target.Compress(sequence, a => a);

            Assert.AreEqual(1, actual.Count());
        }
示例#3
0
        public void CompressTest_TwoTime()
        {
            DataAtomGenerator gen    = new DataAtomGenerator();
            Compressor        target = new Compressor();

            gen.Time      = DateTime.Now.AddDays(-1);
            gen.Process   = "Foo";
            gen.Title     = "Title";
            gen.Frequency = 1;
            int count1 = 4;
            int count2 = 5;

            var sequence = gen.RandomDataStreamTakeNow(count1);

            gen.Time = gen.Time.Value.AddDays(1);

            sequence = sequence.Union(gen.RandomDataStreamTakeNow(count2)).ToArray();

            var actual = target.Compress(sequence, a => a);

            Assert.AreEqual(2, actual.Count());
            Assert.AreEqual(gen.Frequency * count1, actual.ElementAt(0).Frequency);
            Assert.AreEqual(gen.Frequency * count2, actual.ElementAt(1).Frequency);
        }
示例#4
0
        public void Basic_ListAtom_RankedDataFormat()
        {
            #region Setup
            DataAtomGenerator gen = new DataAtomGenerator();

            gen.Process   = "Foo";
            gen.Frequency = 10;             // 30

            var sequence = gen.RandomDataStreamTakeNow(3);

            gen.Process   = "Qux";
            gen.Frequency = 25;             // 50
            sequence      = sequence.Union(gen.RandomDataStreamTakeNow(2)).ToArray();

            gen.Process   = "Bar";
            gen.Frequency = 50;             // 200
            sequence      = sequence.Union(gen.RandomDataStreamTakeNow(4)).ToArray();

            gen.Process   = "Pqr";
            gen.Frequency = 20;             // 20
            sequence      = sequence.Union(gen.RandomDataStreamTakeNow(1)).ToArray();

            List <RankedDataFormat> expected = new List <RankedDataFormat>()
            {
                new RankedDataFormat()
                {
                    Rank     = 1,
                    Activity = "Bar",
                    TimeSpan = 200
                },
                new RankedDataFormat()
                {
                    Rank     = 2,
                    Activity = "Qux",
                    TimeSpan = 50
                },
                new RankedDataFormat()
                {
                    Rank     = 3,
                    Activity = "Foo",
                    TimeSpan = 30
                },
                new RankedDataFormat()
                {
                    Rank     = 4,
                    Activity = "Pqr",
                    TimeSpan = 20
                }
            };
            #endregion

            var actual = new List <RankedDataFormat>(new DataFormatConvertor(sequence).ToRankedDataFormat());

            #region Verify
            Assert.AreEqual(expected.Count, actual.Count);
            for (int i = 0; i < actual.Count; i++)
            {
                Assert.AreEqual(expected[i].Rank, actual[i].Rank);
                Assert.AreEqual(expected[i].TimeSpan, actual[i].TimeSpan);
                Assert.AreEqual(expected[i].Activity, actual[i].Activity);
            }
            #endregion
        }