File hamcrest-0.1.0-git.patch of Package erlang-hamcrest

Overview Repositories Revisions Requests Users Attributes Meta

File hamcrest-0.1.0-git.patch of Package erlang-hamcrest (Revision b01570d340dbb08997ca28c82a3c1bc1)

Currently displaying revision b01570d340dbb08997ca28c82a3c1bc1 , Show latest

diff --git a/.gitignore b/.gitignore
index e405d46..d6882d0 100755
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,7 @@
 *.o
 *.so
 *.swp
+.rebar/
 build/*
 ^build$
 Emakefile
@@ -14,3 +15,11 @@ test/logs/
 ebin/*.beam
 logs/*
 include/hamcrest.hrl
+qc.hrl
+deps/
+ct_*/
+all_runs.html
+ct_*
+jquery-latest.js
+jquery.tablesorter.min.js
+variables-ct@localhost
diff --git a/.travis.yml b/.travis.yml
index 351a2ac..b255a5e 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,7 +1,6 @@
 language: erlang
 otp_release:
-   - R14B03
-   - R14B01
-   - R13B04
+   - R15B02
+   - R16B
 before_script: "make build"
 script: "make test"
diff --git a/Makefile b/Makefile
index 399e0c2..0b8d9c4 100644
--- a/Makefile
+++ b/Makefile
@@ -1,13 +1,14 @@
 
-all: clean build test
+.PHONY: clean build test
+
+all: clean test
 
 clean:
 	@(./rebar clean)
 
 build:
-	@(./rebar get-deps compile)
-
-test:
-	@(./rebar skip_deps=true ct)
+	@(./rebar compile xref)
 
-.PHONY: deps test clean build
+test: build
+	@(./rebar -C test.config get-deps compile)
+	@(./rebar -C test.config skip_deps=true ct)
diff --git a/README.markdown b/README.markdown
index 30f3582..8ff091b 100644
--- a/README.markdown
+++ b/README.markdown
@@ -1,19 +1,23 @@
 Hamcrest Erlang [![travis](https://secure.travis-ci.org/hyperthunk/hamcrest-erlang.png)](http://travis-ci.org/hyperthunk/hamcrest-erlang)
 =============================
 
-This is an implementation of Hamcrest for the [Erlang programming language](http://www.erlang.org/). This
-tutorial has largely been cribbed from the hamcrest-python version, upon which the API is also based.
-
-Hamcrest is a framework for writing matcher objects allowing 'match' rules to be defined declaratively.
-There are a number of situations where matchers are invaluable, such as UI validation, or data filtering,
-but it is in the area of writing flexible tests that matchers are most commonly used.
-
-This tutorial shows you how to use Hamcrest for unit testing. When writing tests it is sometimes difficult
-to get the balance right between over specifying the test (and making it brittle to changes), and not
-specifying enough (making the test less valuable since it continues to pass even when the thing being tested
-is broken). Having a tool that allows you to pick out precisely the aspect under test and describe the values
-it should have, to a controlled level of precision, helps greatly in writing tests that are "just right".
-Such tests fail when the behaviour of the aspect under test deviates from the expected behaviour, yet continue
+This is an implementation of Hamcrest for the
+[Erlang programming language](http://www.erlang.org/). This tutorial has largely
+been cribbed from the hamcrest-python version, upon which the API is also based.
+
+Hamcrest is a framework for writing matcher objects allowing 'match' rules to be
+defined declaratively. There are a number of situations where matchers are
+invaluable, such as UI validation, or data filtering, but it is in the area of
+writing flexible tests that matchers are most commonly used.
+
+This tutorial shows you how to use Hamcrest for unit testing. When writing tests
+it is sometimes difficult to get the balance right between over specifying the
+test (and making it brittle to changes), and not specifying enough (making the
+test less valuable since it continues to pass even when the thing being tested is
+broken). Having a tool that allows you to pick out precisely the aspect under
+test and describe the values it should have, to a controlled level of precision,
+helps greatly in writing tests that are "just right". Such tests fail when the
+behaviour of the aspect under test deviates from the expected behaviour, yet continue
 to pass when minor, unrelated changes to the behaviour are made.
 
 Building Hamcrest-Erlang
@@ -26,13 +30,15 @@ generate the main header file:
 
     $ ./rebar clean && ./rebar compile
 
-Please note that currently there is a bug in the build plugins that requires these steps to be executed separately.
+Please note that currently there is a bug in the build plugins that
+requires these steps to be executed separately.
 
 My first Hamcrest test
 ------------------------
 
-We'll start be writing a very simple EUnit test, but instead of using EUnit's ?assertEqual macro, we use
-Hamcrest's assert_that construct and the standard set of matchers:
+We'll start be writing a very simple EUnit test, but instead of
+using EUnit's ?assertEqual macro, we use Hamcrest's `assert_that`
+construct and the standard set of matchers:
 
 ```erlang
 -module(demo1_tests).
@@ -46,10 +52,12 @@ using_assert_that_test() ->
     assert_that(10, is(greater_than(2))).  %% returns true
 ```
 
-The assert_that function is a stylised sentence for making a test assertion. In this example, the subject of the
-assertion is the number 10 that is the first method parameter. The second method parameter is a matcher
-for numbers, here a matcher that checks one number is greater than another using the standard > operator.
-If the test passes (as it will in this case) then assert_that returns the atom 'true' by default.
+The assert_that function is a stylised sentence for making a test
+assertion. In this example, the subject of the assertion is the number
+10 that is the first method parameter. The second method parameter is a
+matcher for numbers, here a matcher that checks one number is greater
+than another using the standard > operator. If the test passes (as it
+will in this case) then assert_that returns the atom 'true' by default.
 
 Standard Matchers
 ------------------
@@ -83,22 +91,27 @@ The match_mfa/3 function is a building block for creating custom matchers withou
 Using hamcrest assertions
 ----------------------------
 
-The `assert_that/2` and `assert_that/3` functions are the workhorses of the library. Each function takes an *actual* value and a
-match specification (more on this later) and apply the match function to the *actual* input value. If the match function evaluates
-to `false`, the descriptor on the match specification is used to construct and error message and an exception is thrown.
+The `assert_that/2` and `assert_that/3` functions are the workhorses of
+the library. Each function takes an *actual* value and a match specification
+(more on this later) and apply the match function to the *actual* input value.
+If the match function evaluates to `false`, the descriptor on the match
+specification is used to construct and error message and an exception is thrown.
 
-The two and three argument `?assertThat` macros work in exactly the same way, except they borrow their error reporting mechanism
-from eunit and provide information about the line number and expectation failure.
+The two and three argument `?assertThat` macros work in exactly the same way,
+except they borrow their error reporting mechanism from eunit and provide
+information about the line number and expectation failure.
 
 Writing custom matchers
 ----------------------------
 
-Hamcrest comes bundled with a few useful matchers, but you'll probably find that you need to create your own from
-time to time. This commonly occurs when you find a fragment of code that tests the same set of properties over and
-over again (and in different tests), and you want to bundle the fragment into a single assertion. By writing your
-own matcher you'll eliminate code duplication and make your tests more readable!
+Hamcrest comes bundled with a few useful matchers, but you'll
+probably find that you need to create your own from time to time.
+This commonly occurs when you find a fragment of code that tests
+the same set of properties over and over again (and in different tests),
+and you want to bundle the fragment into a single assertion.
 
-Let's write our own matcher for testing if a string is comprised of only digits. This is the test we want to write:
+Let's write our own matcher for testing if a string is comprised
+of only digits. This is the test we want to write:
 
 ```erlang
 string_is_only_digits_test() ->
@@ -110,6 +123,8 @@ And here's the implementation:
 ```erlang
 -module(custom_matchers).
 
+-include("../include/hamcrest.hrl").
+
 -export([only_digits/0]).
 
 only_digits() ->
@@ -122,27 +137,44 @@ only_digits(X) ->
     end.
 ```
 
-The zero arity factory function we exported is responsible for creating the matcher fun, which should take 1 argument
-and return the atom 'true' if it succeeds, otherwise 'false'. Although returning a fun is a simple enough way to define
-a matcher, there is a another way that allows you to specify the expected versus actual input, the matcher fun and a
-textual description that will be evaluated by hamcrest:assert_that/2 in case of match failures. Here's the only_digits/0
-example rewritten using the alternative API:
+The zero arity factory function we exported is responsible
+for creating the matcher fun, which should take 1 argument
+and return the atom 'true' if it succeeds, otherwise 'false'.
+The matcher fun must however be wrapped in a record, which also
+allows you to specify the expected versus actual input, and a textual
+description that will be evaluated by hamcrest:assert_that/2 in
+case of match failures. The `?MATCHER` macro simply takes the
+match function, description and expected input domain and generates
+an instance of this record.
+
+The desc field can contain a format string to be evaluated against
+the expected and actual values, or a function that returns a textual
+description instead. In the former case, the format string will be
+evaluated as `lists:flatten(io_lib:format(Desc, [Expected, Actual]))`
+and the hamcrest:message/4 function exists to provide a simple wrapper
+around that feature, allowing you to specify the whether the input is
+a string, an error tuple or another (arbitrary) term. It evaluates its
+arguments to produce a string that looks something like
+`expected a <TYPE> <DESC> <EXPECTED>, but was <ACTUAL>` when called.
+
+Re-using custom matchers
+------------------------
 
-```erlang
--module(custom_matchers).
+Whilst `only_digits/1` is a useful little function, we can improve on
+this by generalising it to handle any supplied regex compatible with
+the 're' module. Doing this makes the function re-usable in other contexts,
+and in fact there is a matcher for this already in the base library!
 
--export([only_digits/0]).
-
-only_digits() ->
-    matches_regex("^[\\d]*$").
+The `matches_regex` matcher is defined in `hamcrest_matchers` as
 
+```erlang
 matches_regex(Rx) ->
     #'hamcrest.matchspec'{
         matcher     =
                     fun(X) ->
                         case re:run(X, Rx) of
                             {match,_} -> true;
-                            _ -> false
+                            _         -> false
                         end
                     end,
         desc        = fun(Expected,Actual) ->
@@ -152,42 +184,34 @@ matches_regex(Rx) ->
     }.
 ```
 
-First of all, note that we're now calling the generic matches_regex/1 function which will operate over any supplied regex
-compatible with the 're' module. This function is returning an instance of the 'hamcrest.matchspec' record, defined in
-include/hamcrest.hrl. The matcher field points to the actual match function (which needs to return true or false as before).
-The expected field contains the 'expected' value, which in this case is the supplied regex. The desc field can contain a
-format string to be evaluated against the expected and actual values, or a function that returns a textual description instead.
-In the former case, the format string will be evaluated as `lists:flatten(io_lib:format(Desc, [Expected, Actual]))` and the
-hamcrest:message/4 function exists to provide a simple wrapper around that feature, allowing you to specify the whether the
-input is a string, an error tuple or another (arbitrary) term. It evaluates its arguments to produce a string that looks
-something like `expected a <TYPE> <DESC> <EXPECTED>, but was <ACTUAL>` when called.
-
-If you find the record syntax a little too verbose for your liking, there is a macro defined which cuts down on the noise somewhat:
+Given a definition such as this, our `is_digits` matcher becomes much simpler,
+as would `is_alpha_numeric` and many other string matches that regular
+expressions would make easy work of.
 
 ```erlang
-will_fail() ->
-  Matcher =
-  fun(F) ->
-    try F() of
-        _ -> false
-    catch _:_ -> true
-    end
-  end,
-  ?MATCHER(Matcher, expected_fail, {oneof, {exit,error,exception}}).
+-module(custom_matchers).
+
+-include_lib("hamcrest/include/hamcrest.hrl").
+-export([only_digits/0]).
+
+only_digits() ->
+    matches_regex("^[\\d]*$").
 ```
 
-Another way to construct custom matchers is to use the match_mfa/3 function, which takes a module, function and its initial
-arguments and matches if adding the match input to the argument list and calling `apply(M,F,A)` evaluates to true. This takes
-away the headache of having to write the matchspec yourself, at the expense of a slightly less specific description provided
-by assert_that if the match fails. Here's an example usage taken from the tests and another taken from the core API itself:
+Notice that this time we created the record explicitly instead of using
+the `?MATCHER` macro. Yet another way to construct custom matchers is to
+use the match_mfa/3 function, which takes a module, function and its
+initial arguments and matches if adding the match input to the argument
+list and calling `apply(M,F,A)` evaluates to true. This takes away the headache
+of having to write the matchspec yourself, at the expense of a slightly less
+specific description provided by assert_that if the match fails. Here's an
+example usage taken from the tests and another taken from the core API itself:
 
 ```erlang
 isalive() ->
   match_mfa(erlang, is_process_alive, []).
 
 some_test(_) ->
-    IsMemberOf = fun(L) ->
-        match_mfa(lists, member, [L])
-    end,
-    assert_that(hd(X), IsMemberOf(X))
+    IsMemberOf = match_mfa(lists, member, [[a,b,c]]),
+    assert_that(a, IsMember).
 ```
diff --git a/ebin/hamcrest.app b/ebin/hamcrest.app
index a60da2d..5c7b8cf 100644
--- a/ebin/hamcrest.app
+++ b/ebin/hamcrest.app
@@ -2,7 +2,7 @@
  hamcrest,
  [{description,"Hamcrest Matcher Library"},
   {vsn,"0.1.0"},
-  {modules,[hamcrest,hamcrest_matchers,hamcrest_term]},
+  {modules,[hamcrest,hamcrest_matchers,hamcrest_term,hamcrest_transform]},
   {registered,[]},
   {applications,[kernel,stdlib]},
-  {env,[]}]}.
\ No newline at end of file
+  {env,[]}]}.
diff --git a/include/hamcrest_internal.hrl b/include/hamcrest_internal.hrl
index c7d4e39..46df5bc 100644
--- a/include/hamcrest_internal.hrl
+++ b/include/hamcrest_internal.hrl
@@ -26,20 +26,28 @@
 %% @copyright 2010 Tim Watson.
 %% -----------------------------------------------------------------------------
 
+-ifdef(namespaced_types).
+    -type hc_set()    :: sets:set().
+    -type hc_gb_set() :: gb_sets:set().
+-else.
+    -type hc_set()    :: set().
+    -type hc_gb_set() :: gb_set().
+-endif.
+
 -record('hamcrest.matchspec', {
     matcher     =   undefined  :: fun((term()) -> boolean()),
     expected    =   undefined  :: term(),
-    desc        =   ""         :: string() | atom() | fun((term(), term()) -> string())
+    desc        =   ""         :: term()
 }).
 
 -define(MATCHER(MatchFun, Expected, Desc),
-  #'hamcrest.matchspec'{
-    matcher=MatchFun,
-    expected=Expected,
-    desc=Desc
-  }).
+        #'hamcrest.matchspec'{
+          matcher=MatchFun,
+          expected=Expected,
+          desc=Desc
+        }).
 
 -define(HECKLE(M,F,A),
-  .application:set_env(hamcrest, heckle, [M, F, A])).
+  application:set_env(hamcrest, heckle, [M, F, A])).
 
 -define(NOHECKLE, application:unset_env(hamcrest, heckle)).
