func (s *DiegoScheduler) createTaskTaskInfo(slaveId *mesos.SlaveID, taskAuction *auctiontypes.TaskAuction) *mesos.TaskInfo {
	work, _ := json.Marshal(rep.Work{LRPs: []rep.LRP{}, Tasks: []rep.Task{taskAuction.Task}})
	taskId := mesos.TaskID{Value: proto.String(taskAuction.Identifier())}
	taskInfo := mesos.TaskInfo{
		Name:     proto.String(taskAuction.Identifier()),
		TaskId:   &taskId,
		SlaveId:  slaveId,
		Executor: s.executor,
		Resources: []*mesos.Resource{
			util.NewScalarResource("cpus", taskCpuAllocation),
			util.NewScalarResource("mem", float64(taskAuction.MemoryMB)),
			util.NewScalarResource("disk", float64(taskAuction.DiskMB)),
		},
		Data: work,
	}
	return &taskInfo
}

func (s *Scheduler) scheduleTaskAuction(taskAuction *auctiontypes.TaskAuction, startingContainerWeight float64) (*auctiontypes.TaskAuction, error) {
	var winnerCell *Cell
	winnerScore := 1e20

	filteredZones := []Zone{}

	for _, zone := range s.zones {
		cells := zone.FilterCells(taskAuction.RootFs)
		if len(cells) > 0 {
			filteredZones = append(filteredZones, Zone(cells))
		}
	}

	if len(filteredZones) == 0 {
		return nil, auctiontypes.ErrorCellMismatch
	}

	for _, zone := range filteredZones {
		for _, cell := range zone {
			score, err := cell.ScoreForTask(&taskAuction.Task, startingContainerWeight)
			if err != nil {
				continue
			}

			if score < winnerScore {
				winnerScore = score
				winnerCell = cell
			}
		}
	}

	if winnerCell == nil {
		return nil, rep.ErrorInsufficientResources
	}

	err := winnerCell.ReserveTask(&taskAuction.Task)
	if err != nil {
		s.logger.Error("task-failed-to-reserve-cell", err, lager.Data{"cell-guid": winnerCell.Guid, "task-guid": taskAuction.Identifier()})
		return nil, err
	}

	winningAuction := taskAuction.Copy()
	winningAuction.Winner = winnerCell.Guid
	return &winningAuction, nil
}

func matchTaskAuction(offerAggregates [][]*mesos.Offer, taskAuction *auctiontypes.TaskAuction) (int, []*mesos.Offer) {
	taskAuction.Attempts++
	for i, offers := range offerAggregates {
		if getOffersMem(offers) > float64(taskAuction.MemoryMB) &&
			getOffersCpu(offers) > taskCpuAllocation &&
			getOffersDisk(offers) > float64(taskAuction.DiskMB) {
			taskAuction.Winner = offers[0].SlaveId.GetValue()
			taskAuction.WaitDuration = time.Now().Sub(taskAuction.QueueTime)
			offers[0].Resources = append(offers[0].Resources,
				util.NewScalarResource("mem", float64(-taskAuction.MemoryMB)),
				util.NewScalarResource("cpu", -taskCpuAllocation),
				util.NewScalarResource("disk", float64(-taskAuction.DiskMB)))
			return i, offers
		}
	}
	taskAuction.PlacementError = rep.ErrorInsufficientResources.Error()
	return -1, nil
}

			It("should not attempt to start the LRP", func() {
				Expect(clients["A-cell"].PerformCallCount()).To(Equal(0))
				Expect(clients["B-cell"].PerformCallCount()).To(Equal(0))
			})

			It("should mark the start auction as failed", func() {
				startAuction.Attempts = 1
				Expect(results.SuccessfulLRPs).To(BeEmpty())
				Expect(results.FailedLRPs).To(ConsistOf(startAuction))
			})
		})
	})

	Describe("handling task auctions", func() {
		var taskAuction auctiontypes.TaskAuction

		BeforeEach(func() {
			clients["A-cell"] = &repfakes.FakeSimClient{}
			zones["A-zone"] = auctionrunner.Zone{auctionrunner.NewCell(logger, "A-cell", clients["A-cell"], BuildCellState("A-zone", 100, 100, 100, false, linuxOnlyRootFSProviders, []rep.LRP{
				*BuildLRP("does-not-matter", "domain", 0, "", 10, 10),
				*BuildLRP("does-not-matter", "domain", 0, "", 10, 10),
			}))}

			clients["B-cell"] = &repfakes.FakeSimClient{}
			zones["B-zone"] = auctionrunner.Zone{auctionrunner.NewCell(logger, "B-cell", clients["B-cell"], BuildCellState("B-zone", 100, 100, 100, false, linuxOnlyRootFSProviders, []rep.LRP{
				*BuildLRP("does-not-matter", "domain", 0, "", 10, 10),
			}))}

			taskAuction = BuildTaskAuction(BuildTask("tg-1", "domain", linuxRootFSURL, 10, 10), clock.Now())
			clock.Increment(time.Minute)