|
| 1 | +%% EXPECT: ets_bitstring_keys_ok |
| 2 | +%% Regression for storage copies exposing pointer-based bitstring keys. |
| 3 | +%% Returned/copied keys and bag values must still compare by significant bits, |
| 4 | +%% including bitstrings nested in lists and tuples. Run unchanged on BEAM. |
| 5 | +-module(ets_bitstring_keys). |
| 6 | +-export([test/0]). |
| 7 | + |
| 8 | +test() -> |
| 9 | + bag_duplicates(), |
| 10 | + [table_keys(Type) || Type <- [set, bag, duplicate_bag]], |
| 11 | + persistent_keys(), |
| 12 | + io:format("ets_bitstring_keys_ok~n"), |
| 13 | + ok. |
| 14 | + |
| 15 | +keys() -> |
| 16 | + Small = <<"abcdefgh", (id(5)):4>>, |
| 17 | + Bytes = list_to_binary(lists:duplicate(id(200), $x)), |
| 18 | + Large = <<Bytes/binary, (id(3)):2>>, |
| 19 | + [Small, Large, [Small], {wrapped, [Large, Small]}, |
| 20 | + <<(id(5)):3>>, <<(id(20)):5>>, <<(id(4)):3>>]. |
| 21 | + |
| 22 | +id(X) -> X. |
| 23 | + |
| 24 | +bag_duplicates() -> |
| 25 | + [Small, Large | _] = keys(), |
| 26 | + Value = {Small, [Large, Small]}, |
| 27 | + T = ets:new(bitstring_bag, [bag]), |
| 28 | + Row = {key, Value}, |
| 29 | + true = ets:insert(T, Row), |
| 30 | + true = ets:insert(T, Row), |
| 31 | + [Row] = ets:lookup(T, key), |
| 32 | + true = ets:delete(T), |
| 33 | + ok. |
| 34 | + |
| 35 | +table_keys(Type) -> |
| 36 | + T = ets:new(bitstring_keys, [Type]), |
| 37 | + Keys = keys(), |
| 38 | + [true = ets:insert(T, {K, 0, unchanged}) || K <- Keys], |
| 39 | + CopiedRows = ets:tab2list(T), |
| 40 | + Count = length(Keys), |
| 41 | + Count = length(CopiedRows), |
| 42 | + [check_copied_key(Type, T, Row) || Row <- CopiedRows], |
| 43 | + Sorted = lists:sort(Keys), |
| 44 | + Sorted = lists:sort(walk(T, ets:first(T), next)), |
| 45 | + Sorted = lists:sort(walk(T, ets:last(T), prev)), |
| 46 | + %% Keys from traversal also work for lookup and membership. |
| 47 | + true = ets:member(T, ets:first(T)), |
| 48 | + true = ets:member(T, ets:last(T)), |
| 49 | + [begin |
| 50 | + true = ets:delete(T, K), |
| 51 | + false = ets:member(T, K), |
| 52 | + [] = ets:lookup(T, K) |
| 53 | + end || {K, _, _} <- CopiedRows], |
| 54 | + [] = ets:tab2list(T), |
| 55 | + true = ets:delete(T), |
| 56 | + ok. |
| 57 | + |
| 58 | +check_copied_key(Type, T, {K, 0, unchanged}) -> |
| 59 | + true = ets:member(T, K), |
| 60 | + [{K, 0, unchanged}] = ets:lookup(T, K), |
| 61 | + false = ets:insert_new(T, {K, 99, replaced}), |
| 62 | + case Type of |
| 63 | + set -> |
| 64 | + true = ets:update_element(T, K, {3, [updated]}), |
| 65 | + 1 = ets:update_counter(T, K, {2, 1}), |
| 66 | + [{K, 1, [updated]}] = ets:lookup(T, K); |
| 67 | + _ -> ok |
| 68 | + end, |
| 69 | + ok. |
| 70 | + |
| 71 | +walk(_T, '$end_of_table', _Direction) -> []; |
| 72 | +walk(T, K, Direction) -> |
| 73 | + [_] = ets:lookup(T, K), |
| 74 | + Next = case Direction of |
| 75 | + next -> ets:next(T, K); |
| 76 | + prev -> ets:prev(T, K) |
| 77 | + end, |
| 78 | + [K | walk(T, Next, Direction)]. |
| 79 | + |
| 80 | +persistent_keys() -> |
| 81 | + CopyKey = {?MODULE, copied_key}, |
| 82 | + [begin |
| 83 | + %% Reading a stored value makes a new descriptor, which must be |
| 84 | + %% interchangeable with the original when either is used as a key. |
| 85 | + ok = persistent_term:put(CopyKey, K), |
| 86 | + Copied = persistent_term:get(CopyKey), |
| 87 | + ok = persistent_term:put(K, original), |
| 88 | + original = persistent_term:get(Copied), |
| 89 | + ok = persistent_term:put(Copied, replaced), |
| 90 | + replaced = persistent_term:get(K), |
| 91 | + true = persistent_term:erase(Copied), |
| 92 | + missing = persistent_term:get(K, missing) |
| 93 | + end || K <- keys()], |
| 94 | + true = persistent_term:erase(CopyKey), |
| 95 | + ok. |
0 commit comments