mirror of
https://github.com/valitydev/thrift.git
synced 2024-11-07 10:48:51 +00:00
92 lines
3.0 KiB
Haskell
92 lines
3.0 KiB
Haskell
--
|
|
-- Licensed to the Apache Software Foundation (ASF) under one
|
|
-- or more contributor license agreements. See the NOTICE file
|
|
-- distributed with this work for additional information
|
|
-- regarding copyright ownership. The ASF licenses this file
|
|
-- to you under the Apache License, Version 2.0 (the
|
|
-- "License"); you may not use this file except in compliance
|
|
-- with the License. You may obtain a copy of the License at
|
|
--
|
|
-- http://www.apache.org/licenses/LICENSE-2.0
|
|
--
|
|
-- Unless required by applicable law or agreed to in writing,
|
|
-- software distributed under the License is distributed on an
|
|
-- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
-- KIND, either express or implied. See the License for the
|
|
-- specific language governing permissions and limitations
|
|
-- under the License.
|
|
--
|
|
|
|
module BinarySpec where
|
|
|
|
import Test.Hspec
|
|
import Test.Hspec.QuickCheck (prop)
|
|
|
|
import qualified Data.ByteString.Lazy as LBS
|
|
import qualified Data.ByteString.Lazy.Char8 as C
|
|
|
|
import Thrift.Types
|
|
import Thrift.Transport
|
|
import Thrift.Transport.Memory
|
|
import Thrift.Protocol
|
|
import Thrift.Protocol.Binary
|
|
|
|
spec :: Spec
|
|
spec = do
|
|
describe "BinaryProtocol" $ do
|
|
describe "double" $ do
|
|
it "writes in big endian order" $ do
|
|
let val = 2 ** 53
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
writeVal proto (TDouble val)
|
|
bin <- tRead trans 8
|
|
(LBS.unpack bin) `shouldBe`[67, 64, 0, 0, 0, 0, 0, 0]
|
|
|
|
it "reads in big endian order" $ do
|
|
let bin = LBS.pack [67, 64, 0, 0, 0, 0, 0, 0]
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
tWrite trans bin
|
|
val <- readVal proto T_DOUBLE
|
|
val `shouldBe` (TDouble $ 2 ** 53)
|
|
|
|
prop "round trip" $ \val -> do
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
writeVal proto $ TDouble val
|
|
val2 <- readVal proto T_DOUBLE
|
|
val2 `shouldBe` (TDouble val)
|
|
|
|
describe "string" $ do
|
|
it "writes" $ do
|
|
let val = C.pack "aaa"
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
writeVal proto (TString val)
|
|
bin <- tRead trans 7
|
|
(LBS.unpack bin) `shouldBe` [0, 0, 0, 3, 97, 97, 97]
|
|
|
|
describe "binary" $ do
|
|
it "writes" $ do
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
writeVal proto (TBinary $ LBS.pack [42, 43, 44])
|
|
bin <- tRead trans 100
|
|
(LBS.unpack bin) `shouldBe` [0, 0, 0, 3, 42, 43, 44]
|
|
|
|
it "reads" $ do
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
tWrite trans $ LBS.pack [0, 0, 0, 3, 42, 43, 44]
|
|
val <- readVal proto (T_BINARY)
|
|
val `shouldBe` (TBinary $ LBS.pack [42, 43, 44])
|
|
|
|
prop "round trip" $ \val -> do
|
|
trans <- openMemoryBuffer
|
|
let proto = BinaryProtocol trans
|
|
writeVal proto (TBinary $ LBS.pack val)
|
|
val2 <- readVal proto (T_BINARY)
|
|
val2 `shouldBe` (TBinary $ LBS.pack val)
|
|
|