public void FindPathsInvalidate() { var graph = InitGraph(); var dijkstra = new DijkstraAlhorithm <string, TestVertexData, string, TestEdgeData>(graph); dijkstra.FindPaths("S"); var path = dijkstra.GetPath("T"); CollectionAssert.AreEqual(new List <string>() { "S", "V3", "V4", "T" }, path); dijkstra.Invalidate(); dijkstra.FindPaths("S"); path = dijkstra.GetPath("T"); CollectionAssert.AreEqual(new List <string>() { "S", "V3", "V4", "T" }, path); }
public void GetAll_ReturnsOrders_OrderList() { string title01 = "croissants"; string description01 = "catering order"; int price01 = 50; string date01 = "jan 1"; string title02 = "shortbread"; string description02 = "british bake off"; int price02 = 25; string date02 = "april 1"; Order newOrder1 = new Order(title01, description01, price01, date01); Order newOrder2 = new Order(title02, description02, price02, date02); List <Order> newOrder = new List <Order> { newOrder1, newOrder2 }; List <Order> result = new List <Order> { newOrder1, newOrder2 }; CollectionAssert.AreEqual(newOrder, result); }
public void VerifyThatJaggedArrayReturnsExpectedValueArray() { var value = new List <string>() { "-", "-", "-", "-" }; var expectedValueArray = new ValueArray <string>(value); this.defaultValueArrayFactory.Load(transaction, this.secutrityContext.Object); this.parameterTypeService.Verify(x => x.GetShallow(this.transaction, It.IsAny <string>(), It.IsAny <IEnumerable <Guid> >(), this.secutrityContext.Object), Times.Exactly(1)); this.parameterTypeComponentService.Verify(x => x.GetShallow(this.transaction, It.IsAny <string>(), It.IsAny <IEnumerable <Guid> >(), this.secutrityContext.Object), Times.Exactly(1)); var valueArray = this.defaultValueArrayFactory.CreateDefaultValueArray(this.jaggedArrayIid); CollectionAssert.AreEquivalent(expectedValueArray, valueArray); valueArray = this.defaultValueArrayFactory.CreateDefaultValueArray(this.jaggedArrayIid); CollectionAssert.AreEquivalent(expectedValueArray, valueArray); }
public void GetMenuItems_ReturnsCorrectList_MenuItemList() { string name = "Chicken"; float price = 13.99f; List <string> ingredients = new List <string> { "Chicken", "Salt", "Pepper" }; MenuItem newItem = new MenuItem(name, price, ingredients); newItem.Save(); Order newOrder = new Order(); newOrder.Save(); items.Add(newItem); newOrder.AddItem(newItem.GetId()); Order testOrder = Order.Find(newOrder.GetId()); List <MenuItem> testList = testOrder.GetMenuItems(); Console.WriteLine(items.Count + " " + testList.Count); CollectionAssert.AreEqual(items, testList); }
public void HeaderWithAllSet() { Header header = new Header(); header.Id = 1; header.Response = true; header.OperationCode = OperationCode.Status; header.AuthorativeServer = true; header.Truncated = true; header.RecursionDesired = true; header.RecursionAvailable = true; header.ResponseCode = ResponseCode.ServerFailure; header.QuestionCount = 1; header.AnswerRecordCount = 1; header.AuthorityRecordCount = 1; header.AdditionalRecordCount = 1; byte[] content = Helper.ReadFixture("Header", "all"); CollectionAssert.AreEqual(content, header.ToArray()); }
public void Can_select_unary_not_variable_expression() { // ReSharper disable ConvertToConstant.Local var boolVal = true; // ReSharper restore ConvertToConstant.Local var expected = new TestType() { IntColumn = 12, BoolColumn = false, StringColumn = "test" }; EstablishContext(10, expected); var actual = ConnectionString.OpenDbConnection().Select <TestType>(q => q.BoolColumn == !boolVal); Assert.IsNotNull(actual); Assert.Greater(actual.Count, 0); CollectionAssert.Contains(actual, expected); }
private Action <IActivity> CollectEmailContentMessageForForward(string userName) { return(activity => { var messageActivity = activity.AsMessageActivity(); var noEmailContentMessages = GetTemplates(EmailSharedResponses.NoEmailContentForForward); var recipientConfirmedMessages = GetTemplates(EmailSharedResponses.RecipientConfirmed, new { userName = userName }); var allReply = new List <string>(); foreach (var recipientConfirmedMessage in recipientConfirmedMessages) { foreach (var noEmailContentMessage in noEmailContentMessages) { allReply.Add(recipientConfirmedMessage + " " + noEmailContentMessage); } } CollectionAssert.Contains(allReply, messageActivity.Text); }); }
public void FacadeInsertAMonumentAndGetContent() { //Arrange MockRepository mockRepository = new MockRepository(); MonumentController monumentController = new MonumentController(mockRepository); Monument dummyMonument = new Monument() { Id = 1, MonumentNaam = "Manneke pis" }; //Act monumentController.Post(dummyMonument); List <Monument> result = (List <Monument>)monumentController.Get(); //Assert Assert.AreEqual(1, mockRepository.NumberOfTimesAddCalled); CollectionAssert.Contains(result, dummyMonument); }
public void choseongSingleToJongseongTest() { //Arrange char[] testInput = new char[] { 'ᆨ', 'ᆫ', 'ᆮ', 'ᆯ', 'ᆷ', 'ᆸ', 'ᆺ', 'ᆼ', 'ᆽ', 'ᆾ', 'ᆿ', 'ᇀ', 'ᇁ', 'ᇂ' }; char[] expected = new char[] { 'ᄀ', 'ᄂ', 'ᄃ', 'ᄅ', 'ᄆ', 'ᄇ', 'ᄉ', 'ᄋ', 'ᄌ', 'ᄎ', 'ᄏ', 'ᄐ', 'ᄑ', 'ᄒ' }; int testArrLen = testInput.Length; char[] result = new char[testArrLen]; //Act for (int i = 0; i < testArrLen; i++) { result[i] = Hangul.choseongSingleToJongseong(testInput[i]); } //Assert CollectionAssert.AreEqual(expected, result); }
public void TestRemoveKeys() { var cache = GetClientCache<int?, int?>(); var keys = Enumerable.Range(1, 10).Cast<int?>().ToArray(); cache.PutAll(keys.ToDictionary(x => x, x => x)); cache.RemoveAll(keys.Skip(2)); CollectionAssert.AreEquivalent(keys.Take(2), cache.GetAll(keys).Select(x => x.Key)); cache.RemoveAll(new int?[] {1}); Assert.AreEqual(2, cache.GetAll(keys).Single().Value); cache.RemoveAll(keys); cache.RemoveAll(keys); Assert.AreEqual(0, cache.GetSize()); Assert.Throws<ArgumentNullException>(() => cache.RemoveAll(null)); Assert.Throws<IgniteClientException>(() => cache.RemoveAll(new int?[] {1, null})); }
public void SerializeCleanExbin() { NintendoLand.DataFormats.FruitData fruitData = NintendoLand.DataFormats.FruitData.Load(pathToYsiExtract); Assert.AreEqual(fruitData.FruitCount, 90, "Default game files require exactly 90 fruit definitions"); List <byte> serializedData = new List <byte>(); fruitData.SerializeExbin(ref serializedData, 16 + 84 * 90 + 3); // magic number is the max length of the default FruitData.exbin-file #if DEBUG // Write inspectable files during debug builds to allow diffing of generated output and regular files in external tools File.WriteAllText(pathToYsiExtract + "FruitData.exbin" + ".gen", string.Empty); File.WriteAllBytes(pathToYsiExtract + "FruitData.exbin" + ".gen", serializedData.ToArray()); #endif CollectionAssert.AreEqual( File.ReadAllBytes(Path.Combine(pathToYsiExtract, "FruitData.exbin")), serializedData ); }
public void TestMatrixParallelMultiply() { var data = ResourceLoader.Get <double>("general-40x40.mat"); var values = new double[120 * 120]; foreach (var item in data.EnumerateIndexed()) { int i = item.Item1; int j = item.Item2; for (var k = 0; k < 3; k++) { for (var m = 0; m < 3; m++) { values[120 * (i + 40 * k) + j + 40 * m] = item.Item3; } } } var A = DenseMatrix.OfColumnMajor(120, 120, values); CollectionAssert.AreEqual(A.Multiply(A).Values, A.ParallelMultiply(A).Values); }
public void QuickVariableInputViewModel_AddCommand_SplitTypeWithChars_SplitTokenSpace_CorrectResultsReturned() { var qviViewModel = new QuickVariableInputViewModel((source, overwrite) => { }) { Suffix = "", Prefix = "Customer().", VariableListString = "FName LName TelNo", SplitType = "Chars", SplitToken = " ", Overwrite = false }; Assert.IsTrue(qviViewModel.CanAdd); Assert.IsTrue(qviViewModel.AddCommand.CanExecute(null)); qviViewModel.AddCommand.Execute(null); var expected = new List<string> { "[[Customer().FName]]", "[[Customer().LName]]", "[[Customer().TelNo]]" }; var actual = qviViewModel.PreviewViewModel.Inputs.Select(input => input.Key).ToList(); CollectionAssert.AreEqual(expected, actual); }
public void Bound_NamedParameters() { var insertQuery = String.Format("INSERT INTO {0} (text_sample, int_sample, bigint_sample, id) VALUES (:my_text, :my_int, :my_bigint, :id)", AllTypesTableName); var preparedStatement = Session.Prepare(insertQuery); CollectionAssert.AreEqual(new [] { 3 }, preparedStatement.RoutingIndexes); Assert.AreEqual(preparedStatement.Metadata.Columns.Length, 4); Assert.AreEqual("my_text, my_int, my_bigint, id", String.Join(", ", preparedStatement.Metadata.Columns.Select(c => c.Name))); var id = Guid.NewGuid(); Session.Execute( preparedStatement.Bind( new { my_int = 100, my_bigint = -500L, id = id, my_text = "named params ftw!" })); var row = Session.Execute(String.Format("SELECT int_sample, bigint_sample, text_sample FROM {0} WHERE id = {1:D}", AllTypesTableName, id)).First(); Assert.AreEqual(100, row.GetValue <int>("int_sample")); Assert.AreEqual(-500L, row.GetValue <long>("bigint_sample")); Assert.AreEqual("named params ftw!", row.GetValue <string>("text_sample")); }
public void GetAll_ReturnsItems_ItemList() { //Arrange string description01 = "Walk the dog"; string description02 = "Wash the dishes"; Item newItem1 = new Item(description01); newItem1.Save(); Item newItem2 = new Item(description02); newItem2.Save(); List <Item> newList = new List <Item> { newItem1, newItem2 }; //Act List <Item> result = Item.GetAll(); //Assert CollectionAssert.AreEqual(newList, result); }
public void ShouldBuildUserEntity() { NameValueCollection collection = new NameValueCollection(); collection.Add("testuserid", "123"); collection.Add("username", "tparks"); collection.Add("birthday", "7-04-1933"); collection.Add("totalposts", null); collection.Add("posts", "This is my first post"); collection.Add("posts", "I really like toast"); TestUser instance = collection.Create <TestUser>(); Assert.AreEqual(123, instance.TestUserId, "The user ID was wrong."); Assert.AreEqual("tparks", instance.UserName, "The user name was wrong."); Assert.AreEqual(new DateTime(1933, 07, 04), instance.Birthday, "The birthday was wrong."); Assert.IsNull(instance.TotalPosts, "The total post should be null."); var expectedPosts = new string[] { "This is my first post", "I really like toast" }; CollectionAssert.AreEquivalent(expectedPosts, instance.Posts, "The posts were not set."); }
public void GetReachableHoles_HolesReachable_4() { var field = Field.Create(0, 0, 0, @" .......... .......... .......... XXXXXX..XX XXXXX...X. XXXXXX..XX XXXXXX..X. "); var act = MoveGenerator.GetReachableHoles(field, Block.T).Select(c => c.Path.ToString()).ToArray(); var exp = new string[] { "down,down,right,right,right,turnleft,down,down,left", "down,down,right,right,right,turnleft,down,down,left,turnleft", "down,down,right,right,right,turnleft,down,down,left,turnright" }; CollectionAssert.AreEqual(exp, act); }
public void SerializeDirtyExbin() { IEnumerable <string> maps = Directory.EnumerateFiles(pathToYsiExtract, "MapData*.exbin"); foreach (string map in maps) { NintendoLand.DataFormats.MapData mapData = NintendoLand.DataFormats.MapData.Load(map); List <byte> serializedData = new List <byte>(); mapData.SetItem(0, 0, TileTypes.Registrar.GetTypeByMemoryIdentifier('G')); mapData.SerializeExbin(ref serializedData, 16 + 4 + 18 + // header TileTypes.RotatingObjectHeader.BYTES_PER_CONTAINER + // rotating objects header (NintendoLand.DataFormats.MapData.ROWS_TOTAL * NintendoLand.DataFormats.MapData.COLUMNS_TOTAL * (1 + NintendoLand.DataFormats.MapData.CELL_TILE_PADDING)) // payload of actual cells ); // magic number is the max length of a default MapData.exbin-file CollectionAssert.AreNotEqual( File.ReadAllBytes(map), serializedData ); } }
public void Can_select_unary_plus_variable_expression() { // ReSharper disable ConvertToConstant.Local var intVal = +12; // ReSharper restore ConvertToConstant.Local var expected = new TestType() { IntColumn = 12, BoolColumn = true, StringColumn = "test" }; EstablishContext(10, expected); var actual = ConnectionString.OpenDbConnection().Select <TestType>(q => q.IntColumn == intVal); Assert.IsNotNull(actual); Assert.AreEqual(1, actual.Count); CollectionAssert.Contains(actual, expected); }
public void Test_OptimizeSkip_Recalculate_BoolEqualTrue() { //jmp will cause skip this equal optimize using var scriptBefore = new ScriptBuilder(); scriptBefore.Emit(VM.OpCode.JMP, new byte[2] { 0x04, 0x00 }); scriptBefore.Emit(VM.OpCode.PUSH1); scriptBefore.Emit(VM.OpCode.PUSH1); scriptBefore.Emit(VM.OpCode.EQUAL); scriptBefore.Emit(VM.OpCode.NOP); using var scriptAfter = new ScriptBuilder(); scriptAfter.Emit(VM.OpCode.PUSH1); scriptAfter.Emit(VM.OpCode.NOP); var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_USELESS_EQUAL); CollectionAssert.AreNotEqual(scriptAfter.ToArray(), optimized); CollectionAssert.AreEqual(scriptBefore.ToArray(), optimized); }
public void MyHandHasOnePossibleSameSuitMeld_GiveMeThatMeldAndTheDiscardMoves() { var cards = new[] { new Card(1, Suit.Diamonds), new Card(2, Suit.Diamonds), new Card(3, Suit.Diamonds), new Card(1, Suit.Spades) }; GameState gs = CreateGamesStateWithPlayerOneHaving(cards, State.Player1MeldLayDiscard); var pa = new PossibleMoves(Player.One, gs); var moves = pa.Moves(); Assert.AreEqual(5, moves.Count); CollectionAssert.Contains(moves, new MeldMove(Player.One, new Meld(Suit.Diamonds, 1, 3))); }
private void Test_Optimize_Recalculate_Positive_JMPX_L(VM.OpCode biGJumpOpCode) { var smallJumpOpCode = (VM.OpCode)(biGJumpOpCode - 1); using var scriptBefore = new ScriptBuilder(); scriptBefore.Emit(biGJumpOpCode, ToJumpLArg(7)); // ─┐ scriptBefore.Emit(VM.OpCode.NOP); // │ scriptBefore.Emit(VM.OpCode.NOP); // │ scriptBefore.Emit(VM.OpCode.RET); // <┘ var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_DEAD_CODE | OptimizeParserType.USE_SHORT_ADDRESS ); using var scriptAfter = new ScriptBuilder(); scriptAfter.Emit(smallJumpOpCode, ToJumpArg(2)); // ─┐ scriptAfter.Emit(VM.OpCode.RET); // <┘ CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized); }
public void SetColumnsWithZeroLength() { var columnValues = new ColumnValue[] { new StringColumnValue { Columnid = this.columnDict["Unicode"], Value = String.Empty }, new BytesColumnValue { Columnid = this.columnDict["Binary"], Value = new byte[0] }, }; using (var trx = new Transaction(this.session)) using (var update = new Update(this.session, this.tableid, JET_prep.Insert)) { Api.SetColumns(this.session, this.tableid, columnValues); update.Save(); trx.Commit(CommitTransactionGrbit.None); } Api.TryMoveFirst(this.session, this.tableid); Assert.AreEqual(String.Empty, Api.RetrieveColumnAsString(this.session, this.tableid, this.columnDict["Unicode"])); CollectionAssert.AreEqual(new byte[0], Api.RetrieveColumn(this.session, this.tableid, this.columnDict["Binary"])); }
public void Test_Optimize_JMP_LNext() { using var scriptBefore = new ScriptBuilder(); scriptBefore.Emit(VM.OpCode.JMP_L, ToJumpLArg(5)); // ───┐ scriptBefore.Emit(VM.OpCode.PUSH1); // <──┘ // useshortaddress before deleteuselessjmp var optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.USE_SHORT_ADDRESS | OptimizeParserType.DELETE_USELESS_JMP); using var scriptAfter = new ScriptBuilder(); scriptAfter.Emit(VM.OpCode.PUSH1); CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized); // deleteuselessjmp before useshortaddress optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_USELESS_JMP | OptimizeParserType.USE_SHORT_ADDRESS); CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized); // use deleteuselessjmp only optimized = NefOptimizeTool.Optimize(scriptBefore.ToArray(), Array.Empty <int>(), OptimizeParserType.DELETE_USELESS_JMP); CollectionAssert.AreEqual(scriptAfter.ToArray(), optimized); }
public void TestMaxEnd3() { //max end 3 is not static so i have to create an object to call it LoopsAndArrayExercises lAndAExer = new LoopsAndArrayExercises(); //test last one is bigger int [] result = lAndAExer.MaxEnd3(new int[] { 1, 2, 3 }); CollectionAssert.AreEqual(new int[] { 3, 3, 3 }, result); //test 1,10,3 or middle is biggest result = lAndAExer.MaxEnd3(new int[] { 1, 10, 3 }); CollectionAssert.AreEqual(new int[] { 3, 3, 3 }, result); //test first is biggest result = lAndAExer.MaxEnd3(new int[] { 201, 10, 3 }); CollectionAssert.AreEqual(new int[] { 201, 201, 201 }, result); //test all same neg result = lAndAExer.MaxEnd3(new int[] { -1, -1, -1 }); CollectionAssert.AreEqual(new int[] { -1, -1, -1 }, result); }
public void RemoveRange() { _list.AddRange(Enumerable.Range(1, 10)); _list.ClearChanges(); _list.RemoveRange(5, 3); //assert changes var changes = _list.CaptureChanges(); Assert.AreEqual(1, changes.Count); Assert.AreEqual(3, changes.Removes); CollectionAssert.AreEqual(Enumerable.Range(6, 3), changes.First().Range); //assert collection var shouldBe = Enumerable.Range(1, 5) .Union(Enumerable.Range(9, 2)); //assert collection CollectionAssert.AreEqual(shouldBe, _list); }
public void CreateTagArrayFromTags() { // Arrange IEnumerable <Tags> tags = new List <Tags> { new Tags { Tag = "iOS" }, new Tags { Tag = "AR" } }; // Act var result = TagArrayResolver.CreateTagArrayFromTags(tags); // Assert Assert.IsNotNull(result); Assert.IsInstanceOfType(result, typeof(string[])); CollectionAssert.AreEqual(new string[] { "iOS", "AR" }, result); }
public void RetrieveTest() { //Arrange var repository = new VendorRepository(); var expected = new List <Vendor>(); expected.Add(new Vendor() { VendorId = 1, CompanyName = "ABC Corp", Email = "*****@*****.**" }); expected.Add(new Vendor() { VendorId = 2, CompanyName = "XYZ Inc", Email = "*****@*****.**" }); //Act var actual = repository.Retrieve(); //Assert CollectionAssert.AreEqual(expected, actual.ToList()); }
public void GetFeatureNames_Features4Exc1Ratio1_ThrowException() { // arrange FeatureNumericalManager m = new FeatureNumericalManager(); m.Add(new FeatureNumerical("F1")); m.Add(new FeatureNumerical("F2")); m.Add(new FeatureNumerical("F3")); m.Add(new FeatureNumerical("F4")); string resolutionFeatureName = "F2"; // act List <string> names = m.GetFeatureNames(new List <string> { resolutionFeatureName }, 1); // assert Assert.IsNotNull(names); Assert.AreEqual(1, names.Count); CollectionAssert.DoesNotContain(names, resolutionFeatureName); }
private void ValidateChannelGroups(ChannelGroup[] channelGroups) { Assert.IsNotNull(channelGroups); Assert.IsNotEmpty(channelGroups); CollectionAssert.AllItemsAreUnique(channelGroups.Select(group => group.GroupName)); CollectionAssert.AllItemsAreUnique(channelGroups.Select(group => group.GroupId)); foreach (var group in channelGroups) { Assert.IsNotNull(group); Assert.IsNotEmpty(group.GroupName); Assert.IsNotEmpty(group.Channels); foreach (var channel in group.Channels) { Validator.ValidateChannel(channel); } } var channels = channelGroups.SelectMany(group => group.Channels).ToList(); Assert.IsTrue(channels.Any(channel => !string.IsNullOrEmpty(channel.Description))); Assert.IsTrue(channels.Any(channel => channel.SongCount > 0)); }