func (s *Scheduler) scheduleLRPAuction(lrpAuction *auctiontypes.LRPAuction) (*auctiontypes.LRPAuction, error) {
	var winnerCell *Cell
	winnerScore := 1e20

	zones := accumulateZonesByInstances(s.zones, lrpAuction.ProcessGuid)

	filteredZones := filterZonesByRootFS(zones, lrpAuction.RootFs)

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

	sortedZones := sortZonesByInstances(filteredZones)

	for zoneIndex, lrpByZone := range sortedZones {
		for _, cell := range lrpByZone.zone {
			score, err := cell.ScoreForLRP(&lrpAuction.LRP, s.startingContainerWeight)
			if err != nil {
				continue
			}

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

		// if (not last zone) && (this zone has the same # of instances as the next sorted zone)
		// acts as a tie breaker
		if zoneIndex+1 < len(sortedZones) &&
			lrpByZone.instances == sortedZones[zoneIndex+1].instances {
			continue
		}

		if winnerCell != nil {
			break
		}
	}

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

	err := winnerCell.ReserveLRP(&lrpAuction.LRP)
	if err != nil {
		s.logger.Error("lrp-failed-to-reserve-cell", err, lager.Data{"cell-guid": winnerCell.Guid, "lrp-guid": lrpAuction.Identifier()})
		return nil, err
	}

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

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

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

			failedLRPStart := results.FailedLRPs[0]
			Expect(failedLRPStart.Identifier()).To(Equal(startAuction.Identifier()))
			Expect(failedLRPStart.Attempts).To(Equal(startAuction.Attempts + 1))
			Expect(failedLRPStart.PlacementError).To(Equal(auctiontypes.ErrorCellMismatch.Error()))

			By("all tasks are marked failed, and their attempts are incremented")
			Expect(results.FailedTasks).To(HaveLen(1))
			failedTask := results.FailedTasks[0]
			Expect(failedTask.Identifier()).To(Equal(taskAuction.Identifier()))
			Expect(failedTask.Attempts).To(Equal(taskAuction.Attempts + 1))
			Expect(failedLRPStart.PlacementError).To(Equal(auctiontypes.ErrorCellMismatch.Error()))
		})
	})

	Describe("handling start auctions", func() {
		var startAuction auctiontypes.LRPAuction

		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("pg-1", "domain", 0, "", 10, 10),
						*BuildLRP("pg-2", "domain", 0, "", 10, 10),
					}),
				),
			}