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