tests.erl2

%% we start with defMods
%%  Why? we need to know if
%%    X:Y means a call to the Erlang module X or the module we are defining
%%    here.
%%  

defMods shell mod1 mod2 mod3 mod4 end.

addMod shell. 

%% hello world

def hello() -> io:format("Hello world~n") end.
hello().


def test(N) -> io:format("Passing test ~p~n",[N]) end.
def print(X) -> io:format("~p~n", [X]) end.

test(1).

print("factorial defined as a fun").

def fac = fun(0) -> 1; (N) -> N*fac(N-1) end.

print("Unit test of factorial").

120 = fac(5).

print("Print a large factorial").

print(fac(50)).
test(3).

print("define factorial using a fun").

def fac1 = fun(0) -> 1;(N) -> N*fac1(N-1) end.
print(fac1(50)).

test(4).

beginFunc f1/1 end.

  %% f1 is a local fucntion - that is in the export list
  %% so it will be exported

  shell:test(5).

  def f1(X) -> {f1,X} end.

  {f1,123} = f1(123).

  shell:test(5).      %% test(N) would mean in the local scope
                      %% so we have to call this shell:test()
 
  %% define a local function
  
  def local(X) -> {local, X} end.
  {local,222} = local(222).
  shell:test(7).

endFunc.

%% Test that I can call the exported function

{f1, a} = f1(a).
test(8).

%% test that calling the local function will fail

{'EXIT', _} = (catch local(222)).
test(9).

%% Now make two functions both using the
%% same auxilliary functions to test name hiding is correct
%% BOTH of these use the same auxilliary function

beginFunc f2/1 end.
 def f2(X) -> foo(X) end.
 def foo(X) -> {f2foo, X} end.     %% foo is not exported
endFunc.

beginFunc f3/1 end.
 def foo(X) -> {f3foo, X} end.    %% foo is not exported
 def f3(X) -> foo(X) end.
endFunc.

{f2foo,a} = f2(a).	
{f3foo,a} = f3(a).
test(10).

%% add unit tests inside a function definition

beginFunc f4/1 end.
 def foo(X,Y) -> {f3foo, X+Y} end.    %% foo is not exported
 {f3foo,5} = foo(2,3).
 def f3(X) -> foo(1,X) end.
 {f3foo,6} = f3(5).
endFunc.

test(11).

print("Modules").

addMod mod1.

defExports a/1 b/2 c/3 end.  %% ignored for now

 def test(N) -> io:format("Passing local test in mod1:~p~n",[N]) end.

 def a() -> {mod1,a} end.
 {mod1, a} = a().
 shell:test(12).

 def a(X) -> {mod1,a,X} end.
 {mod1, a, 12} = a(12).

 shell:test(13).  
 test(14).

addMod shell.

print("Testing that we can call functions in a module from outside").

{mod1, a, 12} = mod1:a(12).	
test(15).

{'EXIT', _} = (catch mod1:b(12)).
test(16).

%% Mod with private functions

addMod mod2.

defExports a/1 b/2 c/3 end.  %% ignored for now

 def test(N) -> io:format("Passing local test ~p in mod2~n",[N]) end.
 test(17).

 beginFunc a/1 end.
    def a(X) -> b(X) end.
    def b(X) -> {mod2,b,X} end.
 endFunc.

 test(18).

 {mod2,b,123} = a(123).
 test(19).

addMod shell.
 
{mod2,b,123} = mod2:a(123).
test(20).

print("Meta programming ...").

%% We can bind variable *OUTSIDE* a module and
%% use them *inside* the module

F25 = fac(25).

addMod mod3.
 defExports a/1 end.  %% ignored for now

 def a(N) -> F25 + N end.

addMod shell.

print(mod3:a(10)).

print("Just imagine what you could do with this ...").

print("More fancy stuff").

%% We can do unit tests *inside the module*
%% If the unit tests fail - we crash and the module will not be generated

addMod mod4.
 
 defExports fac/1 end. 
 def fac(0) -> 1; fac(N) -> N*fac(N-1) end.
 
 %% unit tests
 120 = fac(5).
 shell:print("unit test worked").

 def twice(X) -> 3*X end.
 9 = twice(3).
 shell:print("** I know this is bad but don't worry").

addMod shell.

test(21).

print("Horray - everything worked dump the results into a file
       which we can compile later").

erl2:make_mods().