thrift/lib/erl/test/test_thrift_membuffer_transport.erl

%%
%% 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(test_thrift_membuffer_transport).
-include_lib("eunit/include/eunit.hrl").


new() -> thrift_membuffer_transport:new().
new(Data) -> thrift_membuffer_transport:new(Data).

new_test_() ->
  [
    {"new empty membuffer", ?_assertMatch(
      {ok, {_, _, {t_membuffer, []}}},
      new()
    )},
    {"new membuffer with <<>>", ?_assertMatch(
      {ok, {_, _, {t_membuffer, [<<>>]}}},
      new(<<>>)
    )},
    {"new membuffer with []", ?_assertMatch(
      {ok, {_, _, {t_membuffer, []}}},
      new([])
    )},
    {"new membuffer with <<\"hallo world\">>", ?_assertMatch(
      {ok, {_, _, {t_membuffer, [<<"hallo world">>]}}},
      new(<<"hallo world">>)
    )},
    {"new membuffer with \"hallo world\"", ?_assertMatch(
      {ok, {_, _, {t_membuffer, "hallo world"}}},
      new("hallo world")
    )}
  ].


read(Membuffer, Bytes) -> thrift_membuffer_transport:read(Membuffer, Bytes).

read_test_() ->
  [
    {"read zero bytes from an empty membuffer", ?_assertMatch(
      {_, {ok, <<>>}},
      read({t_membuffer, []}, 0)
    )},
    {"read 1 byte from an empty membuffer", ?_assertMatch(
      {_, {ok, <<>>}},
      read({t_membuffer, []}, 1)
    )},
    {"read zero bytes from nonempty membuffer", ?_assertMatch(
      {{t_membuffer, <<"hallo world">>}, {ok, <<>>}},
      read({t_membuffer, [["hallo", " "], "world"]}, 0)
    )},
    {"read 1 byte from nonempty membuffer", ?_assertMatch(
      {{t_membuffer, <<"allo world">>}, {ok, <<"h">>}},
      read({t_membuffer, [["hallo", " "], "world"]}, 1)
    )},
    {"read a zillion bytes from nonempty buffer", ?_assertMatch(
      {{t_membuffer, <<>>}, {ok, <<"hallo world">>}},
      read({t_membuffer, [["hallo", " "], "world"]}, 65536)
    )}
  ].


read_exact(Membuffer, Bytes) ->
  thrift_membuffer_transport:read_exact(Membuffer, Bytes).

read_exact_test_() ->
  [
    {"read exactly zero bytes from an empty membuffer", ?_assertMatch(
      {_, {ok, <<>>}},
      read_exact({t_membuffer, []}, 0)
    )},
    {"read exactly 1 byte from an empty membuffer", ?_assertMatch(
      {_, {error, eof}},
      read_exact({t_membuffer, []}, 1)
    )},
    {"read exactly zero bytes from nonempty membuffer", ?_assertMatch(
      {{t_membuffer, <<"hallo world">>}, {ok, <<>>}},
      read_exact({t_membuffer, [["hallo", " "], "world"]}, 0)
    )},
    {"read exactly 1 byte from nonempty membuffer", ?_assertMatch(
      {{t_membuffer, <<"allo world">>}, {ok, <<"h">>}},
      read_exact({t_membuffer, [["hallo", " "], "world"]}, 1)
    )},
    {"read exactly a zillion bytes from nonempty buffer", ?_assertMatch(
      {{t_membuffer, [["hallo", " "], "world"]}, {error, eof}},
      read_exact({t_membuffer, [["hallo", " "], "world"]}, 65536)
    )}
  ].


write(Membuffer, Data) -> thrift_membuffer_transport:write(Membuffer, Data).

write_test_() ->
  [
    {"write empty list to empty membuffer", ?_assertMatch(
      {{t_membuffer, [[], []]}, ok},
      write({t_membuffer, []}, [])
    )},
    {"write empty list to nonempty membuffer", ?_assertMatch(
      {{t_membuffer, ["hallo world", []]}, ok},
      write({t_membuffer, "hallo world"}, [])
    )},
    {"write empty binary to empty membuffer", ?_assertMatch(
      {{t_membuffer, [[], <<>>]}, ok},
      write({t_membuffer, []}, <<>>)
    )},
    {"write empty binary to nonempty membuffer", ?_assertMatch(
      {{t_membuffer, ["hallo world", <<>>]}, ok},
      write({t_membuffer, "hallo world"}, <<>>)
    )},
    {"write a list to empty membuffer", ?_assertMatch(
      {{t_membuffer, [[], "hallo world"]}, ok},
      write({t_membuffer, []}, "hallo world")
    )},
    {"write a list to nonempty membuffer", ?_assertMatch(
      {{t_membuffer, [["hallo", " "], "world"]}, ok},
      write({t_membuffer, ["hallo", " "]}, "world")
    )},
    {"write a binary to empty membuffer", ?_assertMatch(
      {{t_membuffer, [[], <<"hallo world">>]}, ok},
      write({t_membuffer, []}, <<"hallo world">>)
    )},
    {"write a binary to nonempty membuffer", ?_assertMatch(
      {{t_membuffer, [["hallo", " "], <<"world">>]}, ok},
      write({t_membuffer, ["hallo", " "]}, <<"world">>)
    )}
  ].


flush(Transport) -> thrift_membuffer_transport:flush(Transport).

flush_test_() ->
  [
    {"flush empty membuffer", ?_assertMatch(
      {{t_membuffer, []}, ok},
      flush({t_membuffer, []})
    )},
    {"flush nonempty membuffer", ?_assertMatch(
      {{t_membuffer, [<<"hallo world">>]}, ok},
      flush({t_membuffer, [<<"hallo world">>]})
    )}
  ].


close(Transport) -> thrift_membuffer_transport:close(Transport).

close_test_() ->
  {"close membuffer", ?_assertMatch(
    {{t_membuffer, _}, ok},
    close({t_membuffer, []})
  )}.