public void addAllVerticalPointsToListTest()
{
List<Point> list = new List<Point>();
List<Point> listExpected = new List<Point>();
int miny = 0;
int maxy = 4;
int x = 1;
listExpected.Add(new Point(x, 0));
listExpected.Add(new Point(x, 1));
listExpected.Add(new Point(x, 2));
listExpected.Add(new Point(x, 3));
listExpected.Add(new Point(x, 4));
ArraySpaceUtilities.addAllVerticalPointsToList(ref list, miny, maxy, x, true);
Assert.AreEqual(listExpected.Count, list.Count);
Point[] listasarray = list.ToArray();
Point[] expectedlistasarray = listExpected.ToArray();
for (int i = 0; i < listasarray.Length; i++)
{
Assert.AreEqual(true, listasarray[i].Equals(expectedlistasarray[i]));
}
listExpected.Reverse();
list.Clear();
ArraySpaceUtilities.addAllVerticalPointsToList(ref list, miny, maxy, x, false);
Assert.AreEqual(listExpected.Count, list.Count);
listasarray = list.ToArray();
expectedlistasarray = listExpected.ToArray();
for (int i = 0; i < listasarray.Length; i++)
{
Assert.AreEqual(true, listasarray[i].Equals(expectedlistasarray[i]));
}
}
public void DoesMaxHeapifyTest5()
{
List<int> sourceData = new List<int>(new int[] { -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5 });
sourceData.Reverse();
sourceData.HeapifyMax();
var isHeap = IsMaxHeap(sourceData);
Assert.IsTrue(isHeap);
}
public void TestMethod1()
{
Priority[] expectedValue = new Priority[] { Priority.High, Priority.High, Priority.Medium, Priority.Medium, Priority.Low, Priority.Low };
Priority[] actualValue = new Priority[] { Priority.Low, Priority.Medium, Priority.High, Priority.Medium, Priority.High, Priority.Low };
Quicksort(actualValue, 0, 5);
List<Priority> reverted = new List<Priority>(actualValue);
reverted.Reverse();
CollectionAssert.AreEqual(expectedValue, reverted);
}
public List<Candidate> InsertionSort(List<Candidate> list)
{
int i, j;
for (i = 1; i < list.Count; i++)
{
for (int k = i; k > 0 && list[k].numberOfVotes < list[k - 1].numberOfVotes; k--)
Swap(list, k, k - 1);
}
list.Reverse();
return list;
}
public int[] PlusOne(int[] digits)
{
digits = digits.Reverse().ToArray();
List<int> res = new List<int>();
int carry = 1;
for (int i = 0; i < digits.Length; i++)
{
int newNumber = digits[i] + carry;
res.Add(newNumber % 10);
carry = newNumber / 10;
}
if (carry > 0)
{
res.Add(carry);
}
res.Reverse();
return res.ToArray();
}
public void TestPop()
{
var dynamicStack = new DynamicStack<int>();
var list = new List<object>();
for (int i = 0; i < 1000; i++)
{
dynamicStack.Push(i);
list.Add(i);
}
for (int i = 0; i < 50; i++)
{
dynamicStack.Pop();
}
list.RemoveRange(950, 50);
list.Reverse();
var expected = list.ToArray();
var actual = dynamicStack.ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void testBunchOfInsertionsAndDeletions()
{
var list = new List<double> { 74, 101, 11, 1000, 4, -101, -1000 };
var maxHeap = new MaxHeap();
list.ForEach(elem => maxHeap.Add(elem));
list.Sort();
list.Reverse();
var maxes = new List<double>();
for (int i = 0; i < list.Count; i++)
{
maxes.Add(maxHeap.removeMax());
}
List<Tuple<double, double>> expectedVsActual = list.Zip(maxes, Tuple.Create).ToList();
foreach(var tuple in expectedVsActual)
{
Assert.AreEqual(tuple.Item1, tuple.Item2);
}
}
public void TestForwardBackward()
{
var assembly = Assembly.GetAssembly(typeof (BookmarkEnumeratorTest));
var stream = assembly.GetManifestResourceStream(
typeof (BookmarkEnumeratorTest).Namespace + ".BookmarkEnumeratorTest.sky");
Assert.IsNotNull(stream);
var document = (SrmDocument) new XmlSerializer(typeof (SrmDocument)).Deserialize(stream);
Assert.IsNotNull(document);
var forwardEnumerator = new BookmarkEnumerator(document);
var backwardEnumerator = new BookmarkEnumerator(forwardEnumerator) {Forward = false};
var forwardList = new List<Bookmark>(forwardEnumerator);
var backwardList = new List<Bookmark>(backwardEnumerator);
Assert.AreNotEqual(0, forwardList.Count);
Assert.AreEqual(forwardList.Count, backwardList.Count);
// The very last location is the same for both the forwards and backwards enumerators.
backwardList.Reverse(0, backwardList.Count - 1);
CollectionAssert.AreEqual(forwardList, backwardList);
var forwardSet = new HashSet<Bookmark>(forwardList);
Assert.AreEqual(forwardList.Count, forwardSet.Count);
forwardSet.UnionWith(backwardList);
Assert.AreEqual(forwardList.Count, forwardSet.Count);
}
public void TestTemp()
{
using (HarperACL.ACLDataDataContext context = new HarperACL.ACLDataDataContext(ConfigurationManager.ConnectionStrings["AHT_MainConnectionString"].ConnectionString))
{
//var lastcustomer = (from a in context.Customers
// select new { cusnum = long.Parse(a.cusCustNum) })
// .OrderByDescending(x => x.cusnum)
// .ToList();
for (int i = 0; i < 20; i++)
{
DateTime end1 = new DateTime();
DateTime end2 = new DateTime();
DateTime start1 = new DateTime();
DateTime start2 = new DateTime();
start1 = DateTime.Now;
var lastcustomer1 = (from a in context.Customers
select new { cusnum = Convert.ToInt64(a.cusCustNum) })
.OrderByDescending(x => x.cusnum)
.Take(1).Single();
long newcustnum = lastcustomer1.cusnum + 1;
end1 = DateTime.Now;
start2 = DateTime.Now;
newcustnum = 0;
List<string> lastcustomer = (from a in context.Customers
select a.cusCustNum).ToList();
List<long> cusnumbs = new List<long>();
foreach (string cus in lastcustomer)
{
cusnumbs.Add(long.Parse(cus));
}
cusnumbs.Sort();
cusnumbs.Reverse();
newcustnum = cusnumbs[0];
newcustnum++;
end2 = DateTime.Now;
TimeSpan method1 = end1 - start1;
TimeSpan method2 = end2 - start2;
System.Diagnostics.Debug.WriteLine(string.Format("Old {0}: vs New: {1}", new object[] { method2.TotalMilliseconds, method1.TotalMilliseconds }));
}
}
}
private void OneRefactorTest(string newName, string caretText, FileInput[] inputs, Version version, bool preview, string error, ExpectedPreviewItem[] expected = null) {
Console.WriteLine("Replacing {0} with {1}", caretText, newName);
version = version ?? new Version(2, 7);
for (int loops = 0; loops < 2; loops++) {
var views = new List<PythonEditor>();
try {
var mainView = new PythonEditor(inputs[0].Input, version.ToLanguageVersion(), _vs, filename: inputs[0].Filename);
var analyzer = mainView.Analyzer;
views.Add(mainView);
var bufferTable = new Dictionary<string, ITextBuffer> {
{ inputs[0].Filename, mainView.CurrentSnapshot.TextBuffer }
};
foreach (var i in inputs.Skip(1)) {
var editor = new PythonEditor(i.Input, version.ToLanguageVersion(), _vs, mainView.Factory, analyzer, i.Filename);
views.Add(editor);
bufferTable[i.Filename] = editor.CurrentSnapshot.TextBuffer;
}
// test runs twice, one w/ original buffer, once w/ re-analyzed buffers.
if (loops == 1) {
// do it again w/ a changed buffer
mainView.Text = mainView.Text;
}
var caretPos = inputs[0].Input.IndexOf(caretText);
mainView.View.MoveCaret(new SnapshotPoint(mainView.CurrentSnapshot, caretPos));
var extractInput = new RenameVariableTestInput(newName, bufferTable, preview);
var previewChangesService = new TestPreviewChanges(expected);
new VariableRenamer(views[0].View.View, _vs.ServiceProvider).RenameVariable(extractInput, previewChangesService);
if (error != null) {
Assert.AreEqual(error, extractInput.Failure);
return;
}
Assert.IsNull(extractInput.Failure, "Unexpected error message: " + (extractInput.Failure ?? ""));
Assert.AreEqual(preview, previewChangesService.Previewed, preview ? "Changes were not previewed" : "Changes were previewed");
AssertUtil.ArrayEquals(inputs.Select(i => i.Output).ToList(), views.Select(v => v.Text).ToList());
} finally {
views.Reverse();
foreach (var v in views) {
v.Dispose();
}
}
}
}
public void ExpressionSetTestImmediateSolveReverseInput()
{
var tests = new List<Tuple<string, string, double>>
{
new Tuple<string, string, double>("a", "2", 2),
new Tuple<string, string, double>("b", "{a}-1", 1),
new Tuple<string, string, double>("c","{a}+{b}", 3),
new Tuple<string, string, double>("d","{a}*{c}", 6),
new Tuple<string, string, double>("e","{d}-{b}", 5),
new Tuple<string, string, double>("f","{e}+4*{b}", 9),
new Tuple<string, string, double>("g","{f}/{c}+1", 4),
new Tuple<string, string, double>("all","({f}/{c}-{g}+{b})*({a}+{f})+{d}*{e}", 30)
};
tests.Reverse();
var set = new AlgexSet();
set.ImmediateSolve = true;
foreach (var test in tests)
{
set.Add(test.Item1, test.Item2);
}
foreach (var test in tests)
{
Assert.AreEqual(test.Item3, set[test.Item1]);
}
}
public void NodesSortingSparqlOrder()
{
SparqlOrderingComparer comparer = new SparqlOrderingComparer();
//Stream for Output
Console.WriteLine("## Sorting Test");
Console.WriteLine("NULLs < Blank Nodes < URI Nodes < Untyped Literals < Typed Literals");
Console.WriteLine();
//Create a Graph
Graph g = new Graph();
g.BaseUri = new Uri("http://example.org/");
g.NamespaceMap.AddNamespace("", new Uri("http://example.org/"));
//Create a list of various Nodes
List<INode> nodes = new List<INode>();
nodes.Add(g.CreateUriNode(":someUri"));
nodes.Add(g.CreateBlankNode());
nodes.Add(null);
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode("aardvark"));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddDays(-25).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("duck"));
nodes.Add(g.CreateUriNode(":otherUri"));
nodes.Add(g.CreateLiteralNode("1.5", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateUriNode(new Uri("http://www.google.com")));
nodes.Add(g.CreateLiteralNode(DateTime.Now.AddYears(3).ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("23", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("M43d", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateUriNode(new Uri("http://www.dotnetrdf.org")));
nodes.Add(g.CreateLiteralNode("12", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateBlankNode("monkey"));
nodes.Add(g.CreateBlankNode());
nodes.Add(g.CreateLiteralNode("chaese"));
nodes.Add(g.CreateLiteralNode("1.0456345", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("cheese"));
nodes.Add(g.CreateLiteralNode(Convert.ToBase64String(new byte[] { Byte.Parse("32") }), new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("TA==", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBase64Binary)));
nodes.Add(g.CreateLiteralNode("-45454", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode(DateTime.Now.ToString(XmlSpecsHelper.XmlSchemaDateTimeFormat), new Uri(XmlSpecsHelper.XmlSchemaDataTypeDateTime)));
nodes.Add(g.CreateLiteralNode("-3", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Add(g.CreateLiteralNode("242344.3456435", new Uri(XmlSpecsHelper.XmlSchemaDataTypeDouble)));
nodes.Add(g.CreateLiteralNode("true", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateUriNode(":what"));
nodes.Add(null);
nodes.Add(g.CreateLiteralNode("false", new Uri(XmlSpecsHelper.XmlSchemaDataTypeBoolean)));
nodes.Add(g.CreateLiteralNode("invalid-value", new Uri(XmlSpecsHelper.XmlSchemaDataTypeInteger)));
nodes.Sort(comparer);
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
Console.WriteLine();
Console.WriteLine("Now in reverse...");
Console.WriteLine();
nodes.Reverse();
//Output the Results
foreach (INode n in nodes)
{
if (n == null)
{
Console.WriteLine("NULL");
}
else
{
Console.WriteLine(n.ToString());
}
}
}
public void Comments_Are_Ordered_By_Date_Descending()
{
Initialize(true);
using (var repository = new NHibernateBlogService())
{
var comments = new List<Comment>();
for (int i = 0; i < 10; i++)
{
var comment = new Comment() { Name = "test", Content = "Test" };
comments.Add(comment);
Thread.Sleep(1);
}
comments.Reverse();
comments.ForEach(x => repository.Save(x));
Assert.IsTrue(comments.First().DateCreated > comments.Last().DateCreated);
}
using (var repository = new NHibernateBlogService())
{
var loadedComments = repository.GetComments();
Assert.IsFalse(loadedComments.First().DateCreated > loadedComments.Last().DateCreated);
}
}
public void TestReverseCopy_NullDestination_Throws()
{
IReadOnlySublist<List<int>, int> list = new List<int>().ToSublist();
IExpandableSublist<List<int>, int> destination = null;
list.Reverse().CopyTo(destination);
}
public void Reverse()
{
// arrange
List<int> list = new List<int>() { 1, 2, 3 };
// act
list.Reverse();
var actual = list;
// assert
Assert.AreEqual(3, actual[0]);
Assert.AreEqual(2, actual[1]);
Assert.AreEqual(1, actual[2]);
}
public void IsClockwiseTest4()
{
Vector2[] v = new Vector2[] {
new Vector2(1f, 1f),
new Vector2(1f, 0f),
new Vector2(0f, 0f),
new Vector2(0f, 1f),
};
List<Vector2> vList = new List<Vector2>(v);
vList.Reverse();
Assert.IsFalse(MathExt.IsClockwise(vList));
}
public void PerformanceForEach_With80000MixedElements_ShouldIterateOptimally()
{
var Capacity = 80000;
var collection = new LimitedMemoryCollection<int, int>(Capacity);
var records = new List<int>();
for (int i = 0; i < 40000; i++)
{
records.Add(i);
records.Add(79999 - i);
}
foreach (var record in records)
{
collection.Set(record, record);
}
records.Reverse();
var count = 0;
var sw = new Stopwatch();
sw.Start();
foreach (var record in collection)
{
Assert.AreEqual(records[count], record.Key, "Expected Key did not match!");
Assert.AreEqual(records[count++], record.Value, "Expected Value did not match!");
}
var exercutionTime = sw.ElapsedMilliseconds;
Assert.IsTrue(exercutionTime <= 300);
}
public void TestRemoveWithParentNullMethodology()
{
List<SimpleTreeObjectCollection> testObjectList;
SimpleTreeObjectCollection root;
GenerateTestTree(out root, out testObjectList);
List<SimpleTreeObjectCollection> removalList = new List<SimpleTreeObjectCollection>();
testContextInstance.WriteLine("TestRemoveWithParentNullMethodology: Removing all objects Depth-First");
removalList.AddRange(root);
removalList.Reverse();
testContextInstance.WriteLine("TestRemoveWithParentNullMethodology: Removal List: Count={0}", removalList.Count);
testContextInstance.WriteLine("TestRemoveWithParentNullMethodology: Attempting Remove with Parent=Null methodology");
int totalDepthCount = 0;
foreach (var node in removalList)
{
node.Parent = null;
testContextInstance.WriteLine("TestRemoveWithParentNullMethodology: Removed {0}", node);
totalDepthCount += Math.Abs(node.Depth);
}
if (totalDepthCount != 0)
{
throw new AssertFailedException(
String.Format(
CultureInfo.InvariantCulture,
"TestRemoveWithParentNullMethodology: Test was not able to remove the entire tree. {0} nodes, Sum(DepthCount) = {1}",
testObjectList.Count,
totalDepthCount));
}
}
public void TestListReverse()
{
var x = new List<int> { 1, 2, 3 }.ToLiveList();
var i = x.Reverse().ToIndependent();
i.States().Take(1).Check(
() => { },
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connecting);
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 3, 2, 1 }));
Assert.IsTrue(s.Delta == null);
});
i.States().Skip(1).Take(1).Check(
() => x.PublishInner.Insert(0, 0),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 3, 2, 1, 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 3,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 0 },
},
}
}, new IndexNodeComparer<int>()));
});
i.States().Skip(1).Take(1).Check(
() => x.PublishInner.Insert(4, 4),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 4, 3, 2, 1, 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 0,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 4 },
},
}
}, new IndexNodeComparer<int>()));
});
i.States().Skip(1).Take(1).Check(
() => x.PublishInner.Insert(2, -1),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 4, 3, 2, -1, 1, 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 3,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { -1 },
},
}
}, new IndexNodeComparer<int>()));
});
i.States().Skip(1).Take(1).Check(
() => x.PublishInner.RemoveAt(2),
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 4, 3, 2, 1, 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 3,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { -1 },
},
}
}, new IndexNodeComparer<int>()));
});
i.States().Skip(1).Take(1).Check(
() =>
{
x.PublishInner.Insert(2, -1);
x.PublishInner.RemoveAt(4);
},
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 4, 2, -1, 1, 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { 3 },
},
},
new IndexNode<int>
{
Index = 2,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { -1 },
},
},
}, new IndexNodeComparer<int>()));
});
i.States().Skip(1).Take(1).Check(
() =>
{
x.PublishInner.RemoveAt(2);
x.PublishInner.Insert(3, 3);
},
state =>
{
var s = state.Single();
Assert.IsTrue(s.Status == StateStatus.Connected);
Assert.IsTrue(s.Delta.HasChange());
Assert.IsTrue(s.Inner.SequenceEqual(new[] { 4, 3, 2, 1, 0 }));
Assert.IsTrue(s.Delta.IndexDeltas.SequenceEqual(new[]
{
new IndexNode<int>
{
Index = 1,
DenseIndex = 0,
Data = new ListIndexDelta<int>
{
InsertItems = new[] { 3 },
},
},
new IndexNode<int>
{
Index = 3,
DenseIndex = 1,
Data = new ListIndexDelta<int>
{
DeleteItems = new[] { -1 },
},
},
}, new IndexNodeComparer<int>()));
});
}
public void TestConvexHullBuild()
{
List<PointF> pointList = new List<PointF>(
new PointF[]
{
new PointF(0, 100),
new PointF(200, 0),
new PointF(400, 200),
new PointF(800, 300),
new PointF(600, 600),
new PointF(300, 700),
new PointF(200, 600),
new PointF(100, 900)
});
List<PointF> resPointList = ConvexHull.GetConvexHull(pointList);
List<PointF> resToCheckRev = new List<PointF>(globalHull);
resToCheckRev.Reverse();
Assert.IsTrue(resPointList.SequenceEqual(globalHull) || resPointList.SequenceEqual(resToCheckRev));
}
public void TestPullTester()
{
var javaTimeout = (int)TimeSpan.FromMinutes(2).TotalMilliseconds;
// locate java.exe
var javaPath = Path.Combine(Environment.GetEnvironmentVariable("JAVA_HOME"), "bin", "java.exe");
if (!File.Exists(javaPath))
Assert.Inconclusive("java.exe could not be found under JAVA_HOME");
// prepare a temp folder for bitcoinj
string tempFolder;
using (TempDirectory.CreateTempDirectory(out tempFolder))
// initialize kernel
using (var kernel = new StandardKernel())
{
var tempFile = Path.Combine(tempFolder, "BitcoindComparisonTool");
var jarFile = Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location), "pull-tests.jar");
// add logging module
kernel.Load(new ConsoleLoggingModule(LogLevel.Info));
// log startup
var logger = LogManager.GetCurrentClassLogger();
logger.Info($"Starting up: {DateTime.Now}");
// add rules module
var chainType = ChainType.Regtest;
kernel.Load(new RulesModule(chainType));
// add storage module
kernel.Load(new MemoryStorageModule());
kernel.Load(new NetworkMemoryStorageModule());
// initialize the blockchain daemon
using (var coreDaemon = kernel.Get<CoreDaemon>())
{
kernel.Bind<CoreDaemon>().ToConstant(coreDaemon).InTransientScope();
// initialize p2p client
using (var localClient = kernel.Get<LocalClient>())
{
kernel.Bind<LocalClient>().ToConstant(localClient).InTransientScope();
// start the blockchain daemon
coreDaemon.Start();
// find a free port
var port = FindFreePort();
Messaging.Port = port;
// start p2p client
localClient.Start();
// run pull tester
var runLargeReorgs = 0;
var javaProcessInfo = new ProcessStartInfo
{
FileName = javaPath,
Arguments = $"-jar \"{jarFile}\" \"{tempFile}\" {runLargeReorgs} {port}",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true
};
using (var javaProcess = Process.Start(javaProcessInfo))
{
try
{
var errorOccurred = false;
var output = new StringBuilder();
var successOutput = new StringBuilder();
var errorOutput = new StringBuilder();
var onOutput = new DataReceivedEventHandler(
(sender, e) =>
{
if (e.Data?.Contains("ERROR:") ?? false)
errorOccurred = true;
output.AppendLine(e.Data);
if (!errorOccurred)
successOutput.AppendLine(e.Data);
else
errorOutput.AppendLine(e.Data);
});
javaProcess.OutputDataReceived += onOutput;
javaProcess.ErrorDataReceived += onOutput;
javaProcess.BeginOutputReadLine();
javaProcess.BeginErrorReadLine();
var didJavaExit = javaProcess.WaitForExit(javaTimeout);
javaProcess.OutputDataReceived -= onOutput;
javaProcess.ErrorDataReceived -= onOutput;
logger.Info($"Pull Tester Result: {(didJavaExit ? (int?)javaProcess.ExitCode : null)}");
// verify pull tester successfully connected
Assert.IsTrue(output.ToString().Contains(
$"NioClientManager.handleKey: Successfully connected to /127.0.0.1:{port}"),
$"Failed to connect: {output}");
if (errorOccurred || !didJavaExit || javaProcess.ExitCode != 0)
{
// log all success & error output from the comparison tool
string line;
using (var reader = new StringReader(successOutput.ToString()))
while ((line = reader.ReadLine()) != null)
logger.Info(line);
using (var reader = new StringReader(errorOutput.ToString()))
while ((line = reader.ReadLine()) != null)
logger.Error(line);
// don't fail on pull tester result, consensus is not implemented and it will always fail
if (didJavaExit)
Assert.Inconclusive(errorOutput.Length > 0 ? errorOutput.ToString() : output.ToString());
else
{
// if java.exe failed to terminate, log last X lines of output
var lastLinesCount = 20;
var lastLines = new List<string>(lastLinesCount);
var match = Regex.Match(output.ToString(), "^.*$", RegexOptions.Multiline | RegexOptions.RightToLeft);
var count = 0;
while (count < lastLinesCount && (match = match.NextMatch()) != null)
{
lastLines.Add(match.Value);
count++;
}
lastLines.Reverse();
Assert.Fail($"java.exe failed to terminate: {string.Join("", lastLines)}");
}
}
Assert.AreEqual(0, javaProcess.ExitCode);
}
finally
{
// ensure java.exe is terminated
try { javaProcess.Kill(); }
catch (InvalidOperationException) { }
}
}
}
}
}
}
public void Dispose_MultipleItems_DisposesAllItemsInReversedOrder()
{
// Arrange
var scope = new Scope();
var disposedItems = new List<DisposableObject>();
var disposables = new List<DisposableObject>
{
new DisposableObject(disposedItems.Add),
new DisposableObject(disposedItems.Add),
new DisposableObject(disposedItems.Add)
};
disposables.ForEach(scope.RegisterForDisposal);
// Act
scope.Dispose();
disposedItems.Reverse();
// Assert
Assert.IsTrue(disposedItems.SequenceEqual(disposables));
}
public void checkingOrderOfCollection(string CassandraCollectionType, Type TypeOfDataToBeInputed, Type TypeOfKeyForMap = null, string pendingMode = "")
{
string cassandraDataTypeName = QueryTools.convertTypeNameToCassandraEquivalent(TypeOfDataToBeInputed);
string cassandraKeyDataTypeName = "";
string openBracket = CassandraCollectionType == "list" ? "[" : "{";
string closeBracket = CassandraCollectionType == "list" ? "]" : "}";
string mapSyntax = "";
string randomKeyValue = string.Empty;
if (TypeOfKeyForMap != null)
{
cassandraKeyDataTypeName = QueryTools.convertTypeNameToCassandraEquivalent(TypeOfKeyForMap);
mapSyntax = cassandraKeyDataTypeName + ",";
if (TypeOfKeyForMap == typeof(DateTimeOffset))
randomKeyValue = (string)(Randomm.RandomVal(typeof(DateTimeOffset)).GetType().GetMethod("ToString", new Type[] { typeof(string) }).Invoke(Randomm.RandomVal(typeof(DateTimeOffset)), new object[1] { "yyyy-MM-dd H:mm:sszz00" }) + "' : '");
else
randomKeyValue = Randomm.RandomVal(TypeOfDataToBeInputed) + "' : '";
}
string tableName = "table" + Guid.NewGuid().ToString("N");
try
{
Session.Cluster.WaitForSchemaAgreement(
QueryTools.ExecuteSyncNonQuery(Session, string.Format(@"CREATE TABLE {0}(
tweet_id uuid PRIMARY KEY,
some_collection {1}<{2}{3}>
);", tableName, CassandraCollectionType, mapSyntax, cassandraDataTypeName)));
}
catch (AlreadyExistsException)
{
}
Guid tweet_id = Guid.NewGuid();
StringBuilder longQ = new StringBuilder();
longQ.AppendLine("BEGIN BATCH ");
int CollectionElementsNo = 100;
List<Int32> orderedAsInputed = new List<Int32>(CollectionElementsNo);
string inputSide = "some_collection + {1}";
if (CassandraCollectionType == "list" && pendingMode == "prepending")
inputSide = "{1} + some_collection";
for (int i = 0; i < CollectionElementsNo; i++)
{
var data = i * (i % 2);
longQ.AppendFormat(@"UPDATE {0} SET some_collection = " + inputSide + " WHERE tweet_id = {2};"
, tableName, openBracket + randomKeyValue + data + closeBracket, tweet_id.ToString());
orderedAsInputed.Add(data);
}
longQ.AppendLine("APPLY BATCH;");
QueryTools.ExecuteSyncNonQuery(Session, longQ.ToString(), "Inserting...");
if (CassandraCollectionType == "set")
{
orderedAsInputed.Sort();
orderedAsInputed.RemoveRange(0, orderedAsInputed.LastIndexOf(0));
}
else if (CassandraCollectionType == "list" && pendingMode == "prepending")
orderedAsInputed.Reverse();
CqlRowSet rs = Session.Execute(string.Format("SELECT * FROM {0};", tableName), ConsistencyLevel.Default);
using (rs)
{
int ind = 0;
foreach (var row in rs.GetRows())
foreach (var value in row[1] as System.Collections.IEnumerable)
{
Assert.True(orderedAsInputed[ind] == (int)value);
ind++;
}
}
QueryTools.ExecuteSyncQuery(Session, string.Format("SELECT * FROM {0};", tableName));
QueryTools.ExecuteSyncNonQuery(Session, string.Format("DROP TABLE {0};", tableName));
}
public void getArrayIndiciesMarkedByLineTest()
{
//Horizontal line
LineSegment line = new LineSegment(new Point(.5, .5), new Point(5.5, .5));
long arrayspacesizex = 10;
long arrayspacesizey = 10;
List<Point> expected = new List<Point>();
expected.Add(new Point(0, 0));
expected.Add(new Point(1, 0));
expected.Add(new Point(2, 0));
expected.Add(new Point(3, 0));
expected.Add(new Point(4, 0));
expected.Add(new Point(5, 0));
List<Point> actual;
actual = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.Count, actual.Count);
Point[] expectedArray = expected.ToArray();
Point[] actualArray = actual.ToArray();
for (int i = 0; i < expectedArray.Length; i++)
{
Assert.AreEqual(true, actualArray[i].Equals(expectedArray[i]));
}
//Vertical line
line = new LineSegment(new Point(2.5, 1.5), new Point(2.5, 4.5));
expected.Clear();
expected.Add(new Point(2, 1));
expected.Add(new Point(2, 2));
expected.Add(new Point(2, 3));
expected.Add(new Point(2, 4));
expected.Reverse();
actual.Clear();
actual = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.Count, actual.Count);
expectedArray = expected.ToArray();
actualArray = actual.ToArray();
for (int i = 0; i < expectedArray.Length; i++)
{
Assert.AreEqual(true, actualArray[i].Equals(expectedArray[i]));
}
//diagonal line
line = new LineSegment(new Point(0.5, 0.5), new Point(5.5, 2.5));
expected.Clear();
expected.Add(new Point(0, 0));
expected.Add(new Point(1, 0));
expected.Add(new Point(1, 1));
expected.Add(new Point(2, 1));
expected.Add(new Point(3, 1));
expected.Add(new Point(4, 1));
expected.Add(new Point(4, 2));
expected.Add(new Point(5, 2));
actual.Clear();
actual = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.Count, actual.Count);
expectedArray = expected.ToArray();
actualArray = actual.ToArray();
for (int i = 0; i < expectedArray.Length; i++)
{
Assert.AreEqual(true, actualArray[i].Equals(expectedArray[i]));
}
}
public void Remove_5000_Elements_ShouldWorkCorrectly()
{
// Arrange
var customDictionary = new CustomDictionary<string, int>();
var keys = new List<string>();
var count = 5000;
for (int i = 0; i < count; i++)
{
var key = Guid.NewGuid().ToString();
keys.Add(key);
customDictionary.Add(key, i);
}
// Assert
Assert.AreEqual(count, customDictionary.Count);
// Act & Assert
keys.Reverse();
foreach (var key in keys)
{
customDictionary.Remove(key);
count--;
Assert.AreEqual(count, customDictionary.Count);
}
// Assert
var expectedElements = new List<KeyValue<string, int>>();
var actualElements = customDictionary.ToList();
CollectionAssert.AreEquivalent(expectedElements, actualElements);
}
public void TestRanges3()
{
CharSetSolver solver = new CharSetSolver(BitWidth.BV16);
BDD cond = solver.MkCharSetFromRegexCharClass(@"\d");
int cnt = cond.CountNodes();
Pair<uint, uint>[] ranges = solver.ToRanges(cond);
BDD set = solver.MkCharSetFromRanges(ranges);
int nodes = set.CountNodes();
var ranges2 = new List<Pair<uint, uint>>(ranges);
ranges2.Reverse();
BDD set2 = solver.MkCharSetFromRanges(ranges2);
int nodes2 = set.CountNodes();
var ranges3 = solver.ToRanges(set2);
BDD set3 = solver.MkCharSetFromRanges(ranges3);
int cnt2 = set2.CountNodes();
int cnt3 = set3.CountNodes();
Assert.IsTrue(set2 == set3);
Assert.AreEqual<int>(nodes, nodes2);
Assert.AreSame(set,set2);
set.ToDot("digits.dot");
//check equivalence
bool equiv = solver.MkOr(solver.MkAnd(cond, solver.MkNot(set)), solver.MkAnd(set, solver.MkNot(cond))) == solver.False;
Assert.AreEqual<int>(31, ranges.Length);
}
internal static void valueComparator(RowSet rawrowset, List<object[]> insertedRows)
{
var rowset = rawrowset.GetRows().ToList();
Assert.True(rowset.Count == insertedRows.Count, string.Format("Returned rows count is not equal with the count of rows that were inserted! \n Returned: {0} \n Expected: {1} \n", rowset.Count, insertedRows.Count));
int i = 0;
foreach (var row in rowset)
{
if (row.Any(col => col.GetType() == typeof(byte[])))
for (int j = 0; j < row.Length; j++)
Assert.True(row[j].GetType() == typeof(byte[]) ? Assert.ArrEqual((byte[])row[j], (byte[])insertedRows[i][j]) : row[j].Equals(insertedRows[i][j]));
else
{
for (int m = 0; m < row.Length; m++)
{
if (!row[m].Equals(insertedRows[i][m]))
{
insertedRows.Reverse();// To check if needed and why
if (!row[m].Equals(insertedRows[i][m]))
insertedRows.Reverse();
}
Assert.True(row[m].Equals(insertedRows[i][m]), "Inserted data !Equals with returned data.");
}
}
i++;
}
}
