def _resolve_ordered_output_ports(self, output_list, resolve_port_cb, resolve_tunnel_objects):
        """Resolve output actions in the ordered list format"""
        result = []
        for action in output_list:
            for key, value in action.items():
                if key == 'tunnel':
                    tunnel = value
                    # Fetch tunnel items from the tunnel output dict
                    test_config_condition(
                        'dp' not in tunnel,
                        'ACL (%s) tunnel DP not defined' % self._id)
                    tunnel_dp = tunnel['dp']
                    tunnel_port = tunnel.get('port', None)
                    tunnel_id = tunnel.get('tunnel_id', None)
                    tunnel_type = tunnel.get('type', 'vlan')
                    tunnel_exit_instructions = tunnel.get('exit_instructions', [])
                    tunnel_direction = tunnel.get('bi_directional', False)
                    tunnel_maintain = tunnel.get('maintain_encapsulation', False)
                    tunnel_reverse = tunnel.get('reverse', False)
                    test_config_condition(
                        tunnel_reverse and tunnel_direction,
                        ('Tunnel ACL %s cannot contain values for the fields'
                         '`bi_directional` and `reverse` at the same time' % self._id))
                    # Resolve the tunnel items
                    dst_dp, dst_port, tunnel_id = resolve_tunnel_objects(
                        tunnel_dp, tunnel_port, tunnel_id)
                    # Compile the tunnel into an easy-access dictionary
                    tunnel_dict = {
                        'dst_dp': dst_dp,
                        'dst_port': dst_port,
                        'tunnel_id': tunnel_id,
                        'type': tunnel_type,
                        'exit_instructions': tunnel_exit_instructions,
                        'bi_directional': tunnel_direction,
                        'maintain_encapsulation': tunnel_maintain,
                        'reverse': tunnel_reverse,
                    }
                    self.tunnel_dests[tunnel_id] = tunnel_dict
                    result.append({key: tunnel_id})
                elif key == 'port':
                    port_name = value
                    port = resolve_port_cb(port_name)
                    test_config_condition(
                        not port,
                        'ACL (%s) output port undefined in DP: %s' % (self._id, self.dp_id))
                    result.append({key: port})
                elif key == 'ports':
                    resolved_ports = [
                        resolve_port_cb(p) for p in value]
                    test_config_condition(
                        None in resolved_ports,
                        'ACL (%s) output port(s) not defined in DP: %s' % (self._id, self.dp_id))
                    result.append({key: resolved_ports})
                elif key == 'failover':
                    failover = value
                    test_config_condition(not isinstance(failover, dict), (
                        'failover is not a dictionary'))
                    failover_dict = {}
                    for failover_name, failover_values in failover.items():
                        if failover_name == 'ports':
                            resolved_ports = [
                                resolve_port_cb(p) for p in failover_values]
                            test_config_condition(
                                None in resolved_ports,
                                'ACL (%s) failover port(s) not defined in DP: %s' % (
                                    self._id, self.dp_id))
                            failover_dict[failover_name] = resolved_ports
                        else:
                            failover_dict[failover_name] = failover_values
                    result.append({key: failover_dict})
                else:
                    result.append(action)
        return result