public void ChannelPropertyReply()
{
var raws = new[] {
":chat3 818 alfaproject #testing ONJOIN :Welcome to the stupidest channel ever.",
":chat3 818 alfaproject #testing GUID {}",
":chat3 818 alfaproject #testing CREATOR alfaproject[[email protected]]"
};
var channels = new[] {
"#testing",
"#testing",
"#testing"
};
var properties = new[] {
"ONJOIN",
"GUID",
"CREATOR"
};
var values = new[] {
"Welcome to the stupidest channel ever.",
"{}",
"alfaproject[[email protected]]"
};
for (var i = 0; i < raws.Length; i++)
{
var msg = MessageAssert.TypeAndRoundTrip<ChannelPropertyReplyMessage>(raws[i]);
Assert.AreEqual(channels[i], msg.Channel, "Channel");
Assert.AreEqual(properties[i], msg.Prop, "Property");
Assert.AreEqual(values[i], msg.Value, "New Value");
}
}
public void T_FromGame()
{
// ####
// 0I23456789
var colums = new[] { 0, 0, 0, 1, 1, 1, 1, 0, 0, 0 };
var pointUpPositions = PiceT.PositionsPointUp(colums);
var pointDownPositions = PiceT.PositionsPointDown(colums);
var pointLeftPositions = PiceT.PositionsPointLeft(colums);
var pointRightPositions = PiceT.PositionsPointRight(colums);
Assert.AreEqual(4, pointUpPositions.Count);
Assert.AreEqual(0, pointDownPositions.Count);
Assert.AreEqual(1, pointLeftPositions.Count);
Assert.AreEqual(1, pointRightPositions.Count);
foreach (var u in pointUpPositions)
Assert.AreEqual(0, u.Rotation);
foreach (var d in pointDownPositions)
Assert.AreEqual(2, d.Rotation);
foreach (var l in pointLeftPositions)
Assert.AreEqual(3, l.Rotation);
foreach (var r in pointRightPositions)
Assert.AreEqual(1, r.Rotation);
Assert.AreEqual(0, pointUpPositions[0].X);
}
public void TestValidSources()
{
// Arrange
string[] testValues = new[] { "http://bing.com", "http://microsoft.com", "https://paypal.com", "http://library" };
TestValues(testValues, true);
}
public void TvEpisodesWithSceneFileNameFormattingAreCorrectlyParsed()
{
//Arrange
var fileName = "The.Big.Bang.Theory.S04E03.The.Zazzy.Substitution.BluRay.1080p.Remux.AVC.DTS-HDMA.5.1-BluHD.mkv";
var expectedResults = new
{
FileName = "The.Big.Bang.Theory.S04E03.The.Zazzy.Substitution.BluRay.1080p.Remux.AVC.DTS-HDMA.5.1-BluHD.mkv",
ShowName = "The Big Bang Theory",
Extension = ".mkv",
Episode = "03",
EpisodeRange = "",
Season = "04"
};
//Act
var obj = new TvEpisode(fileName);
//Assert
Assert.AreEqual(expectedResults.FileName, obj.FileName);
Assert.AreEqual(expectedResults.ShowName, obj.Name);
Assert.AreEqual(expectedResults.Extension, obj.Extension);
Assert.AreEqual(expectedResults.Episode, obj.Episode);
Assert.AreEqual(expectedResults.EpisodeRange, obj.EpisodeRange);
Assert.AreEqual(expectedResults.Season, obj.Season);
}
public void TvEpisodesAlreadyInTargetFormattingAreCorrectlyParsed()
{
//Arrange
var fileName = "Doctor Who - S09E16.mkv";
var expectedResults = new
{
FileName = "Doctor Who - S09E16.mkv",
ShowName = "Doctor Who",
Extension = ".mkv",
Episode = "16",
EpisodeRange = "",
Season = "09"
};
//Act
var obj = new TvEpisode(fileName);
//Assert
Assert.AreEqual(expectedResults.FileName, obj.FileName);
Assert.AreEqual(expectedResults.ShowName, obj.Name);
Assert.AreEqual(expectedResults.Extension, obj.Extension);
Assert.AreEqual(expectedResults.Episode, obj.Episode);
Assert.AreEqual(expectedResults.EpisodeRange, obj.EpisodeRange);
Assert.AreEqual(expectedResults.Season, obj.Season);
}
public void CatchEnumerable()
{
{
var xs = new[]
{
Observable.Return(2).Concat(Observable.Throw<int>(new Exception())),
Observable.Return(99).Concat(Observable.Throw<int>(new Exception())),
Observable.Range(10,2)
}
.Catch()
.Materialize()
.ToArrayWait();
xs[0].Value.Is(2);
xs[1].Value.Is(99);
xs[2].Value.Is(10);
xs[3].Value.Is(11);
xs[4].Kind.Is(NotificationKind.OnCompleted);
}
{
var xs = new[]
{
Observable.Return(2).Concat(Observable.Throw<int>(new Exception())),
Observable.Return(99).Concat(Observable.Throw<int>(new Exception()))
}
.Catch()
.Materialize()
.ToArrayWait();
xs[0].Value.Is(2);
xs[1].Value.Is(99);
xs[2].Kind.Is(NotificationKind.OnError);
}
}
public void GetBlockingMoveTestMethod()
{
var boards = new[] { new[] { -1, -1, 0, 0, 1, 1, 0, 0, 0 }, //
new[] { 0, 0, 1, -1, 1, 0, 0, 0, 0 } };
var positions = new[]
{
new[] { 2, 0 }, //
new[] { 0, 2 }, //
};
for (var i = 0; i < boards.Length; i++)
{
var board = boards[i];
var g = new CurrentGame(new Board(board));
var brainResult = new BrainResult();
var canMove = g.GetNewMove(brainResult);
try
{
Assert.AreEqual(positions[i][0], brainResult.Moves[0].X);
Assert.AreEqual(positions[i][1], brainResult.Moves[0].Y);
Assert.AreEqual(true, canMove);
}
catch
{
UnitTestHelpers.PrintBoard(board, brainResult.Moves[0].X, brainResult.Moves[0].Y, canMove);
throw;
}
}
}
public void SM_WithStringPropsAndSamePossibleStrings_ShouldBe_Satisfiable()
{
// Arrange
var objectTheorem = new ObjectTheoremContext();
var stringNames = new[] { "Hans", "Fred", "Max" };
objectTheorem.SetPossibleStringValues(stringNames);
var classWithStringA = objectTheorem.CreateInstance<ClassWithStringA>("ClassWithStringA");
var classWithStringB = objectTheorem.CreateInstance<ClassWithStringB>("ClassWithStringB");
// Act
objectTheorem.ConstraintBuilder
.AssertAll<ClassWithStringA, ClassWithStringB>((a, b) => a.FirstName == b.LastName)
.Assert(() => "Hans" == classWithStringA.FirstName);
// Assert
var solved = objectTheorem.Solve();
Assert.IsNotNull(solved);
string firstName = solved.GetValue(classWithStringA, i => i.FirstName);
string lastName = solved.GetValue(classWithStringB, i => i.LastName);
Assert.AreEqual("Hans", firstName);
Assert.AreEqual("Hans", lastName);
}
public void Watch602Test()
{
var raws = new[] {
":hotspeed.sg.as.dal.net 602 _aLfa_ alfa * * 0 :stopped watching",
":hotspeed.sg.as.dal.net 602 _aLfa_ _aLfa_ _aLfa_ c-24-8-243-76.client.comcast.net 1082383544 :stopped watching",
":hotspeed.sg.as.dal.net 602 _aLfa_ _aLfa_ _aLfa_ c-24-8-243-76.client.comcast.net 1082383572 :stopped watching"
};
var msg = MessageAssert.TypeAndRoundTrip<WatchStoppedMessage>(raws[0]);
Assert.AreEqual(msg.WatchedUser.Nickname, "alfa");
Assert.AreEqual(msg.WatchedUser.Username, "*");
Assert.AreEqual(msg.WatchedUser.Host, "*");
Assert.AreEqual(MessageUtil.ConvertToUnixTime(msg.TimeOfChange), 0);
msg = MessageAssert.TypeAndRoundTrip<WatchStoppedMessage>(raws[1]);
Assert.AreEqual(msg.WatchedUser.Nickname, "_aLfa_");
Assert.AreEqual(msg.WatchedUser.Username, "_aLfa_");
Assert.AreEqual(msg.WatchedUser.Host, "c-24-8-243-76.client.comcast.net");
Assert.AreEqual(MessageUtil.ConvertToUnixTime(msg.TimeOfChange), 1082383544);
msg = MessageAssert.TypeAndRoundTrip<WatchStoppedMessage>(raws[2]);
Assert.AreEqual(msg.WatchedUser.Nickname, "_aLfa_");
Assert.AreEqual(msg.WatchedUser.Username, "_aLfa_");
Assert.AreEqual(msg.WatchedUser.Host, "c-24-8-243-76.client.comcast.net");
Assert.AreEqual(MessageUtil.ConvertToUnixTime(msg.TimeOfChange), 1082383572);
}
public void CreateFromConfigTest()
{
var testData = new[]
{
new { Type = "ByteOutput", Reg = 0},
new { Type = "WordOutput", Reg = 1},
new { Type = "ByteOutput", Reg = 2},
new { Type = "FloatOutput", Reg = 4},
new { Type = "DWordOutput", Reg = 6}
};
var entries = testData
.Select((a, i) => new ConfigEntry()
{
Name = "regVarAt" + a.Reg, TypeName = a.Type
})
.ToArray();
var outs = AbstractOutput.CreateFromConfig(entries, n => { }).ToArray();
Assert.AreEqual(entries.Length, outs.Length);
for (int i = 0; i < testData.Length; i++)
{
Assert.AreEqual(outs[i].RegOffset, testData[i].Reg);
}
}
public void FilePathMatcherTest()
{
string[] testFiles = new [] {"c:/temp/subfolder/file.js",
"c:/temp/file.cs",
"c:/projects/temp/file.cs",
"c:/projects/file.js",
"c:/projects/file.min.js"};
List<string> matches = new List<string>(FilePathMatcher.MatchFiles("*.js",testFiles,false));
List<string> expected = new List<string>(new[] {"c:/temp/subfolder/file.js", "c:/projects/file.js",
"c:/projects/file.min.js"});
Assert.AreEqual(3,matches.Count,"Matches single extension pattern *.js");
Assert.AreEqual(string.Join(",", expected),string.Join(",",matches),"List matches");
matches = new List<string>(FilePathMatcher.MatchFiles("*.min.js",testFiles,true));
Assert.AreEqual(4,matches.Count,"Matches exclusion pattern *.min.js");
matches = new List<string>(FilePathMatcher.MatchFiles("temp/",testFiles,true));
expected = new List<string>(new[] {"c:/projects/file.js",
"c:/projects/file.min.js"});
Assert.AreEqual(string.Join(",",expected),string.Join(",",matches),"List matches on excluding a folder path");
}
public void SortByGivenOrderTest()
{
var id1 = Guid.NewGuid();
var id2 = Guid.NewGuid();
var id3 = Guid.NewGuid();
var id4 = Guid.NewGuid();
var expectedOrder = new Guid?[] { id1, id2, id3, id4 };
var items = new[]
{
new SomeEntity { Name = "a", Reference = id3 },
new SomeEntity { Name = "b", Reference = id2 },
new SomeEntity { Name = "c", Reference = id1 },
new SomeEntity { Name = "d", Reference = id2 },
new SomeEntity { Name = "e", Reference = id4 }
};
Graph.SortByGivenOrder(items, expectedOrder, item => item.Reference);
string result = string.Join(", ", items.Select(item => item.Name));
const string expectedResult1 = "c, b, d, a, e";
const string expectedResult2 = "c, d, b, a, e";
Console.WriteLine("result: " + result);
Console.WriteLine("expectedResult1: " + expectedResult1);
Console.WriteLine("expectedResult2: " + expectedResult2);
Assert.IsTrue(result == expectedResult1 || result == expectedResult2, "Result '" + result + "' is not '" + expectedResult1 + "' nor '" + expectedResult2 + "'.");
}
public void TestMobileListConvert()
{
string expect = "1,2,3";
var mobiles = new[] { "1", "2", "3" };
var result = string.Join(",", mobiles);
Assert.AreEqual(expect, result);
}
public void I_DeepHole()
{
// ##### # ##
// ##### ####
// ##########
// 0I23456789
var colums = new[] { 3, 3, 3, 3, 3, 1, 3, 2, 3, 3 };
var deepHolePositions = PiceI.PositionsDeepHole(colums);
var oneLevelPositions = PiceI.PositionsOneLevelStep(colums);
var flatPositions = PiceI.PositionsFlat(colums);
Assert.AreEqual(1, deepHolePositions.Count);
Assert.AreEqual(2, oneLevelPositions.Count);
Assert.AreEqual(2, flatPositions.Count);
foreach (var d in deepHolePositions)
Assert.AreEqual(1, d.Rotation);
foreach (var o in oneLevelPositions)
Assert.AreEqual(1, o.Rotation);
foreach (var f in flatPositions)
Assert.AreEqual(0, f.Rotation);
Assert.AreEqual(5, deepHolePositions[0].X);
}
public void EsfTokenNameToByte_SuccessfullyConvertsTokenNames()
{
var tokens = new
{
UINT16 = new { Value = 0x01, Name = "uint16" },
INT16 = new { Value = 0x02, Name = "int16" },
UINT32 = new { Value = 0x03, Name = "uint32" },
INT32 = new { Value = 0x04, Name = "int32" },
STRING = new { Value = 0x05, Name = "string" },
IPADDR = new { Value = 0x06, Name = "ip_addr" },
INT64 = new { Value = 0x07, Name = "int64" },
UINT64 = new { Value = 0x08, Name = "uint64" },
BOOLEAN = new { Value = 0x09, Name = "boolean" }
};
Assert.AreEqual(tokens.UINT16.Value, EsfParser.TokenNameToByte(tokens.UINT16.Name));
Assert.AreEqual(tokens.INT16.Value, EsfParser.TokenNameToByte(tokens.INT16.Name));
Assert.AreEqual(tokens.UINT32.Value, EsfParser.TokenNameToByte(tokens.UINT32.Name));
Assert.AreEqual(tokens.INT32.Value, EsfParser.TokenNameToByte(tokens.INT32.Name));
Assert.AreEqual(tokens.STRING.Value, EsfParser.TokenNameToByte(tokens.STRING.Name));
Assert.AreEqual(tokens.IPADDR.Value, EsfParser.TokenNameToByte(tokens.IPADDR.Name));
Assert.AreEqual(tokens.INT64.Value, EsfParser.TokenNameToByte(tokens.INT64.Name));
Assert.AreEqual(tokens.UINT64.Value, EsfParser.TokenNameToByte(tokens.UINT64.Name));
Assert.AreEqual(tokens.BOOLEAN.Value, EsfParser.TokenNameToByte(tokens.BOOLEAN.Name));
}
public void Point_Set_X_int()
{
var inputValues = new[]
{
0,
-1,
-2147483648,
2147483647
};
foreach (int xElement in inputValues)
{
try
{
var point = new Point(xElement, 1);
var actual = point.X;
Assert.AreEqual(xElement, actual);
}
catch (PointException exceptionPoint)
{
Assert.AreEqual("Задать X координату можно от 0 до 2147483647", exceptionPoint.Message);
}
}
}
public void ToSQL_003()
{
var data = new
{
ID = 1,
FirstName = "Chris",
LastName = "Pietschmann",
Age = 0
};
var target = data.ToSQLinqUpdate("Person");
var actual = (SQLinqUpdateResult)target.ToSQL();
Assert.AreEqual("[Person]", actual.Table);
Assert.AreEqual(4, actual.Fields.Count);
Assert.AreEqual("@sqlinq_1", actual.Fields["ID"]);
Assert.AreEqual("@sqlinq_2", actual.Fields["FirstName"]);
Assert.AreEqual("@sqlinq_3", actual.Fields["LastName"]);
Assert.AreEqual("@sqlinq_4", actual.Fields["Age"]);
Assert.AreEqual(4, actual.Parameters.Count);
Assert.AreEqual(1, actual.Parameters["@sqlinq_1"]);
Assert.AreEqual("Chris", actual.Parameters["@sqlinq_2"]);
Assert.AreEqual("Pietschmann", actual.Parameters["@sqlinq_3"]);
Assert.AreEqual(0, actual.Parameters["@sqlinq_4"]);
}
public void StackTest()
{
var items = new[] { new object(), new object(), new object(), new object() };
var stack = new PlayedItemsStack<object>(3);
Assert.AreEqual(0, stack.Count);
stack.Add(items[0]);
Assert.AreEqual(items[0], stack.Pop());
Assert.AreEqual(0, stack.Count);
stack.Add(items[0]);
stack.Add(items[1]);
stack.Add(items[2]);
Assert.AreEqual(3, stack.Count);
Assert.IsTrue(stack.Contains(items[0]));
Assert.IsFalse(stack.Contains(items[3]));
stack.Add(items[3]);
Assert.AreEqual(3, stack.Count);
Assert.IsFalse(stack.Contains(items[0]));
Assert.IsTrue(stack.Contains(items[3]));
Assert.AreEqual(items[3], stack.Pop());
Assert.AreEqual(2, stack.Count);
stack.Add(items[2]);
Assert.AreEqual(3, stack.Count);
stack.RemoveAll(items[2]);
Assert.AreEqual(1, stack.Count);
stack.Clear();
Assert.AreEqual(0, stack.Count);
}
public void ServiceContainer_Should_Have_DefaultServices()
{
var serviceContainer = ServiceContainer.Instance;
Assert.IsNotNull(serviceContainer);
var serviceTypes = new[]
{
typeof(TraceServiceBase),
typeof(ModelTreeTraverseServiceBase),
typeof(ModelWeighServiceBase),
typeof(DefaultJSONSerializationService),
typeof(DefaultXMLSerializationService),
typeof(WebPartChromeTypesConvertService),
typeof(ListViewScopeTypesConvertService),
typeof(DefinitionRelationshipServiceBase),
typeof(ModelCompatibilityServiceBase),
typeof(DefaultDiagnosticInfoService),
typeof(ModelPrettyPrintServiceBase),
typeof(ModelDotGraphPrintServiceBase)
};
foreach (var serviceType in serviceTypes)
{
Assert.IsNotNull(serviceContainer.GetService<TraceServiceBase>(), serviceType.Name);
}
}
public void FT_TextFragmentsTest()
{
PpOperations.SelectSlide(3);
var fragments = new[]
{
new[] {17, 37},
new[] {45, 114},
new[] {122, 140},
new[] {148, 166},
new[] {174, 192},
new[] {200, 218},
new[] {226, 234},
new[] {242, 257},
new[] {268, 286},
new[] {305, 313},
new[] {370, 388},
};
foreach (var fragment in fragments)
{
PpOperations.SelectTextInShape(ShapeName, fragment[0], fragment[1]);
PplFeatures.HighlightFragments();
}
AssertIsSame(3, 4);
}
public void CustomProps_GetFromMultipleShapes()
{
var page1 = this.GetNewPage();
var s1 = page1.DrawRectangle(0, 0, 2, 2);
var s2 = page1.DrawRectangle(0, 0, 2, 2);
var s3 = page1.DrawRectangle(0, 0, 2, 2);
var s4 = page1.DrawRectangle(0, 0, 2, 2);
VACUSTPROP.CustomPropertyHelper.Set(s1, "FOO1", "1");
VACUSTPROP.CustomPropertyHelper.Set(s2, "FOO2", "2");
VACUSTPROP.CustomPropertyHelper.Set(s2, "FOO3", "3");
VACUSTPROP.CustomPropertyHelper.Set(s4, "FOO4", "4");
VACUSTPROP.CustomPropertyHelper.Set(s4, "FOO5", "5");
VACUSTPROP.CustomPropertyHelper.Set(s4, "FOO6", "6");
var shapes = new[] {s1, s2, s3, s4};
var allprops = VACUSTPROP.CustomPropertyHelper.Get(page1, shapes);
Assert.AreEqual(4, allprops.Count);
Assert.AreEqual(1, allprops[0].Count);
Assert.AreEqual(2, allprops[1].Count);
Assert.AreEqual(0, allprops[2].Count);
Assert.AreEqual(3, allprops[3].Count);
Assert.AreEqual("\"1\"", allprops[0]["FOO1"].Value.Formula);
Assert.AreEqual("\"2\"", allprops[1]["FOO2"].Value.Formula);
Assert.AreEqual("\"3\"", allprops[1]["FOO3"].Value.Formula);
Assert.AreEqual("\"4\"", allprops[3]["FOO4"].Value.Formula);
Assert.AreEqual("\"5\"", allprops[3]["FOO5"].Value.Formula);
Assert.AreEqual("\"6\"", allprops[3]["FOO6"].Value.Formula);
page1.Delete(0);
}
public void J_FlatRightConner()
{
// # # #
// ###### ###
// ##########
// 0I23456789
var colums = new[] { 3, 2, 3, 2, 3, 2, 1, 2, 2, 2 };
var deepHolePositions = PiceJ.PositionsDeepHole(colums);
var flatHolePositions = PiceJ.PositionsFlatHole(colums);
var flatPositions = PiceJ.PositionsFlat(colums);
var notFlatPositions = PiceJ.PositionsNotFlat(colums);
Assert.AreEqual(0, deepHolePositions.Count);
Assert.AreEqual(0, flatHolePositions.Count);
Assert.AreEqual(1, flatPositions.Count);
Assert.AreEqual(2, notFlatPositions.Count);
foreach (var d in deepHolePositions)
Assert.AreEqual(1, d.Rotation);
foreach (var f in flatHolePositions)
Assert.AreEqual(2, f.Rotation);
foreach (var f in flatPositions)
Assert.AreEqual(0, f.Rotation);
foreach (var n in notFlatPositions)
Assert.AreEqual(3, n.Rotation);
Assert.AreEqual(7, flatPositions[0].X);
}
public void TvEpisodesWithAnXSeasonEpisodeSeparatorAreCorrectlyParsed()
{
//Arrange
var fileName = "doctor_who_2005.8x08.mummy_on_the_orient_express.720p_hdtv_x264-fov.mkv";
var expectedResults = new
{
FileName = "doctor_who_2005.8x08.mummy_on_the_orient_express.720p_hdtv_x264-fov.mkv",
ShowName = "Doctor Who 2005",
Extension = ".mkv",
Episode = "08",
EpisodeRange = "",
Season = "08"
};
//Act
var obj = new TvEpisode(fileName);
//Assert
Assert.AreEqual(expectedResults.FileName, obj.FileName);
Assert.AreEqual(expectedResults.ShowName, obj.Name);
Assert.AreEqual(expectedResults.Extension, obj.Extension);
Assert.AreEqual(expectedResults.Episode, obj.Episode);
Assert.AreEqual(expectedResults.EpisodeRange, obj.EpisodeRange);
Assert.AreEqual(expectedResults.Season, obj.Season);
}
public void VisioPS_Get_Visio_Page_Cell()
{
var cells = new[] { "PageWidth", "PageHeight" };
var result_type = "Double";
var get_results = true;
// Handle the page that gets created when a document is created
var doc = VisioPowerShellTests.visiops_session.New_Visio_Document();
var datatable1 = VisioPowerShellTests.visiops_session.Get_Visio_Page_Cell(cells, get_results, result_type);
Assert.IsNotNull(datatable1);
Assert.AreEqual(8.5, datatable1.Rows[0]["PageWidth"]);
Assert.AreEqual(11.0, datatable1.Rows[0]["PageHeight"]);
//Now lets add another page and get it's width and height
var page2 = VisioPowerShellTests.visiops_session.New_Visio_Page();
var datatable2 = VisioPowerShellTests.visiops_session.Get_Visio_Page_Cell(cells, get_results, result_type);
Assert.IsNotNull(datatable2);
Assert.AreEqual(8.5, datatable2.Rows[0]["PageWidth"]);
Assert.AreEqual(11.0, datatable2.Rows[0]["PageHeight"]);
VisioPowerShellTests.Close_Visio_Application();
}
public void T_FlatBetterThenUpsideDown()
{
// # # # #
// ##########
// ##########
// 0I23456789
var colums = new[] { 3, 2, 2, 2, 3, 2, 3, 2, 3, 2 };
var pointUpPositions = PiceT.PositionsPointUp(colums);
var pointDownPositions = PiceT.PositionsPointDown(colums);
var pointLeftPositions = PiceT.PositionsPointLeft(colums);
var pointRightPositions = PiceT.PositionsPointRight(colums);
Assert.AreEqual(1, pointUpPositions.Count);
Assert.AreEqual(2, pointDownPositions.Count);
Assert.AreEqual(4, pointLeftPositions.Count);
Assert.AreEqual(3, pointRightPositions.Count);
foreach (var u in pointUpPositions)
Assert.AreEqual(0, u.Rotation);
foreach (var d in pointDownPositions)
Assert.AreEqual(2, d.Rotation);
foreach (var l in pointLeftPositions)
Assert.AreEqual(3, l.Rotation);
foreach (var r in pointRightPositions)
Assert.AreEqual(1, r.Rotation);
Assert.AreEqual(1, pointUpPositions[0].X);
}
public void NotReadonlyNonGeneric()
{
var e1 = Emit.NewDynamicMethod(typeof(void), new[] { typeof(int[]), typeof(int) }, "E1");
e1.LoadArgument(0);
e1.LoadArgument(1);
e1.LoadElementAddress<int>();
e1.Duplicate();
e1.LoadIndirect<int>();
e1.LoadConstant(1);
e1.Add();
e1.StoreIndirect<int>();
e1.Return();
string instrs;
var d1 = e1.CreateDelegate<Action<int[], int>>(out instrs);
var x = new[] { 1, 2, 3 };
d1(x, 1);
Assert.AreEqual(1, x[0]);
Assert.AreEqual(3, x[1]);
Assert.AreEqual(3, x[2]);
Assert.IsFalse(instrs.Contains("readonly."));
}
public void TestInvalidSources()
{
// Arrange
string[] testValues = new[] { null, "", "link", "c:\\dir", "\\username\folder", "127.0.0.1", "localhost", "crash;\\_andBurn", "ftp://bing.com", "gopher://kill.it", "http://" };
TestValues(testValues, false);
}
public void MultiLineStringSerialization()
{
var coordinates = new[]
{
new List<IPosition>
{
new GeographicPosition(52.370725881211314, 4.889259338378906),
new GeographicPosition(52.3711451105601, 4.895267486572266),
new GeographicPosition(52.36931095278263, 4.892091751098633),
new GeographicPosition(52.370725881211314, 4.889259338378906)
},
new List<IPosition>
{
new GeographicPosition(52.370725881211314, 4.989259338378906),
new GeographicPosition(52.3711451105601, 4.995267486572266),
new GeographicPosition(52.36931095278263, 4.992091751098633),
new GeographicPosition(52.370725881211314, 4.989259338378906)
},
};
var model = new MultiLineString(coordinates.Select(ca => new LineString(ca)).ToList());
var serializedData = JsonConvert.SerializeObject(model, DefaultJsonSerializerSettings);
var matches = Regex.Matches(serializedData, @"(?<coordinates>[0-9]+([.,][0-9]+))");
double lng;
double.TryParse(matches[0].Value, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out lng);
//Double precision can pose a problem
Assert.IsTrue(Math.Abs(lng - 4.889259338378906) < 0.0000001);
Assert.IsTrue(!serializedData.Contains("latitude"));
}
public void CollectionAsserts()
{
var somePersons = new Person[] { new Person(), new VipPerson() };
// Some trivial collection asserts
CollectionAssert.AllItemsAreNotNull(somePersons);
CollectionAssert.Contains(somePersons, somePersons[0]);
// Some more interesting checks
CollectionAssert.AllItemsAreInstancesOfType(somePersons, typeof(Person));
CollectionAssert.AllItemsAreUnique(somePersons);
// CollectionAssert.AllItemsAreUnique(new [] { "A", "A" }); --> this would fail.
var someStrings = new[] { "AB", "CD" };
var someOtherStrings = new[] { $"{"A"}B", "CD" };
var evenMoreStrings = new[] { "CD", $"{"A"}B" };
CollectionAssert.AreEqual(someStrings, someOtherStrings);
// CollectionAssert.AreEqual(someStrings, evenMoreStrings); -> this would fail
// Note that AreEquivalent ignores order, so this works:
CollectionAssert.AreEquivalent(someStrings, evenMoreStrings);
CollectionAssert.IsSubsetOf(new[] { "AB" }, someStrings);
}
public void ChannelProperty()
{
var raws = new[] {
"PROP #testing ONJOIN :Welcome to the stupidest channel ever.",
"PROP #testing ONJOIN",
"PROP #testing *"
};
var channels = new[] {
"#testing",
"#testing",
"#testing"
};
var properties = new[] {
"ONJOIN",
"ONJOIN",
""
};
var values = new[] {
"Welcome to the stupidest channel ever.",
"",
""
};
for (var i = 0; i < raws.Length; i++)
{
var msg = MessageAssert.TypeAndRoundTrip<ChannelPropertyMessage>(raws[i]);
Assert.AreEqual(channels[i], msg.Channel, "Channel");
Assert.AreEqual(properties[i], msg.Prop, "Property");
Assert.AreEqual(values[i], msg.NewValue, "New Value");
}
}
