Examples with SingularAttributeImpl org.eclipse.persistence.internal.jpa.metamodel.SingularAttributeImpl used on opensource projects

Example 1 with SingularAttributeImpl

use of org.eclipse.persistence.internal.jpa.metamodel.SingularAttributeImpl in project eclipselink by eclipse-ee4j.

the class AdvancedJPAJunitTest method testMetamodelMinimalSanityTest.

/**
 * This test performs minimal sanity testing on the advanced JPA model
 * in order to verify metamodel creation.<p>
 * See the metamodel test package suite for full regression tests.
 * See SVN rev# 5124
 * http://fisheye2.atlassian.com/changelog/~author=mobrien/eclipselink/?cs=5124
 */
public void testMetamodelMinimalSanityTest() {
    EntityManager em = createEntityManager();
    // pre-clear metamodel to enable test reentry (SE only - not EE)
    if (!isOnServer()) {
        ((EntityManagerFactoryDelegate) em.getEntityManagerFactory()).setMetamodel(null);
    }
    Metamodel metamodel = em.getMetamodel();
    // get declared attributes
    EntityType<LargeProject> entityLargeProject = metamodel.entity(LargeProject.class);
    Set<Attribute<LargeProject, ?>> declaredAttributes = entityLargeProject.getDeclaredAttributes();
    // instead of a assertEquals(1, size) for future compatibility with changes to Buyer
    assertTrue(declaredAttributes.size() > 0);
    // check that getDeclaredAttribute and getDeclaredAttributes return the same attribute
    Attribute<LargeProject, ?> budgetAttribute = entityLargeProject.getDeclaredAttribute("budget");
    assertNotNull(budgetAttribute);
    Attribute<LargeProject, ?> budgetSingularAttribute = entityLargeProject.getDeclaredSingularAttribute("budget");
    assertNotNull(budgetSingularAttribute);
    assertEquals(budgetSingularAttribute, budgetAttribute);
    assertTrue(declaredAttributes.contains(budgetSingularAttribute));
    // check the type
    Class<?> budgetClass = budgetSingularAttribute.getJavaType();
    // Verify whether we expect a boxed class or not
    assertEquals(double.class, budgetClass);
    // assertEquals(Double.class, budgetClass);
    // Test LargeProject.budget.buyingDays
    // Check an EnumSet on an Entity
    EntityType<Buyer> entityBuyer = metamodel.entity(Buyer.class);
    // public enum Weekdays { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY }
    // private EnumSet<Weekdays> buyingDays;
    assertNotNull(entityBuyer);
    // check persistence type
    assertEquals(PersistenceType.ENTITY, entityBuyer.getPersistenceType());
    assertEquals(Buyer.class, entityBuyer.getJavaType());
    // verify EnumSet is a SingularAttribute
    Attribute<? super Buyer, ?> buyingDaysAttribute = entityBuyer.getAttribute("buyingDays");
    assertNotNull(buyingDaysAttribute);
    // Check persistent attribute type
    assertEquals(PersistentAttributeType.BASIC, buyingDaysAttribute.getPersistentAttributeType());
    // Non-spec check on the attribute impl type
    // EnumSet is not a Set in the Metamodel - it is a treated as a BasicType single object (SingularAttributeType)
    // BasicTypeImpl@8980685:EnumSet [ javaType: class java.util.EnumSet]
    assertFalse(((SingularAttributeImpl) buyingDaysAttribute).isPlural());
    BindableType buyingDaysElementBindableType = ((SingularAttributeImpl) buyingDaysAttribute).getBindableType();
    assertEquals(BindableType.SINGULAR_ATTRIBUTE, buyingDaysElementBindableType);
    SingularAttribute<? super Buyer, EnumSet> buyingDaysSingularAttribute = entityBuyer.getSingularAttribute("buyingDays", EnumSet.class);
    assertNotNull(buyingDaysSingularAttribute);
    assertFalse(buyingDaysSingularAttribute.isCollection());
    // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_74:_20090909:_Implement_IdentifiableType.hasSingleIdAttribute.28.29
    // Check for Id that exists
    boolean expectedIAExceptionThrown = false;
    boolean hasSingleIdAttribute = false;
    try {
        hasSingleIdAttribute = entityBuyer.hasSingleIdAttribute();
    } catch (IllegalArgumentException iae) {
        // iae.printStackTrace();
        expectedIAExceptionThrown = true;
    }
    assertFalse(expectedIAExceptionThrown);
    assertTrue(hasSingleIdAttribute);
    // Verify that the BasicMap Buyer.creditCards is picked up properly
    // * @param <X> The type the represented Map belongs to
    // * @param <K> The type of the key of the represented Map
    // * @param <V> The type of the value of the represented Map
    // public class MapAttributeImpl<X, K, V> extends PluralAttributeImpl<X, java.util.Map<K, V>, V>
    Attribute<? super Buyer, ?> buyerCreditCards = entityBuyer.getAttribute("creditCards");
    assertNotNull(buyerCreditCards);
    assertTrue(buyerCreditCards.isCollection());
    assertTrue(buyerCreditCards instanceof MapAttributeImpl);
    MapAttribute<? super Buyer, ?, ?> buyerCreditCardsMap = entityBuyer.getMap("creditCards");
    // Verify owning type
    assertNotNull(buyerCreditCardsMap);
    assertEquals(entityBuyer, buyerCreditCardsMap.getDeclaringType());
    // Verify Map Key
    assertEquals(String.class, buyerCreditCardsMap.getKeyJavaType());
    // Verify Map Value
    assertEquals(Long.class, buyerCreditCardsMap.getElementType().getJavaType());
}

