code: def validate_spec(cls, spec, backends=None):
          
          loaded_backends =  Store.loaded_backends() if backends is None else backends
  
          error_info     = {}
          backend_errors = defaultdict(set)
          for backend in loaded_backends:
              cls.start_recording_skipped()
              with options_policy(skip_invalid=True, warn_on_skip=False):
                  options = OptionTree(items=Store.options(backend).data.items(),
                                       groups=Store.options(backend).groups)
                  cls.apply_customizations(spec, options)
  
              for error in cls.stop_recording_skipped():
                  error_key = (error.invalid_keyword,
                               error.allowed_keywords.target,
                               error.group_name)
                  error_info[error_key+(backend,)] = error.allowed_keywords
                  backend_errors[error_key].add(backend)
  
  
          for ((keyword, target, group_name), backends) in backend_errors.items():
              # If the keyword failed for the target across all loaded backends...
              if set(backends) == set(loaded_backends):
                  key = (keyword, target, group_name, Store.current_backend)
                  raise OptionError(keyword,
                                    group_name=group_name,
                                    allowed_keywords=error_info[key])
docs: Given a specification, validated it against the options tree for
          the specified backends by raising OptionError for invalid
          options. If backends is None, validates against all the
          currently loaded backend.
  
          Only useful when invalid keywords generate exceptions instead of
          skipping i.e Options.skip_invalid is False.