public async void GameMasterStarts()
{
// Arrange
var source = new CancellationTokenSource();
string url = "http://127.0.0.1:3005";
string[] args = new string[] { $"urls={url}", "CsPort=1" };
var webhost = Utilities.CreateHostBuilder(typeof(GameMaster.Startup), args).
ConfigureServices(serv => serv.AddSingleton(MockGenerator.Get <ILogger>())).
Build();
hosts.Add(webhost);
// Act
await webhost.StartAsync(source.Token);
HttpResponseMessage response;
using (var client = new HttpClient())
{
client.BaseAddress = new Uri($"{url}");
response = await client.PostAsync("api/InitGame", null);
}
await Task.Delay(500);
source.Cancel();
// Assert
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
var gameMaster = webhost.Services.GetService <GameMaster.Models.GM>();
Assert.False(gameMaster == null, "GameMaster should not be null");
Assert.True(gameMaster.WasGameInitialized, "Game should be initialized");
}
public void UninstallOldPackageFails_HandleGracefully()
{
var oldPackage = new MockPackage();
var package = new MockPackage {
Version = new SemanticVersion("2.0")
};
var mockRepository = new MockPackageRepository();
mockRepository.AddPackage(oldPackage);
var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);
mockPackageMan.Setup(packMan => packMan.UninstallPackage(oldPackage, It.IsAny <bool>(), It.IsAny <bool>()))
.Throws(new InvalidOperationException("Dummy message"));
mockPackageMan.SetupProperty(packMan => packMan.Logger, new TestEasy.NuGet.WebNuGetProject.ErrorLogger());
var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);
// act
WebNuGetProject project = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
var warnings = project.UpdatePackage(package);
// assert
Assert.Contains("Package MockPackage.1.0 could not be uninstalled: Dummy message", warnings);
}
public void RemoveFromPackageManagerAfterRemovingFromProjectManager()
{
var package = new MockPackage();
bool calledProjectManager = false;
bool calledPackageManagerAfterProjectManager = false;
var mockPackageMan = new Mock <IPackageManager>()
{
DefaultValue = DefaultValue.Mock
};
mockPackageMan.Setup(packMan => packMan.UninstallPackage(package, It.IsAny <bool>(), It.IsAny <bool>()))
.Callback(() => calledPackageManagerAfterProjectManager = calledProjectManager);
var mockProjectMan = new Mock <IProjectManager>()
{
DefaultValue = DefaultValue.Mock
};
mockProjectMan.Setup(projMan => projMan.RemovePackageReference(It.IsAny <IPackage>(), false, true))
.Callback(() => calledProjectManager = true);
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);
// act
WebNuGetProject project = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
var warnings = project.UninstallPackage(package, true);
// assert
Assert.True(calledPackageManagerAfterProjectManager);
}
public void TestForValue()
{
MockGenerator gen = new MockGenerator(5);
Assert.AreEqual(gen.Generate(10),
"kjiwq7e8vd");
}
public void DoesNotReturnPackagesFromLocal()
{
var packageA = new MockPackage {
Id = "A"
};
var packageB = new MockPackage {
Id = "B"
};
var packageAB = new MockPackage {
Id = "AB"
};
var mockRemoteRepo = new MockPackageRepository();
mockRemoteRepo.AddPackage(packageA);
mockRemoteRepo.AddPackage(packageB);
var mockLocalRepo = new MockPackageRepository();
mockLocalRepo.AddPackage(packageAB);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(mockRemoteRepo, mockLocalRepo).Object);
// act
var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
var results = project.GetRemotePackages("A");
Assert.Equal(new IPackage[] { packageA }, results);
}
public void OrderedByDownloadCountFirst()
{
var packageA = new MockPackage {
Id = "A", DownloadCount = 1
};
var packageB = new MockPackage {
Id = "B", DownloadCount = 2
};
var mockRepo = new MockPackageRepository();
mockRepo.AddPackage(packageA);
mockRepo.AddPackage(packageB);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(MockGenerator.CreateMockProjectManager(mockRepo, new MockPackageRepository()).Object);
// act
var project = new WebNuGetProject(new string[] { "http://dummyFeed" }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
var results = project.GetRemotePackages("");
Assert.Equal(new IPackage[] { packageB, packageA }, results);
packageA.DownloadCount = 2;
results = project.GetRemotePackages("");
Assert.Equal(new IPackage[] { packageA, packageB }, results);
}
public void InstallNewPackageToPackageManagerBeforeProjectManager()
{
var package = new MockPackage();
var mockRepository = new MockPackageRepository();
mockRepository.AddPackage(package);
bool calledPackageManager = false;
bool calledProjectManagerAfterPackageManager = false;
var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);
mockPackageMan.Setup(packMan => packMan.InstallPackage(package, It.IsAny <bool>(), It.IsAny <bool>()))
.Callback(() => calledPackageManager = true);
var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);
mockProjectMan.Setup(projMan => projMan.UpdatePackageReference(package.Id, package.Version, It.IsAny <bool>(), It.IsAny <bool>()))
.Callback(() => calledProjectManagerAfterPackageManager = calledPackageManager);
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);
// act
WebNuGetProject project = new WebNuGetProject(new string[] {}, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
var warnings = project.UpdatePackage(package);
// assert
Assert.True(calledProjectManagerAfterPackageManager);
}
public void OnlyIncludeFilesWhichExist()
{
// arrange
var mockFileSystem = MockGenerator.CreateMockFileSystem();
// mock Bar.dll to not exist
mockFileSystem.Setup(fs => fs.FileExists(It.IsAny <string>())).Returns <string>((s) => !s.Contains("Bar.dll"));
var mockMSBuildProject = MockGenerator.CreateMockMSBuildProject();
mockMSBuildProject.Setup(p => p.GetItemsWithMetadataProperty("Reference", "HintPath")).Returns(new Dictionary <string, string>()
{
{ "Foo", @"packages\Foo.dll" },
{ "Bar", @"packages\Bar.dll" },
{ "Baz", @"packages\Baz.dll" }
});
Dependencies.FileSystem = mockFileSystem.Object;
Dependencies.MSBuildProjectFactory = MockGenerator.CreateMSBuildProjectFactory(mockMSBuildProject.Object);
// act
var projectSystem = new NuGetMsBuildProjectSystem(@"C:\Dummy\Dummy.csproj");
var results = projectSystem.GetAssemblyReferencePaths();
// assert
string[] expected = { @"C:\Dummy\packages\Foo.dll", @"C:\Dummy\packages\Baz.dll" };
Assert.Equal(expected, results);
}
public void OldVersionOfPackageUninstalled()
{
var oldPackage = new MockPackage();
var package = new MockPackage {
Version = new SemanticVersion("2.0")
};
var mockRepository = new MockPackageRepository();
mockRepository.AddPackage(oldPackage);
var mockPackageMan = MockGenerator.CreateMockPackageManager(mockRepository, mockRepository);
mockPackageMan.Setup(packMan => packMan.UninstallPackage(oldPackage, It.IsAny <bool>(), It.IsAny <bool>()))
.Verifiable();
var mockProjectMan = MockGenerator.CreateMockProjectManager(mockRepository, mockRepository);
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageMan.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectMan.Object);
// act
WebNuGetProject project = new WebNuGetProject(new string[] { }, @"C:\DummyPath", null, MockGenerator.CreateWebProjectSystemFactory());
var warnings = project.UpdatePackage(package);
// assert
mockPackageMan.Verify();
}
private IServiceCollection GetServices(ISocketManager <ISocketClient <Message, Message>, Message> manager,
ISocketClient <Message, Message> gmClient)
{
IServiceCollection services = new ServiceCollection();
var conf = new ServerConfiguration()
{
GMPort = 44360, ListenerIP = "127.0.0.1", PlayerPort = 44370
};
services.AddSingleton(conf);
services.AddSingleton(MockGenerator.Get <Serilog.ILogger>());
services.AddSingleton(manager);
ServiceShareContainer shareContainer = new ServiceShareContainer
{
GameStarted = false,
ConfirmedAgents = new Dictionary <int, bool>(),
GMClient = gmClient
};
services.AddSingleton(shareContainer);
services.AddSingleton(Mock.Of <IApplicationLifetime>());
services.AddSingleton(new ServiceSynchronization(2, 2));
services.AddHostedService <CommunicationService>();
return(services);
}
public void PackageAvailableFromLocal_InstallSucceeds()
{
// arrange
var package = new MockPackage();
var mockLocalRepository = new MockPackageRepository();
var mockRemoteRepository = new MockPackageRepository();
mockLocalRepository.AddPackage(package);
var mockPackageManager = new Mock <IPackageManager>();
var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);
mockProjectManager.Setup(pm => pm.AddPackageReference(package, It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
Dependencies.NuGetProjectSystemFactory = MockGenerator.CreateProjectSystemFactory();
// act
NuGetCore core = new NuGetCore();
var warnings = core.InstallPackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", MockPackage.DefaultVersion.ToString());
// assert
mockProjectManager.Verify();
}
public void PackageAvailableFromLocal_UpdateSucceeds()
{
// arrange
var targetPackage = new MockPackage()
{
Version = new SemanticVersion("2.0")
};
var mockLocalRepository = new MockPackageRepository();
var mockRemoteRepository = new MockPackageRepository();
mockLocalRepository.AddPackage(new MockPackage());
mockLocalRepository.AddPackage(targetPackage);
var mockPackageManager = MockGenerator.CreateMockPackageManager(mockRemoteRepository, mockLocalRepository);
var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);
mockProjectManager.Setup(pm => pm.UpdatePackageReference(targetPackage.Id, targetPackage.Version, It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
Dependencies.NuGetProjectSystemFactory = MockGenerator.CreateProjectSystemFactory();
// act
NuGetCore core = new NuGetCore();
var warnings = core.UpdatePackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", "2.0");
// assert
mockProjectManager.Verify();
}
public void DontSpecifyVersion_UpdatesToLatestPackage()
{
var latestPackage = new MockPackage {
Version = new SemanticVersion("3.0")
};
var mockLocalRepository = new MockPackageRepository();
var mockRemoteRepository = new MockPackageRepository();
mockLocalRepository.AddPackage(new MockPackage());
mockRemoteRepository.AddPackage(new MockPackage {
Version = new SemanticVersion("2.0")
});
mockRemoteRepository.AddPackage(latestPackage);
var mockPackageManager = MockGenerator.CreateMockPackageManager(mockRemoteRepository, mockLocalRepository);
var mockProjectManager = MockGenerator.CreateMockProjectManager(mockRemoteRepository, mockLocalRepository);
mockProjectManager.Setup(pm => pm.UpdatePackageReference(latestPackage.Id, latestPackage.Version, It.IsAny <bool>(), It.IsAny <bool>())).Verifiable();
Dependencies.NuGetPackageManagerFactory = MockGenerator.CreatePackageManagerFactory(mockPackageManager.Object);
Dependencies.NuGetProjectManagerFactory = MockGenerator.CreateProjectManagerFactory(mockProjectManager.Object);
Dependencies.NuGetProjectSystemFactory = MockGenerator.CreateProjectSystemFactory();
// act
NuGetCore core = new NuGetCore();
var warnings = core.UpdatePackage(@"C:\DummyPath", MockPackage.DefaultId, "http://dummyFeed", null);
// assert
mockProjectManager.Verify();
}
/// <summary>
/// Initializes a new instance of the <see cref="DependencyConfigurationRegistry"/> class.
/// </summary>
public StructureMapRepositoryTestRegistry()
{
MockEntities.LoadData();
For <IUserRepository>().Use(MockRepositoryGenerator <UserModel> .RepositoryMock <IUserRepository>());
For <IUnitOfWork>().Use(MockGenerator.UnitOfWorkMock());
For <IDataContext>().Use(MockGenerator.DataContextMock());
}
static void Main(string[] args)
{
var types = typeof(IService).Assembly.GetTypes().Where(t => typeof(IService).IsAssignableFrom(t) && t.IsInterface);
var serviceUtilsProjFileName = "../../../../Utils/LoggedServices/LoggedServices.projitems";
MockGenerator.GenerateMocks(serviceUtilsProjFileName, types, typeof(NullableAttribute));
}
private MainViewModel CreateMainViewModel()
{
var audioService = MockGenerator.CreateAudioService();
var optionsService = MockGenerator.CreateOptionsService();
var destService = MockGenerator.CreateRecordingsDestinationService();
return(new MainViewModel(audioService, optionsService.Object, destService.Object));
}
public static void DumpWatchedProcedure(string caption, Procedure proc)
{
if (proc.Name == "fn00100000")
{
Debug.Print("// {0}: {1} ==================", proc.Name, caption);
MockGenerator.DumpMethod(proc);
proc.Dump(true);
}
}
private static DocumentCategory Create(int id)
{
return(new DocumentCategory()
{
Id = id,
Name = MockGenerator.GetString(50),
Description = MockGenerator.GetString(255)
});
}
public TcpSocketClientTests()
{
logger = MockGenerator.Get <ILogger>();
tcpClientMock = new Mock <IClient>()
{
DefaultValue = DefaultValue.Mock
};
tcpClient = tcpClientMock.Object;
}
private void CompileTest(Action <ProcedureBuilder> buildMock)
{
ProcedureBuilder m = new ProcedureBuilder();
buildMock(m);
MockGenerator g = new MockGenerator(sb);
g.Write(m.Procedure);
}
public void Should_DocumentCategoryValidator_Description_MaximumLength()
{
documentCategory.Description = MockGenerator.GetString(255);
results = validator.Validate(documentCategory);
Assert.IsTrue(results.IsValid);
documentCategory.Description = MockGenerator.GetString(256);
results = validator.Validate(documentCategory);
Assert.IsFalse(results.IsValid);
}
public void Should_DocumentCategoryValidator_Name_MaximumLength()
{
documentCategory.Name = MockGenerator.GetString(50);
results = validator.Validate(documentCategory);
Assert.IsTrue(results.IsValid);
documentCategory.Name = MockGenerator.GetString(51);
results = validator.Validate(documentCategory);
Assert.IsFalse(results.IsValid);
}
public void Delete_Foreign_Key_Should_Throw_Exception_If_Table_Name_Is_Null()
{
// Setup empty FK
var deleteFKExpression = new DeleteForeignKeyExpression();
var fkDef = new ForeignKeyDefinition();
deleteFKExpression.ForeignKey = fkDef;
// Setup empty mock object
var mockGenerator = new MockGenerator(null, null, null);
Assert.Throws<ArgumentNullException>(() => mockGenerator.Generate(deleteFKExpression));
}
public void Delete_Foreign_Key_Should_Throw_Exception_If_Table_Name_Is_Null()
{
// Setup empty FK
var deleteFKExpression = new DeleteForeignKeyExpression();
var fkDef = new ForeignKeyDefinition();
deleteFKExpression.ForeignKey = fkDef;
// Setup empty mock object
var mockGenerator = new MockGenerator(null, null);
Assert.Throws <ArgumentNullException>(() => mockGenerator.Generate(deleteFKExpression));
}
public void AddingFrameworkReference_CallSaveProject()
{
// arrange
var mockProject = MockGenerator.CreateMockMSBuildProject_SaveMethodVerifiable();
// act
var projectSystem = new NuGetMsBuildProjectSystem(@"C:\DummyPath\Dummy.csproj", MockGenerator.CreateMSBuildProjectFactory(mockProject.Object));
projectSystem.AddFrameworkReference("System.Web");
// assert
mockProject.Verify();
}
public void AddingReference_CallSaveProject()
{
// arrange
var mockProject = MockGenerator.CreateMockMSBuildProject_SaveMethodVerifiable();
// act
var projectSystem = new NuGetMsBuildProjectSystem(@"C:\DummyPath\Dummy.csproj", MockGenerator.CreateMSBuildProjectFactory(mockProject.Object));
projectSystem.AddReference(@"C:\DummyPath\packages\Dummy.dll", Stream.Null);
// assert
mockProject.Verify();
}
public void FindProjectFile_CreateMSBuildProjectSystem(string[] files)
{
var mockFileSystem = new Mock <IFileSystem>();
mockFileSystem.Setup(fs => fs.DirectoryGetFiles(@"C:\DummyPath")).Returns(files);
// act
var factory = new NuGetProjectFactory(mockFileSystem.Object, MockGenerator.CreateMSBuildProjectFactory());
var project = factory.CreateProject(@"C:\DummyPath");
// assert
Assert.Equal(typeof(NuGetMsBuildProjectSystem), project.GetType());
}
public void StripExtensionFromReferenceName(string assemblyName, string expectedReferenceName)
{
// arrange
var mockProject = MockGenerator.CreateMockMSBuildProject();
mockProject.Setup(p => p.ReferenceExists(expectedReferenceName)).Verifiable();
// act
var projectSystem = new NuGetMsBuildProjectSystem(@"C:\DummyPath\Dummy.csproj", MockGenerator.CreateMSBuildProjectFactory(mockProject.Object));
// assert
Assert.False(projectSystem.ReferenceExists(assemblyName));
mockProject.Verify();
}
public void NupkgLocalPackageLoader_GetPackageMetadataFromPath_ShouldNotInclude()
{
// Arrange
var mock = new MockGenerator()
.MockOpenExistingPackage()
.MockPackageId();
// Act
var loader = new NupkgLocalPackageLoader(mock.FileSystem.Object, mock.NugetHelper.Object);
var returnedPackageMetadata = loader.GetPackageMetadataFromPath(mock.NupkgFile, (p) => { return(false); });
// Assert
Assert.IsNull(returnedPackageMetadata);
mock.VerifyAll();
}
public void OnlySearchReferenceItemType()
{
// arrange
var mockProject = MockGenerator.CreateMockMSBuildProject();
mockProject.Setup(p => p.ReferenceExists("DummyReference")).Returns(false).Verifiable();
mockProject.Setup(p => p.ItemExists("Content", "DummyReference")).Returns(true);
// act
var projectSystem = new NuGetMsBuildProjectSystem(@"C:\DummyPath\Dummy.csproj", MockGenerator.CreateMSBuildProjectFactory(mockProject.Object));
// assert
Assert.False(projectSystem.ReferenceExists("DummyReference.dll"));
mockProject.Verify();
}
public void RemovingReference_CallSaveProject()
{
// arrange
var mockProject = MockGenerator.CreateMockMSBuildProject_SaveMethodVerifiable();
mockProject.Setup(p => p.ReferenceExists(It.Is <string>(s => s == "Dummy" || s == "Dummy.dll"))).Returns(true);
mockProject.Setup(p => p.RemoveItem("Reference", "Dummy")).Verifiable();
// act
var projectSystem = new NuGetMsBuildProjectSystem(@"C:\DummyPath\Dummy.csproj", MockGenerator.CreateMSBuildProjectFactory(mockProject.Object));
projectSystem.RemoveReference(@"Dummy.dll");
// assert
mockProject.Verify();
}
public void NupkgLocalPackageLoader_DiscoverPackages_ValidPackage()
{
// Arrange
var mock = new MockGenerator()
.MockGetPackages()
.MockOpenExistingPackage()
.MockPackageInfo()
.MockLibDllInTheSameFolderAsNupkg();
PackageMetadata expectedPackageMetadata = mock.GetExpectedPackageMetadata();
// Act
var loader = new NupkgLocalPackageLoader(mock.FileSystem.Object, mock.NugetHelper.Object);
var returnedPackageMetadata = loader.DiscoverPackages(new[] { mock.SourceDirectory },
new HashSet<string>(),
newOnly: false,
lastIndexModifiedTime: DateTime.Now,
cancellationToken: CancellationToken.None,
shouldIncludeFunc: null);
// Assert
Assert.IsTrue(expectedPackageMetadata.Equals(returnedPackageMetadata.First()));
mock.VerifyAll();
}
public void NupkgLocalPackageLoader_GetPackageMetadataFromPath_LibExplicitReferences()
{
// Arrange
var mock = new MockGenerator()
.MockOpenExistingPackage()
.MockPackageInfo()
.MockLibExplicitReferencesDll();
PackageMetadata expectedPackageMetadata = mock.GetExpectedPackageMetadata();
// Act
var loader = new NupkgLocalPackageLoader(mock.FileSystem.Object, mock.NugetHelper.Object);
var returnedPackageMetadata = loader.GetPackageMetadataFromPath(mock.NupkgFile, null);
// Assert
Assert.IsTrue(expectedPackageMetadata.Equals(returnedPackageMetadata));
mock.VerifyAll();
}
public void NupkgLocalPackageLoader_GetPackageMetadataFromPath_ShouldNotInclude()
{
// Arrange
var mock = new MockGenerator()
.MockOpenExistingPackage()
.MockPackageId();
// Act
var loader = new NupkgLocalPackageLoader(mock.FileSystem.Object, mock.NugetHelper.Object);
var returnedPackageMetadata = loader.GetPackageMetadataFromPath(mock.NupkgFile, (p) => { return false; } );
// Assert
Assert.IsNull(returnedPackageMetadata);
mock.VerifyAll();
}
public void NupkgLocalPackageLoader_DiscoverPackages_NupkgNotFound()
{
// Arrange
var mock = new MockGenerator()
.MockGetPackages()
.MockNupkgNotFound();
// Act
var loader = new NupkgLocalPackageLoader(mock.FileSystem.Object, mock.NugetHelper.Object);
var returnedPackageMetadata = loader.DiscoverPackages(new[] { mock.SourceDirectory },
new HashSet<string>(),
newOnly: false,
lastIndexModifiedTime: DateTime.Now,
cancellationToken: CancellationToken.None,
shouldIncludeFunc: null);
// Assert
Assert.IsFalse(returnedPackageMetadata.Any());
mock.VerifyAll();
}
private void CompileTest(Action<ProcedureBuilder> buildMock)
{
ProcedureBuilder m = new ProcedureBuilder();
buildMock(m);
MockGenerator g = new MockGenerator(sb);
g.Write(m.Procedure);
}
