Release mnesia tests

1 files changed, 2419 insertions, 0 deletions

diff --git a/lib/mnesia/test/mnesia_isolation_test.erl b/lib/mnesia/test/mnesia_isolation_test.erl
new file mode 100644
index 0000000000..4fc6e8fe58
--- /dev/null
+++ b/lib/mnesia/test/mnesia_isolation_test.erl
@@ -0,0 +1,2419 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1997-2009. All Rights Reserved.
+%% 
+%% The contents of this file are subject to the Erlang Public License,
+%% Version 1.1, (the "License"); you may not use this file except in
+%% compliance with the License. You should have received a copy of the
+%% Erlang Public License along with this software. If not, it can be
+%% retrieved online at http://www.erlang.org/.
+%% 
+%% Software distributed under the License is distributed on an "AS IS"
+%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+%% the License for the specific language governing rights and limitations
+%% under the License.
+%% 
+%% %CopyrightEnd%
+%%
+
+%%
+-module(mnesia_isolation_test).
+-author('hakan@erix.ericsson.se').
+
+-compile([export_all]).
+-include("mnesia_test_lib.hrl").
+
+init_per_testcase(Func, Conf) ->
+    mnesia_test_lib:init_per_testcase(Func, Conf).
+
+fin_per_testcase(Func, Conf) ->
+    mnesia_test_lib:fin_per_testcase(Func, Conf).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+all(doc) ->
+    ["Verify the isolation property.", 
+     "Operations of concurrent transactions must yield results which",
+     "are indistinguishable from the results which would be obtained by",
+     "forcing each transaction to be serially executed to completion in",
+     "some order. This means that repeated reads of the same records",
+     "within any committed transaction must have returned identical",
+     "data when run concurrently with any mix of arbitary transactions.",
+     "Updates in one transaction must not be visible in any other",
+     "transaction before the transaction has been committed."];
+all(suite) ->
+    [
+     locking, 
+     visibility
+    ].
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+locking(doc) ->
+    ["Verify locking semantics for various configurations",
+     " NoLock = lock_funs(no_lock, any_granularity)",
+     " SharedLock = lock_funs(shared_lock, any_granularity)",
+     " ExclusiveLock = lock_funs(exclusive_lock, any_granularity)",
+     " AnyLock = lock_funs(any_lock, any_granularity)"];
+locking(suite) ->
+    [no_conflict, 
+     simple_queue_conflict, 
+     advanced_queue_conflict, 
+     simple_deadlock_conflict, 
+     advanced_deadlock_conflict,      
+     lock_burst, 
+     sticky_locks,
+     unbound_locking,
+     admin_conflict,
+%%     removed_resources,
+     nasty
+    ].
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+no_conflict(suite) -> [];
+no_conflict(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = no_conflict, 
+    create_conflict_table(Tab, [Node1]), 
+    Fun = fun(OtherOid, Lock1, Lock2) ->
+		  %% Start two transactions
+		  {success, [B, A]} = ?start_activities([Node1, Node1]), 
+		  ?start_transactions([B, A]), 
+		  
+		  A ! fun() -> Lock1(one_oid(Tab)),  ok end, 
+		  ?match_receive({A, ok}), 
+		  B ! fun() -> Lock2(OtherOid),  ok end, 
+		  ?match_receive({B, ok}), 
+		  A ! fun() -> mnesia:abort(ok) end, 
+		  ?match_receive({A, {aborted, ok}}), 
+		  B ! fun() -> mnesia:abort(ok) end, 
+		  ?match_receive({B, {aborted, ok}})
+	  end, 
+    NoLocks = lock_funs(no_lock, any_granularity), 
+    SharedLocks = lock_funs(shared_lock, any_granularity), 
+    AnyLocks = lock_funs(any_lock, any_granularity), 
+    OneOneFun = fun(Lock1, Lock2) -> Fun(one_oid(Tab), Lock1, Lock2) end, 
+    fun_loop(OneOneFun, NoLocks, AnyLocks), 
+    fun_loop(OneOneFun, AnyLocks, NoLocks), 
+    fun_loop(OneOneFun, SharedLocks, SharedLocks), 
+
+    %% Lock different objects
+    OneOtherFun = fun(Lock1, Lock2) -> Fun(other_oid(Tab), Lock1, Lock2) end, 
+    OneSharedLocks = lock_funs(shared_lock, one), 
+    OneExclusiveLocks = lock_funs(exclusive_lock, one), 
+    fun_loop(OneOtherFun, OneSharedLocks, OneExclusiveLocks), 
+    fun_loop(OneOtherFun, OneExclusiveLocks, OneSharedLocks), 
+    fun_loop(OneOtherFun, OneExclusiveLocks, OneExclusiveLocks), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+simple_queue_conflict(suite) -> [];
+simple_queue_conflict(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = simple_queue_conflict, 
+    create_conflict_table(Tab, [Node1]), 
+    Fun = fun(OneLock, OtherLock) ->
+		  %% Start two transactions
+		  {success, [B, A]} = ?start_activities([Node1, Node1]), 
+		  ?start_transactions([B, A]), 
+		  
+		  A ! fun() -> OneLock(one_oid(Tab)),  ok end, 
+		  ?match_receive({A, ok}), 
+		  B ! fun() -> OtherLock(one_oid(Tab)),  ok end, 
+		  wait_for_lock(B, [Node1], 20), % Max 10 sec
+		  A ! end_trans, 
+		  ?match_multi_receive([{A, {atomic, end_trans}}, {B, ok}]), 
+		  B ! fun() -> mnesia:abort(ok) end, 
+		  ?match_receive({B, {aborted, ok}})
+	  end, 
+    OneSharedLocks = lock_funs(shared_lock, one), 
+    AllSharedLocks = lock_funs(shared_lock, all), 
+    OneExclusiveLocks = lock_funs(exclusive_lock, one), 
+    AllExclusiveLocks = lock_funs(exclusive_lock, all), 
+    fun_loop(Fun, OneExclusiveLocks, OneExclusiveLocks), 
+    fun_loop(Fun, AllExclusiveLocks, AllExclusiveLocks), 
+    fun_loop(Fun, OneExclusiveLocks, AllExclusiveLocks), 
+    fun_loop(Fun, AllExclusiveLocks, OneExclusiveLocks), 
+    fun_loop(Fun, OneSharedLocks, AllExclusiveLocks), 
+    fun_loop(Fun, AllSharedLocks, OneExclusiveLocks), 
+    ok.
+
+wait_for_lock(Pid, _Nodes, 0) ->
+    Queue = mnesia:system_info(lock_queue),
+    ?error("Timeout while waiting for lock on Pid ~p in queue ~p~n", [Pid, Queue]);
+wait_for_lock(Pid, Nodes, N) ->
+    rpc:multicall(Nodes, sys, get_status, [mnesia_locker]), 
+    List = [rpc:call(Node, mnesia, system_info, [lock_queue]) || Node <- Nodes],
+    Q = lists:append(List),
+    check_q(Pid, Q, Nodes, N).
+
+check_q(Pid, [{_Oid, _Op, Pid, _Tid, _WFT} | _Tail], _N, _Count) -> ok;
+check_q(Pid, [_ | Tail], N, Count) -> check_q(Pid, Tail, N, Count);
+check_q(Pid, [], N, Count) ->
+    timer:sleep(500),
+    wait_for_lock(Pid, N, Count - 1).
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+advanced_queue_conflict(suite) -> [];
+advanced_queue_conflict(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = advanced_queue_conflict, 
+    create_conflict_table(Tab, [Node1]), 
+    OneRec = {Tab, 3, 3}, 
+    OneOid = {Tab, 3}, 
+    OtherRec = {Tab, 4, 4}, 
+    OtherOid = {Tab, 4}, 
+    
+    %% Start four transactions
+    {success, [D, C, B, A]} = ?start_activities(lists:duplicate(4, Node1)), 
+    ?start_transactions([D, C, B, A]), 
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+
+    %% Acquire some locks
+    A ! fun() -> mnesia:write(OneRec) end, 
+    ?match_receive({A, ok}), 
+    A ! fun() -> mnesia:read(OneOid) end, 
+    ?match_receive({A, [OneRec]}), 
+    
+    B ! fun() -> mnesia:write(OtherRec) end, 
+    ?match_receive({B, ok}), 
+    B ! fun() -> mnesia:read(OneOid) end, 
+    ?match_receive(timeout), 
+    
+    C ! fun() -> mnesia:read(OtherOid) end, 
+    ?match_receive(timeout), 
+    D ! fun() -> mnesia:wread(OtherOid) end, 
+    ?match_receive(timeout), 
+    
+    %% and release them in a certain order
+    A ! end_trans, 
+    ?match_multi_receive([{A, {atomic, end_trans}}, {B, [OneRec]}]), 
+    B ! end_trans, 
+    ?match_multi_receive([{B, {atomic, end_trans}}, {C, [OtherRec]}]), 
+    C ! end_trans, 
+    ?match_multi_receive([{C, {atomic, end_trans}}, {D, [OtherRec]}]), 
+    D ! end_trans, 
+    ?match_receive({D, {atomic, end_trans}}), 
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+simple_deadlock_conflict(suite) -> [];
+simple_deadlock_conflict(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = simple_deadlock_conflict, 
+    create_conflict_table(Tab, [Node1]), 
+    Rec = {Tab, 4, 4}, 
+    Oid = {Tab, 4}, 
+    
+    %% Start two transactions
+    {success, [B, A]} = ?start_activities(lists:duplicate(2, Node1)), 
+    mnesia_test_lib:start_transactions([B, A], 0),  % A is newest
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+
+    B ! fun() -> mnesia:write(Rec) end, 
+    ?match_receive({B, ok}), 
+    A ! fun() -> mnesia:read(Oid) end, 
+    ?match_receive({A, {aborted, nomore}}), 
+    B ! end_trans, 
+    ?match_receive({B, {atomic, end_trans}}), 
+
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+advanced_deadlock_conflict(suite) -> [];
+advanced_deadlock_conflict(Config) when is_list(Config) ->
+    [Node1, Node2] = ?acquire_nodes(2, Config), 
+    Tab = advanced_deadlock_conflict, 
+    create_conflict_table(Tab, [Node2]), 
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    Rec = {Tab, 4, 4}, 
+    Oid = {Tab, 4}, 
+    
+    %% Start two transactions
+    {success, [B, A]} = ?start_activities([Node1, Node2]), 
+    mnesia_test_lib:start_sync_transactions([B, A], 0),  % A is newest
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+
+    B ! fun() -> mnesia:write(Rec) end, 
+    ?match_receive({B, ok}), 
+    A ! fun() -> mnesia:read(Oid) end, 
+    ?match_receive({A, {aborted, nomore}}), 
+    B ! end_trans, 
+    ?match_receive({B, {atomic, end_trans}}), 
+
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+one_oid(Tab) -> {Tab, 1}.
+other_oid(Tab) -> {Tab, 2}.
+    
+create_conflict_table(Tab, Nodes) ->
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					     {ram_copies, Nodes}, 
+					     {attributes, [key, val]}, 
+					     {index, [val]}
+					    ])),
+    ?match([], mnesia_test_lib:sync_tables(Nodes, [Tab])),
+    init_conflict_table(Tab).
+
+init_conflict_table(Tab) ->
+    Recs = mnesia:dirty_match_object({Tab, '_', '_'}), 
+    lists:foreach(fun(R) -> mnesia:dirty_delete_object(R) end, Recs), 
+    Keys = [one_oid(Tab), other_oid(Tab)], 
+    [mnesia:dirty_write({T, K, K}) || {T, K} <- Keys].
+
+%% Apply Fun for each X and Y
+fun_loop(Fun, Xs, Ys) ->
+    lists:foreach(fun(X) -> lists:foreach(fun(Y) -> do_fun(Fun, X, Y) end, Ys) end, Xs).
+
+do_fun(Fun, X, Y) ->
+    Pid = spawn_link(?MODULE, do_fun, [self(), Fun, X, Y]), 
+    receive
+	{done_fun, Pid} -> done_fun
+    end.
+
+do_fun(Monitor, Fun, X, Y) ->
+    ?log("{do_fun ~p~n", [[Fun, X, Y]]), 
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    Fun(X, Y), 
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    unlink(Monitor), 
+    Monitor ! {done_fun, self()}, 
+    exit(done_fun).
+
+%% Returns a list of fun's
+lock_funs(no_lock, one) ->
+    [
+     fun(Oid) -> mnesia:dirty_read(Oid) end, 
+     fun({Tab, Key}) -> mnesia:dirty_write({Tab, Key, Key}) end, 
+     fun({Tab, Key}) -> mnesia:dirty_write({Tab, Key, Key}), 
+		       mnesia:dirty_update_counter({Tab, Key}, 0) end, 
+     fun(Oid) -> mnesia:dirty_delete(Oid) end, 
+     fun({Tab, Key}) -> mnesia:dirty_delete_object({Tab, Key, Key}) end, 
+     fun({Tab, Key}) -> mnesia:dirty_match_object({Tab, Key, Key}) end, 
+     fun({Tab, Key}) -> mnesia:dirty_index_match_object({Tab, Key, Key}, val) end, 
+     fun({Tab, Key}) -> mnesia:dirty_index_read(Tab, Key, val) end, 
+     fun({Tab, Key}) -> mnesia:dirty_index_match_object({Tab, '_', Key}, val) end
+    ];
+lock_funs(no_lock, all) ->
+    [
+     fun({Tab, _}) -> mnesia:dirty_match_object({Tab, '_', '_'}) end, 
+     fun({Tab, _}) -> slot_iter(Tab) end, 
+     fun({Tab, _}) -> key_iter(Tab) end
+    ];
+lock_funs(shared_lock, one) ->
+    
+    [
+     fun(Oid) -> mnesia:read(Oid) end, 
+     fun({Tab, Key}) ->
+	     init_conflict_table(Tab), 
+	     mnesia:dirty_delete(other_oid(Tab)), 
+	     mnesia:match_object({Tab, Key, Key}) end
+     ];
+lock_funs(shared_lock, all) ->
+    [
+     fun({Tab, _}) -> mnesia:read_lock_table(Tab) end, 
+     fun({Tab, Key}) -> mnesia:match_object({Tab, '_', Key}) end, 
+     fun({Tab, _}) -> mnesia:match_object({Tab, '_', '_'}) end, 
+     fun({Tab, _}) -> mnesia:all_keys(Tab) end, 
+     fun({Tab, Key}) -> mnesia:index_match_object({Tab, '_', Key}, val) end,
+     fun({Tab, Key}) -> mnesia:index_read(Tab, Key, val) end
+    ];
+lock_funs(exclusive_lock, one) ->
+    [
+     fun(Oid) -> mnesia:wread(Oid) end, 
+     fun({Tab, Key}) -> mnesia:write({Tab, Key, Key}) end, 
+     fun(Oid) -> mnesia:delete(Oid) end, 
+     fun({Tab, Key}) -> mnesia:delete_object({Tab, Key, Key}) end, 
+     fun({Tab, Key}) -> mnesia:s_write({Tab, Key, Key}) end, 
+     fun(Oid) -> mnesia:s_delete(Oid) end, 
+     fun({Tab, Key}) -> mnesia:s_delete_object({Tab, Key, Key}) end
+    ];
+lock_funs(exclusive_lock, all) ->
+    [
+     fun({Tab, _}) -> mnesia:write_lock_table(Tab) end
+    ];
+lock_funs(Compatibility, any_granularity) ->
+    lists:append([lock_funs(Compatibility, Granularity) ||
+		     Granularity <- [one, all]]);
+lock_funs(any_lock, Granularity) ->
+    lists:append([lock_funs(Compatibility, Granularity) ||
+		     Compatibility <- [no_lock, shared_lock, exclusive_lock]]).
+
+slot_iter(Tab) ->
+    slot_iter(Tab, mnesia:dirty_slot(Tab, 0), 1).
+slot_iter(_Tab, '$end_of_table', _) ->
+    [];
+slot_iter(Tab, Recs, Slot) ->
+    Recs ++ slot_iter(Tab, mnesia:dirty_slot(Tab, Slot), Slot+1).
+
+key_iter(Tab) ->
+    key_iter(Tab, mnesia:dirty_first(Tab)).
+key_iter(_Tab, '$end_of_table') ->
+    [];
+key_iter(Tab, Key) ->
+    [Key | key_iter(Tab, mnesia:dirty_next(Tab, Key))].
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+lock_burst(suite) -> [];
+lock_burst(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = burst, 
+    ?match({atomic, ok},  mnesia:create_table(Tab, 
+					    [{attributes,  [a, b]}, 
+					     {ram_copies, [Node1]}])), 
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ?match(ok, burst_em(Tab, 1000)), 
+    ?match([{burst,1,1000}], mnesia:dirty_read(Tab,1)),
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+burst_em(Tab, N) ->
+    spawn_link(?MODULE, burst_counter, [self(), Tab, N]), 
+    receive
+	burst_counter_done -> ok
+    end.
+
+burst_counter(Monitor, Tab, N) when N > 0 ->
+    ?match(ok, burst_gen(Tab, N, self())), 
+    Monitor ! burst_receiver(N).
+
+burst_receiver(0) ->
+    burst_counter_done;
+burst_receiver(N) ->
+    receive
+	burst_incr_done ->
+	    burst_receiver(N-1)
+    end.
+    
+burst_gen(_, 0, _) ->
+    ok;
+burst_gen(Tab, N, Father) when is_integer(N), N > 0 ->
+    spawn_link(?MODULE,  burst_incr,  [Tab, Father]), 
+    burst_gen(Tab, N-1, Father).
+
+burst_incr(Tab, Father) ->
+    Fun = fun() ->
+		  Val = 
+		      case mnesia:read({Tab, 1}) of
+			  [{Tab, 1, V}] -> V;
+			  [] -> 0
+		      end, 
+		  mnesia:write({Tab, 1, Val+1})
+	  end, 
+    ?match({atomic, ok}, mnesia:transaction(Fun)), 
+    Father ! burst_incr_done.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+sticky_locks(doc) ->
+    ["Simple Tests of sticky locks"];
+
+sticky_locks(suite) ->
+    [
+     basic_sticky_functionality
+     %% Needs to be expandand a little bit further
+    ].
+
+basic_sticky_functionality(suite) -> [];
+basic_sticky_functionality(Config) when is_list(Config) -> 
+    [N1, N2] = Nodes = ?acquire_nodes(2, Config),
+    Tab = basic_table,
+    Storage = mnesia_test_lib:storage_type(disc_copies, Config),
+    ?match({atomic, ok}, mnesia:create_table(Tab, [{Storage, Nodes}])),
+    ?match({atomic, ok}, mnesia:create_table(sync, [{ram_copies, Nodes}])),
+    Trans1 = fun() ->
+		     ?match(ok, mnesia:s_write({Tab, 1, 2})),
+		     ?match([{Tab, 1, 2}], mnesia:read({Tab, 1})),
+		     ?match(timeout, receive M -> M after 500 -> timeout end),
+		     ?match(ok, mnesia:s_write({Tab, 2, 2})),
+		     ?match(ok, mnesia:write({Tab, 42, 4711}))
+	     end,
+    Trans2 = fun() ->
+		     ?match([{Tab, 1, 2}],  mnesia:read({Tab, 1})),
+		     ?match(timeout, receive M -> M after 500 -> timeout end),
+		     ?match(ok, mnesia:write({Tab, 1, 4711})),
+		     ?match(ok, mnesia:s_write({Tab, 2, 4})),
+		     ?match(ok, mnesia:delete({Tab, 42}))
+	     end,
+    rpc:call(N1, mnesia, transaction, [Trans1]),
+    ?match([{Tab,N1}], rpc:call(N1, ?MODULE, get_sticky, [])),
+    ?match([{Tab,N1}], rpc:call(N2, ?MODULE, get_sticky, [])),
+
+    rpc:call(N2, mnesia, transaction, [Trans2]),
+    ?match([], rpc:call(N1, ?MODULE, get_sticky, [])),
+    ?match([], rpc:call(N2, ?MODULE, get_sticky, [])),
+    
+    Slock = fun() -> mnesia:read({sync,sync}),get_sticky() end,
+    ?match({atomic, [{Tab,1, 4711}]}, mnesia:transaction(fun() -> mnesia:read({Tab, 1}) end)),
+    ?match({atomic, [{Tab,2, 4}]},    mnesia:transaction(fun() -> mnesia:read({Tab, 2}) end)),
+    ?match({atomic, [{Tab,N1}]}, rpc:call(N1, mnesia, transaction, 
+					  [fun() -> mnesia:s_write({Tab, 1, 3}),Slock() end])),
+    ?match([{Tab,N1}], rpc:call(N2, ?MODULE, get_sticky, [])),
+    
+    ?match({atomic,[]}, rpc:call(N2, mnesia, transaction, 
+				 [fun() -> mnesia:s_write({Tab, 1, 4}),Slock()  end])),
+
+    ?match([], rpc:call(N1, ?MODULE, get_sticky, [])),
+    ?match([], rpc:call(N2, ?MODULE, get_sticky, [])),
+    
+    ?match({atomic,[{Tab,N2}]}, rpc:call(N2, mnesia, transaction, 
+					 [fun() -> mnesia:s_write({Tab, 1, 4}),Slock() end])),
+    
+    ?match({atomic,[]}, rpc:call(N1, mnesia, transaction, 
+				 [fun() -> mnesia:s_write({Tab, 1, 5}),Slock()  end])),
+    ?match({atomic,[{Tab,N1}]}, rpc:call(N1, mnesia, transaction, 
+					 [fun() -> mnesia:s_write({Tab, 1, 5}),Slock()  end])),
+    ?match({atomic,[]}, rpc:call(N2, mnesia, transaction, 
+				 [fun() -> mnesia:s_write({Tab, 1, 6}),Slock()  end])),
+    ?match({atomic,[{Tab,N2}]}, rpc:call(N2, mnesia, transaction, 
+					 [fun() -> mnesia:s_write({Tab, 1, 7}),Slock()  end])),
+    
+    ?match([{Tab,N2}], get_sticky()),
+    ?match({atomic, [{Tab,1, 7}]}, mnesia:transaction(fun() -> mnesia:read({Tab, 1}) end)),
+    ?match([{Tab,N2}], get_sticky()),
+    ?match({atomic, [{Tab,2, 4}]}, mnesia:transaction(fun() -> mnesia:read({Tab, 2}) end)),
+    ?match([{Tab,N2}], get_sticky()),
+    ?match({atomic,[{Tab,N2}]}, rpc:call(N2, mnesia, transaction, 
+					 [fun() -> mnesia:s_write({Tab, 1, 6}),Slock()  end])),
+    ?match([{Tab,N2}], get_sticky()),
+    ?match({atomic, [{Tab,1, 6}]}, mnesia:transaction(fun() -> mnesia:read({Tab, 1}) end)),
+    ?match([{Tab,N2}], get_sticky()),
+    ?match({atomic, [{Tab,2, 4}]}, mnesia:transaction(fun() -> mnesia:read({Tab, 2}) end)),
+    ?match([{Tab,N2}], get_sticky()),
+    ?verify_mnesia(Nodes, []).
+
+get_sticky() ->
+    mnesia_locker ! {get_table, self(), mnesia_sticky_locks},
+    receive {mnesia_sticky_locks, Locks} -> Locks end.
+
+get_held() ->
+    mnesia_locker ! {get_table, self(), mnesia_sticky_locks},
+    receive {mnesia_sticky_locks, Locks} -> Locks end.
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+unbound_locking(suite) ->
+    [unbound1, unbound2];
+
+unbound_locking(doc) ->
+    ["Check that mnesia handles unbound key variables, GPRS bug."
+     "Ticket id: OTP-3342"].
+
+unbound1(suite) -> [];
+unbound1(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config),
+    
+    ?match({atomic, ok}, mnesia:create_table(ul, [])),
+    
+    Tester = self(),
+    Write = fun() ->
+		    mnesia:write({ul, {key, {17,42}}, val}),
+		    ?log("~p Got write lock waiting...~n", [self()]),  
+		    Tester ! continue,
+		    receive 
+			continue ->
+			    ok
+		    end,
+		    ?log("..continuing~n", []),
+		    ok
+	    end,
+    
+    {success, [A]} = ?start_activities([Node1]),
+    ?start_transactions([A]),    
+    A ! Write,    
+    
+    receive continue -> ok end,
+
+    Match = fun() ->		    
+		    case catch mnesia:match_object({ul, {key, {'_', '$0'}}, '_'}) of
+			{'EXIT', What} ->  %% Cyclic first time
+			    ?log("Cyclic Restarting~n", []),
+			    A ! continue,
+			    A ! end_trans,
+			    exit(What);
+			Res ->
+			    ?log("Got match log ~p...~n", [Res]),
+			    Res
+		    end
+	    end,
+    ?match({atomic, [{ul,{key,{17,42}},val}]}, mnesia:transaction(Match)),
+
+    ?match_receive({A, ok}),
+    ?match_receive({A, {atomic, end_trans}}),
+    ok.
+
+unbound2(suite) -> [];
+unbound2(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config),
+    
+    ?match({atomic, ok}, mnesia:create_table(ul, [])),
+        
+    {success, [B, A]} = ?start_activities([Node1, Node1]),
+    
+    Me = self(),
+    
+    Write = fun() ->
+		    mnesia:write({ul, {key, {17,42}}, val}),
+		    ?log("~p Got write lock waiting... Tid ~p ~n", 
+			 [self(), get(mnesia_activity_state)]),  
+		    Me ! ok_lock,
+		    receive 
+			continue ->
+			    ok
+		    end,
+		    ?log("..continuing~n", []),
+		    ok
+	    end,
+    
+    Match = fun() ->  
+		    receive 
+			continueB -> 
+			    ?log("~p, moving on TID ~p~n", 
+				 [self(), get(mnesia_activity_state)]),
+			    Me ! {self(), continuing}
+		    end,
+		    case catch mnesia:match_object({ul, {key, {'_', '$0'}}, 
+						    '_'}) of
+			{'EXIT', What} ->  %% Cyclic first time
+			    ?log("Cyclic Restarting ~p ~n", [What]),
+			    {should_not_happen,What};
+			Res ->
+			    ?log("Got match log ~p...~n", [Res]),
+			    Res
+		    end
+	    end,
+
+    B ! fun() -> mnesia:transaction(Match) end,
+    timer:sleep(100),  %% Let B be started first..
+    A ! fun() -> mnesia:transaction(Write) end,    
+    
+    receive ok_lock -> ok end,
+
+    B ! continueB,
+    ?match_receive({B, continuing}),
+
+    %% B should now be in lock queue.
+    A ! continue,    
+    ?match_receive({A, {atomic, ok}}),    
+    ?match_receive({B, {atomic, [{ul,{key,{17,42}},val}]}}),
+    ok.
+    
+receiver() ->
+    receive 
+	{_Pid, begin_trans} ->
+	    receiver();
+	Else ->
+	    Else
+    after 
+	10000 ->
+	    timeout
+    end.   
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+admin_conflict(doc) ->
+    ["Provoke lock conflicts with schema transactions and checkpoints."];
+admin_conflict(suite) -> 
+    [
+     create_table,
+     delete_table,
+     move_table_copy,
+     add_table_index,
+     del_table_index,
+     transform_table,
+     snmp_open_table,
+     snmp_close_table,
+     change_table_copy_type,
+     change_table_access,
+     add_table_copy,
+     del_table_copy,
+     dump_tables,
+     extra_admin_tests
+    ].
+
+create_table(suite) -> [];
+create_table(Config) when is_list(Config) ->
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = c_t_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 1, updated}) end,
+    ?match_receive({A, ok}),   %% A is executed
+    
+    DiskMaybe = mnesia_test_lib:storage_type(disc_copies, Config),
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, create_table,
+				   [test_tab1, [{DiskMaybe, [ThisNode]}]]]),
+    ?match_multi_receive([{Pid, {atomic, ok}},
+			  {'EXIT', Pid, normal}]), %% No Locks! op should be exec.
+
+    Pid2 = spawn_link(?MODULE, op, [self(), mnesia, create_table,
+				   [test_tab2, [{ram_copies, [Node2]}]]]),
+
+    ?match_multi_receive([{Pid2, {atomic, ok}},
+			  {'EXIT', Pid2, normal}]), %% No Locks! op should be exec.
+
+    A ! end_trans,        
+    ?match_receive({A,{atomic,end_trans}}),
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+delete_table(suite) -> [];
+delete_table(Config) when is_list(Config) ->
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = d_t_tab,
+    Def = [{ram_copies, [ThisNode, Node2]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:read({Tab, 1}) end,
+    ?match_receive({A, [{Tab, 1, 1, 0}]}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, delete_table,
+				   [Tab]]),
+    
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+move_table_copy(suite) -> [];
+move_table_copy(Config) when is_list(Config) ->
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = m_t_c_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 2, 3}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, move_table_copy,
+				   [Tab, ThisNode, Node2]]),
+    
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    timer:sleep(500), %% Don't know how to sync this !!!
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    sys:get_status(whereis(mnesia_tm)),    % Explicit sync, release locks is async
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+add_table_index(suite) -> [];
+add_table_index(Config) when is_list(Config) ->
+    [ThisNode, _Node2] = ?acquire_nodes(2, Config ++ [{tc_timeout, 60000}]),
+    Tab = a_t_i_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 1, updated}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, 
+				   add_table_index, [Tab, attr1]]),
+
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+del_table_index(suite) -> [];
+del_table_index(Config) when is_list(Config) ->
+    [ThisNode, _Node2] = ?acquire_nodes(2, Config),
+    Tab = d_t_i_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    ?match({atomic, ok}, mnesia:add_table_index(Tab, attr1)),    
+
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 51, 51, attr2}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, del_table_index,
+				   [Tab, attr1]]),
+
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    %% Locks released! op should be exec.
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+transform_table(suite) -> [];
+transform_table(Config) when is_list(Config) -> 
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = t_t_tab,
+    Def = [{ram_copies, [ThisNode, Node2]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:read({Tab, 1}) end,
+    ?match_receive({A, [{Tab, 1, 1, 0}]}),   %% A is executed
+
+    Transform = fun({Table, Key, Attr1, Attr2}) -> % Need todo a transform
+			{Table, Key, {Attr1, Attr2}} end,    
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, transform_table,
+				   [Tab, Transform, [key, attr1]]]),
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+snmp_open_table(suite) -> [];
+snmp_open_table(Config) when is_list(Config) -> 
+    [ThisNode, _Node2] = ?acquire_nodes(2, Config),
+    Tab = s_o_t_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 1, 100}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, snmp_open_table,
+				   [Tab, [{key, integer}]]]),
+
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    %% Locks released! op should be exec. Can take a while (thats the timeout)
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+snmp_close_table(suite) -> [];
+snmp_close_table(Config) when is_list(Config) -> 
+    [ThisNode, _Node2] = ?acquire_nodes(2, Config),
+    Tab = s_c_t_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    ?match({atomic, ok}, mnesia:snmp_open_table(Tab, [{key, integer}])),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 1, 100}) end,
+    ?match_receive({A, ok}),   %% A is executed    
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, snmp_close_table, [Tab]]),   
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    %% Locks released! op should be exec. Can take a while (thats the timeout)
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+change_table_copy_type(suite) -> [];
+change_table_copy_type(Config) when is_list(Config) ->
+    [ThisNode, _Node2] = ?acquire_nodes(2, Config),
+    Tab = c_t_c_t_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+    A ! fun() -> mnesia:write({Tab, 1, 1, updated}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, change_table_copy_type, 
+				   [Tab, ThisNode, disc_copies]]),
+
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+change_table_access(suite) -> [];
+change_table_access(Config) when is_list(Config) -> 
+    [ThisNode, _Node2] = ?acquire_nodes(2, Config),
+    Tab = c_t_a_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 1, updated}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, change_table_access_mode,
+				   [Tab, read_only]]),
+
+    
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+add_table_copy(suite) -> [];
+add_table_copy(Config) when is_list(Config) -> 
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = a_t_c_tab,
+    Def = [{ram_copies, [ThisNode]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+
+    A ! fun() -> mnesia:write({Tab, 1, 1, updated}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, add_table_copy, 
+				   [Tab, Node2, ram_copies]]),
+   
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+del_table_copy(suite) -> [];
+del_table_copy(Config) when is_list(Config) -> 
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = d_t_c_tab,
+    Def = [{ram_copies, [ThisNode, Node2]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+    A ! fun() -> mnesia:write({Tab, 1, 2, 5}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, del_table_copy,
+				   [Tab, ThisNode]]),
+
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A, {atomic,end_trans}}),     
+
+    ?match_receive({Pid, {atomic, ok}}),
+    ?match_receive({'EXIT', Pid, normal}),
+
+    timer:sleep(500), %% Don't know how to sync this !!!
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    sys:get_status(whereis(mnesia_tm)),    % Explicit sync, release locks is async
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+dump_tables(suite) -> [];
+dump_tables(Config) when is_list(Config) -> 
+    [ThisNode, Node2] = ?acquire_nodes(2, Config),
+    Tab = dump_t_tab,
+    Def = [{ram_copies, [ThisNode, Node2]}, {attributes, [key, attr1, attr2]}],
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 50),
+    {success, [A]} = ?start_activities([ThisNode]), 
+    mnesia_test_lib:start_sync_transactions([A], 0),
+    A ! fun() -> mnesia:write({Tab, 1, 1, updated}) end,
+    ?match_receive({A, ok}),   %% A is executed
+
+    Pid = spawn_link(?MODULE, op, [self(), mnesia, dump_tables,
+				   [[Tab]]]),
+
+    ?match_receive(timeout),   %% op waits for locks occupied by A
+
+    A ! end_trans,             %% Kill A, locks should be released
+    ?match_receive({A,{atomic,end_trans}}),     
+    
+    receive 
+	Msg -> ?match({Pid, {atomic, ok}}, Msg)
+    after
+	timer:seconds(20) -> ?error("Operation timed out", [])
+    end,
+    
+    sys:get_status(whereis(mnesia_locker)), % Explicit sync, release locks is async
+    ?match([], mnesia:system_info(held_locks)), 
+    ?match([], mnesia:system_info(lock_queue)), 
+    ok.
+
+op(Father, Mod, Fun, Args) -> 
+    Res = apply(Mod, Fun, Args),
+    Father ! {self(), Res}.
+
+insert(_Tab, 0) -> ok;
+insert(Tab, N) when N > 0 ->
+    ok = mnesia:sync_dirty(fun() -> mnesia:write({Tab, N, N, 0}) end),
+    insert(Tab, N-1).
+
+extra_admin_tests(suite) -> 
+    [del_table_copy_1,
+     del_table_copy_2,
+     del_table_copy_3,
+     add_table_copy_1,
+     add_table_copy_2,
+     add_table_copy_3,
+     add_table_copy_4,
+     move_table_copy_1,
+     move_table_copy_2,
+     move_table_copy_3,
+     move_table_copy_4].
+
+update_own(Tab, Key, Acc) ->
+    Update = 
+	fun() -> 
+		Res = mnesia:read({Tab, Key}),
+		case Res of 
+		    [{Tab, Key, Extra, Acc}] ->
+			mnesia:write({Tab,Key,Extra, Acc+1});
+		    Val ->
+			{read, Val, {acc, Acc}}
+		end
+	end,
+    receive 
+	{Pid, quit} -> Pid ! {self(), Acc}
+    after
+	0 -> 
+	    case mnesia:transaction(Update) of
+		{atomic, ok} -> 	    
+		    update_own(Tab, Key, Acc+1);
+		Else -> 
+		    ?error("Trans failed on ~p with ~p~n"
+			   "Info w2read ~p w2write ~p w2commit ~p storage ~p ~n", 
+			   [node(), 
+			    Else,
+			    mnesia:table_info(Tab, where_to_read),
+			    mnesia:table_info(Tab, where_to_write),
+			    mnesia:table_info(Tab, where_to_commit),
+			    mnesia:table_info(Tab, storage_type)])
+	    end
+    end.
+
+update_shared(Tab, Me, Acc) ->
+    Update = 
+	fun() ->
+		W2R = mnesia:table_info(Tab, where_to_read),
+		Res = mnesia:read({Tab, 0}),
+		case Res of 
+		    [{Tab, Key, Extra, Val}] when element(Me, Extra) == Acc ->
+			Extra1 = setelement(Me, Extra, Acc+1),
+			Term = {Tab, Key, Extra1, Val+1},
+			ok = mnesia:write(Term),
+%			?log("At ~p: ~p w2r ~p w2w ~p ~n", 
+%			     [node(), Term, 
+%			      mnesia:table_info(Tab, where_to_read),
+			W2W = mnesia:table_info(Tab, where_to_write),
+			W2C = mnesia:table_info(Tab, where_to_commit),
+%%			      mnesia:table_info(Tab, storage_type)
+%			     ]),
+			{_Mod, Tid, Ts} = get(mnesia_activity_state),
+			io:format("~p ~p~n", [Tid, ets:tab2list(element(2,Ts))]),
+			{ok,Term,{W2R,W2W,W2C}};
+		    Val ->
+			Info = [{acc, Acc}, {me, Me}, 
+				{tid, element(2, mnesia:get_activity_id())},
+				{locks, mnesia:system_info(held_locks)}],
+			{read, Val, Info}
+		end
+	end,
+    receive 
+	{Pid, quit} -> Pid ! {self(), Acc}
+    after
+	0 -> 
+	    case mnesia:transaction(Update) of
+		{atomic, {ok,Term,W2}} ->
+		    io:format("~p:~p:(~p,~p) ~w@~w~n", [erlang:now(),node(),Me,Acc,Term,W2]),
+		    update_shared(Tab, Me, Acc+1);
+		Else -> 
+		    ?error("Trans failed on ~p with ~p~n"
+			   "Info w2read ~p w2write ~p w2commit ~p storage ~p ~n", 
+			   [node(), 
+			    Else,
+			    mnesia:table_info(Tab, where_to_read),
+			    mnesia:table_info(Tab, where_to_write),
+			    mnesia:table_info(Tab, where_to_commit),
+			    mnesia:table_info(Tab, storage_type)			   
+			   ])
+	    end
+    end.
+
+init_admin(Def, N1, N2, N3) ->
+    Tab = schema_ops,
+    ?match({atomic, ok}, mnesia:create_table(Tab, Def)),
+    insert(Tab, 1002),
+    
+    Pid1 = spawn_link(N1, ?MODULE, update_own, [Tab, 1, 0]),
+    Pid2 = spawn_link(N2, ?MODULE, update_own, [Tab, 2, 0]),
+    Pid3 = spawn_link(N3, ?MODULE, update_own, [Tab, 3, 0]),
+    
+    ?match({atomic, ok}, 
+	   mnesia:transaction(fun() -> mnesia:write({Tab, 0, {0,0,0}, 0}) end)),
+
+    Pid4 = spawn_link(N1, ?MODULE, update_shared, [Tab, 1, 0]),
+    Pid5 = spawn_link(N2, ?MODULE, update_shared, [Tab, 2, 0]),
+    Pid6 = spawn_link(N3, ?MODULE, update_shared, [Tab, 3, 0]),
+    
+    {Pid1, Pid2, Pid3, Pid4, Pid5, Pid6}.
+
+verify_results({P1, P2, P3, P4, P5, P6}) ->
+    Tab = schema_ops, N1 = node(P1),  N2 = node(P2),  N3 = node(P3),
+
+    try 
+	P1 ! {self(), quit}, 
+	R1 = receive {P1, Res1} -> Res1 after 9000 -> throw({timeout,P1}) end,
+	P2 ! {self(), quit}, 
+	R2 = receive {P2, Res2} -> Res2 after 9000 -> throw({timeout,P2}) end,
+	P3 ! {self(), quit}, 
+	R3 = receive {P3, Res3} -> Res3 after 9000 -> throw({timeout,P3}) end,
+
+	P4 ! {self(), quit}, 
+	R4 = receive {P4, Res4} -> Res4 after 9000 -> throw({timeout,P4}) end,
+	P5 ! {self(), quit}, 
+	R5 = receive {P5, Res5} -> Res5 after 9000 -> throw({timeout,P5}) end,
+	P6 ! {self(), quit}, 
+	R6 = receive {P6, Res6} -> Res6 after 9000 -> throw({timeout,P6}) end,
+
+	?match({atomic, ok}, mnesia:transaction(fun() -> mnesia:write_lock_table(Tab) end)),
+	?log("Should be ~p~n", [R1]),
+	?match([{_, _, _, R1}], rpc:call(N1, mnesia, dirty_read, [{Tab, 1}])),
+	?match([{_, _, _, R1}], rpc:call(N2, mnesia, dirty_read, [{Tab, 1}])),
+	?match([{_, _, _, R1}], rpc:call(N3, mnesia, dirty_read, [{Tab, 1}])),
+	?log("Should be ~p~n", [R2]),
+	?match([{_, _, _, R2}], rpc:call(N1, mnesia, dirty_read, [{Tab, 2}])),
+	?match([{_, _, _, R2}], rpc:call(N2, mnesia, dirty_read, [{Tab, 2}])),
+	?match([{_, _, _, R2}], rpc:call(N3, mnesia, dirty_read, [{Tab, 2}])),
+	?log("Should be ~p~n", [R3]),
+	?match([{_, _, _, R3}], rpc:call(N1, mnesia, dirty_read, [{Tab, 3}])),
+	?match([{_, _, _, R3}], rpc:call(N2, mnesia, dirty_read, [{Tab, 3}])),
+	?match([{_, _, _, R3}], rpc:call(N3, mnesia, dirty_read, [{Tab, 3}])),
+
+	Res = R4+R5+R6,
+	?log("Should be {~p+~p+~p}= ~p~n", [R4, R5, R6, Res]),
+	?match([{_, _, {R4,R5,R6}, Res}], rpc:call(N1, mnesia, dirty_read, [{Tab, 0}])),
+	?match([{_, _, {R4,R5,R6}, Res}], rpc:call(N2, mnesia, dirty_read, [{Tab, 0}])),
+	?match([{_, _, {R4,R5,R6}, Res}], rpc:call(N3, mnesia, dirty_read, [{Tab, 0}]))
+    catch throw:{timeout, Pid}  ->
+	    mnesia_lib:dist_coredump(),
+	    ?error("Timeout ~p ~n", [Pid])
+    end.
+    
+
+get_info(Tab) ->
+    Info = mnesia:table_info(Tab, all),
+    mnesia_lib:verbose("~p~n", [Info]).
+
+del_table_copy_1(suite) -> [];
+del_table_copy_1(Config) when is_list(Config) ->
+    [_Node1, Node2, _Node3] = Nodes = ?acquire_nodes(3, Config),
+    del_table(Node2, Node2, Nodes). %Called on same Node as deleted
+del_table_copy_2(suite) -> [];
+del_table_copy_2(Config) when is_list(Config) ->
+    [Node1, Node2, _Node3] = Nodes = ?acquire_nodes(3, Config),
+    del_table(Node1, Node2, Nodes). %Called from other Node 
+del_table_copy_3(suite) -> [];
+del_table_copy_3(Config) when is_list(Config) ->
+    [_Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    del_table(Node3, Node2, Nodes). %Called from Node w.o. table
+
+%%% The actual test
+del_table(CallFrom, DelNode, [Node1, Node2, Node3]) ->
+    Def = [{ram_copies, [Node1]}, {disc_copies, [Node2]}, 
+	   {attributes, [key, attr1, attr2]}],
+    Tab = schema_ops,
+    Pids = init_admin(Def, Node1, Node2, Node3),
+
+    ?log("Call from ~p delete table from ~p ~n", [CallFrom, DelNode]),
+    rpc:multicall([Node1, Node2, Node3], ?MODULE, get_info, [Tab]),
+    
+    ?match({atomic, ok}, 
+	   rpc:call(CallFrom, mnesia, del_table_copy, [Tab, DelNode])),
+
+    verify_results(Pids),
+    rpc:multicall([Node1, Node2, Node3], ?MODULE, get_info, [Tab]),
+    ?verify_mnesia([Node1, Node2, Node3], []).    
+
+add_table_copy_1(suite) -> [];
+add_table_copy_1(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_only_copies, [Node1, Node2]}, 
+	   {attributes, [key, attr1, attr2]}], 
+    add_table(Node1, Node3, Nodes, Def).
+add_table_copy_2(suite) -> [];
+add_table_copy_2(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_only_copies, [Node1, Node2]}, 
+	   {attributes, [key, attr1, attr2]}], 
+    add_table(Node2, Node3, Nodes, Def).
+add_table_copy_3(suite) -> [];
+add_table_copy_3(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_only_copies, [Node1, Node2]},
+	   {attributes, [key, attr1, attr2]}], 
+    add_table(Node3, Node3, Nodes, Def).
+add_table_copy_4(suite) -> [];
+add_table_copy_4(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_only_copies, [Node1]}, 
+	   {attributes, [key, attr1, attr2]}], 
+    add_table(Node2, Node3, Nodes, Def).
+%%% The actual test
+add_table(CallFrom, AddNode, [Node1, Node2, Node3], Def) ->
+    Pids = init_admin(Def, Node1, Node2, Node3),    
+    Tab = schema_ops,
+    ?log("Call from ~p add table to ~p ~n", [CallFrom, AddNode]),
+    rpc:multicall([Node1, Node2, Node3], ?MODULE, get_info, [Tab]),
+    ?match({atomic, ok}, rpc:call(CallFrom, mnesia, add_table_copy, 
+				  [Tab, AddNode, ram_copies])),
+    verify_results(Pids),
+    rpc:multicall([Node1, Node2, Node3], ?MODULE, get_info, [Tab]),
+    ?verify_mnesia([Node1, Node2, Node3], []).
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+move_table_copy_1(suite) -> [];
+move_table_copy_1(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_copies, [Node1, Node2]},
+	   {attributes, [key, attr1, attr2]}], 
+    move_table(Node1, Node1, Node3, Nodes, Def).
+move_table_copy_2(suite) -> [];
+move_table_copy_2(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_copies, [Node1, Node2]},
+	   {attributes, [key, attr1, attr2]}], 
+    move_table(Node2, Node1, Node3, Nodes, Def).
+move_table_copy_3(suite) -> [];
+move_table_copy_3(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_copies, [Node1, Node2]},
+	   {attributes, [key, attr1, attr2]}], 
+    move_table(Node3, Node1, Node3, Nodes, Def).
+move_table_copy_4(suite) -> [];
+move_table_copy_4(Config) when is_list(Config) ->
+    [Node1, Node2, Node3] = Nodes = ?acquire_nodes(3, Config),
+    Def = [{disc_copies, [Node1]},
+	   {attributes, [key, attr1, attr2]}], 
+    move_table(Node2, Node1, Node3, Nodes, Def).
+%%% The actual test
+move_table(CallFrom, FromNode, ToNode, [Node1, Node2, Node3], Def) ->
+    Pids = init_admin(Def, Node1, Node2, Node3),    
+    Tab = schema_ops,   
+    ?log("Call from ~p move table from ~p to ~p ~n", [CallFrom, FromNode, ToNode]),
+    rpc:multicall([Node1, Node2, Node3], ?MODULE, get_info, [Tab]),
+    ?match({atomic, ok}, rpc:call(CallFrom, mnesia, move_table_copy, 
+				  [Tab, FromNode, ToNode])),
+    verify_results(Pids),
+    rpc:multicall([Node1, Node2, Node3], ?MODULE, get_info, [Tab]),
+    ?verify_mnesia([Node1, Node2, Node3], []).
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+visibility(doc) ->
+    ["Verify the visibility semantics for various configurations"];
+visibility(suite) ->
+    [
+     dirty_updates_visible_direct, 
+     dirty_reads_regardless_of_trans, 
+     trans_update_invisibible_outside_trans, 
+     trans_update_visible_inside_trans, 
+     write_shadows, 
+     delete_shadows, 
+%%     delete_shadows2,
+     write_delete_shadows_bag,
+     write_delete_shadows_bag2,
+     iteration,
+     shadow_search,
+     snmp_shadows
+    ].
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+dirty_updates_visible_direct(doc) ->
+    ["One process can immediately see dirty updates of another"];
+dirty_updates_visible_direct(suite) -> [];
+dirty_updates_visible_direct(Config) when is_list(Config) ->
+    dirty_visibility(outside_trans, Config).
+
+dirty_reads_regardless_of_trans(doc) ->
+    ["Dirty reads are not affected by transaction context"];
+dirty_reads_regardless_of_trans(suite) -> [];
+dirty_reads_regardless_of_trans(Config) when is_list(Config) ->
+    dirty_visibility(inside_trans, Config).
+
+dirty_visibility(Mode, Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = list_to_atom(lists:concat([dirty_visibility, '_', Mode])), 
+
+   ?match({atomic, ok},  mnesia:create_table([{name, Tab}, {ram_copies, [Node1]}])), 
+    ValPos = 3, 
+
+    ?match({atomic, ok},  mnesia:add_table_index(Tab, ValPos)), 
+    
+    %% Start two processes
+    {success, [A]} = ?start_activities([Node1]), 
+
+    case Mode of
+	inside_trans ->
+	    ?start_transactions([A]), 
+	    A ! fun() ->
+			mnesia:write({Tab, a, 11}), 
+			mnesia:write({Tab, b, 22}), 
+			mnesia:write({Tab, c, 1}), 
+			mnesia:write({Tab, d, 2}), 
+			mnesia:write({Tab, e, 3}), 
+			lists:sort(mnesia:all_keys(Tab))
+		end, 
+	    ?match_receive({A, [a, b, c, d, e]});
+	outside_trans ->
+	    ignore
+    end, 
+
+    RecA = {Tab, a, 1}, 
+    PatA = {Tab, '$1', 1}, 
+    RecB = {Tab, b, 3}, 
+    PatB = {Tab, '$1', 3}, 
+    RecB2 = {Tab, b, 2}, 
+    PatB2 = {Tab, '$1', 2}, 
+    ?match([], mnesia:dirty_read({Tab, a})), 
+    ?match([], mnesia:dirty_read({Tab, b})), 
+    ?match([], mnesia:dirty_match_object(PatA)), 
+    ?match([], mnesia:dirty_match_object(PatB)), 
+    ?match([], mnesia:dirty_match_object(PatB2)), 
+    ?match([], mnesia:dirty_index_read(Tab, 1, ValPos)), 
+    ?match([], mnesia:dirty_index_read(Tab, 3, ValPos)), 
+    ?match([], mnesia:dirty_index_match_object(PatA, ValPos)), 
+    ?match([], mnesia:dirty_index_match_object(PatB, ValPos)), 
+    ?match([], mnesia:dirty_index_match_object(PatB2, ValPos)), 
+    ?match('$end_of_table', mnesia:dirty_first(Tab)), 
+
+    %% dirty_write
+    A ! fun() -> mnesia:dirty_write(RecA) end, 
+    ?match_receive({A, ok}), 
+    ?match([RecA], mnesia:dirty_read({Tab, a})), 
+    ?match([RecA], mnesia:dirty_match_object(PatA)), 
+    ?match(a, mnesia:dirty_first(Tab)), 
+    ?match([RecA], mnesia:dirty_index_read(Tab, 1, ValPos)), 
+    ?match([RecA], mnesia:dirty_index_match_object(PatA, ValPos)), 
+    ?match('$end_of_table', mnesia:dirty_next(Tab, a)), 
+
+    %% dirty_create
+    A ! fun() -> mnesia:dirty_write(RecB) end, 
+    ?match_receive({A, ok}), 
+    ?match([RecB], mnesia:dirty_read({Tab, b})), 
+    ?match([RecB], mnesia:dirty_match_object(PatB)), 
+    ?match([RecB], mnesia:dirty_index_read(Tab, 3, ValPos)), 
+    ?match([RecB], mnesia:dirty_index_match_object(PatB, ValPos)), 
+    ?match('$end_of_table', 
+	   mnesia:dirty_next(Tab, mnesia:dirty_next(Tab, mnesia:dirty_first(Tab)))), 
+    
+    %% dirty_update_counter
+    A ! fun() -> mnesia:dirty_update_counter({Tab, b}, -1) end, 
+    ?match_receive({A, _}), 
+    ?match([RecB2], mnesia:dirty_read({Tab, b})), 
+    ?match([], mnesia:dirty_match_object(PatB)), 
+    ?match([RecB2], mnesia:dirty_match_object(PatB2)), 
+    ?match([RecB2], mnesia:dirty_index_read(Tab, 2, ValPos)), 
+    ?match([], mnesia:dirty_index_match_object(PatB, ValPos)), 
+    ?match([RecB2], mnesia:dirty_index_match_object(PatB2, ValPos)), 
+    ?match('$end_of_table', 
+	   mnesia:dirty_next(Tab, mnesia:dirty_next(Tab, mnesia:dirty_first(Tab)))), 
+
+    %% dirty_delete
+    A ! fun() -> mnesia:dirty_delete({Tab, b}) end, 
+    ?match_receive({A, ok}), 
+    ?match([], mnesia:dirty_read({Tab, b})), 
+    ?match([], mnesia:dirty_match_object(PatB2)), 
+    ?match([], mnesia:dirty_index_read(Tab, 3, ValPos)), 
+    ?match([], mnesia:dirty_index_match_object(PatB2, ValPos)), 
+    ?match(a, mnesia:dirty_first(Tab)), 
+    ?match('$end_of_table', mnesia:dirty_next(Tab, a)), 
+
+    %% dirty_delete_object
+    ?match([RecA], mnesia:dirty_match_object(PatA)), 
+    A ! fun() -> mnesia:dirty_delete_object(RecA) end, 
+    ?match_receive({A, ok}), 
+    ?match([], mnesia:dirty_read({Tab, a})), 
+    ?match([], mnesia:dirty_match_object(PatA)), 
+    ?match([], mnesia:dirty_index_read(Tab, 1, ValPos)), 
+    ?match([], mnesia:dirty_index_match_object(PatA, ValPos)), 
+    ?match('$end_of_table', mnesia:dirty_first(Tab)), 
+    
+    case Mode of
+	inside_trans ->
+	    A ! end_trans, 
+	    ?match_receive({A, {atomic, end_trans}});
+	outside_trans ->
+	    ignore
+    end, 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+trans_update_invisibible_outside_trans(doc) ->
+    ["Updates in a transaction are invisible outside the transaction"];
+trans_update_invisibible_outside_trans(suite) -> [];
+trans_update_invisibible_outside_trans(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = trans_update_invisibible_outside_trans, 
+
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					     {ram_copies, [Node1]}])), 
+    ValPos = 3, 
+    RecA = {Tab, a, 1}, 
+    PatA = {Tab, '$1', 1}, 
+    RecB = {Tab, b, 3}, 
+    PatB = {Tab, '$1', 3}, 
+    ?match({atomic, ok},  mnesia:add_table_index(Tab, ValPos)), 
+
+    Verify =
+	fun() ->
+		?match([], mnesia:dirty_read({Tab, a})), 
+		?match([], mnesia:dirty_read({Tab, b})), 
+		?match([], mnesia:dirty_match_object(PatA)), 
+		?match([], mnesia:dirty_match_object(PatB)), 
+		?match([], mnesia:dirty_index_read(Tab, 1, ValPos)), 
+		?match([], mnesia:dirty_index_read(Tab, 3, ValPos)), 
+		?match([], mnesia:dirty_index_match_object(PatA, ValPos)), 
+		?match([], mnesia:dirty_index_match_object(PatB, ValPos)), 
+		?match('$end_of_table', mnesia:dirty_first(Tab))
+	     end, 
+
+    Fun = fun() ->
+		  ?match(ok, mnesia:write(RecA)), 
+		  Verify(), 
+
+		  ?match(ok, mnesia:write(RecB)), 
+		  Verify(), 
+
+		  ?match(ok, mnesia:delete({Tab, b})), 
+		  Verify(), 
+		  
+		  ?match([RecA], mnesia:match_object(PatA)), 
+		  Verify(), 
+
+		  ?match(ok, mnesia:delete_object(RecA)), 
+		  Verify(), 
+		  ok
+	  end, 
+    ?match({atomic, ok}, mnesia:transaction(Fun)), 
+    Verify(), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+trans_update_visible_inside_trans(doc) ->
+    ["Updates in a transaction are visible in the same transaction"];
+trans_update_visible_inside_trans(suite) -> [];
+trans_update_visible_inside_trans(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = trans_update_visible_inside_trans, 
+
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					     {ram_copies, [Node1]}])), 
+    ValPos = 3, 
+    RecA = {Tab, a, 1}, 
+    PatA = {Tab, '$1', 1}, 
+    RecB = {Tab, b, 3}, 
+    PatB = {Tab, '$1', 3}, 
+    ?match({atomic, ok},  mnesia:add_table_index(Tab, ValPos)), 
+
+    Fun = fun() ->
+		  %% write
+		  ?match(ok, mnesia:write(RecA)), 
+		  ?match([RecA], mnesia:read({Tab, a})), 
+		  ?match([RecA], mnesia:wread({Tab, a})), 
+		  ?match([RecA], mnesia:match_object(PatA)), 
+		  ?match([a], mnesia:all_keys(Tab)), 
+		  ?match([RecA], mnesia:index_match_object(PatA, ValPos)), 
+		  ?match([RecA], mnesia:index_read(Tab, 1, ValPos)), 
+
+		  %% create
+		  ?match(ok, mnesia:write(RecB)), 
+		  ?match([RecB], mnesia:read({Tab, b})), 
+		  ?match([RecB], mnesia:wread({Tab, b})), 
+		  ?match([RecB], mnesia:match_object(PatB)), 
+		  ?match([RecB], mnesia:index_match_object(PatB, ValPos)), 
+		  ?match([RecB], mnesia:index_read(Tab, 3, ValPos)), 
+		  
+		  %% delete
+		  ?match(ok, mnesia:delete({Tab, b})), 
+		  ?match([], mnesia:read({Tab, b})), 
+		  ?match([], mnesia:wread({Tab, b})), 
+		  ?match([], mnesia:match_object(PatB)), 
+		  ?match([a], mnesia:all_keys(Tab)), 
+		  ?match([], mnesia:index_match_object(PatB, ValPos)), 
+		  ?match([], mnesia:index_read(Tab, 2, ValPos)), 
+		  ?match([], mnesia:index_read(Tab, 3, ValPos)), 
+
+		  %% delete_object
+		  ?match(ok, mnesia:delete_object(RecA)), 
+		  ?match([], mnesia:read({Tab, a})), 
+		  ?match([], mnesia:wread({Tab, a})), 
+		  ?match([], mnesia:match_object(PatA)), 
+		  ?match([], mnesia:all_keys(Tab)), 
+		  ?match([], mnesia:index_match_object(PatA, ValPos)), 
+		  ?match([], mnesia:index_read(Tab, 2, ValPos)), 
+		  ?match([], mnesia:index_read(Tab, 3, ValPos)), 
+		  ok
+	  end, 
+    ?match({atomic, ok}, mnesia:transaction(Fun)), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+write_shadows(doc) ->
+    ["Tests whether the shadow shows the correct object when",
+     "writing to the table"];
+write_shadows(suite) -> [];
+write_shadows(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = write_shadows, 
+
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					     {ram_copies, [Node1]}, 
+					     {type,  set}])), 
+    ValPos = 3, 
+    RecA1 = {Tab, a, 1}, 
+    PatA1 = {Tab, '$1', 1}, 
+    RecA2 = {Tab, a, 2}, 
+    PatA2 = {Tab, '$1', 2}, 
+
+
+    ?match({atomic, ok},  mnesia:add_table_index(Tab, ValPos)), 
+       
+    Fun1 = fun() ->
+		   ?match(ok, mnesia:write(RecA1)), 
+		   ok
+	   end, 
+
+    ?match({atomic, ok}, mnesia:transaction(Fun1)), 
+
+    Fun2 = fun() ->
+		  %% write shadow old write - is the confirmed value visable
+		  %%                          in the shadow ?
+		  ?match([RecA1], mnesia:read({Tab, a})), 
+		  ?match([RecA1], mnesia:wread({Tab, a})), 
+		  ?match([RecA1], mnesia:match_object(PatA1)), 
+		  ?match([a], mnesia:all_keys(Tab)), 
+		  ?match([RecA1], mnesia:index_match_object(PatA1, ValPos)), 
+		  ?match([RecA1], mnesia:index_read(Tab, 1, ValPos)), 
+
+		  %% write shadow new write - is a new value visable instead
+		  %%                          of the old value ?
+		  ?match(ok, mnesia:write(RecA2)), 
+
+		  ?match([RecA2], mnesia:read({Tab, a})), 
+		  ?match([RecA2], mnesia:wread({Tab, a})), 
+		  ?match([RecA2], mnesia:match_object(PatA2)), 		  %% delete shadow old but not new write - is the new value visable
+
+		  ?match([a], mnesia:all_keys(Tab)), 
+		  ?match([RecA2], mnesia:index_match_object(PatA2, ValPos)), 
+		  ?match([RecA2], mnesia:index_read(Tab, 2, ValPos)), 
+		  ok
+
+	  end, 
+    ?match({atomic, ok}, mnesia:transaction(Fun2)), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+delete_shadows(doc) ->
+    ["Test whether the shadow shows the correct object when deleting objects"];
+delete_shadows(suite) -> [];
+delete_shadows(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = delete_shadows, 
+
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					     {ram_copies, [Node1]}, 
+					     {type,  set}])), 
+    ValPos = 3, 
+    OidA  = {Tab, a}, 
+    RecA1 = {Tab, a, 1}, 
+    PatA1 = {Tab, '$1', 1}, 
+    RecA2 = {Tab, a, 2}, 
+    PatA2 = {Tab, '$1', 2}, 
+
+
+    ?match({atomic, ok},  mnesia:add_table_index(Tab, ValPos)), 
+       
+    Fun1 = fun() ->
+		   ?match(ok, mnesia:write(RecA1)), 
+		   ok
+	   end, 
+
+    ?match({atomic, ok}, mnesia:transaction(Fun1)), 
+
+    Fun2 = fun() ->
+		   
+		   
+		  %% delete shadow old write - is the confirmed value invisible
+		  %%                           when deleted in the transaction ?
+		  ?match(ok, mnesia:delete(OidA)), 
+
+		  ?match([], mnesia:read({Tab, a})), 
+		  ?match([], mnesia:wread({Tab, a})), 
+		  ?match([], mnesia:match_object(PatA1)), 
+		  ?match([], mnesia:all_keys(Tab)), 
+		  ?match([], mnesia:index_match_object(PatA1, ValPos)), 
+		  ?match([], mnesia:index_read(Tab, 1, ValPos)), 
+
+		  %% delete shadow old but not new write - is the new value visable
+		  %%                           when the old one was deleted ?
+		  ?match(ok, mnesia:write(RecA2)), 
+
+		  ?match([RecA2], mnesia:read({Tab, a})), 
+		  ?match([RecA2], mnesia:wread({Tab, a})), 
+		  ?match([RecA2], mnesia:match_object(PatA2)), 
+		  ?match([a], mnesia:all_keys(Tab)), 
+		  ?match([RecA2], mnesia:index_match_object(PatA2, ValPos)), 
+		  ?match([RecA2], mnesia:index_read(Tab, 2, ValPos)), 
+	
+		   %% delete shadow old and new write - is the new value invisable
+		  %%                           when deleted ?
+		  ?match(ok, mnesia:delete(OidA)), 
+
+		  ?match([], mnesia:read({Tab, a})), 
+		  ?match([], mnesia:wread({Tab, a})), 
+		  ?match([], mnesia:match_object(PatA2)), 
+		  ?match([], mnesia:all_keys(Tab)), 
+		  ?match([], mnesia:index_match_object(PatA2, ValPos)), 
+		  ?match([], mnesia:index_read(Tab, 2, ValPos)), 
+		  ok
+
+	  end, 
+    ?match({atomic, ok}, mnesia:transaction(Fun2)), 
+    ok.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+write_delete_shadows_bag(doc) ->
+    ["Test the visibility of written and deleted objects in an bag type table"];
+write_delete_shadows_bag(suite) -> [];
+write_delete_shadows_bag(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = write_delete_shadows_bag, 
+
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					       {ram_copies, [Node1]}, 
+					       {type,  bag}])), 
+    ValPos = 3, 
+    OidA  = {Tab, a}, 
+
+    RecA1 = {Tab, a, 1}, 
+    PatA1 = {Tab, '$1', 1}, 
+
+    RecA2 = {Tab, a, 2}, 
+    PatA2 = {Tab, '$1', 2}, 
+
+    RecA3 = {Tab, a, 3}, 
+    PatA3 = {Tab, '$1', 3}, 
+
+    PatA  = {Tab, a, '_'}, 
+
+
+    ?match({atomic, ok},  mnesia:add_table_index(Tab, ValPos)), 
+
+    Fun1 = fun() ->
+		   ?match(ok, mnesia:write(RecA1)), 
+		   ?match(ok, mnesia:write(RecA2)), 
+		   ok
+	   end, 
+
+    ?match({atomic, ok}, mnesia:transaction(Fun1)), 
+
+    Fun2 = fun() ->		   		   
+		   %% delete shadow old write - is the confirmed value invisible
+		   %%                           when deleted in the transaction ?
+		   ?match(ok, mnesia:delete_object(RecA1)), 
+
+		   ?match([RecA2], mnesia:read({Tab, a})), 
+		   ?match([RecA2], mnesia:wread({Tab, a})), 
+		   ?match([RecA2], mnesia:match_object(PatA2)), 
+		   ?match([a], mnesia:all_keys(Tab)), 
+		   ?match([RecA2], mnesia:index_match_object(PatA2, ValPos)), 
+		   ?match([RecA2], mnesia:index_read(Tab, 2, ValPos)), 
+
+		   ?match(ok, mnesia:delete(OidA)), 
+
+		   ?match([], mnesia:read({Tab, a})), 
+		   ?match([], mnesia:wread({Tab, a})), 
+		   ?match([], mnesia:match_object(PatA1)), 
+		   ?match([], mnesia:all_keys(Tab)), 
+		   ?match([], mnesia:index_match_object(PatA1, ValPos)), 
+		   ?match([], mnesia:index_read(Tab, 1, ValPos)), 
+
+		   %% delete shadow old but not new write - are both new value visable
+		   %%                           when the old one was deleted ?
+		   ?match(ok, mnesia:write(RecA2)), 
+		   ?match(ok, mnesia:write(RecA3)), 
+
+
+		   ?match([RecA2, RecA3], lists:sort(mnesia:read({Tab, a}))), 
+		   ?match([RecA2, RecA3], lists:sort(mnesia:wread({Tab, a}))), 
+		   ?match([RecA2], mnesia:match_object(PatA2)), 
+		   ?match([a], mnesia:all_keys(Tab)), 
+		   ?match([RecA2, RecA3], lists:sort(mnesia:match_object(PatA))),
+		   ?match([RecA2], mnesia:index_match_object(PatA2, ValPos)),
+		   ?match([RecA3], mnesia:index_match_object(PatA3, ValPos)),
+		   ?match([RecA2], mnesia:index_read(Tab, 2, ValPos)), 
+
+		   %% delete shadow old and new write - is the new value invisable
+		   %%                           when deleted ?
+		   ?match(ok, mnesia:delete(OidA)), 
+
+		   ?match([], mnesia:read({Tab, a})), 
+		   ?match([], mnesia:wread({Tab, a})), 
+		   ?match([], mnesia:match_object(PatA2)), 
+		   ?match([], mnesia:all_keys(Tab)), 
+		   ?match([], mnesia:index_match_object(PatA2, ValPos)), 
+		   ?match([], mnesia:index_read(Tab, 2, ValPos)), 
+		   ok
+	   end, 
+    ?match({atomic, ok}, mnesia:transaction(Fun2)), 
+    ok.
+
+write_delete_shadows_bag2(doc) ->
+    ["Test the visibility of written and deleted objects in an bag type table " 
+     "and verifies the results"];
+write_delete_shadows_bag2(suite) -> [];
+write_delete_shadows_bag2(Config) when is_list(Config) ->
+
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab = w_d_s_b, 
+
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab}, 
+					       {ram_copies, [Node1]}, 
+					       {type,  bag}])),     
+    Del = fun() ->
+		  R1 = mnesia:read({Tab, 1}),
+		  mnesia:delete({Tab, 1}),
+		  R2 = mnesia:read({Tab, 1}),
+		  mnesia:write({Tab, 1, 1}),
+		  mnesia:write({Tab, 1, 2}),
+		  R3 = mnesia:read({Tab, 1}),
+		  {R1, R2, R3}
+	  end,
+    DelObj = fun() ->
+		     R1 = mnesia:read({Tab, 2}),
+		     mnesia:delete_object({Tab, 2, 2}),
+		     R2 = mnesia:read({Tab, 2}),
+		     mnesia:write({Tab, 2, 1}),
+		     mnesia:write({Tab, 2, 2}),
+		     R3 = mnesia:read({Tab, 2}),
+		     {R1, R2, R3}
+	     end,
+    Both1 = [{Tab, 1, 1}, {Tab, 1, 2}],   
+    Both2 = [{Tab, 2, 1}, {Tab, 2, 2}],   
+    ?match({atomic, {[], [], Both1}}, mnesia:transaction(Del)),
+    ?match({atomic, {Both1, [], Both1}}, mnesia:transaction(Del)),
+    ?match({atomic, Both1}, mnesia:transaction(fun() -> mnesia:read({Tab, 1}) end)),
+    ?match({atomic, {[], [], Both2}}, mnesia:transaction(DelObj)),
+    ?match({atomic, {Both2, [{Tab, 2, 1}], Both2}}, mnesia:transaction(DelObj)),
+    ?match({atomic, Both2}, mnesia:transaction(fun() -> mnesia:read({Tab, 2}) end)),
+    ?verify_mnesia([Node1], []).
+
+shadow_search(doc) ->
+    ["Verifies that ordered_set tables are ordered, and the order is kept" 
+     "even when table is shadowed by transaction updates"];
+shadow_search(suite) -> [];
+shadow_search(Config) when is_list(Config) ->
+    [Node1] = ?acquire_nodes(1, Config), 
+    Tab1  = ss_oset,
+    Tab2 = ss_set,
+    Tab3 = ss_bag,
+    Tabs = [Tab1,Tab2,Tab3],
+    RecName = ss,
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab1}, 
+					       {ram_copies, [Node1]}, 
+					       {record_name, RecName},
+					       {type,  ordered_set}])),
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab2},
+					       {record_name, RecName},
+					       {ram_copies, [Node1]},
+					       {type,  set}])),
+    ?match({atomic, ok},  mnesia:create_table([{name, Tab3},
+					       {record_name, RecName},
+					       {ram_copies, [Node1]}, 
+					       {type,  bag}])),
+    Recs = [{RecName, K, K} || K <- [1,3,5]],
+    [mnesia:dirty_write(Tab1, R) || R <- Recs],
+    [mnesia:dirty_write(Tab2, R) || R <- Recs],
+    [mnesia:dirty_write(Tab3, R) || R <- Recs],
+    
+    Match  = fun(Tab) -> mnesia:match_object(Tab, {'_','_','_'}, write) end,
+    Select = fun(Tab) -> mnesia:select(Tab, [{'_', [], ['$_']}]) end,
+%    Trans = fun(Fun,Args) -> mnesia:transaction(Fun,Args) end,
+    LoopHelp = fun('$end_of_table',_) -> [];
+		  ({Res,Cont},Fun) -> 
+		       Sel = mnesia:select(Cont),
+		       Res ++ Fun(Sel, Fun)
+	       end,
+    SelLoop = fun(Table) -> 
+		      Sel = mnesia:select(Table, [{'_', [], ['$_']}], 1, read),
+		      LoopHelp(Sel,LoopHelp)
+	      end,
+    
+    R1 = {RecName, 2, 2}, R2 = {RecName, 4, 4},
+    R3 = {RecName, 2, 3}, R4 = {RecName, 3, 1},
+    R5 = {RecName, 104, 104},
+    W1 = fun(Tab,Search) -> mnesia:write(Tab,R1,write),
+			    mnesia:write(Tab,R2,write), 
+			    Search(Tab)
+	 end,
+    S1 = lists:sort([R1,R2|Recs]),
+    ?match({atomic,S1}, mnesia:transaction(W1, [Tab1,Select])),
+    ?match({atomic,S1}, mnesia:transaction(W1, [Tab1,Match])),
+    ?match({atomic,S1}, mnesia:transaction(W1, [Tab1,SelLoop])),
+    ?match({atomic,S1}, sort_res(mnesia:transaction(W1, [Tab2,Select]))),
+    ?match({atomic,S1}, sort_res(mnesia:transaction(W1, [Tab2,SelLoop]))),
+    ?match({atomic,S1}, sort_res(mnesia:transaction(W1, [Tab2,Match]))),
+    ?match({atomic,S1}, sort_res(mnesia:transaction(W1, [Tab3,Select]))),
+    ?match({atomic,S1}, sort_res(mnesia:transaction(W1, [Tab3,SelLoop]))),
+    ?match({atomic,S1}, sort_res(mnesia:transaction(W1, [Tab3,Match]))),
+    [mnesia:dirty_delete_object(Tab,R) || R <- [R1,R2], Tab <- Tabs],
+
+    W2 = fun(Tab,Search) -> 
+		 mnesia:write(Tab,R3,write),
+		 mnesia:write(Tab,R1,write), 
+		 Search(Tab)
+	 end,
+    S2 = lists:sort([R1|Recs]),
+    S2Bag = lists:sort([R1,R3|Recs]),
+    ?match({atomic,S2}, mnesia:transaction(W2, [Tab1,Select])),
+    ?match({atomic,S2}, mnesia:transaction(W2, [Tab1,SelLoop])),
+    ?match({atomic,S2}, mnesia:transaction(W2, [Tab1,Match])),
+    ?match({atomic,S2}, sort_res(mnesia:transaction(W2, [Tab2,Select]))),
+    ?match({atomic,S2}, sort_res(mnesia:transaction(W2, [Tab2,SelLoop]))),
+    ?match({atomic,S2}, sort_res(mnesia:transaction(W2, [Tab2,Match]))),
+    ?match({atomic,S2Bag}, sort_res(mnesia:transaction(W2, [Tab3,Select]))),
+    ?match({atomic,S2Bag}, sort_res(mnesia:transaction(W2, [Tab3,SelLoop]))),
+    ?match({atomic,S2Bag}, sort_res(mnesia:transaction(W2, [Tab3,Match]))),
+%%    [mnesia:dirty_delete_object(Tab,R) || R <- [R1,R3], Tab <- Tabs],
+
+    W3 = fun(Tab,Search) -> 
+		 mnesia:write(Tab,R4,write),
+		 mnesia:delete(Tab,element(2,R1),write), 
+		 Search(Tab)
+	 end,
+    S3Bag = lists:sort([R4|lists:delete(R1,Recs)]),
+    S3 = lists:delete({RecName,3,3},S3Bag),
+    ?match({atomic,S3}, mnesia:transaction(W3, [Tab1,Select])),
+    ?match({atomic,S3}, mnesia:transaction(W3, [Tab1,SelLoop])),
+    ?match({atomic,S3}, mnesia:transaction(W3, [Tab1,Match])),
+    ?match({atomic,S3}, sort_res(mnesia:transaction(W3, [Tab2,SelLoop]))),
+    ?match({atomic,S3}, sort_res(mnesia:transaction(W3, [Tab2,Select]))),
+    ?match({atomic,S3}, sort_res(mnesia:transaction(W3, [Tab2,Match]))),
+    ?match({atomic,S3Bag}, sort_res(mnesia:transaction(W3, [Tab3,Select]))),
+    ?match({atomic,S3Bag}, sort_res(mnesia:transaction(W3, [Tab3,SelLoop]))),
+    ?match({atomic,S3Bag}, sort_res(mnesia:transaction(W3, [Tab3,Match]))),
+
+    W4 = fun(Tab,Search) -> 
+		 mnesia:delete(Tab,-1,write),
+		 mnesia:delete(Tab,4 ,write),
+		 mnesia:delete(Tab,17,write),
+		 mnesia:delete_object(Tab,{RecName, -1, x},write),
+		 mnesia:delete_object(Tab,{RecName, 4, x},write),
+		 mnesia:delete_object(Tab,{RecName, 42, x},write),
+		 mnesia:delete_object(Tab,R2,write),
+		 mnesia:write(Tab, R5, write),
+		 Search(Tab)
+	 end,
+    S4Bag = lists:sort([R5|S3Bag]),
+    S4    = lists:sort([R5|S3]),
+    ?match({atomic,S4}, mnesia:transaction(W4, [Tab1,Select])),
+    ?match({atomic,S4}, mnesia:transaction(W4, [Tab1,SelLoop])),
+    ?match({atomic,S4}, mnesia:transaction(W4, [Tab1,Match])),
+    ?match({atomic,S4}, sort_res(mnesia:transaction(W4, [Tab2,Select]))),
+    ?match({atomic,S4}, sort_res(mnesia:transaction(W4, [Tab2,SelLoop]))),
+    ?match({atomic,S4}, sort_res(mnesia:transaction(W4, [Tab2,Match]))),
+    ?match({atomic,S4Bag}, sort_res(mnesia:transaction(W4, [Tab3,Select]))),
+    ?match({atomic,S4Bag}, sort_res(mnesia:transaction(W4, [Tab3,SelLoop]))),
+    ?match({atomic,S4Bag}, sort_res(mnesia:transaction(W4, [Tab3,Match]))),
+    [mnesia:dirty_delete_object(Tab,R) || R <- [{RecName,3,3},R5], Tab <- Tabs],
+        
+    %% hmmm anything more??
+    
+    ?verify_mnesia([Node1], []).
+
+removed_resources(suite) ->     
+    [rr_kill_copy];
+removed_resources(doc) -> 
+    ["Verify that the locking behave when resources are removed"].
+
+rr_kill_copy(suite) -> [];
+rr_kill_copy(Config) when is_list(Config) ->
+    Ns = ?acquire_nodes(3,Config ++ [{tc_timeout, 60000}]),
+    DeleteMe = fun(_Tab,Where2read) ->
+		       ?match([], mnesia_test_lib:kill_mnesia([Where2read]))
+	       end,
+    Del = removed_resources(Ns, DeleteMe),
+    ?verify_mnesia(Ns -- [Del], []).
+
+removed_resources([_N1,N2,N3], DeleteRes) ->
+    Tab = del_res,
+    ?match({atomic, ok}, mnesia:create_table(Tab,[{ram_copies, [N2,N3]}])),
+    
+    Init = fun() -> [mnesia:write({Tab,Key,Key}) || Key <- lists:seq(0,99)] end,
+    ?match([], [Bad || Bad <- mnesia:sync_dirty(Init), Bad /= ok]),
+    
+    Where2Read = mnesia:table_info(Tab, where_to_read),
+    [Keep]  = [N2,N3] -- [Where2Read],
+    Tester = self(),
+    
+    Conflict = fun() -> 
+		       %% Read a value..
+		       [{Tab,1,Val}] = mnesia:read({Tab,1}),
+		       case get(restart) of
+			   undefined -> 
+			       Tester ! {pid_1, self()},
+			       %% Wait for sync, the read value have been 
+			       %% updated and this function should be restarted.
+			       receive {Tester,sync} -> ok  end,
+			       put(restart, restarted);
+			   restarted ->
+			       ok
+		       end,		       
+		       mnesia:write({Tab,1,Val+10})
+	       end,
+    Lucky    = fun() -> 
+		       [{Tab,1,Val}] = mnesia:read({Tab,1}),
+		       mnesia:write({Tab,1,Val+100})
+	       end,
+    
+    CPid = spawn_link(fun() -> Tester ! {self(), mnesia:transaction(Conflict)} end),
+    
+    %% sync first transaction
+    receive {pid_1, CPid} -> synced end,
+
+    DeleteRes(Tab, Where2Read),
+
+    ?match(Keep, mnesia:table_info(Tab, where_to_read)),
+    
+    %% Run the other/Lucky transaction, this should work since 
+    %% it won't grab a lock on the conflicting transactions Where2Read node.
+    
+    LPid = spawn_link(Keep, fun() -> Tester ! {self(),mnesia:transaction(Lucky)} end),
+    ?match_receive({LPid,{atomic,ok}}),
+    
+    %% Continue Transaction no 1
+    CPid ! {self(), sync},
+    
+    ?match(ok, receive {CPid,{atomic,ok}} -> ok after 2000 -> process_info(self()) end),
+    
+    ?match({atomic,[{del_res,1,111}]}, mnesia:transaction(fun() -> mnesia:read({Tab,1}) end)),
+    Where2Read.
+
+nasty(suite) -> [];
+
+nasty(doc) ->
+    ["Tries to fullfill a rather nasty locking scenario, where we have had "
+     "bugs, the testcase tries a combination of locks in locker queue"];
+
+%%  This testcase no longer works as it was intended to show errors when 
+%%  tablelocks was allowed to be placed in the queue though locks existed 
+%%  in the queue with less Tid's. This is no longer allowed and the testcase
+%%  has been update.
+
+nasty(Config) ->
+    ?acquire_nodes(1, Config),
+    Tab = nasty,
+    ?match({atomic, ok}, mnesia:create_table(Tab, [])),    
+    Coord = self(),        				    
+    Write = fun(Key) ->
+		    mnesia:write({Tab, Key, write}),	 
+		    Coord ! {write, Key, self(), mnesia:get_activity_id()},
+		    receive 
+			continue ->
+			    ok
+		    end,	    
+		    Coord ! {done, {write, Key}, self()}		    
+	    end,
+    
+    Update = fun(Key) ->
+		     Coord ! {update, Key, self(), mnesia:get_activity_id()},
+		     receive
+			 continue ->
+			     ok
+		     end,
+		     mnesia:read({Tab, Key}),
+		     mnesia:write({Tab, Key, update}),
+		     receive
+			 continue ->
+			     ok
+		     end,
+		     
+		     Coord ! {done, {update, Key}, self()}
+	     end,
+    
+    TabLock = fun() ->
+		      Coord ! {tablock, Tab, self(), mnesia:get_activity_id()},
+		      receive
+			  continue ->
+			      ok
+		      end,
+		      mnesia:lock({table, Tab}, write),
+		      Coord ! {done, {tablock, Tab}, self()}
+	      end,
+
+    Up = spawn_link(mnesia, transaction, [Update,  [0]]),
+    ?match_receive({update, 0, Up, _Tid}),
+    TL = spawn_link(mnesia, transaction, [TabLock]), 
+    ?match_receive({tablock, Tab, _Tl, _Tid}),
+    W0 = spawn_link(mnesia, transaction, [Write, [0]]), 
+    ?match_receive({write, 0, W0, _Tid}),
+    W1 = spawn_link(mnesia, transaction, [Write, [1]]), 
+    ?match_receive({write, 1, W1, _Tid}),
+    
+    %% Nothing should be in msg queue!
+    ?match(timeout, receive A -> A after 1000 -> timeout end),
+    Up ! continue,  %% Should be queued
+    ?match(timeout, receive A -> A after 1000 -> timeout end),
+    TL ! continue,  %% Should be restarted
+%    ?match({tablock, _, _, _}, receive A -> A after 1000 -> timeout end),
+    ?match(timeout, receive A -> A after 1000 -> timeout end),
+    
+    LQ1 = mnesia_locker:get_lock_queue(),    
+    ?match({2, _}, {length(LQ1), LQ1}),
+    W0 ! continue,                          % Up should be in queue
+    ?match_receive({done, {write, 0}, W0}),
+    ?match_receive({'EXIT', W0, normal}),
+
+    TL ! continue,   % Should stay in queue W1
+    ?match(timeout, receive A -> A after 1000 -> timeout end),
+    Up ! continue,   % Should stay in queue (TL got higher tid)
+    ?match(timeout, receive A -> A after 1000 -> timeout end),
+
+    LQ2 = mnesia_locker:get_lock_queue(),
+    ?match({2, _}, {length(LQ2), LQ2}),    
+    
+    W1 ! continue,
+    ?match_receive({done, {write, 1}, W1}),
+    get_exit(W1),
+    get_exit(TL),
+    ?match_receive({done, {tablock,Tab}, TL}),
+    get_exit(Up),
+    ?match_receive({done, {update, 0}, Up}),
+    
+    ok.
+
+get_exit(Pid) ->
+    receive 
+	{'EXIT', Pid, normal} ->
+	    ok
+    after 10000 ->
+	    ?error("Timeout EXIT ~p~n", [Pid])
+    end.
+
+iteration(doc) ->
+    ["Verify that the updates before/during iteration are visable "
+     "and that the order is preserved for ordered_set tables"];
+iteration(suite) ->
+    [foldl,first_next].
+
+foldl(doc) ->
+    [""];
+foldl(suite) ->
+    [];
+foldl(Config) when is_list(Config) ->
+    Nodes = [_,N2] = ?acquire_nodes(2, Config),
+    Tab1 = foldl_local,
+    Tab2 = foldl_remote,
+    Tab3 = foldl_ordered, 
+    Tab11 = foldr_local,
+    Tab21 = foldr_remote,
+    Tab31 = foldr_ordered, 
+    ?match({atomic, ok}, mnesia:create_table(Tab1, [{ram_copies, Nodes}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab2, [{ram_copies, [N2]}, {type, bag}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab3, [{ram_copies, Nodes}, 
+						    {type, ordered_set}])),    
+    ?match({atomic, ok}, mnesia:create_table(Tab11, [{ram_copies, Nodes}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab21, [{ram_copies, [N2]}, {type, bag}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab31, [{ram_copies, Nodes}, 
+						    {type, ordered_set}])),    
+
+
+    Tab1Els = [{Tab1, N, N} || N <- lists:seq(1, 10)],
+    Tab2Els = [{Tab2, 1, 2} | [{Tab2, N, N} || N <- lists:seq(1, 10)]],
+    Tab3Els = [{Tab3, N, N} || N <- lists:seq(1, 10)],
+    Tab11Els = [{Tab11, N, N} || N <- lists:seq(1, 10)],
+    Tab21Els = [{Tab21, 1, 2} | [{Tab21, N, N} || N <- lists:seq(1, 10)]],
+    Tab31Els = [{Tab31, N, N} || N <- lists:seq(1, 10)],
+    
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab1Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab2Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab3Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab11Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab21Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab31Els],
+    
+    Get = fun(E, A) -> [E | A] end,
+    
+    %% Before 
+    AddB = fun(Tab, Func) -> 
+		   mnesia:write({Tab, 0, 0}),
+		   mnesia:write({Tab, 1, 0}),
+		   mnesia:write({Tab, 11, 0}),
+		   mnesia:Func(Get, [], Tab)
+	   end,        
+    AddT1 = [{Tab1, 0, 0}, {Tab1, 1, 0}] ++ tl(Tab1Els) ++ [{Tab1, 11, 0}],
+    AddT2 = lists:sort([{Tab2, 0, 0}, {Tab2, 1, 0}] ++ Tab2Els ++ [{Tab2, 11, 0}]),
+    AddT3 = [{Tab3, 0, 0}, {Tab3, 1, 0}] ++ tl(Tab3Els) ++ [{Tab3, 11, 0}],
+    AddT11 = [{Tab11, 0, 0}, {Tab11, 1, 0}] ++ tl(Tab11Els) ++ [{Tab11, 11, 0}],
+    AddT21 = lists:sort([{Tab21, 0, 0}, {Tab21, 1, 0}] ++ Tab21Els ++ [{Tab21, 11, 0}]),
+    AddT31 = [{Tab31, 0, 0}, {Tab31, 1, 0}] ++ tl(Tab31Els) ++ [{Tab31, 11, 0}],
+    
+    ?match({atomic, AddT1}, sort_res(mnesia:transaction(AddB, [Tab1, foldl]))),
+    ?match({atomic, AddT2}, sort_res(mnesia:transaction(AddB, [Tab2, foldl]))),
+    ?match({atomic, AddT3}, rev_res(mnesia:transaction(AddB, [Tab3, foldl]))),
+    ?match({atomic, AddT11}, sort_res(mnesia:transaction(AddB, [Tab11, foldr]))),
+    ?match({atomic, AddT21}, sort_res(mnesia:transaction(AddB, [Tab21, foldr]))),
+    ?match({atomic, AddT31}, mnesia:transaction(AddB, [Tab31, foldr])),
+    
+    ?match({atomic, ok}, mnesia:create_table(copy, [{ram_copies, [N2]},
+						    {record_name, Tab1}])),
+    CopyRec = fun(NewRec, Acc) -> 
+		      %% OTP-5495
+		      W = fun() -> mnesia:write(copy, NewRec, write), [NewRec| Acc] end,
+		      {atomic,Res} = sort_res(mnesia:transaction(W)),
+		      Res
+	      end,
+    Copy = fun() -> 
+		   AddT1 = mnesia:foldl(CopyRec, [], Tab1),
+		   AddT1 = sort_res(mnesia:foldl(Get, [], copy))
+	   end,
+    ?match({atomic, AddT1}, sort_res(mnesia:transaction(Copy))),
+    
+    Del  = fun(E, A) -> mnesia:delete_object(E), [E|A] end,
+    DelD = fun(Tab) ->
+		   mnesia:write({Tab, 12, 12}),
+		   mnesia:delete({Tab, 0}),
+		   mnesia:foldr(Del, [], Tab),
+		   mnesia:foldl(Get, [], Tab)
+	   end,
+    ?match({atomic, []}, sort_res(mnesia:transaction(DelD, [Tab1]))),
+    ?match({atomic, []}, sort_res(mnesia:transaction(DelD, [Tab2]))),
+    ?match({atomic, []}, rev_res(mnesia:transaction(DelD, [Tab3]))),
+    
+    ListWrite = fun(Tab) ->   %% OTP-3893 
+			mnesia:write({Tab, [12], 12}),	
+			mnesia:foldr(Get, [], Tab)
+		end,
+    ?match({atomic, [{Tab1, [12], 12}]}, sort_res(mnesia:transaction(ListWrite, [Tab1]))),
+    ?match({atomic, [{Tab2, [12], 12}]}, sort_res(mnesia:transaction(ListWrite, [Tab2]))),
+    ?match({atomic, [{Tab3, [12], 12}]}, rev_res(mnesia:transaction(ListWrite, [Tab3]))),
+    
+    ?verify_mnesia(Nodes, []).	   
+
+sort_res({atomic, List}) when is_list(List) ->
+    {atomic, lists:sort(List)};
+sort_res(Else) when is_list(Else) ->
+    lists:sort(Else);
+sort_res(Else) ->
+    Else.
+
+rev_res({atomic, List}) ->
+    {atomic, lists:reverse(List)};
+rev_res(Else) ->
+    Else.
+
+
+first_next(doc) ->    [""];
+first_next(suite) ->  [];
+first_next(Config) when is_list(Config) ->
+    Nodes = [_,N2] = ?acquire_nodes(2, Config),
+    Tab1 = local,
+    Tab2 = remote,
+    Tab3 = ordered, 
+    Tab4 = bag,
+    Tabs = [Tab1,Tab2,Tab3,Tab4],
+    
+    ?match({atomic, ok}, mnesia:create_table(Tab1, [{ram_copies, Nodes}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab2, [{ram_copies, [N2]}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab3, [{ram_copies, Nodes}, 
+						    {type, ordered_set}])),
+    ?match({atomic, ok}, mnesia:create_table(Tab4, [{ram_copies, Nodes}, 
+						    {type, bag}])),
+
+    %% Some Helpers
+    Trans = fun(Fun) -> mnesia:transaction(Fun) end,
+    Continue = fun(first) -> next;
+		  (last) -> prev
+	       end,
+    LoopHelp = fun('$end_of_table',_,_,_Fun) -> [];
+		  (Key,Tab,Op,Fun) -> 
+		       Next = mnesia:Op(Tab,Key),
+		       [Next |Fun(Next,Tab,Op,Fun)] 
+	       end,
+    Loop = fun(Tab,Start) -> 
+		   First = mnesia:Start(Tab),
+		   Res = [First|LoopHelp(First,Tab,Continue(Start),LoopHelp)],
+		   case mnesia:table_info(Tab, type) of
+		       ordered_set when Start == first -> Res;
+		       ordered_set -> 
+			   {L1,L2} = lists:split(length(Res)-1,Res),
+			   lists:reverse(L1) ++ L2;
+		       _ -> lists:sort(Res)
+		   end	  
+	   end,
+
+    %% Verify empty tables
+    [?match({atomic, ['$end_of_table']}, 
+ 	    Trans(fun() -> Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, ['$end_of_table']}, 
+ 	    Trans(fun() -> Loop(Tab,last) end)) 
+     || Tab <- Tabs],
+    %% Verify that trans write is visible inside trans
+    [?match({atomic, [0,10,'$end_of_table']}, 
+ 	    Trans(fun() ->
+ 			  mnesia:write({Tab,0,0}),
+ 			  mnesia:write({Tab,10,10}),
+ 			  Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, ['$end_of_table']}, 
+ 	    Trans(fun() -> 
+ 			  mnesia:delete({Tab,0}),
+ 			  mnesia:delete({Tab,10}),
+ 			  Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+
+    [?match({atomic, [0,10,'$end_of_table']}, 
+ 	    Trans(fun() -> 
+ 			  mnesia:write({Tab,0,0}),
+ 			  mnesia:write({Tab,10,10}),
+ 			  Loop(Tab,last) end))
+     || Tab <- Tabs],
+    [?match({atomic, ['$end_of_table']}, 
+ 	    Trans(fun() -> 
+ 			  mnesia:delete({Tab,0}),
+ 			  mnesia:delete({Tab,10}),
+ 			  Loop(Tab,last) end)) 
+     || Tab <- Tabs],
+
+    Tab1Els = [{Tab1, N, N} || N <- lists:seq(1, 5)],
+    Tab2Els = [{Tab2, N, N} || N <- lists:seq(1, 5)],
+    Tab3Els = [{Tab3, N, N} || N <- lists:seq(1, 5)],
+    Tab4Els = [{Tab4, 1, 2} | [{Tab4, N, N} || N <- lists:seq(1, 5)]],
+
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab1Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab2Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab3Els],
+    [mnesia:sync_dirty(fun() -> mnesia:write(E) end) || E <- Tab4Els],
+    Keys = lists:sort(mnesia:dirty_all_keys(Tab1)),
+    R1  =  Keys++ ['$end_of_table'],
+    [?match({atomic, R1}, Trans(fun() -> Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+
+    [?match({atomic, R1}, Trans(fun() -> Loop(Tab,last) end)) 
+     || Tab <- Tabs],
+    R2 = R1 -- [3],
+
+    [?match({atomic, R2}, Trans(fun() -> mnesia:delete({Tab,3}),Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, R1}, Trans(fun() -> mnesia:write({Tab,3,3}),Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, R2}, Trans(fun() -> mnesia:delete({Tab,3}),Loop(Tab,last) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, R1}, Trans(fun() -> mnesia:write({Tab,3,3}),Loop(Tab,last) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, R1}, Trans(fun() -> mnesia:write({Tab,4,19}),Loop(Tab,first) end)) 
+     || Tab <- Tabs],
+    [?match({atomic, R1}, Trans(fun() -> mnesia:write({Tab,4,4}),Loop(Tab,last) end)) 
+     || Tab <- Tabs],
+
+    ?verify_mnesia(Nodes, []).
+
+
+snmp_shadows(doc) ->    [""];
+snmp_shadows(suite) ->  [];
+snmp_shadows(Config) when is_list(Config) ->
+    Nodes = ?acquire_nodes(1, Config),
+    Tab = snmp_shadows,
+    io:format("With fixstring~n", []),
+    ?match({atomic, ok}, mnesia:create_table(Tab,[{snmp,[{key,{fix_string,integer}}]}])),
+    snmp_shadows_test(Tab),
+    ?match({atomic, ok}, mnesia:delete_table(Tab)),
+    io:format("Without fixstring~n", []),
+    ?match({atomic, ok}, mnesia:create_table(Tab,[{snmp,[{key,{string,integer}}]}])),
+    snmp_shadows_test(Tab),
+    ?verify_mnesia(Nodes, []).
+
+snmp_shadows_test(Tab) ->
+    [mnesia:dirty_write({Tab, {"string", N}, {N, init}}) || N <- lists:seq(2,8,2)],
+    
+    CheckOrder = fun(A={_,_,{_,_,State}}, Prev) ->
+			 ?match({true, A, Prev}, {Prev < A, A, Prev}),
+			 {State,A} 
+		 end,
+    R1 = mnesia:sync_dirty(fun() -> loop_snmp(Tab, []) end),
+    lists:mapfoldl(CheckOrder, {[],foo,foo}, R1),
+    R2 = mnesia:transaction(fun() -> loop_snmp(Tab, []) end),
+    ?match({atomic, R1}, R2),
+    
+    Shadow = fun() ->
+		     ok = mnesia:write({Tab, {"string",1}, {1,update}}),
+		     ok = mnesia:write({Tab, {"string",4}, {4,update}}),
+		     ok = mnesia:write({Tab, {"string",6}, {6,update}}),
+		     ok = mnesia:delete({Tab, {"string",6}}),
+		     ok = mnesia:write({Tab, {"string",9}, {9,update}}),
+		     ok = mnesia:write({Tab, {"string",3}, {3,update}}),
+		     ok = mnesia:write({Tab, {"string",5}, {5,update}}),
+		     [Row5] = mnesia:read({Tab, {"string",5}}),
+		     ok = mnesia:delete_object(Row5),
+		     loop_snmp(Tab, [])
+	     end,
+    R3 = mnesia:sync_dirty(Shadow),
+    {L3,_} = lists:mapfoldl(CheckOrder, {[],foo,foo}, R3),
+    ?match([{1,update},{2,init},{3,update},{4,update},{8,init},{9,update}], L3),
+    ?match({atomic, ok}, mnesia:clear_table(Tab)),
+
+    [mnesia:dirty_write({Tab, {"string", N}, {N, init}}) || N <- lists:seq(2,8,2)],
+    {atomic, R3} = mnesia:transaction(Shadow),
+    {L4,_} = lists:mapfoldl(CheckOrder, {[],foo,foo}, R3),
+    ?match([{1,update},{2,init},{3,update},{4,update},{8,init},{9,update}], L4),
+    ok.
+   
+loop_snmp(Tab,Prev) ->
+    case mnesia:snmp_get_next_index(Tab,Prev) of
+	{ok, SKey} ->
+	    {{ok,Row},_} = {mnesia:snmp_get_row(Tab, SKey),{?LINE,Prev,SKey}},
+	    {{ok,MKey},_} = {mnesia:snmp_get_mnesia_key(Tab,SKey),{?LINE,Prev,SKey}},
+	    ?match({[Row],Row,SKey,MKey}, {mnesia:read({Tab,MKey}),Row,SKey,MKey}),
+	    [{SKey, MKey, Row} | loop_snmp(Tab, SKey)];
+	endOfTable ->
+	    []
+    end.