public void Detect_multiple_anagrams()
{
var detector = new Anagram("master");
var words = new[] { "stream", "pigeon", "maters" };
var results = new[] { "maters", "stream" };
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void ItOnlyReturnsTriggeredBundles()
{
var collection = new TriggerCollection();
var bundles = new[]
{
new TriggerBundle(TriggerTestHelpers.StaticTrigger(true)),
new TriggerBundle(TriggerTestHelpers.StaticTrigger(false)),
new TriggerBundle(TriggerTestHelpers.StaticTrigger(true)),
new TriggerBundle(TriggerTestHelpers.StaticTrigger(false)),
new TriggerBundle(TriggerTestHelpers.StaticTrigger(false))
};
var expected = new[]
{
bundles[0],
bundles[2],
};
foreach(var bundle in bundles)
{
collection.Add(bundle);
}
var actual = collection.Check();
CollectionAssert.AreEqual(expected, actual);
}
public void ShouldInsertPeoples()
{
// Given
var db = new DataBaseMicrosoft(DataBasesTypes.MicrosoftAccess, TestHelper.CreateTempFile());
var peoples = new[]
{
new People("Акакий", "Программист"),
new People("Генка", "Плотник")
};
var expected = new[]
{
new People("Иванов Иван", "Плотник"),
new People("Князь Владимир", "Программист"),
new People("Петров Петр", "Плотник"),
new People("Клинт Бартон", "Программист"),
new People("Акакий", "Программист"),
new People("Генка", "Плотник")
};
// When
foreach (var people in peoples)
{
db.ExecuteCommand(Parameters.Insert, people);
}
var actual = db.GetElements<People>();
TestHelper.DeleteTemp();
// Then
Assert.AreEqual(expected.Length, actual.Length);
Assert.IsInstanceOf<People>(actual[0]);
CollectionAssert.AreEqual(expected, actual);
}
public void Should_Return_False_For_PropertyInfo_Objects_With_Different_Names()
{
var type = new { Prop1 = 10, Prop2 = 20 }.GetType();
var propData1 = new PropertyData(type.GetProperties()[0]);
var propData2 = new PropertyData(type.GetProperties()[1]);
Assert.IsFalse(propData1.Equals(propData2));
}
public void Can_campaignTemplateContent()
{
var args = new { cid = "9349a04e77" };
var templateContentResponse = tree.Do(x => x.Campaign.campaignTemplateContent(args));
Assert.True(templateContentResponse.Success);
}
public void MergeSortTestWithNegativeNumbers()
{
var input = new[] { 2, 3, 1, -7, 4, 9 };
var expected = new[] { -7, 1, 2, 3, 4, 9 };
SortingProblems.MergeSort(input);
CollectionAssert.AreEqual(expected, input);
}
public void Cmasp_Do()
{
var addr = Address.SegPtr(0x0C20, 0);
var proc = new Procedure("foo", null);
var progaddr = new ProgramAddress(program, addr);
var dc = mr.Stub<IDecompiler>();
var dcSvc = mr.Stub<IDecompilerService>();
var brSvc = mr.Stub<IProjectBrowserService>();
dcSvc.Decompiler = dc;
sc.AddService<IDecompilerService>(dcSvc);
sc.AddService<IProjectBrowserService>(brSvc);
sc.AddService<IDecompilerShellUiService>(new FakeShellUiService());
dc.Expect(d => d.ScanProcedure(progaddr)).IgnoreArguments().Return(proc);
brSvc.Expect(b => b.Reload());
mr.ReplayAll();
var locations = new[] { new ProgramAddress(program, addr) };
var cmd = new Cmd_MarkProcedures(sc, locations);
cmd.DoIt();
mr.VerifyAll();
Assert.AreEqual(1, program.User.Procedures.Count);
var uproc = program.User.Procedures.Values[0];
Assert.AreEqual("0C20:0000", uproc.Address);
}
public void Anagrams_are_case_insensitive()
{
var detector = new Anagram("Orchestra");
var words = new[] { "cashregister", "Carthorse", "radishes" };
var results = new[] { "Carthorse" };
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void No_matches()
{
var detector = new Anagram("diaper");
var words = new[] { "hello", "world", "zombies", "pants" };
var results = new string[0];
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void Eliminate_anagram_subsets()
{
var detector = new Anagram("good");
var words = new[] { "dog", "goody" };
var results = new string[0];
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void Identical_word_is_not_anagram()
{
var detector = new Anagram("corn");
var words = new[] { "corn", "dark", "Corn", "rank", "CORN", "cron", "park" };
var results = new[] { "cron" };
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void Eliminate_anagrams_with_same_checksum()
{
var detector = new Anagram("mass");
var words = new[] { "last" };
var results = new string[0];
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void Does_not_confuse_different_duplicates()
{
var detector = new Anagram("galea");
var words = new[] { "eagle" };
var results = new string[0];
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void Detect_simple_anagram()
{
var detector = new Anagram("ant");
var words = new[] { "tan", "stand", "at" };
var results = new[] { "tan" };
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
public void InsertionSortTestWithNegativeNumbers()
{
var input = new[] { 2, 3, 1, -7, 4, 9 };
var expected = new[] { -7, 1, 2, 3, 4, 9 };
int[] actual = SortingProblems.InsertionSort(input);
CollectionAssert.AreEqual(expected, actual);
}
public void Can_describe_a_field_reference()
{
var Foo = new {Bar = 6};
string description = SpecDescriber.DescribeSpec(() => Foo.Bar == 42);
description.ShouldBe("Foo.Bar should equal 42");
}
public void MergeSortTestHappyFlow2()
{
var input = new[] { 2, 5, 3 };
var expected = new[] { 2, 3, 5 };
SortingProblems.MergeSort(input);
CollectionAssert.AreEqual(expected, input);
}
public void StartAndEndOfStringOrLine()
{
string input = "One thing or another\nAnd then some";
string[] patterns = new[] {
@"^\w+",
@"\w+$",
@"^\w+|\w+$",
@"\w+$|^\w+",
@"\w*^\w*",
@"\w*$\w*",
@"\w+$\w*",
@"\A\w+",
@"\w+\Z",
@"\w+\z",
@"\A\w+|\w+\Z",
};
RegexAssert.AreMatchesSameAsMsoft(input, patterns, AlgorithmType);
RegexAssert.AreMatchesSameAsMsoft(input, patterns, AlgorithmType, RegexOptions.Multiline);
}
public void QuickSortPositiveTest()
{
var input = new[] { 2, 5, 3, 1 };
var expected = new[] { 1, 2, 3, 5 };
SortingProblems.QuickSort(input);
CollectionAssert.AreEqual(expected, input);
}
public void Language_DoesProduceCorrectTokens()
{
string test = null;
Func<Grammar.Token[]> testit = () =>
new Grammar.Lexer(new StringReader(test)).ToArray();
test = "using namespace @namespace;";
var expected = new[] { Using, Namespace, Identifier, Semicolon, Eof };
var result = testit();
var resultTerminals = result.Select(r => r.Terminal).ToArray();
Assert.That(resultTerminals, Is.EquivalentTo(expected));
Assert.That(result[2], Is.AssignableFrom<IdentifierToken>());
Assert.That((result[2] as IdentifierToken).Name, Is.EqualTo("namespace"));
Assert.That(result[2].Lexeme, Is.EqualTo("@namespace"));
Assert.That(result.AsLexemes(), Is.EquivalentTo(new[] { "using", "namespace", "@namespace", ";", null }));
test = "34.3f";
result = testit();
Assert.That(result[0], Is.TypeOf<NumberToken>());
var number = result[0] as NumberToken;
Assert.That(number.GetFloatValue(), Is.EqualTo(34.3f));
Assert.That(number.IsTypeSpecified, Is.True);
Assert.That(number.TypeSuffix, Is.EqualTo('f'));
}
public void TheConvertedDictionaryHasCaseInsensitiveKeys()
{
var testObject = new {Key1 = "value1", Key2 = "value2"}.ToCaseInvariantDictionary();
testObject["key1"].ShouldBe("value1");
testObject["Key1"].ShouldBe("value1");
}
public void CanInvokeFileAction()
{
// Arrange
Resource project = GetSharedProject();
var args = new
{
Title = "New issue",
Description = "Blah ...",
Severity = 5,
Attachment = new { Title = "Att", Description = "Blah blah" }
};
var attachment = new StringFile { ContentType = "text/plain", Filename = "test.txt", Data = "1234" };
var files = new { attachment = attachment };
using (var resp = project.Controls[MasonTestConstants.Rels.IssueAdd].Upload<Resource>(Session, args, files))
{
dynamic result = resp.Created();
Assert.AreEqual("New issue", result.Title);
Assert.AreEqual(5, result.Severity);
Assert.IsNotNull(result.Attachments);
Assert.AreEqual(1, result.Attachments.Count);
}
}
public void AddEmptyTree_Exception_Test()
{
dynamic obj1 = new { Name = "test" };
var tree = new Tree<dynamic>(obj1);
tree.Root.AddChild(null);
}
public void SiftDown()
{
int[] data = new[] {1, 2, 3, 4, 5, 6 };
SiftDown(data, 3, 5);
ShowArray(data);
}
public async Task Icon ()
{
var size = new Size (64);
var canvas = Platforms.Current.CreateImageCanvas (size, scale: 2);
canvas.SaveState ();
canvas.Scale (size);
canvas.Translate (1 / 8.0, 0);
var p = new Path ();
p.MoveTo (0, 1,false);
p.LineTo (0, 0, false);
p.LineTo (0.5, 1, false);
p.LineTo (0.5, 0,false);
var colors = new [] {
"#DCDCDD",
"#C5C3C6",
"#46494C",
"#4C5C68",
"#68A5E2",
};
foreach (var c in colors) {
p.Pen = new Pen (c, 1 / 4.0);
p.Draw (canvas);
canvas.Translate (1 / 16.0, 0);
}
await SaveImage (canvas, "Icon.png");
}
public void ImageIdsAreEqualsByAttribute()
{
var ids1 = new[] { new ImageId(1) };
var ids2 = new[] { new ImageId(1) };
Assert.That(ids1, Is.EqualTo(ids2));
}
public void BindingCanNotBeReused()
{
string xaml = @"<ContentPage xmlns=""http://xamarin.com/schemas/2014/forms""
xmlns:x=""http://schemas.microsoft.com/winfx/2009/xaml""
x:Class=""Xamarin.Forms.Controls.Issue1545"">
<ListView x:Name=""List"" ItemsSource=""{Binding}"">
<ListView.ItemTemplate>
<DataTemplate>
<TextCell Text=""{Binding}"" />
</DataTemplate>
</ListView.ItemTemplate>
</ListView>
</ContentPage>";
ContentPage page = new ContentPage().LoadFromXaml (xaml);
var items = new[] { "Fu", "Bar" };
page.BindingContext = items;
ListView lv = page.FindByName<ListView> ("List");
TextCell cell = (TextCell)lv.TemplatedItems.GetOrCreateContent (0, items[0]);
Assert.That (cell.Text, Is.EqualTo ("Fu"));
cell = (TextCell)lv.TemplatedItems.GetOrCreateContent (1, items[1]);
Assert.That (cell.Text, Is.EqualTo ("Bar"));
}
public void InsertionSortTestHappyFlow()
{
var input = new[] { 2, 5, 3, 1, 7, 4, 9 };
var expected = new[] { 1, 2, 3, 4, 5, 7, 9 };
int[] actual = SortingProblems.InsertionSort(input);
CollectionAssert.AreEqual(expected, actual);
}
public void Transitions2000To2010()
{
// These were fetched with Joda Time 1.6.2, which definitely uses the new rules.
var expectedDates = new[]
{
new LocalDate(2000, 3, 30), // Thursday morning
new LocalDate(2001, 3, 29), // Thursday morning
new LocalDate(2002, 3, 29), // Friday morning from here onwards
new LocalDate(2003, 3, 28),
new LocalDate(2004, 3, 26),
new LocalDate(2005, 4, 1),
new LocalDate(2006, 3, 31),
new LocalDate(2007, 3, 30),
new LocalDate(2008, 3, 28),
new LocalDate(2009, 3, 27),
new LocalDate(2010, 3, 26)
};
for (int year = 2000; year <= 2010; year++)
{
LocalDate summer = new LocalDate(year, 6, 1);
var intervalPair = Jordan.MapLocal(summer.AtMidnight());
Assert.AreEqual(1, intervalPair.Count);
Assert.AreEqual(expectedDates[year - 2000], intervalPair.EarlyInterval.IsoLocalStart.Date);
}
}
public void Detect_anagrams()
{
var detector = new Anagram("allergy");
var words = new[] { "gallery", "ballerina", "regally", "clergy", "largely", "leading" };
var results = new[] { "gallery", "largely", "regally" };
Assert.That(detector.Match(words), Is.EquivalentTo(results));
}
