@Override public boolean canBeApplied(MetaClass clazz) { if (constraints.length == 0) return true; return Arrays.stream(constraints).anyMatch(mc -> mc.asBoxed().isAssignableFrom(clazz.asBoxed())); } }
public static boolean isNumericallyCoercible(final MetaClass target, final MetaClass parm) { MetaClass boxedTarget = target.isPrimitive() ? target.asBoxed() : target; if (boxedTarget != null && Number_MetaClass.isAssignableFrom(target)) { if ((boxedTarget = parm.isPrimitive() ? parm.asBoxed() : parm) != null) { return Number_MetaClass.isAssignableFrom(boxedTarget); } } return false; }
/** * Returns true if the method signature is the same as the methods generated by BindableProxyGenerator */ private boolean isBindableProxyGeneratedMethod(MetaMethod method) { if(method.getName().equals("get") && method.getParameters().length == 1 && method.getParameters()[0].getType().isAssignableFrom(String.class)) { return true; } if(method.getName().equals("set") && method.getParameters().length == 2 && method.getParameters()[0].getType().isAssignableFrom(String.class)) { return true; } return false; }
private void checkSwitchExprType() { final boolean validType = supportedTypes.stream() .anyMatch(cls -> MetaClassFactory.get(cls).isAssignableFrom(switchExprStmt.getType().asBoxed())); if (!validType) throw new InvalidTypeException("Type not permitted in switch statements:" + switchExprStmt.getType().getFullyQualifiedName()); } }
@Test public void testChildIsAssignableFromChild() { // This test checks the valid case: // Child example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); assertTrue(metaChild.isAssignableFrom(metaChild)); }
@Test public void testChildIsNotAssignableFromParent() { // This test checks the disallowed case: // Child child = new Parent(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaParent = getMetaClass(Parent.class); assertFalse(metaChild.isAssignableFrom(metaParent)); }
@Test public void testGrandParentIsAssignableFromChild() { // This test checks the valid case: // Grandparent example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaGrandparent = getMetaClass(Grandparent.class); assertTrue(metaGrandparent.isAssignableFrom(metaChild)); }
@Test public void testChildIsNotAssignableFromGrandParent() { // This test checks the disallowed case: // Child child = new Grandparent(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaGrandparent = getMetaClass(Grandparent.class); assertFalse(metaChild.isAssignableFrom(metaGrandparent)); }
/** * This is a regression test for ERRAI-238. */ @Test public void testUncleInLawIsAssignableFromChild() { // This test checks the valid case: // ParentSuperInterface1 example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaUncleInLaw = getMetaClass(ParentSuperInterface1.class); assertTrue(metaUncleInLaw.isAssignableFrom(metaChild)); }
@Test public void testChildIsNotAssignableFromUncleInLaw() { // This test checks the disallowed case: // Child child = new ParentSuperInterface1() {}; final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaUncleInLaw = getMetaClass(ParentSuperInterface1.class); assertFalse(metaChild.isAssignableFrom(metaUncleInLaw)); }
@Test public void testChildIsNotAssignableFromGreatUncleInLaw() { // This test checks the disallowed case: // Child child = new GrandparentSuperInterface() {}; final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaGreatUncleInLaw = getMetaClass(GrandparentSuperInterface.class); assertFalse(metaChild.isAssignableFrom(metaGreatUncleInLaw)); }
@Test public void testIsolatedInterfaceIsNotAssignableFromObject() { // This test checks the disallowed case: // IsolatedInterface ii = new Object(); final MetaClass metaInterface = getMetaClass(IsolatedInterface.class); final MetaClass metaObject = getMetaClass(Object.class); assertFalse(metaInterface.isAssignableFrom(metaObject)); }
@Test public void testParentIsAssignableFromChild() { // This test checks the valid case: // Parent example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaParent = getMetaClass(Parent.class); assertTrue(metaParent.isAssignableFrom(metaChild)); }
@Test public void testChildIsNotAssignableFromUncleInLaw2() { // This test checks the disallowed case: // Child child = new ParentSuperInterface2() {}; final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaUncleInLaw = getMetaClass(ParentSuperInterface2.class); assertFalse(metaChild.isAssignableFrom(metaUncleInLaw)); }
@Test public void testObjectIsAssignableFromChild() { // This test checks the valid case: //Object example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaObject = getMetaClass(Object.class); assertTrue(metaObject.isAssignableFrom(metaChild)); }
@Test public void testObjectIsAssignableFromIsolatedInterface() { // This test checks the valid case: // Object example = new IsolatedInterface() {}; final MetaClass metaInterface = getMetaClass(IsolatedInterface.class); final MetaClass metaObject = getMetaClass(Object.class); assertTrue(metaObject.isAssignableFrom(metaInterface)); }
/** * This is a regression test for ERRAI-238. */ @Test public void testUncleIsAssignableFromChild() { // This test checks the valid case: // ParentInterface example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaUncle = getMetaClass(ParentInterface.class); assertTrue(metaUncle.isAssignableFrom(metaChild)); }
/** * This is a regression test for ERRAI-238. */ @Test public void testGreatUncleInLawIsAssignableFromChild() { // This test checks the valid case: //GrandparentSuperInterface example = new Child(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaGreatUncleInLaw = getMetaClass(GrandparentSuperInterface.class); assertTrue(metaGreatUncleInLaw.isAssignableFrom(metaChild)); }
@Test public void testChildIsNotAssignableFromObject() { // This test checks the disallowed case: // Child child = new Object(); final MetaClass metaChild = getMetaClass(Child.class); final MetaClass metaObject = getMetaClass(Object.class); assertFalse(metaChild.isAssignableFrom(metaObject)); }
@Test public void testIsAssignableFromComparisonForNested() { final MetaClass interfaceClass = getMetaClass(TestInterface.class); final MetaClass metaHolderClass = getMetaClass(ObjectWithNested.class); // dig out the nested interface from the holder class and ensure it's what we were looking for final MetaClass nestedInterface = metaHolderClass.getDeclaredClasses()[0]; assertEquals("MyNestedInterface", nestedInterface.getName()); assertEquals(getTypeOfMetaClassBeingTested(), nestedInterface.getClass()); assertTrue("MyNestedInterface should be assignable from TestInterface", interfaceClass.isAssignableFrom(nestedInterface)); }