Example 2 with SingularAttributeImpl

use of org.eclipse.persistence.internal.jpa.metamodel.SingularAttributeImpl in project eclipselink by eclipse-ee4j.

the class MetamodelMetamodelTest method testIdentifiableType_getIdType_Method.

public void testIdentifiableType_getIdType_Method() {
    EntityManager em = null;
    boolean expectedIAExceptionThrown = false;
    try {
        em = privateTestSetup();
        assertNotNull(em);
        Metamodel metamodel = em.getMetamodel();
        assertNotNull(metamodel);
        EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl) metamodel.entity(Manufacturer.class);
        assertNotNull(entityManufacturer_);
        EntityTypeImpl<GalacticPosition> entityLocation_ = (EntityTypeImpl) metamodel.entity(GalacticPosition.class);
        assertNotNull(entityLocation_);
        EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl) metamodel.entity(Computer.class);
        assertNotNull(entityComputer_);
        // Actual Test Case
        /**
         *  Return the type that represents the type of the id.
         *  @return type of id
         */
        // Type<?> getIdType();
        // Test EntityType
        // Test normal path for an [Embeddable] type via @EmbeddedId
        expectedIAExceptionThrown = false;
        Type<?> locationIdType = null;
        try {
            locationIdType = entityLocation_.getIdType();
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            iae.printStackTrace();
            expectedIAExceptionThrown = true;
        }
        assertFalse(expectedIAExceptionThrown);
        assertNotNull(locationIdType);
        assertEquals(PersistenceType.EMBEDDABLE, locationIdType.getPersistenceType());
        assertEquals(EmbeddedPK.class, locationIdType.getJavaType());
        // check that the elementType and the owningType (managedType) are set correctly
        // See issue 50 where some mapping types were not setting the elementType correctly (this includes aggregate types like Embeddable)
        // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_50:_20090727:_Handle_all_mapping_types_in_the_SingularAttribute_constructor
        // Get the ManagedType and check this SingularAttribute PK
        Attribute locationIdAttribute = entityLocation_.getAttribute("primaryKey");
        assertNotNull(locationIdAttribute);
        assertTrue(locationIdAttribute instanceof SingularAttributeImpl);
        assertFalse(locationIdAttribute.isCollection());
        // non-spec.
        assertFalse(((AttributeImpl) locationIdAttribute).isPlural());
        ManagedType locationIdAttributeManagedType = locationIdAttribute.getDeclaringType();
        assertEquals(entityLocation_, locationIdAttributeManagedType);
        ManagedTypeImpl locationIdAttributeManagedTypeImpl = ((SingularAttributeImpl) locationIdAttribute).getManagedTypeImpl();
        assertEquals(locationIdType.getJavaType(), ((SingularAttributeImpl) locationIdAttribute).getBindableJavaType());
        assertEquals(Bindable.BindableType.SINGULAR_ATTRIBUTE, ((SingularAttributeImpl) locationIdAttribute).getBindableType());
        assertEquals(locationIdType.getJavaType(), locationIdAttribute.getJavaType());
        Type embeddableType = ((SingularAttributeImpl) locationIdAttribute).getType();
        assertNotNull(embeddableType);
        assertNotSame(embeddableType, locationIdAttributeManagedType);
        // Test normal path for a [Basic] type
        expectedIAExceptionThrown = false;
        Type<?> computerIdType = null;
        try {
            computerIdType = entityComputer_.getIdType();
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            iae.printStackTrace();
            expectedIAExceptionThrown = true;
        }
        assertFalse(expectedIAExceptionThrown);
        assertNotNull(computerIdType);
        assertEquals(PersistenceType.BASIC, computerIdType.getPersistenceType());
        assertEquals(Integer.class, computerIdType.getJavaType());
        // Test MappedSuperclassType
        // Test normal path for a [Basic] type
        expectedIAExceptionThrown = false;
        Type<?> personIdType = null;
        MappedSuperclassTypeImpl<Person> msPerson_ = (MappedSuperclassTypeImpl) metamodel.managedType(Person.class);
        assertNotNull(msPerson_);
        MappedSuperclassTypeImpl<Corporation> msCorporation_ = (MappedSuperclassTypeImpl) metamodel.managedType(Corporation.class);
        assertNotNull(msCorporation_);
        // Verify all types (entities, embeddables, mappedsuperclasses and basic)
        // get all 21 types (a non spec function - for testing introspection)
        Map<String, TypeImpl<?>> typesMap = ((MetamodelImpl) metamodel).getTypes();
        // verify each one
        assertNotNull(typesMap);
        ((MetamodelImpl) metamodel).printAllTypes();
        // Note: Since BasicTypes are lazy - loaded into the metamodel-types Map - this test must preceed any test that verifies all BasicType objects like "testIdentifiableType_getIdType_Method"
        // You will get a lower number here - if only this single test is run via the Testing Browser
        assertEquals(METAMODEL_ALL_TYPES, typesMap.size());
    } catch (IllegalArgumentException iae) {
        iae.printStackTrace();
        expectedIAExceptionThrown = true;
    } finally {
        cleanup(em);
        assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
    }
}

