public void Devices_CanSetLightBarColorAndMotorSpeedsOnDualShockPS4()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
deviceClass = "PS4DualShockGamepad",
interfaceName = "PS4"
});
Assert.That(device, Is.AssignableTo <DualShockGamepadPS4>());
var gamepad = (DualShockGamepadPS4)device;
DualShockPS4OuputCommand?receivedCommand = null;
unsafe
{
testRuntime.SetDeviceCommandCallback(gamepad.id,
(id, commandPtr) =>
{
if (commandPtr->type == DualShockPS4OuputCommand.Type)
{
Assert.That(receivedCommand.HasValue, Is.False);
receivedCommand = *((DualShockPS4OuputCommand *)commandPtr);
return(1);
}
Assert.Fail("Received wrong type of command");
return(InputDeviceCommand.kGenericFailure);
});
}
gamepad.SetMotorSpeeds(0.1234f, 0.5678f);
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.largeMotorSpeed, Is.EqualTo((byte)(0.1234 * 255)));
Assert.That(receivedCommand.Value.smallMotorSpeed, Is.EqualTo((byte)(0.56787 * 255)));
receivedCommand = null;
gamepad.SetLightBarColor(new Color(0.123f, 0.456f, 0.789f));
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.redColor, Is.EqualTo((byte)(0.123f * 255)));
Assert.That(receivedCommand.Value.greenColor, Is.EqualTo((byte)(0.456f * 255)));
Assert.That(receivedCommand.Value.blueColor, Is.EqualTo((byte)(0.789f * 255)));
}
public void ProcessNames_MethodCallExpression()
{
var instance = ExpressionHelper.CreateExpression(typeof(int));
var argument = ExpressionHelper.CreateExpression(typeof(string));
var expression = Expression.Call(instance, MemberInfoFromExpressionUtility.GetMethod(() => 5.ToString ("arg")), argument);
var namedExpression = new NamedExpression("test", expression);
var result = _namedExpressionCombiner.ProcessNames(namedExpression);
Assert.That(result, Is.AssignableTo(typeof(MethodCallExpression)));
Assert.That(((MethodCallExpression)result).Arguments.Count, Is.EqualTo(1));
Assert.That(((MethodCallExpression)result).Arguments[0], Is.TypeOf(typeof(NamedExpression)));
Assert.That(((NamedExpression)((MethodCallExpression)result).Arguments[0]).Name, Is.EqualTo("test"));
Assert.That(((NamedExpression)((MethodCallExpression)result).Arguments[0]).Expression, Is.SameAs(argument));
Assert.That(((MethodCallExpression)result).Object, Is.TypeOf(typeof(NamedExpression)));
Assert.That(((NamedExpression)((MethodCallExpression)result).Object).Name, Is.EqualTo("test"));
Assert.That(((NamedExpression)((MethodCallExpression)result).Object).Expression, Is.SameAs(instance));
}
public void TestMethodInsert(IRunnable obj)
{
var buff = obj.Run();
Assert.That(buff, Is.AssignableTo <ILinkedList>());
ILinkedList linkedList = (ILinkedList)buff;
var item = CreateListItem(linkedList.GetType(), 1);
linkedList.AddLast(item);
item = CreateListItem(linkedList.GetType(), 2);
linkedList.AddLast(item);
item = CreateListItem(linkedList.GetType(), 0);
linkedList.Insert(item, 0);
item = linkedList.GetFirstItem();
Assert.AreEqual(0, (int)item.Value);
}
public void Should_CreateEditor_ForEnum()
{
var field = new ObjectPropertiesField();
_window.rootVisualElement.Add(field);
var block = new WithProperty <PortCapacity>();
field.PropertyBlock = block;
var editor = field.Q(null, BaseField <string> .ussClassName);
Assert.That(editor, Is.Not.Null);
Assert.That(editor, Is.AssignableTo(typeof(BaseField <string>)));
(editor as BaseField <string>).value = PortCapacity.Multiple.ToString();
Assert.That(block.Property, Is.EqualTo(PortCapacity.Multiple));
}
public void Devices_CanSetLightColorAndMotorSpeedsOnMoveController()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
deviceClass = "PS4MoveController",
interfaceName = "PS4"
});
Assert.That(device, Is.AssignableTo <MoveControllerPS4>());
var move = (MoveControllerPS4)device;
MoveControllerPS4OuputCommand?receivedCommand = null;
unsafe
{
runtime.SetDeviceCommandCallback(move.id,
(id, commandPtr) =>
{
if (commandPtr->type == MoveControllerPS4OuputCommand.Type)
{
Assert.That(receivedCommand.HasValue, Is.False);
receivedCommand = *((MoveControllerPS4OuputCommand *)commandPtr);
return(1);
}
Assert.Fail("Received wrong type of command");
return(InputDeviceCommand.GenericFailure);
});
}
move.SetMotorSpeed(0.1234f);
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.motorSpeed, Is.EqualTo((byte)(0.1234 * 255)));
receivedCommand = null;
move.SetLightSphereColor(new Color(0.123f, 0.456f, 0.789f));
Assert.That(receivedCommand.HasValue, Is.True);
Assert.That(receivedCommand.Value.redColor, Is.EqualTo((byte)(0.123f * 255)));
Assert.That(receivedCommand.Value.greenColor, Is.EqualTo((byte)(0.456f * 255)));
Assert.That(receivedCommand.Value.blueColor, Is.EqualTo((byte)(0.789f * 255)));
}
public void DeserializeEquivalentTo_PatternIntegerRange_Week1toWeek52()
{
int testNr = 5;
// Create an instance of the XmlSerializer specifying type and namespace.
TestSuiteXml ts = DeserializeSample();
Assert.That(ts.Tests[testNr].Constraints[0], Is.AssignableTo <EquivalentToXml>());
Assert.That(((EquivalentToXml)ts.Tests[testNr].Constraints[0]).Range, Is.Not.Null);
Assert.That(((EquivalentToXml)ts.Tests[testNr].Constraints[0]).Range, Is.InstanceOf <IIntegerRange>());
Assert.That(((EquivalentToXml)ts.Tests[testNr].Constraints[0]).Range, Is.InstanceOf <IPatternDecorator>());
var range = (PatternIntegerRangeXml)(((EquivalentToXml)ts.Tests[testNr].Constraints[0]).Range);
Assert.That(range.Start, Is.EqualTo(1));
Assert.That(range.End, Is.EqualTo(52));
Assert.That(range.Step, Is.EqualTo(1));
Assert.That(range.Pattern, Is.EqualTo("Week "));
Assert.That(range.Position, Is.EqualTo(PositionValue.Suffix));
}
public void ReasonFor_WithSugestedMods_GivesCorrectParent()
{
var list = new List <string>();
var sugested = generator.GeneratorRandomModule();
var mod = generator.GeneratorRandomModule(sugests: new List <RelationshipDescriptor> {
new RelationshipDescriptor {
name = sugested.identifier
}
});
list.Add(mod.identifier);
AddToRegistry(mod, sugested);
options.with_all_suggests = true;
var relationship_resolver = new RelationshipResolver(list, options, registry, null);
var reason = relationship_resolver.ReasonFor(sugested);
Assert.That(reason, Is.AssignableTo <Relationship.Suggested>());
Assert.That(reason.Parent, Is.EqualTo(mod));
}
public void Build_VariableAndFunctions_FunctionScalarResolverArgs()
{
var predicateXml = new MoreThanXml()
{
Reference = "#12 | text-to-upper | text-to-first-chars([ColA])"
};
var builder = new PredicateArgsBuilder(new ServiceLocator(), Context.None);
var args = builder.Execute(Core.ResultSet.ColumnType.Text, predicateXml);
Assert.That(args, Is.AssignableTo <ReferencePredicateArgs>());
var typedArgs = args as ReferencePredicateArgs;
Assert.That(typedArgs.Reference, Is.TypeOf <FunctionScalarResolver <string> >());
var function = typedArgs.Reference as FunctionScalarResolver <string>;
Assert.That(function.Args.Resolver, Is.TypeOf <ContextScalarResolver <object> >());
}
public void Clone()
{
var modelRootInstantiator = factory.CreateObjectClass(typeof(ModelRoot), null);
var modelRoot = (ModelRoot)modelRootInstantiator.Instantiate();
var simpleObjInstantiator = factory.CreateObjectClass(typeof(SimpleObj), null);
var simpleObj = (SimpleObj)simpleObjInstantiator.Instantiate();
simpleObj.A = 123;
modelRoot.Child = simpleObj;
var clone = modelRoot.CloneTyped();
Assert.That(clone, Is.Not.Null);
Assert.That(clone, Is.Not.SameAs(modelRoot));
//Assert.That(clone.AmCore, Is.Not.SameAs(modelRoot.AmCore));
Assert.That(clone.Child, Is.AssignableTo <SimpleObj>());
var simpleClone = (SimpleObj)clone.Child;
Assert.That(simpleClone.A, Is.EqualTo(123));
Assert.That(simpleClone, Is.Not.SameAs(simpleObj));
}
public async Task Outgoing_operations_are_stored_atomically(Type contextProviderType, DispatchConsistency dispatchConsistency)
{
using (var contextProvider = CreateContext(contextProviderType, sqlConnectionFactory))
{
var invalidOperations = new TransportOperations(
CreateTransportOperation(id: "3", destination: ValidAddress, consistency: dispatchConsistency),
CreateTransportOperation(id: "4", destination: InvalidAddress, consistency: dispatchConsistency)
);
Assert.ThrowsAsync(Is.AssignableTo <Exception>(), async() =>
{
await dispatcher.Dispatch(invalidOperations, contextProvider.TransportTransaction);
contextProvider.Complete();
});
}
var messagesSent = await purger.Purge(queue);
Assert.AreEqual(0, messagesSent);
}
public void DeserializeEqualToQuery_QueryFile4_List()
{
int testNr = 4;
// Create an instance of the XmlSerializer specifying type and namespace.
TestSuiteXml ts = DeserializeSample();
Assert.That(ts.Tests[testNr].Constraints[0], Is.AssignableTo <EqualToXml>());
Assert.That(((EqualToXml)ts.Tests[testNr].Constraints[0]).Query, Is.TypeOf <QueryXml>());
var connStr = ((EqualToXml)ts.Tests[testNr].Constraints[0]).Query.ConnectionString;
Assert.That(connStr, Is.Not.Empty);
Assert.That(connStr, Contains.Substring("Reference"));
var query = ((EqualToXml)ts.Tests[testNr].Constraints[0]).Query.InlineQuery;
Assert.That(query, Is.Not.Empty);
Assert.That(query, Contains.Substring("select top 2 [Name]"));
}
public void Devices_SupportsMoveOnPS4()
{
var device = InputSystem.AddDevice(new InputDeviceDescription
{
deviceClass = "PS4MoveController",
interfaceName = "PS4"
});
Assert.That(device, Is.AssignableTo <MoveControllerPS4>());
var move = (MoveControllerPS4)device;
InputSystem.QueueStateEvent(move,
new MoveControllerStatePS4
{
buttons = 0xffffffff,
trigger = 0.567f,
accelerometer = new Vector3(0.987f, 0.654f, 0.321f),
gyro = new Vector3(0.444f, 0.555f, 0.666f),
});
InputSystem.Update();
Assert.That(move.squareButton.isPressed);
Assert.That(move.triangleButton.isPressed);
Assert.That(move.circleButton.isPressed);
Assert.That(move.crossButton.isPressed);
Assert.That(move.selectButton.isPressed);
Assert.That(move.triggerButton.isPressed);
Assert.That(move.moveButton.isPressed);
Assert.That(move.startButton.isPressed);
Assert.That(move.trigger.ReadValue(), Is.EqualTo(0.567).Within(0.00001));
Assert.That(move.accelerometer.x.ReadValue(), Is.EqualTo(0.987).Within(0.00001));
Assert.That(move.accelerometer.y.ReadValue(), Is.EqualTo(0.654).Within(0.00001));
Assert.That(move.accelerometer.z.ReadValue(), Is.EqualTo(0.321).Within(0.00001));
Assert.That(move.gyro.x.ReadValue(), Is.EqualTo(0.444).Within(0.00001));
Assert.That(move.gyro.y.ReadValue(), Is.EqualTo(0.555).Within(0.00001));
Assert.That(move.gyro.z.ReadValue(), Is.EqualTo(0.666).Within(0.00001));
}
public void TestModelTransformerEnumberableTransformerChaining()
{
var payload = new List <object>();
var modelTransformer = _responseTransformerFactory.Get(payload);
Assume.That(modelTransformer, Is.TypeOf <EnumerableTransformer>());
var transformed = modelTransformer.Transform(_actionConfiguration, payload);
Assume.That(transformed, Is.Null);
payload = new List <object>()
{
new object()
};
transformed = modelTransformer.Transform(_actionConfiguration, payload);
Assume.That(transformed, Is.AssignableTo <IList>());
Assume.That(((IList)transformed).Count, Is.EqualTo(1));
Assume.That(((IList)transformed)[0].GetType().AssemblyQualifiedName, Is.StringContaining("Object.Object, DynHateoas_"));
}
public void TestMethodGetAll(IRunnable obj)
{
var buff = obj.Run();
Assert.That(buff, Is.AssignableTo <ILinkedList>());
ILinkedList linkedList = (ILinkedList)buff;
var item = CreateListItem(linkedList.GetType(), 1);
linkedList.AddLast(item);
item = CreateListItem(linkedList.GetType(), 2);
linkedList.AddLast(item);
item = CreateListItem(linkedList.GetType(), 3);
linkedList.AddLast(item);
var items = linkedList.GetAll();
Assert.IsNotEmpty(items);
Assert.AreEqual(2, items.Count());
Assert.IsTrue(items.All(_ => (int)_.Value != 1));
}
public void MOreTests()
{
var myComp = Assembly.LoadFile(@"c:\temp\MyCompilation.dll");
var type = myComp.GetType("Furnace.Play.Roslyn.FurnaceItem");
System.Console.WriteLine(type);
var json = "{TestString:123}";
var result = (IFurnaceItem)TypeSerializer.DeserializeFromString(json, type);
result.SetFurnaceItem(new FurnaceItemInformation());
Assert.That(result, Is.AssignableTo <IFurnaceItem>());
Assert.That(result, Is.AssignableTo <TestClass>());
var testClass = (TestClass)result;
Assert.That(testClass.TestString, Is.EqualTo("123"));
}
private protected static async Task AssertReplicationCancellation <T>(IAsyncEnumerator <T> enumerator)
{
try
{
var succeeded = await enumerator.MoveNextAsync();
Assert.Fail(succeeded
? $"Expected replication cancellation but got message: {enumerator.Current}"
: "Expected replication cancellation but reached enumeration end instead");
}
catch (Exception e)
{
Assert.That(e, CurrentServerVersion >= Pg10Version
? Is.AssignableTo <OperationCanceledException>()
.With.InnerException.InstanceOf <PostgresException>()
.And.InnerException.Property(nameof(PostgresException.SqlState))
.EqualTo(PostgresErrorCodes.QueryCanceled)
: Is.AssignableTo <OperationCanceledException>()
.With.InnerException.Null);
}
}
public void Audit_Properties_Are_Modified()
{
Mock <IRepository <AuditableEntity> > realRepo = new Mock <IRepository <AuditableEntity> >();
realRepo.Setup(rr => rr.Insert(It.IsAny <AuditableEntity>()));
Mock <AuditableRepository <AuditableEntity> > deco = new Mock <AuditableRepository <AuditableEntity> >(realRepo.Object)
{
CallBase = true
};
AuditableEntity ent = new AuditableEntity();
deco.Object.Insert(ent);
Assert.That(ent, Is.AssignableTo <IAuditable>());
Assert.That(ent, Has.Property("Created").Not.Null);
Assert.That(ent, Has.Property("CreatedBy").Not.Null);
Assert.That(ent, Has.Property("CreatedBy").EqualTo(Thread.CurrentPrincipal.Identity.Name));
realRepo.VerifyAll();
}
public void Deserialize_SampleFile_EmptyResultSet()
{
int testNr = 18;
// Create an instance of the XmlSerializer specifying type and namespace.
var ts = DeserializeSample();
// Check the properties of the object.
Assert.That(ts.Tests[testNr].Systems[0], Is.AssignableTo <ResultSetSystemXml>());
var rs = ts.Tests[testNr].Systems[0] as ResultSetSystemXml;
Assert.That(rs.Empty, Is.Not.Null);
Assert.That(rs.Empty, Is.TypeOf <EmptyResultSetXml>());
var empty = rs.Empty as EmptyResultSetXml;
Assert.That(empty.ColumnCount, Is.EqualTo("4"));
Assert.That(empty.Columns, Has.Count.EqualTo(2));
Assert.That(empty.Columns.Any(x => x.Identifier.Label == "[myFirstColumn]"));
Assert.That(empty.Columns.Any(x => x.Identifier.Label == "[mySecondColumn]"));
}
public void Intercept_AsyncVoidReturnFaultedInvocation()
{
var instrumentationInterceptor = this.CreateInstrumentationInterceptor();
var invocationMock = InvocationMockHelper.MockAsyncVoidReturnFaultedInvocation();
using (var resetEvent = new ManualResetEventSlim())
{
RegistrarMockCountResetEvent(this.registrarMock, resetEvent, 3);
instrumentationInterceptor.Intercept(invocationMock.Object);
resetEvent.Wait();
}
this.registrarMock.Verify(r => r.Register(Guid, It.IsAny <string>()), Times.Exactly(3));
this.guidProviderMock.Verify(g => g.NewGuid(), Times.Once());
invocationMock.Verify(i => i.Proceed(), Times.Once());
invocationMock.VerifyGet(i => i.ReturnValue, Times.Once());
var returnValue = invocationMock.Object.ReturnValue;
Assert.That(returnValue, Is.AssignableTo <Task>());
Assert.That(((Task)returnValue).Status, Is.EqualTo(TaskStatus.Faulted));
}
public void Deserialize_SampleFile_AlterationProjectAway()
{
int testNr = 16;
// Create an instance of the XmlSerializer specifying type and namespace.
var ts = DeserializeSample();
// Check the properties of the object.
Assert.That(ts.Tests[testNr].Systems[0], Is.AssignableTo <ResultSetSystemXml>());
var rs = ts.Tests[testNr].Systems[0] as ResultSetSystemXml;
Assert.That(rs.Alterations, Is.Not.Null);
Assert.That(rs.Alterations, Has.Count.EqualTo(1));
Assert.That(rs.Alterations[0], Is.Not.Null);
Assert.That(rs.Alterations[0], Is.TypeOf <ProjectAwayXml>());
var projectAway = rs.Alterations[0] as ProjectAwayXml;
Assert.That(projectAway.Columns, Is.Not.Null);
Assert.That(projectAway.Columns.Count, Is.EqualTo(2));
}
public void Execute_DecorationCommand_CorrectlyTransformedToArgs(Type xmlType, Type argsType)
{
var xmlInstance = Activator.CreateInstance(xmlType);
Assert.That(xmlInstance, Is.AssignableTo <DecorationCommandXml>());
var xml = new SetupXml()
{
Commands = new List <DecorationCommandXml>()
{
xmlInstance as DecorationCommandXml
}
};
var helper = new SetupHelper(new ServiceLocator(), new Dictionary <string, ITestVariable>());
var commandArgs = helper.Execute(xml.Commands).ElementAt(0);
Assert.That(commandArgs, Is.AssignableTo <IDecorationCommandArgs>());
Assert.That(commandArgs, Is.AssignableTo(argsType));
}
public async Task TestExtendedProperties()
{
const string indexName = "hello-users";
try {
var store = new ElasticUserStore <HelloUser>(_connectionString,
indexName,
forceRecreate: true);
await store.CreateAsync(new HelloUser {
UserName = "******",
Car = new Tesla {
LicensePlate = "ABC123",
Model = TeslaModel.ModelS
}
});
await store.CreateAsync(new HelloUser {
UserName = "******",
Car = new Koenigsegg {
LicensePlate = "ABC123",
Model = KoenigseggModel.One
}
});
var users = await store.GetAllAsync();
var teslaUser = users.FirstOrDefault(x => x.UserName == "abc123");
var koenigseggUser = users.FirstOrDefault(x => x.UserName == "def456");
Assert.That(teslaUser, Is.Not.Null, "No Telsa user found");
Assert.That(koenigseggUser, Is.Not.Null, "No Koenigsegg user found");
Assert.That(teslaUser.Car, Is.AssignableTo <Tesla>(), "Tesla Car is not Tesla");
Assert.That(koenigseggUser.Car, Is.AssignableTo <Koenigsegg>(), "Koenigsegg Car is not Koenigsegg");
}
finally {
Client.DeleteIndex(i => i.Index(indexName));
}
}
public void RemovingItemModTest()
{
var filePath = Utils.GetFullPathToFile("saves/pc/midgame_1.5.dat");
var bytes = File.ReadAllBytes(filePath);
var fileStream = new MemoryStream(bytes);
var saveFile = new SaveFile();
saveFile.Load(fileStream);
var prevNodeCount = saveFile.Nodes.Count;
// Find johnny's glasses in the save.
var item = saveFile.FlatNodes.FirstOrDefault(_ => _.Id == 349);
Assert.That(item, Is.Not.Null);
var itemData = (ItemData)item.Value;
var genericData = itemData.Data;
Assert.That(genericData, Is.AssignableTo(typeof(ItemData.ModableItemData)));
var moddableItem = (ItemData.ModableItemData)genericData;
// Remove the second mod.
var children = moddableItem.RootNode.Children;
moddableItem.RootNode.Children.RemoveAt(1);
List <byte[]> newSave = new List <byte[]>(); // we need the array but cannot assign a variable inside the delegate
Assert.DoesNotThrow(() => { newSave.Add(saveFile.Save()); });
saveFile = new SaveFile();
using (var stream = new MemoryStream(newSave[0]))
{
Assert.DoesNotThrow(() => { saveFile.Load(stream); });
}
Assert.That(saveFile.Nodes.Count, Is.EqualTo(prevNodeCount));
}
public void GetBalancesSafelyRequestWorks()
{
IAutonomousApp client = this.GetAutonomousClient();
IUserIdentity userIdentity = RecognizedUserIdentity.Master;
string docType = userIdentity.DocType;
string docNumber = userIdentity.DocNumber;
IList <AccountInfo> accounts = client.Inquiries.GetAccounts(docType, docNumber);
CollectionAssert.IsNotEmpty(accounts);
AccountInfo accountInfo = accounts.FirstOrDefault(account => account.Source == Subsystem.Tup);
Assert.IsNotNull(accountInfo);
string accountId = accountInfo.SourceAccountId;
IList <BalanceResultInfo> inquiryResults = client.InquiriesV11.GetBalances(docType, docNumber, accountId);
CollectionAssert.IsNotEmpty(inquiryResults);
Assert.That(inquiryResults.Count, Is.EqualTo(1));
const string AccountTypesPattern = "80|81|82|83|84";
const string AccountNumberPattern = @".*\d{4}";
foreach (BalanceResultInfo inquiryResult in inquiryResults)
{
CollectionAssert.IsNotEmpty(inquiryResult.Data);
Assert.IsNotEmpty(inquiryResult.Reason);
Assert.That(inquiryResult.Status, Is.EqualTo(SubsystemStatus.Available));
Assert.That(inquiryResult.Subsystem, Is.EqualTo(Subsystem.Tup));
Assert.That(inquiryResult.Data.Count, Is.EqualTo(5));
foreach (BalanceInfo balance in inquiryResult.Data)
{
Assert.That(balance.Balance, Is.AssignableTo(typeof(decimal)));
Assert.That(balance.Number, Is.Not.Null.And.Match(AccountNumberPattern));
Assert.That(balance.SourceAccountId, Is.Not.Empty);
Assert.That(balance.TypeId, Is.Not.Null.And.Match(AccountTypesPattern));
Assert.That(balance.TypeName, Is.Not.Empty);
}
}
}
public void ReasonFor_WithTreeOfMods_GivesCorrectParents()
{
var list = new List <string>();
var suggested = generator.GeneratorRandomModule();
var recommendedA = generator.GeneratorRandomModule();
var recommendedB = generator.GeneratorRandomModule();
var mod = generator.GeneratorRandomModule(
suggests: new List <RelationshipDescriptor>
{
new ModuleRelationshipDescriptor {
name = suggested.identifier
}
}
);
list.Add(mod.identifier);
suggested.recommends = new List <RelationshipDescriptor>
{
new ModuleRelationshipDescriptor {
name = recommendedA.identifier
},
new ModuleRelationshipDescriptor {
name = recommendedB.identifier
}
};
AddToRegistry(mod, suggested, recommendedA, recommendedB);
options.with_all_suggests = true;
options.with_recommends = true;
var relationship_resolver = new RelationshipResolver(list, null, options, registry, null);
var reason = relationship_resolver.ReasonFor(recommendedA);
Assert.That(reason, Is.AssignableTo <SelectionReason.Recommended>());
Assert.That(reason.Parent, Is.EqualTo(suggested));
reason = relationship_resolver.ReasonFor(recommendedB);
Assert.That(reason, Is.AssignableTo <SelectionReason.Recommended>());
Assert.That(reason.Parent, Is.EqualTo(suggested));
}
public void Deserialize_SampleFile_AlterationLookup()
{
int testNr = 9;
// Create an instance of the XmlSerializer specifying type and namespace.
TestSuiteXml ts = DeserializeSample();
// Check the properties of the object.
Assert.That(ts.Tests[testNr].Systems[0], Is.AssignableTo <ResultSetSystemXml>());
var rs = ts.Tests[testNr].Systems[0] as ResultSetSystemXml;
Assert.That(rs.Alteration, Is.Not.Null);
Assert.That(rs.Alteration.Lookups, Is.Not.Null);
Assert.That(rs.Alteration.Lookups, Has.Count.EqualTo(1));
Assert.That(rs.Alteration.Lookups[0], Is.Not.Null);
Assert.That(rs.Alteration.Lookups[0], Is.TypeOf <LookupXml>());
Assert.That(rs.Alteration.Lookups[0].Missing, Is.TypeOf <MissingXml>());
Assert.That(rs.Alteration.Lookups[0].Join, Is.TypeOf <JoinXml>());
Assert.That(rs.Alteration.Lookups[0].ResultSet, Is.TypeOf <ResultSetSystemXml>());
}
public void DerivedType()
{
bool help = false;
var p = new CiOptionSet()
{
{ "h|help", v => help = v != null },
};
p.Parse(_("-H"));
Assert.AreEqual(help, true);
help = false;
p.Parse(_("-HELP"));
Assert.AreEqual(help, true);
Assert.AreEqual(p["h"], p[0]);
Assert.AreEqual(p["help"], p[0]);
Assert.Throws(Is.AssignableTo(typeof(KeyNotFoundException)), () => { var tmp = p["invalid"]; Console.Write(tmp); });
Utils.AssertException(typeof(ArgumentException), "prototypes must be null!",
p, v => { v.Add("N|NUM=", (int n) => { }); });
Assert.That(() => { var ignore = p[null]; Console.Write(ignore); }, Throws.InstanceOf <ArgumentNullException>());
}
public void Deserialize_SampleFile_AlterationUnstack()
{
int testNr = 14;
// Create an instance of the XmlSerializer specifying type and namespace.
var ts = DeserializeSample();
// Check the properties of the object.
Assert.That(ts.Tests[testNr].Systems[0], Is.AssignableTo <ResultSetSystemXml>());
var rs = ts.Tests[testNr].Systems[0] as ResultSetSystemXml;
Assert.That(rs.Alterations, Is.Not.Null);
Assert.That(rs.Alterations, Has.Count.EqualTo(1));
Assert.That(rs.Alterations[0], Is.Not.Null);
Assert.That(rs.Alterations[0], Is.TypeOf <UnstackXml>());
var unstack = rs.Alterations[0] as UnstackXml;
Assert.That(unstack.Header, Is.Not.Null);
Assert.That(unstack.Header, Is.TypeOf <HeaderXml>());
Assert.That(unstack.GroupBy, Is.TypeOf <GroupByXml>());
}
public void Deserialize_SampleFile_AlterationSummarization()
{
int testNr = 13;
// Create an instance of the XmlSerializer specifying type and namespace.
var ts = DeserializeSample();
// Check the properties of the object.
Assert.That(ts.Tests[testNr].Systems[0], Is.AssignableTo <ResultSetSystemXml>());
var rs = ts.Tests[testNr].Systems[0] as ResultSetSystemXml;
Assert.That(rs.Alterations, Is.Not.Null);
Assert.That(rs.Alterations, Has.Count.EqualTo(1));
Assert.That(rs.Alterations[0], Is.Not.Null);
Assert.That(rs.Alterations[0], Is.TypeOf <SummarizeXml>());
var summerize = rs.Alterations[0] as SummarizeXml;
Assert.That(summerize.Aggregation, Is.Not.Null);
Assert.That(summerize.Aggregation, Is.TypeOf <SumXml>());
Assert.That(summerize.Aggregation.ColumnType, Is.EqualTo(ColumnType.Numeric));
}
public void TestSchema([IncludeDataSources(ProviderName.SQLiteMS)] string context)
{
void TestMethod(string columnName, string schemaName = null)
{
var ms = CreateMappingSchema(columnName, schemaName);
using (var db = GetDataContext(context, ms))
using (db.CreateLocalTable <SampleClass>())
{
db.Insert(new SampleClass()
{
Id = 1, StrKey = "K1", Value = "V1"
});
}
}
TestMethod("Value1");
TestMethod("Value2");
TestMethod("ValueF1", "FAIL");
Assert.Throws(Is.AssignableTo(typeof(Exception)), () => TestMethod("ValueF2", "FAIL"));
}
