-module(erlrrd).
-include_lib ("eunit/include/eunit.hrl").

-export([create/1, update/1, updatev/1, dump/1, restore/1, last/1,
         first/1, info/1, fetch/1, tune/1, resize/1, xport/1,
         graph/1, lastupdate/1, ls/0, cd/1, mkdir/1, pwd/0
         ]).

-export([start_link/1, start_link/0]).
-export([start/0]).
-export([stop/0]).
-export([combine/1, c/1]).

-behaviour(gen_server).
-export([init/1, handle_call/3, handle_cast/2, handle_info/2,
	 terminate/2, code_change/3]).

-record( state2, { port, timeout }  ).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Public 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


%% @equiv erlrrd_app:start()
start() -> erlrrd_app:start().
%% @equiv erlrrd_app:stop()
stop() -> erlrrd_app:stop().

%% @spec start_link(RRDToolCmd) -> Result
%%   RRDToolCmd = string()
%%   Result = {ok,Pid} | ignore | {error,Error}
%%     Pid = pid()
%%     Error = {already_started,Pid} | shutdown | term()
%% @doc calls gen_server:start_link
%%   RRDToolCmd is the command passed to open_port()
%%   usually "rrdtool -"
start_link(RRDToolCmd) when is_list(RRDToolCmd) ->
  application:set_env(erlrrd, rrdtoolcmd, RRDToolCmd ),
  start_link().

%% @equiv start_link("rrdtool -")
start_link() -> 
  gen_server:start_link({local, ?MODULE}, ?MODULE, [], []).

%% @spec combine(List) -> List
%%   List = [ term() ]
%% @doc "joins" and quotes the given arg list. 
%%   takes a list of arguments, and returns a deeplist with 
%%   each argument surrounded by double quotes
%%   then separated by spaces. Note 
%%   it does not try to escape any double quotes
%%   in the arguments.
%%
%%   combine(["these", "are", "my args"]). ->
%%
%%   [["\"","these","\""]," ",["\"","are","\""]," ",["\"","my args","\""]]
%%
%%   it is intended as a convinence function to the 
%%   rrdtool commands which all take a single iodata() argument
%%   which represents the string to be passed as the arguments 
%%   to the corresponding rrdtool command.  
%%
%%   erlrrd:xport(erlrrd:c(["DEF:foo=/path with/space/foo.rrd:foo:AVERAGE", "XPORT:foo"])).
combine(Args) -> 
    join([ [ "\"", X, "\"" ] || X <- Args ], " ").
%% @spec c(List) -> List
%%   List = [ term() ]
% @equiv combine(Args)
c(Args) -> combine(Args).


% rrdtool commands

%% @spec create(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc Set up a new Round Robin Database (RRD). Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdcreate.en.html rrdcreate].
create     (Args) when is_list(Args) -> do(create,     Args).

%% @spec update(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc Store new data values into an RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdupdate.en.html rrdupdate].
update     (Args) when is_list(Args) -> do(update,     Args).

%% @spec updatev(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc Operationally equivalent to update except for output. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdupdate.en.html rrdupdate].
updatev    (Args) when is_list(Args) -> do(updatev,    Args).

%% @spec dump(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc    Dump the contents of an RRD in plain ASCII. In connection with
%%         restore you can use this to move an RRD from one computer
%%         architecture to another.  Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrddump.en.html rrddump].
dump       (Args) when is_list(Args) -> do(dump,       Args).

%% @spec restore(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc Restore an RRD in XML format to a binary RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdrestore.en.html rrdrestore]
restore    (Args) when is_list(Args) -> do(restore,    Args).

%% @spec last(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = integer()
%% @doc    Return the date of the last data sample in an RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdlast.en.html rrdlast]
last       (Args) when is_list(Args) -> 
  case do(last,       Args) of
    { error, Reason } -> { error, Reason };
    { ok, [[Response]] } -> { ok, erlang:list_to_integer(Response) }
  end.

%% @spec lastupdate(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc    Return the most recent update to an RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdlastupdate.en.html rrdlastupdate]
lastupdate (Args) when is_list(Args) -> do(lastupdate, Args).

%% @spec first(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = integer()
%% @doc Return the date of the first data sample in an RRA within an
%%       RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdfirst.en.html rrdfirst]
first       (Args) when is_list(Args) -> 
  case do(first,       Args) of
    { error, Reason } -> { error, Reason };
    { ok, [[Response]] } -> { ok, erlang:list_to_integer(Response) }
  end.

