public void TwentySevenCells_GetAdjacentPointsToCentreCell_SixDirectionsReturned() { //Arrange var point = new MazePoint(1, 1, 1); var size = new MazeSize { Z = 3, Y = 3, X = 3 }; //Act var directions = _movementHelper.AdjacentPoints(point, size).ToList(); //Assert Assert.That(directions.Count, Is.EqualTo(6)); Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Left)); Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Right)); Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Forward)); Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Back)); Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Up)); Assert.That(directions, Has.Exactly(1).EqualTo(Direction.Down)); }
public void EnhancedTouch_CanTrackActiveFingers_FromMultipleTouchscreens() { var screen1 = Touchscreen.current; var screen2 = InputSystem.AddDevice <Touchscreen>(); Assert.That(Touch.fingers, Has.Count.EqualTo(screen1.touches.Count + screen2.touches.Count)); Assert.That(Touch.fingers, Has.Exactly(screen1.touches.Count).With.Property("screen").SameAs(screen1)); Assert.That(Touch.fingers, Has.Exactly(screen2.touches.Count).With.Property("screen").SameAs(screen2)); BeginTouch(1, new Vector2(0.123f, 0.234f), screen: screen1); BeginTouch(1, new Vector2(0.234f, 0.345f), screen: screen2); Assert.That(Touch.activeFingers, Has.Count.EqualTo(2)); Assert.That(Touch.activeFingers, Has.Exactly(1).With.Property("screen").SameAs(screen1).And.With.Property("screenPosition") .EqualTo(new Vector2(0.123f, 0.234f)).Using(Vector2EqualityComparer.Instance)); Assert.That(Touch.activeFingers, Has.Exactly(1).With.Property("screen").SameAs(screen2).And.With.Property("screenPosition") .EqualTo(new Vector2(0.234f, 0.345f)).Using(Vector2EqualityComparer.Instance)); }
public void Boolean_literal_stored_in_bool_succeeds() { var syntax = new BooleanLiteralSyntax(true, default); var method = new CompiledMethod("Test::Method"); var builder = new BasicBlockGraphBuilder().GetInitialBlockBuilder(); var nameResolver = new TestingResolver(new ScopedVariableMap()); var diagnostics = new TestingDiagnosticSink(); var localIndex = ExpressionCompiler.TryCompileExpression( syntax, SimpleType.Bool, method, builder, nameResolver, diagnostics); Assert.That(localIndex, Is.EqualTo(0)); Assert.That(diagnostics.Diagnostics, Is.Empty); Assert.That(method.Values, Has.Exactly(1).Items); var local = method.Values[0]; Assert.That(local.Type, Is.EqualTo(SimpleType.Bool)); AssertSingleLoad(builder, localIndex, true); }
public void Two_attributes_without_parameters() { const string source = @"namespace Test; [Attribute1] [Attribute2] private void Function() {}"; var syntaxTree = ParseSourceWithoutDiagnostics(source); Assert.That(syntaxTree.Functions, Has.Exactly(1).Items); var function = syntaxTree.Functions[0]; Assert.That(function.Attributes, Has.Exactly(2).Items); Assert.That(function.Attributes[0].Name, Is.EqualTo("Attribute1")); Assert.That(function.Attributes[0].Position.Line, Is.EqualTo(2)); Assert.That(function.Attributes[0].Parameters, Is.Empty); Assert.That(function.Attributes[1].Name, Is.EqualTo("Attribute2")); Assert.That(function.Attributes[1].Position.Line, Is.EqualTo(3)); Assert.That(function.Attributes[1].Parameters, Is.Empty); Assert.That(function.Position.Line, Is.EqualTo(4)); }
public IEnumerator DirectInteractorCanHoverInteractable() { var manager = TestUtilities.CreateInteractionManager(); var interactable = TestUtilities.CreateGrabInteractable(); var directInteractor = TestUtilities.CreateDirectInteractor(); yield return(new WaitForFixedUpdate()); yield return(null); var validTargets = new List <XRBaseInteractable>(); manager.GetValidTargets(directInteractor, validTargets); Assert.That(validTargets, Has.Exactly(1).EqualTo(interactable)); var hoverTargetList = new List <XRBaseInteractable>(); directInteractor.GetHoverTargets(hoverTargetList); Assert.That(hoverTargetList, Has.Exactly(1).EqualTo(interactable)); }
public async Task Subscribe_is_persistent() { var queue = new FakeStorageQueue(); var messageType = new MessageType(typeof(SomeMessage)); var storage = CreateAndInit(queue); await storage.Subscribe(new Subscriber("sub1", null), messageType, new ContextBag()); await storage.Subscribe(new Subscriber("sub2", "endpointA"), messageType, new ContextBag()); var storedMessages = queue.GetAllMessages().ToArray(); Assert.That(storedMessages.Length, Is.EqualTo(2)); storage = CreateAndInit(queue); var subscribers = (await storage.GetSubscriberAddressesForMessage(new[] { messageType }, new ContextBag())).ToArray(); Assert.That(subscribers, Has.Exactly(1).Matches <Subscriber>(s => s.TransportAddress == "sub1" && s.Endpoint == null)); Assert.That(subscribers, Has.Exactly(1).Matches <Subscriber>(s => s.TransportAddress == "sub2" && s.Endpoint == "endpointA")); }
public void ReturnComparisonForFirstProduct_WithPartialKnownExpectedValues() { var products = new List <LoanProduct> { new LoanProduct(1, "a", 1), new LoanProduct(2, "b", 2), new LoanProduct(3, "c", 3) }; var sut = new ProductComparer(new LoanAmount("USD", 200_000m), products); List <MonthlyRepaymentComparison> comparisons = sut.CompareMonthlyRepayments(new LoanTerm(30)); Assert.That(comparisons, Has.Exactly(1) .Matches <MonthlyRepaymentComparison>( item => item.ProductName == "a" && item.InterestRate == 1 && item.MonthlyRepayment > 0)); }
public void Devices_CanCreateOnScreenButton() { var gameObject = new GameObject(); var button = gameObject.AddComponent <OnScreenButton>(); button.controlPath = "/<Keyboard>/a"; Assert.That(InputSystem.devices, Has.Exactly(1).InstanceOf <Keyboard>()); var keyboard = (Keyboard)InputSystem.devices.FirstOrDefault(x => x is Keyboard); Assert.That(keyboard.aKey.isPressed, Is.False); button.OnPointerDown(null); InputSystem.Update(); Assert.That(keyboard.aKey.isPressed, Is.True); button.OnPointerUp(null); InputSystem.Update(); Assert.That(keyboard.aKey.isPressed, Is.False); }
public void Factory_creates_valid_horizontal_battleship() { var randomNumberGenerator = new DeterministicModuloRandomNumberGenerator(); var factory = new BattleshipFactory(randomNumberGenerator); var ship = factory.CreateAt(new Position(3, 3)); var expectedPositions = new[] { new Position(3, 3), new Position(4, 3), new Position(5, 3), new Position(6, 3), new Position(7, 3), }; Assert.That(ship.Positions, Has.Exactly(5).Items); Assert.That(ship.Positions, Is.EquivalentTo(expectedPositions)); }
public void PickLeaderTest([Range(1, 10)] int n) { Player[] players = new Player[n]; for (int i = 0; i < n; i++) { players[i] = new Player { ID = i }; } for (int i = 0; i < n; i++) { gm.PickLeader(players); } Assert.That(players, Has.Exactly(1).Property("IsLeader").True); Assert.That(players[n - 1].IsLeader, Is.True); gm.PickLeader(players); Assert.That(players[0].IsLeader, Is.True); }
public void GetUnitializedFields_WithMultipleValidCtors_MissingInitInMultipleCtors() { var(semantic, syntax) = CompiledSourceFileProvider.CompileClass(string.Format(c_multipleConstructorTemplate, "field1 = \"hello\"; \r\n" + "field3 = \"\"; \r\n", "field1 = \"hello\"; \r\n" + "field3 = \"\"; \r\n", "field1 = \"hello\"; \r\n" + "field2 = \"\"; \r\n")); var(f1, f2, f3) = GetTestFields(syntax); var constructorInitFilter = new ConstructorInitializationFilter(syntax, new[] { f1, f2, f3 }); var uninitialized = constructorInitFilter.GetUnitializedFields(); Assert.That(uninitialized, Has.Exactly(2).Items); Assert.That(uninitialized, Is.EquivalentTo(new[] { f2, f3 })); }
public void Compile_exits_if_main_module_provides_no_entry_point() { const string source1 = @"namespace Test;"; var sourceProvider = new TestingSourceFileProvider(); sourceProvider.Add(".", "main.cle", source1); using (var outputProvider = new TestingOutputFileProvider()) { var result = CompilerDriver.Compile(new CompilationOptions("."), sourceProvider, outputProvider); Assert.That(result.FailedCount, Is.EqualTo(1)); Assert.That(result.ModuleCount, Is.EqualTo(1)); Assert.That(result.SucceededCount, Is.EqualTo(0)); Assert.That(result.Diagnostics, Has.Exactly(1).Items); Assert.That(result.Diagnostics[0].Code, Is.EqualTo(DiagnosticCode.NoEntryPointProvided)); Assert.That(result.Diagnostics[0].Module, Is.EqualTo(".")); } }
public void VerifyGetAllInstancesReturnsCorrectInstances() { string firstStringInstance = nameof(firstStringInstance); string secondStringInstance = nameof(secondStringInstance); var container = new CompositionContainer(); container.ComposeExportedValue(firstStringInstance); container.ComposeExportedValue(secondStringInstance); container.ComposeExportedValue(typeof(string)); container.ComposeExportedValue(Math.PI); var serviceLocator = new MefServiceLocator(container); var instances = serviceLocator.GetAllInstances <string>(); Assert.That(instances.ToList(), Has.Count.EqualTo(2)); Assert.That(instances, Has.Exactly(1).EqualTo(firstStringInstance)); Assert.That(instances, Has.Exactly(1).EqualTo(secondStringInstance)); }
public void ShouldMap() { using (var transaction = Session.BeginTransaction()) { var createdUser = new User { GooglePlusId = "some id?" }; Session.Save(createdUser); var playlist2 = new Playlist("users second playlist") { User = createdUser, Sequence = 200, }; var playlistItem = new PlaylistItem { Playlist = playlist2, Sequence = 200, }; playlist2.AddItem(playlistItem); var playlistId = Session.Save(playlist2); Session.Flush(); Session.Clear(); var savedPlaylist = Session.Get <Playlist>(playlistId); Assert.That(savedPlaylist.Title, Is.EqualTo("users second playlist")); Assert.That(savedPlaylist.Id, Is.Not.EqualTo(Guid.Empty)); Assert.That(savedPlaylist.Sequence, Is.EqualTo(200)); Assert.That(savedPlaylist.Items, Has.Exactly(1).EqualTo(playlistItem)); transaction.Rollback(); } }
public void Grid4X4WithFourColourPairs() { // Arrange var startCoordsBlue = CoordsFactory.GetCoords(0, 3); var endCoordsBlue = CoordsFactory.GetCoords(3, 3); // "BOOB" // " RR " // " GG " // " " var colourPairBlue = new ColourPair(startCoordsBlue, endCoordsBlue, DotColours.Blue); var grid = new Grid(4, colourPairBlue, new ColourPair(CoordsFactory.GetCoords(1, 3), CoordsFactory.GetCoords(2, 3), DotColours.Orange), new ColourPair(CoordsFactory.GetCoords(1, 2), CoordsFactory.GetCoords(2, 2), DotColours.Red), new ColourPair(CoordsFactory.GetCoords(1, 1), CoordsFactory.GetCoords(2, 1), DotColours.Green)); var expectedCoordsList = new[] { startCoordsBlue, CoordsFactory.GetCoords(0, 2), CoordsFactory.GetCoords(0, 1), CoordsFactory.GetCoords(0, 0), CoordsFactory.GetCoords(1, 0), CoordsFactory.GetCoords(2, 0), CoordsFactory.GetCoords(3, 0), CoordsFactory.GetCoords(3, 1), CoordsFactory.GetCoords(3, 2), endCoordsBlue }; // Act var pathFinder = new PathFinder(CancellationToken.None); var initialPathsBlue = PathFinder.InitialPaths(colourPairBlue); var paths = pathFinder.FindAllPaths(grid, endCoordsBlue, initialPathsBlue, 10); // Assert Assert.That(paths.Count(), Is.EqualTo(1)); Assert.That(paths, Has.All.Matches <Path>(p => p.IsActive)); Assert.That(paths, Has.Exactly(1).Matches <Path>(p => p.CoordsList.SequenceEqual(expectedCoordsList))); }
public void ReverseRelation_Generic() { Order order = new Order { Customer = new Customer { Name = "A" }, // OrderItems = DB.DataSet<OrderItem>() }; DB.LoadRelation(() => order.OrderItems); order.OrderItems.Add(new OrderItem() { Description = "X" }); order.OrderItems.Add(new OrderItem() { Description = "X" }); order.OrderItems.Add(new OrderItem() { Description = "X" }); order.OrderItems.Add(new OrderItem() { Description = "X" }); order.OrderItems.Add(new OrderItem() { Description = "X" }); var originalOrder = order; DB.Orders.Insert(order, o => o.Customer, o => o.OrderItems); order = DB.Orders.Read(originalOrder.OrderID, o => o.OrderItems); Assert.That(order.OrderItems, Has.Exactly(5).Items.And.All.Property(nameof(OrderItem.Order)).SameAs(order)); }
public async Task UpdateInfoAsync() { // already registered user with outdated info var oldUser = await MakeUserAsync("old username", u => { u.Email = "*****@*****.**"; u.Language = LanguageType.Chinese; u.DiscordConnection = new DbUserDiscordConnection { Id = 12345, Discriminator = 4321, Email = "*****@*****.**" }; }); var handler = ActivatorUtilities.CreateInstance <DiscordOAuthHandler>(Services, _clientFactory); var user = await handler.GetOrCreateUserAsync("test code"); // should not create new user Assert.That(user.Id, Is.EqualTo(oldUser.Id)); // should update user with new info Assert.That(user.Username, Is.EqualTo("phosphene47")); Assert.That(user.Email, Is.EqualTo("*****@*****.**")); Assert.That(user.Language, Is.EqualTo(LanguageType.Japanese)); Assert.That(user.DiscordConnection.Id, Is.EqualTo(12345)); Assert.That(user.DiscordConnection.Discriminator, Is.EqualTo(1234)); Assert.That(user.DiscordConnection.Email, Is.EqualTo("*****@*****.**")); // should not create snapshot var snapshots = Services.GetService <ISnapshotService>(); var snapshotSearch = await snapshots.SearchAsync(ObjectType.User, new SnapshotQuery { TargetId = user.Id, Limit = 10 }); Assert.That(snapshotSearch.Items, Has.Exactly(0).Items); }
public void Should_get_chat_logs_in_room() { var recent_log = new ChatLogBuilder() .With(l => l.Id, 1) .With(l => l.Message, "Hello chat from 15 minutes ago") .With(l => l.Timestamp, DateTime.UtcNow.AddMinutes(-15)) .With(l => l.Room, "global") .BuildAndSave(); new ChatLogBuilder() .With(l => l.Id, 2) .With(l => l.Message, "This is an old message") .With(l => l.Timestamp, DateTime.UtcNow.AddHours(-3)) .With(l => l.Room, "global") .BuildAndSave(); new ChatLogBuilder() .With(l => l.Id, 3) .With(l => l.Message, "This is an old message") .With(l => l.Timestamp, DateTime.UtcNow.AddHours(-3)) .With(l => l.Room, "elsewhere") .BuildAndSave(); var less_recent_log = new ChatLogBuilder() .With(l => l.Id, 4) .With(l => l.Message, "Hello chat from 45 minutes ago") .With(l => l.Timestamp, DateTime.UtcNow.AddMinutes(-45)) .With(l => l.Room, "global") .BuildAndSave(); var logs = DomainRegistry.Repository.Find(new GetChatLogs { Room = "global", Filter = "lasth" }).ToArray(); Assert.That(logs, Has.Exactly(2).Items); Assert.That(logs[0].Id, Is.EqualTo(less_recent_log.Id)); Assert.That(logs[0].Message, Is.EqualTo("Hello chat from 45 minutes ago")); Assert.That(logs[1].Id, Is.EqualTo(recent_log.Id)); }
public void Can_Update_Cart() { // Arrange // - create a mock repository Mock <IStoreRepository> mockRepo = new Mock <IStoreRepository>(); mockRepo.Setup(m => m.Products).Returns((new Product[] { new Product { ProductID = 1, Name = "P1" } }).AsQueryable <Product>()); Cart testCart = new Cart(); // Action CartModel cartModel = new CartModel(mockRepo.Object, testCart); cartModel.OnPost(1, "myUrl"); //Assert Assert.That(testCart.Lines, Has.Exactly(1).Items); Assert.AreEqual("P1", testCart.Lines.First().Product.Name); Assert.AreEqual(1, testCart.Lines.First().Quantity); }
public void ComplexType() { var obj = new TestComplexType(); ModelSanitizer.Sanitize(obj); Assert.That(obj, Is.Not.Null); Assert.That(obj.String, Is.EqualTo("sanitize me")); Assert.That(obj.IgnoreMe, Is.EqualTo(" ignored ")); Assert.That(obj.StringSet, Is.EqualTo(new SortedSet <string> { "hello" })); Assert.That(obj.Nested, Has.Exactly(2).Items); Assert.That(obj.Nested[0].Name, Is.EqualTo("one")); Assert.That(obj.Nested[0].Dict, Is.Null); Assert.That(obj.Nested[1].Name, Is.EqualTo("two")); Assert.That(obj.Nested[1].Dict, Has.Exactly(1).Items); Assert.That(obj.Nested[1].Dict["three"].Name, Is.EqualTo("three")); }
public void should_return_base_forms() { new FormSourceBuilder() .With(u => u.FriendlyName, "Regular Guy") .BuildAndSave(); new FormSourceBuilder() .With(u => u.FriendlyName, "Regular Girl") .BuildAndSave(); new FormSourceBuilder() .With(u => u.FriendlyName, "Is A Big Fat Troll") .BuildAndSave(); var forms = DomainRegistry.Repository.Find(new GetBaseForms()).ToList(); Assert.That(forms, Has.Exactly(2).Items); Assert.That(forms.ElementAt(0).FriendlyName, Is.EqualTo("Regular Guy")); Assert.That(forms.ElementAt(1).FriendlyName, Is.EqualTo("Regular Girl")); }
public void GetAssertionsToPerform_returns_correct_specs_for_two_capabilities(CapabilityAssertionSpecProvider sut, string fooVal, int barVal, int bazVal) { var result = sut.GetAssertionsToPerform(MethodWith2RequiredCapabilities, new object[] { fooVal, barVal, bazVal }); Assert.That(result, Has.Exactly(1).Matches <CapabilitiesAssertionSpec>(x => Equals(x.CapabilityAttribute.RequiredCapability, SampleCapability.Three) && x.ParameterName == "foo" && Equals(x.ParameterValue, fooVal)), "A spec is returned for parameter 'foo' with correct values"); Assert.That(result, Has.Exactly(1).Matches <CapabilitiesAssertionSpec>(x => Equals(x.CapabilityAttribute.RequiredCapability, SampleCapability.Two) && x.ParameterName == "baz" && Equals(x.ParameterValue, bazVal)), "A spec is returned for parameter 'baz' with correct values"); Assert.That(result, Has.None.Matches <CapabilitiesAssertionSpec>(x => x.ParameterName == "bar"), "A spec is not returned for parameter 'bar' because it is not decorated with the attribute"); }
public void TestObjectDeleting() { RunAsync(async delegate { // Create new object var obj1 = await DataStore.PutAsync(new WorkspaceData() { Name = "Test", }); // Delete it var success = await DataStore.DeleteAsync(obj1); Assert.IsTrue(success, "Object was not deleted."); // Verify that the message about object delete was delivered Assert.That(messages, Has.Count.EqualTo(2)); Assert.That(messages, Has.Exactly(1) .Matches <DataChangeMessage> (msg => msg.Action == DataAction.Put && obj1.Matches(msg.Data))); Assert.That(messages, Has.Exactly(1) .Matches <DataChangeMessage> (msg => msg.Action == DataAction.Delete && obj1.Matches(msg.Data))); }); }
public void TestTransaction() { RunAsync(async delegate { await DataStore.ExecuteInTransactionAsync((ctx) => { var obj1 = ctx.Put(new WorkspaceData() { Name = "Test", }); var obj2 = ctx.Connection.Get <WorkspaceData> (obj1.Id); Assert.IsNotNull(obj2); Assert.AreEqual(obj1.Id, obj2.Id); Assert.AreEqual(obj1.Name, obj2.Name); }); // Verify messages Assert.That(messages, Has.Count.EqualTo(1)); Assert.That(messages, Has.Exactly(1) .Matches <DataChangeMessage> ((msg) => msg.Action == DataAction.Put)); }); }
public void Devices_SupportsXInputDevicesOnPlatform(string product, string manufacturer, string interfaceName, string layoutName) { var description = new InputDeviceDescription { interfaceName = interfaceName, product = product, manufacturer = manufacturer }; InputDevice device = null; Assert.That(() => device = InputSystem.AddDevice(description), Throws.Nothing); using (var matches = InputSystem.FindControls(string.Format("/<{0}>", layoutName))) Assert.That(matches, Has.Exactly(1).SameAs(device)); Assert.That(device.name, Is.EqualTo(layoutName)); Assert.That(device.description.manufacturer, Is.EqualTo(manufacturer)); Assert.That(device.description.interfaceName, Is.EqualTo(interfaceName)); Assert.That(device.description.product, Is.EqualTo(product)); }
public void GetInspectingEntities() { EventLogSettings eventLogSettings; eventLogSettings = Entity.Get <EventLogSettings>(ForceSecurityTraceContext.EventLogSettingsAlias, true); Assert.That(eventLogSettings, Is.Not.Null); eventLogSettings.InspectSecurityChecksOnResource.Add(eventLogSettings.As <Resource>()); eventLogSettings.Save(); Thread.Sleep(new TimeSpan(ForceSecurityTraceContext.TicksToWaitBeforeRefreshing)); Assert.That( ForceSecurityTraceContext.GetInspectingEntities(), Has.Exactly(1).EqualTo(eventLogSettings.Id)); eventLogSettings.InspectSecurityChecksOnResource.Clear( ); eventLogSettings.Save( ); Thread.Sleep(new TimeSpan(ForceSecurityTraceContext.TicksToWaitBeforeRefreshing)); }
public void ManualCreation() { //arrange var sut = new EmailMessageBuffer(); EmailMessage message = new EmailMessage( It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>(), It.IsAny <string>()) { Subject = "Hi" }; //act sut.Add(message); //arrange Assert.That(sut.Emails, Has.Exactly(1).Items); }
public void customer_is_added_depending_on_validation_result() { var validator = Mock.Of <ICustomerValidator>(v => v.Validate(StartsWithJ)); var customerRepository = new CustomerRepository(validator); var john = Mock.Of <ICustomer>(customer => customer.FirstName == "John"); var james = Mock.Of <ICustomer>(customer => customer.FirstName == "james"); var ken = Mock.Of <ICustomer>(customer => customer.FirstName == "Ken"); customerRepository.Add(john); customerRepository.Add(james); customerRepository.Add(ken); Assert.That(customerRepository.AllCustomers, Has.Exactly(1).Matches <ICustomer>(customer => customer.FirstName == "John")); }
public void ValidationExtensions_Validate_Object_ReturnValidationResultWithNoSuccessAndEror() { var objectToValidate = new { }; var validationRules = Substitute.For <List <IValidationRule <dynamic> > >(); var validator = Substitute.For <Validator <dynamic> >(validationRules); validator.Validate(objectToValidate).Returns((ValidationResult) => { var result = new ValidationResult(); result.Success = false; result.AddError("Validation error message"); return(result); }); var actual = objectToValidate.Validate(validator); Assert.IsNotNull(actual); Assert.IsFalse(actual.Success); Assert.IsNotNull(actual.Errors); Assert.That(actual.Errors, Has.Exactly(1).EqualTo("Validation error message")); }
public void ReverseRelation_DataSet() { Customer customer = new Customer() { Name = "A" }; DB.Customers.Insert(customer); for (int i = 0; i < 5; i++) { DB.Orders.Insert(new Order() { CustomerID = customer.CustomerID }); } customer = DB.Customers.Read(customer.CustomerID); Assert.That(customer.Orders, Has.Exactly(5).Items.And.All.Property("Customer").SameAs(customer)); }