@@ -658,7 +658,7 @@ private boolean processVmCreateResponseFromDatacenter(final SimEvent evt) {
                     vmWaitingList.remove(vm);
                     vmFailedList.add(vm);
                     LOGGER.warn(
-                        "{}: {}: {} has been moved to the failed list because creation retry is not enabled.",
+                        "{}: {}: {} has been moved to the failed list because creation retry is disabled or the max number of retries was reached.",
                         getSimulation().clockStr(), getName(), vm);
                 }
 
@@ -715,7 +715,7 @@ private void notifyOnVmsCreatedListeners() {
      */
     private void requestCreationOfWaitingVmsToFallbackDatacenter() {
         this.lastSelectedDc = Datacenter.NULL;
-        if (vmWaitingList.isEmpty() || requestDatacenterToCreateWaitingVms(false, true)) {
+        if (vmWaitingList.isEmpty() || requestDatacenterToCreateWaitingVms(true, false)) {
             return;
         }
 
@@ -756,33 +756,37 @@ private void processVmCreationFailure() {
      * @param isFallbackDatacenter true to indicate that a fallback Datacenter will be tried,
      *                             after the previous one was not able to create all waiting VMs;
      *                             false to indicate it will try the default datacenter.
-     * @return true if some Datacenter was selected; false if all Datacenter were tried
-     *         and not all VMs could be created
+     * @param creationRetry true to indicate it's a retry to create failed VMs
+     *                      (which enables trying again Datacenters already tried before), false otherwise
+     * @return true if some VM creation request was sent to a Datacenter;
+     *         false if all Datacenters were tried and not all VMs could be created
      * @see #submitVmList(java.util.List)
      */
     private boolean requestDatacenterToCreateWaitingVms(final boolean isFallbackDatacenter, final boolean creationRetry) {
         if(vmWaitingList.isEmpty())
             return false;
 
+        int sentRequests = 0;
         for (final var vm : vmWaitingList) {
             if(creationRetry) {
                 vm.setLastTriedDatacenter(Datacenter.NULL);
             }
 
             if(!batchVmCreation) {
                 this.lastSelectedDc = getLastSelectedDc(isFallbackDatacenter, vm);
-                vmCreation.incCreationRequests(requestSingleVmCreation(lastSelectedDc, isFallbackDatacenter, vm));
+                sentRequests += requestSingleVmCreation(lastSelectedDc, isFallbackDatacenter, vm);
             }
         }
 
         //Sends a single VM creation request to the first selected DC for a List of Vms
         if(batchVmCreation) {
             //In batch VM creation, sends all VMs to the same DC selected for the first VM
             this.lastSelectedDc = getLastSelectedDc(isFallbackDatacenter, vmWaitingList.get(0));
-            vmCreation.incCreationRequests(requestVmCreation(lastSelectedDc, isFallbackDatacenter, vmWaitingList));
+            sentRequests += requestVmCreation(lastSelectedDc, isFallbackDatacenter, vmWaitingList);
         }
 
-        return lastSelectedDc != Datacenter.NULL;
+        vmCreation.incCreationRequests(sentRequests);
+        return sentRequests > 0;
     }
 
     private Datacenter getLastSelectedDc(final boolean isFallbackDatacenter, final Vm vm) {
 
@@ -0,0 +1,131 @@
+/*
+ * CloudSim Plus: A modern, highly-extensible and easier-to-use Framework for
+ * Modeling and Simulation of Cloud Computing Infrastructures and Services.
+ * http://cloudsimplus.org
+ *
+ *     Copyright (C) 2015-2021 Universidade da Beira Interior (UBI, Portugal) and
+ *     the Instituto Federal de Educação Ciência e Tecnologia do Tocantins (IFTO, Brazil).
+ *
+ *     This file is part of CloudSim Plus.
+ *
+ *     CloudSim Plus is free software: you can redistribute it and/or modify
+ *     it under the terms of the GNU General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ *
+ *     CloudSim Plus is distributed in the hope that it will be useful,
+ *     but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *     GNU General Public License for more details.
+ *
+ *     You should have received a copy of the GNU General Public License
+ *     along with CloudSim Plus. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.cloudsimplus.integrationtests;
+
+import org.cloudsimplus.brokers.DatacenterBroker;
+import org.cloudsimplus.brokers.DatacenterBrokerSimple;
+import org.cloudsimplus.cloudlets.Cloudlet;
+import org.cloudsimplus.cloudlets.CloudletSimple;
+import org.cloudsimplus.core.CloudSimPlus;
+import org.cloudsimplus.datacenters.DatacenterSimple;
+import org.cloudsimplus.hosts.Host;
+import org.cloudsimplus.hosts.HostSimple;
+import org.cloudsimplus.resources.Pe;
+import org.cloudsimplus.resources.PeSimple;
+import org.cloudsimplus.vms.Vm;
+import org.cloudsimplus.vms.VmSimple;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * An Integration Test (IT) to check that a VM that can't be placed in
+ * the only existing Datacenter is retried just the maximum number of times
+ * defined in the broker's {@link org.cloudsimplus.brokers.VmCreation},
+ * instead of being retried forever.
+ *
+ * @see <a href="https://github.com/cloudsimplus/cloudsimplus-examples/issues/31">Issue #31 in the examples repository</a>
+ */
+final class VmCreationRetryIntegrationTest {
+    private static final int TIMEOUT_SECS = 10;
+    private static final int HOST_PES = 4;
+    private static final int VM_PES = HOST_PES;
+    private static final int MIPS = 1000;
+    private static final int VMS = 2;
+    private static final int CLOUDLET_LENGTH = 10_000;
+    private static final int MAX_RETRIES = 3;
+    private static final double RETRY_DELAY = 5;
+
+    private CloudSimPlus simulation;
+    private DatacenterBroker broker;
+    private Vm failedVm;
+    private AtomicInteger creationFailures;
+
+    @BeforeEach
+    void setUp() {
+        simulation = new CloudSimPlus();
+        new DatacenterSimple(simulation, List.of(createHost()));
+        broker = new DatacenterBrokerSimple(simulation);
+        creationFailures = new AtomicInteger();
+
+        final var vmList = createVms();
+        failedVm = vmList.getLast();
+        failedVm.addOnCreationFailureListener(evt -> creationFailures.incrementAndGet());
+        broker.submitVmList(vmList);
+        broker.submitCloudletList(List.of(createCloudlet(vmList.getFirst())));
+    }
+
+    @Test
+    @Timeout(value = TIMEOUT_SECS, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
+    void retriesFailedVmUpToMaxRetries() {
+        broker.getVmCreation().setRetryDelay(RETRY_DELAY).setMaxRetries(MAX_RETRIES);
+        simulation.start();
+
+        //The first creation attempt plus all retries
+        assertEquals(MAX_RETRIES + 1, creationFailures.get());
+        assertTrue(broker.getVmFailedList().contains(failedVm));
+    }
+
+    @Test
+    @Timeout(value = TIMEOUT_SECS, threadMode = Timeout.ThreadMode.SEPARATE_THREAD)
+    void doesNotRetryFailedVmWhenRetryIsDisabled() {
+        broker.getVmCreation().setRetryDelay(-1);
+        simulation.start();
+
+        assertEquals(1, creationFailures.get());
+        assertTrue(broker.getVmFailedList().contains(failedVm));
+    }
+
+    private static Host createHost() {
+        final var peList = new ArrayList<Pe>(HOST_PES);
+        for (int i = 0; i < HOST_PES; i++) {
+            peList.add(new PeSimple(MIPS));
+        }
+
+        return new HostSimple(peList);
+    }
+
+    /**
+     * Creates VMs that require all Host PEs, so that only the first one can be placed.
+     */
+    private static List<Vm> createVms() {
+        final var vmList = new ArrayList<Vm>(VMS);
+        for (int i = 0; i < VMS; i++) {
+            vmList.add(new VmSimple(MIPS, VM_PES));
+        }
+
+        return vmList;
+    }
+
+    private static Cloudlet createCloudlet(final Vm vm) {
+        return new CloudletSimple(CLOUDLET_LENGTH, 1).setVm(vm);
+    }
+}