%% @spec info(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc Get information about an RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdinfo.en.html rrdinfo].
info       (Args) when is_list(Args) -> do(info,       Args).

%% @spec fetch(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc   Get data for a certain time period from a RRD. The graph func-
%%         tion uses fetch to retrieve its data from an RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdfetch.en.html rrdfetch].
fetch      (Args) when is_list(Args) -> do(fetch,      Args).

%% @spec tune(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc Alter setup of an RRD. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdtune.en.html rrdtune].
tune       (Args) when is_list(Args) -> do(tune,       Args).

%% @spec resize(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc    Change the size of individual RRAs. This is dangerous! Check
%%         rrdresize.
resize     (Args) when is_list(Args) -> do(resize,     Args).

%% @spec xport(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc   Export data retrieved from one or several RRDs. Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdxport.en.html rrdxport]
%%
%%  erlrrd:xport("'DEF:foo=/path with/space/foo.rrd:foo:AVERAGE' XPORT:foo").
%%
%%  erlrrd:xport(erlrrd:c(["DEF:foo=/path with/space/foo.rrd:foo:AVERAGE", "XPORT:foo"])).
xport      (Args) when is_list(Args) -> do(xport,      Args).

%% @spec graph(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc   Create a graph from data stored in one or several RRDs. Apart
%%         from generating graphs, data can also be extracted to stdout.
%%         Check 
%% [http://oss.oetiker.ch/rrdtool/doc/rrdgraph.en.html rrdgraph].
graph      (Args) when is_list(Args) -> 
  % TODO: scan for this pattern w/out flattening the io_list? 
  % TODO: support  graphing to stdout!!! :) 
  Flat = erlang:binary_to_list(erlang:iolist_to_binary(Args)),
  case regexp:match(Flat, "(^| )-( |$)") of
    { match, _, _ } -> 
      % graph to stdout will break this Ports parsing of reponses..
      { error, "Graphing to stdout not supported." };
    nomatch -> 
      do(graph, Args)
  end.

%%%%% rrd "remote" commands %%%%

%% @spec cd(erlang:iodata()) -> ok |  
%%   { error, Reason } 
%%  Reason = iolist()
%% @doc   ask the rrdtool unix process to change directories
%% 
%%    erlrrd:cd("/usr/share/rrd/data").
%%
%%    erlrrd:cd(erlrrd:combine(["/Users/foo/Library/Application Support/myapp/rrd"]).
cd         (Arg)  when is_list(Arg) -> 
  case do(cd,         Arg) of
    { error, Reason } -> { error, Reason };
    { ok, _ } -> ok
  end.

%% @spec mkdir(erlang:iodata()) -> { ok, Response }  |  
%%   { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc   ask the rrdtool unix process to create a directory
mkdir      (Arg)  when is_list(Arg) -> do(mkdir,      Arg).

%% @spec ls() -> { ok, Response }  | { error, Reason } 
%%  Reason = iolist()
%%  Response = iolist()
%% @doc  lists all *.rrd files in rrdtool unix process'
%%       current working directory
ls         ()     -> do(ls,         []  ).

%% @spec pwd() -> { ok, Response }  |  { error, Reason } 
%%  Reason = iolist()
%%  Response = string()
%% @doc  return the rrdtool unix process'
%%       current working directory.
pwd        ()     -> 
  case do(pwd,       []) of
    { error, Reason } -> { error, Reason };
    { ok, [[Response]] } -> { ok, Response }
  end.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Gen server interface poo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%% @hidden
init([]) -> 
  RRDToolCmd = case application:get_env(erlrrd, rrdtoolcmd) of
    { ok, Cmd } ->  Cmd;
    undefined -> "rrdtool -"
  end,
  Timeout = case application:get_env(erlrrd, timeout) of
    { ok, T } -> T;
    undefined -> 3000
  end,
  process_flag(trap_exit, true),
  Port = erlang:open_port(
    {spawn, RRDToolCmd},
    [ {line, 10000}, eof, exit_status, stream ] 
  ),
  {ok, #state2{port = Port, timeout = Timeout}}.

%% handle_call
%% @hidden
handle_call(
  {do, Action, Args }, 
  _From, 
  #state2{port = Port, timeout = Timeout } = State
  ) ->
    Line = [ erlang:atom_to_list(Action), " ", Args , "\n"],
    port_command(Port, Line),
    case collect_response(Port, Timeout) of
          {response, Response} -> 
              {reply, { ok, Response }, State};
          { error, timeout } ->
              {stop, port_timeout, State};
          { error, Error } -> 
              {reply, { error, Error  }, State}
    end.

%% handle_cast
%% @hidden
handle_cast(_Msg, State) -> 
  % io:format(user, "Got unexpected cast msg: ~p~n", [Msg]),
  %% TODO error/event loging in erlang style.
  {noreply, State}.

%% handle_info
%% @hidden
handle_info({ Port , {exit_status, Status}}, State) 
  when 
    Port =:= State#state2.port
  -> 
  { stop, { port_exit, Status }, State};

handle_info(_Msg, State) -> 
  % io:format(user, "Got unexpected info msg: ~p~n", [Msg]),
  %% TODO error/event loging in erlang style.
  {noreply, State}.

%% terminate
%% @hidden
terminate(_Reason, _State) -> ok.

%% code_change
%% @hidden
code_change(_OldVsn, State, _Extra) -> 
  {ok, State}.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Private poo
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

do(Command, Args) -> 
  case has_newline(Args) of
    true  -> { error, "No newlines" };
    false -> gen_server:call (?MODULE, { do, Command, Args } ) 
  end.

join([Head | [] ], _Sep) ->
  [Head];
join([Head | Tail], Sep) ->
  [ Head, Sep | join(Tail, Sep) ].

has_newline([]) -> false;
has_newline(<<>>) -> false;
has_newline([ H |  T]) 
  when is_list(H); is_binary(H) ->
    case has_newline(H) of
      true -> true;
      false -> has_newline(T)
    end;
has_newline([ H | T]) when is_integer(H) ->
  if 
    H =:= $\n -> true;
    true -> has_newline(T)
  end;
has_newline(<<H:8,T/binary>>) ->
  if 
    H =:= $\n -> true;
    true -> has_newline(T)
  end.


collect_response(Port, Timeout ) ->
    collect_response(Port, [], [], Timeout ).

collect_response( Port, RespAcc, LineAcc, Timeout) ->
    receive
        {Port, {data, {eol, "OK u:" ++ _T }}} ->
            {response, lists:reverse(RespAcc)};
        {Port, {data, {eol, "ERROR: " ++ Error }}} ->
            {error, [ Error, lists:reverse(RespAcc)]};
        {Port, {data, {eol, Result}}} ->
            Line = lists:reverse([Result | LineAcc]),
            collect_response(Port, [Line | RespAcc], [], Timeout);
        {Port, {data, {noeol, Result}}} ->
            collect_response(Port, RespAcc, [Result | LineAcc], Timeout)

    %% Prevent the gen_server from hanging indefinitely in case the
    %% spawned process is taking too long processing the request.
    after Timeout ->  
            { error, timeout }
    end.
-ifdef(EUNIT).
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Test Helpers
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

test_start_stop_(StartFun, StopFun, Tag) -> 
  { spawn, 
    { inorder,
      [
        check_stopped_(Tag),
        { Tag, setup,
          StartFun,
          StopFun,
          check_started_(Tag) 
        },
        check_stopped_(Tag)
      ]
    }
  }.

check_started_(Tag) ->
  wrap_tag_(Tag,
    [
      ?_test(ls()),
      ?_test(pwd()),
      ?_test(ok),
      ?_test(ok)
    ] 
  ).

check_stopped_(Tag) ->
  wrap_tag_(Tag,
    [
      ?_assertExit( { noproc, _ }, pwd()),
      ?_assertExit( { noproc, _ }, ls())
    ]
  ).

check_last_(RRDFile,Now) -> 
  fun () -> 
    { ok, When } = erlrrd:last(RRDFile),
    When = Now
  end.

start_helper_() -> 
  application:unset_env(erlrrd, rrdtoolcmd),
  application:unset_env(erlrrd, timeout),
  {ok, Pid} = start_link(), 
  Pid.
stop_helper_(Pid) -> stop_helper_(Pid, 3000).
stop_helper_(Pid, Timeout) ->
  true = exit(Pid, normal),
  receive 
    {'EXIT', Pid, Reason} -> Reason
  after Timeout -> 
    throw({ timeout, { Pid, "Pid not responding to EXIT?"} })
  end.

% check if the dir we're in end's in /tests
check_cwd_helper_() ->
   { ok, L } = file:get_cwd(),  
   "stset/" ++ _  = lists:reverse(L).

p_func(X,Steps) -> 
  Pi = math:pi(),
  5 * ( 
    math:sin( 3*Pi/2 + X/(Steps / (8*Pi) )  )
    + 1
  ).

time_since_epoch() ->
  calendar:datetime_to_gregorian_seconds( erlang:universaltime())
    - ( 719528 * 86400 ).

wrap_tag_(T,L) when is_list(L) -> 
  [ { T, X } || X <- L ].

cast(Blah) -> 
 gen_server:cast(?MODULE, Blah ).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Tests
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%%%% test starting and stopping %%%%

-define(spew(Args), io:format(user, "~p~n", [{Args}])).
-define(assertExists(File), 
      { ok, _ } = file:read_file_info(File)).
-define(assertEnoent(File), 
      { error, enoent } = file:read_file_info(File)).


start_link_test_() -> 
  test_start_stop_(
    fun start_helper_/0,
    fun stop_helper_/1,
    "start_link test" 
  ).

start_stop_test_() ->
  test_start_stop_(
    fun()  -> ok = start() end,
    fun(_) -> ok = stop()  end,
    "start/0 stop/0"
  ).

start_sup_test_() ->
  test_start_stop_(
    fun() -> 
      {ok,Pid} = erlrrd_sup:start_link(),
      Pid 
    end,
    fun stop_helper_/1,
    "sup:start_link/0 exit/2" 
  ).

start_sup2_test_() ->
  test_start_stop_(
    fun() -> 
      check_cwd_helper_(),
      {ok,Pid} = erlrrd_sup:start_link("./dummyrrdtool"),
      Pid 
    end,
    fun stop_helper_/1,
    "sup:start_link/1 exit/2" 
  ).

start_app_test_() -> 
  test_start_stop_(
    fun()  -> ok = erlrrd_app:start() end,
    fun(_) -> ok = erlrrd_app:stop()  end,
    "app:start/0 app:stop/0"
  ).

%%%% test interfaces %%%%

datain_dataout_test_() ->
  Prefix = "foo",
  RRDFile = Prefix ++ ".rrd",
  PNGFile = Prefix ++ ".png",
  RRDDump = Prefix ++ ".rrd.xml",
  RRDRestoredFile = Prefix ++ ".2.rrd",
  Now = time_since_epoch(),
  Then = Now - 86400,
  StepSize = 60,
  Steps = round((Now - Then) / StepSize),
  { setup,
    fun()  -> 
      check_cwd_helper_(),
      file:delete(RRDFile),
      file:delete(RRDDump),
      file:delete(RRDRestoredFile),
      ?assertEnoent(RRDFile),
      { ok, Pid } = start_link(),
      Pid
    end,
    fun(Pid) -> 
      stop_helper_(Pid),
      file:delete(RRDFile),
      file:delete(RRDDump),
      file:delete(RRDRestoredFile),
      ok 
    end,
    { inorder,
      [
        % create an rrd
        fun() ->
          {ok, _ } = erlrrd:create([
            io_lib:fwrite("~s --start ~B", [RRDFile, Then]),
            io_lib:fwrite(" --step ~B DS:thedata:GAUGE:~B:U:U",
              [ StepSize, StepSize ]),
            io_lib:fwrite(" RRA:AVERAGE:0.5:1:~B",[Steps])
          ])
        end,

        % write sin wave to rrd
        fun() -> 
          lists:foreach(
            fun(X) ->
              P = p_func(X,Steps),
              %io:format(user, "~s ~B:~f~n", [ RRDFile, Then + X * StepSize, P ]),
              {ok, _ } = erlrrd:update(
                io_lib:format("~s ~B:~f", [ RRDFile, Then + X * StepSize, P ])
              )
            end,
            lists:seq(1, Steps)
          )
        end,

        % check the update times
        check_last_(RRDFile, Now),
        fun() -> 
          { ok, When } = erlrrd:first(RRDFile),
          RoundThen = (erlang:trunc(Then/StepSize) + 1) * StepSize,
          When = RoundThen
        end,
        ?_test(?assertMatch({error, _}, erlrrd:last("/somenothing/file"))),
        ?_test(?assertMatch({error, _}, erlrrd:first("/somenothing/file"))),

        % make a graph!! :)
        fun() -> 
          { ok, _ } = erlrrd:graph([
            "-l 0 -r", " ",
            "-w 700 -h 200 -a PNG ", PNGFile,
            " DEF:thedata=", RRDFile, ":thedata:AVERAGE AREA:thedata#CC9945",
            io_lib:format(" --start ~B --end ~B", [ Then, Now ])
          ])
          % ok, now how can we check the graph???  hmm.
        end,

        % run fetch
        fun() -> 
          { ok, _Data } = erlrrd:fetch([
            RRDFile, " AVERAGE ",
            io_lib:format(" --start ~B --end ~B", [ Then, Now ])
          ]),
          %?spew(Data),
          %TODO check data
          ok
        end,

        % dump the rrd
        fun() -> 
          ?assertEnoent(RRDDump),
          { ok, _ } = erlrrd:dump( RRDFile ++ " " ++ RRDDump ),
          ?assertExists(RRDDump)
        end,

        % restore the rrd
        fun() -> 
          ?assertExists(RRDDump),
          ?assertEnoent(RRDRestoredFile),
          { ok, _ } = erlrrd:restore( RRDDump ++ " " ++ RRDRestoredFile ),
          ?assertExists(RRDRestoredFile)
        end,
        check_last_(RRDRestoredFile, Now),

        % xport
        { "xport",
          fun() -> 
            ?assertExists(RRDRestoredFile),
            {ok, Response} = xport([
              "DEF:c=", RRDRestoredFile, ":thedata:AVERAGE",
              " XPORT:c",
              io_lib:format(" --start ~B --end ~B", [ Then, Now ])
            ]),
            %% TODO check response
            Response
          end
        },
        
        %lastupdate
        fun() -> 
          { ok, [ _, _, [Last]] } = lastupdate(RRDRestoredFile),
          ?assertMatch(
            {match, _, _ },
            regexp:match(Last, 
              % TODO make the regex match beginning of line? why no work? 
              io_lib:format("~B", [ Now ])
            )
          ),
          ok
        end,

        % info 
        fun() -> 
          { ok, Info } = info(RRDFile),
          [ ["filename = " ++ _L] | _T ] = Info
        end,
          
        fun() -> commas_are_cool end
      ]
    }
  }.

remote_cmds_test_() ->
  Dir = "makadir",
  { setup,
    fun() -> 
      check_cwd_helper_(),
      ?assertEnoent(Dir),
      start_helper_()
    end,
    fun(P) -> 
      file:del_dir(Dir),
      stop_helper_(P)
    end,
    { inorder, 
      [ 
        % pwd
        { "pwd1", fun() -> 
          { ok, Cwd } = erlrrd:pwd(),
          "stset/" ++ _  = lists:reverse(Cwd)
        end},
        { "mkdir", fun() -> erlrrd:mkdir(Dir) end },
        { "cd ", fun() -> ok = erlrrd:cd(Dir) end},
        % pwd 
        { "pwd2", 
          fun() -> 
            { ok, Cwd } = erlrrd:pwd(),
            { match, _, _ }  = 
              regexp:match(Cwd, "/tests/" ++ Dir ++ "$")
          end 
        },
        { "ls", 
          fun() -> 
            % relys on '.' and '..' always returning first? 
            % is that a bad idea? 
            { ok, List } = ls(),
            io:format(user," ~p~n", [List]),
            ?assert( lists:any(fun(X) -> X =:= ["d .."] end, List))
          end },
        fun() -> commas_are_cool end
      ]
    }
  }.

c_test_() -> 
  [
    ?_test(
      [ 
        ["\"", "these", "\""], " ",
        ["\"", "are",   "\""], " ",
        ["\"", "my",    "\""], " ",
        ["\"", "args",  "\""]  
      ] = c(["these", "are", "my", "args"])),
    ?_test([[ "\"", "a", "\""]] = c(["a"]))
  ].

pass_newlines_test_() ->
  M = "No newlines",
  { setup,
    fun start_helper_/0,
    fun stop_helper_/1,
    [ 
      ?_assertMatch( { error, M }, cd("..\n")),
      ?_assertMatch( { error, M }, info("fart.rrd\n")),
      ?_assertMatch( { error, M }, 
        create(["foo.rrd bar baz", [[[[<<"blahdedah\n">>]]]], "haha"])
      ),
      fun() -> ok end
    ]
  }.

graph_to_stdout_saftey_test_() -> 
  M = { error, "Graphing to stdout not supported." },
  [
    ?_assertMatch( M, graph(" -")),
    ?_assertMatch( M, graph("-")),
    ?_assertMatch( M, graph(" - ")),
    ?_assertMatch( M, graph([" ", "-"," "])),
    ?_assertMatch( M, graph([" ", [[["-"]]]," "])),
    ?_assertMatch( M, graph([" ", [[["-"]]]])),
    ?_assertMatch( M, graph([[[["-"]]]," "])),
    ?_assertMatch( M, graph([" ", [[[<<"-">>]]]," "])),
    ?_assertMatch( M, graph([" ", [[[<<"-">>]]]])),
    ?_assertMatch( M, graph([[[[<<"-">>]]]," "])),
    fun() -> ok end
  ].

%%%% tests for corner cases %%%%

cause_long_response_test_() -> 
  { setup,
    fun()  -> 
      check_cwd_helper_(),
      { ok, Pid } = start_link("./dummyrrdtool -"),
      Pid
    end,
    fun stop_helper_/1,
    ?_test(do(longresponse, []))
  }.

cause_timeout_test_() -> 
  { setup,
    fun()  -> 
      check_cwd_helper_(),
      ok = application:set_env(erlrrd, timeout, 1),
      { ok, Pid } = erlrrd_sup:start_link("./dummyrrdtool -"),
      Pid
    end,
    fun stop_helper_/1,
    ?_assertExit({port_timeout, _}, do(timeout, []))
  }.

%%%% tests of privates %%%%

join_test() -> 
  [ "a", " ", "b", " ", "c"] = join(["a", "b", "c"], " ").
join_test_() ->
  [ 
    ?_test([ "a", " ", "b", " ", "c"] = join(["a", "b", "c"], " ")),
    ?_assertNot([ "a", "b", " ", "c"]  =:= join(["a", "b", "c"], " "))
  ].

has_newline_test_() ->
  [ 
    ?_test( true  = has_newline("\n")),
    ?_test( true  = has_newline(["\n"])),
    ?_test( true  = has_newline(
      ["these", ["are", [ "my args" ] | <<"newline\n">> ], "so", "there"])),
    ?_test( false = has_newline(
      ["these", ["are", [ "my args" ] | <<"newline">> ], "so", "there"])),
    ?_test( true  = has_newline(
      ["these\n", ["are", [ "my args" ] | <<"newline">> ], "so", "there"])),
    ?_test( true  = has_newline(
      ["these", ["are", 
      [ "my args" | [[[[[[[[ "blah\n"]]]]]]]] ] | <<"newline">> ], 
      "so", "there"])),
    ?_test( false = has_newline("")),
    ?_test( false = has_newline([])),
    ?_test( false = has_newline(<<>>))
  ].

%%%%% tests to get coverage %%%%%

should_be_done_better_test_() -> 
  { setup,
    fun start_helper_/0,
    fun stop_helper_/1,
    [
       ?_assertMatch( {error, _ }, tune("blah") ),
       ?_assertMatch( {error, _ }, resize("blah") ),
       ?_assertMatch( {error, _ }, updatev("blah") ),
       ?_test(ok)
    ]
  }.

handle_cast_test_() ->
  { setup,
    fun start_helper_/0,
    fun stop_helper_/1,
    ?_test(cast(blah))
  }.

handle_info_test_() -> 
  { setup,
    fun start_helper_/0,
    fun stop_helper_/1,
    ?_test(?MODULE ! yo)
  }.

stop_helper_test_() -> 
  { setup, 
    % start fun
    fun() -> 
      F = fun(F) -> 
        receive
          Any -> io:format(user,"~p Hey, got: ~p~n", [ self(), Any ])
        end,
        F(F)
      end,
      spawn(
        fun() -> 
          process_flag(trap_exit, true),
          F(F)
        end
      )
    end,
    % stop fun,
    fun(P) -> exit(P, kill) end,
    % test gen
    fun(P) -> 
      ?_assertThrow({timeout,_}, stop_helper_(P, 1))
    end
  }.

port_exit_test_() -> 
  ?_assert(
    begin
      io:format(user, "~n==== test: expect erlrrd exit~n", []),
      {ok,Pid} = start_link("./dummyrrdtool"),
      {ok, _} = do(die, []),
      receive 
        { 'EXIT', Pid, {port_exit, 1} } -> true
      after 4000 -> 
        exit(Pid,kill),
        false
      end
    end
  ).

code_change_test() -> 
  { ok, state } = code_change( oldvsn, state, extra ).

-endif.