From d9761b07466e6b4b8bc36d88cfa504287a6e5b82 Mon Sep 17 00:00:00 2001 From: Devon Estes Date: Fri, 23 Nov 2018 12:05:56 +0100 Subject: [PATCH 1/2] Allow inputs to be an ordered list of tuples Now if inputs are given as an ordered list of tuples, the output will be in the same order as the list of inputs given instead of sorted by the input alphabetically. I also updated some dependencies to get them on the same page as the formatters, and fixed some Credo issues. --- .travis.yml | 15 +----- README.md | 18 +++++-- lib/benchee.ex | 4 +- lib/benchee/benchmark.ex | 2 +- lib/benchee/benchmark/repeated_measurement.ex | 2 +- lib/benchee/benchmark/runner.ex | 8 +-- lib/benchee/configuration.ex | 30 +++++++---- lib/benchee/conversion.ex | 2 +- lib/benchee/formatters/console.ex | 12 ++++- lib/benchee/formatters/console/memory.ex | 2 +- lib/benchee/formatters/console/run_time.ex | 2 +- lib/benchee/output/benchmark_printer.ex | 2 +- mix.exs | 5 +- mix.lock | 9 ++-- test/benchee/benchmark/runner_test.exs | 5 +- test/benchee/benchmark_test.exs | 13 +++-- test/benchee/configuration_test.exs | 19 ++++--- test/benchee/formatter_test.exs | 2 +- .../formatters/console/memory_test.exs | 2 +- .../formatters/console/run_time_test.exs | 2 +- test/benchee/formatters/console_test.exs | 51 +++++++++++++++++-- test/benchee/formatters/tagged_save_test.exs | 13 +++-- .../benchee/output/benchmark_printer_test.exs | 6 +-- test/benchee/scenario_loader_test.exs | 3 +- test/benchee/statistics_test.exs | 2 +- test/benchee_test.exs | 45 +++++++++++++--- 26 files changed, 187 insertions(+), 89 deletions(-) diff --git a/.travis.yml b/.travis.yml index 2628a8cc..56142cd8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,29 +1,16 @@ language: elixir elixir: - - 1.4.5 - - 1.5.3 - 1.6.6 - 1.7.4 otp_release: - - 19.3 - 20.3 - 21.1 - -matrix: - exclude: - - elixir: 1.4.5 - otp_release: 21.1 - - elixir: 1.5.3 - otp_release: 21.1 - - elixir: 1.7.4 - otp_release: 19.3 - before_script: - MIX_ENV=test mix compile --warnings-as-errors - travis_wait mix dialyzer --plt script: - mix credo --strict - - if [[ "$TRAVIS_ELIXIR_VERSION" == "1.6"* ]]; then mix format --check-formatted; fi + - mix format --check-formatted - mix dialyzer --halt-exit-status - mix safe_coveralls.travis after_script: diff --git a/README.md b/README.md index c8ad5724..696a1c28 100644 --- a/README.md +++ b/README.md @@ -94,7 +94,7 @@ Add benchee to your list of dependencies in `mix.exs`: ```elixir defp deps do - [{:benchee, "~> 0.11", only: :dev}] + [{:benchee, "~> 0.13", only: :dev}] end ``` @@ -162,7 +162,7 @@ The available options are the following (also documented in [hexdocs](https://he * `warmup` - the time in seconds for which a benchmarking job should be run without measuring times before "real" measurements start. This simulates a _"warm"_ running system. Defaults to 2. * `time` - the time in seconds for how long each individual benchmarking job should be run for measuring the execution times (run time performance). Defaults to 5. * `memory_time` - the time in seconds for how long [memory measurements](measuring-memory-consumption) should be conducted. Defaults to 0 (turned off). -* `inputs` - a map from descriptive input names to some different input, your benchmarking jobs will then be run with each of these inputs. For this to work your benchmarking function gets the current input passed in as an argument into the function. Defaults to `nil`, aka no input specified and functions are called without an argument. See [Inputs](#inputs). +* `inputs` - a map or list of two element tuples. If a map, they keys are descriptive input names and values are the actual input values. If a list of tuples, the first element in each tuple is the input name, and the second element in each tuple is the actual input value. Your benchmarking jobs will then be run with each of these inputs. For this to work your benchmarking function gets the current input passed in as an argument into the function. Defaults to `nil`, aka no input specified and functions are called without an argument. See [Inputs](#inputs). * `formatters` - list of formatters either as a module implementing the formatter behaviour, a tuple of said module and options it should take or formatter functions. They are run when using `Benchee.run/2` or you can invoktem them through `Benchee.Formatter.output/1`. Functions need to accept one argument (which is the benchmarking suite with all data) and then use that to produce output. Used for plugins. Defaults to the builtin console formatter `Benchee.Formatters.Console`. See [Formatters](#formatters). * `pre_check` - whether or not to run each job with each input - including all given before or after scenario or each hooks - before the benchmarks are measured to ensure that your code executes without error. This can save time while developing your suites. Defaults to `false`. * `parallel` - the function of each benchmarking job will be executed in `parallel` number processes. If `parallel: 4` then 4 processes will be spawned that all execute the _same_ function for the given time. When these finish/the time is up 4 new processes will be spawned for the next job/function. This gives you more data in the same time, but also puts a load on the system interfering with benchmark results. For more on the pros and cons of parallel benchmarking [check the wiki](https://github.com/PragTob/benchee/wiki/Parallel-Benchmarking). Defaults to 1 (no parallel execution). @@ -218,18 +218,26 @@ A full example, including an example of the console output, can be found ### Inputs -`:inputs` is a very useful configuration that allows you to run the same benchmarking jobs with different inputs. You specify the inputs as a map from name (String or atom) to the actual input value. Functions can have different performance characteristics on differently shaped inputs - be that structure or input size. +`:inputs` is a very useful configuration that allows you to run the same benchmarking jobs with different inputs. You specify the inputs as either a map from name (String or atom) to the actual input value or a list of tuples where the first element in each tuple is the name and the second element in the tuple is the value. Functions can have different performance characteristics on differently shaped inputs - be that structure or input size. One of such cases is comparing tail-recursive and body-recursive implementations of `map`. More information in the [repository with the benchmark](https://github.com/PragTob/elixir_playground/blob/master/bench/tco_blog_post_focussed_inputs.exs) and the [blog post](https://pragtob.wordpress.com/2016/06/16/tail-call-optimization-in-elixir-erlang-not-as-efficient-and-important-as-you-probably-think/). ```elixir map_fun = fn(i) -> i + 1 end inputs = %{ - "Small (1 Thousand)" => Enum.to_list(1..1_000), + "Small (1 Thousand)" => Enum.to_list(1..1_000), "Middle (100 Thousand)" => Enum.to_list(1..100_000), - "Big (10 Million)" => Enum.to_list(1..10_000_000), + "Big (10 Million)" => Enum.to_list(1..10_000_000) } +# Or inputs could also look like this: +# +# inputs = [ +# {"Small (1 Thousand)", Enum.to_list(1..1_000)}, +# {"Middle (100 Thousand)", Enum.to_list(1..100_000)}, +# {"Big (10 Million)", Enum.to_list(1..10_000_000)} +# ] + Benchee.run %{ "map tail-recursive" => fn(list) -> MyMap.map_tco(list, map_fun) end, diff --git a/lib/benchee.ex b/lib/benchee.ex index 41fd6e08..b73e4467 100644 --- a/lib/benchee.ex +++ b/lib/benchee.ex @@ -68,11 +68,11 @@ for {module, moduledoc} <- [{Benchee, elixir_doc}, {:benchee, erlang_doc}] do defdelegate init(), to: Benchee.Configuration defdelegate init(config), to: Benchee.Configuration defdelegate system(suite), to: Benchee.System + defdelegate benchmark(suite, name, function), to: Benchee.Benchmark + defdelegate benchmark(suite, name, function, printer), to: Benchee.Benchmark defdelegate measure(suite), to: Benchee.Benchmark defdelegate measure(suite, printer), to: Benchee.Benchmark - defdelegate benchmark(suite, name, function), to: Benchee.Benchmark defdelegate statistics(suite), to: Benchee.Statistics defdelegate load(suite), to: Benchee.ScenarioLoader - defdelegate benchmark(suite, name, function, printer), to: Benchee.Benchmark end end diff --git a/lib/benchee/benchmark.ex b/lib/benchee/benchmark.ex index 26c30e07..1871fb4b 100644 --- a/lib/benchee/benchmark.ex +++ b/lib/benchee/benchmark.ex @@ -4,7 +4,7 @@ defmodule Benchee.Benchmark do Exposes `benchmark/4` and `measure/3` functions. """ - alias Benchee.Benchmark.{Scenario, ScenarioContext, Runner} + alias Benchee.Benchmark.{Runner, Scenario, ScenarioContext} alias Benchee.Output.BenchmarkPrinter, as: Printer alias Benchee.Suite alias Benchee.Utility.DeepConvert diff --git a/lib/benchee/benchmark/repeated_measurement.ex b/lib/benchee/benchmark/repeated_measurement.ex index ff96fa35..9926bf84 100644 --- a/lib/benchee/benchmark/repeated_measurement.ex +++ b/lib/benchee/benchmark/repeated_measurement.ex @@ -21,7 +21,7 @@ defmodule Benchee.Benchmark.RepeatedMeasurement do # with too high variance. Therefore determine an n how often it should be # executed in the measurement cycle. - alias Benchee.Benchmark.{Hooks, Runner, Scenario, ScenarioContext, Measure} + alias Benchee.Benchmark.{Hooks, Measure, Runner, Scenario, ScenarioContext} alias Benchee.Utility.RepeatN @minimum_execution_time 10 diff --git a/lib/benchee/benchmark/runner.ex b/lib/benchee/benchmark/runner.ex index 370acea9..c2eed0ce 100644 --- a/lib/benchee/benchmark/runner.ex +++ b/lib/benchee/benchmark/runner.ex @@ -4,12 +4,8 @@ defmodule Benchee.Benchmark.Runner do # This module actually runs our benchmark scenarios, adding information about # run time and memory usage to each scenario. - alias Benchee.Benchmark - alias Benchee.Benchmark.{Scenario, ScenarioContext, Measure, Hooks, RepeatedMeasurement} - alias Benchee.Configuration - alias Benchee.Conversion - alias Benchee.Statistics - alias Benchee.Utility.Parallel + alias Benchee.{Benchmark, Configuration, Conversion, Statistics, Utility.Parallel} + alias Benchmark.{Hooks, Measure, RepeatedMeasurement, Scenario, ScenarioContext} @doc """ Executes the benchmarks defined before by first running the defined functions diff --git a/lib/benchee/configuration.ex b/lib/benchee/configuration.ex index c3b312a6..3681b842 100644 --- a/lib/benchee/configuration.ex +++ b/lib/benchee/configuration.ex @@ -3,13 +3,15 @@ defmodule Benchee.Configuration do Functions to handle the configuration of Benchee, exposes `init/1` function. """ + alias Benchee.Formatters.{Console, CSV, HTML, JSON} + alias Benchee.{ - Suite, Configuration, Conversion.Duration, Conversion.Scale, - Utility.DeepConvert, - Formatters.Console + Formatters.Console, + Suite, + Utility.DeepConvert } defstruct parallel: 1, @@ -53,7 +55,7 @@ defmodule Benchee.Configuration do pre_check: boolean, formatters: [(Suite.t() -> Suite.t())], print: map, - inputs: %{Suite.key() => any} | nil, + inputs: %{Suite.key() => any} | [{String.t(), any}] | nil, save: map | false, load: String.t() | [String.t()] | false, formatter_options: map, @@ -273,7 +275,7 @@ defmodule Benchee.Configuration do parallel: 2, time: 1_000_000_000.0, warmup: 200_000_000.0, - inputs: %{"Small" => 5, "Big" => 9999}, + inputs: [{"Big", 9999}, {"Small", 5}], save: false, load: false, formatters: [&IO.puts/1], @@ -319,7 +321,7 @@ defmodule Benchee.Configuration do defp standardized_user_configuration(config) do config - |> DeepConvert.to_map([:formatters]) + |> DeepConvert.to_map([:formatters, :inputs]) |> translate_formatter_keys |> force_string_input_keys end @@ -332,8 +334,6 @@ defmodule Benchee.Configuration do DeepMerge.deep_merge(%{formatter_options: formatter_options}, config) end - alias Benchee.Formatters.{Console, CSV, JSON, HTML} - # backwards compatible formatter definition without leaving the burden on every formatter defp formatter_options_to_tuples(config) do update_in(config, [Access.key(:formatters), Access.all()], fn @@ -355,9 +355,17 @@ defmodule Benchee.Configuration do defp force_string_input_keys(config = %{inputs: inputs}) do standardized_inputs = - for {name, value} <- inputs, into: %{} do - {to_string(name), value} - end + inputs + |> Enum.reduce([], fn {name, value}, acc -> + normalized_name = to_string(name) + + if List.keymember?(acc, normalized_name, 0) do + acc + else + [{normalized_name, value} | acc] + end + end) + |> Enum.reverse() %{config | inputs: standardized_inputs} end diff --git a/lib/benchee/conversion.ex b/lib/benchee/conversion.ex index ff6d9e5e..8d5fea0a 100644 --- a/lib/benchee/conversion.ex +++ b/lib/benchee/conversion.ex @@ -6,7 +6,7 @@ defmodule Benchee.Conversion do """ alias Benchee.Benchmark.Scenario - alias Benchee.Conversion.{Duration, Count, Memory} + alias Benchee.Conversion.{Count, Duration, Memory} @doc """ Takes scenarios and a given scaling_strategy, returns the best units for the diff --git a/lib/benchee/formatters/console.ex b/lib/benchee/formatters/console.ex index 652ec3d8..54df9a8d 100644 --- a/lib/benchee/formatters/console.ex +++ b/lib/benchee/formatters/console.ex @@ -70,7 +70,17 @@ defmodule Benchee.Formatters.Console do |> Map.merge(options) scenarios - |> Enum.group_by(fn scenario -> scenario.input_name end) + |> Enum.reduce([], fn scenario, grouped -> + case List.keyfind(grouped, scenario.input_name, 0) do + {_, group} -> + new_tuple = {scenario.input_name, [scenario | group]} + List.keyreplace(grouped, scenario.input_name, 0, new_tuple) + + _ -> + [{scenario.input_name, [scenario]} | grouped] + end + end) + |> Enum.reverse() |> Enum.map(fn {input, scenarios} -> scenarios |> Statistics.sort() diff --git a/lib/benchee/formatters/console/memory.ex b/lib/benchee/formatters/console/memory.ex index edc787a9..3baaa65c 100644 --- a/lib/benchee/formatters/console/memory.ex +++ b/lib/benchee/formatters/console/memory.ex @@ -9,9 +9,9 @@ defmodule Benchee.Formatters.Console.Memory do alias Benchee.{ Benchmark.Scenario, Conversion, - Conversion.Unit, Conversion.Count, Conversion.Memory, + Conversion.Unit, Formatters.Console.Helpers, Statistics } diff --git a/lib/benchee/formatters/console/run_time.ex b/lib/benchee/formatters/console/run_time.ex index d8602de0..dd8b6043 100644 --- a/lib/benchee/formatters/console/run_time.ex +++ b/lib/benchee/formatters/console/run_time.ex @@ -10,8 +10,8 @@ defmodule Benchee.Formatters.Console.RunTime do Benchmark.Scenario, Conversion, Conversion.Count, - Conversion.Unit, Conversion.Duration, + Conversion.Unit, Formatters.Console.Helpers, Statistics } diff --git a/lib/benchee/output/benchmark_printer.ex b/lib/benchee/output/benchmark_printer.ex index ee93ac15..b3816a8b 100644 --- a/lib/benchee/output/benchmark_printer.ex +++ b/lib/benchee/output/benchmark_printer.ex @@ -72,7 +72,7 @@ defmodule Benchee.Output.BenchmarkPrinter do defp inputs_out(inputs) do inputs - |> Map.keys() + |> Enum.map(fn {name, _} -> name end) |> Enum.join(", ") end diff --git a/mix.exs b/mix.exs index 7f228d08..5be64fd3 100644 --- a/mix.exs +++ b/mix.exs @@ -51,13 +51,12 @@ defmodule Benchee.Mixfile do [ {:deep_merge, "~> 0.1"}, {:ex_guard, "~> 1.3", only: :dev}, - {:credo, "< 0.9.3", only: :dev}, - # newer versions break in older elixirs + {:credo, "~> 1.0.0", only: :dev}, {:ex_doc, "~> 0.18.0", only: :dev}, {:earmark, "~> 1.0", only: :dev}, {:excoveralls, "~> 0.7", only: :test}, {:inch_ex, "~> 0.5", only: :docs}, - {:dialyxir, "~> 0.5", only: :dev, runtime: false} + {:dialyxir, "~> 1.0.0-rc.4", only: :dev, runtime: false} ] end diff --git a/mix.lock b/mix.lock index a349b475..e3879dd3 100644 --- a/mix.lock +++ b/mix.lock @@ -1,13 +1,14 @@ %{ "bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], [], "hexpm"}, "certifi": {:hex, :certifi, "2.4.2", "75424ff0f3baaccfd34b1214184b6ef616d89e420b258bb0a5ea7d7bc628f7f0", [:rebar3], [{:parse_trans, "~>3.3", [hex: :parse_trans, repo: "hexpm", optional: false]}], "hexpm"}, - "credo": {:hex, :credo, "0.9.2", "841d316612f568beb22ba310d816353dddf31c2d94aa488ae5a27bb53760d0bf", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:poison, ">= 0.0.0", [hex: :poison, repo: "hexpm", optional: false]}], "hexpm"}, + "credo": {:hex, :credo, "1.0.0", "aaa40fdd0543a0cf8080e8c5949d8c25f0a24e4fc8c1d83d06c388f5e5e0ea42", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"}, "deep_merge": {:hex, :deep_merge, "0.2.0", "c1050fa2edf4848b9f556fba1b75afc66608a4219659e3311d9c9427b5b680b3", [:mix], [], "hexpm"}, - "dialyxir": {:hex, :dialyxir, "0.5.1", "b331b091720fd93e878137add264bac4f644e1ddae07a70bf7062c7862c4b952", [:mix], [], "hexpm"}, - "earmark": {:hex, :earmark, "1.2.6", "b6da42b3831458d3ecc57314dff3051b080b9b2be88c2e5aa41cd642a5b044ed", [:mix], [], "hexpm"}, + "dialyxir": {:hex, :dialyxir, "1.0.0-rc.4", "71b42f5ee1b7628f3e3a6565f4617dfb02d127a0499ab3e72750455e986df001", [:mix], [{:erlex, "~> 0.1", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm"}, + "earmark": {:hex, :earmark, "1.3.0", "17f0c38eaafb4800f746b457313af4b2442a8c2405b49c645768680f900be603", [:mix], [], "hexpm"}, + "erlex": {:hex, :erlex, "0.1.6", "c01c889363168d3fdd23f4211647d8a34c0f9a21ec726762312e08e083f3d47e", [:mix], [], "hexpm"}, "ex_doc": {:hex, :ex_doc, "0.18.4", "4406b8891cecf1352f49975c6d554e62e4341ceb41b9338949077b0d4a97b949", [:mix], [{:earmark, "~> 1.1", [hex: :earmark, repo: "hexpm", optional: false]}], "hexpm"}, "ex_guard": {:hex, :ex_guard, "1.3.3", "941acb390979a1ef40ed0ef10d07035ce7d98b9d0089cecca132f9c0744ac620", [:mix], [{:fs, "~> 0.9", [hex: :fs, repo: "hexpm", optional: false]}], "hexpm"}, - "excoveralls": {:hex, :excoveralls, "0.10.2", "fb4abd5b8a1b9d52d35e1162e7e2ea8bfb84b47ae07c38d39aa8ce64be0b0794", [:mix], [{:hackney, "~> 1.13", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"}, + "excoveralls": {:hex, :excoveralls, "0.10.3", "b090a3fbcb3cfa136f0427d038c92a9051f840953ec11b40ee74d9d4eac04d1e", [:mix], [{:hackney, "~> 1.13", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm"}, "fs": {:hex, :fs, "0.9.2", "ed17036c26c3f70ac49781ed9220a50c36775c6ca2cf8182d123b6566e49ec59", [:rebar], [], "hexpm"}, "hackney": {:hex, :hackney, "1.14.3", "b5f6f5dcc4f1fba340762738759209e21914516df6be440d85772542d4a5e412", [:rebar3], [{:certifi, "2.4.2", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "6.0.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "1.0.1", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "1.0.2", [hex: :mimerl, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "1.1.4", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm"}, "idna": {:hex, :idna, "6.0.0", "689c46cbcdf3524c44d5f3dde8001f364cd7608a99556d8fbd8239a5798d4c10", [:rebar3], [{:unicode_util_compat, "0.4.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm"}, diff --git a/test/benchee/benchmark/runner_test.exs b/test/benchee/benchmark/runner_test.exs index 477ca8ab..13f8f9d5 100644 --- a/test/benchee/benchmark/runner_test.exs +++ b/test/benchee/benchmark/runner_test.exs @@ -1,9 +1,10 @@ defmodule Benchee.Benchmark.RunnerTest do use ExUnit.Case, async: true + import Benchee.TestHelpers import ExUnit.CaptureIO - alias Benchee.{Suite, Benchmark, Configuration} - alias Benchee.Benchmark.Scenario + + alias Benchee.{Benchmark, Benchmark.Scenario, Configuration, Suite} alias Benchee.Test.FakeBenchmarkPrinter, as: TestPrinter @config %Configuration{ diff --git a/test/benchee/benchmark_test.exs b/test/benchee/benchmark_test.exs index 70891048..1f66321f 100644 --- a/test/benchee/benchmark_test.exs +++ b/test/benchee/benchmark_test.exs @@ -1,11 +1,16 @@ defmodule Benchee.BenchmarkTest do use ExUnit.Case, async: true - alias Benchee.Benchmark - alias Benchee.Configuration - alias Benchee.Benchmark.{Scenario, ScenarioContext} + + alias Benchee.{ + Benchmark, + Benchmark.Scenario, + Benchmark.ScenarioContext, + Configuration, + Suite + } + alias Benchee.Test.FakeBenchmarkPrinter, as: TestPrinter alias Benchee.Test.FakeBenchmarkRunner, as: TestRunner - alias Benchee.Suite describe ".benchmark" do test "can add jobs with atom keys but converts them to string" do diff --git a/test/benchee/configuration_test.exs b/test/benchee/configuration_test.exs index 339a38ef..89c35c3a 100644 --- a/test/benchee/configuration_test.exs +++ b/test/benchee/configuration_test.exs @@ -9,26 +9,29 @@ defmodule Benchee.ConfigurationTest do @default_config %Configuration{} - describe ".init/1" do - test "it crashes for values that are going to be ignored" do + describe "init/1" do + test "crashes for values that are going to be ignored" do assert_raise KeyError, fn -> init(runntime: 2) end end - test "it converts input keys to strings" do + test "converts maps to lists and input keys to strings" do suite = init(inputs: %{"map" => %{}, list: []}) - assert %Suite{ - configuration: %{inputs: %{"list" => [], "map" => %{}}} - } = suite + assert %Suite{configuration: %{inputs: [{"list", []}, {"map", %{}}]}} = suite end - test "it loses duplicated inputs keys after normalization" do + test "doesn't convert input lists to maps" do + suite = init(inputs: [{"map", %{}}, {:list, []}]) + assert %Suite{configuration: %{inputs: [{"map", %{}}, {"list", []}]}} = suite + end + + test "loses duplicated inputs keys after normalization" do suite = init(inputs: %{"map" => %{}, map: %{}}) assert %Suite{configuration: %{inputs: inputs}} = suite - assert %{"map" => %{}} == inputs + assert [{"map", %{}}] == inputs end test "uses information from :save to setup the external term formattter" do diff --git a/test/benchee/formatter_test.exs b/test/benchee/formatter_test.exs index 00d0d4cb..371ba3b5 100644 --- a/test/benchee/formatter_test.exs +++ b/test/benchee/formatter_test.exs @@ -1,6 +1,6 @@ defmodule Benchee.FormatterTest do use ExUnit.Case, async: true - alias Benchee.{Suite, Formatter, Test.FakeFormatter} + alias Benchee.{Formatter, Suite, Test.FakeFormatter} describe "output/1" do test "calls `write/1` with the output of `format/1` on each module" do diff --git a/test/benchee/formatters/console/memory_test.exs b/test/benchee/formatters/console/memory_test.exs index 0273fdce..eaf1714c 100644 --- a/test/benchee/formatters/console/memory_test.exs +++ b/test/benchee/formatters/console/memory_test.exs @@ -2,7 +2,7 @@ defmodule Benchee.Formatters.Console.MemoryTest do use ExUnit.Case, async: true doctest Benchee.Formatters.Console.Memory - alias Benchee.{Formatters.Console.Memory, Statistics, Benchmark.Scenario} + alias Benchee.{Benchmark.Scenario, Formatters.Console.Memory, Statistics} @console_config %{ comparison: true, diff --git a/test/benchee/formatters/console/run_time_test.exs b/test/benchee/formatters/console/run_time_test.exs index faa9cc98..d55dd6a5 100644 --- a/test/benchee/formatters/console/run_time_test.exs +++ b/test/benchee/formatters/console/run_time_test.exs @@ -2,7 +2,7 @@ defmodule Benchee.Formatters.Console.RunTimeTest do use ExUnit.Case, async: true doctest Benchee.Formatters.Console.RunTime - alias Benchee.{Formatters.Console.RunTime, Statistics, Benchmark.Scenario} + alias Benchee.{Benchmark.Scenario, Formatters.Console.RunTime, Statistics} @console_config %{ comparison: true, diff --git a/test/benchee/formatters/console_test.exs b/test/benchee/formatters/console_test.exs index 1d9ab6f7..78bfe851 100644 --- a/test/benchee/formatters/console_test.exs +++ b/test/benchee/formatters/console_test.exs @@ -3,8 +3,7 @@ defmodule Benchee.Formatters.ConsoleTest do doctest Benchee.Formatters.Console import ExUnit.CaptureIO - alias Benchee.{Formatters.Console, Suite, Statistics, Benchmark.Scenario} - alias Benchee.Formatter + alias Benchee.{Benchmark.Scenario, Formatter, Formatters.Console, Statistics, Suite} @config %Benchee.Configuration{ title: "A comprehensive benchmarking of inputs" @@ -68,7 +67,7 @@ defmodule Benchee.Formatters.ConsoleTest do end end - describe ".format" do + describe "format/2" do @header_regex ~r/Name.+ips.+average.+deviation.+median.+99th %.*/ test "with multiple inputs and just one job" do scenarios = [ @@ -116,6 +115,52 @@ defmodule Benchee.Formatters.ConsoleTest do assert result_2 =~ ~r/Job.+2\.5.+400.+15\.00%.+395.+500\.1/ end + test "retains the order of scenarios" do + scenarios = [ + %Scenario{ + name: "Job", + input_name: "Other Arg", + input: "Other Arg", + run_time_statistics: %Statistics{ + average: 400.0, + ips: 2_500.0, + std_dev_ratio: 0.15, + median: 395.0, + percentiles: %{99 => 500.1}, + sample_size: 200 + }, + memory_usage_statistics: %Statistics{} + }, + %Scenario{ + name: "Job", + input_name: "My Arg", + input: "My Arg", + run_time_statistics: %Statistics{ + average: 200.0, + ips: 5_000.0, + std_dev_ratio: 0.1, + median: 195.5, + percentiles: %{99 => 400.1}, + sample_size: 200 + }, + memory_usage_statistics: %Statistics{} + } + ] + + [other_arg, my_arg] = + Console.format(%Suite{scenarios: scenarios, configuration: @config}, @options) + + [input_header, header, result] = my_arg + assert input_header =~ "My Arg" + assert header =~ @header_regex + assert result =~ ~r/Job.+5.+200.+10\.00%.+195\.5.+400\.1/ + + [input_header_2, header_2, result_2] = other_arg + assert input_header_2 =~ "Other Arg" + assert header_2 =~ @header_regex + assert result_2 =~ ~r/Job.+2\.5.+400.+15\.00%.+395.+500\.1/ + end + test "with multiple inputs and two jobs" do scenarios = [ %Scenario{ diff --git a/test/benchee/formatters/tagged_save_test.exs b/test/benchee/formatters/tagged_save_test.exs index c08f855e..848b257a 100644 --- a/test/benchee/formatters/tagged_save_test.exs +++ b/test/benchee/formatters/tagged_save_test.exs @@ -1,12 +1,15 @@ defmodule Benchee.Formatters.TaggedSaveTest do use ExUnit.Case - alias Benchee.{Suite, Statistics} - alias Benchee.Benchmark.Scenario - alias Benchee.Formatter - alias Benchee.Formatters.TaggedSave + alias Benchee.{ + Benchmark.Scenario, + Formatter, + Formatters.TaggedSave, + Statistics, + Suite + } - import Benchee.Formatters.TaggedSave + import TaggedSave import Benchee.Benchmark, only: [no_input: 0] import ExUnit.CaptureIO import Benchee.TestHelpers, only: [suite_without_scenario_tags: 1] diff --git a/test/benchee/output/benchmark_printer_test.exs b/test/benchee/output/benchmark_printer_test.exs index 43c91818..56a9e550 100644 --- a/test/benchee/output/benchmark_printer_test.exs +++ b/test/benchee/output/benchmark_printer_test.exs @@ -1,10 +1,10 @@ defmodule Benchee.Output.BenchmarkPrintertest do use ExUnit.Case, async: true + + alias Benchee.{Benchmark, Benchmark.Scenario, Configuration} + import ExUnit.CaptureIO import Benchee.Output.BenchmarkPrinter - alias Benchee.Benchmark.Scenario - alias Benchee.Benchmark - alias Benchee.Configuration @system_info %{ elixir: "1.4", diff --git a/test/benchee/scenario_loader_test.exs b/test/benchee/scenario_loader_test.exs index b2039eba..27484633 100644 --- a/test/benchee/scenario_loader_test.exs +++ b/test/benchee/scenario_loader_test.exs @@ -1,8 +1,7 @@ defmodule Benchee.ScenarioLoaderTest do use ExUnit.Case import Benchee.ScenarioLoader - alias Benchee.{Suite, Configuration} - alias Benchee.Benchmark.{Scenario} + alias Benchee.{Benchmark.Scenario, Configuration, Suite} test "`load` indeed loads scenarios into the suite" do scenarios = [%Scenario{tag: "old"}] diff --git a/test/benchee/statistics_test.exs b/test/benchee/statistics_test.exs index e024e7e2..4e3140e7 100644 --- a/test/benchee/statistics_test.exs +++ b/test/benchee/statistics_test.exs @@ -1,6 +1,6 @@ defmodule Benchee.StatistcsTest do use ExUnit.Case, async: true - alias Benchee.{Statistics, Suite, Benchmark.Scenario, Configuration} + alias Benchee.{Benchmark.Scenario, Configuration, Statistics, Suite} doctest Benchee.Statistics @sample_1 [600, 470, 170, 430, 300] diff --git a/test/benchee_test.exs b/test/benchee_test.exs index 6fe693df..c34e1e92 100644 --- a/test/benchee_test.exs +++ b/test/benchee_test.exs @@ -1,13 +1,17 @@ defmodule BencheeTest do use ExUnit.Case, async: true + + alias Benchee.{ + Conversion.Duration, + Formatter, + Formatters.Console, + Statistics, + Suite, + Test.FakeFormatter + } + import ExUnit.CaptureIO import Benchee.TestHelpers - alias Benchee.Test.FakeFormatter - alias Benchee.Statistics - alias Benchee.Formatter - alias Benchee.Formatters.Console - alias Benchee.Suite - alias Benchee.Conversion.Duration doctest Benchee @@ -418,6 +422,35 @@ defmodule BencheeTest do assert length(occurences) == 3 end + test "inputs can also be a list of 2-tuples" do + output = + capture_io(fn -> + map_fun = fn i -> [i, i * i] end + + inputs = [ + inputs: [ + {"small list", Enum.to_list(1..100)}, + {"medium list", Enum.to_list(1..1_000)}, + {"bigger list", Enum.to_list(1..10_000)} + ] + ] + + configuration = Keyword.merge(@test_configuration, inputs) + + Benchee.run( + %{ + "flat_map" => fn input -> Enum.flat_map(input, map_fun) end, + "map.flatten" => fn input -> input |> Enum.map(map_fun) |> List.flatten() end + }, + configuration + ) + end) + + assert String.contains?(output, ["small list", "medium list", "bigger list"]) + occurences = Regex.scan(body_regex("flat_map"), output) + assert length(occurences) == 3 + end + test "multiple inputs with very fast functions" do output = capture_io(fn -> From 4708dade1a2273bdb820641e8efa91777c2257a9 Mon Sep 17 00:00:00 2001 From: Devon Estes Date: Fri, 23 Nov 2018 15:06:07 +0100 Subject: [PATCH 2/2] Remove all deprecated functionality This is probably what will end up being released as 1.0! I did this first so I knew what I needed to go back and deprecate by looking at the diff. I'm gonna tack on another commit with that stuff and open a separate PR (which, funny enough, we'll probably merge first). --- lib/benchee.ex | 40 +++++-------- lib/benchee/benchmark.ex | 16 +---- lib/benchee/configuration.ex | 71 ++-------------------- lib/benchee/formatter.ex | 37 +++++++----- test/benchee/configuration_test.exs | 92 ++++++++--------------------- test/benchee_test.exs | 21 +------ 6 files changed, 71 insertions(+), 206 deletions(-) diff --git a/lib/benchee.ex b/lib/benchee.ex index b73e4467..d576d702 100644 --- a/lib/benchee.ex +++ b/lib/benchee.ex @@ -20,35 +20,27 @@ for {module, moduledoc} <- [{Benchee, elixir_doc}, {:benchee, erlang_doc}] do alias Benchee.Formatter @doc """ - Run benchmark jobs defined by a map and optionally provide configuration - options. + Runs the given benchmarks, calculates statistics based on the results and + outputs results with the configured formatters. - Runs the given benchmarks and prints the results on the console. - - * jobs - a map from descriptive benchmark job name to a function to be - executed and benchmarked - * configuration - configuration options to alter what Benchee does, see - `Benchee.Configuration.init/1` for documentation of the available options. + Benchmarks are defined as a map where the keys are a name for the given + function and the values are the functions to benchmark. Users can configure + the run by passing a keyword list as the second argument. For more + information on configuration see `Benchee.Configuration.init/1`. ## Examples - Benchee.run(%{"My Benchmark" => fn -> 1 + 1 end, - "My other benchmrk" => fn -> "1" ++ "1" end}, time: 3) - # Prints a summary of the benchmark to the console - + Benchee.run( + %{ + "My Benchmark" => fn -> 1 + 1 end, + "My other benchmrk" => fn -> [1] ++ [1] end + }, + warmup: 2, + time: 3 + ) """ - def run(jobs, config \\ []) - - def run(jobs, config) when is_list(config) do - do_run(jobs, config) - end - - def run(config, jobs) when is_map(jobs) do - # pre 0.6.0 way of passing in the config first and as a map - do_run(jobs, config) - end - - defp do_run(jobs, config) do + @spec run(map, keyword) :: any + def run(jobs, config \\ []) when is_list(config) do config |> Benchee.init() |> Benchee.system() diff --git a/lib/benchee/benchmark.ex b/lib/benchee/benchmark.ex index 1871fb4b..7ed18410 100644 --- a/lib/benchee/benchmark.ex +++ b/lib/benchee/benchmark.ex @@ -6,8 +6,7 @@ defmodule Benchee.Benchmark do alias Benchee.Benchmark.{Runner, Scenario, ScenarioContext} alias Benchee.Output.BenchmarkPrinter, as: Printer - alias Benchee.Suite - alias Benchee.Utility.DeepConvert + alias Benchee.{Suite, Utility.DeepConvert} @type job_name :: String.t() | atom @no_input :__no_input @@ -48,19 +47,6 @@ defmodule Benchee.Benchmark do %Suite{suite | scenarios: List.flatten([scenarios | new_scenarios])} end - defp build_scenarios_for_job(job_name, function, config) - - defp build_scenarios_for_job(job_name, function, nil) do - [ - build_scenario(%{ - job_name: job_name, - function: function, - input: @no_input, - input_name: @no_input - }) - ] - end - defp build_scenarios_for_job(job_name, function, %{inputs: nil}) do [ build_scenario(%{ diff --git a/lib/benchee/configuration.ex b/lib/benchee/configuration.ex index 3681b842..1694dcba 100644 --- a/lib/benchee/configuration.ex +++ b/lib/benchee/configuration.ex @@ -3,8 +3,6 @@ defmodule Benchee.Configuration do Functions to handle the configuration of Benchee, exposes `init/1` function. """ - alias Benchee.Formatters.{Console, CSV, HTML, JSON} - alias Benchee.{ Configuration, Conversion.Duration, @@ -19,7 +17,7 @@ defmodule Benchee.Configuration do warmup: 2, memory_time: 0.0, pre_check: false, - formatters: [Console], + formatters: [{Console, %{comparison: true, extended_statistics: false}}], percentiles: [50, 99], print: %{ benchmarking: true, @@ -29,16 +27,7 @@ defmodule Benchee.Configuration do inputs: nil, save: false, load: false, - # formatters should end up here but known once are still picked up at - # the top level for now - formatter_options: %{ - console: %{ - comparison: true, - extended_statistics: false - } - }, unit_scaling: :best, - # If you/your plugin/whatever needs it your data can go here assigns: %{}, before_each: nil, after_each: nil, @@ -53,12 +42,11 @@ defmodule Benchee.Configuration do warmup: number, memory_time: number, pre_check: boolean, - formatters: [(Suite.t() -> Suite.t())], + formatters: [(Suite.t() -> Suite.t()) | {atom, map}], print: map, inputs: %{Suite.key() => any} | [{String.t(), any}] | nil, save: map | false, load: String.t() | [String.t()] | false, - formatter_options: map, unit_scaling: Scale.scaling_strategy(), assigns: map, before_each: fun | nil, @@ -265,9 +253,7 @@ defmodule Benchee.Configuration do ...> warmup: 0.2, ...> formatters: [&IO.puts/1], ...> print: [fast_warning: false], - ...> console: [comparison: false], ...> inputs: %{"Small" => 5, "Big" => 9999}, - ...> formatter_options: [some: "option"], ...> unit_scaling: :smallest) %Benchee.Suite{ configuration: @@ -284,13 +270,6 @@ defmodule Benchee.Configuration do fast_warning: false, configuration: true }, - formatter_options: %{ - console: %{ - comparison: false, - extended_statistics: false - }, - some: "option" - }, percentiles: [50, 99], unit_scaling: :smallest, assigns: %{}, @@ -311,7 +290,6 @@ defmodule Benchee.Configuration do config |> standardized_user_configuration |> merge_with_defaults - |> formatter_options_to_tuples |> convert_time_to_nano_s |> update_measure_memory |> save_option_conversion @@ -322,37 +300,9 @@ defmodule Benchee.Configuration do defp standardized_user_configuration(config) do config |> DeepConvert.to_map([:formatters, :inputs]) - |> translate_formatter_keys |> force_string_input_keys end - # backwards compatible translation of formatter keys to go into - # formatter_options now - @formatter_keys [:console, :csv, :json, :html] - defp translate_formatter_keys(config) do - {formatter_options, config} = Map.split(config, @formatter_keys) - DeepMerge.deep_merge(%{formatter_options: formatter_options}, config) - end - - # backwards compatible formatter definition without leaving the burden on every formatter - defp formatter_options_to_tuples(config) do - update_in(config, [Access.key(:formatters), Access.all()], fn - Console -> formatter_configuration_from_options(config, Console, :console) - CSV -> formatter_configuration_from_options(config, CSV, :csv) - JSON -> formatter_configuration_from_options(config, JSON, :json) - HTML -> formatter_configuration_from_options(config, HTML, :html) - formatter -> formatter - end) - end - - defp formatter_configuration_from_options(config, module, legacy_option_key) do - if Map.has_key?(config.formatter_options, legacy_option_key) do - {module, config.formatter_options[legacy_option_key]} - else - module - end - end - defp force_string_input_keys(config = %{inputs: inputs}) do standardized_inputs = inputs @@ -408,22 +358,13 @@ defmodule Benchee.Configuration do """) end - defp save_option_conversion(config = %{save: false}) do - config - end + defp save_option_conversion(config = %{save: false}), do: config defp save_option_conversion(config = %{save: save_values}) do save_options = Map.merge(save_defaults(), save_values) - - tagged_save_options = %{ - tag: save_options.tag, - path: save_options.path - } - - %__MODULE__{ - config - | formatters: config.formatters ++ [{Benchee.Formatters.TaggedSave, tagged_save_options}] - } + tagged_save_options = %{tag: save_options.tag, path: save_options.path} + formatters = config.formatters ++ [{Benchee.Formatters.TaggedSave, tagged_save_options}] + %__MODULE__{config | formatters: formatters} end defp save_defaults do diff --git a/lib/benchee/formatter.ex b/lib/benchee/formatter.ex index 8ff483fe..6e3e756c 100644 --- a/lib/benchee/formatter.ex +++ b/lib/benchee/formatter.ex @@ -32,8 +32,6 @@ defmodule Benchee.Formatter do """ @callback write(any, options) :: :ok | {:error, String.t()} - @typep module_configuration :: module | {module, options} - @doc """ Format and output all configured formatters and formatting functions. @@ -54,7 +52,7 @@ defmodule Benchee.Formatter do {parallelizable, serial} = formatters |> Enum.map(&normalize_module_configuration/1) - |> Enum.split_with(&is_formatter_module?/1) + |> Enum.split_with(&is_tuple/1) # why do we ignore this suite? It shouldn't be changed anyway. # We assign it because dialyzer would complain otherwise :D @@ -65,25 +63,37 @@ defmodule Benchee.Formatter do suite end - @default_opts %{} - defp normalize_module_configuration(module_configuration) - defp normalize_module_configuration({module, opts}), do: {module, DeepConvert.to_map(opts)} + defp normalize_module_configuration(formatter) when is_function(formatter, 1), do: formatter - defp normalize_module_configuration(formatter) when is_atom(formatter) do - {formatter, @default_opts} + defp normalize_module_configuration({module, opts}) do + normalize_module_configuration(module, DeepConvert.to_map(opts)) end - defp normalize_module_configuration(formatter), do: formatter + defp normalize_module_configuration(module) when is_atom(module) do + normalize_module_configuration(module, %{}) + end - defp is_formatter_module?({formatter, _options}) when is_atom(formatter) do - module_attributes = formatter.module_info(:attributes) + defp normalize_module_configuration(module, opts) do + if formatter_module?(module) do + {module, opts} + else + raise_behaviour_not_implemented(module) + end + end - module_attributes + defp formatter_module?(module) do + :attributes + |> module.module_info() |> Keyword.get(:behaviour, []) |> Enum.member?(Benchee.Formatter) end - defp is_formatter_module?(_), do: false + defp raise_behaviour_not_implemented(module) do + raise """ + The module you're attempting to use as a formatter - #{module} - does + not implement the `Benchee.Formatter` behaviour. + """ + end @doc """ Output a suite with a given formatter and options. @@ -105,7 +115,6 @@ defmodule Benchee.Formatter do # Invokes `format/2` and `write/2` as defined by the `Benchee.Formatter` # behaviour. The output for all formatters is generated in parallel, and then # the results of that formatting are written in sequence. - @spec parallel_output(Suite.t(), [module_configuration]) :: Suite.t() defp parallel_output(suite, module_configurations) do module_configurations |> Parallel.map(fn {module, options} -> {module, options, module.format(suite, options)} end) diff --git a/test/benchee/configuration_test.exs b/test/benchee/configuration_test.exs index 89c35c3a..40cf9b08 100644 --- a/test/benchee/configuration_test.exs +++ b/test/benchee/configuration_test.exs @@ -11,104 +11,58 @@ defmodule Benchee.ConfigurationTest do describe "init/1" do test "crashes for values that are going to be ignored" do - assert_raise KeyError, fn -> - init(runntime: 2) - end + assert_raise KeyError, fn -> init(runntime: 2) end end test "converts maps to lists and input keys to strings" do - suite = init(inputs: %{"map" => %{}, list: []}) - - assert %Suite{configuration: %{inputs: [{"list", []}, {"map", %{}}]}} = suite + assert %Suite{configuration: %{inputs: [{"list", []}, {"map", %{}}]}} = + init(inputs: %{"map" => %{}, list: []}) end - test "doesn't convert input lists to maps" do - suite = init(inputs: [{"map", %{}}, {:list, []}]) - assert %Suite{configuration: %{inputs: [{"map", %{}}, {"list", []}]}} = suite + test "doesn't convert input lists to maps and retains the order of input lists" do + assert %Suite{configuration: %{inputs: [{"map", %{}}, {"list", []}]}} = + init(inputs: [{"map", %{}}, {:list, []}]) end test "loses duplicated inputs keys after normalization" do - suite = init(inputs: %{"map" => %{}, map: %{}}) - - assert %Suite{configuration: %{inputs: inputs}} = suite - assert [{"map", %{}}] == inputs + assert %Suite{configuration: %{inputs: [{"map", %{}}]}} = + init(inputs: %{"map" => %{}, map: %{}}) end test "uses information from :save to setup the external term formattter" do - suite = init(save: [path: "save_one.benchee", tag: "master"]) - - assert suite.configuration.formatters == [ - {Benchee.Formatters.Console, %{comparison: true, extended_statistics: false}}, - {Benchee.Formatters.TaggedSave, %{path: "save_one.benchee", tag: "master"}} - ] + assert %Suite{ + configuration: %{ + formatters: [ + {Benchee.Formatters.Console, %{comparison: true, extended_statistics: false}}, + {Benchee.Formatters.TaggedSave, %{path: "save_one.benchee", tag: "master"}} + ] + } + } = init(save: [path: "save_one.benchee", tag: "master"]) end test ":save tag defaults to date" do - suite = init(save: [path: "save_one.benchee"]) - - [_, {_, etf_options}] = suite.configuration.formatters - - assert etf_options.tag =~ ~r/\d\d\d\d-\d\d?-\d\d?--\d\d?-\d\d?-\d\d?/ - assert etf_options.path == "save_one.benchee" - end - - test "takes formatter_options to build tuple list" do - suite = - init( - formatter_options: %{console: %{foo: :bar}}, - formatters: [Benchee.Formatters.Console] - ) - - assert [{Benchee.Formatters.Console, %{foo: :bar}}] = suite.configuration.formatters - end - - test "formatters already specified as a tuple are left alone" do - suite = - init( - formatter_options: %{console: %{foo: :bar}}, - formatters: [{Benchee.Formatters.Console, %{a: :b}}] - ) - - assert [{Benchee.Formatters.Console, %{a: :b}}] == suite.configuration.formatters - end - - test "legacy formatter options default to just the module if no options are given" do - suite = init(formatters: [Benchee.Formatter.CSV]) + assert %Suite{configuration: %{formatters: [_, {_, %{tag: tag, path: "save_one.benchee"}}]}} = + init(save: [path: "save_one.benchee"]) - assert [Benchee.Formatter.CSV] == suite.configuration.formatters + assert tag =~ ~r/\d\d\d\d-\d\d?-\d\d?--\d\d?-\d\d?-\d\d?/ end end describe ".deep_merge behaviour" do test "it can be adjusted with a map" do - user_options = %{ - time: 10, - formatter_options: %{ - custom: %{option: true}, - console: %{extended_statistics: true} - } - } + user_options = %{time: 10} result = deep_merge(@default_config, user_options) - expected = %Configuration{ - time: 10, - formatter_options: %{ - custom: %{option: true}, - console: %{ - comparison: true, - extended_statistics: true - } - } - } + expected = %Configuration{time: 10} assert expected == result end test "it just replaces when given another configuration" do - other_config = %Configuration{formatter_options: %{some: %{value: true}}} + other_config = %Configuration{} result = deep_merge(@default_config, other_config) - expected = %Configuration{formatter_options: %{some: %{value: true}}} + expected = %Configuration{} assert ^expected = result end diff --git a/test/benchee_test.exs b/test/benchee_test.exs index c34e1e92..99593b98 100644 --- a/test/benchee_test.exs +++ b/test/benchee_test.exs @@ -79,23 +79,6 @@ defmodule BencheeTest do assert Regex.match?(body_regex("Magic"), output) end - test "integration high level README example old school map config" do - output = - capture_io(fn -> - list = Enum.to_list(1..10_000) - map_fun = fn i -> [i, i * i] end - - map_config = Enum.into(@test_configuration, %{}) - - Benchee.run(map_config, %{ - "flat_map" => fn -> Enum.flat_map(list, map_fun) end, - "map.flatten" => fn -> list |> Enum.map(map_fun) |> List.flatten() end - }) - end) - - readme_sample_asserts(output) - end - test "integration high level README example but with formatter options" do output = capture_io(fn -> @@ -233,7 +216,7 @@ defmodule BencheeTest do @test_configuration, time: 0.01, warmup: 0, - console: [comparison: false] + formatters: [{Console, %{comparison: false}}] ) ) end) @@ -281,7 +264,7 @@ defmodule BencheeTest do readme_sample_asserts(output) end - test "formatters can be supplied with the Formatter.output/3 function" do + test "formatters can be supplied as a function with arity 1" do output = capture_io(fn -> list = Enum.to_list(1..10_000)