public void NestedNamedFolderWithNestedDoubleStar() { var rulesFactory = new FolderRecurseRules(); rulesFactory.AddGlobPath(@"Folder\**\*.txt"); List <FolderSegmentRule> filePathSegmentRules = rulesFactory.GenerateRules(false); Assert.That(filePathSegmentRules.Count, Is.EqualTo(2)); Assert.That(filePathSegmentRules[0].Type, Is.EqualTo(EFolderSegmentType.MatchAnyFolderPattern)); Assert.That(filePathSegmentRules[0].FolderNameRegexes, Has.Member(@"^Folder$")); Assert.That(filePathSegmentRules[1].Type, Is.EqualTo(EFolderSegmentType.MatchZeroOrMOreFoldersRecursive)); List <FolderSegmentRule> folderPathSegmentRules = rulesFactory.GenerateRules(true); Assert.That(folderPathSegmentRules.Count, Is.EqualTo(2)); Assert.That(folderPathSegmentRules[0].Type, Is.EqualTo(EFolderSegmentType.MatchAnyFolderPattern)); Assert.That(folderPathSegmentRules[0].FolderNameRegexes, Has.Member(@"^Folder$")); Assert.That(folderPathSegmentRules[1].Type, Is.EqualTo(EFolderSegmentType.MatchZeroOrMOreFoldersRecursive)); }
public void SetCollection_PerformsAllBidirectionalChanges() { var newOpposites = new OrderCollection { _order2, _order3 }; var customer3 = DomainObjectIDs.Customer3.GetObject <Customer> (); Assert.That(_order1.Customer, Is.SameAs(_customerEndPoint.GetDomainObject())); Assert.That(_order2.Customer, Is.SameAs(_customerEndPoint.GetDomainObject())); Assert.That(_order3.Customer, Is.SameAs(customer3)); Assert.That(customer3.Orders, Has.Member(_order3)); SetCollectionAndNotify(_customerEndPoint, newOpposites); Assert.That(_order1.Customer, Is.Null); Assert.That(_order2.Customer, Is.SameAs(_customerEndPoint.GetDomainObject())); Assert.That(_order3.Customer, Is.SameAs(_customerEndPoint.GetDomainObject())); Assert.That(customer3.Orders, Has.No.Member(_order3)); }
public void VirtualEndPointQuery_OneMany_Consistent_CollectionLoadedFirst() { var order1 = DomainObjectIDs.Order1.GetObject <Order> (); order1.OrderItems.EnsureDataComplete(); var orderItem1 = DomainObjectIDs.OrderItem1.GetObject <OrderItem>(); Assert.That(orderItem1.Order, Is.SameAs(order1)); Assert.That(order1.OrderItems, Has.Member(orderItem1)); CheckSyncState(orderItem1, oi => oi.Order, true); CheckSyncState(orderItem1.Order, o => o.OrderItems, true); // these do nothing BidirectionalRelationSyncService.Synchronize(TestableClientTransaction, RelationEndPointID.Resolve(orderItem1, oi => oi.Order)); BidirectionalRelationSyncService.Synchronize(TestableClientTransaction, RelationEndPointID.Resolve(orderItem1.Order, o => o.OrderItems)); CheckSyncState(orderItem1, oi => oi.Order, true); CheckSyncState(orderItem1.Order, o => o.OrderItems, true); }
public async Task CanRetrieveReservedWordsAsync() { var configuration = TestConfigurationHelper.GetDefaultConfiguration(); var dialect = Dialect.Dialect.GetDialect(configuration.Properties); var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties); await(connectionHelper.PrepareAsync(CancellationToken.None)); try { var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection); var reserved = metaData.GetReservedWords(); Assert.That(reserved, Is.Not.Empty); Assert.That(reserved, Has.Member("SELECT").IgnoreCase); Assert.That(reserved, Has.Member("FROM").IgnoreCase); } finally { connectionHelper.Release(); } }
public void CreateGetDeleteAnycastIpAddressEntryTest() { var mibrow = new MIB_ANYCASTIPADDRESS_ROW(GetV6Addr(), primaryAdapter.Luid); Assert.That(GetAnycastIpAddressTable(ADDRESS_FAMILY.AF_INET6, out var t1), Is.Zero); if (t1.Contains(mibrow)) { Assert.That(DeleteAnycastIpAddressEntry(ref mibrow), Is.Zero); } Assert.That(CreateAnycastIpAddressEntry(ref mibrow), Is.Zero); GetAnycastIpAddressTable(ADDRESS_FAMILY.AF_INET6, out var t2); Assert.That(t2, Has.Member(mibrow)); Assert.That(GetAnycastIpAddressEntry(ref mibrow), Is.Zero); Assert.That(DeleteAnycastIpAddressEntry(ref mibrow), Is.Zero); GetAnycastIpAddressTable(ADDRESS_FAMILY.AF_INET6, out var t3); Assert.That(t3, Has.No.Member(mibrow)); }
public void GetCoffeeCondiments_ReturnCollectionOfCoffeCondimentNamesAsString_WhenInvalidParameterPassed() { // Arrange var testingAssemblyName = typeof(SofiaMenuProvider_Should).Assembly.GetName(); var testingCommonCoffeeNamespace = typeof(FakeEspresso).Namespace; var testingSpecialCoffeeNamespace = typeof(FakeDoppio).Namespace; var condimentsNamespace = typeof(FakeMilk).Namespace; var sofiaMenuProvider = new SofiaMenuProvider( testingAssemblyName, testingCommonCoffeeNamespace, testingSpecialCoffeeNamespace, condimentsNamespace); // Act var coffeeTypesList = sofiaMenuProvider.GetCoffeeCondiments(); // Assert Assert.That(coffeeTypesList, Has.Member(typeof(FakeMilk).Name)); }
public void GetMembers_ByLevel_ReturnListMembersWithCorrectUniqueName() { //Buiding object used during test var mae = new MembersAdomdEngine(); var disco = new DiscoveryRequestFactory().Build( ConnectionStringReader.GetAdomd(), string.Empty, "Adventure Works", "Geography", "Geography", "Country" ); //Call the method to test var actual = mae.GetMembers(disco); //Assertion Assert.That(List.Map(actual).Property("UniqueName"), Has.Member("[Geography].[Geography].[Country].&[Canada]")); Assert.That(List.Map(actual).Property("UniqueName"), Has.Member("[Geography].[Geography].[Country].&[France]")); }
public void It_makes_robust_call_to_find_then_clicks_element_on_underlying_driver() { var element = new StubElement(); driver.StubCss("something.to fill in", element, browserSession); spyRobustWrapper.AlwaysReturnFromRobustly(element); var elementScope = browserSession.FindCss("something.to fill in"); Assert.That(driver.FindCssRequests, Is.Empty, "Finder not called robustly"); elementScope.FillInWith("some filled in stuff"); RunQueryAndCheckTiming(); Assert.That(driver.FindCssRequests.Any(), Is.False, "Scope finder was not deferred"); Assert.That(driver.SetFields.Keys, Has.Member(element)); Assert.That(driver.SetFields[element].Value, Is.EqualTo("some filled in stuff")); }
public void GetPropTest() { using (var i = new ShellItem(testDoc)) { Assert.That(i.Properties.Count, Is.GreaterThan(0)); Assert.That(i.Properties[PROPERTYKEY.System.Author], Has.Member("TestAuthor")); Assert.That(i.Properties[PROPERTYKEY.System.ItemTypeText], Does.StartWith("Microsoft Word")); Assert.That(i.Properties[PROPERTYKEY.System.DateAccessed], Is.TypeOf <FILETIME>()); Assert.That(i.Properties[new PROPERTYKEY()], Is.Null); Assert.That(i.Properties[new PROPERTYKEY(Guid.NewGuid(), 2)], Is.Null); Assert.That(i.Properties["System.Author"], Has.Member("TestAuthor")); Assert.That(i.Properties["DocAuthor"], Has.Member("TestAuthor")); Assert.That(() => i.Properties[null], Throws.Exception); Assert.That(() => i.Properties["Arthur"], Throws.Exception); Assert.That(i.Properties.GetProperty <string>(PROPERTYKEY.System.Company), Is.InstanceOf <string>().And.StartWith("Microsoft")); Assert.That(() => i.Properties.GetProperty <int>(PROPERTYKEY.System.Company), Throws.Exception); } }
public void CanRetrieveReservedWords() { var configuration = TestConfigurationHelper.GetDefaultConfiguration(); var dialect = Dialect.Dialect.GetDialect(configuration.Properties); var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties); connectionHelper.Prepare(); try { var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection); var reserved = metaData.GetReservedWords(); Assert.That(reserved, Is.Not.Empty); Assert.That(reserved, Has.Member("SELECT")); Assert.That(reserved, Has.Member("FROM")); } finally { connectionHelper.Release(); } }
public void creates_table_with_columns() { var tblName = Provider.GetTableName("schema1", "ISP_Test"); if (!Provider.CheckSchemaExists(tblName.Schema)) { Provider.CreateSchema(tblName.Schema); } Assert.That(Provider.CheckTableExists(tblName), Is.False); Assert.That(Provider.GetTableNames(), Has.No.Member(tblName)); // create a blank table with an ID::int column and no keys or constraints Provider.CreateTable(tblName, false, false); Provider.RenameColumn(tblName, "ID", "other_column"); Assert.That(Provider.GetTableColumnNames(tblName), Has.Member("other_column")); Assert.That(Provider.GetTableColumnNames(tblName), Has.No.Member("ID")); }
protected void PrepareInconsistentState_OneMany_ObjectIncluded(out Company company, out IndustrialSector industrialSector) { SetDatabaseModifyable(); company = CreateCompanyInDatabaseAndLoad(); Assert.That(company.IndustrialSector, Is.Null); industrialSector = DomainObjectIDs.IndustrialSector1.GetObject <IndustrialSector> (); SetIndustrialSectorInOtherTransaction(company.ID, industrialSector.ID); // Resolve virtual end point - the database says that company points to industrialSector, but the transaction says it points to null! industrialSector.Companies.EnsureDataComplete(); Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies, Has.Member(company)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); }
public void CanDeserializeIsRequested() { var types = new List <Type>(); var serializer = new BlobSerializerDelegate(obj => null, (d, t) => null, t => { types.Add(t); return(true); }); using (var db = new BlobDatabase(serializer)) { db.CreateTable <ComplexOrder>(); } Assert.That(types, Has.Member(typeof(List <ComplexHistory>))); Assert.That(types, Has.Member(typeof(List <ComplexLine>))); Assert.AreEqual(2, types.Count, "Too many types requested by serializer"); }
public void ObjectLoaded_WithInconsistentForeignKey_OneMany() { SetDatabaseModifyable(); // set up new IndustrialSector object in database with one company var industrialSector = CreateIndustrialSectorInDatabaseAndLoad(); industrialSector.Companies.EnsureDataComplete(); // in parallel transaction, add a second Company to the IndustrialSector var newCompanyID = CreateCompanyAndSetIndustrialSectorInOtherTransaction(industrialSector.ID); Assert.That(industrialSector.Companies.Count, Is.EqualTo(1)); // load Company into this transaction; in the database, the Company has a foreign key to the IndustrialSector var newCompany = newCompanyID.GetObject <Company> (); Assert.That(newCompany.IndustrialSector, Is.SameAs(industrialSector)); Assert.That(industrialSector.Companies, Has.No.Member(newCompany)); Assert.That(industrialSector.Companies.Count, Is.EqualTo(1)); CheckSyncState(industrialSector, s => s.Companies, true); CheckSyncState(newCompany, c => c.IndustrialSector, false); CheckSyncState(industrialSector.Companies[0], c => c.IndustrialSector, true); CheckActionThrows <InvalidOperationException> (newCompany.Delete, "out of sync with the opposite property"); CheckActionThrows <InvalidOperationException> (industrialSector.Delete, "out of sync with the collection property"); CheckActionWorks(() => industrialSector.Companies.RemoveAt(0)); CheckActionWorks(() => industrialSector.Companies.Add(Company.NewObject())); CheckActionThrows <InvalidOperationException> (() => industrialSector.Companies.Add(newCompany), "out of sync with the collection property"); CheckActionThrows <InvalidOperationException> (() => newCompany.IndustrialSector = null, "out of sync with the opposite property "); BidirectionalRelationSyncService.Synchronize(ClientTransaction.Current, RelationEndPointID.Resolve(newCompany, c => c.IndustrialSector)); CheckSyncState(newCompany, c => c.IndustrialSector, true); Assert.That(industrialSector.Companies, Has.Member(newCompany)); CheckActionWorks(() => newCompany.IndustrialSector = null); CheckActionWorks(() => industrialSector.Companies.Add(newCompany)); }
public void Execute_ContentWithTwoGroupableRowAtTheEnd_ContentReduced() { var state = BuildState(); var firstRow = state.TestCaseCollection.Scope.Content.NewRow(); firstRow[0] = "firstCell1"; firstRow[1] = "secondCell1"; firstRow[2] = "thirdCell1"; state.TestCaseCollection.Scope.Content.Rows.Add(firstRow); var secondRow = state.TestCaseCollection.Scope.Content.NewRow(); secondRow[0] = "firstCell2"; secondRow[1] = "secondCell2"; secondRow[2] = "thirdCell2"; state.TestCaseCollection.Scope.Content.Rows.Add(secondRow); var thirdRow = state.TestCaseCollection.Scope.Content.NewRow(); thirdRow[0] = "firstCell2"; thirdRow[1] = "secondCell3"; thirdRow[2] = "thirdCell2"; state.TestCaseCollection.Scope.Content.Rows.Add(thirdRow); state.TestCaseCollection.Scope.Content.AcceptChanges(); var action = new GroupCaseAction(new[] { "secondColumn" }); action.Execute(state); Assert.That(state.TestCaseCollection.Scope.Content.Columns, Has.Count.EqualTo(3)); Assert.That(state.TestCaseCollection.Scope.Variables, Has.Count.EqualTo(3)); Assert.That(state.TestCaseCollection.Scope.Variables, Has.Member("secondColumn")); Assert.That(state.TestCaseCollection.Scope.Content.Columns["secondColumn"].Ordinal, Is.EqualTo(1)); Assert.That(state.TestCaseCollection.Scope.Content.Rows, Has.Count.EqualTo(2)); Assert.That(state.TestCaseCollection.Scope.Content.Rows[0]["secondColumn"], Is.TypeOf <string[]>()); var list = (state.TestCaseCollection.Scope.Content.Rows[1]["secondColumn"] as string[]).ToList(); Assert.That(list, Has.Member("secondCell2")); Assert.That(list, Has.Member("secondCell3")); Assert.That(list, Has.Count.EqualTo(2)); list = (state.TestCaseCollection.Scope.Content.Rows[0]["secondColumn"] as string[]).ToList(); Assert.That(list, Has.Member("secondCell1")); }
public void Commit_InSubTransaction_InconsistentState_OneMany_ObjectIncluded() { Company company; IndustrialSector industrialSector; PrepareInconsistentState_OneMany_ObjectIncluded(out company, out industrialSector); Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies, Has.Member(company)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope()) { Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies.Count, Is.EqualTo(6)); CheckActionThrows <InvalidOperationException> (() => company.IndustrialSector = industrialSector, "out of sync"); company.IndustrialSector = DomainObjectIDs.IndustrialSector2.GetObject <IndustrialSector> (); industrialSector.Companies.Insert(0, DomainObjectIDs.Company2.GetObject <Company> ()); CheckActionThrows <InvalidOperationException> (() => industrialSector.Companies.Remove(company), "out of sync"); Assert.That(company.IndustrialSector, Is.SameAs(DomainObjectIDs.IndustrialSector2.GetObject <IndustrialSector> ())); Assert.That(industrialSector.Companies.Count, Is.EqualTo(7)); ClientTransaction.Current.Commit(); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); Assert.That(company.IndustrialSector, Is.SameAs(DomainObjectIDs.IndustrialSector2.GetObject <IndustrialSector> ())); Assert.That(industrialSector.Companies.Count, Is.EqualTo(7)); } Assert.That(company.IndustrialSector, Is.SameAs(DomainObjectIDs.IndustrialSector2.GetObject <IndustrialSector> ())); Assert.That(industrialSector.Companies.Count, Is.EqualTo(7)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); }
[Test] public void ForEachCompletesIterationsLessThenBreakIndexOf( [Values(Parallelism / 2, Parallelism, Parallelism * 2)] int cancelAt) { T[] sources = TestData <T> .MakeTestArray(_sampleSize); List <T> completed = new List <T>(_sampleSize); _sut = new ParallelCompletion <T, int>(_executor, _localInit, (t, s, l) => { Thread.Sleep(s.CurrentIndex == 0 ? Delays.ShortMillis : 10); if (s.CurrentIndex == cancelAt) { s.Break(); } else { if (!s.ShouldExitCurrentIteration) { lock (completed) completed.Add(t); } else { Assert.That(s.LowestBreakIteration, Is.EqualTo(cancelAt)); Assert.That(s.IsExceptional, Is.False); Assert.That(s.IsStopped, Is.False); } } return(0); }, _localFinally); var result = _sut.ForEach(sources, Parallelism); _localFinally.AssertWasCalled(x => x(0)); Assert.That(result.IsCompleted, Is.False); Assert.That(result.LowestBreakIteration, Is.EqualTo(cancelAt)); Assert.That(completed.Count, Is.GreaterThanOrEqualTo(cancelAt)); Assert.That(completed, Has.Member(sources[0])); ThreadManager.JoinAndVerify(); }
public void InconsistentState_GuaranteedInSubTransaction_OneMany_ObjectIncluded() { Company company; IndustrialSector industrialSector; PrepareInconsistentState_OneMany_ObjectIncluded(out company, out industrialSector); Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies, Has.Member(company)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope()) { Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies, Has.Member(company)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); } CheckActionThrows <InvalidOperationException> (() => industrialSector.Companies.Remove(company), "out of sync"); using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope()) { Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies, Has.Member(company)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); } CheckActionThrows <InvalidOperationException> (() => company.IndustrialSector = industrialSector, "out of sync"); using (ClientTransaction.Current.CreateSubTransaction().EnterDiscardingScope()) { Assert.That(company.IndustrialSector, Is.Null); Assert.That(industrialSector.Companies, Has.Member(company)); CheckSyncState(company, c => c.IndustrialSector, true); CheckSyncState(industrialSector, s => s.Companies, false); } }
public void It_makes_robust_call_to_find_then_click_element_on_underlying_driver() { var element = new StubElement(); var finderCalled = false; driver.StubCss("something.to hover", element); session.Hover(() => { finderCalled = true; return(element); }); Assert.That(finderCalled, Is.False, "Finder not called robustly"); Assert.That(driver.HoveredElements, Is.Empty, "Hover not called robustly"); spyRobustWrapper.DeferredActions.Single()(); Assert.That(finderCalled, Is.True); Assert.That(driver.HoveredElements, Has.Member(element)); }
public void GetMembers_ByHierarchy_ReturnListMembersWithCorrectCaptions() { //Buiding object used during test var mae = new MembersAdomdEngine(); var disco = new DiscoveryRequestFactory().Build( ConnectionStringReader.GetAdomd(), string.Empty, "Adventure Works", "Geography", "Geography", null ); //Call the method to test var actual = mae.GetMembers(disco); //Assertion Assert.That(List.Map(actual).Property("Caption"), Has.Member("All Geographies")); Assert.That(List.Map(actual).Property("Caption"), Has.Member("Canada")); Assert.That(List.Map(actual).Property("Caption"), Has.Member("France")); }
public void GetMembersDax_ByLevel_ReturnListMembersWithCorrectCaptions() { //Buiding object used during test var mae = new MembersAdomdEngine(); var disco = new DiscoveryRequestFactory().Build( ConnectionStringReader.GetAdomdTabular(), string.Empty, "Internet Operation", "Geography", "Geography", "Country Region" ); //Call the method to test var actual = mae.GetMembers(disco); ////Assertion Assert.That(List.Map(actual).Property("Caption"), Has.None.EqualTo("All")); Assert.That(List.Map(actual).Property("Caption"), Has.Member("Canada")); Assert.That(List.Map(actual).Property("Caption"), Has.Member("France")); }
public void Test_Add_Part_Method() { var laptopPart = new LaptopPart("Ssd", 1m); laptop.AddPart(laptopPart); var pcPart = new PCPart("Ram", 1m); PC.AddPart(pcPart); var phonePart = new PhonePart("Mic", 1m); phone.AddPart(phonePart); Assert.AreEqual(1, laptop.Parts.Count); Assert.AreEqual(1, PC.Parts.Count); Assert.AreEqual(1, phone.Parts.Count); var parts = laptop.Parts; Assert.That(parts, Has.Member(laptopPart)); }
public void ValidateUniqueStateCombinations_TwoStateCombinations() { AccessControlTestHelper testHelper = new AccessControlTestHelper(); using (testHelper.Transaction.EnterNonDiscardingScope()) { SecurableClassDefinition orderClass = testHelper.CreateOrderClassDefinition(); StatePropertyDefinition paymentProperty = testHelper.CreatePaymentStateProperty(orderClass); StateCombination paidCombination1 = testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]); StateCombination paidCombination2 = testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.Paid).Name]); testHelper.CreateStateCombination(orderClass, paymentProperty[EnumWrapper.Get(PaymentState.None).Name]); SecurableClassValidationResult result = new SecurableClassValidationResult(); orderClass.ValidateUniqueStateCombinations(result); Assert.That(result.IsValid, Is.False); Assert.That(result.DuplicateStateCombinations.Count, Is.EqualTo(2)); Assert.That(result.DuplicateStateCombinations, Has.Member(paidCombination1)); Assert.That(result.DuplicateStateCombinations, Has.Member(paidCombination2)); } }
public void FindTrashedCourses_WhenCalled_ListOfCoursesWithIsDeletedEqualsTrue() { // arrange var theater = _courses.SingleOrDefault(c => c.Id == 8); _courseRepository.Setup(m => m.Find(It.IsAny <Expression <Func <Course, bool> > >(), It.IsAny <Func <IQueryable <Course>, IOrderedQueryable <Course> > >(), It.IsAny <string>())) .Returns(() => { return(_courses.Where(c => c.IsDeleted == true).OrderBy(c => c.Id)); }); var courseService = new CourseService(_courseRepository.Object); courseService.CourseTypeService = _courseTypeService.Object; // act var result = courseService.FindTrashedCourses(); // assert _courseRepository.Verify(m => m.Find(It.IsAny <Expression <Func <Course, bool> > >(), It.IsAny <Func <IQueryable <Course>, IOrderedQueryable <Course> > >(), It.IsAny <string>())); Assert.That(result, Has.Member(theater)); }
public void RegisterOriginalOppositeEndPoint() { Assert.That(_dataManager.OriginalOppositeEndPoints.ToArray(), Is.Empty); var endPointStub = MockRepository.GenerateStub <IRealObjectEndPoint> (); endPointStub.Stub(stub => stub.GetDomainObjectReference()).Return(_domainObject2); endPointStub.Stub(stub => stub.ObjectID).Return(_domainObject2.ID); Assert.That(_dataManager.CollectionData.ToArray(), Has.No.Member(_domainObject2)); Assert.That(_dataManager.OriginalCollectionData.ToArray(), Has.No.Member(_domainObject2)); Assert.That(_dataManager.OriginalItemsWithoutEndPoints, Has.No.Member(_domainObject2)); _dataManager.RegisterOriginalOppositeEndPoint(endPointStub); Assert.That(_dataManager.HasDataChanged(), Is.False); Assert.That(_dataManager.CollectionData.ToArray(), Has.Member(_domainObject2)); Assert.That(_dataManager.OriginalCollectionData.ToArray(), Has.Member(_domainObject2)); Assert.That(_dataManager.OriginalOppositeEndPoints.ToArray(), Is.EqualTo(new[] { endPointStub })); Assert.That(_dataManager.CurrentOppositeEndPoints.ToArray(), Is.EqualTo(new[] { endPointStub })); }
public void insert_should_insert_at_the_beginning( [Range(0, 5)] int index) { Assume.That(index, Is.GreaterThanOrEqualTo(0)); Assume.That(index, Is.LessThan(initialItems.Count)); var newItem = NewItem(); TestDelegate setter = () => collection.Insert(index, newItem); Assert.That(setter, Throws.Nothing, String.Format("i={0}, count={1}", index, initialItems.Count)); Assert.That(collection, Has.Count.EqualTo(initialItems.Count + 1)); Assert.That(collection, Has.Member(newItem)); Assert.That(collection[index], Is.SameAs(newItem)); AssertCollectionIsChanged(); var expectedItems = new List <TItem>(initialItems); expectedItems.Insert(index, newItem); AssertInvariants(expectedItems); }
public void CreateGetDeleteAnycastIpAddressEntryTest() { var target = new IN6_ADDR(new byte[] { 0xfe, 0x3f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x20, 0x00 }); var mibrow = new MIB_ANYCASTIPADDRESS_ROW(new SOCKADDR_IN6(target, 0), primaryAdapter.Luid); Assert.That(GetAnycastIpAddressTable(ADDRESS_FAMILY.AF_INET6, out var t1), Is.Zero); if (t1.Contains(mibrow)) { Assert.That(DeleteAnycastIpAddressEntry(ref mibrow), Is.Zero); } Assert.That(CreateAnycastIpAddressEntry(ref mibrow), Is.Zero); GetAnycastIpAddressTable(ADDRESS_FAMILY.AF_INET6, out var t2); Assert.That(t2, Has.Member(mibrow)); Assert.That(GetAnycastIpAddressEntry(ref mibrow), Is.Zero); Assert.That(DeleteAnycastIpAddressEntry(ref mibrow), Is.Zero); GetAnycastIpAddressTable(ADDRESS_FAMILY.AF_INET6, out var t3); Assert.That(t3, Has.No.Member(mibrow)); }
private void PerformSuccessfulSearchTest(ResourceId resource, SearchRequest request, FieldCategories fieldType) { var expectedId = new Dictionary <string, ulong>() { [FieldCategories.SystemField.ToString()] = SystemRecord.Data[resource].Id, [FieldCategories.UserField.ToString()] = UserRecord.Data[resource].Id }; var manager = new DefaultManager(); var response = manager.Send <SearchResponse>(request); PrAssert.That(response, PrIs.SuccessfulResponse <SearchResponse>()); PrAssert.That(response.Result.Status, PrIs.EqualTo("OK")); if (response.Result.Total == 0) { PrAssert.That(response.Result.Items, Has.No.Member((int)expectedId[fieldType.ToString()])); } else { PrAssert.That(response.Result.Items, Has.Member((int)expectedId[fieldType.ToString()])); } }
public void BuildContext_SuppressedInheritance() { ClassContext inheritedContext = new ClassContextBuilder(typeof(BaseType2)) .AddMixin(typeof(BT3Mixin1)) .AddComposedInterface(typeof(BT1Mixin2)) .BuildClassContext(); _classBuilder.Clear(); _classBuilder.AddMixins <BT1Mixin1, BT1Mixin2> (); _classBuilder.AddComposedInterfaces <IBT6Mixin1, IBT6Mixin2> (); ClassContext builtContext = _classBuilder.BuildClassContext(new[] { inheritedContext }); Assert.That(builtContext.Mixins.Count, Is.EqualTo(2)); Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin1)), Is.True); Assert.That(builtContext.Mixins.ContainsKey(typeof(BT1Mixin2)), Is.True); Assert.That(builtContext.ComposedInterfaces.Count, Is.EqualTo(2)); Assert.That(builtContext.ComposedInterfaces, Has.Member(typeof(IBT6Mixin1))); Assert.That(builtContext.ComposedInterfaces, Has.Member(typeof(IBT6Mixin2))); }
public void TestAddAndRemove() { var c = new TestClass(); var changedProperties = new List <string>(); _model.PropertyChanged += (o, e) => changedProperties.Add(e.PropertyName); _model.Add(c); Assert.That(_model.Count, Is.EqualTo(1)); Assert.That(_model.IsModified, Is.True); Assert.That(changedProperties, Has.Member("Count")); changedProperties.Clear(); _model.Remove(c); Assert.That(_model.Count, Is.EqualTo(0)); Assert.That(_model.IsModified, Is.False); Assert.That(changedProperties, Has.Member("Count")); }