Just use ETap
PropEr is fun and all but its super hard to debug failing tests and its
really not buying me that much in this case because I'm not really using
its generators for anything. ETap is good enough here.
diff --git a/.gitignore b/.gitignore
index 9287ed2..f218820 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,3 @@
.eunit/
-deps/
ebin/
+test/*.beam
diff --git a/Makefile b/Makefile
index 77f45fd..f476779 100644
--- a/Makefile
+++ b/Makefile
@@ -25,11 +25,15 @@
$(REBAR) compile
-eunit:
- $(REBAR) eunit skip_deps=true
+etap: test/etap.beam test/tutil.beam
+ prove test/*.t
-check: build eunit
+check: build etap
+
+
+%.beam: %.erl
+ erlc -o test/ $<
.PHONY: all clean distclean deps build eunit check
diff --git a/rebar.config b/rebar.config
deleted file mode 100644
index 660dc25..0000000
--- a/rebar.config
+++ /dev/null
@@ -1,12 +0,0 @@
-% Copyright 2012 Cloudant. All rights reserved.
-
-{deps, [
- {proper, ".*", {git, "https://github.com/manopapad/proper.git", "master"}}
-]}.
-
-{eunit_opts, [
- verbose,
- {report, {
- eunit_surefire, [{dir,"."}]
- }}
-]}.
diff --git a/src/ets_lru.erl b/src/ets_lru.erl
index e74c343..73398d9 100644
--- a/src/ets_lru.erl
+++ b/src/ets_lru.erl
@@ -98,7 +98,7 @@
ok.
-hit(#ets_lru{objects=Objs, atimes=ATs}=LRU, Key) ->
+hit(#ets_lru{objects=Objs, atimes=ATs}, Key) ->
case ets:match(Objs, #entry{key=Key, atime='$1', _='_'}) of
[[ATime]] ->
NewATime = erlang:now(),
@@ -114,12 +114,13 @@
expire(#ets_lru{lifetime=undefined}) ->
ok;
expire(#ets_lru{objects=Objs, atimes=ATs, lifetime=LT}=LRU) ->
+ Now = os:timestamp(),
LTMicro = LT * 1000,
case ets:first(ATs) of
'$end_of_table' ->
ok;
ATime ->
- case timer:now_diff(erlang:now(), ATime) > LTMicro of
+ case timer:now_diff(Now, ATime) > LTMicro of
true ->
[{ATime, Key}] = ets:lookup(ATs, ATime),
true = ets:delete(ATs, ATime),
diff --git a/test/01-basic-behavior.t b/test/01-basic-behavior.t
new file mode 100755
index 0000000..a35a944
--- /dev/null
+++ b/test/01-basic-behavior.t
@@ -0,0 +1,72 @@
+#! /usr/bin/env escript
+
+-define(WITH_LRU(F), tutil:with_lru(fun(LRU) -> F(LRU) end)).
+
+main([]) ->
+ code:add_pathz("test"),
+ code:add_pathz("ebin"),
+
+ tutil:run(12, fun() -> test() end).
+
+
+test() ->
+ test_lifecycle(),
+ ?WITH_LRU(test_insert_lookup),
+ ?WITH_LRU(test_insert_overwrite),
+ ?WITH_LRU(test_insert_remove),
+ ?WITH_LRU(test_member),
+ ?WITH_LRU(test_clear),
+
+ ok.
+
+
+test_lifecycle() ->
+ Resp = ets_lru:create(?MODULE, []),
+ etap:fun_is(
+ fun({ok, _LRU}) -> true; (_) -> false end,
+ Resp,
+ "ets_lru:create/2 returned an LRU"
+ ),
+ {ok, LRU} = Resp,
+ etap:is(ok, ets_lru:destroy(LRU), "Destroyed the LRU ok").
+
+
+test_insert_lookup(LRU) ->
+ ok = ets_lru:insert(LRU, foo, bar),
+ Resp = ets_lru:lookup(LRU, foo),
+ etap:is(Resp, {ok, bar}, "Lookup returned the inserted value").
+
+
+test_insert_overwrite(LRU) ->
+ ok = ets_lru:insert(LRU, foo, bar),
+ Resp1 = ets_lru:lookup(LRU, foo),
+ etap:is(Resp1, {ok, bar}, "Lookup returned the inserted value"),
+ ok = ets_lru:insert(LRU, foo, bam),
+ Resp2 = ets_lru:lookup(LRU, foo),
+ etap:is(Resp2, {ok, bam}, "Lookup returned the newly inserted value").
+
+
+test_insert_remove(LRU) ->
+ ok = ets_lru:insert(LRU, foo, bar),
+ Resp1 = ets_lru:lookup(LRU, foo),
+ etap:is(Resp1, {ok, bar}, "Lookup returned the inserted value"),
+ ok = ets_lru:remove(LRU, foo),
+ Resp2 = ets_lru:lookup(LRU, foo),
+ etap:is(Resp2, not_found, "Lookup returned not_found for removed value").
+
+
+test_member(LRU) ->
+ etap:is(false, ets_lru:member(LRU, foo), "Not yet a member: foo"),
+ ok = ets_lru:insert(LRU, foo, bar),
+ etap:is(true, ets_lru:member(LRU, foo), "Now a member: foo"),
+ ok = ets_lru:remove(LRU, foo),
+ etap:is(false, ets_lru:member(LRU, foo), "No longer a member: foo").
+
+
+test_clear(LRU) ->
+ ok = ets_lru:insert(LRU, foo, bar),
+ Resp1 = ets_lru:lookup(LRU, foo),
+ etap:is(Resp1, {ok, bar}, "Lookup returned the inserted value"),
+ ok = ets_lru:clear(LRU),
+ Resp2 = ets_lru:lookup(LRU, foo),
+ etap:is(Resp2, not_found, "Lookup returned not_found after a clear").
diff --git a/test/02-lru-options.t b/test/02-lru-options.t
new file mode 100755
index 0000000..7dbec8f
--- /dev/null
+++ b/test/02-lru-options.t
@@ -0,0 +1,69 @@
+#! /usr/bin/env escript
+
+main([]) ->
+ code:add_pathz("test"),
+ code:add_pathz("ebin"),
+
+ tutil:run(unknown, fun() -> test() end).
+
+
+test() ->
+ test_named_tables(),
+ test_max_objects(),
+ test_max_size(),
+ test_lifetime(),
+ test_bad_option(),
+
+ ok.
+
+
+test_named_tables() ->
+ {ok, LRU} = ets_lru:create(foo, [named_tables]),
+ etap:is(ets:info(foo_objects, size), 0, "foo_objects table exists"),
+ etap:is(ets:info(foo_atimes, size), 0, "foo_atimes table exists"),
+ ok = ets_lru:destroy(LRU),
+ etap:isnt(catch ets:info(foo_objects, size), 0, "foo_objects is gone"),
+ etap:isnt(catch ets:info(foo_atimes, size), 0, "foo_atimes is gone"),
+ ok.
+
+
+test_max_objects() ->
+ % See also: 03-limit-max-objects.t
+ test_good([{max_objects, 5}]),
+ test_good([{max_objects, 1}]),
+ test_good([{max_objects, 923928342098203942}]).
+
+
+test_max_size() ->
+ % See also: 04-limit-max-size.t
+ test_good([{max_size, 1}]),
+ test_good([{max_size, 5}]),
+ test_good([{max_size, 23423409090923423942309423094}]).
+
+
+test_lifetime() ->
+ % See also: 05-limit-lifetime.t
+ test_good([{lifetime, 1}]),
+ test_good([{lifetime, 5}]),
+ test_good([{lifetime, 1244209909182409328409283409238}]).
+
+
+test_bad_option() ->
+ test_bad([{bingo, bango}]),
+ test_bad([12]),
+ test_bad([true]).
+
+
+test_good(Options) ->
+ etap:fun_is(fun
+ ({ok, LRU}) -> ets_lru:destroy(LRU), true;
+ (_) -> false
+ end, ets_lru:create(?MODULE, Options), "LRU created ok with options").
+
+
+test_bad(Options) ->
+ etap:fun_is(fun
+ ({invalid_option, _}) -> true;
+ ({ok, LRU}) -> ets_lru:destroy(LRU), false;
+ (_) -> false
+ end, catch ets_lru:create(?MODULE, Options), "LRU error with options").
\ No newline at end of file
diff --git a/test/03-limit-max-objects.t b/test/03-limit-max-objects.t
new file mode 100755
index 0000000..ccf9e7d
--- /dev/null
+++ b/test/03-limit-max-objects.t
@@ -0,0 +1,26 @@
+#! /usr/bin/env escript
+
+objs() -> 25.
+
+main([]) ->
+ code:add_pathz("test"),
+ code:add_pathz("ebin"),
+
+ tutil:run(1, fun() -> test() end).
+
+
+test() ->
+ {ok, LRU} = ets_lru:create(lru, [named_tables, {max_objects, objs()}]),
+ etap:is(insert_kvs(LRU, 100 * objs()), ok, "Max object count ok"),
+ ok = ets_lru:destroy(LRU).
+
+
+insert_kvs(LRU, 0) ->
+ ok;
+insert_kvs(LRU, Count) ->
+ ets_lru:insert(LRU, Count, bar),
+ case ets:info(lru_objects, size) > objs() of
+ true -> erlang:error(exceeded_max_objects);
+ false -> ok
+ end,
+ insert_kvs(LRU, Count-1).
diff --git a/test/04-limit-max-size.t b/test/04-limit-max-size.t
new file mode 100755
index 0000000..b318e27
--- /dev/null
+++ b/test/04-limit-max-size.t
@@ -0,0 +1,26 @@
+#! /usr/bin/env escript
+
+max_size() -> 1024.
+
+main([]) ->
+ code:add_pathz("test"),
+ code:add_pathz("ebin"),
+
+ tutil:run(1, fun() -> test() end).
+
+
+test() ->
+ {ok, LRU} = ets_lru:create(lru, [named_tables, {max_size, max_size()}]),
+ etap:is(insert_kvs(LRU, 10000), ok, "Max size ok"),
+ ok = ets_lru:destroy(LRU).
+
+
+insert_kvs(LRU, 0) ->
+ ok;
+insert_kvs(LRU, Count) ->
+ ets_lru:insert(LRU, Count, 1.5234),
+ case ets:info(lru_objects, memory) > max_size() of
+ true -> erlang:error(exceeded_max_size);
+ false -> ok
+ end,
+ insert_kvs(LRU, Count-1).
diff --git a/test/05-limit-lifetime.t b/test/05-limit-lifetime.t
new file mode 100755
index 0000000..2421579
--- /dev/null
+++ b/test/05-limit-lifetime.t
@@ -0,0 +1,15 @@
+#! /usr/bin/env escript
+
+lifetime() -> 1024.
+
+main([]) ->
+ code:add_pathz("test"),
+ code:add_pathz("ebin"),
+
+ tutil:run(unknown, fun() -> test() end).
+
+
+test() ->
+ {ok, LRU} = ets_lru:create(lru, [named_tables, {lifetime, lifetime()}]),
+ % Figure out how to test this.
+ ok = ets_lru:destroy(LRU).
diff --git a/test/etap.erl b/test/etap.erl
new file mode 100644
index 0000000..6924d09
--- /dev/null
+++ b/test/etap.erl
@@ -0,0 +1,612 @@
+%% Copyright (c) 2008-2009 Nick Gerakines <nick@gerakines.net>
+%%
+%% Permission is hereby granted, free of charge, to any person
+%% obtaining a copy of this software and associated documentation
+%% files (the "Software"), to deal in the Software without
+%% restriction, including without limitation the rights to use,
+%% copy, modify, merge, publish, distribute, sublicense, and/or sell
+%% copies of the Software, and to permit persons to whom the
+%% Software is furnished to do so, subject to the following
+%% conditions:
+%%
+%% The above copyright notice and this permission notice shall be
+%% included in all copies or substantial portions of the Software.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+%% EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+%% OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+%% NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+%% HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+%% WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+%% FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+%% OTHER DEALINGS IN THE SOFTWARE.
+%%
+%% @author Nick Gerakines <nick@gerakines.net> [http://socklabs.com/]
+%% @author Jeremy Wall <jeremy@marzhillstudios.com>
+%% @version 0.3.4
+%% @copyright 2007-2008 Jeremy Wall, 2008-2009 Nick Gerakines
+%% @reference http://testanything.org/wiki/index.php/Main_Page
+%% @reference http://en.wikipedia.org/wiki/Test_Anything_Protocol
+%% @todo Finish implementing the skip directive.
+%% @todo Document the messages handled by this receive loop.
+%% @todo Explain in documentation why we use a process to handle test input.
+%% @doc etap is a TAP testing module for Erlang components and applications.
+%% This module allows developers to test their software using the TAP method.
+%%
+%% <blockquote cite="http://en.wikipedia.org/wiki/Test_Anything_Protocol"><p>
+%% TAP, the Test Anything Protocol, is a simple text-based interface between
+%% testing modules in a test harness. TAP started life as part of the test
+%% harness for Perl but now has implementations in C/C++, Python, PHP, Perl
+%% and probably others by the time you read this.
+%% </p></blockquote>
+%%
+%% The testing process begins by defining a plan using etap:plan/1, running
+%% a number of etap tests and then calling eta:end_tests/0. Please refer to
+%% the Erlang modules in the t directory of this project for example tests.
+-module(etap).
+-vsn("0.3.4").
+
+-export([
+ ensure_test_server/0,
+ start_etap_server/0,
+ test_server/1,
+ msg/1, msg/2,
+ diag/1, diag/2,
+ expectation_mismatch_message/3,
+ plan/1,
+ end_tests/0,
+ not_ok/2, ok/2, is_ok/2, is/3, isnt/3, any/3, none/3,
+ fun_is/3, expect_fun/3, expect_fun/4,
+ is_greater/3,
+ skip/1, skip/2,
+ datetime/1,
+ skip/3,
+ bail/0, bail/1,
+ test_state/0, failure_count/0
+]).
+
+-export([
+ contains_ok/3,
+ is_before/4
+]).
+
+-export([
+ is_pid/2,
+ is_alive/2,
+ is_mfa/3
+]).
+
+-export([
+ loaded_ok/2,
+ can_ok/2, can_ok/3,
+ has_attrib/2, is_attrib/3,
+ is_behaviour/2
+]).
+
+-export([
+ dies_ok/2,
+ lives_ok/2,
+ throws_ok/3
+]).
+
+
+-record(test_state, {
+ planned = 0,
+ count = 0,
+ pass = 0,
+ fail = 0,
+ skip = 0,
+ skip_reason = ""
+}).
+
+%% @spec plan(N) -> Result
+%% N = unknown | skip | {skip, string()} | integer()
+%% Result = ok
+%% @doc Create a test plan and boot strap the test server.
+plan(unknown) ->
+ ensure_test_server(),
+ etap_server ! {self(), plan, unknown},
+ ok;
+plan(skip) ->
+ io:format("1..0 # skip~n");
+plan({skip, Reason}) ->
+ io:format("1..0 # skip ~s~n", [Reason]);
+plan(N) when is_integer(N), N > 0 ->
+ ensure_test_server(),
+ etap_server ! {self(), plan, N},
+ ok.
+
+%% @spec end_tests() -> ok
+%% @doc End the current test plan and output test results.
+%% @todo This should probably be done in the test_server process.
+end_tests() ->
+ case whereis(etap_server) of
+ undefined -> self() ! true;
+ _ -> etap_server ! {self(), state}
+ end,
+ State = receive X -> X end,
+ if
+ State#test_state.planned == -1 ->
+ io:format("1..~p~n", [State#test_state.count]);
+ true ->
+ ok
+ end,
+ case whereis(etap_server) of
+ undefined -> ok;
+ _ -> etap_server ! done, ok
+ end.
+
+bail() ->
+ bail("").
+
+bail(Reason) ->
+ etap_server ! {self(), diag, "Bail out! " ++ Reason},
+ etap_server ! done, ok,
+ ok.
+
+%% @spec test_state() -> Return
+%% Return = test_state_record() | {error, string()}
+%% @doc Return the current test state
+test_state() ->
+ etap_server ! {self(), state},
+ receive
+ X when is_record(X, test_state) -> X
+ after
+ 1000 -> {error, "Timed out waiting for etap server reply.~n"}
+ end.
+
+%% @spec failure_count() -> Return
+%% Return = integer() | {error, string()}
+%% @doc Return the current failure count
+failure_count() ->
+ case test_state() of
+ #test_state{fail=FailureCount} -> FailureCount;
+ X -> X
+ end.
+
+%% @spec msg(S) -> ok
+%% S = string()
+%% @doc Print a message in the test output.
+msg(S) -> etap_server ! {self(), diag, S}, ok.
+
+%% @spec msg(Format, Data) -> ok
+%% Format = atom() | string() | binary()
+%% Data = [term()]
+%% UnicodeList = [Unicode]
+%% Unicode = int()
+%% @doc Print a message in the test output.
+%% Function arguments are passed through io_lib:format/2.
+msg(Format, Data) -> msg(io_lib:format(Format, Data)).
+
+%% @spec diag(S) -> ok
+%% S = string()
+%% @doc Print a debug/status message related to the test suite.
+diag(S) -> msg("# " ++ S).
+
+%% @spec diag(Format, Data) -> ok
+%% Format = atom() | string() | binary()
+%% Data = [term()]
+%% UnicodeList = [Unicode]
+%% Unicode = int()
+%% @doc Print a debug/status message related to the test suite.
+%% Function arguments are passed through io_lib:format/2.
+diag(Format, Data) -> diag(io_lib:format(Format, Data)).
+
+%% @spec expectation_mismatch_message(Got, Expected, Desc) -> ok
+%% Got = any()
+%% Expected = any()
+%% Desc = string()
+%% @doc Print an expectation mismatch message in the test output.
+expectation_mismatch_message(Got, Expected, Desc) ->
+ msg(" ---"),
+ msg(" description: ~p", [Desc]),
+ msg(" found: ~p", [Got]),
+ msg(" wanted: ~p", [Expected]),
+ msg(" ..."),
+ ok.
+
+% @spec evaluate(Pass, Got, Expected, Desc) -> Result
+%% Pass = true | false
+%% Got = any()
+%% Expected = any()
+%% Desc = string()
+%% Result = true | false
+%% @doc Evaluate a test statement, printing an expectation mismatch message
+%% if the test failed.
+evaluate(Pass, Got, Expected, Desc) ->
+ case mk_tap(Pass, Desc) of
+ false ->
+ expectation_mismatch_message(Got, Expected, Desc),
+ false;
+ true ->
+ true
+ end.
+
+%% @spec ok(Expr, Desc) -> Result
+%% Expr = true | false
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that a statement is true.
+ok(Expr, Desc) -> evaluate(Expr == true, Expr, true, Desc).
+
+%% @spec not_ok(Expr, Desc) -> Result
+%% Expr = true | false
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that a statement is false.
+not_ok(Expr, Desc) -> evaluate(Expr == false, Expr, false, Desc).
+
+%% @spec is_ok(Expr, Desc) -> Result
+%% Expr = any()
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that two values are the same.
+is_ok(Expr, Desc) -> evaluate(Expr == ok, Expr, ok, Desc).
+
+%% @spec is(Got, Expected, Desc) -> Result
+%% Got = any()
+%% Expected = any()
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that two values are the same.
+is(Got, Expected, Desc) -> evaluate(Got == Expected, Got, Expected, Desc).
+
+%% @spec isnt(Got, Expected, Desc) -> Result
+%% Got = any()
+%% Expected = any()
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that two values are not the same.
+isnt(Got, Expected, Desc) -> evaluate(Got /= Expected, Got, Expected, Desc).
+
+%% @spec is_greater(ValueA, ValueB, Desc) -> Result
+%% ValueA = number()
+%% ValueB = number()
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that an integer is greater than another.
+is_greater(ValueA, ValueB, Desc) when is_integer(ValueA), is_integer(ValueB) ->
+ mk_tap(ValueA > ValueB, Desc).
+
+%% @spec any(Got, Items, Desc) -> Result
+%% Got = any()
+%% Items = [any()]
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that an item is in a list.
+any(Got, Items, Desc) when is_function(Got) ->
+ is(lists:any(Got, Items), true, Desc);
+any(Got, Items, Desc) ->
+ is(lists:member(Got, Items), true, Desc).
+
+%% @spec none(Got, Items, Desc) -> Result
+%% Got = any()
+%% Items = [any()]
+%% Desc = string()
+%% Result = true | false
+%% @doc Assert that an item is not in a list.
+none(Got, Items, Desc) when is_function(Got) ->
+ is(lists:any(Got, Items), false, Desc);
+none(Got, Items, Desc) ->
+ is(lists:member(Got, Items), false, Desc).
+
+%% @spec fun_is(Fun, Expected, Desc) -> Result
+%% Fun = function()
+%% Expected = any()
+%% Desc = string()
+%% Result = true | false
+%% @doc Use an anonymous function to assert a pattern match.
+fun_is(Fun, Expected, Desc) when is_function(Fun) ->
+ is(Fun(Expected), true, Desc).
+
+%% @spec expect_fun(ExpectFun, Got, Desc) -> Result
+%% ExpectFun = function()
+%% Got = any()
+%% Desc = string()
+%% Result = true | false
+%% @doc Use an anonymous function to assert a pattern match, using actual
+%% value as the argument to the function.
+expect_fun(ExpectFun, Got, Desc) ->
+ evaluate(ExpectFun(Got), Got, ExpectFun, Desc).
+
+%% @spec expect_fun(ExpectFun, Got, Desc, ExpectStr) -> Result
+%% ExpectFun = function()
+%% Got = any()
+%% Desc = string()
+%% ExpectStr = string()
+%% Result = true | false
+%% @doc Use an anonymous function to assert a pattern match, using actual
+%% value as the argument to the function.
+expect_fun(ExpectFun, Got, Desc, ExpectStr) ->
+ evaluate(ExpectFun(Got), Got, ExpectStr, Desc).
+
+%% @equiv skip(TestFun, "")
+skip(TestFun) when is_function(TestFun) ->
+ skip(TestFun, "").
+
+%% @spec skip(TestFun, Reason) -> ok
+%% TestFun = function()
+%% Reason = string()
+%% @doc Skip a test.
+skip(TestFun, Reason) when is_function(TestFun), is_list(Reason) ->
+ begin_skip(Reason),
+ catch TestFun(),
+ end_skip(),
+ ok.
+
+%% @spec skip(Q, TestFun, Reason) -> ok
+%% Q = true | false | function()
+%% TestFun = function()
+%% Reason = string()
+%% @doc Skips a test conditionally. The first argument to this function can
+%% either be the 'true' or 'false' atoms or a function that returns 'true' or
+%% 'false'.
+skip(QFun, TestFun, Reason) when is_function(QFun), is_function(TestFun), is_list(Reason) ->
+ case QFun() of
+ true -> begin_skip(Reason), TestFun(), end_skip();
+ _ -> TestFun()
+ end,
+ ok;
+
+skip(Q, TestFun, Reason) when is_function(TestFun), is_list(Reason), Q == true ->
+ begin_skip(Reason),
+ TestFun(),
+ end_skip(),
+ ok;
+
+skip(_, TestFun, Reason) when is_function(TestFun), is_list(Reason) ->
+ TestFun(),
+ ok.
+
+%% @private
+begin_skip(Reason) ->
+ etap_server ! {self(), begin_skip, Reason}.
+
+%% @private
+end_skip() ->
+ etap_server ! {self(), end_skip}.
+
+%% @spec contains_ok(string(), string(), string()) -> true | false
+%% @doc Assert that a string is contained in another string.
+contains_ok(Source, String, Desc) ->
+ etap:isnt(
+ string:str(Source, String),
+ 0,
+ Desc
+ ).
+
+%% @spec is_before(string(), string(), string(), string()) -> true | false
+%% @doc Assert that a string comes before another string within a larger body.
+is_before(Source, StringA, StringB, Desc) ->
+ etap:is_greater(
+ string:str(Source, StringB),
+ string:str(Source, StringA),
+ Desc
+ ).
+
+%% @doc Assert that a given variable is a pid.
+is_pid(Pid, Desc) when is_pid(Pid) -> etap:ok(true, Desc);
+is_pid(_, Desc) -> etap:ok(false, Desc).
+
+%% @doc Assert that a given process/pid is alive.
+is_alive(Pid, Desc) ->
+ etap:ok(erlang:is_process_alive(Pid), Desc).
+
+%% @doc Assert that the current function of a pid is a given {M, F, A} tuple.
+is_mfa(Pid, MFA, Desc) ->
+ etap:is({current_function, MFA}, erlang:process_info(Pid, current_function), Desc).
+
+%% @spec loaded_ok(atom(), string()) -> true | false
+%% @doc Assert that a module has been loaded successfully.
+loaded_ok(M, Desc) when is_atom(M) ->
+ etap:fun_is(fun({module, _}) -> true; (_) -> false end, code:load_file(M), Desc).
+
+%% @spec can_ok(atom(), atom()) -> true | false
+%% @doc Assert that a module exports a given function.
+can_ok(M, F) when is_atom(M), is_atom(F) ->
+ Matches = [X || {X, _} <- M:module_info(exports), X == F],
+ etap:ok(Matches > 0, lists:concat([M, " can ", F])).
+
+%% @spec can_ok(atom(), atom(), integer()) -> true | false
+%% @doc Assert that a module exports a given function with a given arity.
+can_ok(M, F, A) when is_atom(M); is_atom(F), is_number(A) ->
+ Matches = [X || X <- M:module_info(exports), X == {F, A}],
+ etap:ok(Matches > 0, lists:concat([M, " can ", F, "/", A])).
+
+%% @spec has_attrib(M, A) -> true | false
+%% M = atom()
+%% A = atom()
+%% @doc Asserts that a module has a given attribute.
+has_attrib(M, A) when is_atom(M), is_atom(A) ->
+ etap:isnt(
+ proplists:get_value(A, M:module_info(attributes), 'asdlkjasdlkads'),
+ 'asdlkjasdlkads',
+ lists:concat([M, " has attribute ", A])
+ ).
+
+%% @spec has_attrib(M, A. V) -> true | false
+%% M = atom()
+%% A = atom()
+%% V = any()
+%% @doc Asserts that a module has a given attribute with a given value.
+is_attrib(M, A, V) when is_atom(M) andalso is_atom(A) ->
+ etap:is(
+ proplists:get_value(A, M:module_info(attributes)),
+ [V],
+ lists:concat([M, "'s ", A, " is ", V])
+ ).
+
+%% @spec is_behavior(M, B) -> true | false
+%% M = atom()
+%% B = atom()
+%% @doc Asserts that a given module has a specific behavior.
+is_behaviour(M, B) when is_atom(M) andalso is_atom(B) ->
+ is_attrib(M, behaviour, B).
+
+%% @doc Assert that an exception is raised when running a given function.
+dies_ok(F, Desc) ->
+ case (catch F()) of
+ {'EXIT', _} -> etap:ok(true, Desc);
+ _ -> etap:ok(false, Desc)
+ end.
+
+%% @doc Assert that an exception is not raised when running a given function.
+lives_ok(F, Desc) ->
+ etap:is(try_this(F), success, Desc).
+
+%% @doc Assert that the exception thrown by a function matches the given exception.
+throws_ok(F, Exception, Desc) ->
+ try F() of
+ _ -> etap:ok(nok, Desc)
+ catch
+ _:E ->
+ etap:is(E, Exception, Desc)
+ end.
+
+%% @private
+%% @doc Run a function and catch any exceptions.
+try_this(F) when is_function(F, 0) ->
+ try F() of
+ _ -> success
+ catch
+ throw:E -> {throw, E};
+ error:E -> {error, E};
+ exit:E -> {exit, E}
+ end.
+
+%% @private
+%% @doc Start the etap_server process if it is not running already.
+ensure_test_server() ->
+ case whereis(etap_server) of
+ undefined ->
+ proc_lib:start(?MODULE, start_etap_server,[]);
+ _ ->
+ diag("The test server is already running.")
+ end.
+
+%% @private
+%% @doc Start the etap_server loop and register itself as the etap_server
+%% process.
+start_etap_server() ->
+ catch register(etap_server, self()),
+ proc_lib:init_ack(ok),
+ etap:test_server(#test_state{
+ planned = 0,
+ count = 0,
+ pass = 0,
+ fail = 0,
+ skip = 0,
+ skip_reason = ""
+ }).
+
+
+%% @private
+%% @doc The main etap_server receive/run loop. The etap_server receive loop
+%% responds to seven messages apperatining to failure or passing of tests.
+%% It is also used to initiate the testing process with the {_, plan, _}
+%% message that clears the current test state.
+test_server(State) ->
+ NewState = receive
+ {_From, plan, unknown} ->
+ io:format("# Current time local ~s~n", [datetime(erlang:localtime())]),
+ io:format("# Using etap version ~p~n", [ proplists:get_value(vsn, proplists:get_value(attributes, etap:module_info())) ]),
+ State#test_state{
+ planned = -1,
+ count = 0,
+ pass = 0,
+ fail = 0,
+ skip = 0,
+ skip_reason = ""
+ };
+ {_From, plan, N} ->
+ io:format("# Current time local ~s~n", [datetime(erlang:localtime())]),
+ io:format("# Using etap version ~p~n", [ proplists:get_value(vsn, proplists:get_value(attributes, etap:module_info())) ]),
+ io:format("1..~p~n", [N]),
+ State#test_state{
+ planned = N,
+ count = 0,
+ pass = 0,
+ fail = 0,
+ skip = 0,
+ skip_reason = ""
+ };
+ {_From, begin_skip, Reason} ->
+ State#test_state{
+ skip = 1,
+ skip_reason = Reason
+ };
+ {_From, end_skip} ->
+ State#test_state{
+ skip = 0,
+ skip_reason = ""
+ };
+ {_From, pass, Desc} ->
+ FullMessage = skip_diag(
+ " - " ++ Desc,
+ State#test_state.skip,
+ State#test_state.skip_reason
+ ),
+ io:format("ok ~p ~s~n", [State#test_state.count + 1, FullMessage]),
+ State#test_state{
+ count = State#test_state.count + 1,
+ pass = State#test_state.pass + 1
+ };
+
+ {_From, fail, Desc} ->
+ FullMessage = skip_diag(
+ " - " ++ Desc,
+ State#test_state.skip,
+ State#test_state.skip_reason
+ ),
+ io:format("not ok ~p ~s~n", [State#test_state.count + 1, FullMessage]),
+ State#test_state{
+ count = State#test_state.count + 1,
+ fail = State#test_state.fail + 1
+ };
+ {From, state} ->
+ From ! State,
+ State;
+ {_From, diag, Message} ->
+ io:format("~s~n", [Message]),
+ State;
+ {From, count} ->
+ From ! State#test_state.count,
+ State;
+ {From, is_skip} ->
+ From ! State#test_state.skip,
+ State;
+ done ->
+ exit(normal)
+ end,
+ test_server(NewState).
+
+%% @private
+%% @doc Process the result of a test and send it to the etap_server process.
+mk_tap(Result, Desc) ->
+ IsSkip = lib:sendw(etap_server, is_skip),
+ case [IsSkip, Result] of
+ [_, true] ->
+ etap_server ! {self(), pass, Desc},
+ true;
+ [1, _] ->
+ etap_server ! {self(), pass, Desc},
+ true;
+ _ ->
+ etap_server ! {self(), fail, Desc},
+ false
+ end.
+
+%% @private
+%% @doc Format a date/time string.
+datetime(DateTime) ->
+ {{Year, Month, Day}, {Hour, Min, Sec}} = DateTime,
+ io_lib:format("~4.10.0B-~2.10.0B-~2.10.0B ~2.10.0B:~2.10.0B:~2.10.0B", [Year, Month, Day, Hour, Min, Sec]).
+
+%% @private
+%% @doc Craft an output message taking skip/todo into consideration.
+skip_diag(Message, 0, _) ->
+ Message;
+skip_diag(_Message, 1, "") ->
+ " # SKIP";
+skip_diag(_Message, 1, Reason) ->
+ " # SKIP : " ++ Reason.
diff --git a/test/ets_lru_behavior_tests.erl b/test/ets_lru_behavior_tests.erl
deleted file mode 100644
index cd65ab2..0000000
--- a/test/ets_lru_behavior_tests.erl
+++ /dev/null
@@ -1,195 +0,0 @@
--module(ets_lru_behavior_tests).
--behaviour(proper_statem).
-
-
--include_lib("proper/include/proper.hrl").
--include_lib("eunit/include/eunit.hrl").
-
-
--export([
- initial_state/0,
- command/1,
- precondition/2,
- postcondition/3,
- next_state/3,
- random_key/1
-]).
-
-
--export([
- kvs_insert/4,
- kvs_lookup/2,
- kvs_remove/2,
- kvs_hit/2
-]).
-
-
--record(st, {
- ets_lru,
- kvs_lru
-}).
-
-
-proper_test_() ->
- PropErOpts = [
- {to_file, user},
- {max_size, 20},
- {numtests, 1000}
- ],
- {timeout, 3600, ?_assertEqual([], proper:module(?MODULE, PropErOpts))}.
-
-
-prop_lru() ->
- Fmt = "History: ~p~nState: ~p~nRes: ~p~nCmds:~n~p~n",
- ?FORALL(Cmds, commands(?MODULE),
- begin
- {H, S, R} = run_commands(?MODULE, Cmds),
- cleanup(S),
- ?WHENFAIL(
- io:format(standard_error, Fmt, [H, S, R, Cmds]),
- R =:= ok
- )
- end
- ).
-
-
-initial_state() ->
- #st{}.
-
-
-command(#st{ets_lru=undefined}=S) ->
- MaxObjs = 1 + random:uniform(5),
- Opts = [{max_objects, MaxObjs}],
- {call, ets_lru, create, [proper_ets_lru_tab, Opts]};
-command(S) ->
- Key = {call, ?MODULE, random_key, [S]},
- frequency([
- % Common operations
- {50, {call, ets_lru, insert, [S#st.ets_lru, key(), val()]}},
- {5, {call, ets_lru, lookup, [S#st.ets_lru, Key]}},
-
- % Make removes less common so we hit limits
- {3, {call, ets_lru, remove, [S#st.ets_lru, Key]}},
-
- {1, {call, ets_lru, insert, [S#st.ets_lru, Key, val()]}},
- {1, {call, ets_lru, lookup, [S#st.ets_lru, key()]}},
- {1, {call, ets_lru, remove, [S#st.ets_lru, key()]}},
-
- {1, {call, ets_lru, hit, [S#st.ets_lru, Key]}},
- {1, {call, ets_lru, clear, [S#st.ets_lru]}}
- ]).
-
-
-precondition(_, _) ->
- true.
-
-
-postcondition(_S, {call, _, create, [_, _]}, {ok, _}) ->
- true;
-postcondition(S, {call, _, insert, [_, _Key, _]}, ok) ->
- check_constraints(S);
-postcondition(S, {call, _, lookup, [_, Key]}, Val) ->
- case lists:keysearch(Key, 1, S#st.kvs_lru) of
- {value, {Key, V}} when {ok, V} == Val ->
- check_constraints(S);
- false when Val == not_found ->
- check_constraints(S);
- E ->
- io:format(standard_error, "Bad lookup: ~p ~p~n",
- [E, Val]),
- false
- end;
-postcondition(S, {call, _, remove, [_, _Key]}, ok) ->
- check_constraints(S);
-postcondition(S, {call, _, hit, [_, _Key]}, ok) ->
- check_constraints(S);
-postcondition(S, {call, _, clear, [_]}, ok) ->
- check_constraints(S);
-postcondition(_S, _C, _V) ->
- io:format(standard_error, "BAD CALL: ~p ~p~n", [_C, _V]),
- false.
-
-
-check_constraints(S) ->
- ELRU = S#st.ets_lru,
- Count = ets:info(element(2, ELRU), size),
- MaxCount = element(5, ELRU),
- case Count > MaxCount of
- true ->
- io:format(standard_error, "Max count exceeded: ~p ~p~n",
- [Count, MaxCount]);
- false ->
- ok
- end,
- Count =< MaxCount.
-
-
-next_state(S, V, {call, _, create, [_, _]}) ->
- S#st{
- ets_lru={call, erlang, element, [2, V]},
- kvs_lru=[]
- };
-next_state(#st{kvs_lru=KVs}=S, _V, {call, _, insert, [_, Key, Val]}) ->
- S#st{
- kvs_lru={call, ?MODULE, kvs_insert, [KVs, Key, Val, S#st.ets_lru]}
- };
-next_state(#st{kvs_lru=KVs}=S, _V, {call, _, lookup, [_, Key]}) ->
- S#st{
- kvs_lru={call, ?MODULE, kvs_lookup, [KVs, Key]}
- };
-next_state(#st{kvs_lru=KVs}=S, _V, {call, _, remove, [_, Key]}) ->
- S#st{
- kvs_lru={call, ?MODULE, kvs_remove, [KVs, Key]}
- };
-next_state(#st{kvs_lru=KVs}=S, _V, {call, _, hit, [_, Key]}) ->
- S#st{
- kvs_lru={call, ?MODULE, kvs_hit, [KVs, Key]}
- };
-next_state(S, _V, {call, _, clear, [_]}) ->
- S#st{
- kvs_lru=[]
- }.
-
-
-cleanup(#st{ets_lru=undefined}) ->
- ok;
-cleanup(S) ->
- ets_lru:destroy(S#st.ets_lru).
-
-
-random_key(#st{kvs_lru=KVs}) ->
- Keys = [foo] ++ [K || {K, _V, _T} <- KVs],
- NumKeys = erlang:length(Keys),
- KeyPos = random:uniform(NumKeys),
- lists:nth(KeyPos, Keys).
-
-
-% Simple inefficient LRU implementation
-
-kvs_insert(KVs, K, V, ELRU) ->
- Max = element(5, ELRU),
- NewKVs = [{K, V} | lists:keydelete(K, 1, KVs)],
- lists:sublist(NewKVs, Max).
-
-
-kvs_lookup(KVs, K) ->
- case lists:keysearch(K, 1, KVs) of
- {value, {K, V}} ->
- TmpKVs = lists:keydelete(K, 1, KVs),
- [{K, V} | TmpKVs];
- false ->
- KVs
- end.
-
-
-kvs_remove(KVs, K) ->
- lists:keydelete(K, 1, KVs).
-
-
-kvs_hit(S, K) ->
- kvs_lookup(S, K).
-
-
-key() -> any().
-val() -> any().
-
diff --git a/test/ets_lru_constraints_tests.erl b/test/ets_lru_constraints_tests.erl
deleted file mode 100644
index ebd2f37..0000000
--- a/test/ets_lru_constraints_tests.erl
+++ /dev/null
@@ -1,120 +0,0 @@
--module(ets_lru_max_count_tests).
--behaviour(proper_statem).
-
-
--include_lib("proper/include/proper.hrl").
--include_lib("eunit/include/eunit.hrl").
-
-
--export([
- initial_state/0,
- command/1,
- precondition/2,
- postcondition/3,
- next_state/3,
- random_key/1
-]).
-
-
--record(st, {lru, keys}).
-
-
-proper_test_() ->
- PropErOpts = [
- {to_file, user},
- {max_size, 25},
- {numtests, 1000}
- ],
- {timeout, 3600, ?_assertEqual([], proper:module(?MODULE, PropErOpts))}.
-
-
-prop_lru() ->
- Fmt = "History: ~p~nState: ~p~nRes: ~p~nCmds:~n~p~n",
- ?FORALL(Cmds, commands(?MODULE),
- begin
- {H, S, R} = run_commands(?MODULE, Cmds),
- cleanup(S),
- ?WHENFAIL(
- io:format(standard_error, Fmt, [H, S, R, Cmds]),
- R =:= ok
- )
- end
- ).
-
-
-initial_state() ->
- #st{keys=[]}.
-
-
-command(#st{lru=undefined}=S) ->
- MaxObjs = 1 + random:uniform(10),
- MaxSize = 512 + random:uniform(128),
- Opts = [{max_objects, MaxObjs}, {max_size, MaxSize}],
- {call, ets_lru, create, [proper_ets_lru_tab, Opts]};
-command(S) ->
- Key = {call, ?MODULE, random_key, [S#st.keys]},
- frequency([
- {50, {call, ets_lru, insert, [S#st.lru, key(), val()]}},
- {1, {call, ets_lru, lookup, [S#st.lru, Key]}},
- {1, {call, ets_lru, remove, [S#st.lru, Key]}},
- {1, {call, ets_lru, hit, [S#st.lru, Key]}}
- ]).
-
-
-precondition(_, _) ->
- true.
-
-
-postcondition(_S, {call, _, create, [_, _]}, {ok, _}) ->
- true;
-postcondition(S, _C, _V) ->
- check_constraints(S).
-
-
-check_constraints(S) ->
- Count = ets:info(element(2, S#st.lru), size),
- MaxCount = element(5, S#st.lru),
- case Count > MaxCount of
- true ->
- io:format(standard_error, "Max count exceeded: ~p ~p~n",
- [Count, MaxCount]);
- false ->
- ok
- end,
- Size = ets:info(element(2, S#st.lru), memory),
- MaxSize = element(6, S#st.lru),
- case Size > MaxSize of
- true ->
- io:format(standard_error, "Max size exceeded: ~p ~p~n",
- [Size, MaxSize]);
- false ->
- ok
- end,
- Count =< MaxCount andalso Size =< MaxSize.
-
-
-next_state(S, V, {call, _, create, [_, _]}) ->
- S#st{
- lru={call, erlang, element, [2, V]}
- };
-next_state(S, _V, {call, _, insert, [_, Key, _Val]}) ->
- S#st{keys=[Key | S#st.keys]};
-next_state(S, _V, _C) ->
- S.
-
-
-cleanup(#st{lru=undefined}) ->
- ok;
-cleanup(S) ->
- ets_lru:destroy(S#st.lru).
-
-
-random_key(Keys0) ->
- Keys = [foo] ++ Keys0,
- NumKeys = erlang:length(Keys),
- KeyPos = random:uniform(NumKeys),
- lists:nth(KeyPos, Keys).
-
-
-key() -> any().
-val() -> any().
diff --git a/test/tutil.erl b/test/tutil.erl
new file mode 100644
index 0000000..ac258e6
--- /dev/null
+++ b/test/tutil.erl
@@ -0,0 +1,26 @@
+-module(tutil).
+
+-export([
+ run/2,
+ with_lru/1
+]).
+
+
+run(Plan, Fun) ->
+ etap:plan(Plan),
+ case (catch Fun()) of
+ ok ->
+ etap:end_tests();
+ Error ->
+ Msg = lists:flatten(io_lib:format("Error: ~p", [Error])),
+ etap:bail(Msg)
+ end.
+
+
+with_lru(Fun) ->
+ {ok, LRU} = ets_lru:create(?MODULE, []),
+ try
+ Fun(LRU)
+ after
+ ets_lru:destroy(LRU)
+ end.
\ No newline at end of file
