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]); } } }