i++; return switchTransformer(preds, trs, def);
public void testInvokerTransformer() { List list = new ArrayList(); assertEquals(new Integer(0), TransformerUtils.invokerTransformer("size").transform(list)); list.add(new Object()); assertEquals(new Integer(1), TransformerUtils.invokerTransformer("size").transform(list)); assertEquals(null, TransformerUtils.invokerTransformer("size").transform(null)); try { TransformerUtils.invokerTransformer(null); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.invokerTransformer("noSuchMethod").transform(new Object()); fail(); } catch (FunctorException ex) {} }
public Map makeEmptyMap() { return TransformedSortedMap.decorate(new TreeMap(), TransformerUtils.nopTransformer(), TransformerUtils.nopTransformer()); }
public void testNopTransformer() { assertNotNull(TransformerUtils.nullTransformer()); assertSame(TransformerUtils.nullTransformer(), TransformerUtils.nullTransformer()); assertEquals(null, TransformerUtils.nopTransformer().transform(null)); assertEquals(cObject, TransformerUtils.nopTransformer().transform(cObject)); assertEquals(cString, TransformerUtils.nopTransformer().transform(cString)); assertEquals(cInteger, TransformerUtils.nopTransformer().transform(cInteger)); }
public void testChainedTransformer() { Transformer a = TransformerUtils.constantTransformer("A"); Transformer b = TransformerUtils.constantTransformer("B"); assertEquals("A", TransformerUtils.chainedTransformer(b, a).transform(null)); assertEquals("B", TransformerUtils.chainedTransformer(a, b).transform(null)); assertEquals("A", TransformerUtils.chainedTransformer(new Transformer[] {b, a}).transform(null)); Collection coll = new ArrayList(); coll.add(b); coll.add(a); assertEquals("A", TransformerUtils.chainedTransformer(coll).transform(null)); assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer(new Transformer[0])); assertSame(NOPTransformer.INSTANCE, TransformerUtils.chainedTransformer(Collections.EMPTY_LIST)); TransformerUtils.chainedTransformer(null, null); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.chainedTransformer((Transformer[]) null); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.chainedTransformer((Collection) null); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.chainedTransformer(new Transformer[] {null, null}); fail(); } catch (IllegalArgumentException ex) {}
public void testSwitchTransformer() { Transformer a = TransformerUtils.constantTransformer("A"); Transformer b = TransformerUtils.constantTransformer("B"); Transformer c = TransformerUtils.constantTransformer("C"); assertEquals("A", TransformerUtils.switchTransformer(PredicateUtils.truePredicate(), a, b).transform(null)); assertEquals("B", TransformerUtils.switchTransformer(PredicateUtils.falsePredicate(), a, b).transform(null)); assertEquals(null, TransformerUtils.switchTransformer( new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, new Transformer[] {a, b}).transform("WELL")); assertEquals("A", TransformerUtils.switchTransformer( new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, new Transformer[] {a, b}).transform("HELLO")); assertEquals("B", TransformerUtils.switchTransformer( new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, new Transformer[] {a, b}).transform("THERE")); assertEquals("C", TransformerUtils.switchTransformer( new Predicate[] {PredicateUtils.equalPredicate("HELLO"), PredicateUtils.equalPredicate("THERE")}, new Transformer[] {a, b}, c).transform("WELL")); map.put(PredicateUtils.equalPredicate("HELLO"), a); map.put(PredicateUtils.equalPredicate("THERE"), b); assertEquals(null, TransformerUtils.switchTransformer(map).transform("WELL")); assertEquals("A", TransformerUtils.switchTransformer(map).transform("HELLO")); assertEquals("B", TransformerUtils.switchTransformer(map).transform("THERE")); map.put(null, c); assertEquals("C", TransformerUtils.switchTransformer(map).transform("WELL"));
public void testTransformedPredicate() { assertEquals(true, PredicateUtils.transformedPredicate( TransformerUtils.nopTransformer(), PredicateUtils.truePredicate()).evaluate(new Object())); Map map = new HashMap(); map.put(Boolean.TRUE, "Hello"); Transformer t = TransformerUtils.mapTransformer(map); Predicate p = PredicateUtils.equalPredicate("Hello"); assertEquals(false, PredicateUtils.transformedPredicate(t, p).evaluate(null)); assertEquals(true, PredicateUtils.transformedPredicate(t, p).evaluate(Boolean.TRUE)); try { PredicateUtils.transformedPredicate(null, null); fail(); } catch (IllegalArgumentException ex) {} }
public void testExecutorTransformer() { assertEquals(null, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(null)); assertEquals(cObject, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cObject)); assertEquals(cString, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cString)); assertEquals(cInteger, TransformerUtils.asTransformer(ClosureUtils.nopClosure()).transform(cInteger)); try { TransformerUtils.asTransformer((Closure) null); } catch (IllegalArgumentException ex) { return; } fail(); }
public void testPredicateTransformer() { assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(null)); assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(cObject)); assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(cString)); assertEquals(Boolean.TRUE, TransformerUtils.asTransformer(PredicateUtils.truePredicate()).transform(cInteger)); try { TransformerUtils.asTransformer((Predicate) null); } catch (IllegalArgumentException ex) { return; } fail(); }
i++; return switchTransformer(preds, trs, def);
public Map makeEmptyMap() { return TransformedMap.decorate(new HashMap(), TransformerUtils.nopTransformer(), TransformerUtils.nopTransformer()); }
public void testInvokerTransformer2() { List list = new ArrayList(); assertEquals(Boolean.FALSE, TransformerUtils.invokerTransformer( "contains", new Class[] {Object.class}, new Object[] {cString}).transform(list)); list.add(cString); assertEquals(Boolean.TRUE, TransformerUtils.invokerTransformer( "contains", new Class[] {Object.class}, new Object[] {cString}).transform(list)); assertEquals(null, TransformerUtils.invokerTransformer( "contains", new Class[] {Object.class}, new Object[] {cString}).transform(null)); TransformerUtils.invokerTransformer(null, null, null); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.invokerTransformer( "noSuchMethod", new Class[] {Object.class}, new Object[] {cString}).transform(new Object()); fail(); } catch (FunctorException ex) {} try { TransformerUtils.invokerTransformer("badArgs", null, new Object[] { cString }); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.invokerTransformer("badArgs", new Class[] {Object.class}, null); fail(); } catch (IllegalArgumentException ex) {} try { TransformerUtils.invokerTransformer("badArgs", new Class[] {}, new Object[] { cString }); fail(); } catch (IllegalArgumentException ex) {}
public void testFactoryTransformer() { assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(null)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cObject)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cString)); assertEquals(null, TransformerUtils.asTransformer(FactoryUtils.nullFactory()).transform(cInteger)); try { TransformerUtils.asTransformer((Factory) null); } catch (IllegalArgumentException ex) { return; } fail(); }
i++; return switchTransformer(preds, trs, def);
public void testAsPredicateTransformerEx2() { try { PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(null); } catch (FunctorException ex) { return; } fail(); }
TransformerUtils.invokerTransformer("getId")); List<Long> allocatedActiveHostIds = (List<Long>) org.apache.commons.collections.CollectionUtils.collect(existingHostMaps, TransformerUtils.invokerTransformer("getHostId"));
public void testTransformerDecorate() { Transformer transformer = TransformerUtils.asTransformer(oneFactory); SortedMap map = LazySortedMap.decorate(new TreeMap(), transformer); assertTrue(map instanceof LazySortedMap); try { map = LazySortedMap.decorate(new TreeMap(), (Transformer) null); fail("Expecting IllegalArgumentException for null transformer"); } catch (IllegalArgumentException e) { // expected } try { map = LazySortedMap.decorate(null, transformer); fail("Expecting IllegalArgumentException for null map"); } catch (IllegalArgumentException e) { // expected } }
i++; return switchTransformer(preds, trs, def);
public void testAsPredicateTransformer() { assertEquals(false, PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(Boolean.FALSE)); assertEquals(true, PredicateUtils.asPredicate(TransformerUtils.nopTransformer()).evaluate(Boolean.TRUE)); }
@SuppressWarnings("unchecked") protected void activateService(Service service, Map<Long, Service> servicesToActivate, List<Long> alreadySeenServices, List<Long> alreadyActivatedServices) { if (alreadyActivatedServices.contains(service.getId())) { return; } alreadySeenServices.add(service.getId()); List<Long> consumedServicesIds = (List<Long>) CollectionUtils.collect( consumeMapDao.findConsumedServices(service.getId()), TransformerUtils.invokerTransformer("getConsumedServiceId")); for (Long consumedServiceId : consumedServicesIds) { Service consumedService = servicesToActivate.get(consumedServiceId); if (consumedService != null && !alreadySeenServices.contains(consumedService.getId())) { activateService(consumedService, servicesToActivate, alreadySeenServices, alreadyActivatedServices); } } if (service.getState().equalsIgnoreCase(CommonStatesConstants.INACTIVE)) { Map<String, Object> data = new HashMap<>(); List<Long> consumedServicesToWaitFor = new ArrayList<>(); consumedServicesToWaitFor.addAll(consumedServicesIds); consumedServicesToWaitFor.retainAll(alreadyActivatedServices); data.put(ServiceConstants.FIELD_WAIT_FOR_CONSUMED_SERVICES_IDS, consumedServicesToWaitFor); objectProcessManager.scheduleStandardProcess(StandardProcess.ACTIVATE, service, data); } alreadyActivatedServices.add(service.getId()); } }