1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
Code.require_file "test_helper.exs", __DIR__
defmodule ModuleTest.ToBeUsed do
def value, do: 1
defmacro __using__(_) do
target = __CALLER__.module
Module.put_attribute(target, :has_callback, false)
Module.put_attribute(target, :before_compile, __MODULE__)
Module.put_attribute(target, :after_compile, __MODULE__)
Module.put_attribute(target, :before_compile, {__MODULE__, :callback})
quote do: (def line, do: __ENV__.line)
end
defmacro __before_compile__(_) do
quote do: (def before_compile, do: true)
end
defmacro __after_compile__(Macro.Env[module: ModuleTest.ToUse], bin) when is_binary(bin) do
# IO.puts "HELLO"
end
defmacro callback(env) do
value = Module.get_attribute(env.module, :has_callback)
quote do
def original_value(1), do: unquote(value)
end
end
end
defmodule ModuleTest.ToUse do
32 = __ENV__.line # Moving the next line around can make tests fail
def original_value(2), do: true
use ModuleTest.ToBeUsed
end
defmodule ModuleTest do
use ExUnit.Case, async: true
Module.register_attribute __MODULE__, :register_example, accumulate: true, persist: true
@register_example :it_works
@register_example :still_works
contents = quote do: (def eval_quoted_info, do: {__MODULE__, __ENV__.file, __ENV__.line})
Module.eval_quoted __MODULE__, contents, [], file: "sample.ex", line: 13
defmacrop in_module(block) do
quote do
defmodule Temp, unquote(block)
:code.purge(Temp)
:code.delete(Temp)
end
end
## Eval
test :eval_quoted do
assert eval_quoted_info() == {ModuleTest, "sample.ex", 13}
end
test :line_from_macro do
assert ModuleTest.ToUse.line == 34
end
## Callbacks
test :compile_callback_hook do
refute ModuleTest.ToUse.original_value(1)
assert ModuleTest.ToUse.original_value(2)
end
test :before_compile_callback_hook do
assert ModuleTest.ToUse.before_compile
end
test :on_definition do
defmodule OnDefinition do
@on_definition ModuleTest
def hello(foo, bar) do
foo + bar
end
end
assert Process.get(ModuleTest.OnDefinition) == :called
end
def __on_definition__(env, kind, name, args, guards, expr) do
Process.put(env.module, :called)
assert env.module == ModuleTest.OnDefinition
assert kind == :def
assert name == :hello
assert [{:foo, _, _}, {:bar, _ , _}] = args
assert [] = guards
assert {{:., _, [:erlang, :+]}, _, [{:foo, _, nil}, {:bar, _, nil}]} = expr
end
test :overridable_inside_before_compile do
defmodule OverridableWithBeforeCompile do
@before_compile ModuleTest
end
assert OverridableWithBeforeCompile.constant == 1
end
test :alias_with_raw_atom do
defmodule :"Elixir.ModuleTest.RawModule" do
def hello, do: :world
end
assert RawModule.hello == :world
end
defmacro __before_compile__(_) do
quote do
def constant, do: 1
defoverridable constant: 0
end
end
## Attributes
test :reserved_attributes do
assert List.keyfind(ExUnit.Server.__info__(:attributes), :behaviour, 0) == {:behaviour, [:gen_server]}
end
test :registered_attributes do
assert [{:register_example, [:it_works]}, {:register_example, [:still_works]}] ==
Enum.filter __MODULE__.__info__(:attributes), &match?({:register_example, _}, &1)
end
@some_attribute [1]
@other_attribute [3, 2, 1]
test :inside_function_attributes do
assert [1] = @some_attribute
assert [3, 2, 1] = @other_attribute
end
## Naming
test :concat do
assert Module.concat(Foo, Bar) == Foo.Bar
assert Module.concat(Foo, :Bar) == Foo.Bar
assert Module.concat(Foo, "Bar") == Foo.Bar
assert Module.concat(Foo, Bar.Baz) == Foo.Bar.Baz
assert Module.concat(Foo, "Bar.Baz") == Foo.Bar.Baz
assert Module.concat(Bar, nil) == Elixir.Bar
end
test :safe_concat do
assert Module.safe_concat(Foo, :Bar) == Foo.Bar
assert_raise ArgumentError, fn ->
Module.safe_concat SafeConcat, Doesnt.Exist
end
end
test :split do
module = Very.Long.Module.Name.And.Even.Longer
assert Module.split(module) == ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
assert Module.split("Elixir.Very.Long") == ["Very", "Long"]
assert Module.concat(Module.split(module)) == module
end
test :__MODULE__ do
assert Code.eval_string("__MODULE__.Foo") |> elem(0) == Foo
end
## Creation
test :defmodule do
assert match?({:module, Defmodule, binary, 3} when is_binary(binary), defmodule Defmodule do
1 + 2
end)
end
test :defmodule_with_atom do
assert match?({:module, :root_defmodule, _, _}, defmodule :root_defmodule do
:ok
end)
end
test :create do
contents =
quote do
def world, do: true
end
{:module, ModuleCreateSample, _, _} =
Module.create(ModuleCreateSample, contents, __ENV__)
assert ModuleCreateSample.world
end
test :no_function_in_module_body do
in_module do
assert __ENV__.function == nil
end
end
## Definitions
test :defines? do
in_module do
refute Module.defines? __MODULE__, {:foo, 0}
def foo(), do: bar()
assert Module.defines? __MODULE__, {:foo, 0}
assert Module.defines? __MODULE__, {:foo, 0}, :def
refute Module.defines? __MODULE__, {:bar, 0}, :defp
defp bar(), do: :ok
assert Module.defines? __MODULE__, {:bar, 0}, :defp
refute Module.defines? __MODULE__, {:baz, 0}, :defmacro
defmacro baz(), do: :ok
assert Module.defines? __MODULE__, {:baz, 0}, :defmacro
end
end
test :definitions_in do
in_module do
def foo(1, 2, 3), do: 4
assert Module.definitions_in(__MODULE__) == [foo: 3]
assert Module.definitions_in(__MODULE__, :def) == [foo: 3]
assert Module.definitions_in(__MODULE__, :defp) == []
end
end
test :function do
assert Module.function(:erlang, :atom_to_list, 1).(:hello) == 'hello'
assert is_function Module.function(This, :also_works, 0)
end
end
|
