public async SystemTasks.Task TestCustomLogger() { CustomLogger logger = new CustomLogger(); Configuration config = Configuration.Create().WithVerbosityEnabled(); ICoyoteRuntime runtime = RuntimeFactory.Create(config); runtime.SetLogger(logger); Generator generator = Generator.Create(); Task task = Task.Run(() => { int result = generator.NextInteger(10); logger.WriteLine($"Task '{Task.CurrentId}' completed with result '{result}'."); }); await task; string expected = @"<RandomLog> Task '' nondeterministically chose ''. Task '' completed with result ''."; string actual = RemoveNonDeterministicValuesFromReport(logger.ToString()); Assert.Equal(expected, actual); logger.Dispose(); }
public static async Task ConcurrentAlbumCreates(ICoyoteRuntime runtime) { var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond WA"; var billingAddress = "101 100th Ave NE Redmond WA"; var albumName = "myAlbum"; var storageProvider = new AzureStorageProvider("Test", new Logger("Test")); var userController = new UserController(); var createResult = await userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress); Assert(createResult.Success); CheckUser(createResult.Response); Assert(!await storageProvider.DoesAccountExits(userName)); var galleryController = new GalleryController(); var createAlbumTask1 = galleryController.CreateAlbum(userName, albumName); var createAlbumTask2 = galleryController.CreateAlbum(userName, albumName); await Task.WhenAll(createAlbumTask1, createAlbumTask2); Assert(createAlbumTask1.Result.Success ^ createAlbumTask2.Result.Success); Assert(await storageProvider.DoesAccountExits(userName)); Assert(await storageProvider.DoesContainerExist(userName, albumName)); var album = createAlbumTask1.Result.Success ? createAlbumTask1.Result.Response : createAlbumTask2.Result.Response; CheckAlbum(album); }
public static async Task ConcurrentUserUpdates(ICoyoteRuntime runtime) { var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond WA"; var billingAddress = "101 100th Ave NE Redmond WA"; var userController = new UserController(); var createResult = await userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress); Assert(createResult.Success); var mailingAddressUpdate1 = "132 102nd Ave SE Seattle, WA"; var billingAddressUpdate1 = "132 102nd Ave SE Seattle, WA"; var mailingAddressUpdate2 = "126 105th Ave NE Los Angeles, CA"; var billingAddressUpdate2 = "126 105th Ave NE Los Angeles, CA"; var updateTask1 = userController.UpdateUserAddress(userName, mailingAddressUpdate1, billingAddressUpdate1); var updateTask2 = userController.UpdateUserAddress(userName, mailingAddressUpdate2, billingAddressUpdate2); Task.WaitAll(updateTask1, updateTask2); Assert(updateTask1.Result.Success && updateTask2.Result.Success); var user = await userController.GetUser(userName); Assert((user.Response.Address.MailingAddress == mailingAddressUpdate1 && user.Response.Address.BillingAddress == billingAddressUpdate1) || (user.Response.Address.MailingAddress == mailingAddressUpdate2 && user.Response.Address.BillingAddress == billingAddressUpdate2)); }
public static async Task ConcurrentUserDeletes(ICoyoteRuntime runtime) { var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond WA"; var billingAddress = "101 100th Ave NE Redmond WA"; var userController = new UserController(); var createResult = await userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress); Assert(createResult.Success); var deleteTask1 = userController.DeleteUser(userName); var deleteTask2 = userController.DeleteUser(userName); Task.WaitAll(deleteTask1, deleteTask2); Assert(deleteTask1.Result.Success ^ deleteTask2.Result.Success); var successfulObject = deleteTask1.Result.Success ? deleteTask1.Result.Response : deleteTask2.Result.Response; CheckUser(successfulObject); }
public static async Task Execute(ICoyoteRuntime runtime) { runtime.OnFailure += OnRuntimeFailure; Specification.RegisterMonitor <LivenessMonitor>(); IFailoverDriver driver = new FailoverDriver(RunForever, runtime.Logger); await driver.RunTest(); }
public static void TestBoundedBufferFindDeadlockConfiguration(ICoyoteRuntime runtime) { CheckRewritten(); var random = Microsoft.Coyote.Random.Generator.Create(); int bufferSize = random.NextInteger(5) + 1; int readers = random.NextInteger(5) + 1; int writers = random.NextInteger(5) + 1; int iterations = random.NextInteger(10) + 1; int totalIterations = iterations * readers; int writerIterations = totalIterations / writers; int remainder = totalIterations % writers; runtime.Logger.WriteLine(LogSeverity.Important, "Testing buffer size {0}, reader={1}, writer={2}, iterations={3}", bufferSize, readers, writers, iterations); BoundedBuffer buffer = new BoundedBuffer(bufferSize); var tasks = new List <Task>(); for (int i = 0; i < readers; i++) { tasks.Add(Task.Run(() => Reader(buffer, iterations))); } int x = 0; for (int i = 0; i < writers; i++) { int w = writerIterations + ((i == (writers - 1)) ? remainder : 0); x += w; tasks.Add(Task.Run(() => Writer(buffer, w))); } Microsoft.Coyote.Specifications.Specification.Assert(x == totalIterations, "total writer iterations doesn't match!"); Task.WaitAll(tasks.ToArray()); }
public static async Task ConcurrentPictureCreates(ICoyoteRuntime runtime) { var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond WA"; var billingAddress = "101 100th Ave NE Redmond WA"; var albumName = "myAlbum"; var pictureName = "pic.jpg"; var pictureContents = "0x2321"; var userController = new UserController(); var createResult = await userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress); Assert(createResult.Success); var galleryController = new GalleryController(); var createAlbumResult = await galleryController.CreateAlbum(userName, albumName); Assert(createAlbumResult.Success); CheckAlbum(createAlbumResult.Response); var pictureCreateTask1 = galleryController.UploadPicture(userName, albumName, pictureName, pictureContents); var pictureCreateTask2 = galleryController.UploadPicture(userName, albumName, pictureName, pictureContents); await Task.WhenAll(pictureCreateTask1, pictureCreateTask2); Assert(pictureCreateTask1.Result.Success ^ pictureCreateTask2.Result.Success); var picture = pictureCreateTask1.Result.Success ? pictureCreateTask1.Result.Response : pictureCreateTask2.Result.Response; CheckPicture(picture); }
public static void Main() { RunForever = true; ICoyoteRuntime runtime = RuntimeProvider.Create(); _ = Execute(runtime); Console.ReadLine(); Console.WriteLine("User cancelled the test by pressing ENTER"); }
public static void TestBoundedBufferMinimalDeadlock(ICoyoteRuntime runtime) { BoundedBuffer buffer = new BoundedBuffer(1, runtime); var tasks = new List <Task>() { Task.Run(() => Reader(buffer, 5)), Task.Run(() => Reader(buffer, 5)), Task.Run(() => Writer(buffer, 10)) }; Task.WaitAll(tasks.ToArray()); }
public static async Task UserControllerConcurrencyFuzzing(ICoyoteRuntime runtime) { const int transacriptLength = 4; var controller = new UserController(); var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond, WA"; var billingAddress = "101 100th Ave NE Redmond, WA"; var userTasks = new List <Task <ActionResult <User> > >(); var addressTasks = new List <Task <ActionResult <Address> > >(); for (int i = 0; i < transacriptLength; i++) { var choice = runtime.RandomInteger(transacriptLength); switch (choice) { case 0: userTasks.Add(controller.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress)); break; case 1: addressTasks.Add(controller.UpdateUserAddress(userName, mailingAddress, billingAddress)); break; case 2: userTasks.Add(controller.DeleteUser(userName)); break; case 3: userTasks.Add(controller.GetUser(userName)); break; } } var tasks = new List <Task>(); tasks.AddRange(userTasks); tasks.AddRange(addressTasks); await Task.WhenAll(tasks); userTasks.ForEach(t => CheckUserTaskResult(t)); addressTasks.ForEach(t => CheckAddressTaskResult(t)); }
private async Task RunAsync(ICoyoteRuntime r) { await Task.Run(async() => { r.Logger.WriteLine($"Task '{Task.CurrentId}' is running."); await Task.Delay(0); r.Logger.WriteLine($"Task '{Task.CurrentId}' completed."); }); await Task.Run(async() => { r.Logger.WriteLine($"Task '{Task.CurrentId}' is running."); await Task.Delay(0); r.Logger.WriteLine($"Task '{Task.CurrentId}' completed."); }); Specification.Assert(false, "Reached test assertion."); }
public static async Task Execute_TwoReadersAndWriters(ICoyoteRuntime runtime) { Action <string> log = s => runtime.Logger.WriteLine(s); var numConsumerProducer = 2; log($"Testing Queue with {numConsumerProducer} consumers and producers"); var queue = new CoyoteAsyncQueue <int>(numConsumerProducer + 1, new InterestingEvents()); var tasks = new List <Task>() { Task.Run(() => Writer(queue, Enumerable.Range(1, 10), "Task1")), Task.Run(() => Writer(queue, Enumerable.Range(10, 20), "Task2")), Task.Run(() => Reader(queue, "Task3")), Task.Run(() => Reader(queue, "Task4")), }; await Task.WhenAll(tasks.ToArray()); }
public static async Task ConcurrentAlbumDeletes(ICoyoteRuntime runtime) { var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond WA"; var billingAddress = "101 100th Ave NE Redmond WA"; var albumName = "myAlbum"; var storageProvider = new AzureStorageProvider("Test", new Logger("Test")); var userController = new UserController(); var createResult = await userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress); Assert(createResult.Success); CheckUser(createResult.Response); Assert(!await storageProvider.DoesAccountExits(userName)); var galleryController = new GalleryController(); var createAlbumResult = await galleryController.CreateAlbum(userName, albumName); Assert(createAlbumResult.Success); CheckAlbum(createAlbumResult.Response); Assert(await storageProvider.DoesAccountExits(userName)); var albumDeleteTask1 = galleryController.DeleteAlbum(userName, albumName); var albumDeleteTask2 = galleryController.DeleteAlbum(userName, albumName); await Task.WhenAll(albumDeleteTask1, albumDeleteTask2); Assert(albumDeleteTask1.Result.Success ^ albumDeleteTask2.Result.Success); var album = albumDeleteTask1.Result.Success ? albumDeleteTask1.Result.Response : albumDeleteTask2.Result.Response; CheckAlbum(album); // Assert that even though the album has been deleted the storage account is still there // as it should only be deleted when the user is deleted Assert(await storageProvider.DoesAccountExits(userName)); }
public static async Task ConcurrentUserCreates(ICoyoteRuntime runtime) { var userController = new UserController(); var info = new Dictionary <string, User>(); info["1"] = new User("user1", "*****@*****.**", "425-123-1234", "Address 1", "Address 1"); info["2"] = new User("user1", "*****@*****.**", "425-987-9876", "Address 2", "Address 2"); var result = new Dictionary <string, Task <ActionResult <User> > >(); result["1"] = userController.CreateUser( info["1"].UserName, info["1"].EmailAddress, info["1"].PhoneNumber, info["1"].Address.MailingAddress, info["1"].Address.BillingAddress); result["2"] = userController.CreateUser( info["2"].UserName, info["2"].EmailAddress, info["2"].PhoneNumber, info["2"].Address.MailingAddress, info["2"].Address.BillingAddress); Task.WaitAll(result.Values.ToArray()); Assert(result["1"].Result.Success ^ result["2"].Result.Success); var successfulIndex = result["1"].Result.Success ? "1" : "2"; var user = (await userController.GetUser(result[successfulIndex].Result.Response.UserName)).Response; Assert(user.EmailAddress == info[successfulIndex].EmailAddress); Assert(user.PhoneNumber == info[successfulIndex].PhoneNumber); Assert(user.Address.MailingAddress == info[successfulIndex].Address.MailingAddress); Assert(user.Address.BillingAddress == info[successfulIndex].Address.BillingAddress); }
public static async Task Execute_TenReadersAndWriters(ICoyoteRuntime runtime) { Action <string> log = s => runtime.Logger.WriteLine(s); var generator = Generator.Create(); var numConsumerProducer = generator.NextInteger(10) + 1; var numConsumers = numConsumerProducer; var numProducers = numConsumerProducer; log($"Testing Queue with {numConsumerProducer} consumers and producers"); var queue = new CoyoteAsyncQueue <int>(numConsumerProducer, new InterestingEvents()); var tasks = Chop(RandomStream(generator, 100), numProducers) .Select((x, i) => { var t = Task.Run(() => Writer(queue, x, $"Task{i}")); i++; return(t); }) .ToList(); for (int i = 0; i < numProducers; i++) { tasks.Add(Task.Run(() => Reader(queue, ""))); } await Task.WhenAll(tasks.ToArray()); }
private async Task RunAsync(ICoyoteRuntime r) { SharedEntry entry = new SharedEntry(); Task task1 = Task.Run(async() => { r.Logger.WriteLine($"Task '{Task.CurrentId}' is running."); await Task.Delay(10); r.Logger.WriteLine($"Task '{Task.CurrentId}' completed."); }); await task1; Task task2 = Task.Run(async() => { r.Logger.WriteLine($"Task '{Task.CurrentId}' is running."); await Task.Delay(10); r.Logger.WriteLine($"Task '{Task.CurrentId}' completed."); }); await task2; Specification.Assert(false, "Reached test assertion."); }
public static async SystemTasks.Task SystemAsyncTaskTestWithRuntime(ICoyoteRuntime runtime) { Assert.NotNull(runtime); await SystemTasks.Task.CompletedTask; }
public static void VoidTestWithRuntime(ICoyoteRuntime runtime) => Assert.NotNull(runtime);
public static async Task DeleteWithConcurrentAPIs(ICoyoteRuntime runtime) { var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond WA"; var billingAddress = "101 100th Ave NE Redmond WA"; var albumName = "myAlbum"; var pictureName = "pic.jpg"; var pictureContents = "0x2321"; var userController = new UserController(); var galleryController = new GalleryController(); var logger = new Logger("DeleteWithConcurrentAPIs"); var db = new DatabaseProvider("Test", logger); var storage = new AzureStorageProvider("Test", logger); var createResult = await userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress); Assert(createResult.Success); Assert(createResult.Response.UserName == userName && createResult.Response.EmailAddress == emailAddress); var doc = await db.GetDocument(Constants.UserCollection, userName); Assert(doc[Constants.EmailAddress] == emailAddress); var tasks = new List <Task>(); // We start the delete operation, along with a number of concurrenct APIs in the background // which should not interfere with the invariant we check at the end of the delete operation var deleteResultTask = userController.DeleteUser(userName); tasks.Add(deleteResultTask); const int transcriptLength = 7; for (int i = 0; i < transcriptLength; i++) { var choice = runtime.RandomInteger(transcriptLength); switch (choice) { case 0: tasks.Add(userController.UpdateUserAddress(userName, mailingAddress, billingAddress)); break; case 1: tasks.Add(userController.GetUser(userName)); break; case 2: tasks.Add(galleryController.CreateAlbum(userName, albumName)); break; case 3: tasks.Add(galleryController.DeleteAlbum(userName, albumName)); break; case 4: tasks.Add(galleryController.UploadPicture(userName, albumName, pictureName, pictureContents)); break; case 5: tasks.Add(galleryController.RetrievePicture(userName, albumName, pictureName)); break; case 6: tasks.Add(galleryController.DeletePicture(userName, albumName, pictureName)); break; } } Task.WaitAll(tasks.ToArray()); var deleteResult = deleteResultTask.Result; Assert(deleteResult.Success); Assert(!await db.DoesDocumentExist(Constants.UserCollection, userName)); Assert(!await storage.DoesAccountExits(doc[Constants.UniqueId])); }
public static async Task GalleryServiceConcurrencyFuzzing(ICoyoteRuntime runtime) { const int transacriptLength = 9; var userController = new UserController(); var galleryController = new GalleryController(); var userName = "******"; var emailAddress = "*****@*****.**"; var phoneNumber = "425-123-1234"; var mailingAddress = "101 100th Ave NE Redmond, WA"; var billingAddress = "101 100th Ave NE Redmond, WA"; var albumName = "Holiday"; var pictureName = "Beach.jpg"; var pictureContent = "923bac12"; var userTasks = new List <Task <ActionResult <User> > >(); var addressTasks = new List <Task <ActionResult <Address> > >(); var albumTasks = new List <Task <ActionResult <Album> > >(); var pictureTasks = new List <Task <ActionResult <Picture> > >(); for (int i = 0; i < transacriptLength; i++) { var choice = runtime.RandomInteger(transacriptLength); switch (choice) { case 0: userTasks.Add(userController.CreateUser(userName, emailAddress, phoneNumber, mailingAddress, billingAddress)); break; case 1: addressTasks.Add(userController.UpdateUserAddress(userName, mailingAddress, billingAddress)); break; case 2: userTasks.Add(userController.DeleteUser(userName)); break; case 3: userTasks.Add(userController.GetUser(userName)); break; case 4: albumTasks.Add(galleryController.CreateAlbum(userName, albumName)); break; case 5: albumTasks.Add(galleryController.DeleteAlbum(userName, albumName)); break; case 6: pictureTasks.Add(galleryController.UploadPicture(userName, albumName, pictureName, pictureContent)); break; case 7: pictureTasks.Add(galleryController.DeletePicture(userName, albumName, pictureName)); break; case 8: pictureTasks.Add(galleryController.RetrievePicture(userName, albumName, pictureName)); break; } } var tasks = new List <Task>(); tasks.AddRange(userTasks); tasks.AddRange(addressTasks); tasks.AddRange(albumTasks); tasks.AddRange(pictureTasks); await Task.WhenAll(tasks.ToArray()); userTasks.ForEach(t => CheckUserTaskResult(t)); addressTasks.ForEach(t => CheckAddressTaskResult(t)); albumTasks.ForEach(t => CheckAlbumTaskResult(t)); pictureTasks.ForEach(t => CheckPictureTaskResult(t)); }
public HomeController(ILogger <HomeController> logger, ICoyoteRuntime runtime) { _logger = logger; this.Runtime = runtime.Runtime; }
public static CoyoteTasks.Task CoyoteTaskTestWithRuntime(ICoyoteRuntime runtime) { Assert.NotNull(runtime); return(CoyoteTasks.Task.CompletedTask); }
public static async CoyoteTasks.Task CoyoteAsyncTaskTestWithRuntime(ICoyoteRuntime runtime) { Assert.NotNull(runtime); await CoyoteTasks.Task.CompletedTask; }
public BoundedBuffer(int bufferSize, ICoyoteRuntime runtime) { this.Runtime = runtime; this.Buffer = new object[bufferSize]; }