public void RoundTripTest()
            {
                for (int i = 0; i < transmittedMessage.Length; i++)
                {
                    // message[i] must be elements of the field. If size = 16, field elements are 0 .. 15.
                    // rand.Next(0, 16) returns elements between 0 .. 15
                    transmittedMessage[i] = (byte)rand.Next(0, (int)fieldSize);
                }

                // ---- Encode the message ----
                watch.Start();
                encoder.Encode(transmittedMessage);
                watch.Stop();

                Array.Copy(transmittedMessage, receivedMessage, transmittedMessage.Length);

                // ---- Corrupt the message ----
                int corruptPosition;

                for (int i = 0; i < maxCorruption; i++)
                {
                    corruptPosition = rand.Next(0, receivedMessage.Length);
                    receivedMessage[corruptPosition] = (byte)rand.Next(0, (int)fieldSize);
                }

                // ---- Repair the message ----
                watch.Start();
                decoder.Decode(receivedMessage);
                watch.Stop();

                // ---- Compare ----
                ArrayHelpers.CheckArrayEquals(transmittedMessage, receivedMessage);
            }
        private static void Compare(Stream left, Stream right)
        {
            int leftReadLen;
            int rightReadLen;

            byte[] leftBuffer  = new byte[4096];
            byte[] rightBuffer = new byte[4096];

            while (true)
            {
                leftReadLen  = left.Read(leftBuffer, 0, leftBuffer.Length);
                rightReadLen = right.Read(rightBuffer, 0, rightBuffer.Length);

                if (leftReadLen != rightReadLen)
                {
                    throw new Exception();
                }

                if (leftReadLen == 0)
                {
                    break;
                }

                ArrayHelpers.CheckArrayEquals(leftBuffer, rightBuffer);
            }
        }
        public static void DecoderValidTest()
        {
            Rs256Decoder decoder = new Rs256Decoder( 16, 11, 0x13 );
            byte[] message = { 12, 12, 3, 3, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
            byte[] cleanMessage = { 12, 12, 3, 3, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

            decoder.Decode( message );

            ArrayHelpers.CheckArrayEquals( message, cleanMessage );
        }
        public static void EncoderTest()
        {
            Rs256Encoder encoder = new Rs256Encoder( 16, 11, 0x13 );
            byte[] message = { 0, 0, 0, 0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
            byte[] encodedMessage = { 12, 12, 3, 3, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

            encoder.Encode( message );

            ArrayHelpers.CheckArrayEquals( message, encodedMessage );
        }
        public static void DecoderErrorTest()
        {
            Decoder decoder = new Decoder(16, 11, 4, 0x13);

            // Note the errors:             v                   v
            int[] message      = { 12, 12, 1, 3, 11, 10, 9, 8, 1, 6, 5, 4, 3, 2, 1 };
            int[] cleanMessage = { 12, 12, 3, 3, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };

            decoder.Decode(message);

            ArrayHelpers.CheckArrayEquals(message, cleanMessage);
        }