72 lines
2.5 KiB
Haskell
72 lines
2.5 KiB
Haskell
module Test.Pipes.Node.Buffer where
|
|
|
|
import Prelude
|
|
|
|
import Control.Monad.Error.Class (catchError)
|
|
import Control.Monad.Gen (chooseInt, sized)
|
|
import Data.Array as Array
|
|
import Data.FoldableWithIndex (forWithIndex_)
|
|
import Data.Int as Int
|
|
import Data.String.Gen (genAsciiString)
|
|
import Data.Tuple (fst, snd)
|
|
import Data.Tuple.Nested ((/\))
|
|
import Effect.Class (liftEffect)
|
|
import Effect.Unsafe (unsafePerformEffect)
|
|
import Node.Buffer (Buffer, BufferValueType(..))
|
|
import Node.Buffer as Buffer
|
|
import Node.Encoding (Encoding(..))
|
|
import Pipes ((>->))
|
|
import Pipes (each) as Pipes
|
|
import Pipes.Core (runEffect) as Pipes
|
|
import Pipes.Node.Buffer as Pipes.Node.Buffer
|
|
import Pipes.Prelude (drain, toListM) as Pipes
|
|
import Test.QuickCheck (class Arbitrary)
|
|
import Test.QuickCheck.Arbitrary (arbitrary)
|
|
import Test.QuickCheck.Gen (randomSample', vectorOf)
|
|
import Test.Spec (Spec, describe, it)
|
|
import Test.Spec.Assertions (fail, shouldEqual)
|
|
|
|
data BufferJunk = BufferJunk Buffer
|
|
|
|
instance Arbitrary BufferJunk where
|
|
arbitrary = sized \s -> do
|
|
ns <- vectorOf s (chooseInt 0 7)
|
|
pure $ unsafePerformEffect do
|
|
buf <- Buffer.alloc s
|
|
forWithIndex_ ns \ix n -> Buffer.write UInt8 (Int.toNumber n) ix buf
|
|
pure $ BufferJunk buf
|
|
|
|
data BufferUTF8 = BufferUTF8 String Buffer
|
|
|
|
instance Arbitrary BufferUTF8 where
|
|
arbitrary = do
|
|
s <- genAsciiString
|
|
pure $ BufferUTF8 s $ unsafePerformEffect $ Buffer.fromString s UTF8
|
|
|
|
spec :: Spec Unit
|
|
spec = describe "Pipes.Node.Buffer" do
|
|
describe "toString" do
|
|
it "fails when encoding wrong" do
|
|
vals <- Pipes.each <$> (map \(BufferJunk b) -> b) <$> liftEffect (randomSample' 10 arbitrary)
|
|
let
|
|
uut = Pipes.runEffect $ vals >-> Pipes.Node.Buffer.toString UTF8 >-> Pipes.drain
|
|
ok = do
|
|
uut
|
|
fail "Should have thrown"
|
|
err _ = pure unit
|
|
catchError ok err
|
|
it "junk OK in hex" do
|
|
vals <- Pipes.each <$> (map \(BufferJunk b) -> b) <$> liftEffect (randomSample' 10 arbitrary)
|
|
Pipes.runEffect $ vals >-> Pipes.Node.Buffer.toString Hex >-> Pipes.drain
|
|
it "UTF8 ok" do
|
|
vals <- (map \(BufferUTF8 s b) -> s /\ b) <$> liftEffect (randomSample' 100 arbitrary)
|
|
let
|
|
bufs = Pipes.each $ snd <$> vals
|
|
strs = fst <$> vals
|
|
act <- Array.fromFoldable <$> Pipes.toListM (bufs >-> Pipes.Node.Buffer.toString UTF8)
|
|
act `shouldEqual` strs
|
|
describe "fromString" do
|
|
it "ok" do
|
|
vals <- Pipes.each <$> liftEffect (randomSample' 100 genAsciiString)
|
|
Pipes.runEffect $ vals >-> Pipes.Node.Buffer.fromString UTF8 >-> Pipes.drain
|