public void FNVPrimeOffset_PrimeAndOffset_Works()
        {
            {
                var fnvPrimeOffset = FNVPrimeOffset.Create(32, BigInteger.One, new BigInteger(UInt64.MaxValue));

                Assert.Equal(
                    new UInt32[] { 1 },
                    fnvPrimeOffset.Prime);

                Assert.Equal(
                    new UInt32[] { UInt32.MaxValue },
                    fnvPrimeOffset.Offset);
            }


            {
                var fnvPrimeOffset = FNVPrimeOffset.Create(96, new BigInteger(UInt64.MaxValue), BigInteger.One);


                Assert.Equal(
                    new UInt32[] { UInt32.MaxValue, UInt32.MaxValue, 0 },
                    fnvPrimeOffset.Prime);

                Assert.Equal(
                    new UInt32[] { 1, 0, 0 },
                    fnvPrimeOffset.Offset);
            }
        }
Esempio n. 2
0
            public BlockTransformer_32BitBase(FNVPrimeOffset fnvPrimeOffset)
                : this()
            {
                _prime = fnvPrimeOffset.Prime[0];

                _hashValue = fnvPrimeOffset.Offset[0];
            }
Esempio n. 3
0
        protected FNV1Base(IFNVConfig config)
        {
            if (config == null)
            {
                throw new ArgumentNullException(nameof(config));
            }


            _config = config.Clone();


            if (_config.HashSizeInBits <= 0 || _config.HashSizeInBits % 32 != 0)
            {
                throw new ArgumentOutOfRangeException($"{nameof(config)}.{nameof(config.HashSizeInBits)}", _config.HashSizeInBits, $"{nameof(config)}.{nameof(config.HashSizeInBits)} must be a positive a multiple of 32.");
            }

            if (_config.Prime <= BigInteger.Zero)
            {
                throw new ArgumentOutOfRangeException($"{nameof(config)}.{nameof(config.Prime)}", _config.Prime, $"{nameof(config)}.{nameof(config.Prime)} must be greater than zero.");
            }

            if (_config.Offset <= BigInteger.Zero)
            {
                throw new ArgumentOutOfRangeException($"{nameof(config)}.{nameof(config.Offset)}", _config.Offset, $"{nameof(config)}.{nameof(config.Offset)} must be greater than zero.");
            }


            _fnvPrimeOffset = FNVPrimeOffset.Create(_config.HashSizeInBits, _config.Prime, _config.Offset);
        }
Esempio n. 4
0
            public BlockTransformer_64BitBase(FNVPrimeOffset fnvPrimeOffset)
                : this()
            {
                _prime = ((UInt64)fnvPrimeOffset.Prime[1] << 32) | fnvPrimeOffset.Prime[0];

                _hashValue = ((UInt64)fnvPrimeOffset.Offset[1] << 32) | fnvPrimeOffset.Offset[0];
            }
Esempio n. 5
0
            public BlockTransformer_ExtendedBase(FNVPrimeOffset fnvPrimeOffset)
                : this()
            {
                _prime = fnvPrimeOffset.Prime.ToArray();

                _hashValue       = fnvPrimeOffset.Offset.ToArray();
                _hashSizeInBytes = _hashValue.Length * 4;
            }
        public void FNVPrimeOffset_Create_ValidBitSize_Throws()
        {
            var validBitSizes = new[] { 32, 64, 96, 128, 256, 512, 1024, 65536 };

            foreach (var validBitSize in validBitSizes)
            {
                var fnvPrimeOffset = FNVPrimeOffset.Create(validBitSize, BigInteger.One, BigInteger.One);

                Assert.NotNull(fnvPrimeOffset);
            }
        }
        public void FNVPrimeOffset_Create_InvalidOffset_Throws()
        {
            var invalidOffsets = new[] { new BigInteger(-65536), BigInteger.Zero, BigInteger.MinusOne };

            foreach (var invalidOffset in invalidOffsets)
            {
                Assert.Equal(
                    "offset",
                    Assert.Throws <ArgumentOutOfRangeException>(
                        () => FNVPrimeOffset.Create(32, BigInteger.One, invalidOffset))
                    .ParamName);
            }
        }
        public void FNVPrimeOffset_Create_InvalidBitSize_Throws()
        {
            var invalidBitSizes = new[] { -1, 0, 8, 16, 31, 33, 63, 65, 255 };

            foreach (var invalidBitSize in invalidBitSizes)
            {
                Assert.Equal(
                    "bitSize",
                    Assert.Throws <ArgumentOutOfRangeException>(
                        () => FNVPrimeOffset.Create(invalidBitSize, BigInteger.One, BigInteger.One))
                    .ParamName);
            }
        }
        public void FNVPrimeOffset_PrimeAndOffset_ResultsAreCached()
        {
            var fnvPrimeOffset1 = FNVPrimeOffset.Create(32, BigInteger.One, BigInteger.One);
            var fnvPrimeOffset2 = FNVPrimeOffset.Create(32, BigInteger.One, BigInteger.One);


            Assert.Equal(
                fnvPrimeOffset1.Prime,
                fnvPrimeOffset2.Prime);

            Assert.Equal(
                fnvPrimeOffset1.Prime,
                fnvPrimeOffset2.Offset);

            Assert.Equal(
                fnvPrimeOffset1.Prime,
                fnvPrimeOffset2.Prime);

            Assert.Equal(
                fnvPrimeOffset1.Prime,
                fnvPrimeOffset2.Offset);
        }
 public void FNVPrimeOffset_Create_Works()
 {
     Assert.NotNull(
         FNVPrimeOffset.Create(32, BigInteger.One, BigInteger.One));
 }
Esempio n. 11
0
 public BlockTransformer_64Bit(FNVPrimeOffset fnvPrimeOffset)
     : base(fnvPrimeOffset)
 {
 }
Esempio n. 12
0
 public BlockTransformer_Extended(FNVPrimeOffset fnvPrimeOffset)
     : base(fnvPrimeOffset)
 {
 }