       if (unquote(default_worker)) do
         defmodule Worker do
           use Noizu.SimplePool.WorkerBehaviour, unquote(worker_options)
-          def tests() do
-            :ok
-          end
         end
       end
 
       if (unquote(default_server)) do
         defmodule Server do
           use Noizu.SimplePool.ServerBehaviour, unquote(server_options)
-          def lazy_load(state) do
-            IO.puts "#{__MODULE__}.lazy_load Default"
-            state
-          end
+          def lazy_load(state), do: state
         end
       end
 

defmodule Noizu.SimplePool.Behaviour do
  @callback nmid_seed() :: {integer, integer}
  @callback lookup_table() :: atom
  @callback book_keeping_init() :: {{integer, integer}, integer}
  @callback generate_nmid(Noizu.SimplePool.Server.State.t) :: {integer, Noizu.SimplePool.Server.State.t}

  def map_intersect(list, subset) do
    List.foldl(
      list,
      %{},
      fn(entry, acc) ->
        Map.put(acc, entry, Enum.member?(subset, entry))
      end
    )
  end

  def simple_nmid({node, process}, sequence) do
    # node < 100,  0-99
    # process < 10000, 100-9999
    _nmid = (node + (process * 100) + (sequence * 1000000))
  end

  defmacro __using__(options) do
    defaults = Keyword.get(options, :defaults, [])
    default_worker = Enum.member?(defaults, :worker)
    default_server = Enum.member?(defaults, :server)
    default_worker_supervisor = Enum.member?(defaults, :worker_supervisor)
    default_pool_supervisor = Enum.member?(defaults, :pool_supervisor)

    # @TODO standardize around override/only logic.
    disable = Keyword.get(options, :disable, [])
    disable_lookup_table = Enum.member?(disable, :lookup_table)
    disable_book_keeping_init = Enum.member?(disable, :book_keeping_init)
    disable_generate_nmid = Enum.member?(disable, :generate_nmid)
    global_verbose = Keyword.get(options, :verbose, false)
    module_verbose = Keyword.get(options, :base_verbose, false)

    # @TODO copy/merge any key global options and set in worker/supervisor option set if not overriden.
    worker_options = Keyword.get(options, :worker_options, [])
      |> Keyword.put(:verbose, global_verbose)
    server_options = Keyword.get(options, :server_options, [])
      |> Keyword.put(:verbose, global_verbose)
    worker_supervisor_options = Keyword.get(options, :worker_supervisor_options, [])
      |> Keyword.put(:verbose, global_verbose)
    pool_supervisor_options = Keyword.get(options, :pool_supervisor_options, [])
      |> Keyword.put(:verbose, global_verbose)

    nmid_table = Keyword.get(options, :nmid_table)
    if nmid_table == nil && !disable_generate_nmid do
       raise "NMID_TABLE must be set to environments NMID Generator Table"
    end

    quote do
      require Amnesia

      require Amnesia.Helper
      import unquote(__MODULE__)
      @behaviour Noizu.SimplePool.Behaviour

      def nmid_seed(), do: {nil, nil}

      if (!unquote(disable_lookup_table)) do
        @lookup_table Module.concat([__MODULE__, "LookupTable"])
