anchor.diff:              ok
       end,
   
  -    {ok, {L5, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  -    {ok, {L6, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  -
  -    spawn_link(Node1, fun() ->
  +    {ok, {L5, _, _, _}} = lasp:declare(?SET),
  +    {ok, {L6, _, _, _}} = lasp:declare(?SET),
  +
  +    spawn_link(fun() ->
                   {ok, _} = lasp:read_any([{L5, {strict, undefined}}, {L6, {strict, undefined}}]),
                   Self ! read_any
           end),
   
  -    ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [L5, {add, 1}, a])),
  +    {ok, _} = lasp:update(L5, {add, 1}, a),
   
       receive
           read_any ->
  
positive.code: -define(COUNTER, lasp_pncounter).
  -define(ID, <<"myidentifier">>).
  
  ivar_test(Config) ->
      [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  
      %% Single-assignment variables.
      {ok, {I1, _, _, _}} = rpc:call(Node1, lasp, declare, [lasp_ivar]),
      {ok, {I2, _, _, _}} = rpc:call(Node1, lasp, declare, [lasp_ivar]),
      {ok, {I3, _, _, _}} = rpc:call(Node1, lasp, declare, [lasp_ivar]),
  
      V1 = 1,
  
      %% Attempt pre, and post- dataflow variable bind operations.
      ?assertMatch(ok, rpc:call(Node1, lasp, bind_to, [I2, I1])),
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, bind, [I1, V1])),
      ?assertMatch(ok, rpc:call(Node1, lasp, bind_to, [I3, I1])),
  
      %% Perform invalid bind; won't return error, just will have no
      %% effect.
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, bind, [I1, 2])),
  
      %% Verify the same value is contained by all.
      ?assertMatch({ok, {_, _, _, V1}}, rpc:call(Node1, lasp, read, [I3, {strict, undefined}])),
      ?assertMatch({ok, {_, _, _, V1}}, rpc:call(Node1, lasp, read, [I2, {strict, undefined}])),
      ?assertMatch({ok, {_, _, _, V1}}, rpc:call(Node1, lasp, read, [I1, {strict, undefined}])),
  
      io:format("*woekjfoewf~n"),
  
      ok.
  
  map_test(Config) ->
      [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  
      %% Create initial set.
      {ok, {S1, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Add elements to initial set and update.
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S1, {add_all, [1,2,3]}, a])),
  
      %% Create second set.
      {ok, {S2, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Apply map.
      ?assertMatch(ok, rpc:call(Node1, lasp, map, [S1, fun(X) -> X * 2 end, S2])),
  
      %% Wait.
      timer:sleep(4000),
  
      %% Bind again.
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S1, {add_all, [4,5,6]}, a])),
  
      %% Wait.
      timer:sleep(4000),
  
      %% Read resulting value.
      {ok, {_, _, _, S1V4}} = rpc:call(Node1, lasp, read, [S1, {strict, undefined}]),
  
      %% Read resulting value.
      {ok, {_, _, _, S2V1}} = rpc:call(Node1, lasp, read, [S2, {strict, undefined}]),
  
      ?assertEqual({ok, [1,2,3,4,5,6], [2,4,6,8,10,12]},
                   {ok, ?SET:value(S1V4), ?SET:value(S2V1)}),
  
      ok.
  
  filter_test(Config) ->
      [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  
      %% Create initial set.
      {ok, {S1, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Add elements to initial set and update.
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S1, {add_all, [1,2,3]}, a])),
  
      %% Create second set.
      {ok, {S2, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Apply filter.
      ?assertMatch(ok, rpc:call(Node1, lasp, filter, [S1, fun(X) -> X rem 2 == 0 end, S2])),
  
      %% Wait.
      timer:sleep(4000),
  
      %% Bind again.
      ?assertMatch({ok, _}, rpc:call(Node1, lasp, update, [S1, {add_all, [4,5,6]}, a])),
  
      %% Wait.
      timer:sleep(4000),
  
      %% Read resulting value.
      {ok, {_, _, _, S1V4}} = rpc:call(Node1, lasp, read, [S1, {strict, undefined}]),
  
      %% Read resulting value.
      {ok, {_, _, _, S2V1}} = rpc:call(Node1, lasp, read, [S2, {strict, undefined}]),
  
      ?assertEqual({ok, [1,2,3,4,5,6], [2,4,6]},
                   {ok, ?SET:value(S1V4), ?SET:value(S2V1)}),
  
      ok.
  
  fold_test(Config) ->
      [Node1 | _Nodes] = proplists:get_value(nodes, Config),
  
      %% Create initial set.
      {ok, {S1, _, _, _}} = rpc:call(Node1, lasp, declare, [?SET]),
  
      %% Perform some operations.
      ?assertMatch({ok, _},
                   rpc:call(Node1, lasp, update, [S1, {add_all, [1,2,3]}, a])),
      ?assertMatch({ok, _},
                   rpc:call(Node1, lasp, update, [S1, {remove_all, [2,3]}, b])),
      ?assertMatch({ok, _},
                   rpc:call(Node1, lasp, update, [S1, {add, 2}, c])),
  
      %% Create second set.
      {ok, {S2, _, _, _}} = rpc:call(Node1, lasp, declare, [?COUNTER]),
  
      %% Define the fold function.
      FoldFun = fun(X, _Acc) ->
  
negative.code: 
      ok.
  
  %% @doc Cartesian product test.
  product_test(_Config) ->
      %% Create initial sets.
      {ok, {S1, _, _, _}} = lasp:declare(?SET),
      {ok, {S2, _, _, _}} = lasp:declare(?SET),
  
      %% Create output set.
      {ok, {S3, _, _, _}} = lasp:declare(?SET),
  
      %% Populate initial sets.
      ?assertMatch({ok, _}, lasp:update(S1, {add_all, [1,2,3]}, a)),
      ?assertMatch({ok, _}, lasp:update(S2, {add_all, [a,b,3]}, a)),
  
      %% Apply product.
      ?assertMatch(ok, lasp:product(S1, S2, S3)),
  
      %% Sleep.
      timer:sleep(400),
  
      %% Read product.
      {ok, {_, _, _, Product0}} = lasp:read(S3, undefined),
  
      %% Read product value.
      Product = ?SET:value(Product0),
  