private static IEnumerable <Assembly> LoadAllUnloadedAssemblies(Assembly[] loadedAssemblies)
{
if (StackTraceExtensions.ForceUseOfMockResolver())
{
return(loadedAssemblies);
}
//ncrunch: no coverage start
var assemblies = new List <Assembly>(loadedAssemblies);
var dllFiles = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.dll");
foreach (var filePath in dllFiles)
{
try
{
assemblies = TryLoadAllUnloadedAssemblies(assemblies, filePath);
}
catch (Exception ex)
{
Logger.Warning("Failed to load assembly " + filePath + ": " + ex.Message);
}
}
foreach (var assembly in loadedAssemblies)
{
if (assembly.IsAllowed() && !AssemblyExtensions.IsPlatformAssembly(assembly.GetName().Name))
{
LoadDependentAssemblies(assembly, assemblies);
}
}
return(assemblies);
}
public GLFW3Window(Settings settings)
{
if (!StackTraceExtensions.StartedFromNCrunchOrNunitConsole)
{
Glfw.SetErrorCallback(ErrorCallback);
}
if (!Glfw.Init())
{
throw new UnableToInitializeGLFW();
}
if (GetGlfwMajorVersion() < 3)
{
throw new UnableToInitializeShadersForGLFW();
}
this.settings = settings;
CreateWindow(settings.Resolution, settings.StartInFullscreen);
new GLFW3Time();
Title = StackTraceExtensions.GetEntryName();
BackgroundColor = Color.Black;
hwnd = GetForegroundWindow();
Icon appIcon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
if (appIcon != null && hwnd != IntPtr.Zero)
{
SetIcon(appIcon);
}
}
//ncrunch: no coverage start
private void ShowInitializationErrorBox(Type baseType, Exception ex)
{
var exceptionText = StackTraceExtensions.FormatExceptionIntoClickableMultilineText(ex);
var window = Resolve <Window>();
window.CopyTextToClipboard(exceptionText);
const string Header = "Fatal Initialization Error";
var text = GetHintTextForKnownIssues(ex);
text += "Unable to resolve class " + baseType + "\n";
if (ExceptionExtensions.IsDebugMode)
{
text += exceptionText;
}
else
{
text += ex.GetType().Name + " " + ex.Message;
}
text += ErrorWasCopiedToClipboardMessage + ClickIgnoreToContinue;
if (window.ShowMessageBox(Header, text, new[] { "Ignore", "Abort" }) != "Abort")
{
return;
}
Dispose();
if (!StackTraceExtensions.StartedFromNCrunchOrNunitConsole)
{
Environment.Exit((int)AppRunner.ExitCode.InitializationError);
}
}
public void InitializeCreepyTowersMockContentLoader()
{
if (StackTraceExtensions.ForceUseOfMockResolver())
{
ContentLoader.Use <CreepyTowersMockContentLoader>();
}
}
private void OnObjectFinished(MessageData dataContainer)
{
var dataBytes = dataContainer.IsDataCompressed
? ZlibStream.UncompressBuffer(dataContainer.Data) : dataContainer.Data;
using (var dataStream = new MemoryStream(dataBytes))
using (var dataReader = new BinaryReader(dataStream))
{
object receivedMessage;
try
{
receivedMessage = TryReceiveMessage(dataReader);
}
catch (Exception ex)
{
receivedMessage =
new ServerError(StackTraceExtensions.FormatExceptionIntoClickableMultilineText(ex));
}
if (DataReceived != null)
{
DataReceived(receivedMessage);
}
else
{
throw new NobodyIsUsingTheDataReceivedEvent(receivedMessage);
}
}
}
private static void Pause()
{
if (!StackTraceExtensions.IsStartedFromNCrunch())
{
Thread.Sleep(25); //ncrunch: no coverage
}
}
public FormsWindow(Settings settings)
: this(new NativeMessageForm())
{
var form = panel as Form;
if (settings.StartInFullscreen)
{
IsFullscreen = settings.StartInFullscreen;
form.FormBorderStyle = FormBorderStyle.None;
form.TopMost = true;
form.StartPosition = FormStartPosition.Manual;
form.DesktopLocation = new SystemPoint(0, 0);
}
else
{
form.FormBorderStyle = FormBorderStyle.Sizable;
form.StartPosition = FormStartPosition.CenterScreen;
}
form.ClientSize = new SystemSize((int)settings.Resolution.Width,
(int)settings.Resolution.Height);
form.MinimumSize = new SystemSize(1, 1);
form.Text = StackTraceExtensions.GetEntryName();
BackgroundColor = Color.Black;
Icon appIcon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
if (appIcon != null)
{
form.Icon = appIcon;
}
form.SizeChanged += OnSizeChanged;
form.Show();
}
//ncrunch: no coverage start
protected ApproveFirstFrameScreenshot()
{
if (!StackTraceExtensions.IsStartedFromNCrunch() && StackTraceExtensions.IsUnitTest() &&
ExcludeSharpDXAsScreenshotsCanOnlyBeMadeDelayed())
{
CheckApprovalImageAfterFirstFrame();
}
}
//ncrunch: no coverage start
private void WarnIfUnitTestTakesTooLong()
{
if (StackTraceExtensions.ContainsUnitTest() && TookLongerThan10Ms())
{
Debug.WriteLine("This unit test takes too long (" + testElapsedMs + "ms, max. 10ms is " +
"allowed), please add Category(\"Slow\") to run it nightly instead!");
}
}
public XnaWindow(Game game)
{
this.game = game;
game.Window.Title = StackTraceExtensions.GetEntryName();
game.Window.AllowUserResizing = true;
game.IsMouseVisible = true;
game.Window.ClientSizeChanged += OnViewportSizeChanged;
}
public void CreateContentUploadQueue()
{
FileReader fileReader = StackTraceExtensions.IsStartedFromNCrunch()
? new MockFileReader() : new FileReader();
contentUploadQueue = new MockContentUploadQueue(fileReader,
(metaData, fileBytes) => uploadedContentFiles++);
}
public void FakeSetupMethod()
{
const string FakeTestFullName =
"DeltaEngine.Tests.StackTraceExtensionsTests.GetTestMethodNameFromSetUpMethod";
StackTraceExtensions.SetUnitTestName(FakeTestFullName);
Assert.AreEqual("GetTestMethodNameFromSetUpMethod",
new StackTrace().GetFrames().GetTestMethodName());
}
public ProjectCreatorViewModel(Service service)
{
this.service = service;
this.service.DataReceived += OnDataReceived;
project = new CsProject(service.UserName);
AvailableStarterKits = VsTemplate.GetAllTemplateNames(project.Framework);
AvailableFrameworks = StackTraceExtensions.IsStartedFromNCrunch()
? new FrameworkFinderSpy().All : new FrameworkFinder().All;
RegisterCommands();
}
public void FormatExceptionIntoClickableMultilineText()
{
try
{
TryFormatExceptionIntoClickableMultilineText();
} // ncrunch: no coverage
catch (Exception ex)
{
Console.WriteLine(StackTraceExtensions.FormatExceptionIntoClickableMultilineText(ex));
}
}
private void CheckApprovalImageAfterFirstFrame()
{
var approvalTestName = StackTraceExtensions.GetApprovalTestName();
if (String.IsNullOrEmpty(approvalTestName))
{
return;
}
firstFrameApprovalImageFilename = "..\\..\\" + approvalTestName + "." +
GetType().Name.Replace("Resolver", "") + ".png";
}
public XnaWindow(Game game)
{
this.game = game;
Title = StackTraceExtensions.GetEntryName();
game.Window.AllowUserResizing = true;
game.IsMouseVisible = true;
game.Window.ClientSizeChanged += OnViewportSizeChanged;
game.Window.OrientationChanged +=
(sender, args) => OnOrientationChanged(GetOrientation(game.Window.CurrentOrientation));
game.Exiting += (sender, args) => { IsClosing = true; };
BackgroundColor = Color.Black;
}
public void WindingOfVerticesShouldBeCounterClockWise()
{
if (!StackTraceExtensions.IsStartedFromNCrunch())
{
return; //ncrunch: no coverage
}
MockGeometry geometry = CreateMockGeometry();
var indices = new short[] { 0, 1, 2 };
geometry.SetData(CreateVertexData(), indices);
AssertVertices(geometry, indices);
AssertGeometryIsCounterClockWise(geometry);
}
public void WhenTwoServersExistMessagesAreSentToTheCorrectOne()
{
if (!StackTraceExtensions.IsStartedFromNCrunch())
{
return; //ncrunch: no coverage
}
MessagingSession serverSession2 = Messaging.StartSession(Port + 1);
MessagingSession clientSession2 = Messaging.JoinSession(Address, Port + 1);
clientSession.SendMessage("first");
clientSession2.SendMessage("second");
Assert.AreEqual("first", serverSession.GetMessages()[0].Data);
Assert.AreEqual("second", serverSession2.GetMessages()[0].Data);
}
public void RegisterRenderableObject()
{
if (!StackTraceExtensions.IsStartedFromNCrunch())
{
return;
}
using (var device = new MockDevice(new MockWindow()))
{
device.Clear();
device.Present();
resolver.Register(device);
resolver.RegisterSingleton <Drawing>();
resolver.Register(new Line2D(Vector2D.One, Vector2D.Zero, Color.Red));
}
}
public void WithTwoClientsWhenOneClientMessagesTheServerItIsEchoedToTheOtherClient()
{
if (!StackTraceExtensions.IsStartedFromNCrunch())
{
return; //ncrunch: no coverage
}
var clientSession2 = Messaging.JoinSession(Address, Port);
clientSession2.SendMessage("welcome");
List <MessagingSession.Message> messages = clientSession.GetMessages();
Assert.AreEqual(1, serverSession.GetMessages().Count);
Assert.AreEqual(1, messages.Count);
VerifyMessageContents(messages[0], 2, "welcome");
Assert.AreEqual(2, serverSession.NumberOfParticipants);
}
private static string GetVisualStudioDocumentsFolder()
{
if (StackTraceExtensions.IsStartedFromNCrunch())
{
return(GetSupportedVisualStudioFolders()[0]);
}
//ncrunch: no coverage start
foreach (var myVisualStudioDocuments in GetSupportedVisualStudioFolders())
{
if (Directory.Exists(myVisualStudioDocuments))
{
return(myVisualStudioDocuments);
}
}
throw new VisualStudioDocumentsLocationNotFound();
//ncrunch: no coverage end
}
public void DrawAtlasSprite()
{
if (StackTraceExtensions.IsStartedFromNCrunch())
{
return;
}
// ncrunch: no coverage start
//test: ContentLoader.Use<DiskContentLoader>();
new FilledRect(Rectangle.HalfCentered, Color.Brown);
var sprite1 = new Sprite("headPL", new Rectangle(0.25f, 0.25f, 0.5f, 0.25f));
sprite1.UV = new Rectangle(0, 0, 1, 0.5f);
sprite1.Color = Color.Red;
var sprite2 = new Sprite("headPL", new Rectangle(0.25f, 0.5f, 0.5f, 0.25f));
sprite2.UV = new Rectangle(0, 0.5f, 1, 0.5f);
sprite2.Color = Color.Blue;
}
public FormsWindow()
{
form = new Form
{
Text = StackTraceExtensions.GetEntryName(),
Size = new Size(800, 600),
FormBorderStyle = FormBorderStyle.Sizable,
StartPosition = FormStartPosition.CenterScreen
};
Icon appIcon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
if (appIcon != null)
{
form.Icon = appIcon;
}
form.SizeChanged += OnSizeChanged;
form.Show();
closeAfterOneFrameIfInIntegrationTest = !StackTraceExtensions.ContainsNoTestOrIsVisualTest();
}
//ncrunch: no coverage start
protected virtual void CreateNewSourceCodeClass()
{
if (StackTraceExtensions.IsStartedFromNCrunch())
{
return;
}
string path = service.GetAbsoluteSolutionFilePath(service.ProjectName);
var filePath = Path.GetDirectoryName(path);
bool canCreate = true;
if (File.Exists(filePath + "\\" + sceneClassName + ".cs"))
{
canCreate = GiveUserOptionOfOverwriting();
}
if (canCreate)
{
AddClassToProjectFileAndCsProj(filePath);
}
}
public void InitializeResolver()
{
if (StackTraceExtensions.ForceUseOfMockResolver())
{
resolver = new MockResolver();
return;
}
//ncrunch: no coverage start
if (!StackTraceExtensions.StartedFromProgramMain)
{
StackTraceExtensions.SetUnitTestName(TestContext.CurrentContext.Test.FullName);
}
resolver = new XnaResolver();
if (StackTraceExtensions.IsCloseAfterFirstFrameAttributeUsed() ||
StackTraceExtensions.StartedFromNCrunchOrNunitConsole)
{
Resolve <Window>().CloseAfterFrame();
}
//ncrunch: no coverage end
}
public void FormatStackTraceIntoClickableMultilineText()
{
// This will output text into the NCrunch output window, which is needed to test this feature
Console.WriteLine(StackTraceExtensions.FormatStackTraceIntoClickableMultilineText());
}
public void IsUnitTest()
{
Assert.IsTrue(StackTraceExtensions.IsUnitTest());
}
public void Main()
{
// Because this method is named "Main" we will get the namespace name instead!
Assert.AreEqual("DeltaEngine.Tests.Extensions", StackTraceExtensions.GetEntryName());
}
public void GetEntryName()
{
Assert.AreEqual("GetEntryName", StackTraceExtensions.GetEntryName());
}
public void IsApprovalTest()
{
Assert.AreEqual("", StackTraceExtensions.GetApprovalTestName());
}
