"{ Package: 'exept:regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#ReadStreamTest

	instanceVariableNames:'startPosition streamClass'

	classVariableNames:''

	poolDictionaries:''

	category:'Tests-Regression'

!

!ReadStreamTest class methodsFor:'documentation'!

documentation

"

    documentation to be added.

    [author:]

        Stefan Vogel (stefan@zwerg)

    [see also:]

    [instance variables:]

    [class variables:]

"

!

history

    "Created: / 13.12.2001 / 17:13:17 / stefan"

! !

!ReadStreamTest methodsFor:'accessing'!

streamClass

    ^ streamClass

! !

!ReadStreamTest methodsFor:'helpers'!

checkReadStreamFor:testCollection 

    "check for correct common behavior of Stream reading"

    "The stream is opened in a way so that it can be used for both

     ReadStreams and ReadWriteStreams. Do not use #on:!!"

    ^ self checkReadStreamFor:testCollection useWith:true

!

checkReadStreamFor:testCollection useWith:useWith

    "check for correct common behavior of Stream reading"

    |stream|

    "The stream is opened in a way so that it can be used for both

     ReadStreams and ReadWriteStreams. Do not use #on:!!"

    useWith ifTrue:[

        stream := self streamClass with:testCollection.

    ] ifFalse:[

        stream := self streamClass on:testCollection.

    ].

    stream reset. "for ReadWriteStreams"

    self assert:(stream size == testCollection size).

    testCollection size == 0 ifTrue:[

        self assert:(stream isEmpty).

    ] ifFalse:[

        self assert:(stream isEmpty not).

    ].

    testCollection 

        keysAndValuesDo:[:pos :element | 

            self assert:(stream atEnd not).

            self assert:(stream peek == element).

            self assert:(stream position == (pos + startPosition - 1)).

            self assert:(stream next == element).

            self assert:(stream position == (pos + startPosition))

        ].

    self assert:(stream atEnd).

    self assert:(stream peek isNil).

    self assert:(stream next isNil).

    streamClass endOfStreamSignal 

        handle:[:ex | ex return]

        do:[

            self should:(stream next) raise:streamClass endOfStreamSignal.

            self should:(stream peek) raise:streamClass endOfStreamSignal.

            self shouldnt:(stream peekOrNil) raise:streamClass endOfStreamSignal

        ]

! !

!ReadStreamTest methodsFor:'setup'!

setUp

    self streamClass:Rel5::ReadStream.

!

streamClass:aClass 

    streamClass := aClass.

    startPosition := streamClass zeroPosition

! !

!ReadStreamTest methodsFor:'tests'!

testBasic

    |stream|

    stream := self streamClass on:''.

    self assert:(stream isReadable).

    self assert:(stream isPositionable).

    self assert:(stream isWritable not).

    self assert:(stream size == 0).

    self assert:(stream isEmpty)

!

testOn

    |stream|

    stream := self streamClass on:'12345'.

    self assert:(stream position == startPosition).

    self assert:(stream isEmpty not).

    self assert:(stream size == 5).

!

testReadStream

   self checkReadStreamFor:''.

   self checkReadStreamFor:'12345'.

   self checkReadStreamFor:'12345'asByteArray.

   self checkReadStreamFor:#[1 2 3 4 5].

   self checkReadStreamFor:#(1 2 3 4 5).

   self checkReadStreamFor:#(1 2 3 4 5) asOrderedCollection.

   self checkReadStreamFor:''                                   useWith:false.

   self checkReadStreamFor:'12345'                              useWith:false.

   self checkReadStreamFor:'12345'asByteArray                   useWith:false.

   self checkReadStreamFor:#[1 2 3 4 5]                         useWith:false.

   self checkReadStreamFor:#(1 2 3 4 5)                         useWith:false.

   self checkReadStreamFor:#(1 2 3 4 5) asOrderedCollection     useWith:false.

   "

    (self selector:#testReadStream) runCase

   "

!

testSkipAny

    |stream skipChars|

    stream := self streamClass 

                on:'some numbers1234with\in other99 stuff' withCRs.

    skipChars := 'abcdefghijklmnopqrstuvwxyz\ ' withCRs.

    self assert:(stream skipAny:skipChars) == $1.

    self assert:(Integer readFrom:stream) == 1234.

    self assert:(stream skipAny:skipChars) == $9.

    self assert:(Integer readFrom:stream) == 99

!

testSkipSeparators

    |stream sep|

    stream := self streamClass on:'one      two\three' withCRs.

    self assert:((sep := stream skipSeparators) == $o).

    self assert:(stream nextWord = 'one').

    self assert:(stream skipSeparators == $t).

    self assert:(stream nextWord = 'two').

    self assert:(stream skipSeparators == $t).

    self assert:(stream nextWord = 'three').

    self assert:(stream atEnd).

    self assert:(stream skipSeparators isNil)

!

testSkipSeparatorsExceptCR

    |stream|

    stream := self streamClass on:'one      two\three' withCRs.

    self assert:(stream skipSeparatorsExceptCR == $o).

    self assert:(stream nextWord = 'one').

    self assert:(stream skipSeparatorsExceptCR == $t).

    self assert:(stream nextWord = 'two').

    self assert:(stream skipSeparatorsExceptCR == Character cr).

    self assert:(stream next = Character cr).

    self assert:(stream nextWord = 'three').

    self assert:(stream atEnd).

    self assert:(stream skipSeparatorsExceptCR isNil)

!

testSkipSpaces

    |stream|

    stream := self streamClass on:'one      two\three' withCRs.

    self assert:(stream skipSpaces == $o).

    self assert:(stream nextWord = 'one').

    self assert:(stream skipSpaces == $t).

    self assert:(stream nextWord = 'two').

    self assert:(stream skipSpaces == Character cr).

    self assert:(stream next = Character cr).

    self assert:(stream nextWord = 'three').

    self assert:(stream atEnd).

    self assert:(stream skipSpaces isNil)

!

testWith

    |stream|

    stream := self streamClass with:'12345'.

    self assert:(stream position == (startPosition+5)).

!

xxtestReadBinary

    |stream byte|

    stream := self streamClass on:'hello'.

    stream binary.

    self assert:(byte := stream next) == $h asciiValue.

    self assert:(byte := stream next) == $e asciiValue.

    self assert:(byte := stream next) == $l asciiValue.

    self assert:(byte := stream next) == $l asciiValue.

    self assert:(byte := stream next) == $o asciiValue.

    self assert:(stream atEnd)

   "

    (self selector:#testReadBinary) runCase

   "

! !

!ReadStreamTest class methodsFor:'documentation'!

version

    ^ '$Header$'

! !