Format and prepare for release

3 files changed, 81 insertions, 74 deletions

diff --git a/test/concurrent_limiter_test.exs b/test/concurrent_limiter_test.exs
index e1d281e..090417e 100644
--- a/test/concurrent_limiter_test.exs
+++ b/test/concurrent_limiter_test.exs
@@ -1,42 +1,39 @@
+# ConcurrentLimiter: A concurrency limiter.
+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
+# SPDX-License-Identifier: LGPL-3.0-only
+
 defmodule ConcurrentLimiterTest do
   use ExUnit.Case
   doctest ConcurrentLimiter
 
-  test "limiter ets is atomic" do
-    name = "test1"
+  test "limiter is atomic" do
+    name = "test"
     ConcurrentLimiter.new(name, 2, 2)
-    atomic_test(name)
-  end
-
-  test "limiter atomics is atomic" do
-    name = "test2"
-    ConcurrentLimiter.new(name, 2, 2, backend: :atomics)
-    atomic_test(name)
-  end
-
-  defp atomic_test(name) do
     self = self()
 
-    sleepy = fn sleep ->
-      case ConcurrentLimiter.limit(name, fn ->
-             send(self, :ok)
-             Process.sleep(sleep)
-             :ok
-           end) do
-        :ok -> :ok
-        other -> send(self, other)
-      end
-    end
-
-    spawn_link(fn -> sleepy.(500) end)
-    spawn_link(fn -> sleepy.(500) end)
-    spawn_link(fn -> sleepy.(500) end)
-    spawn_link(fn -> sleepy.(500) end)
-    spawn_link(fn -> sleepy.(500) end)
+    spawn_link(fn -> sleepy(name, 500) end)
+    spawn_link(fn -> sleepy(name, 500) end)
+    spawn_link(fn -> sleepy(name, 500) end)
+    spawn_link(fn -> sleepy(name, 500) end)
+    spawn_link(fn -> sleepy(name, 500) end)
     assert_receive :ok, 2000
     assert_receive :ok, 2000
     assert_receive {:error, :overload}, 2000
     assert_receive :ok, 2000
     assert_receive :ok, 2000
   end
+
+  defp sleepy(duration) do
+    result =
+      ConcurrentLimiter.limit(name, fn ->
+        send(self, :ok)
+        Process.sleep(sleep)
+        :ok
+      end)
+
+    case result do
+      :ok -> :ok
+      other -> send(self, other)
+    end
+  end
 end
diff --git a/test/samples/multi_limiter.exs b/test/samples/multi_limiter.exs
index f56cb6c..0936773 100644
--- a/test/samples/multi_limiter.exs
+++ b/test/samples/multi_limiter.exs
@@ -1,49 +1,54 @@
 infinite = 1_000_000_000_000_000_000_000_000_000_000_000_000_000_000_000
-parallel = case Integer.parse(System.get_env("PARALLEL", "")) do
-  {int, _} -> int
-  _ -> System.schedulers_online()/2
-end
 
-multi_count = case Integer.parse(System.get_env("MULTI", "")) do
-  {int, _} -> int
-  _ -> parallel
-end
+parallel =
+  case Integer.parse(System.get_env("PARALLEL", "")) do
+    {int, _} -> int
+    _ -> System.schedulers_online() / 2
+  end
+
+multi_count =
+  case Integer.parse(System.get_env("MULTI", "")) do
+    {int, _} -> int
+    _ -> parallel
+  end
 
-names = fn(prefix) ->
+names = fn prefix ->
   for i <- 1..multi_count do
     Module.concat(MultiConcurrentLimiterBenchmark, "#{prefix}#{i}")
   end
 end
 
+bench_unique =
+  for name <- names.("u") do
+    ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, name, []})
+    name
+  end
 
-bench_unique = for name <- names.("u") do
-  ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, name, []})
-  name
-end
-
-IO.inspect(bench_unique)
-
-bench_atomics = for name <- names.("a") do
-  ConcurrentLimiter.new(name, infinite, 0, backend: :atomics)
-  name
-end
+bench_atomics =
+  for name <- names.("a") do
+    ConcurrentLimiter.new(name, infinite, 0, backend: :atomics)
+    name
+  end
 
-bench_shared = for name <- names.("s") do
-  ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, ConcurrentLimiterTest, []})
-  name
-end
+bench_shared =
+  for name <- names.("s") do
+    ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, ConcurrentLimiterTest, []})
+    name
+  end
 
 rw = [{:read_concurrency, true}, {:write_concurrency, true}]
 
-bench_unique_rw = for name <- names.("u_rw") do
-  ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, name, rw})
-  name
-end
+bench_unique_rw =
+  for name <- names.("u_rw") do
+    ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, name, rw})
+    name
+  end
 
-bench_shared_rw = for name <- names.("s_rw") do
-  ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, ConcurrentLimiterTestRW, rw})
-  name
-end
+bench_shared_rw =
+  for name <- names.("s_rw") do
+    ConcurrentLimiter.new(name, infinite, 0, backend: {:ets, ConcurrentLimiterTestRW, rw})
+    name
+  end
 
 multiple = %{
   "ConcurrentLimiter.limit/2 unique ets" => fn ->
diff --git a/test/samples/update_counter.exs b/test/samples/update_counter.exs
index 6310c57..1d8e837 100644
--- a/test/samples/update_counter.exs
+++ b/test/samples/update_counter.exs
@@ -1,20 +1,25 @@
 :ets.new(:limiter_bench, [:public, :named_table])
-:ets.new(:limiter_bench_concurrent, [:public, :named_table, {:read_concurrency, false}, {:write_concurrency, true}])
+
+:ets.new(:limiter_bench_concurrent, [
+  :public,
+  :named_table,
+  {:read_concurrency, false},
+  {:write_concurrency, true}
+])
+
 atomics = :atomics.new(1, [])
 
-update_counter = 
-  %{
-    "ets:update_counter" => fn ->
-      :ets.update_counter(:limiter_bench, "bench", {2, 1}, {"bench", 0})
-    end,
-    "ets:update_counter concurrent" => fn ->
-      :ets.update_counter(:limiter_bench, "bench", {2, 1}, {"bench", 0})
-    end,
-    "atomics:add_get" => fn ->
-      :atomics.add_get(atomics, 1, 1)
-    end,
-  }
+update_counter = %{
+  "ets:update_counter" => fn ->
+    :ets.update_counter(:limiter_bench, "bench", {2, 1}, {"bench", 0})
+  end,
+  "ets:update_counter concurrent" => fn ->
+    :ets.update_counter(:limiter_bench, "bench", {2, 1}, {"bench", 0})
+  end,
+  "atomics:add_get" => fn ->
+    :atomics.add_get(atomics, 1, 1)
+  end
+}
 
 Benchee.run(update_counter, parallel: 1)
 Benchee.run(update_counter, parallel: System.schedulers_online())
-