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];
}
