code: def _resolve_requirements(self, requirements):
          
          try:
              dut_count = requirements["duts"]["*"]["count"]
          except KeyError:
              return []
  
          default_values = {
              "type": "hardware",
              "allowed_platforms": [],
              "nick": None,
          }
  
          default_values.update(requirements["duts"]["*"])
          del default_values["count"]
          dut_keys = list(default_values.keys())
          dut_keys.extend(["application", "location", "subtype"])
  
          dut_requirements = self.__generate_indexed_requirements(dut_count,
                                                                  default_values,
                                                                  requirements)
  
          # Match groups of duts defined with 1..40 notation.
          for key in requirements["duts"].keys():
              if not isinstance(key, string_types):
                  continue
              match = re.search(r'([\d]{1,})\.\.([\d]{1,})', key)
              if match:
                  first_dut_idx = int(match.group(1))
                  last_dut_idx = int(match.group(2))
                  for i in range(first_dut_idx, last_dut_idx+1):
                      for k in dut_keys:
                          if k in requirements["duts"][key]:
                              dut_requirements[i-1].set(k, copy.copy(requirements["duts"][key][k]))
  
          for idx, req in enumerate(dut_requirements):
  
              if isinstance(req.get("nick"), string_types):
                  nick = req.get("nick")
                  req.set("nick", ResourceConfig.__replace_base_variables(nick,
                                                                          len(dut_requirements),
                                                                          idx))
              self._solve_location(req, len(dut_requirements), idx)
          self._dut_requirements = dut_requirements
          return None
docs: Internal method for resolving requirements into resource configurations.
  
          :param requirements: Resource requirements from test case configuration as dictionary.
          :return: Empty list if dut_count cannot be resolved, or nothing