public void IncrementIntegerTest() { Action<List<int>>[] actions = new Action<List<int>>[] { IncrementInteger.Convert, IncrementInteger.SinglePass }; int digits = 0; for (int i = 0; i <= 1000; i++) { if (i % 10 == 0) digits++; for(int j = 0; j < actions.Length; j++) { List<int> list = new List<int>(); for (int k = 0; k < digits; k++) list.Insert(0, 0); IncrementInteger.ToList(i, list); actions[j](list); Assert.AreEqual(IncrementInteger.ToInt(list), i + 1); } } }
public void Constructor() { TestAssemblyResults testAssemblyResults = new TestAssemblyResults(null, TimeSpan.FromSeconds(42)); Assert.IsNotNull(testAssemblyResults.TestClassResults); Assert.IsFalse(testAssemblyResults.TestClassResults.Any()); Assert.AreEqual(42, testAssemblyResults.ExecutionTime.TotalSeconds); Assert.AreEqual(TestResultStatus.Passed, testAssemblyResults.Status); ////////////////////////////// List<TestClassResults> testClassResults = new List<TestClassResults>() { new TestClassResults("SomeClassName", null, new TimeSpan()) { Status = TestResultStatus.Passed } }; testAssemblyResults = new TestAssemblyResults(testClassResults, new TimeSpan()); Assert.IsNotNull(testAssemblyResults.TestClassResults); Assert.AreEqual(1, testAssemblyResults.TestClassResults.Count()); Assert.AreEqual("SomeClassName", testAssemblyResults.TestClassResults.Single().ClassName); Assert.AreEqual(TestResultStatus.Passed, testAssemblyResults.Status); ////////////////////////////// testClassResults.Insert(0, new TestClassResults("SomeClassName2", null, new TimeSpan()) { Status = TestResultStatus.Inconclusive }); testAssemblyResults = new TestAssemblyResults(testClassResults, new TimeSpan()); Assert.AreEqual(TestResultStatus.Inconclusive, testAssemblyResults.Status); ////////////////////////////// testClassResults.Insert(1, new TestClassResults("SomeClassName3", null, new TimeSpan()) { Status = TestResultStatus.Failed }); testAssemblyResults = new TestAssemblyResults(testClassResults, new TimeSpan()); Assert.AreEqual(TestResultStatus.Failed, testAssemblyResults.Status); }
public void changeDaySatusTest() { int _howmanydays = 500; // TODO: Initialize to an appropriate value int _hq_x = 700; // TODO: Initialize to an appropriate value int _hq_y = 1000; // TODO: Initialize to an appropriate value Mission target = new Mission(_howmanydays, _hq_x, _hq_y); // TODO: Initialize to an appropriate value target.BeginningDateEarth = new DateTime(2015, 11, 20); target.startMission(); int nbJour = target.convertEarthDateInMissionDay()[0]; List<Day> expected = new List<Day>(); int i; for (i = 0; i < nbJour; i++) { expected.Insert(i,new Past(i,target.map_Hq)); } expected.Insert(nbJour, new Present(nbJour, target.map_Hq)); for (i = nbJour+1; i < _howmanydays; i++) { expected.Insert(i, new Future(i, target.map_Hq)); } bool same = true; int j=0; while (same && (j < _howmanydays)) { if (!(target.L_day[j].GetType().Equals(expected[j].GetType()))) { same = false; } j++; } Assert.IsTrue(same); }
void EntryInit() { rev = new List<int>(); sorted = new List<int>(); i = 0; while (i < 10) { rev.Insert(0, i); sorted.Add(i); i = i + 1; } this.Assert(rev.Count == 10); // Assert that simply reversing the list produces a sorted list sorted = Reverse(rev); this.Assert(sorted.Count == 10); b = IsSorted(sorted); this.Assert(b); b = IsSorted(rev); this.Assert(!b); // Assert that BubbleSort returns the sorted list sorted = BubbleSort(rev); this.Assert(sorted.Count == 10); b = IsSorted(sorted); this.Assert(b); b = IsSorted(rev); this.Assert(!b); }
public void TestUpperBound_BuildSet() { Random random = new Random(); // build a list var list = new List<int>(100); Sublist.Generate(100, i => random.Next(100)).AddTo(list.ToSublist()); // only add unique items in sorted order var set = new List<int>(); foreach (int value in list) { int index = set.ToSublist().UpperBound(value); if (index == 0 || set[index - 1] != value) { set.Insert(index, value); } } // check that all items are present, sorted and unique list.ToSublist().Sort().InPlace(); Assert.IsTrue(set.ToSublist().IsSorted(), "The set is not sorted."); bool hasValues = set.ToSublist().IsSubset(list.ToSublist()); Assert.IsTrue(hasValues, "Not all of the values were copied."); Assert.IsFalse(set.ToSublist().FindDuplicates(), "A duplicate was found."); }
public void TestChar() { var list = new List<char>(); list.Insert('v', 0); list.Insert('c', 1); list.Insert('d', 2); var arr = new char[3]; int i = 0; foreach (char x in list) { arr[i] = x; ++i; } Assert.AreEqual('v', arr[0]); Assert.AreEqual('c', arr[1]); Assert.AreEqual('d', arr[2]); }
public void TestItemAtInPlace_Find3rdPlace() { Random random = new Random(); // build a list, leaving space for zero, one and two var list = new List<int>(97); Sublist.Generate(97, i => random.Next(3, 100)).AddTo(list.ToSublist()); // insert 0-2 at random positions in the list list.Insert(random.Next(0, list.Count + 1), 0); list.Insert(random.Next(0, list.Count + 1), 1); list.Insert(random.Next(0, list.Count + 1), 2); // now find what item belongs in the second position, as if the list was sorted list.ToSublist().ItemAt(2).InPlace(); int actual = list[2]; Assert.AreEqual(2, actual, "The 2 was not moved to the second position."); }
public void QuickPulseDataAccumulatorManagerLocksInSampleCorrectlyMultithreaded() { // ARRANGE var accumulatorManager = new QuickPulseDataAccumulatorManager(); int taskCount = 100; var writeTasks = new List<Task>(taskCount); var pause = TimeSpan.FromMilliseconds(10); for (int i = 0; i < taskCount; i++) { var task = new Task(() => { Interlocked.Increment(ref accumulatorManager.CurrentDataAccumulator.AIRequestSuccessCount); // sleep to increase the probability of sample completion happening right now Thread.Sleep(pause); Interlocked.Increment(ref accumulatorManager.CurrentDataAccumulator.AIDependencyCallSuccessCount); }); writeTasks.Add(task); } var completionTask = new Task(() => { // sleep to increase the probability of more write tasks being between the two writes Thread.Sleep(TimeSpan.FromTicks(pause.Ticks / 2)); accumulatorManager.CompleteCurrentDataAccumulator(); }); // shuffle the completion task into the middle of the pile to have it fire roughly halfway through writeTasks.Insert(writeTasks.Count / 2, completionTask); // ACT var sample1 = accumulatorManager.CurrentDataAccumulator; var result = Parallel.For(0, writeTasks.Count, new ParallelOptions() { MaxDegreeOfParallelism = taskCount }, i => writeTasks[i].RunSynchronously()); while (!result.IsCompleted) { } var sample2 = accumulatorManager.CurrentDataAccumulator; // ASSERT // we expect some "telemetry items" to get "sprayed" over the two neighboring samples Assert.IsTrue(sample1.AIRequestSuccessCount > sample1.AIDependencyCallSuccessCount); Assert.IsTrue(sample2.AIRequestSuccessCount < sample2.AIDependencyCallSuccessCount); // overall numbers should match exactly Assert.AreEqual(taskCount, sample1.AIRequestSuccessCount + sample2.AIRequestSuccessCount); Assert.AreEqual(taskCount, sample1.AIDependencyCallSuccessCount + sample2.AIDependencyCallSuccessCount); }
/// <summary> /// Adds DCE stuffing to the list of bytes passed across. /// </summary> /// <param name="bytes"></param> private List<byte> AddDCEStuffing(List<byte> bytes) { for(var i = 0;i < bytes.Count;++i) { if(bytes[i] == 0x010) { bytes.Insert(i, 0x10); ++i; } } return bytes; }
private static int[] ToArray(int x) { bool negative = x < 0; x = Math.Abs(x); List<int> list = new List<int>(); while(x > 0) { list.Insert(0, x % 10); x /= 10; } if (negative) list[0] *= -1; return list.ToArray(); }
public void CountSolutions() { for (int iter=0; iter< Iterations; iter++) { var work = Factory.Solution(rnd); List<Location> order = new List<Location>(); for (int i = 0; i < 81; i++) order.Insert(rnd.Next(order.Count), i); for (int i = 0; i < 40; i++) work[order[i]] = 0; givens[0].Add(work.CountSolutions()); } WriteStatistics("Solutions found after cutting 40 singles:", givens[0]); }
private static void SinglePass(List<int> number) { int i = number.Count - 1; number[i]++; while(i > 0 && number[i] == 10) { number[i] = 0; i--; number[i]++; } if(number[0] == 10) { number[0] = 0; number.Insert(0, 1); } }
void EntryInit() { l = new List<int>(); l.Insert(0, 12); l.Insert(0, 23); l.Insert(0, 12); l.Insert(0, 23); l.Insert(0, 12); l.Insert(0, 23); mac = this.CreateMachine(typeof(Tester)); this.Send(mac, new Config(l, 1)); this.Send(mac, new SeqPayload(l)); }
public void TestFindAny_FindSpecialCharacters() { Random random = new Random(); // build a random string representing a password var password = new List<char>(); Sublist.Generate(100, i => (char)random.Next(32, 127)).AddTo(password.ToSublist()); password.Insert(50, '>'); // insert an invalid character // have a list of characters that aren't allowed char[] exclusions = { '<', '>', '[', ']', '{', '}', '(', ')' }; // see if the password contains an invalid character var result = password.ToSublist().FindAny(exclusions.ToSublist()); Assert.IsTrue(result.Exists, "No special characters were found."); char actual = password[result.Index]; Assert.IsTrue(exclusions.ToSublist().Find(actual), "The character found was not in the exclusions list."); }
public void ConfirmSetTest() { SET.Processing isSet = new Processing(); List<Cards> cardList = new List<Cards>(); SET.Cards card1 = new Cards(); SET.Cards card2 = new Cards(); SET.Cards card3 = new Cards(); card1.Color = "red"; card1.Number = 1; card1.Shade = "solid"; card1.Shape = "oval"; card2.Color = "green"; card2.Number = 2; card2.Shade = "solid"; card2.Shape = "oval"; card3.Color = "blue"; card3.Number = 3; card3.Shade = "solid"; card3.Shape = "oval"; cardList.Insert(0, card1); cardList.Insert(1, card2); cardList.Insert(2, card3); Assert.IsTrue(isSet.ConfirmSet(cardList) > 0); card1.Color = "red"; card1.Number = 1; card1.Shade = "solid"; card1.Shape = "oval"; card2.Color = "green"; card2.Number = 2; card2.Shade = "solid"; card2.Shape = "oval"; card3.Color = "blue"; card3.Number = 2; card3.Shade = "solid"; card3.Shape = "oval"; cardList.Clear(); cardList.Insert(0, card1); cardList.Insert(1, card2); cardList.Insert(2, card3); Assert.IsFalse(isSet.ConfirmSet(cardList) > 0); }
public void Details_LoggedInStaff_ShouldReturnAPrimaryGuardian() { // Arrange Mock<IAccountService> accountService = new Mock<IAccountService>(); Mock<IRepositoryService> repoService = new Mock<IRepositoryService>(); Mock<IPrimaryGuardianRepository> primaryGuardianRepo = new Mock<IPrimaryGuardianRepository>(); Mock<ICenterRepository> centerRepo = new Mock<ICenterRepository>(); // center id 1 accountService.Setup(a => a.GetCurrentUserCenterId()).Returns(() => 1); accountService.Setup(a => a.GetRolesForUser()).Returns(new string[] { "Staff" }); var pgs1 = new List<PrimaryGuardian>(); for (int i = 0; i < 15; i++) { pgs1.Insert(i, (Util.RandomPrimaryGuardian(i + 1, 1))); } var pgs1Children = new[] { Util.RandomChild(1, pgs1[0].Id), Util.RandomChild(2, pgs1[0].Id) }; var pgs1SecGuardian = new[] { Util.RandomSecondaryGuardian(1, pgs1[0].Id) }; primaryGuardianRepo.Setup(r => r.FindByIdAndCenterId(7, 1)).Returns(pgs1[6]); repoService.SetupGet(r => r.primaryGuardianRepo).Returns(() => primaryGuardianRepo.Object); repoService.SetupGet(r => r.centerRepo).Returns(() => centerRepo.Object); PrimaryGuardiansController controller = new PrimaryGuardiansController(accountService.Object, repoService.Object); // Act ActionResult result = controller.Details(7) as ActionResult; // Assert Assert.IsInstanceOfType(result, typeof(ViewResult)); ViewResult asViewResult = (ViewResult)result; Assert.IsFalse(asViewResult.ViewBag.IsAdmin); Assert.IsInstanceOfType(asViewResult.ViewData.Model, typeof(PrimaryGuardian)); Assert.AreEqual(pgs1[6], (PrimaryGuardian)asViewResult.Model); }
public TestClass(Type type, IEnumerable<IFilter> filters) { _type = type; var validCtor = type.GetConstructor(new Type[] { }); _ctor = validCtor == null ? (Func<object>)null : () => validCtor.Invoke(_noArgs); Name = type.Name; List<MethodInfo> methods = new List<MethodInfo>(); for (var testType = type; testType != typeof(object); testType = testType.BaseType) { foreach (var method in testType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static)) { methods.Insert(0, method); } } Methods = ( from method in methods where method.GetCustomAttributes(typeof(TestMethodAttribute), true).Any() where filters.All(filter => filter.Test(type, method)) select new TestMethod(method)).ToList(); _assemblyInitialize = new AuxiliaryMethod<AssemblyInitializeAttribute>(methods, @static: true); _assemblyCleanup = new AuxiliaryMethod<AssemblyCleanupAttribute>(methods, @static: true); _classInitialize = new AuxiliaryMethod<ClassInitializeAttribute>(methods, @static: true); _classCleanup = new AuxiliaryMethod<ClassCleanupAttribute>(methods, @static: true); _testCleanup = new AuxiliaryMethod<TestCleanupAttribute>(methods); _testInitialize = new AuxiliaryMethod<TestInitializeAttribute>(methods); }
public void TestRenameNameSpaceForSite() { IInputContext context = DnaMockery.CreateDatabaseInputContext(); // Create the namespace object and call the add namespace method NameSpaces testNameSpace = new NameSpaces(context); // Create the list of anmespace to add List<NameSpaceItem> namespaces = new List<NameSpaceItem>(); namespaces.Add(AddNameSpaceToSite(1, "category")); namespaces.Add(AddNameSpaceToSite(1, "mood")); namespaces.Add(AddNameSpaceToSite(1, "people")); namespaces.Add(AddNameSpaceToSite(1, "places")); foreach (NameSpaceItem name in namespaces) { // check to make sure the name was added correctly Assert.IsTrue(name.ID > 0, "NameSpaceId is zero! Failed to create new name space. namespace being added = " + name.Name); } // Create the stored procedure reader for the namespace object using (IDnaDataReader reader = context.CreateDnaDataReader("renamenamespace")) { // Now rename one of the namespaces NameSpaceItem renamed = new NameSpaceItem(namespaces[1].Name + "-renamed", namespaces[1].ID); namespaces.RemoveAt(1); namespaces.Insert(1, renamed); testNameSpace.RenameNameSpaceForSite(1, namespaces[1].ID, namespaces[1].Name); } // Now get all the namespaces for the site using (IDnaDataReader reader2 = context.CreateDnaDataReader("getnamespacesforsite")) { // Now get all the namespaces for the site and comparte the results with the known values. List<NameSpaceItem> foundNameSpaces = testNameSpace.GetNameSpacesForSite(1); for (int i = 0; i < foundNameSpaces.Count; i++) { Assert.AreEqual(namespaces[i].Name, foundNameSpaces[i].Name, "The namespaces found are not the same as the ones added for Names"); Assert.AreEqual(namespaces[i].ID, foundNameSpaces[i].ID, "The namespaces found are not the same as the ones added for IDs"); } } }
public void TestInsert_IndexInMiddle_InsertsInMiddle() { var list = new List<int>() { 1, 2, 4, 5 }.Reversed(); list.Insert(2, 3); int[] expected = { 1, 2, 3, 4, 5 }; Assert.IsTrue(expected.ToSublist().IsEqualTo(list.List.ToSublist())); }
private XElement SortChildren(XElement parentElement) { // if not in regular Csdl xml namespace, do not sort any further if (parentElement.Name.NamespaceName != this.schemaNamespaceName) { return parentElement; } // sort attributes var sortedAttributes = parentElement.Attributes().OrderBy(a => a.Name.NamespaceName + ":" + a.Name.LocalName); // sort child elements List<XElement> sortedElements = new List<XElement>(); foreach (var e in parentElement.Elements()) { int index = this.FindInsertionIndex(e, sortedElements, parentElement.Name.LocalName); sortedElements.Insert(index, this.SortChildren(e)); } var nonElements = parentElement.Nodes().Where(n => !(n is XElement)); return new XElement(parentElement.Name, sortedAttributes, sortedElements, nonElements); }
public void GeneratorChildrenTest() { var children = new List<ChildInfo> { new ChildInfo("gi_frame", null), new ChildInfo("gi_running", null), new ChildInfo("Results View", "tuple(a)", "Expanding the Results View will run the iterator") }; if (Version.Version >= PythonLanguageVersion.V26) { children.Insert(0, new ChildInfo("gi_code", null)); } ChildTest("GeneratorTest.py", 6, "a", 0, children.ToArray()); }
public void GradingNFAEps() { var solver = new CharSetSolver(BitWidth.BV64); List<char> alph = new List<char> { 'a', 'b' }; HashSet<char> al = new HashSet<char>(alph); var a = solver.MkCharConstraint(false, 'a'); var b = solver.MkCharConstraint(false, 'b'); var movesSol = new List<Move<BDD>>(); movesSol.Add(new Move<BDD>(5, 0, null)); movesSol.Add(new Move<BDD>(0, 0, a)); movesSol.Add(new Move<BDD>(0, 0, b)); movesSol.Add(new Move<BDD>(0, 1, a)); movesSol.Add(new Move<BDD>(1, 2, b)); var nfa1 = Automaton<BDD>.Create(5, new int[] { 2 }, movesSol); var movesAtt = new List<Move<BDD>>(); movesAtt.Add(new Move<BDD>(0, 0, a)); movesAtt.Add(new Move<BDD>(0, 1, b)); movesAtt.Add(new Move<BDD>(1, 1, b)); movesAtt.Add(new Move<BDD>(1, 2, a)); movesAtt.Add(new Move<BDD>(2, 2, a)); movesAtt.Add(new Move<BDD>(2, 3, b)); movesAtt.Add(new Move<BDD>(3, 3, b)); movesAtt.Add(new Move<BDD>(3, 4, a)); movesAtt.Add(new Move<BDD>(4, 4, a)); movesAtt.Add(new Move<BDD>(4, 4, b)); var nfa2 = Automaton<BDD>.Create(0, new int[] { 4 }, movesAtt); List<Pair<int, IEnumerable<NFAFeedback>>> tests = new List<Pair<int, IEnumerable<NFAFeedback>>>(); tests.Insert(0,NFAGrading.GetGrade(nfa1, nfa2, al, solver, timeout, 10, FeedbackLevel.Hint)); tests.Insert(0, NFAGrading.GetGrade(nfa2, nfa1, al, solver, timeout, 10, FeedbackLevel.Hint)); tests.Insert(0, NFAGrading.GetGrade(nfa1, nfa1, al, solver, timeout, 10, FeedbackLevel.Hint)); tests.Insert(0, NFAGrading.GetGrade(nfa2, nfa2, al, solver, timeout, 10, FeedbackLevel.Hint)); foreach (var test in tests) { Console.WriteLine("grade: {0}, ", test.First); foreach (var f in test.Second) Console.WriteLine(f.ToString()); } }
public void TestInsert_IndexTooBig_Throws() { var list = new List<int>() { 1, 2, 3 }.Reversed(); list.Insert(4, 0); }
private static void CalculateConditionStatesBasedOnTestCase2() { List<DTElement> elements = new List<DTElement>(); for (int i = 0; i < 2; i++) elements.Add(new DTElement { Name = string.Format("Condition {0}", i), Kind = DTElementKind.Condition }); for (int i = 0; i < 2; i++) elements.Add(new DTElement { Name = string.Format("Action {0}", i), Kind = DTElementKind.Action }); var f = DTState.No; var t = DTState.Yes; var e = DTState.Empty; var notOrdered = new List<List<DTState>> { new DTState[] { f, t, f, t }.ToList(), new DTState[] { f, f, t, t }.ToList(), new DTState[] { e, e, e, t }.ToList(), new DTState[] { t, t, e, t }.ToList() }; for (int i = 0; i < elements.Count; i++) elements[i].SetStates(notOrdered[i]); DTRuleSet basedOn = DTRuleSet.FromElements(elements); elements.Insert(2, new DTElement { Name = "Condition 2", Kind = DTElementKind.Condition }); elements.Insert(3, new DTElement { Name = "Condition 3", Kind = DTElementKind.Condition }); var expected = new Dictionary<DTElement, List<DTState>> { { elements[0], new DTState[] { f, f, f, f, t, t, t, t, f, f, f, f, t, t, t, t }.ToList() }, { elements[1], new DTState[] { f, f, f, f, f, f, f, f, t, t, t, t, t, t, t, t }.ToList() }, { elements[2], new DTState[] { t, t, f, f, t, t, f, f, t, t, f, f, t, t, f, f }.ToList() }, { elements[3], new DTState[] { t, f, t, f, t, f, t, f, t, f, t, f, t, f, t, f }.ToList() }, //{ elements[4], new DTState[] { e, e, e, e, e, e, e, e, e, e, e, e, t, t, t, t }.ToList() }, //{ elements[5], new DTState[] { t, t, t, t, t, t, t, t, e, e, e, e, t, t, t, t }.ToList() }, }; var actual = DTRuleSet_Accessor.CalculateConditionStatesBasedOn(elements, basedOn); foreach (var pair in expected) { CollectionAssert.AreEqual(pair.Value, actual[pair.Key]); } }
public void CloudBlockBlobBlockReordering() { CloudBlobContainer container = GetRandomContainerReference(); try { container.Create(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); List<string> originalBlockIds = GetBlockIdList(10); List<string> blockIds = new List<string>(originalBlockIds); List<byte[]> blocks = new List<byte[]>(); for (int i = 0; i < blockIds.Count; i++) { byte[] buffer = Encoding.UTF8.GetBytes(i.ToString()); using (MemoryStream stream = new MemoryStream(buffer)) { blob.PutBlock(blockIds[i], stream, null); } blocks.Add(buffer); } blob.PutBlockList(blockIds); Assert.AreEqual("0123456789", DownloadText(blob, Encoding.UTF8)); blockIds.RemoveAt(0); blob.PutBlockList(blockIds); Assert.AreEqual("123456789", DownloadText(blob, Encoding.UTF8)); blockIds.RemoveAt(8); blob.PutBlockList(blockIds); Assert.AreEqual("12345678", DownloadText(blob, Encoding.UTF8)); blockIds.RemoveAt(3); blob.PutBlockList(blockIds); Assert.AreEqual("1235678", DownloadText(blob, Encoding.UTF8)); using (MemoryStream stream = new MemoryStream(blocks[9])) { blob.PutBlock(originalBlockIds[9], stream, null); } blockIds.Insert(0, originalBlockIds[9]); blob.PutBlockList(blockIds); Assert.AreEqual("91235678", DownloadText(blob, Encoding.UTF8)); using (MemoryStream stream = new MemoryStream(blocks[0])) { blob.PutBlock(originalBlockIds[0], stream, null); } blockIds.Add(originalBlockIds[0]); blob.PutBlockList(blockIds); Assert.AreEqual("912356780", DownloadText(blob, Encoding.UTF8)); using (MemoryStream stream = new MemoryStream(blocks[4])) { blob.PutBlock(originalBlockIds[4], stream, null); } blockIds.Insert(2, originalBlockIds[4]); blob.PutBlockList(blockIds); Assert.AreEqual("9142356780", DownloadText(blob, Encoding.UTF8)); blockIds.Insert(0, originalBlockIds[0]); blob.PutBlockList(blockIds); Assert.AreEqual("09142356780", DownloadText(blob, Encoding.UTF8)); } finally { container.DeleteIfExists(); } }
private void VerificationScenario(uint testKey) { // setup List<SiloAddress> silos = new List<SiloAddress>(); foreach (var siloHandle in GetActiveSilos()) { long hash = siloHandle.Silo.SiloAddress.GetConsistentHashCode(); int index = silos.FindLastIndex(siloAddr => siloAddr.GetConsistentHashCode() < hash) + 1; silos.Insert(index, siloHandle.Silo.SiloAddress); } // verify parameter key VerifyKey(testKey, silos); // verify some other keys as well, apart from the parameter key // some random keys for (int i = 0; i < 3; i++) { VerifyKey((uint)random.Next(), silos); } // lowest key uint lowest = (uint)(silos.First().GetConsistentHashCode() - 1); VerifyKey(lowest, silos); // highest key uint highest = (uint)(silos.Last().GetConsistentHashCode() + 1); VerifyKey(lowest, silos); }
public void TestInsert_NegativeIndex_Throws() { var list = new List<int>() { 1, 2, 3 }.Reversed(); list.Insert(-1, 4); }
public void SearchCollection1SearchTermMultiplePropertiesDuplicateResultTest() { //Happy flow var searchCollection = new List<HelpItem>(_helpItems); searchCollection.Insert(2, searchCollection[3]); var target = new SearchList<HelpItem>(searchCollection); const string searchTerm = "Help omschrijving 4"; var expected = searchCollection.Find(s => s.HelpDescription == searchTerm); _propertyNames[4] = string.Empty; var actual = target.SearchCollection1SearchTermAllProperties(searchTerm, _propertyNames); Assert.IsTrue(actual.Contains(expected)); }
//throws Exception /** Allow checking for multiple errors in one test */ protected void checkErrors( ErrorQueue equeue, List<object> expectedMessages ) { var messageExpected = new List<object>( equeue.errors.Count ); for ( int i = 0; i < equeue.errors.Count; i++ ) { Message m = (Message)equeue.errors[i]; bool foundMsg = false; for ( int j = 0; j < expectedMessages.Count; j++ ) { Message em = (Message)expectedMessages[j]; if ( m.msgID == em.msgID && m.arg.Equals( em.arg ) && m.arg2.Equals( em.arg2 ) ) { foundMsg = true; } } if ( foundMsg ) { messageExpected.Insert( i, true ); } else messageExpected.Insert( i, false ); } for ( int i = 0; i < equeue.errors.Count; i++ ) { Assert.IsTrue( ( (Boolean)messageExpected[i] ), "unexpected error:" + equeue.errors[i] ); } }
public void Conversation() { //OAuthTokens tokens = Configuration.GetTokens(); var statusResponse = TwitterStatus.Show(7183041864671232); Assert.IsNotNull(statusResponse.ResponseObject, statusResponse.ErrorMessage); List<TwitterStatus> conversation = new List<TwitterStatus>(); conversation.Add(statusResponse.ResponseObject); while (statusResponse.ResponseObject.InReplyToStatusId.HasValue) { statusResponse = TwitterStatus.Show(statusResponse.ResponseObject.InReplyToStatusId.Value); Assert.IsNotNull(statusResponse.ResponseObject, statusResponse.ErrorMessage); conversation.Insert(0, statusResponse.ResponseObject); } }