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