public ReadWriteAsyncParams(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
 {
     this.Buffer = buffer;
     this.Offset = offset;
     this.Count = count;
     this.CancellationHelper = cancellationToken.CanBeCanceled ? new IOCancellationHelper(cancellationToken) : null;
 }

            public void WrapUnderlyingBytes()
            {
                var rawBytes = new Byte[0];
                var bytes = new Binary(rawBytes);

                Assert.Same(rawBytes, (Byte[])bytes);
            }

        public void CopiesResult()
        {
            // Note that a preable is not expected on the generated stream.
            string text = "Hello world";
            Byte[] textInBytes = Encoding.UTF8.GetBytes(text);
            string outputText;

            Byte[] buffer = new Byte[1024];

            using (MemoryStream stream = new MemoryStream(buffer))
            using (StringWriter writer = new StringWriter())
            using (StreamWriter outputWriter = new StreamWriter(stream))
            {
                writer.Write(text);
                writer.CopyTo(outputWriter);

                outputText = writer.ToString();
            }

            Assert.Equal(text, outputText, StringComparer.Ordinal);

            for (int i = 0; i < textInBytes.Length; i++)
            {
                Assert.Equal(textInBytes[i], buffer[i]);
            }
        }

            public static Byte[] DecompressArray(Byte[] inBuf)
            {
                Logger.Enter();
                MemoryStream memory = new MemoryStream();

                try
                {
                    using (GZipStream stream = new GZipStream(new MemoryStream(inBuf), CompressionMode.Decompress))
                    {
                        const int size = 4096;
                        byte[] buffer = new byte[size];

                        int count = 0;
                        do
                        {
                            count = stream.Read(buffer, 0, size);
                            if (count > 0)
                            {
                                memory.Write(buffer, 0, count);
                            }
                        }
                        while (count > 0);
                    }
                }
                catch(Exception ex)
                {
                    Logger.Error(String.Format("Decompress error.Internal msg: {0}", ex.Message));
                }

                Logger.Leave();
                return memory.ToArray();
            }

 public void Decrement()
 {
     // Reduce the size of the byte by 1 (note that this does not check for overflows!)
     Byte b = new Byte(1);
     b.TwosComplement();
     RippleAdd(b);
 }

        public void OnlyUsesBufferUpToSize(int count)
        {
            string text = new string('a', count);
            Byte[] textInBytes = Encoding.UTF8.GetBytes(text);

            Mock<StreamWriter> mock;

            Byte[] buffer = new Byte[textInBytes.Length + 100];

            using (MemoryStream stream = new MemoryStream(buffer))
            {
                StringWriter writer = new StringWriter();

                mock = new Mock<StreamWriter>(MockBehavior.Strict, stream) { CallBase = true };
                mock.Setup(sw => sw.Write(It.IsAny<char[]>(),
                                          It.IsAny<int>(),
                                          It.Is<int>(c => c == StringWriterExtensions.BufferSize ||
                                                          c == textInBytes.Length % StringWriterExtensions.BufferSize)))
                    .Verifiable();

                StreamWriter outputWriter = mock.Object;
                writer.Write(text);
                writer.CopyTo(outputWriter);

                mock.Verify();
            }
        }

 public static string DecompressString(Byte[] value)
 {
     if (value.Length > 0)
         return Encoding.UTF8.GetString(CLZF.Decompress(value));
     else
         return "";
 }

 public void PosTest2()
 {
     Byte[] bytes = new Byte[] { };
     UTF7Encoding UTF7 = new UTF7Encoding();
     int charCount = UTF7.GetCharCount(bytes, 0, 0);
     Assert.Equal(0, charCount);
 }

            public void CanCompareToBoxedRawBytes()
            {
                var lhs = new Binary(new Byte[] { 1, 2, 3 });
                var rhs = new Byte[] { 1, 2, 3 };

                Assert.Equal(0, lhs.CompareTo((Object)rhs));
            }

        public void ToggleBit(byte register, int bit_position)
        {
            Byte b = new Byte(Read(register));     // Read control register
            b.ToggleBit(bit_position);                // Modify oscillator bit

            // Write new byte value
            Write(register, b.ToByte());
        }

        public async Task ModifyBaseStream()
        {
            var ms = await LocalMemoryStream.readAppFileAsync(gzTestFile("GZTestDocument.txt.gz"));

            var zip = new GZipStream(ms, CompressionMode.Decompress);
            int size = 1024;
            Byte[] bytes = new Byte[size];
            zip.BaseStream.Read(bytes, 0, size); // This will throw if the underlying stream is not writeable as expected
        }

        public void PosTest3()
        {
            UnicodeEncoding uE = new UnicodeEncoding(false, true);
            Byte[] expectedValue = new Byte[] { 0xff, 0xfe };
            Byte[] actualValue;

            actualValue = uE.GetPreamble();
            Assert.Equal(expectedValue, actualValue);
        }

 public void PosTest1()
 {
     Byte[] bytes = new Byte[] {
                      85,  84,  70,  56,  32,  69, 110,
                      99, 111, 100, 105, 110, 103,  32,
                      69, 120,  97, 109, 112, 108, 101};
     UTF7Encoding utf7 = new UTF7Encoding();
     string str = utf7.GetString(bytes, 0, bytes.Length);
 }

 public GAPScanResponseEventArgs(Byte rssi, Byte packet_type, Byte[] bd_addr, Byte address_type, Byte bond, Byte[] data)
 {
     this.rssi = rssi;
     this.packet_type = packet_type;
     this.bd_addr = bd_addr;
     this.address_type = address_type;
     this.bond = bond;
     this.data = data;
 }

 public void PosTest3()
 {
     Char[] chars = GetCharArray(10);
     Byte[] bytes = new Byte[20];
     UnicodeEncoding uEncoding = new UnicodeEncoding();
     int actualValue;
     actualValue = uEncoding.GetBytes(chars, 0, 0, bytes, 20);
     Assert.Equal(0, actualValue);
 }

 public void PosTest1()
 {
     Byte[] bytes;
     String chars = "UTF7 Encoding Example";
     UTF7Encoding UTF7 = new UTF7Encoding();
     int byteCount = chars.Length;
     bytes = new Byte[byteCount];
     int bytesEncodedCount = UTF7.GetBytes(chars, 1, 2, bytes, 0);
 }

        public void PosTest3()
        {
            String chars = GetString(10);
            Byte[] bytes = new Byte[30];
            UnicodeEncoding uEncoding = new UnicodeEncoding();
            int actualValue;

            actualValue = uEncoding.GetBytes(chars, 0, 0, bytes, 30);
            Assert.Equal(0, actualValue);
        }

 public SystemBootEventArgs(UInt16 major, UInt16 minor, UInt16 patch, UInt16 build, UInt16 ll_version, Byte protocol_version, Byte hw)
 {
     this.major = major;
     this.minor = minor;
     this.patch = patch;
     this.build = build;
     this.ll_version = ll_version;
     this.protocol_version = protocol_version;
     this.hw = hw;
 }

 public void PosTest2()
 {
     Byte[] bytes;
     String chars = "";
     UTF7Encoding UTF7 = new UTF7Encoding();
     int byteCount = chars.Length;
     bytes = new Byte[byteCount];
     int bytesEncodedCount = UTF7.GetBytes(chars, 0, byteCount, bytes, 0);
     Assert.Equal(0, bytesEncodedCount);
 }

 public void PosTest2()
 {
     Char[] chars;
     Byte[] bytes = new Byte[] { };
     UTF7Encoding UTF7 = new UTF7Encoding();
     int charCount = UTF7.GetCharCount(bytes, 0, 0);
     chars = new Char[] { };
     int charsDecodedCount = UTF7.GetChars(bytes, 0, 0, chars, 0);
     Assert.Equal(0, charsDecodedCount);
 }