public void Test_ToByte()
        {
            var converter = new AutoByteConverter();
            var actual = converter.ToByte(_buffer, 0);
            const int expected = 128;

            Assert.AreEqual(expected, actual);
        }
        public void Test_ToInt32()
        {
            var converter = new AutoByteConverter();
            var actual = converter.ToInt32(_buffer, 8);
            const uint expected = 5u;

            Assert.AreEqual(expected, actual);
        }
 public void SetUp()
 {
     _address = string.Format("{0}:11207", ConfigurationManager.AppSettings["serverIp"]);
     var ipEndpoint = UriExtensions.GetEndPoint(_address);
     var factory = DefaultConnectionFactory.GetGeneric<SslConnection>();
     var converter = new AutoByteConverter();
     _configuration = new PoolConfiguration(MaxSize, MinSize, WaitTimeout, RecieveTimeout, ShutdownTimeout, SendTimeout)
     {
         UseSsl = true
     };
     _connectionPool = new ConnectionPool<SslConnection>(_configuration, ipEndpoint, factory, converter);
     _connectionPool.Initialize();
 }
        public void Test_Timed_Execution_Parallel()
        {
            var options = new ParallelOptions { MaxDegreeOfParallelism = 4 };
            var converter = new AutoByteConverter();
            var serializer = new TypeSerializer(converter);
            var vbucket = GetVBucket();
            var n = 1000;//set to a higher # if needed

            using (new OperationTimer())
            {
                Parallel.For(0, n, options, i =>
                {
                    var key = string.Format("key{0}", i);
                    var set = new Set<int>(key, i, vbucket, converter);
                    var result = IOStrategy.Execute(set);
                    Assert.IsTrue(result.Success);
  
                    var get = new Get<int>(key, vbucket, converter, serializer);
                    var result1 = IOStrategy.Execute(get);
                    Assert.IsTrue(result1.Success); 
                    Assert.AreEqual(i, result1.Value);
                });
            }
        }
        public void Test_Timed_Execution()
        {
            var converter = new AutoByteConverter();
            var serializer = new TypeSerializer(converter);
            var vbucket = GetVBucket();
            int n = 1000; //set to a higher # if needed

            using (new OperationTimer())
            {
                var key = string.Format("key{0}", 111);
                var set = new Set<int>(key, 111, vbucket, converter);
                var get = new Get<int>(key, vbucket, converter, serializer);

                for (var i = 0; i < n; i++)
                {
                    var result = IOStrategy.Execute(set);
                    Assert.IsTrue(result.Success);

                    var result1 = IOStrategy.Execute(get);
                    Assert.IsTrue(result1.Success);
                    Assert.AreEqual(111, result1.Value);
                }
            }
        }
        public void Test_Cas2()
        {
            var converter = new AutoByteConverter();
             var bytes = new byte[]
             {
                 0x00,
		        0x00,
		        0xa9,
		        0x53,
		        0x5f,
		        0x3d,
		        0xa7,
		        0x0f
             };
             const ulong expected = 186175545255695;
            var actual = converter.ToUInt64(bytes, 0);
            Assert.AreEqual(expected, actual);
        }
 public void Test_Cas()
 {
     var converter = new AutoByteConverter();
     var bytes = new byte[] {255, 255, 255, 255, 229, 93, 159, 223};
     const ulong expected = 18446744073262702559;
     var actual = converter.ToUInt64(bytes, 0);
     Assert.AreEqual(expected, actual);
 }
        public void Test_FromUInt64()
        {
            var converter = new AutoByteConverter();
            var actual = new byte[15];
            converter.FromUInt64(5, actual, 3);
            var expected = new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00 };

            Assert.AreEqual(expected, actual);
        }
        public void Test_ToString()
        {
            const int offset = 24;
            const int length = 5;

            var converter = new AutoByteConverter();
            var actual = converter.ToString(_buffer, offset, length);
            const string expected = "Hello";

            Assert.AreEqual(expected, actual);
        }