def _to_rows(self, header, items):
        rows = []
        if trove_utils.is_collection(items):
            if any(trove_utils.is_collection(item) for item in items):
                # This is multi-row property.
                for item in items:
                    rows.extend(self._to_rows(header, item))
            else:
                # This is a single-row property with multiple arguments.
                rows.append(self._to_list(header, self._string_converter.to_strings(items)))
        else:
            # This is a single-row property with only one argument.
            rows.append(self._to_list(header, items))

        return rows

 def assert_instance_action(
         self, instance_ids, expected_states, expected_http_code):
     self.assert_client_code(expected_http_code)
     if expected_states:
         self.assert_all_instance_states(
             instance_ids if utils.is_collection(instance_ids)
             else [instance_ids], expected_states)

 def assert_delete_instances(self, instance_ids, expected_http_code):
     instance_ids = (instance_ids if utils.is_collection(instance_ids)
                     else [instance_ids])
     client = self.auth_client
     for instance_id in instance_ids:
         client.instances.delete(instance_id)
         self.assert_client_code(client, expected_http_code)

 def append_option_group(opt_group, cmd_opts):
     for name, value in opt_group.items():
         if utils.is_collection(value):
             for item in value:
                 append_option(name, item, cmd_opts)
         else:
             append_option(name, value, cmd_opts)

    def to_objects(self, items):
        """Recursively convert collection string to objects.

        :returns:        Copy of the input collection with all items converted.
        """
        if trove_utils.is_collection(items):
            return map(self.to_objects, items)

        return self._to_object(items)

    def assert_delete_instances(
            self, instance_ids, expected_last_state, expected_http_code):
        instance_ids = (instance_ids if utils.is_collection(instance_ids)
                        else [instance_ids])
        for instance_id in instance_ids:
            self.auth_client.instances.delete(instance_id)
            self.assert_client_code(expected_http_code)

        self.assert_all_gone(instance_ids, expected_last_state)

    def _to_list(self, *items):
        container = []
        for item in items:
            if trove_utils.is_collection(item):
                # This item is a nested collection - unpack it.
                container.extend(self._to_list(*item))
            else:
                # This item is not a collection - append it to the list.
                container.append(item)

        return container

 def assert_all_gone(self, instance_ids, expected_last_status):
     self._wait_all_deleted(instance_ids
                            if utils.is_collection(instance_ids)
                            else [instance_ids], expected_last_status)

 def assert_instance_action(self, instance_ids, expected_states):
     if expected_states:
         self.assert_all_instance_states(
             instance_ids if utils.is_collection(instance_ids)
             else [instance_ids], expected_states)

 def add_inst_ids(mcs, inst_ids):
     if not utils.is_collection(inst_ids):
         inst_ids = [inst_ids]
     debug_inst_ids = mcs.get_inst_ids()
     debug_inst_ids |= set(inst_ids)
     mcs._data['inst_ids'] = debug_inst_ids