diff --git a/priv/build/plugins/eqc_resolver.erl b/priv/build/plugins/eqc_resolver.erl
new file mode 100644
index 0000000..94adab9
--- /dev/null
+++ b/priv/build/plugins/eqc_resolver.erl
@@ -0,0 +1,61 @@
+%% -----------------------------------------------------------------------------
+%%
+%% Hamcrest Erlang.
+%%
+%% Copyright (c) 2010 Tim Watson (watson.timothy@gmail.com)
+%%
+%% 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 Tim Watson <watson.timothy@gmail.com>
+%% @copyright 2010 Tim Watson.
+%%
+%% Generates hamcrest.hrl header file during build process. Loaded by rebar.
+%% -----------------------------------------------------------------------------
+-module(eqc_resolver).
+
+-export([preprocess/2]).
+
+preprocess(Config, _) ->
+    case rebar_utils:processing_base_dir(Config) of
+        false -> {ok, []};
+        true  -> case code:lib_dir(eqc, include) of
+                     {error, bad_name} ->
+                         write_include("proper"),
+                         {ok, []};
+                     _ ->
+                         write_include("eqc"),
+                         Deps = rebar_config:get_local(Config, deps, []),
+                         DepsNoPropEr = proplists:delete(proper, Deps),
+                         Config2 = rebar_config:set(Config, deps, DepsNoPropEr),
+                         {ok, Config2, []}
+                 end
+    end.
+
+write_include(Lib) ->
+    file:write_file(filename:join(test_dir(), "qc.hrl"),
+                    include(Lib)).
+
+test_dir() ->
+    filename:join(rebar_utils:get_cwd(), "test").
+
+include(Lib) ->
+    [<<"-include_lib(\"">>,
+     Lib, <<"/include/">>,
+     Lib, <<".hrl\").\n">>,
+     <<"-define(">>, Lib, <<", true).">>].
diff --git a/priv/build/plugins/header_generator.erl b/priv/build/plugins/header_generator.erl
index 2c94beb..b5cb255 100644
--- a/priv/build/plugins/header_generator.erl
+++ b/priv/build/plugins/header_generator.erl
@@ -34,7 +34,7 @@ post_compile(_, AppFile) ->
     case lists:suffix("hamcrest.app", AppFile) of
         true ->
             code:add_patha(filename:join(rebar_utils:get_cwd(), "ebin")),
