Assertions.assertThat(content.get(fieldName)).as(fieldName + " is present in the actual content").isNull(); return; Assertions.assertThat(actualValue).as(fieldName + " is not present in the actual content").isNotNull(); Assertions.assertThat(value).as("Incorrect value type for " + fieldName).isInstanceOf(List.class); final List<?> actualValueList = (List<?>)actualValue; final List<?> valueList = (List<?>)value; Assertions.assertThat(actualValue.getClass()).as("Incorrect value type for " + fieldName).isEqualTo(value.getClass()); Assertions.assertThat(actualValue).as("Values don't match for " + fieldName).isEqualTo(value);
private void assertStruct(final Struct expectedStruct, final Struct actualStruct) { expectedStruct.schema().fields().stream().forEach(field -> { final Object expectedValue = expectedStruct.get(field); if (expectedValue == null) { Assertions.assertThat(actualStruct.get(field.name())).as(fieldName + " is present in the actual content").isNull(); return; } final Object actualValue = actualStruct.get(field.name()); Assertions.assertThat(actualValue).as("No value found for " + fieldName).isNotNull(); Assertions.assertThat(actualValue.getClass()).as("Incorrect value type for " + fieldName).isEqualTo(expectedValue.getClass()); if (actualValue instanceof byte[]) { Assertions.assertThat(expectedValue).as("Array is not expected for " + fieldName).isInstanceOf(byte[].class); Assertions.assertThat((byte[]) actualValue).as("Values don't match for " + fieldName).isEqualTo((byte[]) expectedValue); } else if (actualValue instanceof Struct) { assertStruct((Struct)expectedValue, (Struct)actualValue); } else { Assertions.assertThat(actualValue).as("Values don't match for " + fieldName).isEqualTo(expectedValue); } }); }
private void assertSchema(Struct content) { if (schema == null) { return; } Schema schema = content.schema(); Field field = schema.field(fieldName); Assertions.assertThat(field).as(fieldName + " not found in schema " + schema).isNotNull(); VerifyRecord.assertConnectSchemasAreEqual(field.name(), field.schema(), this.schema); } }
for (Iterator<SourceRecord> it = records.iterator(); it.hasNext();) { SourceRecord record = it.next(); assertThat(record.sourceOffset().get("snapshot")).as("Snapshot phase").isEqualTo(true); if (it.hasNext()) { assertThat(record.sourceOffset().get("snapshot_completed")).as("Snapshot in progress").isEqualTo(false); assertThat(record.sourceOffset().get("snapshot_completed")).as("Snapshot completed").isEqualTo(true); assertNull(valueB.get("before")); assertThat(recordA.sourceOffset().get("snapshot")).as("Streaming phase").isNull(); assertThat(recordA.sourceOffset().get("snapshot_completed")).as("Streaming phase").isNull(); assertThat(recordA.sourceOffset().get("change_lsn")).as("LSN present").isNotNull(); assertThat(recordB.sourceOffset().get("snapshot")).as("Streaming phase").isNull(); assertThat(recordB.sourceOffset().get("snapshot_completed")).as("Streaming phase").isNull(); assertThat(recordB.sourceOffset().get("change_lsn")).as("LSN present").isNotNull();
.as("result of getThriftFieldIsLegacyId on " + f) .isEqualTo(expected);
public static JMenuItemFixture menuItemWithPath( Robot robot, Container root, String... path ) { ComponentMatcher m = new JMenuItemMatcher(path); Component item = robot.finder().find(root, m); assertThat(item).as(format(item)).isInstanceOf(JMenuItem.class); return new JMenuItemFixture(robot, (JMenuItem) item); }
@Test public void testThereAreNoConflicts() { Number rubyNextValue = nextValue( Ruby.class ); Number pearlNextValue = nextValue( Pearl.class ); assertThat( rubyNextValue ).as( "Should be the same because the generators are stored in different tables, even if they have the same pkColumnName" ) .isEqualTo( pearlNextValue ); }
@Test public void testMergeableRequiredness() { ThriftStructMetadata metadata = new ThriftStructMetadataBuilder(new ThriftCatalog(), MergeableRequiredness.class).build(); assertThat(metadata.getField(1).getRequiredness()) .as("requiredness of field 'foo'") .isEqualTo(Requiredness.OPTIONAL); }
@Test public void testPersistWithEmbeddedList() throws Exception { final Session session = openSession(); Transaction transaction = session.beginTransaction(); List<String> alternativePhones = Arrays.asList( "+1-222-555-0222", "+1-202-555-0333" ); AccountWithPhone account = new AccountWithPhone( "2", "Mobile account 2" ); account.setPhoneNumber( new PhoneNumber( "+1-222-555-0111", alternativePhones ) ); session.persist( account ); transaction.commit(); session.clear(); transaction = session.beginTransaction(); AccountWithPhone loadedUser = (AccountWithPhone) session.get( AccountWithPhone.class, account.getId() ); assertThat( loadedUser ).as( "Cannot load persisted object with nested embeddables" ).isNotNull(); assertThat( loadedUser.getPhoneNumber() ).isNotNull(); assertThat( loadedUser.getPhoneNumber().getMain() ).isEqualTo( account.getPhoneNumber().getMain() ); assertThat( loadedUser.getPhoneNumber().getAlternatives() ).containsOnly( alternativePhones.toArray( new Object[alternativePhones.size()] ) ); session.delete( loadedUser ); transaction.commit(); session.clear(); transaction = session.beginTransaction(); assertThat( session.get( AccountWithPhone.class, account.getId() ) ).isNull(); transaction.commit(); session.close(); }
@Test public void testPersistEmbeddedWithNullEmbeddedList() throws Exception { final Session session = openSession(); Transaction transaction = session.beginTransaction(); AccountWithPhone wombatSoftware = new AccountWithPhone( "1", "Mobile account 1" ); wombatSoftware.setPhoneNumber( null ); session.persist( wombatSoftware ); transaction.commit(); session.clear(); transaction = session.beginTransaction(); AccountWithPhone loadedUser = (AccountWithPhone) session.get( AccountWithPhone.class, wombatSoftware.getId() ); assertThat( loadedUser ).as( "Cannot load persisted object with nested embeddables" ).isNotNull(); // It is not null because of the list of elements assertThat( loadedUser.getPhoneNumber() ).isNotNull(); assertThat( loadedUser.getPhoneNumber().getMain() ).isNull(); assertThat( loadedUser.getPhoneNumber().getAlternatives() ).isEmpty(); session.delete( loadedUser ); transaction.commit(); session.clear(); transaction = session.beginTransaction(); assertThat( session.get( AccountWithPhone.class, wombatSoftware.getId() ) ).isNull(); transaction.commit(); session.close(); }
assertThat( loadedAccount ).as( "Cannot load persisted object with nested embeddables" ).isNotNull(); assertThat( loadedAccount.getHomeAddress() ).isNotNull(); assertThat( loadedAccount.getHomeAddress().getType() ).isNull(); assertThat( loadedAccount ).as( "Cannot load persisted object with nested embeddables" ).isNotNull(); assertThat( loadedAccount.getHomeAddress() ).isNull(); session.delete( loadedAccount );
@Test public void testPersistWithListEmbeddedInNestedComponent() throws Exception { final Session session = openSession(); Transaction transaction = session.beginTransaction(); Order order = new Order( "order-1", "Telescope", new ShippingAddress( new PhoneNumber( "+1-222-555-0111", Arrays.asList( "+1-222-555-0222", "+1-202-555-0333" ) ), "Planet road 68" ) ); session.persist( order ); transaction.commit(); session.clear(); transaction = session.beginTransaction(); Order loadedOrder = (Order) session.get( Order.class, "order-1" ); assertThat( loadedOrder ).as( "Cannot load persisted object with nested embeddables" ).isNotNull(); assertThat( loadedOrder.getShippingAddress() ).isNotNull(); assertThat( loadedOrder.getShippingAddress().getPhone() ).isNotNull(); assertThat( loadedOrder.getShippingAddress().getPhone().getMain() ).isEqualTo( "+1-222-555-0111" ); assertThat( loadedOrder.getShippingAddress().getPhone().getAlternatives() ).containsOnly( "+1-222-555-0222", "+1-202-555-0333" ); session.delete( loadedOrder ); transaction.commit(); session.clear(); transaction = session.beginTransaction(); assertThat( session.get( Order.class, "order-1" ) ).isNull(); transaction.commit(); session.close(); }
assertThat( loadedAccount ).as( "Cannot load persisted object" ).isNotNull(); final Address loadedAddress = loadedAccount.getHomeAddress(); assertThat( loadedAddress ).as( "Embeddable should not be null" ).isNotNull(); assertThat( loadedAddress.getCity() ).as( "persist and load fails for embeddable" ).isEqualTo( address.getCity() ); assertThat( loadedAddress.getZipCode() ).as( "@Column support for embeddable does not work" ).isEqualTo( address.getZipCode() );
assertThat( loadedAccount ).as( "Cannot load persisted object with nested embeddables which are null" ).isNotNull(); assertThat( loadedAccount.getHomeAddress() ).isNull(); assertThat( loadedAccount ).as( "Cannot load persisted object with nested embeddables" ).isNotNull(); assertThat( loadedAccount.getHomeAddress() ).isNotNull(); assertThat( loadedAccount.getHomeAddress().getCity() ).isEqualTo( "Lima" );
@Test public void testOrderedList() throws Exception { father.getOrderedChildren().add( luke ); father.getOrderedChildren().add( null ); father.getOrderedChildren().add( leia ); inTransaction( session -> { session.persist( luke ); session.persist( leia ); session.persist( father ); } ); inTransaction( session -> { father = (Father) session.get( Father.class, father.getId() ); assertThat( father.getOrderedChildren() ) .as( "List should have 3 elements" ) .hasSize( 3 ); assertThat( father.getOrderedChildren().get( 0 ).getName() ) .as( "Luke should be first" ) .isEqualTo( luke.getName() ); assertThat( father.getOrderedChildren().get( 1 ) ) .as( "Second born should be null" ) .isNull(); assertThat( father.getOrderedChildren().get( 2 ).getName() ) .as( "Leia should be third" ) .isEqualTo( leia.getName() ); } ); }
assertThat( loadedAccount ).as( "Cannot load persisted object" ).isNotNull(); assertThat( loadedAccount.getAddresses() ).onProperty( "city" ).containsOnly( "Paris", "Rome" ); assertThat( loadedAccount.getAddresses() ).onProperty( "zipCode" ).containsOnly( "75007", "00184" );