   Prints a notice which job is currently being benchmarked.
   """
   def benchmarking(_, _, %{print: %{benchmarking: false}}), do: nil
+
   def benchmarking(name, input_name, _config) do
-    IO.puts "Benchmarking #{name}#{input_information(input_name)}..."
+    IO.puts("Benchmarking #{name}#{input_information(input_name)}...")
   end
 
-  @no_input Benchmark.no_input
-  defp input_information(@no_input),  do: ""
+  @no_input Benchmark.no_input()
+  defp input_information(@no_input), do: ""
   defp input_information(input_name), do: " with input #{input_name}"
 
   @doc """
   Prints a warning about accuracy of benchmarks when the function is super fast.
   """
   def fast_warning do
-    IO.puts """
+    IO.puts("""
     Warning: The function you are trying to benchmark is super fast, making measurements more unreliable!
     This holds especially true for memory measurements.
     See: https://github.com/PragTob/benchee/wiki/Benchee-Warnings#fast-execution-warning
 
     You may disable this warning by passing print: [fast_warning: false] as configuration options.
-    """
+    """)
   end
 end

    inputs: #{inputs_out(inputs)}
    Estimated total run time: #{Duration.format(total_time)}

    """
  end

  defp inputs_out(nil), do: "none specified"
  defp inputs_out(inputs) do
    inputs
    |> Map.keys
    |> Enum.join(", ")
  end


  def configuration_information(%{configuration: %{print: %{configuration: false}}}) do
    nil
  end

  def configuration_information(%{scenarios: scenarios, system: sys, configuration: config}) do
    system_information(sys)
    suite_information(scenarios, config)
  end

  defp system_information(%{
         erlang: erlang_version,
         elixir: elixir_version,
         os: os,
         num_cores: num_cores,
         cpu_speed: cpu_speed,
         available_memory: available_memory
       }) do
    IO.puts("""
    Operating System: #{os}"
    CPU Information: #{cpu_speed}
    Number of Available Cores: #{num_cores}
    Available memory: #{available_memory}
    Elixir #{elixir_version}
    Erlang #{erlang_version}
    """)
  end

  defp suite_information(scenarios, %{
         parallel: parallel,
         time: time,
         warmup: warmup,
         inputs: inputs,
         memory_time: memory_time
       }) do
    scenario_count = length(scenarios)
    exec_time = warmup + time + memory_time
    total_time = scenario_count * exec_time

    IO.puts("""
    Benchmark suite executing with the following configuration:
    warmup: #{Duration.format(warmup)}
    time: #{Duration.format(time)}
