Website Summary Files Commits Branches @commit @diff @stats
path: root / homework / 81709 / JSCompiler.Core.Tests / BaseInputStreamFileTests.cs
blob: ebc557c706d4d6a60ee5fa2603f98af8b41734ab (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
using System;
using System.Text;
using System.Collections.Generic;
using System.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace JSCompiler.Core.Tests
{
    [TestClass]
    public class BaseInputStreamTests
    {
        [TestMethod]
        public void IsEndOfStream_WhenNotEnd_ReturnsFalse()
        {
            byte[] buff = new byte[3] { 32, 14, 25 };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream);

            bool isEnd;
            for(int i = 0; i < 2; i++)
            {
                isEnd = testInputStream.IsEndOfStream();
                testInputStream.Next();
                Assert.IsFalse(isEnd);
            }
        }

        [TestMethod]
        public void IsEndOfStream_AtBeginningWithoutData_ReturnsTrue()
        {
            MemoryStream memStream = new MemoryStream();
            BaseInputStream testInputStream = new BaseInputStream(memStream);

            bool isEnd = testInputStream.IsEndOfStream();

            Assert.IsTrue(isEnd);
        }

        [TestMethod]
        public void IsEndOfStream_WhenEnd_ReturnsTrue()
        {
            byte[] buff = new byte[3] { 32, 14, 25 };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream);

            for (int i = 0; i < 3; i++, testInputStream.Next());
            bool isEnd = testInputStream.IsEndOfStream();

            Assert.IsTrue(isEnd);
        }

        [TestMethod]
        public void Peek_AtPosition_ReturnsCorrectItemFromStream()
        {
            byte[] buff = new byte[8] { 32, 14, 25, 14, 12, 51, 25, 33 };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream);
            char item;

            for (int i = 0; i < 5; i++, testInputStream.Next())
            {
                item = testInputStream.Peek();
                Assert.AreEqual((char)buff[i], item);
            }
        }

        [TestMethod]
        public void Peek_AtEnd_ReturnsEndItem()
        {
            byte[] buff = new byte[3] { 32, 14, 25 };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream);

            for (int i = 0; i < 3; i++, testInputStream.Next());
            char last = testInputStream.Peek();

            Assert.AreEqual(0, last);
        }

        [TestMethod]
        [ExpectedException(typeof(EndOfStreamException))]
        public void Next_WhenEndStream_ThrowsEndOfStreamException()
        {
            byte[] buff = new byte[3] { 32, 14, 25 };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream);

            for (int i = 0; i < 4; i++, testInputStream.Next());
        }

        [TestMethod]
        public void Next_WhenBuffersAreSwapped_ReturnsCorrectItem()
        {
            byte[] buff = new byte[10] { 32, 14, 25, 14, 23, 42, 16, 21, 15, 76 };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream, 3);

            for (int i = 0; i < 10; i++)
            {
                char curr = testInputStream.Next();
                Assert.AreEqual((char)buff[i], curr);
            }
        }

        [TestMethod]
        public void Line_NewLinesTracking_ReturnsCorrectNumberOfLines()
        {
            byte[] buff = new byte[10] { (byte) '\n', 32, 14, 25, 14, (byte) '\n', 42, 16, (byte) '\n', (byte)'\n' };
            MemoryStream memStream = new MemoryStream(buff);
            BaseInputStream testInputStream = new BaseInputStream(memStream);

            for (int i = 0; i < 10; i++, testInputStream.Next());

            Assert.AreEqual(4, testInputStream.Line);
        }
    }
}