public void StaticBehaviorTest()
 {
     BufferingReadStreamTestWrapper bufferedReadStream = new BufferingReadStreamTestWrapper(new MemoryStream());
     this.Assert.IsTrue(bufferedReadStream.CanRead, "CanRead should be true.");
     this.Assert.IsFalse(bufferedReadStream.CanSeek, "CanSeek should be false.");
     this.Assert.IsFalse(bufferedReadStream.CanWrite, "CanWrite should be false.");
 }
Beispiel #2
0
        public void StaticBehaviorTest()
        {
            BufferingReadStreamTestWrapper bufferedReadStream = new BufferingReadStreamTestWrapper(new MemoryStream());

            this.Assert.IsTrue(bufferedReadStream.CanRead, "CanRead should be true.");
            this.Assert.IsFalse(bufferedReadStream.CanSeek, "CanSeek should be false.");
            this.Assert.IsFalse(bufferedReadStream.CanWrite, "CanWrite should be false.");
        }
Beispiel #3
0
        public void BufferingReadStreamTest()
        {
            IEnumerable <ReadOperation[]> bufferingReads = new ReadOperation[][]
            {
                new ReadOperation[]
                {
                    // No buffering reads
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9
                    }
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 19
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = 8, ExpectedBytesRead = 8, ExpectedResult = 12
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = byte.MaxValue, ExpectedBytesRead = byte.MaxValue, ExpectedResult = byte.MaxValue - 1
                    },
                },
            };

            IEnumerable <ReadOperation[]> replayReads = new ReadOperation[][]
            {
                new ReadOperation[]
                {
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9
                    }
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 20, ExpectedBytesRead = 20, ExpectedResult = 19
                    }
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 2, ExpectedBytesRead = 2, ExpectedResult = 1
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 6
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 2, ExpectedBytesRead = 2, ExpectedResult = 1
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 6
                    },
                    new ReadOperation {
                        Count = 3, ExpectedBytesRead = 3, ExpectedResult = 9
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 1, ExpectedBytesRead = 1, ExpectedResult = 0
                    },
                    new ReadOperation {
                        Count = 1, ExpectedBytesRead = 1, ExpectedResult = 1
                    },
                    new ReadOperation {
                        Count = 1, ExpectedBytesRead = 1, ExpectedResult = 2
                    },
                    new ReadOperation {
                        Count = 1, ExpectedBytesRead = 1, ExpectedResult = 3
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 19
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14
                    },
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 24
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 19
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 19
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 19
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 20, ExpectedBytesRead = 20, ExpectedResult = 19
                    },
                    new ReadOperation {
                        Count = 20, ExpectedBytesRead = 20, ExpectedResult = 39
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = byte.MaxValue, ExpectedBytesRead = byte.MaxValue, ExpectedResult = byte.MaxValue - 1
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = byte.MaxValue, ExpectedBytesRead = byte.MaxValue, ExpectedResult = byte.MaxValue - 1
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 0, ExpectedResult = byte.MaxValue - 1
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 0, ExpectedResult = byte.MaxValue - 1
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 0, ExpectedResult = byte.MaxValue - 1
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 14
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9
                    },
                    new ReadOperation {
                        Count = 10, ExpectedBytesRead = 10, ExpectedResult = 19
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4
                    },
                    new ReadOperation {
                        Count = byte.MaxValue - 5, ExpectedBytesRead = byte.MaxValue - 5, ExpectedResult = byte.MaxValue - 1
                    },
                },
                new ReadOperation[]
                {
                    new ReadOperation {
                        Count = 20, ExpectedBytesRead = 20, ExpectedResult = 19
                    },
                    new ReadOperation {
                        Count = byte.MaxValue - 20, ExpectedBytesRead = byte.MaxValue - 20, ExpectedResult = byte.MaxValue - 1
                    },
                },
            };

            this.CombinatorialEngineProvider.RunCombinations(
                bufferingReads,
                // Adding the null case to completely skip the buffering replay reads
                replayReads.ConcatSingle(null),
                replayReads,
                (bufferingRead, bufferingReplayRead, replayRead) =>
            {
                MemoryStream testStream = new MemoryStream(testBytes);
                BufferingReadStreamTestWrapper bufferingReadStream = new BufferingReadStreamTestWrapper(testStream);

                byte[] targetBuffer = new byte[1000];
                int currentOffset   = 0;

                foreach (ReadOperation readOp in bufferingRead)
                {
                    int bytesRead = bufferingReadStream.Read(targetBuffer, currentOffset, readOp.Count);
                    this.Assert.AreEqual(readOp.ExpectedBytesRead, bytesRead, "Bytes read differs.");

                    currentOffset += bytesRead;
                    this.Assert.AreEqual(readOp.ExpectedResult, targetBuffer[currentOffset - 1], "Last byte read differs.");
                }

                if (bufferingReplayRead != null)
                {
                    bufferingReadStream.ResetStream();

                    targetBuffer  = new byte[1000];
                    currentOffset = 0;

                    foreach (ReadOperation readOp in bufferingReplayRead)
                    {
                        int bytesRead = bufferingReadStream.Read(targetBuffer, currentOffset, readOp.Count);
                        this.Assert.AreEqual(readOp.ExpectedBytesRead, bytesRead, "Bytes read differs.");

                        currentOffset += bytesRead;
                        this.Assert.AreEqual(readOp.ExpectedResult, targetBuffer[currentOffset - 1], "Last byte read differs.");
                    }
                }

                bufferingReadStream.StopBuffering();

                targetBuffer  = new byte[1000];
                currentOffset = 0;

                foreach (ReadOperation readOp in replayRead)
                {
                    int bytesRead = bufferingReadStream.Read(targetBuffer, currentOffset, readOp.Count);
                    this.Assert.AreEqual(readOp.ExpectedBytesRead, bytesRead, "Bytes read differs.");

                    currentOffset += bytesRead;
                    this.Assert.AreEqual(readOp.ExpectedResult, targetBuffer[currentOffset - 1], "Last byte read differs.");
                }
            });
        }
        public void BufferingReadStreamTest()
        {
            IEnumerable<ReadOperation[]> bufferingReads = new ReadOperation[][]
            {
                new ReadOperation[]
                {
                    // No buffering reads
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9 }
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 19 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = 8, ExpectedBytesRead = 8, ExpectedResult = 12 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = byte.MaxValue, ExpectedBytesRead = byte.MaxValue, ExpectedResult = byte.MaxValue - 1 },
                },
            };

            IEnumerable<ReadOperation[]> replayReads = new ReadOperation[][]
            {
                new ReadOperation[]
                {
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4},
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9 }
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 20, ExpectedBytesRead = 20, ExpectedResult = 19 }
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 2, ExpectedBytesRead = 2, ExpectedResult = 1 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 6 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 2, ExpectedBytesRead = 2, ExpectedResult = 1 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 6 },
                    new ReadOperation { Count = 3, ExpectedBytesRead = 3, ExpectedResult = 9 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 1, ExpectedBytesRead = 1, ExpectedResult = 0 },
                    new ReadOperation { Count = 1, ExpectedBytesRead = 1, ExpectedResult = 1 },
                    new ReadOperation { Count = 1, ExpectedBytesRead = 1, ExpectedResult = 2 },
                    new ReadOperation { Count = 1, ExpectedBytesRead = 1, ExpectedResult = 3 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 19 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14 },
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 24 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 14 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 19 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9 },
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 19 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 9 },
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 19 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 20, ExpectedBytesRead = 20, ExpectedResult = 19 },
                    new ReadOperation { Count = 20, ExpectedBytesRead = 20, ExpectedResult = 39 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = byte.MaxValue, ExpectedBytesRead = byte.MaxValue, ExpectedResult = byte.MaxValue - 1 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = byte.MaxValue, ExpectedBytesRead = byte.MaxValue, ExpectedResult = byte.MaxValue - 1 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 0, ExpectedResult = byte.MaxValue - 1 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 0, ExpectedResult = byte.MaxValue - 1 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 0, ExpectedResult = byte.MaxValue - 1 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 14 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 9 },
                    new ReadOperation { Count = 10, ExpectedBytesRead = 10, ExpectedResult = 19 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 5, ExpectedBytesRead = 5, ExpectedResult = 4 },
                    new ReadOperation { Count = byte.MaxValue - 5, ExpectedBytesRead = byte.MaxValue - 5, ExpectedResult = byte.MaxValue - 1 },
                },
                new ReadOperation[]
                {
                    new ReadOperation { Count = 20, ExpectedBytesRead = 20, ExpectedResult = 19 },
                    new ReadOperation { Count = byte.MaxValue - 20, ExpectedBytesRead = byte.MaxValue - 20, ExpectedResult = byte.MaxValue - 1 },
                },
            };

            this.CombinatorialEngineProvider.RunCombinations(
                bufferingReads,
                // Adding the null case to completely skip the buffering replay reads
                replayReads.ConcatSingle(null),
                replayReads,
                (bufferingRead, bufferingReplayRead, replayRead) =>
                {
                    MemoryStream testStream = new MemoryStream(testBytes);
                    BufferingReadStreamTestWrapper bufferingReadStream = new BufferingReadStreamTestWrapper(testStream);

                    byte[] targetBuffer = new byte[1000];
                    int currentOffset = 0;

                    foreach (ReadOperation readOp in bufferingRead)
                    {
                        int bytesRead = bufferingReadStream.Read(targetBuffer, currentOffset, readOp.Count);
                        this.Assert.AreEqual(readOp.ExpectedBytesRead, bytesRead, "Bytes read differs.");

                        currentOffset += bytesRead;
                        this.Assert.AreEqual(readOp.ExpectedResult, targetBuffer[currentOffset - 1], "Last byte read differs.");
                    }

                    if (bufferingReplayRead != null)
                    {
                        bufferingReadStream.ResetStream();

                        targetBuffer = new byte[1000];
                        currentOffset = 0;

                        foreach (ReadOperation readOp in bufferingReplayRead)
                        {
                            int bytesRead = bufferingReadStream.Read(targetBuffer, currentOffset, readOp.Count);
                            this.Assert.AreEqual(readOp.ExpectedBytesRead, bytesRead, "Bytes read differs.");

                            currentOffset += bytesRead;
                            this.Assert.AreEqual(readOp.ExpectedResult, targetBuffer[currentOffset - 1], "Last byte read differs.");
                        }
                    }

                    bufferingReadStream.StopBuffering();

                    targetBuffer = new byte[1000];
                    currentOffset = 0;

                    foreach (ReadOperation readOp in replayRead)
                    {
                        int bytesRead = bufferingReadStream.Read(targetBuffer, currentOffset, readOp.Count);
                        this.Assert.AreEqual(readOp.ExpectedBytesRead, bytesRead, "Bytes read differs.");

                        currentOffset += bytesRead;
                        this.Assert.AreEqual(readOp.ExpectedResult, targetBuffer[currentOffset - 1], "Last byte read differs.");
                    }
                });
        }