public void SpinSortValidation()
        {
            var vector         = new CorrelationVectorV2();
            var spinParameters = new SpinParameters
            {
                Entropy     = SpinEntropy.Two,
                Interval    = SpinCounterInterval.Fine,
                Periodicity = SpinCounterPeriodicity.Short
            };

            uint lastSpinValue  = 0;
            var  wrappedCounter = 0;

            for (int i = 0; i < 100; i++)
            {
                // The cV after a Spin will look like <cvBase>.0.<spinValue>.0, so the spinValue is at index = 2.
                var spinValue = uint.Parse(CorrelationVector.Spin(vector.Value, spinParameters).Value.Split('.')[2]);

                // Count the number of times the counter wraps.
                if (spinValue <= lastSpinValue)
                {
                    wrappedCounter++;
                }

                lastSpinValue = spinValue;

                // Wait for 10ms.
                Task.Delay(10).Wait();
            }

            // The counter should wrap at most 1 time.
            Assert.IsTrue(wrappedCounter <= 1);
        }
        public void ConvertFromVectorBaseToGuidBackToVectorBase()
        {
            // CV bases which have four zero least significant bits meaning a conversion to a Guid will retain all
            // information.
            // CV Base -> Guid -> CV Base conversions result in:
            //   /////////////////////A -> ffffffff-ffff-ffff-ffff-fffffffffffc -> /////////////////////A
            //   /////////////////////Q -> ffffffff-ffff-ffff-ffff-fffffffffffd -> /////////////////////Q
            //   /////////////////////g -> ffffffff-ffff-ffff-ffff-fffffffffffe -> /////////////////////g
            //   /////////////////////w -> ffffffff-ffff-ffff-ffff-ffffffffffff -> /////////////////////w
            string[] validGuidVectorBases = new string[]
            {
                "/////////////////////A",
                "/////////////////////Q",
                "/////////////////////g",
                "/////////////////////w",
            };

            foreach (string vectorBase in validGuidVectorBases)
            {
                var  correlationVector         = CorrelationVector.Parse($"{vectorBase}.0");
                Guid baseAsGuid                = correlationVector.GetBaseAsGuid();
                var  correlationVectorFromGuid = new CorrelationVectorV2(baseAsGuid);

                Assert.AreEqual(correlationVector.Value, correlationVectorFromGuid.Value,
                                $"Correlation vector base -> guid -> correlation vector base should result in the same vector base for {vectorBase}");
            }
        }
        public void GetBaseAsGuidV2Test()
        {
            var  guid = System.Guid.NewGuid();
            var  correlationVector = new CorrelationVectorV2(guid);
            Guid baseAsGuid        = correlationVector.GetBaseAsGuid();

            Assert.AreEqual(guid, baseAsGuid, "Correlation Vector base as a guid should be the same as the initial guid");
        }
        public void CreateV2CorrelationVectorTest()
        {
            var correlationVector = new CorrelationVectorV2();
            var splitVector       = correlationVector.Value.Split('.');

            Assert.AreEqual(2, splitVector.Length, "Correlation Vector should be created with two components separated by a '.'");
            Assert.AreEqual(22, splitVector[0].Length, "Correlation Vector base should be 22 characters long");
            Assert.AreEqual("0", splitVector[1], "Correlation Vector extension should start with zero");
        }