Example 3 with SingularAttributeImpl

use of org.eclipse.persistence.internal.jpa.metamodel.SingularAttributeImpl in project eclipselink by eclipse-ee4j.

the class MetamodelMetamodelTest method testOutOfSpecificationInternalAPI.

public void testOutOfSpecificationInternalAPI() {
    EntityManager em = null;
    boolean exceptionThrown = false;
    try {
        em = privateTestSetup();
        assertNotNull(em);
        Metamodel metamodel = em.getMetamodel();
        assertNotNull(metamodel);
        // Actual Test Case
        EntityTypeImpl<ArrayProcessor> entityArrayProcessor_ = (EntityTypeImpl) metamodel.entity(ArrayProcessor.class);
        assertNotNull(entityArrayProcessor_);
        EntityTypeImpl<Processor> entityProcessor_ = (EntityTypeImpl) metamodel.entity(Processor.class);
        assertNotNull(entityProcessor_);
        // verify all Types have their javaClass set
        Collection<TypeImpl<?>> types = ((MetamodelImpl) metamodel).getTypes().values();
        assertNotNull(types);
        for (TypeImpl type : types) {
            assertNotNull(type);
            assertNotNull(type.getJavaType());
        }
        // verify all embeddables are only embeddables
        Set<EmbeddableType<?>> embeddables = metamodel.getEmbeddables();
        assertNotNull(embeddables);
        for (EmbeddableType embeddable : embeddables) {
            // This method works only on EntityType
            assertNotNull(embeddable);
            assertTrue(embeddable instanceof EmbeddableTypeImpl);
        }
        // verify all entities are only entities
        Set<EntityType<?>> entities = metamodel.getEntities();
        assertNotNull(entities);
        for (EntityType entity : entities) {
            // This method works only on EntityType
            assertNotNull(entity.getName());
            assertTrue(entity instanceof EntityTypeImpl);
        }
        // Verify all Attributes and their element and declaring/managed types
        List<Attribute> allAttributes = ((MetamodelImpl) metamodel).getAllManagedTypeAttributes();
        assertNotNull(allAttributes);
        assertEquals(METAMODEL_ALL_ATTRIBUTES_SIZE, allAttributes.size());
        // Why do we have this function? So we can verify attribute integrity
        for (Attribute anAttribute : allAttributes) {
            ManagedType declaringType = anAttribute.getDeclaringType();
            assertNotNull(declaringType);
            Type elementType = null;
            if (((AttributeImpl) anAttribute).isPlural()) {
                elementType = ((PluralAttributeImpl) anAttribute).getElementType();
            } else {
                elementType = ((SingularAttributeImpl) anAttribute).getType();
            }
            assertNotNull("elementType should not be null", elementType);
            // Since the javaType may be computed off the elementType - it must not be null or we will get a NPE below
            Class<?> javaType = anAttribute.getJavaType();
        }
        boolean expectedIAExceptionThrown = false;
        // Check entity-->entity hierarchy
        // Processor:entity (Board boards)
        // +--VectorProcessor
        Set<Attribute<ArrayProcessor, ?>> entityArrayProcessorDeclaredAttributes = entityArrayProcessor_.getDeclaredAttributes();
        assertEquals(1, entityArrayProcessorDeclaredAttributes.size());
        // verify getting the attribute directly
        Attribute<ArrayProcessor, ?> entityArrayProcessorDeclaredAttribute = entityArrayProcessor_.getDeclaredAttribute("speed");
        // verify we do get an IAE on declared type above
        try {
            Attribute<ArrayProcessor, ?> entityArrayProcessorDeclaredAttributeThatIsNonExistent = entityArrayProcessor_.getDeclaredAttribute("non-existent");
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            expectedIAExceptionThrown = true;
        }
        assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
        // Verify we get an IAE on a type declared above
        try {
            Attribute<ArrayProcessor, ?> entityArrayProcessorDeclaredAttributeThatIsDeclaredAbove = entityArrayProcessor_.getDeclaredAttribute("id");
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            expectedIAExceptionThrown = true;
        }
        assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
        Set<Attribute<Processor, ?>> entityProcessorDeclaredAttributes = entityProcessor_.getDeclaredAttributes();
        assertEquals(3, entityProcessorDeclaredAttributes.size());
    } catch (IllegalArgumentException iae) {
        iae.printStackTrace();
        exceptionThrown = true;
    } finally {
        cleanup(em);
        assertFalse("An IAE exception should not occur here.", exceptionThrown);
    }
}

