public void Test(string original, string expected, string defaults, string overrides)
{
Config c = new Config();
var defs = new Dictionary <string, ResizeSettings>();
defs.Add("p", new ResizeSettings(defaults));
var sets = new Dictionary <string, ResizeSettings>();
sets.Add("p", new ResizeSettings(overrides));
new Presets(defs, sets, false).Install(c);
var e = new UrlEventArgs("/image.jpg", new ResizeSettings(original));
c.Pipeline.FireRewritingEvents(null, null, e);
Dictionary <string, string> expectedDict = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var ex = new ResizeSettings(expected);
foreach (string k in ex.Keys)
{
expectedDict[k] = ex[k];
}
Dictionary <string, string> dict = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (string k in e.QueryString.Keys)
{
dict[k] = e.QueryString[k];
}
Assert.AreElementsEqualIgnoringOrder <KeyValuePair <string, string> >(expectedDict, dict);
}
public void FacetQuery()
{
var connection = new MSolrConnection();
connection.get += (url, param) => {
Assert.AreEqual("/select", url);
var expectedParams = new Dictionary <string, string> {
{ "q", "" },
{ "rows", SolrQueryExecuter <TestDocumentWithUniqueKey> .ConstDefaultRows.ToString() },
{ "facet", "true" },
{ "facet.query", "id:1" },
};
Assert.AreElementsEqualIgnoringOrder(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
};
var querySerializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
var facetQuerySerializer = new DefaultFacetQuerySerializer(querySerializer, new DefaultFieldSerializer());
var parser = new MSolrAbstractResponseParser <TestDocumentWithUniqueKey>();
parser.parse &= x => x.Stub();
var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(parser, connection, querySerializer, facetQuerySerializer, null);
var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null);
var r = solr.Query(new SolrQuery(""), new QueryOptions {
Facet = new FacetParameters {
Queries = new ISolrFacetQuery[] {
new SolrFacetQuery(new SolrQuery("id:1")),
},
}
});
Assert.AreEqual(1, connection.get.Calls);
}
public void RunMultipleCulture()
{
var run = Runner.GetPrimaryTestStepRun(typeof(MultipleCultureSample), "Test");
var cultures = GetLogs(run.Children);
Assert.AreElementsEqualIgnoringOrder(new[] { "en-US", "en-GB", "fr-FR" }, cultures, (x, y) => y.StartsWith(x));
}
public void RunMultipleCultureWithThreads([Column("Test1", "Test2")] string methodName) // Issue 572 (http://code.google.com/p/mb-unit/issues/detail?id=572)
{
var runs = Runner.GetTestStepRuns(typeof(MultipleCultureWithThreadsSample), methodName);
var cultures = GetLogs(runs).Where(x => Regex.IsMatch(x, @"^\w{2}-\w{2}"));
Assert.AreElementsEqualIgnoringOrder(new[] { "en-US", "en-US", "fr-FR", "fr-FR" }, cultures, (x, y) => y.StartsWith(x));
}
private void Then_the_contact_book_should_contains_all_other_contacts(ScenarioContext ctx)
{
Assert.AreElementsEqualIgnoringOrder(
ctx.ContactBook.Contacts.ToArray(),
ctx.AddedContacts.Except(ctx.RemovedContacts).ToArray(),
"All contacts that has not been explicitly removed should be still present in contact book");
}
/// <summary>
/// Verify the expectations on a message type.
/// </summary>
/// <param name="type">The message type to assert on.</param>
private static void TestType(Type type)
{
// get the fields of the type
FieldInfo[] fields = type.GetFields();
// all fields must be public readonly
Assert.IsTrue(fields.All(f => f.IsPublic && f.IsInitOnly),
"All fields must be marked public readonly. Not conforming: {0}",
fields.Where(f => !(f.IsPublic && f.IsInitOnly)).Select(f => f.Name).ToArray());
// get the constructors of the type
ConstructorInfo[] constructors = type.GetConstructors();
// the type must have exactly one constructor
Assert.Count(1, constructors, "The message type has {0} constructors and must have exactly 1", constructors.Count());
ConstructorInfo constructor = constructors.Single();
// get the parameters of the constructor
ParameterInfo[] parameters = constructor.GetParameters();
// the parameter count must be exactly as the field count
Assert.Count(fields.Count(), parameters,
"The constructor parameter {0} count must be the same as the field count {1} .", parameters.Count(), fields.Count());
// get the names of the fields
IEnumerable <string> fieldNames = fields.Select(f => f.Name.ToLowerInvariant());
// get the names of the constructor parameters
IEnumerable <string> paramNames = parameters.Select(p => p.Name.ToLowerInvariant());
// assert they are the same
Assert.AreElementsEqualIgnoringOrder(fieldNames, paramNames);
}
public void RegisteredTest()
{
var expected = new[] { "Backup" };
var actual = tr.GetRegisteredTasks();
Assert.AreElementsEqualIgnoringOrder(expected, actual);
}
public void Populates_within_constructor_ok()
{
var collection = new InvalidValuesClass <int>(typeof(ArgumentException), new[] { 123, 456, 789 });
Assert.AreEqual(typeof(ArgumentException), collection.ExpectedExceptionType);
Assert.AreElementsEqualIgnoringOrder(new[] { 123, 456, 789 }, collection);
}
public void QueryWithPagination()
{
const string qstring = "id:123";
const int start = 10;
const int rows = 20;
var connection = new MSolrConnection();
connection.get += (url, param) => {
Assert.AreEqual("/select", url);
var expectedParams = new Dictionary <string, string> {
{ "q", qstring },
{ "start", start.ToString() },
{ "rows", rows.ToString() },
};
Assert.AreElementsEqualIgnoringOrder(expectedParams, param);
return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
};
var querySerializer = new MSolrQuerySerializer();
querySerializer.serialize += _ => qstring;
var resultParser = new MSolrAbstractResponseParser <TestDocumentWithUniqueKey>();
resultParser.parse &= x => x.Stub();
var executer = new SolrQueryExecuter <TestDocumentWithUniqueKey>(resultParser, connection, querySerializer, null, null);
var solr = new SolrBasicServer <TestDocumentWithUniqueKey>(connection, executer, null, null, null, null, null, null);
var r = solr.Query(new SolrQuery(qstring), new QueryOptions {
Start = start, Rows = rows
});
Assert.AreEqual(1, connection.get.Calls);
}
private void Then_all_contacts_should_be_available_in_the_contact_book(ScenarioContext ctx)
{
Assert.AreElementsEqualIgnoringOrder(
ctx.AddedContacts,
ctx.ContactBook.Contacts.ToArray(),
"Contacts should be added to contact book");
}
public void TestModifiySettings(string original, string expected, string defaults, string overrides)
{
var defs = new Dictionary <string, ResizeSettings>();
defs.Add("p", new ResizeSettings(defaults));
var sets = new Dictionary <string, ResizeSettings>();
sets.Add("p", new ResizeSettings(overrides));
ResizeSettings result = new Presets(defs, sets, false).Modify(new ResizeSettings(original));
Dictionary <string, string> expectedDict = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var ex = new ResizeSettings(expected);
foreach (string k in ex.Keys)
{
expectedDict[k] = ex[k];
}
Dictionary <string, string> dict = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
foreach (string k in result.Keys)
{
dict[k] = result[k];
}
Assert.AreElementsEqualIgnoringOrder <KeyValuePair <string, string> >(expectedDict, dict);
}
public void EnumData(string testMethod, string[] expectedTestLogOutput)
{
var run = Runner.GetPrimaryTestStepRun(CodeReference.CreateFromMember(typeof(EnumDataSample).GetMethod(testMethod)));
Assert.AreElementsEqualIgnoringOrder(expectedTestLogOutput,
run.Children.Select(x => x.TestLog.GetStream(MarkupStreamNames.Default).ToString()),
(x, y) => y.Contains(x));
}
public void RunDataDrivenTests(string fullName, string[] expectedTestLogOutput)
{
TestStepRun run = Runner.GetPrimaryTestStepRun(r => r.Step.FullName.EndsWith(fullName));
Assert.AreElementsEqualIgnoringOrder(expectedTestLogOutput,
run.Children.Select(x => x.TestLog.GetStream(MarkupStreamNames.Default).ToString()),
(x, y) => y.Contains(x));
}
public void PopulatesWithListInitializerSyntax()
{
var collection = new DistinctInstanceCollection <int> {
123, 456, 789
};
Assert.AreElementsEqualIgnoringOrder(new[] { 123, 456, 789 }, collection);
}
public void PopulatesExplicitelyTheCollection()
{
var collection = new DistinctInstanceCollection <int>();
collection.Add(123);
collection.Add(456);
collection.Add(789);
Assert.AreElementsEqualIgnoringOrder(new[] { 123, 456, 789 }, collection);
}
protected void AssertDiff(DiffSet actual, params Diff[] expected)
{
Assert.AreEqual(expected.Length == 0, actual.IsEmpty);
Assert.AreElementsEqualIgnoringOrder(expected, actual,
new StructuralEqualityComparer <Diff>
{
x => x.Type,
x => x.Path.ToString(),
});
}
public void Test()
{
var run = Runner.GetPrimaryTestStepRun(CodeReference.CreateFromMember(typeof(ImpersonateAttributeSample).GetMethod("Test")));
var userNames = GetLogs(run.Children)
.Select(x => Regex.Match(x, @"User = \w+\\(?<UserName>\w+)"))
.Where(m => m.Success)
.Select(m => m.Groups["UserName"].Value);
Assert.AreElementsEqualIgnoringOrder(new[] { "TestUser", "AnotherTestUser" }, userNames);
}
public void Populates_explicitely_the_collection_ok()
{
var collection = new InvalidValuesClass <int>(typeof(ArgumentException));
collection.Add(123);
collection.Add(456);
collection.Add(789);
Assert.AreEqual(typeof(ArgumentException), collection.ExpectedExceptionType);
Assert.AreElementsEqualIgnoringOrder(new[] { 123, 456, 789 }, collection);
}
public void PairwiseJoin()
{
var actual = DataGenerators.Join(new[] { "A", "B" }, new[] { 1, 2 }, new[] { 5.0, 9.0 }, JoinStrategy.Pairwise);
Assert.AreElementsEqualIgnoringOrder(new[]
{
new Triple <string, int, double>("A", 1, 9.0),
new Triple <string, int, double>("B", 2, 9.0),
new Triple <string, int, double>("A", 2, 5.0),
new Triple <string, int, double>("B", 1, 5.0),
}, actual);
}
public void SequentialJoin()
{
var actual = DataGenerators.Join(new[] { "A", "B", "C", "D" }, new[] { 1, 2, 3, 4 }, JoinStrategy.Sequential);
Assert.AreElementsEqualIgnoringOrder(new[]
{
new Pair <string, int>("A", 1),
new Pair <string, int>("B", 2),
new Pair <string, int>("C", 3),
new Pair <string, int>("D", 4),
}, actual);
}
public void TestSelectFrom()
{
var globalAsaxMethods = new AnalysisDataResolver()
.Resolve(typeof(GlobalAsaxStub))
.GetMethods();
var selectedMethods = new GlobalAsaxMethodsSelectionStrategy()
.SelectFrom(globalAsaxMethods, null)
.ToArray();
Assert.AreElementsEqualIgnoringOrder(globalAsaxMethods, selectedMethods);
}
public void Consuming_should_be_thread_safe()
{
var t1 = new Thread(Publish100Messages);
var t2 = new Thread(Consume100Messages);
t1.Start();
t2.Start();
Assert.IsTrue(consumer.WaitUntilDelivery(1000));
Assert.AreEqual(200, consumer.Received.Count);
Assert.AreElementsEqualIgnoringOrder(Enumerable.Range(0, 200), consumer.Received.Select(r => r.Value));
}
public void Adds_classes_Ok()
{
var collection = new InvalidValuesClassCollection <int>();
collection.Add(typeof(ArgumentOutOfRangeException), 1, 2, 3);
collection.Add(new InvalidValuesClass <int>(typeof(ArgumentException))
{
4, 5, 6
});
collection.Add(typeof(InvalidOperationException), 7, 8, 9);
Assert.Count(3, collection);
Assert.AreElementsEqualIgnoringOrder(new[] { typeof(ArgumentOutOfRangeException), typeof(ArgumentException), typeof(InvalidOperationException) }, collection.Select(x => x.ExpectedExceptionType));
}
public void ExecuteWithAllParameters()
{
var parameters = new ExtractParameters(null, "1", "text.doc");
var conn = new MSolrConnection();
conn.postStream += (url, type, stream, kvs) => {
Assert.AreEqual("/update/extract", url);
Assert.AreEqual("application/word-document", type);
var p = new[] {
KV.Create("literal.id", parameters.Id),
KV.Create("resource.name", parameters.ResourceName),
KV.Create("literal.field1", "value1"),
KV.Create("literal.field2", "value2"),
KV.Create("stream.type", "application/word-document"),
KV.Create("commit", "true"),
KV.Create("uprefix", "pref"),
KV.Create("defaultField", "field1"),
KV.Create("extractOnly", "true"),
KV.Create("extractFormat", "text"),
KV.Create("capture", "html"),
KV.Create("captureAttr", "true"),
KV.Create("xpath", "body"),
KV.Create("lowernames", "true")
};
Assert.AreElementsEqualIgnoringOrder(p, kvs);
return("");
};
var cmd = new ExtractCommand(new ExtractParameters(null, "1", "text.doc")
{
AutoCommit = true,
Capture = "html",
CaptureAttributes = true,
DefaultField = "field1",
ExtractOnly = true,
ExtractFormat = ExtractFormat.Text,
Fields = new[] {
new ExtractField("field1", "value1"),
new ExtractField("field2", "value2")
},
LowerNames = true,
XPath = "body",
Prefix = "pref",
StreamType = "application/word-document"
});
cmd.Execute(conn);
Assert.AreEqual(1, conn.postStream.Calls);
}
public void AreElementsEqualIgnoringOrder_fails_when_excess_or_missing_elements()
{
AssertionFailure[] failures = Capture(()
=> Assert.AreElementsEqualIgnoringOrder(new[] { 1, 2, 3, 2, 3, 1 }, new List <int> {
4, 2, 1, 1, 4, 1, 4
}));
Assert.Count(1, failures);
Assert.AreEqual("Expected elements to be equal but possibly in a different order.", failures[0].Description);
Assert.AreEqual("Equal Elements", failures[0].LabeledValues[0].Label);
Assert.AreEqual("[1, 1, 2]", failures[0].LabeledValues[0].FormattedValue.ToString());
Assert.AreEqual("Excess Elements", failures[0].LabeledValues[1].Label);
Assert.AreEqual("[1, 4, 4, 4]", failures[0].LabeledValues[1].FormattedValue.ToString());
Assert.AreEqual("Missing Elements", failures[0].LabeledValues[2].Label);
Assert.AreEqual("[2, 3, 3]", failures[0].LabeledValues[2].FormattedValue.ToString());
}
public void GetSchemaCommand()
{
var conn = new Mocks.MSolrConnection();
conn.get += (url, kvs) => {
Assert.AreEqual("/admin/file", url);
var expectedKVs = new[] { KV.Create("file", "schema.xml") };
Assert.AreElementsEqualIgnoringOrder(expectedKVs, kvs);
return("");
};
var cmd = new GetSchemaCommand();
cmd.Execute(conn);
Assert.AreEqual(1, conn.get.Calls);
}
public void Run()
{
TestStepRun testRun = Runner.GetPrimaryTestStepRun(CodeReference.CreateFromMember(typeof(NonEquatableStubSample).GetMethod("Test")));
Assert.AreEqual(TestOutcome.Passed, testRun.Result.Outcome);
IList <TestStepRun> steps = testRun.Children;
Assert.AreElementsEqualIgnoringOrder(new[]
{
"CustomEqualityComparer: x = 123, y = 456",
"CustomEqualityComparer: x = 123, y = 123",
"CustomEqualityComparer: x = 456, y = 123"
}, steps.Select(x => x.TestLog.ToString()),
(x, y) => y.Contains(x));
}
public void ResetTest()
{
tr.Reset();
var initRegged = tr.GetRegisteredTasks();
var task = new TestTask();
tr.Register(task);
var newRegged = tr.GetRegisteredTasks();
Assert.AreElementsNotEqual(initRegged, newRegged);
tr.Reset();
var resetRegged = tr.GetRegisteredTasks();
Assert.AreElementsNotEqual(resetRegged, newRegged);
Assert.AreElementsEqualIgnoringOrder(initRegged, resetRegged);
}
public void TestGetBaseAndImplementedMethods()
{
const string TestMethodName = "TestMethod";
var resolver = new AnalysisDataResolver();
var methods = Inheritance.GetBaseAndImplementedMethods(
resolver.Resolve(typeof(TestInheritedClass).GetMethod(TestMethodName))
);
Assert.AreElementsEqualIgnoringOrder(
methods.ToArray(), new[] {
resolver.Resolve(typeof(TestInterface).GetMethod(TestMethodName)),
resolver.Resolve(typeof(TestBaseClass).GetMethod(TestMethodName))
}
);
}
public void CanStoreAndQuery()
{
Ambient.Data.DeleteAll();
Ambient.Data.Store(new Item {
Name = "A", Value = 1
});
Ambient.Data.Store(new Item {
Name = "B", Value = 2
});
IList <Item> items = Ambient.Data.Query <Item>();
Assert.AreElementsEqualIgnoringOrder(new[] { new Item {
Name = "A", Value = 1
}, new Item {
Name = "B", Value = 2
} }, items);
}