public static void GetSourceTest()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
ConsoleHelpers.Debug("Testing GetSource function with {0} Iterations.", Iterations);
ulong counter = 0;
//var firstLink = links.First();
// Создаём одну связь, из которой будет производить считывание
var firstLink = links.Create();
var sw = Stopwatch.StartNew();
// Тестируем саму функцию
for (ulong i = 0; i < Iterations; i++)
{
counter += links.GetSource(firstLink);
}
var elapsedTime = sw.Elapsed;
var iterationsPerSecond = Iterations / elapsedTime.TotalSeconds;
// Удаляем связь, из которой производилось считывание
links.Delete(firstLink);
ConsoleHelpers.Debug(
"{0} Iterations of GetSource function done in {1} ({2} Iterations per second), counter result: {3}",
Iterations, elapsedTime, (long)iterationsPerSecond, counter);
}
}
public static void CascadeUpdateTest()
{
var itself = _constants.Itself;
using (var scope = new TempLinksTestScope(useLog: true))
{
var links = scope.Links;
var l1 = links.Create();
var l2 = links.Create();
l2 = links.Update(l2, l2, l1, l2);
links.CreateAndUpdate(l2, itself);
links.CreateAndUpdate(l2, itself);
l2 = links.Update(l2, l1);
links.Delete(l2);
Global.Trash = links.Count();
links.Unsync.DisposeIfPossible(); // Close links to access log
Global.Trash = FileHelpers.ReadAll <UInt64LinksTransactionsLayer.Transition>(scope.TempTransactionLogFilename);
}
}
public static void TestGetTarget()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
ConsoleHelpers.Debug("Testing GetTarget function with {0} Iterations.", Iterations);
ulong counter = 0;
//var firstLink = links.First();
var firstLink = links.Create();
var sw = Stopwatch.StartNew();
for (ulong i = 0; i < Iterations; i++)
{
counter += links.GetTarget(firstLink);
}
var elapsedTime = sw.Elapsed;
var iterationsPerSecond = Iterations / elapsedTime.TotalSeconds;
links.Delete(firstLink);
ConsoleHelpers.Debug(
"{0} Iterations of GetTarget function done in {1} ({2} Iterations per second), counter result: {3}",
Iterations, elapsedTime, (long)iterationsPerSecond, counter);
}
}
public static void ConvertersTest()
{
using (var scope = new TempLinksTestScope())
{
const int N = 10;
var links = scope.Links;
var meaningRoot = links.CreatePoint();
var one = links.CreateAndUpdate(meaningRoot, links.Constants.Itself);
var powerOf2ToUnaryNumberConverter = new PowerOf2ToUnaryNumberConverter <ulong>(links, one);
var toUnaryNumberConverter = new AddressToUnaryNumberConverter <ulong>(links, powerOf2ToUnaryNumberConverter);
var random = new System.Random(0);
ulong[] numbers = new ulong[N];
ulong[] unaryNumbers = new ulong[N];
for (int i = 0; i < N; i++)
{
numbers[i] = random.NextUInt64();
unaryNumbers[i] = toUnaryNumberConverter.Convert(numbers[i]);
}
var fromUnaryNumberConverterUsingOrOperation = new UnaryNumberToAddressOrOperationConverter <ulong>(links, powerOf2ToUnaryNumberConverter);
var fromUnaryNumberConverterUsingAddOperation = new UnaryNumberToAddressAddOperationConverter <ulong>(links, one);
for (int i = 0; i < N; i++)
{
Assert.Equal(numbers[i], fromUnaryNumberConverterUsingOrOperation.Convert(unaryNumbers[i]));
Assert.Equal(numbers[i], fromUnaryNumberConverterUsingAddOperation.Convert(unaryNumbers[i]));
}
}
}
public static void TestRandomSearchAll()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
ulong counter = 0;
var maxLink = links.Count();
var iterations = links.Count();
ConsoleHelpers.Debug("Testing Random Search with {0} Iterations.", links.Count());
var sw = Stopwatch.StartNew();
for (var i = iterations; i > 0; i--)
{
var linksAddressRange = new Range <ulong>(_constants.InternalReferencesRange.Minimum, maxLink);
var source = RandomHelpers.Default.NextUInt64(linksAddressRange);
var target = RandomHelpers.Default.NextUInt64(linksAddressRange);
counter += links.SearchOrDefault(source, target);
}
var elapsedTime = sw.Elapsed;
var iterationsPerSecond = iterations / elapsedTime.TotalSeconds;
ConsoleHelpers.Debug("{0} Iterations of Random Search done in {1} ({2} Iterations per second), c: {3}",
iterations, elapsedTime, (long)iterationsPerSecond, counter);
}
}
public static void TestGetTargetInParallel()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
ConsoleHelpers.Debug("Testing GetTarget function with {0} Iterations in parallel.", Iterations);
long counter = 0;
//var firstLink = links.First();
var firstLink = links.Create();
var sw = Stopwatch.StartNew();
Parallel.For(0, Iterations, x =>
{
Interlocked.Add(ref counter, (long)links.GetTarget(firstLink));
//Interlocked.Increment(ref counter);
});
var elapsedTime = sw.Elapsed;
var iterationsPerSecond = Iterations / elapsedTime.TotalSeconds;
links.Delete(firstLink);
ConsoleHelpers.Debug(
"{0} Iterations of GetTarget function done in {1} ({2} Iterations per second), counter result: {3}",
Iterations, elapsedTime, (long)iterationsPerSecond, counter);
}
}
public static void AllTreeBreakDownAtSequencesCreationBugTest()
{
// Made out of AllPossibleConnectionsTest test.
//const long sequenceLength = 5; //100% bug
const long sequenceLength = 4; //100% bug
//const long sequenceLength = 3; //100% _no_bug (ok)
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var createResults = sequences.CreateAllVariants2(sequence);
Global.Trash = createResults;
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void Create64BillionLinks()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var linksBeforeTest = links.Count();
long linksToCreate = 64 * 1024 * 1024 / UInt64UnitedMemoryLinks.LinkSizeInBytes;
ConsoleHelpers.Debug("Creating {0} links.", linksToCreate);
var elapsedTime = Performance.Measure(() =>
{
for (long i = 0; i < linksToCreate; i++)
{
links.Create();
}
});
var linksCreated = links.Count() - linksBeforeTest;
var linksPerSecond = linksCreated / elapsedTime.TotalSeconds;
ConsoleHelpers.Debug("Current links count: {0}.", links.Count());
ConsoleHelpers.Debug("{0} links created in {1} ({2} links per second)", linksCreated, elapsedTime,
(long)linksPerSecond);
}
}
public static void IndexTest()
{
using (var scope = new TempLinksTestScope(new SequencesOptions <ulong> {
UseIndex = true
}, useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var index = sequences.Options.Index;
var e1 = links.Create();
var e2 = links.Create();
var sequence = new[]
{
e1, e2, e1, e2 // mama / papa
};
Assert.False(index.MightContain(sequence));
index.Add(sequence);
Assert.True(index.MightContain(sequence));
}
}
public static void CreateAllVariantsTest()
{
const long sequenceLength = 8;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var sw1 = Stopwatch.StartNew();
var results1 = sequences.CreateAllVariants1(sequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var results2 = sequences.CreateAllVariants2(sequence); sw2.Stop();
Assert.True(results1.Count > results2.Length);
Assert.True(sw1.Elapsed > sw2.Elapsed);
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
Assert.True(links.Count() == 0);
}
}
public static void DictionaryBasedFrequencyStoredOptimalVariantSequenceTest()
{
using (var scope = new TempLinksTestScope(useSequences: false))
{
var links = scope.Links;
links.UseUnicode();
var sequence = UnicodeMap.FromStringToLinkArray(_sequenceExample);
var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(links);
var linkFrequenciesCache = new LinkFrequenciesCache <ulong>(links, totalSequenceSymbolFrequencyCounter);
var index = new CachedFrequencyIncrementingSequenceIndex <ulong>(linkFrequenciesCache);
var linkToItsFrequencyNumberConverter = new FrequenciesCacheBasedLinkToItsFrequencyNumberConverter <ulong>(linkFrequenciesCache);
var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(links, linkToItsFrequencyNumberConverter);
var optimalVariantConverter = new OptimalVariantConverter <ulong>(links, sequenceToItsLocalElementLevelsConverter);
var sequences = new Sequences.Sequences(links, new SequencesOptions <ulong>()
{
Walker = new LeveledSequenceWalker <ulong>(links)
});
ExecuteTest(sequences, sequence, sequenceToItsLocalElementLevelsConverter, index, optimalVariantConverter);
}
}
public static void RecursiveStringFormattingTest()
{
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences; // TODO: Auto use sequences on Sequences getter.
var a = links.CreatePoint();
var b = links.CreatePoint();
var c = links.CreatePoint();
var ab = links.GetOrCreate(a, b);
var cb = links.GetOrCreate(c, b);
var ac = links.GetOrCreate(a, c);
a = links.Update(a, c, b);
b = links.Update(b, a, c);
c = links.Update(c, a, b);
Debug.WriteLine(links.FormatStructure(ab, link => link.IsFullPoint(), true));
Debug.WriteLine(links.FormatStructure(cb, link => link.IsFullPoint(), true));
Debug.WriteLine(links.FormatStructure(ac, link => link.IsFullPoint(), true));
Assert.True(links.FormatStructure(cb, link => link.IsFullPoint(), true) == "(5:(4:5 (6:5 4)) 6)");
Assert.True(links.FormatStructure(ac, link => link.IsFullPoint(), true) == "(6:(5:(4:5 6) 6) 4)");
Assert.True(links.FormatStructure(ab, link => link.IsFullPoint(), true) == "(4:(5:4 (6:5 4)) 6)");
// TODO: Think how to build balanced syntax tree while formatting structure (eg. "(4:(5:4 6) (6:5 4)") instead of "(4:(5:4 (6:5 4)) 6)"
Assert.True(sequences.SafeFormatSequence(cb, DefaultFormatter, false) == "{{5}{5}{4}{6}}");
Assert.True(sequences.SafeFormatSequence(ac, DefaultFormatter, false) == "{{5}{6}{6}{4}}");
Assert.True(sequences.SafeFormatSequence(ab, DefaultFormatter, false) == "{{4}{5}{4}{6}}");
}
}
public static void LinksBasedFrequencyStoredOptimalVariantSequenceTest()
{
using (var scope = new TempLinksTestScope(useSequences: false))
{
var links = scope.Links;
var constants = links.Constants;
links.UseUnicode();
var sequence = UnicodeMap.FromStringToLinkArray(_sequenceExample);
var meaningRoot = links.CreatePoint();
var unaryOne = links.CreateAndUpdate(meaningRoot, constants.Itself);
var frequencyMarker = links.CreateAndUpdate(meaningRoot, constants.Itself);
var frequencyPropertyMarker = links.CreateAndUpdate(meaningRoot, constants.Itself);
var unaryNumberToAddressConverter = new UnaryNumberToAddressAddOperationConverter <ulong>(links, unaryOne);
var unaryNumberIncrementer = new UnaryNumberIncrementer <ulong>(links, unaryOne);
var frequencyIncrementer = new FrequencyIncrementer <ulong>(links, frequencyMarker, unaryOne, unaryNumberIncrementer);
var frequencyPropertyOperator = new PropertyOperator <ulong>(links, frequencyPropertyMarker, frequencyMarker);
var index = new FrequencyIncrementingSequenceIndex <ulong>(links, frequencyPropertyOperator, frequencyIncrementer);
var linkToItsFrequencyNumberConverter = new LinkToItsFrequencyNumberConveter <ulong>(links, frequencyPropertyOperator, unaryNumberToAddressConverter);
var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(links, linkToItsFrequencyNumberConverter);
var optimalVariantConverter = new OptimalVariantConverter <ulong>(links, sequenceToItsLocalElementLevelsConverter);
var sequences = new Sequences.Sequences(links, new SequencesOptions <ulong>()
{
Walker = new LeveledSequenceWalker <ulong>(links)
});
ExecuteTest(sequences, sequence, sequenceToItsLocalElementLevelsConverter, index, optimalVariantConverter);
}
}
public static void AllPossibleConnectionsTest()
{
const long sequenceLength = 5;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var createResults = sequences.CreateAllVariants2(sequence);
var reverseResults = sequences.CreateAllVariants2(sequence.Reverse().ToArray());
for (var i = 0; i < 1; i++)
{
var sw1 = Stopwatch.StartNew();
var searchResults1 = sequences.GetAllConnections(sequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var searchResults2 = sequences.GetAllConnections1(sequence); sw2.Stop();
var sw3 = Stopwatch.StartNew();
var searchResults3 = sequences.GetAllConnections2(sequence); sw3.Stop();
var sw4 = Stopwatch.StartNew();
var searchResults4 = sequences.GetAllConnections3(sequence); sw4.Stop();
Global.Trash = searchResults3;
Global.Trash = searchResults4; //-V3008
var intersection1 = createResults.Intersect(searchResults1).ToList();
Assert.True(intersection1.Count == createResults.Length);
var intersection2 = reverseResults.Intersect(searchResults1).ToList();
Assert.True(intersection2.Count == reverseResults.Length);
var intersection0 = searchResults1.Intersect(searchResults2).ToList();
Assert.True(intersection0.Count == searchResults2.Count);
var intersection3 = searchResults2.Intersect(searchResults3).ToList();
Assert.True(intersection3.Count == searchResults3.Count);
var intersection4 = searchResults3.Intersect(searchResults4).ToList();
Assert.True(intersection4.Count == searchResults4.Count);
}
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void AllPartialVariantsSearchTest()
{
const long sequenceLength = 8;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var createResults = sequences.CreateAllVariants2(sequence);
//var createResultsStrings = createResults.Select(x => x + ": " + sequences.FormatSequence(x)).ToList();
//Global.Trash = createResultsStrings;
var partialSequence = new ulong[sequenceLength - 2];
Array.Copy(sequence, 1, partialSequence, 0, (int)sequenceLength - 2);
var sw1 = Stopwatch.StartNew();
var searchResults1 = sequences.GetAllPartiallyMatchingSequences0(partialSequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var searchResults2 = sequences.GetAllPartiallyMatchingSequences1(partialSequence); sw2.Stop();
//var sw3 = Stopwatch.StartNew();
//var searchResults3 = sequences.GetAllPartiallyMatchingSequences2(partialSequence); sw3.Stop();
var sw4 = Stopwatch.StartNew();
var searchResults4 = sequences.GetAllPartiallyMatchingSequences3(partialSequence); sw4.Stop();
//Global.Trash = searchResults3;
//var searchResults1Strings = searchResults1.Select(x => x + ": " + sequences.FormatSequence(x)).ToList();
//Global.Trash = searchResults1Strings;
var intersection1 = createResults.Intersect(searchResults1).ToList();
Assert.True(intersection1.Count == createResults.Length);
var intersection2 = createResults.Intersect(searchResults2).ToList();
Assert.True(intersection2.Count == createResults.Length);
var intersection4 = createResults.Intersect(searchResults4).ToList();
Assert.True(intersection4.Count == createResults.Length);
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public void FormatTest()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var link = links.Create();
var linkString = links.Format(link);
Assert.Equal("(1: 1 1)", linkString);
}
}
public static void TransactionUserCodeErrorSomeDataSavedTest()
{
// User Code Error (Autoreverted), some data saved
var itself = _constants.Itself;
TempLinksTestScope lastScope = null;
try
{
ulong l1;
ulong l2;
using (var scope = new TempLinksTestScope(useLog: true))
{
var links = scope.Links;
l1 = links.CreateAndUpdate(itself, itself);
l2 = links.CreateAndUpdate(itself, itself);
l2 = links.Update(l2, l2, l1, l2);
links.CreateAndUpdate(l2, itself);
links.CreateAndUpdate(l2, itself);
links.Unsync.DisposeIfPossible();
Global.Trash = FileHelpers.ReadAll <UInt64LinksTransactionsLayer.Transition>(scope.TempTransactionLogFilename);
}
using (var scope = lastScope = new TempLinksTestScope(deleteFiles: false, useLog: true))
{
var links = scope.Links;
var transactionsLayer = (UInt64LinksTransactionsLayer)links.Unsync;
using (var transaction = transactionsLayer.BeginTransaction())
{
l2 = links.Update(l2, l1);
links.Delete(l2);
ExceptionThrower();
transaction.Commit();
}
Global.Trash = links.Count();
}
}
catch
{
Assert.False(lastScope == null);
Global.Trash = FileHelpers.ReadAll <UInt64LinksTransactionsLayer.Transition>(lastScope.TempTransactionLogFilename);
lastScope.DeleteFiles();
}
}
public static void AllVariantsSearchTest()
{
const long sequenceLength = 8;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var createResults = sequences.CreateAllVariants2(sequence).Distinct().ToArray();
//for (int i = 0; i < createResults.Length; i++)
// sequences.Create(createResults[i]);
var sw0 = Stopwatch.StartNew();
var searchResults0 = sequences.GetAllMatchingSequences0(sequence); sw0.Stop();
var sw1 = Stopwatch.StartNew();
var searchResults1 = sequences.GetAllMatchingSequences1(sequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var searchResults2 = sequences.Each1(sequence); sw2.Stop();
var sw3 = Stopwatch.StartNew();
var searchResults3 = sequences.Each(sequence.ShiftRight()); sw3.Stop();
var intersection0 = createResults.Intersect(searchResults0).ToList();
Assert.True(intersection0.Count == searchResults0.Count);
Assert.True(intersection0.Count == createResults.Length);
var intersection1 = createResults.Intersect(searchResults1).ToList();
Assert.True(intersection1.Count == searchResults1.Count);
Assert.True(intersection1.Count == createResults.Length);
var intersection2 = createResults.Intersect(searchResults2).ToList();
Assert.True(intersection2.Count == searchResults2.Count);
Assert.True(intersection2.Count == createResults.Length);
var intersection3 = createResults.Intersect(searchResults3).ToList();
Assert.True(intersection3.Count == searchResults3.Count);
Assert.True(intersection3.Count == createResults.Length);
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void CharAndUnaryNumberUnicodeSymbolConvertersTest()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var meaningRoot = links.CreatePoint();
var one = links.CreateAndUpdate(meaningRoot, links.Constants.Itself);
var powerOf2ToUnaryNumberConverter = new PowerOf2ToUnaryNumberConverter <ulong>(links, one);
var addressToUnaryNumberConverter = new AddressToUnaryNumberConverter <ulong>(links, powerOf2ToUnaryNumberConverter);
var unaryNumberToAddressConverter = new UnaryNumberToAddressOrOperationConverter <ulong>(links, powerOf2ToUnaryNumberConverter);
TestCharAndUnicodeSymbolConverters(links, meaningRoot, addressToUnaryNumberConverter, unaryNumberToAddressConverter);
}
}
public static void PatternMatchTest()
{
var zeroOrMany = Sequences.Sequences.ZeroOrMany;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var e1 = links.Create();
var e2 = links.Create();
var sequence = new[]
{
e1, e2, e1, e2 // mama / papa
};
var balancedVariantConverter = new BalancedVariantConverter <ulong>(links);
var balancedVariant = balancedVariantConverter.Convert(sequence);
// 1: [1]
// 2: [2]
// 3: [1,2]
// 4: [1,2,1,2]
var doublet = links.GetSource(balancedVariant);
var matchedSequences1 = sequences.MatchPattern(e2, e1, zeroOrMany);
Assert.True(matchedSequences1.Count == 0);
var matchedSequences2 = sequences.MatchPattern(zeroOrMany, e2, e1);
Assert.True(matchedSequences2.Count == 0);
var matchedSequences3 = sequences.MatchPattern(e1, zeroOrMany, e1);
Assert.True(matchedSequences3.Count == 0);
var matchedSequences4 = sequences.MatchPattern(e1, zeroOrMany, e2);
Assert.Contains(doublet, matchedSequences4);
Assert.Contains(balancedVariant, matchedSequences4);
for (var i = 0; i < sequence.Length; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void PathsTest()
{
var source = _constants.SourcePart;
var target = _constants.TargetPart;
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var l1 = links.CreatePoint();
var l2 = links.CreatePoint();
var r1 = links.GetByKeys(l1, source, target, source);
var r2 = links.CheckPathExistance(l2, l2, l2, l2);
}
}
public static void ReadSequenceTest()
{
const long sequenceLength = 2000;
using (var scope = new TempLinksTestScope(useSequences: false))
{
var links = scope.Links;
var sequences = new Sequences.Sequences(links, new SequencesOptions <ulong> {
Walker = new LeveledSequenceWalker <ulong>(links)
});
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var balancedVariantConverter = new BalancedVariantConverter <ulong>(links);
var sw1 = Stopwatch.StartNew();
var balancedVariant = balancedVariantConverter.Convert(sequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var readSequence1 = sequences.ToList(balancedVariant); sw2.Stop();
var sw3 = Stopwatch.StartNew();
var readSequence2 = new List <ulong>();
SequenceWalker.WalkRight(balancedVariant,
links.GetSource,
links.GetTarget,
links.IsPartialPoint,
readSequence2.Add);
sw3.Stop();
Assert.True(sequence.SequenceEqual(readSequence1));
Assert.True(sequence.SequenceEqual(readSequence2));
// Assert.True(sw2.Elapsed < sw3.Elapsed);
Console.WriteLine($"Stack-based walker: {sw3.Elapsed}, Level-based reader: {sw2.Elapsed}");
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void StringAndUnicodeSequenceConvertersTest()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var itself = links.Constants.Itself;
var meaningRoot = links.CreatePoint();
var unaryOne = links.CreateAndUpdate(meaningRoot, itself);
var unicodeSymbolMarker = links.CreateAndUpdate(meaningRoot, itself);
var unicodeSequenceMarker = links.CreateAndUpdate(meaningRoot, itself);
var frequencyMarker = links.CreateAndUpdate(meaningRoot, itself);
var frequencyPropertyMarker = links.CreateAndUpdate(meaningRoot, itself);
var powerOf2ToUnaryNumberConverter = new PowerOf2ToUnaryNumberConverter <ulong>(links, unaryOne);
var addressToUnaryNumberConverter = new AddressToUnaryNumberConverter <ulong>(links, powerOf2ToUnaryNumberConverter);
var charToUnicodeSymbolConverter = new CharToUnicodeSymbolConverter <ulong>(links, addressToUnaryNumberConverter, unicodeSymbolMarker);
var unaryNumberToAddressConverter = new UnaryNumberToAddressOrOperationConverter <ulong>(links, powerOf2ToUnaryNumberConverter);
var unaryNumberIncrementer = new UnaryNumberIncrementer <ulong>(links, unaryOne);
var frequencyIncrementer = new FrequencyIncrementer <ulong>(links, frequencyMarker, unaryOne, unaryNumberIncrementer);
var frequencyPropertyOperator = new PropertyOperator <ulong>(links, frequencyPropertyMarker, frequencyMarker);
var index = new FrequencyIncrementingSequenceIndex <ulong>(links, frequencyPropertyOperator, frequencyIncrementer);
var linkToItsFrequencyNumberConverter = new LinkToItsFrequencyNumberConveter <ulong>(links, frequencyPropertyOperator, unaryNumberToAddressConverter);
var sequenceToItsLocalElementLevelsConverter = new SequenceToItsLocalElementLevelsConverter <ulong>(links, linkToItsFrequencyNumberConverter);
var optimalVariantConverter = new OptimalVariantConverter <ulong>(links, sequenceToItsLocalElementLevelsConverter);
var stringToUnicodeSequenceConverter = new StringToUnicodeSequenceConverter <ulong>(links, charToUnicodeSymbolConverter, index, optimalVariantConverter, unicodeSequenceMarker);
var originalString = "Hello";
var unicodeSequenceLink = stringToUnicodeSequenceConverter.Convert(originalString);
var unicodeSymbolCriterionMatcher = new TargetMatcher <ulong>(links, unicodeSymbolMarker);
var unicodeSymbolToCharConverter = new UnicodeSymbolToCharConverter <ulong>(links, unaryNumberToAddressConverter, unicodeSymbolCriterionMatcher);
var unicodeSequenceCriterionMatcher = new TargetMatcher <ulong>(links, unicodeSequenceMarker);
var sequenceWalker = new LeveledSequenceWalker <ulong>(links, unicodeSymbolCriterionMatcher.IsMatched);
var unicodeSequenceToStringConverter = new UnicodeSequenceToStringConverter <ulong>(links, unicodeSequenceCriterionMatcher, sequenceWalker, unicodeSymbolToCharConverter);
var resultingString = unicodeSequenceToStringConverter.Convert(unicodeSequenceLink);
Assert.Equal(originalString, resultingString);
}
}
public static void TransactionUserCodeErrorNoDataSavedTest()
{
// User Code Error (Autoreverted), no data saved
var itself = _constants.Itself;
TempLinksTestScope lastScope = null;
try
{
using (var scope = lastScope = new TempLinksTestScope(deleteFiles: false, useLog: true))
{
var links = scope.Links;
var transactionsLayer = (UInt64LinksTransactionsLayer)((LinksDisposableDecoratorBase <ulong>)links.Unsync).Links;
using (var transaction = transactionsLayer.BeginTransaction())
{
var l1 = links.CreateAndUpdate(itself, itself);
var l2 = links.CreateAndUpdate(itself, itself);
l2 = links.Update(l2, l2, l1, l2);
links.CreateAndUpdate(l2, itself);
links.CreateAndUpdate(l2, itself);
//Global.Trash = FileHelpers.ReadAll<UInt64LinksTransactionsLayer.Transition>(scope.TempTransactionLogFilename);
l2 = links.Update(l2, l1);
links.Delete(l2);
ExceptionThrower();
transaction.Commit();
}
Global.Trash = links.Count();
}
}
catch
{
Assert.False(lastScope == null);
var transitions = FileHelpers.ReadAll <UInt64LinksTransactionsLayer.Transition>(lastScope.TempTransactionLogFilename);
Assert.True(transitions.Length == 1 && transitions[0].Before.IsNull() && transitions[0].After.IsNull());
lastScope.DeleteFiles();
}
}
public static void CompressionTest()
{
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var e1 = links.Create();
var e2 = links.Create();
var sequence = new[]
{
e1, e2, e1, e2 // mama / papa / template [(m/p), a] { [1] [2] [1] [2] }
};
var balancedVariantConverter = new BalancedVariantConverter <ulong>(links.Unsync);
var totalSequenceSymbolFrequencyCounter = new TotalSequenceSymbolFrequencyCounter <ulong>(links.Unsync);
var doubletFrequenciesCache = new LinkFrequenciesCache <ulong>(links.Unsync, totalSequenceSymbolFrequencyCounter);
var compressingConverter = new CompressingConverter <ulong>(links.Unsync, balancedVariantConverter, doubletFrequenciesCache);
var compressedVariant = compressingConverter.Convert(sequence);
// 1: [1] (1->1) point
// 2: [2] (2->2) point
// 3: [1,2] (1->2) doublet
// 4: [1,2,1,2] (3->3) doublet
Assert.True(links.GetSource(links.GetSource(compressedVariant)) == sequence[0]);
Assert.True(links.GetTarget(links.GetSource(compressedVariant)) == sequence[1]);
Assert.True(links.GetSource(links.GetTarget(compressedVariant)) == sequence[2]);
Assert.True(links.GetTarget(links.GetTarget(compressedVariant)) == sequence[3]);
var source = _constants.SourcePart;
var target = _constants.TargetPart;
Assert.True(links.GetByKeys(compressedVariant, source, source) == sequence[0]);
Assert.True(links.GetByKeys(compressedVariant, source, target) == sequence[1]);
Assert.True(links.GetByKeys(compressedVariant, target, source) == sequence[2]);
Assert.True(links.GetByKeys(compressedVariant, target, target) == sequence[3]);
// 4 - length of sequence
Assert.True(links.GetSquareMatrixSequenceElementByIndex(compressedVariant, 4, 0) == sequence[0]);
Assert.True(links.GetSquareMatrixSequenceElementByIndex(compressedVariant, 4, 1) == sequence[1]);
Assert.True(links.GetSquareMatrixSequenceElementByIndex(compressedVariant, 4, 2) == sequence[2]);
Assert.True(links.GetSquareMatrixSequenceElementByIndex(compressedVariant, 4, 3) == sequence[3]);
}
}
public static void TestDeletionOfAllLinks()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var linksBeforeTest = links.Count();
ConsoleHelpers.Debug("Deleting all links");
var elapsedTime = Performance.Measure(links.DeleteAll);
var linksDeleted = linksBeforeTest - links.Count();
var linksPerSecond = linksDeleted / elapsedTime.TotalSeconds;
ConsoleHelpers.Debug("{0} links deleted in {1} ({2} links per second)", linksDeleted, elapsedTime,
(long)linksPerSecond);
}
}
public static void BalancedVariantSearchTest()
{
const long sequenceLength = 200;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var balancedVariantConverter = new BalancedVariantConverter <ulong>(links);
var sw1 = Stopwatch.StartNew();
var balancedVariant = balancedVariantConverter.Convert(sequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var searchResults2 = sequences.GetAllMatchingSequences0(sequence); sw2.Stop();
var sw3 = Stopwatch.StartNew();
var searchResults3 = sequences.GetAllMatchingSequences1(sequence); sw3.Stop();
// На количестве в 200 элементов это будет занимать вечность
//var sw4 = Stopwatch.StartNew();
//var searchResults4 = sequences.Each(sequence); sw4.Stop();
Assert.True(searchResults2.Count == 1 && balancedVariant == searchResults2[0]);
Assert.True(searchResults3.Count == 1 && balancedVariant == searchResults3.First());
//Assert.True(sw1.Elapsed < sw2.Elapsed);
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void BalancedPartialVariantsSearchTest()
{
const long sequenceLength = 200;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var balancedVariantConverter = new BalancedVariantConverter <ulong>(links);
var balancedVariant = balancedVariantConverter.Convert(sequence);
var partialSequence = new ulong[sequenceLength - 2];
Array.Copy(sequence, 1, partialSequence, 0, (int)sequenceLength - 2);
var sw1 = Stopwatch.StartNew();
var searchResults1 = sequences.GetAllPartiallyMatchingSequences0(partialSequence); sw1.Stop();
var sw2 = Stopwatch.StartNew();
var searchResults2 = sequences.GetAllPartiallyMatchingSequences1(partialSequence); sw2.Stop();
Assert.True(searchResults1.Count == 1 && balancedVariant == searchResults1[0]);
Assert.True(searchResults2.Count == 1 && balancedVariant == searchResults2.First());
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}
public static void TestEach()
{
using (var scope = new TempLinksTestScope())
{
var links = scope.Links;
var counter = new Counter <IList <ulong>, ulong>(links.Constants.Continue);
ConsoleHelpers.Debug("Testing Each function.");
var sw = Stopwatch.StartNew();
links.Each(counter.IncrementAndReturnTrue);
var elapsedTime = sw.Elapsed;
var linksPerSecond = counter.Count / elapsedTime.TotalSeconds;
ConsoleHelpers.Debug("{0} Iterations of Each's handler function done in {1} ({2} links per second)",
counter, elapsedTime, (long)linksPerSecond);
}
}
public static void CalculateAllUsagesTest()
{
const long sequenceLength = 3;
using (var scope = new TempLinksTestScope(useSequences: true))
{
var links = scope.Links;
var sequences = scope.Sequences;
var sequence = new ulong[sequenceLength];
for (var i = 0; i < sequenceLength; i++)
{
sequence[i] = links.Create();
}
var createResults = sequences.CreateAllVariants2(sequence);
//var reverseResults = sequences.CreateAllVariants2(sequence.Reverse().ToArray());
for (var i = 0; i < 1; i++)
{
var linksTotalUsages1 = new ulong[links.Count() + 1];
sequences.CalculateAllUsages(linksTotalUsages1);
var linksTotalUsages2 = new ulong[links.Count() + 1];
sequences.CalculateAllUsages2(linksTotalUsages2);
var intersection1 = linksTotalUsages1.Intersect(linksTotalUsages2).ToList();
Assert.True(intersection1.Count == linksTotalUsages2.Length);
}
for (var i = 0; i < sequenceLength; i++)
{
links.Delete(sequence[i]);
}
}
}