public static SparseAList <int> init(int[] arr, int size) { var result = new SparseAList <int>(); result.AddRange(arr); return(result); }
public void TestSwap() { List <int> list1, list2; SparseAList <int> alist1 = NewList(10, out list1); SparseAList <int> alist2 = NewList(100, out list2); // Can't Swap with a frozen list SparseAList <int> frozen = alist1.Clone(); frozen.Freeze(); if (_testExceptions) { AssertThrows <ReadOnlyException>(() => alist1.Swap(frozen)); } // Swap, and ensure that ListChanging and NodeObserver are swapped. alist1.ListChanging += (sender, args) => Assert.Fail(); alist1.AddObserver(new AListTestObserver <int, int>()); alist1.Swap(alist2); Assert.AreEqual(0, alist1.ObserverCount); Assert.AreEqual(1, alist2.ObserverCount); list2.Add(999); alist1.Add(999); ExpectList(alist1, list2, false); ExpectList(alist2, list1, true); }
public void TestPrependAppend() { List <int> list = new List <int>(); var alist = NewList(); List <int>[] lists = new List <int> [13]; SparseAList <int>[] alists = new SparseAList <int>[] { NewList(0, 0, out lists[0]), NewList(2, 1, out lists[1]), NewList(6, 5, out lists[2]), NewList(10, 5, out lists[3]), NewList(15, 11, out lists[4]), NewList(30, 11, out lists[5]), NewList(30, 20, out lists[6]), NewList(60, 20, out lists[7]), NewList(50, 32, out lists[8]), NewList(100, 32, out lists[9]), NewList(80, 53, out lists[10]), NewList(150, 53, out lists[11]), NewList(150, 100, out lists[12]), }; Assert.AreEqual(alists.Length, lists.Length); // So, let's just do a random series of Append and Prepend operations, // clearing the list occasionally so that both list sizes vary a lot, // which will cause the code paths to vary (important because there // are several different ways these operations can be done). for (int trial = 0; trial < 20; trial++) { if (trial % 4 == 0) { alist.Clear(); list.Clear(); } int whirl = _r.Next(alists.Length); SparseAList <int> other = alists[whirl]; bool append = _r.Next(2) == 0; int ric = alist.GetRealItemCount(), otherRic = other.GetRealItemCount(), oldTH = alist.TreeHeight; if (append) { alist.Append(other); list.AddRange(lists[whirl]); } else { alist.Prepend(other); list.InsertRange(0, lists[whirl]); } Assert.That(other.GetImmutableCount() == other.Count || other.TreeHeight <= 1); Assert.That(alist.GetRealItemCount() == ric + otherRic); Assert.That(alist.GetImmutableCount() >= other.GetImmutableCount() || oldTH == 1); } }
public void LeafCapacityLimitIsRespected() { var list = new SparseAList <int>(_maxLeafSize, _maxInnerSize); for (int i = 0; i < 100 + _maxLeafSize * _maxInnerSize; i++) { list.Insert(_r.Next(list.Count + 1), i); } VerifyLeafCapacityLimitIsRespected(list, _maxLeafSize); }
public override IListSource <ITagSpan <ITag> > RunAnalysis(ITextSnapshot snapshot, SparseAList <EditorToken> eTokens, CancellationToken cancellationToken) { var sourceFile = new TextSnapshotAsSourceFile(snapshot); var tokens = ToNormalTokens(eTokens); var results = new DList <ITagSpan <ClassificationTag> >(); var parser = new MyLesParser(tokens, sourceFile, TraceMessageSink.Value, results); var _ = parser.StmtList(); results.Sort((t1, t2) => t1.Span.Start.Position.CompareTo(t2.Span.Start.Position)); return(results); }
public void TestNextLowerItem() { var alist = new SparseAList <int>(_maxLeafSize, _maxInnerSize); int?i; for (i = 0; i < 100; i++) { alist.Add(i.Value); alist.InsertSpace(alist.Count, 1000); } i = int.MaxValue; Assert.AreEqual(alist.NextLowerItem(ref i), 99); Assert.AreEqual(i.Value, 99099); i = 99100; Assert.AreEqual(alist.NextLowerItem(ref i), 99); Assert.AreEqual(i.Value, 99099); Assert.AreEqual(alist.NextLowerItem(ref i), 98); Assert.AreEqual(i.Value, 98098); i = 55555; Assert.AreEqual(alist.NextLowerItem(ref i), 55); Assert.AreEqual(i.Value, 55055); i = 1002; Assert.AreEqual(alist.NextLowerItem(ref i), 1); Assert.AreEqual(i.Value, 1001); Assert.AreEqual(alist.NextLowerItem(ref i), 0); Assert.AreEqual(i.Value, 0); i = 1; Assert.AreEqual(alist.NextLowerItem(ref i), 0); Assert.AreEqual(i.Value, 0); Assert.AreEqual(alist.NextLowerItem(ref i), default(int)); Assert.AreEqual(i.HasValue, false); i = int.MinValue; Assert.AreEqual(alist.NextLowerItem(ref i), default(int)); Assert.AreEqual(i.HasValue, false); // Place a value at the edge of integer space alist.Clear(); alist.InsertSpace(0, int.MaxValue - 1); alist.Add(777); i = int.MinValue; Assert.AreEqual(alist.NextLowerItem(ref i), default(int)); Assert.AreEqual(i.HasValue, false); i = int.MaxValue; Assert.AreEqual(alist.NextLowerItem(ref i), default(int)); Assert.AreEqual(i.HasValue, false); i = null; Assert.AreEqual(alist.NextLowerItem(ref i), 777); Assert.AreEqual(i.Value, int.MaxValue); }
public static DList <Token> ToNormalTokens(SparseAList <EditorToken> eTokens) { var output = new DList <Token>(); int?index = null; for (;;) { EditorToken eTok = eTokens.NextHigherItem(ref index); if (index == null) { break; } output.Add(eTok.ToToken(index.Value)); } return(output); }
public override IListSource <ITagSpan <ITag> > RunAnalysis(ITextSnapshot snapshot, SparseAList <EditorToken> eTokens, CancellationToken cancellationToken) { var sourceFile = new TextSnapshotAsSourceFile(snapshot); var tokens = ToNormalTokens(eTokens); var tokensAsLexer = new TokenListAsLexer(tokens, sourceFile); var tokensTree = new TokensToTree(new TokenListAsLexer(tokens, sourceFile), true) { ErrorSink = MessageSink.Trace }; var results = new DList <ITagSpan <ClassificationTag> >(); var parser = new MyLesParser(tokensTree.Buffered(), sourceFile, MessageSink.Trace, results); parser.ParseStmtsGreedy(); results.Sort((t1, t2) => t1.Span.Start.Position.CompareTo(t2.Span.Start.Position)); return(results); }
static void Main(string[] args) { Console.WriteLine("Input elements of a list in a row: "); var s = Console.ReadLine().Split(' '); var arr = s.Select(f => Convert.ToInt32(f)).ToArray(); // var arr = new int[] { 0, 0, 0, 0, 0, 2, 4, 7, 10 }; facebookList = init(arr, arr.Length); // Gets 2 from test array Console.WriteLine($"{get(5)}"); // Sets 2 to 100 set(5, 100); // Gets 100 from test array Console.WriteLine($"{get(5)}"); }
public void TestClearSpace() { for (int iter = 0; iter < 10; iter++) { int i1 = MathEx.Square(_r.Next(50)) + 1; // e.g. 100 int i0 = _r.Next(i1); // e.g. 50 int i2 = i1 + MathEx.Square(_r.Next(50)) + 1; // e.g. 100 int i3 = i2 + _r.Next(2500); // e.g. 1000 SparseAList <int> list = new SparseAList <int>(); list.ClearSpace(0, i1); Assert.AreEqual(i1, list.Count); Assert.AreEqual(0, list.GetRealItemCount()); Assert.AreEqual(0, list[i1 - 1]); if (_testExceptions) { Assert.Throws <ArgumentOutOfRangeException>(() => { var _ = list[i1]; }); Assert.Throws <ArgumentOutOfRangeException>(() => { list.ClearSpace(0, -1); }); Assert.Throws <ArgumentOutOfRangeException>(() => { list.ClearSpace(-1, 10); }); } list.ClearSpace(i0, i2 - i0); Assert.AreEqual(i2, list.Count); Assert.AreEqual(0, list.GetRealItemCount()); for (int i = i0; i < i2; i++) { list[i] = i; } list.ClearSpace(i1, i3 - i1); Assert.AreEqual(i3, list.Count); Assert.AreEqual(i1 - i0, list.GetRealItemCount()); list.ClearSpace(i0 + 1, i1 - (i0 + 1)); Assert.AreEqual(i3, list.Count); Assert.AreEqual(1, list.GetRealItemCount()); list.ClearSpace(0, i0 + 1); Assert.AreEqual(i3, list.Count); Assert.AreEqual(0, list.GetRealItemCount()); } }
protected SparseAList <int> NewList(int initialCount, int realCount, out List <int> list) { Debug.Assert(realCount <= initialCount); SparseAList <int> alist = NewList(); list = new List <int>(); // Make a list of random size <= initialCount for (int i = 0; i < realCount; i++) { AddToBoth(alist, list, i, i); } // Add empty spaces until Count == initialCount while (alist.Count < initialCount) { int i = _r.Next(alist.Count + 1); alist.InsertSpace(i); list.Insert(i, 0); } return(alist); }
SparseAList <int> NewList(int start, int count, ListChangingHandler <int> observer, out List <int> list) { var alist = new SparseAList <int>(_maxLeafSize, _maxInnerSize); list = new List <int>(); for (int i = 0; i < count; i++) { if (_r.Next(2) == 0) { alist.Add(start + i); list.Add(start + i); } else { alist.InsertSpace(i); list.Add(0); } } if (observer != null) { alist.ListChanging += observer; } return(alist); }
protected override SparseAList <int> RemoveSection(SparseAList <int> alist, int start, int subcount) { return(alist.RemoveSection(start, subcount)); }
public static DList<Token> ToNormalTokens(SparseAList<EditorToken> eTokens) { var output = new DList<Token>(); int? index = null; for (;;) { EditorToken eTok = eTokens.NextHigherItem(ref index); if (index == null) break; output.Add(eTok.ToToken(index.Value)); } return output; }
public static int Loyc_Collections() { return(MiniTest.RunTests.RunMany( new InternalDArrayTests(_seed), new TypeDictionaryWithBaseTypeLookupsTests(), new ListSourceSliceTests(), new ListSliceTests(), new ROLSliceTests(), new HeapTests(_seed), new SimpleCacheTests(), new InvertibleSetTests(), // Test with small node sizes as well as the standard node size, // including the minimum size of 3 (the most problematic size). new AListTests(false, _seed, 8, 8), new AListTests(false, _seed, 3, 3), new BListTests(false, _seed, 8, 8), new BListTests(false, _seed, 3, 3), new BDictionaryTests(false, _seed, 6, 6), new SparseAListTests(false, _seed, 3, 3), new SparseAListTests(false, _seed, 9, 9), new BMultiMapTests(4), new DequeTests <DList <int> >(delegate() { return new DList <int>(); }), new DequeTests <AList <int> >(delegate() { return new AList <int>(); }), new DequeTests <SparseAList <int> >(delegate() { return new SparseAList <int>(); }), new DictionaryTests <BDictionary <object, object> >(true, true), new ListTests <AList <int> >(false, delegate(int n) { var l = new AList <int>(); l.Resize(n); return l; }), new ListRangeTests <AList <int> >(false, delegate() { return new AList <int>(); }, 12345), new ListTests <SparseAList <int> >(false, delegate(int n) { var l = new SparseAList <int>(); l.Resize(n); return l; }, 12345), new ListRangeTests <SparseAList <int> >(false, delegate() { return new SparseAList <int>(); }, 12345), new WListTests(), new FWListTests(), new VListTests(), new FVListTests(), new MapTests(), new SparseAListTests(true, _seed, 8, 4), new SparseAListTests(), new AListTests(), new BListTests(), new BDictionaryTests(), new MSetTests(), // derived from MutableSetTests<MSet<STI>, STI> new SymbolSetTests(), // derived from MutableSetTests<MSet<Symbol>, Symbol> new ImmSetTests(), // tests for Set<T> new MapTests() // derived from DictionaryTests<MMap<object, object>> )); }
public static void Loyc_Collections() { MiniTest.RunTests.Run(new CPTrieTests()); MiniTest.RunTests.Run(new SimpleCacheTests()); MiniTest.RunTests.Run(new InvertibleSetTests()); // Test with small node sizes as well as the standard node size, // including the minimum size of 3 (the most problematic size). int seed = 237588399; MiniTest.RunTests.Run(new AListTests(false, seed, 8, 8)); MiniTest.RunTests.Run(new BListTests(false, seed, 3, 3)); MiniTest.RunTests.Run(new BDictionaryTests(false, seed, 6, 6)); MiniTest.RunTests.Run(new SparseAListTests(false, seed, 10, 10)); MiniTest.RunTests.Run(new DequeTests <AList <int> >(delegate() { return(new AList <int>()); })); MiniTest.RunTests.Run(new DequeTests <SparseAList <int> >(delegate() { return(new SparseAList <int>()); })); MiniTest.RunTests.Run(new DictionaryTests <BDictionary <object, object> >(true, true)); MiniTest.RunTests.Run(new ListTests <AList <int> >(false, delegate(int n) { var l = new AList <int>(); l.Resize(n); return(l); })); MiniTest.RunTests.Run(new ListRangeTests <AList <int> >(false, delegate() { return(new AList <int>()); }, 12345)); MiniTest.RunTests.Run(new ListTests <SparseAList <int> >(false, delegate(int n) { var l = new SparseAList <int>(); l.Resize(n); return(l); }, 12345)); MiniTest.RunTests.Run(new ListRangeTests <SparseAList <int> >(false, delegate() { return(new SparseAList <int>()); }, 12345)); MiniTest.RunTests.Run(new RWListTests()); MiniTest.RunTests.Run(new WListTests()); MiniTest.RunTests.Run(new RVListTests()); MiniTest.RunTests.Run(new VListTests()); MiniTest.RunTests.Run(new MapTests()); MiniTest.RunTests.Run(new SparseAListTests(true, seed, 8, 4)); MiniTest.RunTests.Run(new SparseAListTests()); MiniTest.RunTests.Run(new AListTests()); MiniTest.RunTests.Run(new BListTests()); MiniTest.RunTests.Run(new BDictionaryTests()); MiniTest.RunTests.Run(new MSetTests()); // derived from MutableSetTests<MSet<STI>, STI> MiniTest.RunTests.Run(new SymbolSetTests()); // derived from MutableSetTests<MSet<Symbol>, Symbol> MiniTest.RunTests.Run(new ImmSetTests()); // tests for Set<T> MiniTest.RunTests.Run(new MapTests()); // derived from DictionaryTests<MMap<object, object>> MiniTest.RunTests.Run(new KeylessHashtableTests()); }
// Derived class is responsible for parsing in this method public abstract ParseResults RunAnalysis(ITextSnapshot snapshot, SparseAList <EditorToken> input, CancellationToken cancelToken);
public static void Main(string[] args) { // Workaround for MS bug: Assert(false) will not fire in debugger Debug.Listeners.Clear(); Debug.Listeners.Add(new DefaultTraceListener()); Console.WriteLine("Running tests on stable code..."); // Omitted: unit tests that throw & catch exceptions (those are below) // Loyc.Essentials RunTests.Run(new ListExtTests()); RunTests.Run(new MathExTests()); RunTests.Run(new UStringTests()); RunTests.Run(new StringExtTests()); RunTests.Run(new HashTagsTests()); RunTests.Run(new LocalizeTests()); RunTests.Run(new SymbolTests()); RunTests.Run(new ThreadExTests()); RunTests.Run(new ListTests <InternalList <int> >(false, delegate(int n) { var l = InternalList <int> .Empty; l.Resize(n); return(l); })); RunTests.Run(new ListRangeTests <InternalList <int> >(false, delegate() { return(InternalList <int> .Empty); })); RunTests.Run(new ListTests <DList <int> >(false, delegate(int n) { var l = new DList <int>(); l.Resize(n); return(l); })); RunTests.Run(new DequeTests <DList <int> >(delegate() { return(new DList <int>()); })); RunTests.Run(new ListRangeTests <DList <int> >(false, delegate() { return(new DList <int>()); })); // Loyc.Collections RunTests.Run(new CPTrieTests()); RunTests.Run(new SimpleCacheTests()); RunTests.Run(new InvertibleSetTests()); // Test with small node sizes as well as the standard node size, // including the minimum size of 3 (the most problematic size). int seed = 237588399; RunTests.Run(new AListTests(false, seed, 8, 8)); RunTests.Run(new BListTests(false, seed, 3, 3)); RunTests.Run(new BDictionaryTests(false, seed, 6, 6)); RunTests.Run(new SparseAListTests(false, seed, 10, 10)); RunTests.Run(new DequeTests <AList <int> >(delegate() { return(new AList <int>()); })); RunTests.Run(new DequeTests <SparseAList <int> >(delegate() { return(new SparseAList <int>()); })); RunTests.Run(new DictionaryTests <BDictionary <object, object> >(true, true)); RunTests.Run(new ListTests <AList <int> >(false, delegate(int n) { var l = new AList <int>(); l.Resize(n); return(l); })); RunTests.Run(new ListRangeTests <AList <int> >(false, delegate() { return(new AList <int>()); }, 12345)); RunTests.Run(new ListTests <SparseAList <int> >(false, delegate(int n) { var l = new SparseAList <int>(); l.Resize(n); return(l); }, 12345)); RunTests.Run(new ListRangeTests <SparseAList <int> >(false, delegate() { return(new SparseAList <int>()); }, 12345)); // Loyc.Syntax RunTests.Run(new TokenTests()); RunTests.Run(new LesLexerTests()); RunTests.Run(new LesParserTests()); RunTests.Run(new LesPrinterTests()); RunTests.Run(new TokensToTreeTests()); RunTests.Run(new StreamCharSourceTests()); RunTests.Run(new LexerSourceTests_Calculator()); RunTests.Run(new ParserSourceTests_Calculator()); RunTests.Run(new IndentTokenGeneratorTests()); // Loyc.Utilities RunTests.Run(new LineMathTests()); RunTests.Run(new PointMathTests()); RunTests.Run(new Loyc.LLParserGenerator.IntSetTests()); RunTests.Run(new TagsInWListTests()); RunTests.Run(new UGTests()); for (;;) { ConsoleKeyInfo k; Console.WriteLine(); Console.WriteLine("What do you want to do?"); Console.WriteLine("1. Run unit tests that expect exceptions"); Console.WriteLine("2. Run unit tests on unstable code"); Console.WriteLine("9. Benchmarks"); Console.WriteLine("Z. List encodings"); Console.WriteLine("Press ESC or ENTER to Quit"); Console.WriteLine((k = Console.ReadKey(true)).KeyChar); if (k.Key == ConsoleKey.Escape || k.Key == ConsoleKey.Enter) { break; } else if (k.KeyChar == '1') { // Loyc.Essentials RunTests.Run(new GTests()); // Loyc.Utilities RunTests.Run(new GoInterfaceTests()); // Loyc.Collections RunTests.Run(new RWListTests()); RunTests.Run(new WListTests()); RunTests.Run(new RVListTests()); RunTests.Run(new VListTests()); RunTests.Run(new MapTests()); RunTests.Run(new SparseAListTests(true, seed, 8, 4)); RunTests.Run(new SparseAListTests()); RunTests.Run(new AListTests()); RunTests.Run(new BListTests()); RunTests.Run(new BDictionaryTests()); RunTests.Run(new MSetTests()); // derived from MutableSetTests<MSet<STI>, STI> RunTests.Run(new SymbolSetTests()); // derived from MutableSetTests<MSet<Symbol>, Symbol> RunTests.Run(new ImmSetTests()); // tests for Set<T> RunTests.Run(new MapTests()); // derived from DictionaryTests<MMap<object, object>> } else if (k.KeyChar == '2') { RunTests.Run(new KeylessHashtableTests()); } else if (k.KeyChar == 'z' || k.KeyChar == 'Z') { foreach (EncodingInfo inf in Encoding.GetEncodings()) { Console.WriteLine("{0} {1}: {2}", inf.CodePage, inf.Name, inf.DisplayName); } } } }
public static int Loyc_Collections() { // Test with small node sizes as well as the standard node size, // including the minimum size of 3 (the most problematic size). int seed = 237588399; return(MiniTest.RunTests.RunMany( new SimpleCacheTests(), new InvertibleSetTests(), new AListTests(false, seed, 8, 8), new BListTests(false, seed, 3, 3), new BDictionaryTests(false, seed, 6, 6), new SparseAListTests(false, seed, 10, 10), new DequeTests <AList <int> >(delegate() { return new AList <int>(); }), new DequeTests <SparseAList <int> >(delegate() { return new SparseAList <int>(); }), new DictionaryTests <BDictionary <object, object> >(true, true), new ListTests <AList <int> >(false, delegate(int n) { var l = new AList <int>(); l.Resize(n); return l; }), new ListRangeTests <AList <int> >(false, delegate() { return new AList <int>(); }, 12345), new ListTests <SparseAList <int> >(false, delegate(int n) { var l = new SparseAList <int>(); l.Resize(n); return l; }, 12345), new ListRangeTests <SparseAList <int> >(false, delegate() { return new SparseAList <int>(); }, 12345), new WListTests(), new FWListTests(), new VListTests(), new FVListTests(), new MapTests(), new SparseAListTests(true, seed, 8, 4), new SparseAListTests(), new AListTests(), new BListTests(), new BDictionaryTests(), new MSetTests(), // derived from MutableSetTests<MSet<STI>, STI> new SymbolSetTests(), // derived from MutableSetTests<MSet<Symbol>, Symbol> new ImmSetTests(), // tests for Set<T> new MapTests() // derived from DictionaryTests<MMap<object, object>> )); }
public override SparseAList <int> CopySection(SparseAList <int> alist, int start, int subcount) { return(alist.CopySection(start, subcount)); }
public static void Main(string[] args) { // Workaround for MS bug: Assert(false) will not fire in debugger Debug.Listeners.Clear(); Debug.Listeners.Add( new DefaultTraceListener() ); Console.WriteLine("Running tests on stable code..."); // Omitted: unit tests that throw & catch exceptions (those are below) // Loyc.Essentials RunTests.Run(new ListExtTests()); RunTests.Run(new MathExTests()); RunTests.Run(new UStringTests()); RunTests.Run(new StringExtTests()); RunTests.Run(new HashTagsTests()); RunTests.Run(new LocalizeTests()); RunTests.Run(new SymbolTests()); RunTests.Run(new ThreadExTests()); RunTests.Run(new ListTests<InternalList<int>>(false, delegate(int n) { var l = InternalList<int>.Empty; l.Resize(n); return l; })); RunTests.Run(new ListRangeTests<InternalList<int>>(false, delegate() { return InternalList<int>.Empty; })); RunTests.Run(new ListTests<DList<int>>(false, delegate(int n) { var l = new DList<int>(); l.Resize(n); return l; })); RunTests.Run(new DequeTests<DList<int>>(delegate() { return new DList<int>(); })); RunTests.Run(new ListRangeTests<DList<int>>(false, delegate() { return new DList<int>(); })); // Loyc.Collections RunTests.Run(new CPTrieTests()); RunTests.Run(new SimpleCacheTests()); RunTests.Run(new InvertibleSetTests()); // Test with small node sizes as well as the standard node size, // including the minimum size of 3 (the most problematic size). int seed = 237588399; RunTests.Run(new AListTests(false, seed, 8, 8)); RunTests.Run(new BListTests(false, seed, 3, 3)); RunTests.Run(new BDictionaryTests(false, seed, 6, 6)); RunTests.Run(new SparseAListTests(false, seed, 10, 10)); RunTests.Run(new DequeTests<AList<int>>(delegate() { return new AList<int>(); })); RunTests.Run(new DequeTests<SparseAList<int>>(delegate() { return new SparseAList<int>(); })); RunTests.Run(new DictionaryTests<BDictionary<object, object>>(true, true)); RunTests.Run(new ListTests<AList<int>>(false, delegate(int n) { var l = new AList<int>(); l.Resize(n); return l; })); RunTests.Run(new ListRangeTests<AList<int>>(false, delegate() { return new AList<int>(); }, 12345)); RunTests.Run(new ListTests<SparseAList<int>>(false, delegate(int n) { var l = new SparseAList<int>(); l.Resize(n); return l; }, 12345)); RunTests.Run(new ListRangeTests<SparseAList<int>>(false, delegate() { return new SparseAList<int>(); }, 12345)); // Loyc.Syntax RunTests.Run(new TokenTests()); RunTests.Run(new LesLexerTests()); RunTests.Run(new LesParserTests()); RunTests.Run(new LesPrinterTests()); RunTests.Run(new TokensToTreeTests()); RunTests.Run(new StreamCharSourceTests()); RunTests.Run(new LexerSourceTests_Calculator()); RunTests.Run(new ParserSourceTests_Calculator()); RunTests.Run(new IndentTokenGeneratorTests()); // Loyc.Utilities RunTests.Run(new LineMathTests()); RunTests.Run(new PointMathTests()); RunTests.Run(new Loyc.LLParserGenerator.IntSetTests()); RunTests.Run(new TagsInWListTests()); RunTests.Run(new UGTests()); for(;;) { ConsoleKeyInfo k; Console.WriteLine(); Console.WriteLine("What do you want to do?"); Console.WriteLine("1. Run unit tests that expect exceptions"); Console.WriteLine("2. Run unit tests on unstable code"); Console.WriteLine("9. Benchmarks"); Console.WriteLine("Z. List encodings"); Console.WriteLine("Press ESC or ENTER to Quit"); Console.WriteLine((k = Console.ReadKey(true)).KeyChar); if (k.Key == ConsoleKey.Escape || k.Key == ConsoleKey.Enter) break; else if (k.KeyChar == '1') { // Loyc.Essentials RunTests.Run(new GTests()); // Loyc.Utilities RunTests.Run(new GoInterfaceTests()); // Loyc.Collections RunTests.Run(new RWListTests()); RunTests.Run(new WListTests()); RunTests.Run(new RVListTests()); RunTests.Run(new VListTests()); RunTests.Run(new MapTests()); RunTests.Run(new SparseAListTests(true, seed, 8, 4)); RunTests.Run(new SparseAListTests()); RunTests.Run(new AListTests()); RunTests.Run(new BListTests()); RunTests.Run(new BDictionaryTests()); RunTests.Run(new MSetTests()); // derived from MutableSetTests<MSet<STI>, STI> RunTests.Run(new SymbolSetTests()); // derived from MutableSetTests<MSet<Symbol>, Symbol> RunTests.Run(new ImmSetTests()); // tests for Set<T> RunTests.Run(new MapTests()); // derived from DictionaryTests<MMap<object, object>> } else if (k.KeyChar == '2') { RunTests.Run(new KeylessHashtableTests()); } else if (k.KeyChar == 'z' || k.KeyChar == 'Z') { foreach (EncodingInfo inf in Encoding.GetEncodings()) Console.WriteLine("{0} {1}: {2}", inf.CodePage, inf.Name, inf.DisplayName); } } }
public static void Loyc_Collections() { MiniTest.RunTests.Run(new CPTrieTests()); MiniTest.RunTests.Run(new SimpleCacheTests()); MiniTest.RunTests.Run(new InvertibleSetTests()); // Test with small node sizes as well as the standard node size, // including the minimum size of 3 (the most problematic size). int seed = 237588399; MiniTest.RunTests.Run(new AListTests(false, seed, 8, 8)); MiniTest.RunTests.Run(new BListTests(false, seed, 3, 3)); MiniTest.RunTests.Run(new BDictionaryTests(false, seed, 6, 6)); MiniTest.RunTests.Run(new SparseAListTests(false, seed, 10, 10)); MiniTest.RunTests.Run(new DequeTests<AList<int>>(delegate() { return new AList<int>(); })); MiniTest.RunTests.Run(new DequeTests<SparseAList<int>>(delegate() { return new SparseAList<int>(); })); MiniTest.RunTests.Run(new DictionaryTests<BDictionary<object, object>>(true, true)); MiniTest.RunTests.Run(new ListTests<AList<int>>(false, delegate(int n) { var l = new AList<int>(); l.Resize(n); return l; })); MiniTest.RunTests.Run(new ListRangeTests<AList<int>>(false, delegate() { return new AList<int>(); }, 12345)); MiniTest.RunTests.Run(new ListTests<SparseAList<int>>(false, delegate(int n) { var l = new SparseAList<int>(); l.Resize(n); return l; }, 12345)); MiniTest.RunTests.Run(new ListRangeTests<SparseAList<int>>(false, delegate() { return new SparseAList<int>(); }, 12345)); MiniTest.RunTests.Run(new RWListTests()); MiniTest.RunTests.Run(new WListTests()); MiniTest.RunTests.Run(new RVListTests()); MiniTest.RunTests.Run(new VListTests()); MiniTest.RunTests.Run(new MapTests()); MiniTest.RunTests.Run(new SparseAListTests(true, seed, 8, 4)); MiniTest.RunTests.Run(new SparseAListTests()); MiniTest.RunTests.Run(new AListTests()); MiniTest.RunTests.Run(new BListTests()); MiniTest.RunTests.Run(new BDictionaryTests()); MiniTest.RunTests.Run(new MSetTests()); // derived from MutableSetTests<MSet<STI>, STI> MiniTest.RunTests.Run(new SymbolSetTests()); // derived from MutableSetTests<MSet<Symbol>, Symbol> MiniTest.RunTests.Run(new ImmSetTests()); // tests for Set<T> MiniTest.RunTests.Run(new MapTests()); // derived from DictionaryTests<MMap<object, object>> MiniTest.RunTests.Run(new KeylessHashtableTests()); }