-            Exports = [ F || F <- hamcrest_matchers:module_info(exports), 
+            Exports = [ F || F <- hamcrest_matchers:module_info(exports),
                              F /= module_info ],
             rebar_log:log(debug, "Adding header exports/imports: ~p~n", [Exports]),
             Imports = [ io_lib:format("~s/~p", [F,A]) || {F, A} <- Exports ],
@@ -45,13 +45,20 @@ post_compile(_, AppFile) ->
             Path = filename:join(PWD, "priv/build/templates/hamcrest.hrl.src"),
             {ok, Bin} = file:read_file(Path),
             Res = rebar_templater:render(Bin, dict:from_list([{imports, ImportList}])),
+            ResBin = erlang:iolist_to_binary(Res),
             Dest = filename:absname(filename:join(["include", "hamcrest.hrl"])),
-            case file:write_file(Dest, list_to_binary(Res)) of
-                ok -> 
-                    rebar_log:log(info, "Header file(s) generated.~n", []),
+            case file:read_file(Dest) of
+                {ok, ResBin} ->
+                    rebar_log:log(info, "Header file(s) untouched.~n", []),
                     ok;
-                {error, WriteError} ->
-                    rebar_utils:abort("Failed to write ~p: ~p~n", [Dest, WriteError])
+                _ ->
+                    case file:write_file(Dest, ResBin) of
+                        ok ->
+                            rebar_log:log(info, "Header file(s) generated.~n", []),
+                            ok;
+                        {error, WriteError} ->
+                            rebar_utils:abort("Failed to write ~p: ~p~n", [Dest, WriteError])
+                    end
             end;
         false ->
             ok
diff --git a/priv/build/templates/hamcrest.hrl.src b/priv/build/templates/hamcrest.hrl.src
index 2acf553..2ed54ca 100644
--- a/priv/build/templates/hamcrest.hrl.src
+++ b/priv/build/templates/hamcrest.hrl.src
@@ -37,7 +37,7 @@
     ((fun () ->
         case (hamcrest:assert_that(Value, MatchSpec)) of
             true -> true;
-            __V -> .erlang:error({assertion_failed,
+            __V -> erlang:error({assertion_failed,
                       [{module, ?MODULE},
                        {line, ?LINE},
                        {expected, true},
@@ -50,7 +50,7 @@
 fun() ->
     case (hamcrest:assert_that(Value, MatchSpec)) of
         true -> true;
-        __V -> .erlang:error({assertion_failed,
+        __V -> erlang:error({assertion_failed,
                   [{module, ?MODULE},
                    {line, ?LINE},
                    {expected, true},
@@ -63,7 +63,7 @@ end).
     ((fun () ->
         case (hamcrest:assert_that(Value, MatchSpec, After)) of
         true -> true;
-        __V -> .erlang:error({assertion_failed,
+        __V -> erlang:error({assertion_failed,
                       [{module, ?MODULE},
                        {line, ?LINE},
                        {expected, true},
@@ -74,5 +74,5 @@ end).
       end)())).
 -endif.
 
--import(hamcrest, [assert_that/2, assert_that/3]).
+-import(hamcrest, [assert_that/2, assert_that/3, match/2, match/3]).
 -import(hamcrest_matchers, [{{ imports }}]).
diff --git a/rebar.config b/rebar.config
index 7574918..adeb36c 100644
--- a/rebar.config
+++ b/rebar.config
@@ -1,15 +1,26 @@
 
 {lib_dirs, ["deps"]}.
-{erl_opts, [debug_info, fail_on_warning]}.
-{cover_enabled, true}.
+{erl_opts, [debug_info, fail_on_warning, {platform_define, "^[0-9]+", namespaced_types}]}.
 {clean_files, ["logs", "build", "include/hamcrest.hrl"]}.
-{deps, [
-  {proper, "1.0", {git, "http://github.com/manopapad/proper.git", "master"}}
-]}.
-
-%{pre_hooks, [
-%    {compile, "sh priv/build/scripts/bootstrap-deps.sh"}
-%]}.
 
 {plugin_dir, "priv/build/plugins"}.
-{plugins, [header_generator]}.
+{plugins, [header_generator, eqc_resolver]}.
+
+{xref_checks, []}.
+{xref_queries,
+    [{"((XC - UC) || (XU - X - B))",[]},  %% calls to undefined functions
+     {"(L - LU)", []},                    %% local unused
+     {"(LU * (X - XU))", [                %% exported functions only used locally
+        {hamcrest,assert_that,2},         %% NB: we're a library so this is expected...
+        {hamcrest,assert_that,3},
+        {hamcrest,check,2},
+        {hamcrest,describe,2},
+        {hamcrest,heckle,2},
+        {hamcrest,match,3},
+        {hamcrest_matchers,check_member,2}, %% called via apply/3
+        {hamcrest_matchers,equal_to,1},
+        {hamcrest_matchers,foreach,1},
+        {hamcrest_matchers,is_not,1},
+        {hamcrest_matchers,match_mfa,3},
+        {hamcrest_matchers,reverse_match_mfa,3}]},
+     {"(DF * (XU + LU))", []}]}.
diff --git a/src/hamcrest.erl b/src/hamcrest.erl
index 5ee6f41..cf1d329 100644
--- a/src/hamcrest.erl
+++ b/src/hamcrest.erl
@@ -33,139 +33,91 @@
 
 -include("hamcrest_internal.hrl").
 
--export_type([matcher/0]).
+-export_type([matchspec/0]).
 
--export([match/2,
+-export([is_matcher/1,
+         match/2,
          match/3,
          check/2,
          assert_that/2,
          assert_that/3,
-         message/4,
          describe/2,
-         describe_spec/2,
          heckle/2]).
 
-
 %%%============================================================================
 %%% Types
 %%%============================================================================
 
--opaque matcher() :: #'hamcrest.matchspec'{}.
-
+-opaque matchspec() :: #'hamcrest.matchspec'{}.
 
 %%%============================================================================
 %%% API
 %%%============================================================================
 
+%% @doc Returns `true' if the specified term is a valid hamcrest matcher,
+%% otherwise `false'.
+-spec(is_matcher(any()) -> boolean()).
+is_matcher(Something) ->
+  erlang:is_record(Something, 'hamcrest.matchspec').
+
+-spec(match(term(), matchspec()) -> boolean()).
 match(Value, MatchSpec) ->
   match(Value, MatchSpec, fun() -> ok end).
 
+-spec(match(term(), matchspec(),
+                  fun(() -> any())) -> boolean()).
 match(Value, MatchSpec, RunAfter) ->
-  catch( assert_that(Value, MatchSpec, RunAfter) ) == true.
+  (catch assert_that(Value, MatchSpec, RunAfter)) == true.
 
+-spec(assert_that(term(), matchspec(),
+                        fun(() -> any())) -> 'true' | no_return()).
 assert_that(Value, MatchSpec, RunAfter) when is_function(RunAfter, 0) ->
-  %% TODO: verify that this doesn't break the semantics of assert_that *and* match!! :/
   try assert_that(Value, MatchSpec)
   after RunAfter()
   end.
 
+-spec(assert_that(term(), matchspec()) -> 'true' | no_return()).
 assert_that(Value, MatchSpec) ->
   case check(Value, MatchSpec) of
     {assertion_failed, _}=Failure ->
       erlang:error(Failure);
     true ->
-      true
+      true;
+    Other ->
+      exit({what_the, Other})
   end.
 
+-spec(check(term(), matchspec()) -> 'true' | {assertion_failed, term()}).
 check(Value, #'hamcrest.matchspec'{ matcher=MatchFunc }=MatchSpec) ->
   heckle(MatchSpec, Value),
-  try check(Value, MatchFunc) of
+  try MatchFunc(Value) of
     true -> true;
-    {assertion_failed, expected_exit} ->
-      {assertion_failed, describe_error(MatchSpec, {success, Value})};
     {assertion_failed, _} ->
       {assertion_failed, describe(MatchSpec, Value)};
-    {assertion_override, Err} ->
-      {assertion_failed, Err};
+    {assertion_override, _}=Err ->
+      {assertion_failed, describe(MatchSpec, Err)};
+    false ->
+      {assertion_failed, describe(MatchSpec, Value)};
     What ->
       {assertion_failed, What}
   catch
     Class:Reason ->
-      {assertion_failed, describe_error(MatchSpec, {Class, Reason})}
-  end;
-check(Value, MatchSpec) when is_function(MatchSpec, 1) ->
-  case MatchSpec(Value) of
-    false ->
-      case is_function(Value, 0) of
-        %% TODO: ticket #
-        true  -> {assertion_failed, expected_exit};
-        false -> {assertion_failed, default_describe(Value)}
-      end;
-    _ -> true
+      {assertion_failed, describe(MatchSpec, {Class, Reason})}
   end.
 
+-spec(heckle(matchspec(), any()) -> any()).
 heckle(MatchSpec, Actual) ->
   case application:get_env(hamcrest, heckle) of
     {ok, [M,F,A]} ->
-      Argv = [MatchSpec, Actual],
-      apply(M, F, [Argv|A]);
+      Argv = [MatchSpec, Actual|A],
+      apply(M, F, Argv);
     _ ->
       ok
   end.
 
-%% default_heckle(#'hamcrest.matchspec'{ expected=Exp }=_Matcher, Actual) ->
-%%default_heckle(_) ->
-%%  io:format("about to apply matcher [~p] against actual input [~p]~n", [Exp, Actual]).
-
-message(string, Def, Expected, Actual) ->
-  lists:flatten(io_lib:format("Expected a string ~s [~s], but was [~s]",
-    [Def, Expected, Actual]));
-message(error, Desc, Expected, {Class, Reason}) ->
-  Actual = io_lib:format("unexpected exit with ~p:~p", [Class, Reason]),
-  Desc(Expected, Actual);
-message(_Type, _Def, Expected, Actual) when is_list(Expected)
-                                      andalso is_record(hd(Expected), 'hamcrest.matchspec') ->
-  lists:flatten(describe_spec(Actual, Expected));
-message(Type, Def, Expected, Actual) when is_list(Def) ->
-  lists:flatten(io_lib:format("Expected a ~p ~s [~p], but was [~p]",
-    [Type, Def, Expected, Actual])).
-
-default_describe(Value) ->
-  describe(fun(X) ->
-              message(value, "matching", Value, X)
-           end, undefined, Value).
-
-describe(#'hamcrest.matchspec'{ expected={anyof, Matchers} }, Actual) ->
-  describe_spec(Actual, Matchers);
+describe(Ms, Actual) when is_function(Actual, 0) ->
+    describe(Ms, erlang:fun_info(Actual));
 describe(#'hamcrest.matchspec'{ desc=Desc, expected=Expected }, Actual) ->
-  describe(Desc, Expected, Actual).
-
-describe(Desc, Expected, Actual) when is_function(Desc, 2) ->
-  Desc(Expected, Actual);
-describe(Desc, _, Actual) when is_function(Desc, 1) ->
-  Desc(Actual);
-describe(Desc, Expected, Actual) when is_list(Desc) ->
-  lists:flatten(io_lib:format(Desc, [Expected, Actual]));
-describe({oneof,{exit,error,exception}}, expected_fail, _) ->
-  "Expected failure, but operation succeeded!";
-describe(expected_fail, {Class, Reason}, _) ->
-  describe("Expected ~p due to ~p, but operation succeeded!", Class, Reason).
-
-describe_spec(Actual, Matchers) ->
-  lists:flatten([ describe(Matcher, Actual) ++ "\n" || Matcher <- Matchers ]).
-
-describe_error(#'hamcrest.matchspec'{ desc=expected_fail,
-                                      expected={Class, Reason} },
-                                               {ActualClass, ActualReason}) ->
-  case ActualClass of
-    success ->
-      Msg = "expected exit with ~p:~p, but operation succeeded",
-      lists:flatten(io_lib:format(Msg, [Class, Reason]));
-    _ ->
-      Msg = "expected exit with ~p:~p, but was [~p:~p]",
-      lists:flatten(io_lib:format(Msg, [Class, Reason, ActualClass, ActualReason]))
-  end;
-describe_error(#'hamcrest.matchspec'{ desc=Desc,
-                                      expected=Expected },
-                                      {Class, Reason}) when is_function(Desc) ->
-  message(error, Desc, Expected, {Class, Reason}).
+  [{expected, Expected},
+   {actual, Actual},
+   {matcher, Desc}].
diff --git a/src/hamcrest_matchers.erl b/src/hamcrest_matchers.erl
index 8651b72..41a9c8b 100644
--- a/src/hamcrest_matchers.erl
+++ b/src/hamcrest_matchers.erl
@@ -40,7 +40,10 @@
     all_of/1,
     anything/0,
     any_of/1,
+    foreach/1,
     is/1,
+    is_true/0,
+    is_false/0,
     is_not/1,
     equal_to/1,
     exactly_equal_to/1,
@@ -56,25 +59,45 @@
     has_length/1,
     has_same_contents_as/1,
     contains_member/1,
+    matches_regex/1,
     match_mfa/3,
+    match_mfa/4,
     reverse_match_mfa/3,
+    reverse_match_mfa/4,
     isalive/0,
     isdead/0,
     isempty/0,
     check_isempty/1,
     check_member/2]).
 
--spec(will_fail/0 :: () -> fun((fun(() -> any())) -> any())).
+%%%============================================================================
+%%% Types
+%%%============================================================================
+
+-type matchfun(A) :: fun((A) -> boolean()).
+-type container_t() :: list() | hc_set() | hc_gb_set().
+
+%%%============================================================================
+%%% API
+%%%============================================================================
+
+-spec(will_fail() -> hamcrest:matchspec()).
 will_fail() ->
+    %% Matcher :: fun((fun(() -> any())) -> boolean())
     Matcher = fun(F) ->
         try F() of
             _ -> false
         catch _:_ -> true end
     end,
-    ?MATCHER(Matcher, expected_fail, {oneof, {exit,error,exception}}).
+    #'hamcrest.matchspec'{
+        matcher     = Matcher,
+        desc        = will_fail,
+        expected    = {oneof,{exit,error,exception}}
+    }.
 
--spec(will_fail/2 :: (atom(), term()) -> #'hamcrest.matchspec'{}).
+-spec(will_fail(atom(), term()) -> hamcrest:matchspec()).
 will_fail(Type, Reason) ->
+    %% Matcher :: fun((fun(() -> any())) -> boolean())
     Matcher = fun(F) ->
         try F() of
             _ -> false
@@ -82,197 +105,219 @@ will_fail(Type, Reason) ->
     end,
     #'hamcrest.matchspec'{
         matcher     = Matcher,
-        desc        = expected_fail,
+        desc        = will_fail,
         expected    = {Type, Reason}
     }.
 
--spec(anything/0 :: () -> fun((term()) -> true)).
+-spec(anything() -> hamcrest:matchspec()).
 anything() ->
-    fun(_) -> true end.
+    ?MATCHER(fun(_) -> true end, any, anything).
+
+-spec(foreach(hamcrest:matchspec()) -> hamcrest:matchspec()).
+foreach(M) when is_record(M, 'hamcrest.matchspec') ->
+    ?MATCHER(fun(L) -> drop_matches(M, L) == [] end, M,
+             {foreach, M#'hamcrest.matchspec'.desc}).
 
--spec(any_of/1 :: (list(fun((term()) -> boolean()))) -> #'hamcrest.matchspec'{};
-                  (list(#'hamcrest.matchspec'{})) -> #'hamcrest.matchspec'{}).
+drop_matches(Match, []) ->
+    case hamcrest:match([], Match) of
+        true -> [];
+        _    -> false
+    end;
+drop_matches(Match, L) ->
+    lists:dropwhile(fun(E) -> hamcrest:match(E, Match) end, L).
+
+-spec(any_of(list(matchfun(term())))     -> hamcrest:matchspec();
+                  (list(hamcrest:matchspec())) -> hamcrest:matchspec()).
 any_of(Matchers) when is_list(Matchers) ->
     MatchFun =
     fun(M) when is_function(M) -> M;
      (#'hamcrest.matchspec'{matcher=F}) -> F
     end,
     #'hamcrest.matchspec'{
-        matcher     = fun(X) -> lists:member(true, 
+        matcher     = fun(X) -> lists:member(true,
                                     [ (MatchFun(M))(X) || M <- Matchers ]) end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "matching any of", Expected, Actual)
-                      end,
-        expected    = {anyof, Matchers}
+        desc        = any_of,
+        expected    = {any, Matchers}
     }.
 
--spec(all_of/1 :: (list(fun((term()) -> boolean()))) -> #'hamcrest.matchspec'{};
-                  (list(#'hamcrest.matchspec'{})) -> #'hamcrest.matchspec'{}).
+%% TODO: older syntax for type specifications - we need to support
+%% >= R13B for the most part...
+-spec all_of(list(matchfun(term())))     -> hamcrest:matchspec();
+            (list(hamcrest:matchspec())) -> hamcrest:matchspec().
 all_of(Matchers) when is_list(Matchers) ->
     MatchFun = fun(M) when is_function(M) -> M;
        (#'hamcrest.matchspec'{matcher=F}) -> F
     end,
     #'hamcrest.matchspec'{
-        matcher     = fun(X) -> not(lists:member(false, 
+        matcher     = fun(X) -> not(lists:member(false,
                                     [ (MatchFun(M))(X) || M <- Matchers ])) end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "matching any of", Expected, Actual)
-                      end,
-        expected    = {anyof, Matchers}
+        desc        = all_of,
+        expected    = {all, Matchers}
     }.
 
--spec(equal_to/1 :: (term()) -> #'hamcrest.matchspec'{}).
+-spec(equal_to(term()) -> hamcrest:matchspec()).
 equal_to(Y) ->
     #'hamcrest.matchspec'{
         matcher     = fun(X) -> X == Y end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "equal to", Expected, Actual)
-                      end,
+        desc        = equal_to,
         expected    = Y
     }.
 
--spec(exactly_equal_to/1 :: (term()) -> #'hamcrest.matchspec'{}).
+-spec(exactly_equal_to(term()) -> hamcrest:matchspec()).
 exactly_equal_to(X) ->
     #'hamcrest.matchspec'{
         matcher     = fun(Y) -> X =:= Y end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "exactly equal to", Expected, Actual)
-                      end,
+        desc        = exactly_equal_to,
         expected    = X
     }.
 
--spec(is/1 :: (Y::fun((X::term()) -> boolean())) -> fun((X::term()) -> boolean());
-              (Y::#'hamcrest.matchspec'{}) -> #'hamcrest.matchspec'{};
-              (Y) -> fun((Y) -> boolean())).
-is(Matcher) when is_function(Matcher) ->
-    Matcher;
+-spec(is(matchfun(term()))      -> hamcrest:matchspec();
+         (hamcrest:matchspec()) -> hamcrest:matchspec();
+         (any())                -> hamcrest:matchspec()).
 is(Matcher) when is_record(Matcher, 'hamcrest.matchspec') ->
     Matcher;
 is(Term) ->
     equal_to(Term).
 
--spec(is_not/1 :: (Y::fun((X::term()) -> boolean())) -> 
-                        fun((X::term()) -> boolean());
-                  (Y::#'hamcrest.matchspec'{}) -> 
-                        #'hamcrest.matchspec'{};
-                  (term()) -> #'hamcrest.matchspec'{}).
-is_not(Matcher) when is_function(Matcher, 1) ->
-  fun(X) -> not(Matcher(X)) end;
-is_not(#'hamcrest.matchspec'{ matcher=MatchFun }=MatchSpec) 
+-spec(is_true() -> hamcrest:matchspec()).
+is_true() ->
+    equal_to(true).
+
+-spec(is_false() -> hamcrest:matchspec()).
+is_false() ->
+    is_not(equal_to(true)).
+
+-spec(is_not(matchfun(term()))     -> hamcrest:matchspec();
+            (hamcrest:matchspec()) -> hamcrest:matchspec();
+            (term())               -> hamcrest:matchspec()).
+is_not(#'hamcrest.matchspec'{ matcher=MatchFun }=MatchSpec)
     when is_record(MatchSpec, 'hamcrest.matchspec') ->
   MatchSpec#'hamcrest.matchspec'{ matcher = (fun(X) -> not(MatchFun(X)) end) };
 is_not(Term) ->
   is_not(equal_to(Term)).
 
--spec(greater_than/1 :: (number()) -> #'hamcrest.matchspec'{}).
+-spec(greater_than(number()) -> hamcrest:matchspec()).
 greater_than(X) ->
     #'hamcrest.matchspec'{
         matcher     = fun(Y) -> Y > X end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "greater than", Expected, Actual)
-                      end,
+        desc        = greater_than,
         expected    = X
     }.
 
--spec(greater_than_or_equal_to/1 :: (number()) -> #'hamcrest.matchspec'{}).
+-spec(greater_than_or_equal_to(number()) -> hamcrest:matchspec()).
 greater_than_or_equal_to(X) ->
     #'hamcrest.matchspec'{
         matcher     = fun(Y) -> Y >= X end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "greater than or equal to", Expected, Actual)
-                      end,
+        desc        = greater_than_or_equal_to,
         expected    = X
     }.
 
--spec(less_than/1 :: (number()) -> #'hamcrest.matchspec'{}).
+-spec(less_than(number()) -> hamcrest:matchspec()).
 less_than(X) ->
     #'hamcrest.matchspec'{
         matcher     = fun(Y) -> Y < X end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "less than", Expected, Actual)
-                      end,
+        desc        = less_than,
         expected    = X
     }.
 
--spec(less_than_or_equal_to/1 :: (number()) -> #'hamcrest.matchspec'{}).
+-spec(less_than_or_equal_to(number()) -> hamcrest:matchspec()).
 less_than_or_equal_to(X) ->
     #'hamcrest.matchspec'{
         matcher     = fun(Y) -> Y =< X end,
-        desc        = fun(Expected,Actual) ->
-                        message(value, "less than or equal to", Expected, Actual)
-                      end,
+        desc        = {less_than_or_equal_to, X},
         expected    = X
     }.
 
--spec(contains_string/1 :: (string()) -> fun((string()) -> boolean())).
+%% fun((string()) -> boolean()) matchers...
+
+-spec(contains_string(string()) -> hamcrest:matchspec()).
 contains_string([_|_]=X) ->
-    fun(Y) -> string:str(Y, X) > 0 end.
+    ?MATCHER(fun(Y) -> string:str(Y, X) > 0 end, X, {contains_string, X}).
 
--spec(starts_with/1 :: (string()) -> fun((string()) -> boolean())).
+-spec(starts_with(string()) -> hamcrest:matchspec()).
 starts_with(X) ->
-    fun(Y) -> string:str(Y, X) == 1 end.
+    ?MATCHER(fun(Y) -> string:str(Y, X) == 1 end, X, {starts_with, X}).
 
--spec(ends_with/1 :: (string()) -> fun((string()) -> boolean())).
+-spec(ends_with(string()) -> hamcrest:matchspec()).
 ends_with(X) ->
-    fun(Y) -> string:equal(string:right(Y, length(X)), X) end.
+    ?MATCHER(fun(Y) -> string:equal(string:right(Y, length(X)), X) end,
+             X, {ends_with, X}).
+
+-spec(matches_regex(string()) -> hamcrest:matchspec()).
+matches_regex(Rx) ->
+    #'hamcrest.matchspec'{
+               matcher     =
+                   fun(X) ->
+                           case re:run(X, Rx) of
+                               {match,_} -> true;
+                               _         -> false
+                           end
+                   end,
+               desc        = {regex_match, Rx},
+               expected    = Rx
+              }.
 
+-spec(match_mfa(module(), atom(), list(term())) -> hamcrest:matchspec()).
 match_mfa(Mod, Func, Args) ->
     #'hamcrest.matchspec'{
         matcher     = fun(X) -> catch(apply(Mod, Func, Args ++ [X])) == true end,
-        desc        = fun(_, Actual) ->
-                        Desc = "Expected the outcome of evaluating "
-                               "~p:~p to be true, but was ~p",
-                        lists:flatten(io_lib:format(Desc, [Mod, Func, Actual]))
-                      end,
+        desc        = {eval, [Mod, Func, Args]},
         expected    = true
     }.
 
-reverse_match_mfa(Mod, Func, Args) ->
+-spec(match_mfa(module(), atom(),
+                list(term()), term()) -> hamcrest:matchspec()).
+match_mfa(Mod, Func, Args, Desc) ->
+    MS = match_mfa(Mod, Func, Args),
+    MS#'hamcrest.matchspec'{desc=Desc}.
+
+-spec(reverse_match_mfa(module(), atom(),
+                        list(term())) -> hamcrest:matchspec()).
+reverse_match_mfa(Mod, Func, Args) when is_list(Args) ->
     #'hamcrest.matchspec'{
         matcher     = fun(X) -> catch(apply(Mod, Func, [X|Args])) == true end,
-        desc        = fun(_, Actual) ->
-                        Desc = "Expected the outcome of evaluating "
-                               "~p:~p to be true, but was ~p",
-                        lists:flatten(io_lib:format(Desc, [Mod, Func, Actual]))
-                      end,
+        desc        = {eval, [Mod, Func, lists:reverse(Args)]},
         expected    = true
     }.
 
+-spec(reverse_match_mfa(module(), atom(),
+                        list(term()), term()) -> hamcrest:matchspec()).
+reverse_match_mfa(Mod, Func, Args, Desc) ->
+    MS = reverse_match_mfa(Mod, Func, Args),
+    MS#'hamcrest.matchspec'{desc=Desc}.
+
+-spec(isalive() -> hamcrest:matchspec()).
 isalive() ->
-    match_mfa(erlang, is_process_alive, []).
+    MS = match_mfa(erlang, is_process_alive, []),
+    MS#'hamcrest.matchspec'{desc=is_process_alive, expected=true}.
 
+-spec(isdead() -> hamcrest:matchspec()).
 isdead() ->
     #'hamcrest.matchspec'{
         matcher     = fun(X) -> not erlang:is_process_alive(X) end,
-        desc        = fun(_, _) ->
-                        "Expected the outcome of evaluating erlang:is_process_alive "
-                        "to be false, but was true"
-                      end,
+        desc        = is_process_alive,
         expected    = false
     }.
 
--spec(has_length/1 :: (number()) -> #'hamcrest.matchspec'{}).
+-spec(has_length(number()) -> hamcrest:matchspec()).
 has_length(Size) when is_number(Size) ->
   ?MATCHER(fun(XS) -> length(XS) == Size end,
-    fun(_, Actual) ->
-        Desc = "Expected a list of length ~p, but was ~p",
-        case is_list(Actual) of
-            true -> lists:flatten(io_lib:format(Desc, [Size, length(Actual)]));
-            false -> lists:flatten(io_lib:format(Desc, [Size, Actual]))
-        end
-    end,
-    Size).
+           Size, {length, Size}).
 
+-spec(has_same_contents_as(container_t()) -> hamcrest:matchspec()).
 has_same_contents_as(Container) when is_list(Container) ->
-    all_of([reverse_match_mfa(?MODULE, check_member, [E]) || E <- Container]).
+    MS = foreach(match_mfa(?MODULE, check_member, [Container])),
+    MS#'hamcrest.matchspec'{desc=has_same_contents_as, expected=Container}.
 
+-spec(contains_member(term()) -> hamcrest:matchspec()).
 contains_member(E) ->
     reverse_match_mfa(?MODULE, check_member, [E]).
 
+check_member([], []) ->
+    true;
 check_member(Container, E) when is_list(Container) ->
     lists:member(E, Container);
 check_member(Container, E) ->
-    ct:pal("checking for ~p in ~p, where~n", [E, Container]),
     case sets:is_set(Container) of
         true ->
             sets:is_element(E, Container);
@@ -292,6 +337,7 @@ check_member(Container, E) ->
             end
     end.
 
+-spec(isempty() -> hamcrest:matchspec()).
 isempty() ->
     match_mfa(?MODULE, check_isempty, []).
 
@@ -302,7 +348,7 @@ check_isempty({}) ->
 check_isempty(X) ->
     case sets:is_set(X) of
         true ->
-            sets:is_empty(X);
+            sets:size(X) == 0;
         _ ->
             case gb_sets:is_set(X) of
                 true -> gb_sets:is_empty(X);
diff --git a/src/hamcrest_transform.erl b/src/hamcrest_transform.erl
new file mode 100644
index 0000000..2871b97
--- /dev/null
+++ b/src/hamcrest_transform.erl
@@ -0,0 +1,166 @@
+%% -----------------------------------------------------------------------------
+%%
+%% Hamcrest Erlang.
+%%
+%% Copyright (c) 2017 Karolis Petrauskas (k.petrauskas@gmail.com)
+%%
+%% 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 Karolis Petrauskas <k.petrauskas@gmail.com>
+%% @copyright 2017 Karolis Petrauskas.
+%% @doc Hamcrest parse transform.
+%% @reference See <a href="http://code.google.com/p/hamcrest/">Hamcrest</a>
+%% for more information.
+%% -----------------------------------------------------------------------------
+-module(hamcrest_transform).
+-export([parse_transform/2]).
+
+
+%%  @doc
+%%  This parse transform imports the hamcrest matchers if they are not imported yet.
+%%  It also expands `assertThat' and `assertThat_' calls to the corresponding assertions.
+%%
+parse_transform(Forms, _Opts) ->
+    ok = init_var_names(),
+    FormsWithImport = ensure_import(Forms),
+    lists:map(fun transform_asserts_form/1, FormsWithImport).
+
+
+%%  @private
+%%  Check, if there exists an import for the matchers.
+%%
+have_import(Forms) ->
+    [] =/= [ I || I = {attribute, _Line, import, {hamcrest_matchers, _Imported}} <- Forms ].
+
+
+%%  @private
+%%  Add import for matchers, if they are missing.
+%%
+ensure_import(Forms) ->
+    case have_import(Forms) of
+        true  -> Forms;
+        false -> add_import_form(Forms)
+    end.
+
+
+%%  @private
+%%  Add import after the module attribute.
+%%
+add_import_form([]) ->
+    [];
+
+add_import_form([{attribute, L, module, _Name} = Form | Other]) ->
+    Imported = hamcrest_matchers:module_info(exports) -- [{module_info,0}, {module_info,1}],
+    ImportForm = {attribute, L, import, {hamcrest_matchers, Imported}},
+    [Form, ImportForm | Other];
+
+add_import_form([Form | Other]) ->
+    [Form | add_import_form(Other)].
+
+
+%%  @private
+%%  Transform `assertThat', traverse functions.
+%%
+transform_asserts_form({function, Line, Name, Arity, Clauses}) ->
+    {function, Line, Name, Arity, lists:map(fun transform_asserts_clause/1, Clauses)};
+
+transform_asserts_form(Form) ->
+    Form.
+
+
+%%  @private
+%%  Transform `assertThat', traverse function clauses.
+%%
+transform_asserts_clause({clause, Line, Head, Guard, Exprs}) ->
+    {clause, Line, Head, Guard, lists:map(fun transform_asserts_expr/1, Exprs)}.
+
+
+%%  @private
+%%  Transform `assertThat', traverse expressions.
+%%
+transform_asserts_expr({call, LineC, {atom, _LineA, assertThat}, [_Value, _Expected] = Args}) ->
+    transform_assert_call(LineC, Args);
+
+transform_asserts_expr({call, LineC, {atom, _LineA, assertThat_}, [_Value, _Expected] = Args}) ->
+    {'fun', LineC, {clauses, [{clause, LineC, [], [], [
+        transform_assert_call(LineC, Args)
+    ]}]}};
+
+transform_asserts_expr(Expr) when is_tuple(Expr) ->
+    list_to_tuple(lists:map(fun transform_asserts_expr/1, tuple_to_list(Expr)));
+
+transform_asserts_expr(Expr) when is_list(Expr) ->
+    lists:map(fun transform_asserts_expr/1, Expr);
+
+transform_asserts_expr(Expr) ->
+    Expr.
+
+
+%%  @private
+%%
+%%  Transforms `assertThat(Value, MatchSpec)' to
+%%  ```
+%%      case hamcrest:check(Value, MatchSpec) of
+%%          true                      -> true;
+%%          {assertion_failed, __V_X} -> erlang:error({assertion_failed, __V_X});
+%%          __V_X                     -> erlang:error({assertion_failed, __V_X})
+%%      end
+%%  '''
+%%
+%%  The transformation differs from the `?assertThat(Value, MatchSpec)' macro
+%%  in order to have stack trace without the temporary function on top ot it.
+%%
+transform_assert_call(Line, Args) ->
+    VarName = next_var_name(),
+    CallErlangError = {call, Line, {remote, Line, {atom, Line, erlang}, {atom, Line, error}}, [
+        {tuple, Line, [
+            {atom, Line, assertion_failed},
+            {var, Line, VarName}
+        ]}
+    ]},
+    {'case', Line, {call,Line, {remote,Line,{atom,Line,hamcrest},{atom,Line,check}}, Args}, [
+        {clause, Line, [{atom, Line, true}], [], [
+            {atom, Line, true}
+        ]},
+        {clause, Line, [{tuple, Line, [{atom, Line, assertion_failed}, {var, Line, VarName}]}], [], [
+            CallErlangError
+        ]},
+        {clause, Line, [{var, Line, VarName}], [], [
+            CallErlangError
+        ]}
+    ]}.
+
+
+%%  @private
+%%  Reset variable counter.
+%%
+init_var_names() ->
+    _ = erlang:put({?MODULE, var_num}, 0),
+    ok.
+
+
+%%  @private
+%%  Create new variable name.
+%%
+next_var_name() ->
+    VarNum = erlang:get({?MODULE, var_num}) + 1,
+    erlang:put({?MODULE, var_num}, VarNum),
+    list_to_atom("__V_" ++ integer_to_list(VarNum)).
+
+
diff --git a/test.config b/test.config
new file mode 100644
index 0000000..f206e37
--- /dev/null
+++ b/test.config
@@ -0,0 +1,19 @@
+{cover_enabled, true}.
+
+{deps, [
+    {proper, "1.*", {git, "http://github.com/manopapad/proper.git", "v1.2"}}
+]}.
+
+{erl_opts, [
+    debug_info,
+    fail_on_warning,
+    {src_dirs, ["test"]},
+    {platform_define, "^[0-9]+", namespaced_types}
+    ]}.
+
+{validate_app_modules, false}.
+
+{ct_extra_params, "-no_auto_compile"}.
+
+{plugin_dir, "priv/build/plugins"}.
+{plugins, [eqc_resolver]}.
diff --git a/test/hamcrest_SUITE.erl b/test/hamcrest_SUITE.erl
index a15be30..d8fdd11 100644
--- a/test/hamcrest_SUITE.erl
+++ b/test/hamcrest_SUITE.erl
@@ -31,8 +31,8 @@
 -module(hamcrest_SUITE).
 
 -include_lib("common_test/include/ct.hrl").
--include_lib("proper/include/proper.hrl").
--include("../include/test.hrl").
+-include("test.hrl").
+-include("qc.hrl").
 -include("../include/hamcrest.hrl").
 
 -compile(export_all).
@@ -40,15 +40,15 @@
 all() -> ?CT_REGISTER_TESTS(?MODULE).
 
 assert_that_always_passes_input_to_matcher_fun(_) ->
-  P = ?FORALL(X, any(),
+  P = ?FORALL(X, something(),
     begin
-      F = fun(Y) -> Y == X end,
-      assert_that(X, F)
+      M = ?MATCHER(fun(Y) -> Y == X end, equality, X),
+      assert_that(X, M)
     end),
     ?EQC(P).
 
 assert_that_ignores_test_descriptions_when_matchers_pass(_) ->
-  P = ?FORALL(X, any(),
+  P = ?FORALL(X, something(),
     begin
       F = fun(Y) -> Y == X end,
       assert_that(X, #'hamcrest.matchspec'{ matcher=F, desc="" })
@@ -56,7 +56,7 @@ assert_that_ignores_test_descriptions_when_matchers_pass(_) ->
     ?EQC(P).
 
 assert_that_returns_true_from_match_success(_) ->
-  P = ?FORALL(X, any(),
+  P = ?FORALL(X, something(),
     assert_that(X, is(X))),
   ?EQC(P).
 
@@ -64,7 +64,12 @@ assert_that_returns_true_from_match_success(_) ->
 
 failing_assertions_throw_exceptions(_) ->
   MF = is(equal_to(2)),
-  ?assertException(error, {assertion_failed, "Expected a value equal to [2], but was [1]"},
+  ?assertException(
+     error,
+     {assertion_failed,
+      [{expected,2},
+       {actual,1},
+       {matcher,equal_to}]},
     assert_that(1, MF)).
 
 three_arg_assert_that_always_runs_supplied_fun(_) ->
@@ -72,3 +77,38 @@ three_arg_assert_that_always_runs_supplied_fun(_) ->
   catch( ?assertThat(1, is(equal_to(2)), AfterFun) ),
   WasRun = get(after_run),
   ?assertThat(WasRun, is(equal_to(wasrun))).
+
+is_matcher(_) ->
+  ?assertThat(hamcrest:is_matcher(blah), is_false()),
+  ?assertThat(hamcrest:is_matcher(contains_string("1234")), is_true()),
+  ?assertThat(hamcrest:is_matcher(has_same_contents_as("1234")), is_true()),
+  ?assertThat(hamcrest:is_matcher(foreach(is_true())), is_true()),
+  ?assertThat(hamcrest:is_matcher(has_length(10)), is_true()),
+  ?assertThat(hamcrest:is_matcher(all_of([is_true(), is_false()])), is_true()),
+  ?assertThat(hamcrest:is_matcher(any_of([is_true(), is_false()])), is_true()),
+  ?assertThat(hamcrest:is_matcher(reverse_match_mfa(erlang, is_process_alive, [])), is_true()),
+  P = ?FORALL(X, list(something()),
+          begin
+              [case lists:member(F, [foreach, all_of, any_of,
+                                     reverse_match_mfa, has_length,
+                                     has_same_contents_as, check_member,
+                                     check_isempty, module_info,
+                                     contains_string]) of
+                  true ->
+                      ok;
+                  _ ->
+                      Fn = fun hamcrest_matchers:F/A,
+                      Matcher = apply(Fn, lists:duplicate(A, X)),
+                      io:format("checking ~p for ~p~n", [Matcher, {F, A, Fn}]),
+                      ?assertThat(hamcrest:is_matcher(Matcher),
+                                 is_true())
+               end || {F, A} <- hamcrest_matchers:module_info(exports)],
+               true
+          end),
+  ?EQC(P).
+
+-ifdef('eqc').
+something() -> eqc_gen:oneof([int(), nat(), list(char), binary()]).
+-else.
+something() -> any().
+-endif.
diff --git a/test/hamcrest_matchers_SUITE.erl b/test/hamcrest_matchers_SUITE.erl
index 28f4cfd..6726425 100644
--- a/test/hamcrest_matchers_SUITE.erl
+++ b/test/hamcrest_matchers_SUITE.erl
@@ -30,31 +30,37 @@
 -module(hamcrest_matchers_SUITE).
 
 -include_lib("common_test/include/ct.hrl").
--include_lib("proper/include/proper.hrl").
--include("../include/test.hrl").
+-include("qc.hrl").
 -include("../include/hamcrest.hrl").
 
 -compile(export_all).
 
-all() -> ?CT_REGISTER_TESTS(?MODULE).
+-include("test.hrl").
+
+all() ->
+    application:set_env(hamcrest, heckle, [?MODULE, say, []]),
+    ?CT_REGISTER_TESTS(?MODULE).
+
+say(MS, Actual) ->
+    io:format("checking ~p against ~p~n", [Actual, MS]).
 
 anything_always_matches(_) ->
-    P = ?FORALL(X, any(),
+    P = ?FORALL(X, binary(),
             true == assert_that(X, is(anything()))),
     ?EQC(P).
 
 is_matches_the_same_way_as_the_underlying_matcher(_) ->
-    P = ?FORALL(X, any(),
+    P = ?FORALL(X, binary(),
             is(equal_to(X)) == equal_to(X)),
     ?EQC(P).
 
 is_provides_convenient_shortcut_for_equal_to(_) ->
-    P = ?FORALL(X, any(),
+    P = ?FORALL(X, binary(),
             is(X) == equal_to(X)),
     ?EQC(P).
 
 is_not_evaluates_to_logical_negation_of_underlying_matcher(_) ->
-    P = ?FORALL(X, {any(), any()},
+    P = ?FORALL(X, {binary(), binary()},
             begin
                 #'hamcrest.matchspec'{matcher=F1} = equal_to(X),
                 #'hamcrest.matchspec'{matcher=F2} = is_not(equal_to(X)),
@@ -63,7 +69,7 @@ is_not_evaluates_to_logical_negation_of_underlying_matcher(_) ->
     ?EQC(P).
 
 is_not_provides_convenient_shortcut_for_not_equal_to(_) ->
-    P = ?FORALL({X, Y}, {any(), any()},
+    P = ?FORALL({X, _Y}, {binary(), binary()},
             begin
                 #'hamcrest.matchspec'{matcher=F1} = equal_to(X),
                 #'hamcrest.matchspec'{matcher=F2} = is_not(X),
@@ -72,30 +78,43 @@ is_not_provides_convenient_shortcut_for_not_equal_to(_) ->
     ?EQC(P).
 
 reflexivity_of_equal_to(_) ->
-    P = ?FORALL(X, any(),
-            ?IMPLIES(X == X,
-              begin
-                Y = X,
-                assert_that(X, equal_to(Y))
-              end)),
+    P = ?FORALL(X, binary(),
+                begin
+                    Y = X,
+                    assert_that(X, equal_to(Y))
+                end),
     ?EQC(P).
 
 symmetry_of_equal_to(_) ->
-    P = ?FORALL({X, Y}, {int(), int()},
-            ?IMPLIES(Y == X,
-                assert_that(X, equal_to(Y)))),
+    P = ?FORALL(X, int(),
+                begin
+                    Y = X,
+                    assert_that(X, equal_to(Y)),
+                    Z = Y,
+                    assert_that(Z, equal_to(X))
+                end),
     ?EQC(P).
 
 exactly_equal_to_works_on_types_and_values(_) ->
     true = assert_that(atom, exactly_equal_to(atom)),
-    ?assertException(error, {assertion_failed, "Expected a value exactly equal to [atom], but was [\"atom\"]"},
-        assert_that("atom", exactly_equal_to(atom))),
+    ?assertException(
+       error,
+       {assertion_failed,
+        [{expected,atom},
+         {actual,"atom"},
+         {matcher,exactly_equal_to}]},
+       assert_that("atom", exactly_equal_to(atom))),
     true = assert_that(1, exactly_equal_to(1)),
-    ?assertException(error, {assertion_failed, "Expected a value exactly equal to [1], but was [1.0]"},
+    ?assertException(
+       error,
+       {assertion_failed,
+        [{expected, 1},
+         {actual, 1.0},
+         {matcher, exactly_equal_to}]},
         assert_that(1.0, exactly_equal_to(1))).
 
 any_of_checks_the_logical_disjunction_of_a_list_of_matchers(_) ->
-    P = ?FORALL(XS, list(boolean()),
+    P = ?FORALL(XS, list(char()),
             ?IMPLIES(length(XS) > 0,
             begin
                 M = lists:map(fun(_) -> fun(_) -> true end end, XS),
@@ -113,11 +132,17 @@ will_fail_asserts_failure_against_given_condition(_) ->
 
 %% TODO: check will_fail during 'failure' conditions
 will_fail_should_fail_if_the_operation_succeeds(_) ->
-  P = ?FORALL(X, any(),
+  P = ?FORALL(X, binary(),
       begin
         F = fun() -> X end,
+        FI = erlang:fun_info(F),
         ok ==
-        ?assertException(error, {assertion_failed, "expected exit with error:{nomatch,unexpected_value}, but operation succeeded"},
+        ?assertException(error,
+            {assertion_failed,
+              [{expected,
+                {error,{nomatch,unexpected_value}}},
+               {actual, FI},
+               {matcher,will_fail}]},
             assert_that(F, will_fail(error, {nomatch, unexpected_value})))
       end),
   ?EQC(P).
@@ -132,13 +157,15 @@ greater_than_should_fail_with_error_unlike_built_in_operator(_) ->
   P = ?FORALL({X, Y}, {oneof([int(), real()]), oneof([int(), real()])},
       ?IMPLIES(Y < X,
       begin
-        Msg = hamcrest:message(value, "greater than", X, Y),
         try (assert_that(Y, greater_than(X))) of
           Term ->
-            ct:pal("Term = ~p", [Term]),
-            false
+            ct:pal("Term = ~p", [Term]), false
         catch error:Reason ->
-          {assertion_failed, Msg} == Reason
+          assert_that(Reason,
+                equal_to({assertion_failed,
+                            [{expected, X},
+                             {actual, Y},
+                             {matcher, greater_than}]}))
         end
       end)),
     ?EQC(P).
@@ -171,11 +198,10 @@ less_than_or_equal_to_should_behave_like_built_in_operator(_) ->
     ?EQC(P).
 
 contains_string_should_get_proper_subset_in_all_cases(_) ->
-  P = ?FORALL({X, Y}, {string(), int()},
-        ?IMPLIES(length(X) > 0 andalso
-                 length(X) >= Y andalso
-                 Y > 0,
+  P = ?FORALL(X, noshrink(non_empty(list(char()))),
+        ?IMPLIES(length(X) > 0,
         begin
+          Y = round(length(X) / 2),
           SubStr = string:left(X, Y),
           true = assert_that(X, contains_string(SubStr))
         end)),
@@ -185,7 +211,7 @@ contains_string_should_not_create_matcher_for_empty_strings(_) ->
   ?assertException(error, function_clause, contains_string([])).
 
 contains_string_should_not_match_empty_string(_) ->
-  P = ?FORALL(X, string(),
+  P = ?FORALL(X, list(char()),
         ?IMPLIES(length(X) > 0,
             assert_that(fun() ->
                             assert_that(X, contains_string("foo bar baz"))
@@ -194,29 +220,32 @@ contains_string_should_not_match_empty_string(_) ->
   ?EQC(P).
 
 starts_with_should_only_match_first_portion_of_string(_) ->
-  P = ?FORALL({X, Y}, {string(), int()},
-        ?IMPLIES(Y > 1 andalso
-                 length(X) > Y andalso
-                 string:left(X, Y) /= string:right(X, Y),
+  P = ?FORALL(Xs, noshrink(non_empty(list(char()))),
+        ?IMPLIES(length(Xs) > 1,
         begin
-          LStr = string:left(X, Y),
-          RStr = string:right(X, Y),
-          true = assert_that(X, starts_with(LStr)),
-          Val = (starts_with(RStr))(X),
-          not Val
+          Y = erlang:max(round(length(Xs) / 2), 2),
+          LStr = string:left(Xs, Y),
+          RStr = string:right(Xs, Y),
+          true = assert_that(Xs, starts_with(LStr)),
+          if RStr /= LStr ->
+                  assert_that(match(Xs, starts_with(RStr)),
+                              is_false());
+             true -> true
+          end
         end)),
     ?EQC(P).
 
 ends_with_should_only_match_last_portion_of_string(_) ->
-  P = ?FORALL({X, Y}, {string(), int()},
-        ?IMPLIES(Y > 1 andalso length(X) >= Y,
+  P = ?FORALL(Xs, noshrink(non_empty(list(char()))),
+        ?IMPLIES(length(Xs) > 0,
         begin
-          LStr = string:left(X, Y),
-          RStr = string:right(X, Y),
-          case (assert_that(X, ends_with(RStr))) of
+          Y = round(length(Xs) / 2),
+          _LStr = string:left(Xs, Y),
+          RStr = string:right(Xs, Y),
+          case (assert_that(Xs, ends_with(RStr))) of
             true -> true;
             false ->
-                ct:pal("X = ~p~n", [X]),
+                ct:pal("X = ~p~n", [Xs]),
                 ct:pal("Y = ~p~n", [Y]),
                 ct:pal("RStr = ~p~n", [RStr]),
                 false
@@ -227,25 +256,22 @@ ends_with_should_only_match_last_portion_of_string(_) ->
     ?EQC(P).
 
 has_length_should_match_length(_) ->
-  P = ?FORALL(XS, list(),
+  P = ?FORALL(XS, list(int()),
       begin
         assert_that(XS, has_length(length(XS)))
       end),
     ?EQC(P).
 
-match_mfa_should_defer_to_supplied_mfa(_) ->
-  P = ?FORALL(X, string(),
+match_mfa(_) ->
+  P = ?FORALL(X, list(char()),
         ?IMPLIES(length(X) > 0,
         begin
-          IsMemberOf = fun(L) ->
-            match_mfa(lists, member, [L])
-          end,
-          assert_that(hd(X), IsMemberOf(X))
+          assert_that(hd(X), reverse_match_mfa(lists, member, [X]))
         end)),
     ?EQC(P).
 
 reverse_match_mfa_should_flip_its_arguments(_) ->
-    P = ?FORALL(X, string(),
+    P = ?FORALL(X, list(char()),
         ?IMPLIES(length(X) > 0,
         begin
             Head = hd(X),
@@ -257,24 +283,27 @@ reverse_match_mfa_should_flip_its_arguments(_) ->
     ?EQC(P).
 
 has_same_contents_as_should_ignore_order(_) ->
-    P = ?FORALL(X, list(),
+    P = ?FORALL(X, non_empty(list(int())),
         ?IMPLIES(length(X) > 0,
         assert_that(lists:reverse(X), has_same_contents_as(X)))),
     ?EQC(P).
 
 has_same_contents_as_should_recognise_singular_errors(_) ->
-    P = ?FORALL(X, list(),
-        ?IMPLIES(length(X) > 0,
-        assert_that(
-        fun() -> assert_that(tl(X), has_same_contents_as(X)) end, 
-        will_fail()))),
+    P = ?FORALL(X, noshrink(non_empty(list(int()))),
+        ?IMPLIES(length(sets:to_list(sets:from_list(X))) > 0,
+        begin
+            Xs = sets:to_list(sets:from_list(X)),
+            assert_that(
+              fun() -> assert_that(tl(Xs), has_same_contents_as([a, b, c])) end,
+              will_fail())
+        end)),
     ?EQC(P).
 
 has_same_contents_as_should_work_for_empty_lists(_) ->
     ?assertThat([], has_same_contents_as([])).
 
 match_mfa_should_fail_if_mf_is_invalid(_) ->
-    NoSuchMod = no_existing, NoSuchFunc = nor_i,
+    NoSuchMod = non_existing, NoSuchFunc = nor_i,
     #'hamcrest.matchspec'{matcher=M} = match_mfa(NoSuchMod, NoSuchFunc, []),
     M(any_input) == false.
 
diff --git a/test/hamcrest_transform_SUITE.erl b/test/hamcrest_transform_SUITE.erl
new file mode 100644
index 0000000..5db0627
--- /dev/null
+++ b/test/hamcrest_transform_SUITE.erl
@@ -0,0 +1,59 @@
+%% -----------------------------------------------------------------------------
+%%
+%% Hamcrest Erlang.
+%%
+%% Copyright (c) 2017 Karolis Petrauskas (k.petrauskas@gmail.com)
+%%
+%% 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 Karolis Petrauskas <k.petrauskas@gmail.com>
+%% @copyright 2017 Karolis Petrauskas.
+%% -----------------------------------------------------------------------------
+
+-module(hamcrest_transform_SUITE).
+-compile([{parse_transform, hamcrest_transform}]).  % NOTE: This line is being tested.
+-export([all/0, test_success/1, test_failed_assert/1, test_generator/1]).
+
+
+all() ->
+    [test_success, test_failed_assert, test_generator].
+
+
+test_success(_Config) ->
+    true = assertThat(1, is(1)),
+    ok.
+
+
+test_failed_assert(_Config) ->
+    true = try assertThat(1, is(2)) of
+        true ->
+            error_expected
+    catch
+        error:{assertion_failed, _AssertionDetails} ->
+            [{?MODULE, _Function, _Arity, _FileLine} | _] = erlang:get_stacktrace(),
+            true
+    end,
+    ok.
+
+
+test_generator(_Config) ->
+    true = (assertThat_(1, is(1)))(),
+    ok.
+
+
diff --git a/include/test.hrl b/test/test.hrl
similarity index 88%
rename from include/test.hrl
rename to test/test.hrl
index 66eb37b..80c1291 100644
--- a/include/test.hrl
+++ b/test/test.hrl
@@ -38,7 +38,7 @@
             Mod:module_info(exports)
         )
     ],
-    ct:pal("registering ~p~n", [All]),
+    ct:log("registering ~p~n", [All]),
     All).
 
 %% NB: copied verbatim from eunit.hrl because proper_common.hrl redefined the LET macro, 
@@ -46,7 +46,7 @@
 -define(assertException(Class, Term, Expr),
 	((fun () ->
 	    try (Expr) of
-	        __V -> .erlang:error({assertException_failed,
+	        __V -> erlang:error({assertException_failed,
 				      [{module, ?MODULE},
 				       {line, ?LINE},
 				       {expression, (??Expr)},
@@ -57,7 +57,7 @@
 	    catch
 		Class:Term -> ok;
 	        __C:__T ->
-		    .erlang:error({assertException_failed,
+		    erlang:error({assertException_failed,
 				   [{module, ?MODULE},
 				    {line, ?LINE},
 				    {expression, (??Expr)},
@@ -66,14 +66,15 @@
 				     ++" , [...] }"},
 				    {unexpected_exception,
 				     {__C, __T,
-				      .erlang:get_stacktrace()}}]})
+				      erlang:get_stacktrace()}}]})
 	    end
 	  end)())).
 
 -define(EQC(P),
-    case code:lib_dir(eqc, include) of
-        {error, bad_name} ->
-            proper:quickcheck(P);
-        _ ->
-            eqc:check(P)
+    begin
+    Mod = case code:lib_dir(eqc, include) of
+              {error, bad_name} -> proper;
+              _                 -> eqc
+          end,
+    true = Mod:quickcheck(P)
     end).

Places

File hamcrest-0.1.0-git.patch of Package erlang-hamcrest (Revision b01570d340dbb08997ca28c82a3c1bc1)

Places