public void AffineHash_Hash_Measure_Avalanche()
        {
            Random random = new Random();
            var    cases  = new[]
            {
                new { name = "zeroes", source = Enumerable.Repeat((byte)0x00, 100).ToArray() },
                new { name = "ones", source = Enumerable.Repeat((byte)0xFF, 100).ToArray() },
                new { name = "alternating-right", source = Enumerable.Repeat((byte)0x55, 100).ToArray() },
                new { name = "alternating-left", source = Enumerable.Repeat((byte)0xAA, 100).ToArray() },
                new { name = "random", source = Enumerable.Repeat(default(byte), 100).Select(b => (byte)random.Next()).ToArray() },
            };
            Avalanche avalanche = new Avalanche();

            this.TestContext.WriteLine("power,predictability,scale,shift");
            for (int trial = 0; trial < 10000; trial++)
            {
                AffineHash target = new AffineHash(random);
                avalanche.Reset(target);
                bool strong = true;
                bool weak   = false;
                foreach (var c in cases)
                {
                    avalanche.Next(c.source);
                    double predictability = avalanche.Predictability();
                    if (predictability > 0.1)
                    {
                        strong = false;
                    }

                    if (predictability > 0.2)
                    {
                        weak = true;
                    }
                }

                if (strong)
                {
                    double predictability = avalanche.Finish();
                    this.TestContext.WriteLine("strong,{0},{1},{2}", predictability, target.Scale, target.Shift);
                }

                if (weak)
                {
                    double predictability = avalanche.Finish();
                    this.TestContext.WriteLine("weak,{0},{1},{2}", predictability, target.Scale, target.Shift);
                }
            }
        }