Example 4 with SingularAttributeImpl

use of org.eclipse.persistence.internal.jpa.metamodel.SingularAttributeImpl in project eclipselink by eclipse-ee4j.

the class MetamodelMetamodelTest method testAttribute_isCollection_false_Method.

public void testAttribute_isCollection_false_Method() {
    EntityManager em = null;
    boolean exceptionThrown = false;
    try {
        em = privateTestSetup();
        assertNotNull(em);
        Metamodel metamodel = em.getMetamodel();
        assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
        EntityTypeImpl<GalacticPosition> entityLocation_ = (EntityTypeImpl) metamodel.entity(GalacticPosition.class);
        assertNotNull(entityLocation_);
        Type<?> locationIdType = entityLocation_.getIdType();
        assertNotNull(locationIdType);
        assertEquals(PersistenceType.EMBEDDABLE, locationIdType.getPersistenceType());
        assertEquals(EmbeddedPK.class, locationIdType.getJavaType());
        Attribute locationIdAttribute = entityLocation_.getAttribute("primaryKey");
        assertNotNull(locationIdAttribute);
        assertTrue(locationIdAttribute instanceof SingularAttributeImpl);
        /**
         *  Is the attribute collection-valued.
         *  @return boolean indicating whether attribute is
         *          collection-valued
         */
        // boolean isCollection();
        assertFalse(locationIdAttribute.isCollection());
        // non-spec.
        assertFalse(((AttributeImpl) locationIdAttribute).isPlural());
        ManagedType locationIdAttributeManagedType = locationIdAttribute.getDeclaringType();
        assertEquals(entityLocation_, locationIdAttributeManagedType);
        ManagedTypeImpl locationIdAttributeManagedTypeImpl = ((SingularAttributeImpl) locationIdAttribute).getManagedTypeImpl();
        assertEquals(locationIdType.getJavaType(), ((SingularAttributeImpl) locationIdAttribute).getBindableJavaType());
        assertEquals(Bindable.BindableType.SINGULAR_ATTRIBUTE, ((SingularAttributeImpl) locationIdAttribute).getBindableType());
        assertEquals(locationIdType.getJavaType(), locationIdAttribute.getJavaType());
        Type embeddableType = ((SingularAttributeImpl) locationIdAttribute).getType();
        assertNotNull(embeddableType);
        assertNotSame(embeddableType, locationIdAttributeManagedType);
    } catch (IllegalArgumentException iae) {
        iae.printStackTrace();
        exceptionThrown = true;
    } finally {
        cleanup(em);
        assertFalse("An IAE exception should not occur here.", exceptionThrown);
    }
}