public void TestSmartQueuePopTail()
{
SmartQueue<TestEntry> q = new SmartQueue<TestEntry>();
Assert.IsTrue(q.IsEmpty && q.Count == 0 && q.Head == null);
// enqueue e1 and e2 onto the queue
TestEntry e1 = new TestEntry();
TestEntry e2 = new TestEntry();
q.Enqueue(e1);
q.Enqueue(e2);
Assert.IsTrue(q.Head == e1 && q.Tail == e2 && q.Count == 2);
Assert.IsTrue(e1.IsEnqueued);
Assert.IsTrue(e1.IsActive);
// now pop e2 from the tail, make sure it never got activated or deactivated
var popped = q.PopTail();
Assert.IsTrue(popped == e2);
Assert.IsTrue(q.Head == e1 && q.Tail == e1 && q.Count == 1);
Assert.IsFalse(e2.IsEnqueued);
Assert.IsFalse(e2.IsActive);
Assert.IsTrue(e2.enqueuedCount == 1 && e2.dequeuedCount == 1);
Assert.IsTrue(e2.activationCount == 0 && e2.deactivationCount == 0); // never activated or deactivated
Assert.IsTrue(e2.poppedTailCount == 1); // it knows it got popped from the tail
// now let's pop the head element from the tail, make sure it's cleaned up
var popped2 = q.PopTail();
Assert.IsTrue(popped2 == e1);
Assert.IsTrue(q.IsEmpty);
Assert.IsFalse(e1.IsActive);
Assert.IsFalse(e1.IsEnqueued);
Assert.IsTrue(e1.enqueuedCount == 1 && e1.dequeuedCount == 1);
Assert.IsTrue(e1.activationCount == 1 && e1.deactivationCount == 1); // both activated and deactivated
Assert.IsTrue(e1.poppedTailCount == 1); // it also knows it got popped from the tail
}
public void TestSmartQueueEnqueueAndDequeue()
{
SmartQueue<TestEntry> q = new SmartQueue<TestEntry>();
Assert.IsTrue(q.IsEmpty && q.Count == 0 && q.Head == null);
// make an empty something
TestEntry e1 = new TestEntry();
Assert.IsTrue(e1.enqueuedCount == 0 && e1.dequeuedCount == 0 && e1.activationCount == 0 && e1.deactivationCount == 0);
Assert.IsNull(e1.container);
Assert.IsFalse(e1.IsActive);
Assert.IsFalse(e1.IsEnqueued);
// enqueue it. make sure it's there, and got notified appropriately
q.Enqueue(e1);
Assert.IsTrue(q.Head == e1 && q.Tail == e1 && q.Count == 1 && !q.IsEmpty);
Assert.IsTrue(e1.enqueuedCount == 1 && e1.activationCount == 1);
Assert.IsTrue(e1.IsEnqueued);
Assert.IsTrue(e1.IsActive);
// enqueue something else behind it. the first one should be unaffected
TestEntry e2 = new TestEntry();
q.Enqueue(e2);
Assert.IsTrue(q.Head == e1 && q.Tail == e2 && q.Count == 2 && !q.IsEmpty);
Assert.IsTrue(e1.enqueuedCount == 1 && e1.activationCount == 1); // same as before
Assert.IsTrue(e1.IsEnqueued);
Assert.IsTrue(e1.IsActive);
// but the second one shouldn't be active yet
Assert.IsTrue(e2.enqueuedCount == 1 && e2.activationCount == 0); // enq'd, inactive
Assert.IsTrue(e2.IsEnqueued);
Assert.IsFalse(e2.IsActive);
// dequeue e1, verify it cleaned up
var popped = q.Dequeue();
Assert.IsTrue(popped == e1);
Assert.IsTrue(q.Head == e2 && q.Count == 1 && !q.IsEmpty);
Assert.IsTrue(e1.enqueuedCount == 1 && e1.activationCount == 1); // activations unchanged
Assert.IsTrue(e1.deactivationCount == 1 && e1.dequeuedCount == 1); // deactivations updated
Assert.IsFalse(e1.IsActive);
Assert.IsFalse(e1.IsEnqueued);
Assert.IsTrue(e1.pushedBackCount == 0 && e1.poppedTailCount == 0); // nothing unexpected here
// verify e2 activated
Assert.IsTrue(e2.enqueuedCount == 1 && e2.activationCount == 1);
Assert.IsTrue(e2.IsActive);
// now deq e2 and verify things cleaned up
var popped2 = q.Dequeue();
Assert.IsTrue(popped2 == e2);
Assert.IsTrue(q.Head == null && q.Count == 0 && q.IsEmpty);
Assert.IsTrue(e2.enqueuedCount == 1 && e2.activationCount == 1); // activations unchanged
Assert.IsTrue(e2.deactivationCount == 1 && e2.dequeuedCount == 1); // deactivations updated
Assert.IsTrue(e2.pushedBackCount == 0);
Assert.IsFalse(e2.IsActive); // none of these is true anymore
Assert.IsFalse(e2.IsEnqueued);
Assert.IsNull(e2.container);
}
public bool initWithEntryID(int entryId)
{
TouchEnabled = true;
Schedule(tick);
m_entry = TestEntries.TestList[entryId];
m_test = m_entry.CreateFcn();
m_test.Initialize();
return(true);
}
public void Parse_UsesDefaultManifestNameForManifest()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.File("sample.txt")));
// Act
var manifest = ManifestParser.Parse(assembly);
// Assert
Assert.NotNull(manifest);
}
public void TestSmartStack()
{
SmartStack <TestEntry> stack = new SmartStack <TestEntry>();
Assert.IsTrue(stack.IsEmpty && stack.Count == 0 && stack.Peek() == null);
// make an empty something
TestEntry e1 = new TestEntry();
Assert.IsTrue(e1.pushCount == 0 && e1.popCount == 0 && e1.activationCount == 0 && e1.deactivationCount == 0);
Assert.IsNull(e1.container);
Assert.IsFalse(e1.IsActive);
Assert.IsFalse(e1.IsOnStack);
// push it! make sure it's there, and got notified appropriately
stack.Push(e1);
Assert.IsTrue(stack.Peek() == e1 && stack.Count == 1 && !stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 1);
Assert.IsTrue(e1.IsOnStack);
Assert.IsTrue(e1.IsActive);
// push something else. this should deactivate but not pop the first one
TestEntry e2 = new TestEntry();
stack.Push(e2);
Assert.IsTrue(stack.Peek() == e2 && stack.Count == 2 && !stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 1); // same as before, but
Assert.IsTrue(e1.IsOnStack);
Assert.IsFalse(e1.IsActive); // ...this is no longer true
Assert.IsTrue(e1.deactivationCount == 1); // because it's been deactivated (not on top anymore)
// pop that something else, let's verify e1 is activated
var popped = stack.Pop();
Assert.IsTrue(popped == e2);
Assert.IsTrue(stack.Peek() == e1 && stack.Count == 1 && !stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 2); // activations incremented
Assert.IsTrue(e1.deactivationCount == 1); // deactivations unchanged
Assert.IsTrue(e1.IsActive);
// now pop the last thing
var popped2 = stack.Pop();
Assert.IsTrue(popped2 == e1);
Assert.IsTrue(stack.Peek() == null && stack.Count == 0 && stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 2); // activations unchanged
Assert.IsTrue(e1.deactivationCount == 2 && e1.popCount == 1); // deactivations and popped incremented
Assert.IsFalse(e1.IsActive); // none of these is true anymore
Assert.IsFalse(e1.IsOnStack);
Assert.IsNull(e1.container);
}
public void SessionCache_Set_NullKeyShouldThrowException()
{
// Arrange
var value = new TestEntry {
Name = "Test"
};
var sut = this.SessionCache;
// Act
sut.Set(null, value);
// Assert
// Should throw error
}
public void Parse_FindsManifestWithCustomName()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.File("sample.txt")),
manifestName: "Manifest.xml");
// Act
var manifest = ManifestParser.Parse(assembly, "Manifest.xml");
// Assert
Assert.NotNull(manifest);
}
public void ShouldHandleAndIgnoreException()
{
Exception ex = new Exception();
Entry entry = new TestEntry();
ILog logger = _mocks.StrictMock<ILog>();
Expect.Call(() => logger.Info("Exception processing: " + entry, ex));
_mocks.ReplayAll();
IExceptionHandler exceptionHandler = new IgnoreExceptionHandler(logger);
exceptionHandler.Handle(ex, entry);
_mocks.VerifyAll();
}
public ActionResult Details(int id)
{
ViewBag.Message = "Details of this Exam:";
TestEntry entry = null;
foreach (TestEntry e in testEntryList)
{
if (id == e.ID)
{
entry = e;
break;
}
}
return(View(entry));
}
public void SessionCache_Set_ExpectsValue()
{
// Arrange
var value = new TestEntry {
Name = "test"
};
var key = Guid.NewGuid().ToString();
var sut = this.SessionCache;
// Act
sut.Set(key, value);
// Assert
Assert.IsTrue(sut.Contains(key));
}
public void ShouldHandleAndIgnoreException()
{
Exception ex = new Exception();
Entry entry = new TestEntry();
ILog logger = _mocks.StrictMock <ILog>();
Expect.Call(() => logger.Info("Exception processing: " + entry, ex));
_mocks.ReplayAll();
IExceptionHandler exceptionHandler = new IgnoreExceptionHandler(logger);
exceptionHandler.Handle(ex, entry);
_mocks.VerifyAll();
}
//Get final result
public ActionResult FinalResult(string token)
{
using (CyberSchoolEntities context = new CyberSchoolEntities())
{
TestEntry objTestEntry = context.TestEntry.Where(x => x.Token == token).FirstOrDefault();
if (objTestEntry == null)
{
TempData["message"] = "You have invalid token. Please re-login and try again.";
return(RedirectToAction("Index", "Login"));
}
int marks = 0;
if (objTestEntry.TotalMarks != null)
{
marks = (int)objTestEntry.TotalMarks;
}
int testID = (int)objTestEntry.TestID;
List <Question> objQuestionList = context.Question.Where(x => x.TestId == testID && x.IsActive == 1 && x.IsDeleted == 0).ToList();
double totalMarks = 0;
foreach (var item in objQuestionList)
{
totalMarks += (double)item.PointsOfQuestion;
}
TempData["FinalMarks"] = (int)((marks / totalMarks) * 100);
Test objTest = context.Test.Where(o => o.Id == objTestEntry.TestID).FirstOrDefault();
TempData["Grade"] = objTest.GradeVsSubject.Grade.Grade1.ToString();
TempData["Subject"] = objTest.GradeVsSubject.Subject.SubjectName;
TempData["TestName"] = objTest.TestName;
TempData["Part"] = objTest.PaperPart;
try
{
objTestEntry.Token = Guid.NewGuid().ToString();
objTestEntry.TokenExpireTime = DateTime.Now;
context.Entry(objTestEntry).State = EntityState.Modified;
context.SaveChanges();
}
catch (Exception)
{
TempData["dbError"] = "Server Error. Please Login again.";
return(RedirectToAction("Index", "Login"));
}
}
return(View());
}
protected override void OnPaint(GUI.PaintEventArgs e)
{
base.OnPaint(e);
if (testSelection != testIndex)
{
testIndex = testSelection;
entry = TestEntries.g_testEntries[testIndex];
test = entry.createFcn();
viewZoom = 1.0;
m_OffsetX = 0;
m_OffsetY = 0;
m_ExampleNumberLabel.Text = "Ex " + (testIndex + 1).ToString("0") + "/" + testCount.ToString("0");
}
Graphics graphics = e.Graphics;
if (!DoubleBuffered)
{
graphics.FillRectangle(Color.FromArgb((graphics is SoftwareGraphics) ? 96 : 192, Color.Black), ClientRectangle);
}
else
{
graphics.Clear(Color.FromArgb((graphics is SoftwareGraphics) ? 96 : 192, Color.Black));
}
graphics.SmoothingMode = entry.solidDraw ? SmoothingMode.None : SmoothingMode.AntiAlias;
test._debugDraw.m_Graphics = graphics;
test._debugDraw.m_Font = m_InfoFont;
m_Scale = viewZoom * System.Math.Min(ClientWidth, ClientHeight) / 39;
m_CenterX = ClientWidth / 2 + m_OffsetX;
m_CenterY = ClientHeight * 0.85 + m_OffsetY;
test._debugDraw.SetViewTransform(m_CenterX, m_CenterY, m_Scale);
m_TPSCounter.Tick();
test.SetTextLine(30);
settings.hz = m_TPSCounter.TPS;// settingsHz;
test.Step(settings);
test.DrawTitle(50, 15, entry.name);
}
public void GetDirectoryContents_ReturnsNoEntries_ForFilePaths()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot"),
TestEntry.File("site.css")));
var provider = new ManifestEmbeddedFileProvider(assembly);
// Act
var contents = provider.GetDirectoryContents("site.css");
// Assert
Assert.IsType <NotFoundDirectoryContents>(contents);
}
/// <summary>
/// Gets test entry from stored test entries.
/// </summary>
/// <param name="executionId"></param>
/// <returns>Test entry</returns>
private TestEntry GetTestEntry(Guid executionId)
{
TestEntry testEntry = null;
if (executionId != Guid.Empty)
{
this.entries.TryGetValue(executionId, out testEntry);
if (testEntry == null)
{
this.innerTestEntries.TryGetValue(executionId, out testEntry);
}
}
return(testEntry);
}
public void EnterTests()
{
_testEntries.Clear();
var count = Convert.ToInt32(Console.ReadLine());
for (var i = 0; i < count; i++)
{
Console.WriteLine("Enter Student's Name:");
var testEntry = new TestEntry();
testEntry.StudentName = Console.ReadLine();
Console.WriteLine("Enter Student's Score:");
testEntry.Score = Convert.ToInt32(Console.ReadLine());
_testEntries.Add(testEntry);
}
}
public void Entry_CompareEntry_CompareDescriptionAndTitle()
{
var entry1 = TestEntry.CreateEntry("Test Entry", 5, 2);
var entry2 = TestEntry.CreateEntry("Test Entry", 5, 2);
// check to see if they contain the same simple types
Assert.True(entry1.CompareTo(entry1) == 0);
Assert.True(entry1.CompareTo(entry2) == 0);
// change a simple type
entry2.Title = "Test Entry 2";
Assert.True(entry1.CompareTo(entry2) == 1, "entry1 is equal to entry2");
entry2.Description = "Some Description";
Assert.True(entry1.CompareTo(entry2) == 1);
}
public void BlogDataService_CreateGetDeleteEntry_Successful(IBlogDataService blogdataservice)
{
var entry = TestEntry.CreateEntry(String.Format("Test Entry"), 5, 2);
blogdataservice.SaveEntry(entry, null);
var dt = DateTime.Now;
var returnEntry = blogdataservice.GetEntry(entry.EntryId);
Assert.Equal(0, entry.CompareTo(returnEntry));
blogdataservice.DeleteEntry(entry.EntryId, null);
var entryFailRetrieval = blogdataservice.GetEntry(entry.EntryId);
Assert.Null(entryFailRetrieval);
}
public void TestSmartStack()
{
SmartStack<TestEntry> stack = new SmartStack<TestEntry>();
Assert.IsTrue(stack.IsEmpty && stack.Count == 0 && stack.Peek() == null);
// make an empty something
TestEntry e1 = new TestEntry();
Assert.IsTrue(e1.pushCount == 0 && e1.popCount == 0 && e1.activationCount == 0 && e1.deactivationCount == 0);
Assert.IsNull(e1.container);
Assert.IsFalse(e1.IsActive);
Assert.IsFalse(e1.IsOnStack);
// push it! make sure it's there, and got notified appropriately
stack.Push(e1);
Assert.IsTrue(stack.Peek() == e1 && stack.Count == 1 && !stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 1);
Assert.IsTrue(e1.IsOnStack);
Assert.IsTrue(e1.IsActive);
// push something else. this should deactivate but not pop the first one
TestEntry e2 = new TestEntry();
stack.Push(e2);
Assert.IsTrue(stack.Peek() == e2 && stack.Count == 2 && !stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 1); // same as before, but
Assert.IsTrue(e1.IsOnStack);
Assert.IsFalse(e1.IsActive); // ...this is no longer true
Assert.IsTrue(e1.deactivationCount == 1); // because it's been deactivated (not on top anymore)
// pop that something else, let's verify e1 is activated
var popped = stack.Pop();
Assert.IsTrue(popped == e2);
Assert.IsTrue(stack.Peek() == e1 && stack.Count == 1 && !stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 2); // activations incremented
Assert.IsTrue(e1.deactivationCount == 1); // deactivations unchanged
Assert.IsTrue(e1.IsActive);
// now pop the last thing
var popped2 = stack.Pop();
Assert.IsTrue(popped2 == e1);
Assert.IsTrue(stack.Peek() == null && stack.Count == 0 && stack.IsEmpty);
Assert.IsTrue(e1.pushCount == 1 && e1.activationCount == 2); // activations unchanged
Assert.IsTrue(e1.deactivationCount == 2 && e1.popCount == 1); // deactivations and popped incremented
Assert.IsFalse(e1.IsActive); // none of these is true anymore
Assert.IsFalse(e1.IsOnStack);
Assert.IsNull(e1.container);
}
public ActionResult Delete(TestEntry entry)
{
if (entry == null)
{
return(RedirectToAction("Error"));
}
foreach (TestEntry e in testEntryList)
{
if (e.ID == entry.ID)
{
testEntryList.Remove(e);
break;
}
}
return(RedirectToAction("List"));
}
public void ShouldResolveFullName()
{
// Arrange
const string name = "Test";
// Act
var entry = new TestEntry(name);
// Assert
var fullName = entry.FullName;
Assert.EndsWith(name, fullName);
var hasRoot = Path.IsPathRooted(fullName);
Assert.True(hasRoot);
}
public void BlogDataService_GetEntryForEditDelete_Successful(IBlogDataService blogdataservice)
{
var entry = TestEntry.CreateEntry(String.Format("Test Entry 2"), 5, 2);
blogdataservice.SaveEntry(entry, null);
var dt = DateTime.Now;
var returnEntry = blogdataservice.GetEntryForEdit(entry.EntryId);
Assert.NotNull(returnEntry);
blogdataservice.DeleteEntry(entry.EntryId, null);
var entryFailRetrieval = blogdataservice.GetEntry(entry.EntryId);
Assert.Null(entryFailRetrieval);
}
public void SessionCache_Get_HandleNullValue()
{
// Arrange
var key = Guid.NewGuid().ToString();
TestEntry value = null;
var sut = this.SessionCache;
sut.Set(key, value);
// Act
var entry = sut.Get <TestEntry>(key);
// Assert
Assert.IsTrue(sut.Contains(key));
Assert.IsNull(entry);
}
public void GetFileInfo_ResolveNonExistingFile_ReturnsNotFoundFileInfo()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
var provider = new ManifestEmbeddedFileProvider(assembly);
// Act
var file = provider.GetFileInfo("some/non/existing/file.txt");
// Assert
Assert.IsType <NotFoundFileInfo>(file);
}
public void GetFileInfo_EscapingFromTheRootFolder_ReturnsNotFound()
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var jqueryValidate = provider.GetFileInfo(Path.Combine("..", "wwwroot", "jquery.validate.js"));
Assert.IsType <NotFoundFileInfo>(jqueryValidate);
}
public void GetDirectoryContents_ReturnsNotFoundDirectoryContents_ForPathsWithInvalidCharacters(string path)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var directory = provider.GetDirectoryContents(path);
Assert.IsType <NotFoundDirectoryContents>(directory);
}
private void StartTest(int index)
{
// save previous flags
DebugViewFlags flags = (DebugViewFlags)0;
if (_test != null)
{
flags = _test.DebugView.Flags;
}
_entry = TestEntries.TestList[index];
_test = _entry.CreateTest();
_test.GameInstance = this;
_test.Initialize();
// re-enable previous flags
_test.DebugView.Flags |= flags;
}
public void ScopedFileProvider_DoesNotReturnFilesOutOfScope(string path)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js")),
TestEntry.File("site.css")));
var provider = new ManifestEmbeddedFileProvider(assembly);
var scopedProvider = new ManifestEmbeddedFileProvider(assembly, provider.Manifest.Scope("wwwroot"), DateTimeOffset.UtcNow);
// Act
var jqueryValidate = scopedProvider.GetFileInfo(path);
// Assert
Assert.IsType <NotFoundFileInfo>(jqueryValidate);
}
public ActionResult Edit(TestEntry entry)
{
if (!ModelState.IsValid)
{
ViewBag.Message = "There was an editing error:";
return(View("Edit", entry));
}
foreach (TestEntry e in testEntryList)
{
if (e.ID == entry.ID)
{
e.sum += entry.sum;
e.amount++;
break;
}
}
return(RedirectToAction("List"));
}
public void TestAddRemove()
{
// let's test ICollection<T> functions
SmartStack <TestEntry> stack = new SmartStack <TestEntry>();
Assert.IsTrue(stack.IsEmpty && stack.Count == 0 && stack.Peek() == null);
// make an empty something
TestEntry e1 = new TestEntry();
stack.Push(e1);
TestEntry e2 = new TestEntry();
stack.Push(e2);
TestEntry e3 = new TestEntry();
stack.Add(e3); // this should be the same as push
Assert.IsTrue(stack.Peek() == e3);
Assert.IsTrue(stack.Count == 3);
// verify that the one in the middle was activated and deactivated only once
Assert.IsTrue(e2.activationCount == 1 && e2.deactivationCount == 1);
Assert.IsTrue(e2.pushCount == 1 && e2.popCount == 0);
// now remove from the middle
bool result = stack.Remove(e2);
Assert.IsTrue(result);
Assert.IsTrue(stack.Count == 2);
Assert.IsTrue(stack.Peek() == e3);
// make sure removed item didn't get re/deactivated, only removed
Assert.IsTrue(e2.activationCount == 1 && e2.deactivationCount == 1);
Assert.IsTrue(e2.pushCount == 1 && e2.popCount == 1);
Assert.IsFalse(e2.IsOnStack);
// make sure we can't remove things that aren't there
Assert.IsFalse(stack.Remove(e2)); // double remove
Assert.IsFalse(stack.Remove(null)); // something that isn't there
}
public void GetFileInfo_ReturnsNotFoundfileInfo_ForPathsWithInvalidCharacters(string path)
{
// Arrange
var assembly = new TestAssembly(
TestEntry.Directory("unused",
TestEntry.Directory("wwwroot",
TestEntry.File("jquery.validate.js"),
TestEntry.File("jquery.min.js"),
TestEntry.File("site.css"))));
// Act
var provider = new ManifestEmbeddedFileProvider(assembly);
// Assert
var file = provider.GetFileInfo(path);
Assert.IsType <NotFoundFileInfo>(file);
Assert.Equal(path, file.Name);
}
protected static bool TryCreateFactoryFromRuntimeHost(TestEntry entry, ICollection <Exception> exceptions, out DbProviderFactory factory)
{
try
{
factory = (DbProviderFactory)RuntimeHost.Current.CreateInstance(
serviceProvider: null,
entry.AssemblyName,
entry.DBProviderFactoryTypeName);
return(true);
}
catch (Exception ex)
{
// Ignore, check if we could load the assembly
exceptions.Add(ex);
}
// Try to create from current domain in case of a successfully loaded assembly
return(TryCreateFromCurrentDomain(entry, exceptions, out factory));
}
static void makeTest(
int childrenCount,
int sweetsCount,
params int[] funcParams)
{
TestEntry e = new TestEntry();
e.childrenCount = childrenCount;
e.sweetsCount = sweetsCount;
e.childrenLikes = new int[childrenCount][];
int beg = 0;
int end = 0;
for (int i = 0; i < childrenCount; ++i)
{
end = System.Array.IndexOf(funcParams, -1, beg);
e.childrenLikes[i] = new int[end - beg];
for (int j = beg; j < end; ++j)
{
e.childrenLikes[i][j - beg] = funcParams[j];
}
beg = end + 1;
}
end = System.Array.IndexOf(funcParams, -1, beg);
e.childrenLimits = new int[end - beg];
System.Array.Copy(funcParams, beg, e.childrenLimits, 0, end - beg);
beg = end + 1;
end = System.Array.IndexOf(funcParams, -1, beg);
e.sweetsLimits = new int[end - beg];
System.Array.Copy(funcParams, beg, e.sweetsLimits, 0, end - beg);
beg = end + 1;
e.flow1 = funcParams[beg++];
e.flow2 = funcParams[beg++];
System.Diagnostics.Debug.Assert(funcParams[beg] == -2, "Invalid params");
tests.Add(e);
}
static private bool testTask1(int num, TestEntry e)
{
int[] sweets = null;
var resultFlow1 = Sweets.Task1(
e.childrenCount,
e.sweetsCount,
e.childrenLikes,
out sweets);
bool test1Result = true;
// Check if result is as expected
test1Result = test1Result && resultFlow1 == e.flow1;
// Check if sweets exists
test1Result = test1Result && sweets != null;
// sweets table should have proper size
test1Result = test1Result && sweets.Length == e.childrenCount;
// Check if child really likes sweet it gets
for (int i = 0; test1Result && i < e.childrenCount; ++i)
{
test1Result = sweets[i] == -1 || System.Array.IndexOf(e.childrenLikes[i], sweets[i]) != -1;
}
// Check if every sweet is given only once
if (test1Result)
{
System.Array.Sort(sweets);
for (int i = 1; test1Result && i < e.childrenCount; ++i)
{
test1Result = sweets[i] == -1 || sweets[i - 1] != sweets[i];
}
}
System.Console.WriteLine("Test {0}: \t{1}", num, test1Result ? "OK": "FAIL");
return(test1Result);
}
public void TestAddRemove()
{
// let's test ICollection<T> functions
SmartStack<TestEntry> stack = new SmartStack<TestEntry>();
Assert.IsTrue(stack.IsEmpty && stack.Count == 0 && stack.Peek() == null);
// make an empty something
TestEntry e1 = new TestEntry();
stack.Push(e1);
TestEntry e2 = new TestEntry();
stack.Push(e2);
TestEntry e3 = new TestEntry();
stack.Add(e3); // this should be the same as push
Assert.IsTrue(stack.Peek() == e3);
Assert.IsTrue(stack.Count == 3);
// verify that the one in the middle was activated and deactivated only once
Assert.IsTrue(e2.activationCount == 1 && e2.deactivationCount == 1);
Assert.IsTrue(e2.pushCount == 1 && e2.popCount == 0);
// now remove from the middle
bool result = stack.Remove(e2);
Assert.IsTrue(result);
Assert.IsTrue(stack.Count == 2);
Assert.IsTrue(stack.Peek() == e3);
// make sure removed item didn't get re/deactivated, only removed
Assert.IsTrue(e2.activationCount == 1 && e2.deactivationCount == 1);
Assert.IsTrue(e2.pushCount == 1 && e2.popCount == 1);
Assert.IsFalse(e2.IsOnStack);
// make sure we can't remove things that aren't there
Assert.IsFalse(stack.Remove(e2)); // double remove
Assert.IsFalse(stack.Remove(null)); // something that isn't there
}
public void ShouldHandleFatalException()
{
Exception causeException = new Exception();
Entry entry = new TestEntry();
ILog logger = _mocks.DynamicMock<ILog>();
Expect.Call(() => logger.Fatal("Exception processing: " + entry, causeException));
_mocks.ReplayAll();
IExceptionHandler exceptionHandler = new FatalExceptionHandler(logger);
try
{
exceptionHandler.Handle(causeException, entry);
Assert.Fail("No exception was thrown");
}
catch (ApplicationException ex)
{
Assert.AreEqual(causeException, ex.InnerException);
}
_mocks.VerifyAll();
}
public void EntryIsDuplicateIsFalseForNonMatchingHash()
{
//Arrange
var mockService = new Mock<IFactorsService> { CallBase = true };
var mockContext = new Mock<DataContext> { CallBase = true };
var entryId = Guid.NewGuid();
var testEntry = new TestEntry { TestValue = "test3",Id = entryId};
var mockDataEntry = new FakeDbSet<DataEntry>(new[]
{
new TestEntry {TestValue = "test"},
new TestEntry {TestValue = "test"},
testEntry
});
mockContext
.SetupGet(context => context.DataEntries)
.Returns(mockDataEntry);
var sut = new CalculationDataContext(mockContext.Object, mockService.Object);
//Act
var actual = sut.EntryIsDuplicate(entryId, testEntry.Hash);
//Assert
Assert.IsFalse(actual);
}
public void TestSmartQueuePushHead()
{
SmartQueue<TestEntry> q = new SmartQueue<TestEntry>();
Assert.IsTrue(q.IsEmpty && q.Count == 0 && q.Head == null);
// enqueue e1 and e2 onto the queue
TestEntry e1 = new TestEntry();
TestEntry e2 = new TestEntry();
q.Enqueue(e1);
q.Enqueue(e2);
Assert.IsTrue(q.Head == e1 && q.Tail == e2 && q.Count == 2);
Assert.IsTrue(e1.IsEnqueued);
Assert.IsTrue(e1.IsActive);
// now push back something in front of e1
TestEntry h = new TestEntry();
q.PushHead(h);
Assert.IsTrue(q.Head == h && q.Tail == e2 && q.Count == 3);
Assert.IsTrue(h.IsActive && h.IsEnqueued);
Assert.IsTrue(e1.IsEnqueued);
Assert.IsFalse(e1.IsActive); // no longer the head
Assert.IsTrue(e1.pushedBackCount == 1); // it knows it got pushed back
// now let's dequeue it and verify we're back to previous state
var popped = q.Dequeue();
Assert.IsTrue(popped == h);
Assert.IsFalse(h.IsActive);
Assert.IsFalse(h.IsEnqueued);
Assert.IsTrue(q.Head == e1 && q.Tail == e2 && q.Count == 2);
Assert.IsTrue(e1.IsActive && e1.IsEnqueued);
Assert.IsTrue(e1.pushedBackCount == 1);
}
static void SimulationLoop() {
Vec2 oldCenter = settings.viewCenter;
settings.hz = settingsHz;
test.Step(settings);
test.DrawTitle(entry.name);
if (testSelection != testIndex) {
testIndex = testSelection;
entry = g_testEntries[testIndex];
test = entry.createFcn();
viewZoom = 12.0f;
camera.SetZoom(viewZoom);
settings.viewCenter.Set(0.0f, 20.0f);
}
}
public static void Main(string[] args) {
g_testEntries = AllTests.GetTests();
testCount = g_testEntries.Count();
testIndex = Math.Max(0, Math.Min(testIndex, testCount - 1));
testSelection = testIndex;
entry = g_testEntries[testIndex];
test = entry.createFcn();
GraphicsManager.SetWindowState(OpenTK.WindowState.Maximized);
string title = String.Format("Box2D Version {0}.{1}.{2}", Settings._version.major, Settings._version.minor, Settings._version.revision);
GraphicsManager.SetTitle(title);
camera = new Camera2D();
camera.OnRender += SimulationLoop;
camera.SetZoom(12);
camera.CenterOnTarget(true);
camera.SetLocation(0, 0);
GraphicsManager.Update += new GraphicsManager.Updater(GraphicsManager_Update);
WindowControl glui = new WindowControl(MainCanvas.GetCanvas());
glui.Dock = Gwen.Pos.Left;
Label text = new Label(glui);
text.Text = "Tests";
text.SetPosition(10, 10);
testList = new ListBox(glui);
testList.RowSelected += delegate(Base sender, ItemSelectedEventArgs tlargs) {
testSelection = testList.SelectedRowIndex;
};
foreach (TestEntry e in g_testEntries) {
testList.AddRow(e.name, "", e);
}
testList.SelectedRowIndex = testSelection;
testList.SetPosition(10, 30);
testList.SetSize(170, 180);
//glui.add_separator();
Base SettingsBox = new Base(glui);
SettingsBox.SetSize(200, 185);
SettingsBox.SetPosition(0, 250);
{
NumericUpDown spinner = new NumericUpDown(SettingsBox);
spinner.Text = "Vel Iters";
spinner.Min = 1;
spinner.Max = 500;
spinner.ValueChanged += delegate(Base sender, EventArgs vcargs) {
settings.velocityIterations = (int)spinner.Value;
};
spinner.Value = settings.velocityIterations;
spinner.SetPosition(10, 10);
NumericUpDown posSpinner = new NumericUpDown(SettingsBox);
posSpinner.Min = 0;
posSpinner.Max = 100;
posSpinner.Text = "Pos Iters";
posSpinner.ValueChanged += delegate(Base sender, EventArgs psargs) {
settings.positionIterations = (int)posSpinner.Value;
};
posSpinner.Value = settings.positionIterations;
posSpinner.SetPosition(10, 35);
NumericUpDown hertzSpinner = new NumericUpDown(SettingsBox);
hertzSpinner.Text = "Hertz";
hertzSpinner.Min = 5;
hertzSpinner.Max = 200;
hertzSpinner.ValueChanged += delegate(Base sender, EventArgs hargs) {
settingsHz = hertzSpinner.Value;
};
hertzSpinner.Value = settingsHz;
hertzSpinner.SetPosition(10, 60);
LabeledCheckBox scb = new LabeledCheckBox(SettingsBox);
scb.Text = "Sleep";
scb.CheckChanged += delegate(Base sender, EventArgs argsscb) {
settings.enableSleep = scb.IsChecked;
};
scb.IsChecked = settings.enableSleep;
scb.SetPosition(10, 85);
LabeledCheckBox wsu = new LabeledCheckBox(SettingsBox);
wsu.Text = "Warm Starting";
wsu.CheckChanged += delegate(Base sender, EventArgs argsscb) {
settings.enableWarmStarting = wsu.IsChecked;
};
wsu.IsChecked = settings.enableWarmStarting;
wsu.SetPosition(10, 110);
LabeledCheckBox toi = new LabeledCheckBox(SettingsBox);
toi.Text = "Time of Impact";
toi.CheckChanged += delegate(Base sender, EventArgs argsscb) {
settings.enableContinuous = toi.IsChecked;
};
toi.IsChecked = settings.enableContinuous;
toi.SetPosition(10, 135);
LabeledCheckBox ssb = new LabeledCheckBox(SettingsBox);
ssb.Text = "Sub-Stepping";
ssb.CheckChanged += delegate(Base sender, EventArgs argsscb) {
settings.enableSubStepping = ssb.IsChecked;
};
ssb.IsChecked = settings.enableSubStepping;
ssb.SetPosition(10, 160);
}
Base drawPanel = new Base(glui);
drawPanel.Dock = Gwen.Pos.Bottom;
drawPanel.SetSize(200, 225);
{
LabeledCheckBox cbShapes = new LabeledCheckBox(drawPanel);
cbShapes.Text = "Shapes";
cbShapes.IsChecked = settings.drawShapes;
cbShapes.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawShapes = cbShapes.IsChecked;
};
cbShapes.SetPosition(10, 10);
//glui.add_checkbox_to_panel(drawPanel, "Joints", &settings.drawJoints);
LabeledCheckBox cbJoints = new LabeledCheckBox(drawPanel);
cbJoints.Text = "Joints";
cbJoints.IsChecked = settings.drawJoints;
cbJoints.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawJoints = cbJoints.IsChecked;
};
cbJoints.SetPosition(10, 30);
//glui.add_checkbox_to_panel(drawPanel, "AABBs", &settings.drawAABBs);
LabeledCheckBox cbAABBs = new LabeledCheckBox(drawPanel);
cbAABBs.Text = "AABBs";
cbAABBs.IsChecked = settings.drawAABBs;
cbAABBs.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawAABBs = cbAABBs.IsChecked;
};
cbAABBs.SetPosition(10, 50);
//glui.add_checkbox_to_panel(drawPanel, "Contact Points", &settings.drawContactPoints);
LabeledCheckBox cbPoints = new LabeledCheckBox(drawPanel);
cbPoints.Text = "Contact Points";
cbPoints.IsChecked = settings.drawContactPoints;
cbPoints.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawContactPoints = cbPoints.IsChecked;
};
cbPoints.SetPosition(10, 70);
//glui.add_checkbox_to_panel(drawPanel, "Contact Normals", &settings.drawContactNormals);
LabeledCheckBox cbNormals = new LabeledCheckBox(drawPanel);
cbNormals.Text = "Contact Normals";
cbNormals.IsChecked = settings.drawContactNormals;
cbNormals.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawContactNormals = cbNormals.IsChecked;
};
cbNormals.SetPosition(10, 90);
//glui.add_checkbox_to_panel(drawPanel, "Contact Impulses", &settings.drawContactImpulse);
LabeledCheckBox cbImpulses = new LabeledCheckBox(drawPanel);
cbImpulses.Text = "Contact Impulses";
cbImpulses.IsChecked = settings.drawContactImpulse;
cbImpulses.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawContactImpulse = cbImpulses.IsChecked;
};
cbImpulses.SetPosition(10, 110);
//glui.add_checkbox_to_panel(drawPanel, "Friction Impulses", &settings.drawFrictionImpulse);
LabeledCheckBox cbFriction = new LabeledCheckBox(drawPanel);
cbFriction.Text = "Friction Impulses";
cbFriction.IsChecked = settings.drawFrictionImpulse;
cbFriction.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawFrictionImpulse = cbFriction.IsChecked;
};
cbFriction.SetPosition(10, 130);
//glui.add_checkbox_to_panel(drawPanel, "Center of Masses", &settings.drawCOMs);
LabeledCheckBox cbMasses = new LabeledCheckBox(drawPanel);
cbMasses.Text = "Center of Masses";
cbMasses.IsChecked = settings.drawCOMs;
cbMasses.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawCOMs = cbMasses.IsChecked;
};
cbMasses.SetPosition(10, 150);
//glui.add_checkbox_to_panel(drawPanel, "Statistics", &settings.drawStats);
LabeledCheckBox cbStatistics = new LabeledCheckBox(drawPanel);
cbStatistics.Text = "Statistics";
cbStatistics.IsChecked = settings.drawStats;
cbStatistics.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawStats = cbStatistics.IsChecked;
};
cbStatistics.SetPosition(10, 170);
//glui.add_checkbox_to_panel(drawPanel, "Profile", &settings.drawProfile);
LabeledCheckBox cbProfile = new LabeledCheckBox(drawPanel);
cbProfile.Text = "Profile";
cbProfile.IsChecked = settings.drawProfile;
cbProfile.CheckChanged += delegate(Base cbshapes, EventArgs eacbshapes) {
settings.drawProfile = cbProfile.IsChecked;
};
cbProfile.SetPosition(10, 190);
}
Base Buttons = new Base(glui);
Buttons.Dock = Gwen.Pos.Bottom;
Buttons.Height = 100;
{
Button btnPause = new Button(Buttons);
btnPause.Text = "Pause";
btnPause.IsToggle = true;
btnPause.SetPosition(10, 10);
btnPause.ToggleState = settings.pause;
btnPause.Clicked += delegate(Base sender, ClickedEventArgs evargs) {
settings.pause = btnPause.ToggleState;
};
Button btnSS = new Button(Buttons);
btnSS.Text = "Single Step";
btnSS.SetPosition(10, 40);
btnSS.Clicked += delegate(Base sender, ClickedEventArgs evargs) {
SingleStep();
};
Button btnRestart = new Button(Buttons);
btnRestart.Text = "Restart";
btnRestart.SetPosition(10, 70);
btnRestart.Clicked += delegate(Base sender, ClickedEventArgs evargs) {
Restart();
};
}
glui.SetSize(200, 300);
GraphicsManager.Start();
}
static void Restart()
{
entry = g_testEntries[testIndex];
test = entry.createFcn();
}
