Java Code Examples for java.util.concurrent.Callable

@Override
public Observable<Article> returnArticleByUrl(final String url) {
    return Observable.fromCallable(new Callable<Article>() {
        @Override
        public Article call() throws Exception {
            List<Article> articles = mDaoSession.getArticleDao().queryBuilder()
                    .where(ArticleDao.Properties.Url.eq(url))
                    .list();

            if (articles.isEmpty()) {
                return null;
            } else {
                return articles.get(0);
            }
        }
    });
}
 

@Test
public void loadNextActiveSubscriptionHistoryForPriceModel_FpEndsAtUpgradeTime()
        throws Exception {
    // given
    setupSubAndPmHistoriesForAsyncUpgrade();

    // when
    SubscriptionHistory subHistory = runTX(
            new Callable<SubscriptionHistory>() {
                @Override
                public SubscriptionHistory call() throws Exception {
                    return bdr
                            .loadNextActiveSubscriptionHistoryForPriceModel(
                                    PRICEMODEL1_KEY,
                                    dateToMillis("2012-10-03 10:20:00"));
                }
            });

    // then
    assertNull(subHistory);
}
 

@Test
public void disposedOnCallThrows() {
    List<Throwable> errors = TestCommonHelper.trackPluginErrors();
    try {
        final TestObserver<Integer> to = new TestObserver<Integer>();

        Observable.fromCallable(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                to.cancel();
                throw new TestException();
            }
        })
        .subscribe(to);

        to.assertEmpty();

        TestCommonHelper.assertUndeliverable(errors, 0, TestException.class);
    } finally {
        RxJavaCommonPlugins.reset();
    }
}
 

/**
 * Grant permissions globally to the given user. Will wait until all active
 * AccessController instances have updated their permissions caches or will
 * throw an exception upon timeout (10 seconds).
 */
public static void grantGlobal(final HBaseTestingUtility util, final String user,
    final Permission.Action... actions) throws Exception {
  SecureTestUtil.updateACLs(util, new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      try (Connection connection = ConnectionFactory.createConnection(util.getConfiguration())) {
        try (Table acl = connection.getTable(AccessControlLists.ACL_TABLE_NAME)) {
          BlockingRpcChannel service = acl.coprocessorService(HConstants.EMPTY_START_ROW);
          AccessControlService.BlockingInterface protocol =
              AccessControlService.newBlockingStub(service);
          ProtobufUtil.grant(null, protocol, user, actions);
        }
      }
      return null;
    }
  });
}
 

/**
 * <b>Test case:</b> Add a new tag entry<br>
 * <b>ExpectedResult:</b>
 * <ul>
 * <li>The tag entry can be retrieved from DB and is identical to the
 * provided object</li>
 * <li>A history object is created for the tag entry</li>
 * </ul>
 * 
 * @throws Exception
 */
@Test
public void testAdd() throws Exception {
    runTX(new Callable<Void>() {
        public Void call() throws Exception {
            doTestAdd();
            return null;
        }
    });
    runTX(new Callable<Void>() {
        public Void call() throws Exception {
            doTestAddCheck();
            return null;
        }
    });
}
 

Callable<C> $(I i, CompressSpec spec) throws Exception {
    BitmapFactory.Options decodeBoundsOptions = BitmapOptionsCompat.getDefaultDecodeBoundsOptions();

    getDecodeOptions(i, decodeBoundsOptions);

    spec.options.inSampleSize =
            spec.calculation.calculateInSampleSize(
                    decodeBoundsOptions.outWidth,
                    decodeBoundsOptions.outHeight);
    Logger.i("inSampleSize-->" + spec.options.inSampleSize);
    spec.options.quality =
            spec.calculation.calculateQuality(
                    decodeBoundsOptions.outWidth,
                    decodeBoundsOptions.outHeight,
                    decodeBoundsOptions.outWidth / spec.options.inSampleSize,
                    decodeBoundsOptions.outHeight / spec.options.inSampleSize);
    Logger.i("quality-->" + spec.options.quality);
    while (!MemoryUtil.memoryEnough(
            decodeBoundsOptions.outWidth / spec.options.inSampleSize,
            decodeBoundsOptions.outHeight / spec.options.inSampleSize,
            decodeBoundsOptions.inPreferredConfig,
            spec.safeMemory));

    Callable<C> callable = getCallable(i, spec);
    return callable;
}
 

@Test(expected = UnsupportedOperationException.class)
public void createUser_LDAPUsed() throws Exception {
    try {
        final VOUserDetails userToCreate = new VOUserDetails();
        userToCreate.setUserId("newUser");
        runTX(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                idMgmt.createUser(userToCreate, Collections.singletonList(
                        UserRoleType.ORGANIZATION_ADMIN), null);
                return null;
            }
        });
    } catch (EJBException e) {
        throw e.getCausedByException();
    }
}
 

@Override
public boolean isInstance(final Object instance) {
    if (! (instance instanceof ScriptObjectMirror)) {
        return false;
    }

    final ScriptObjectMirror mirror = (ScriptObjectMirror)instance;
    // if not belongs to my global scope, return false
    if (global != mirror.global) {
        return false;
    }

    return inGlobal(new Callable<Boolean>() {
        @Override public Boolean call() {
            return sobj.isInstance(mirror.sobj);
        }
    });
}
 

/**
 * <b>Testcase:</b> Try to insert two products with the same productId<br>
 * <b>ExpectedResult:</b> SaasNonUniqueBusinessKeyException
 * 
 * @throws Throwable
 */
@Test(expected = NonUniqueBusinessKeyException.class)
public void testViolateUniqueConstraint() throws Throwable {
    try {
        runTX(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                doTestViolateUniqueConstraintPrepare();
                return null;
            }
        });
        runTX(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                doTestViolateUniqueConstraint();
                return null;
            }
        });
    } catch (EJBException e) {
        throw e.getCause();
    }
}
 

@Test
public void testPerformBillingRunForOrganizationNoCosts() throws Exception {
    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            Scenario.setup(container, false, true);

            PriceModel priceModel = Scenario.getPriceModel();
            priceModel = mgr.getReference(PriceModel.class,
                    priceModel.getKey());

            priceModel.setType(PriceModelType.FREE_OF_CHARGE);
            return null;
        }
    });

    BillingResult res = serviceBill.generateBillingForAnyPeriod(
            System.currentTimeMillis(), System.currentTimeMillis() + 20,
            Scenario.getCustomer().getKey()).get(0);

    Assert.assertNotNull("Result must not be null", res);
    checkEquals("Wrong costs contained", new BigDecimal("0.68"),
            res.getGrossAmount(), PriceConverter.NORMALIZED_PRICE_SCALING);
}
 

@Before
public void setup() {
    sessionContext = new TestSessionContext(null, null);
    callable = new Callable<Object>() {
        @Override
        public Void call() {
            return null;
        }
    };
    ctx = new IInvocationCtx() {
        @Override
        public TransactionManager getTransactionManager() {
            return null;
        }

        @Override
        public boolean isApplicationException(Exception e) {
            return false;
        }
    };
}
 

public void addPartner(String key, Partner partner) {
	String partnerPath = ZKPaths.makePath(partnerStorePath, key);
	RetryRunner.create().onFinalError(e -> {
		LOGGER.error("addPartner.error", e);
		ReporterHolder.incException(e);
		throw new ServiceErrorException(ErrorCode.SYSTEM_ERROR);
	}).run((Callable<Void>) () -> {
		if (client.checkExists().creatingParentsIfNeeded().forPath(partnerPath) != null) {
			client.setData()
			      .forPath(partnerPath, JSONObject.toJSONBytes(partner));
		} else {
			client.create()
			      .creatingParentsIfNeeded()
			      .withMode(CreateMode.PERSISTENT)
			      .forPath(partnerPath, JSONObject.toJSONBytes(partner));
		}
		return null;
	});
}
 

private void createMarketingPermission(final long tpKey,
        final long orgRefKey) throws Exception {
    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            TechnicalProduct technicalProduct = dm.find(
                    TechnicalProduct.class, tpKey);
            OrganizationReference reference = dm.find(
                    OrganizationReference.class, orgRefKey);

            MarketingPermission permission = new MarketingPermission();
            permission.setOrganizationReference(reference);
            permission.setTechnicalProduct(technicalProduct);
            dm.persist(permission);
            return null;
        }
    });
}
 

@Test
public void getMarketplacesForOrganization_InitialSupplier()
        throws Exception {
    Long suppInitialUserKey = runTX(new Callable<Long>() {

        @Override
        public Long call() throws Exception {
            Organization org = Organizations.createOrganization(mgr,
                    OrganizationRoleType.SUPPLIER);
            PlatformUser user = Organizations.createUserForOrg(mgr, org,
                    true, "testGetMarketplaces_InitialSupplier");
            mgr.flush();
            return Long.valueOf(user.getKey());
        }
    });
    container.login(suppInitialUserKey.longValue(), ROLE_SERVICE_MANAGER);
    List<VOMarketplace> list = marketplaceService
            .getMarketplacesForOrganization();
    assertNotNull(list);
    assertEquals("Created user may at least publish to open mp", 1,
            list.size());
    assertEquals("Created user may at least publish to open mp",
            OPEN_MP_ID, list.get(0).getMarketplaceId());
}
 

private TechnicalProductOperation doModify(
        final TechnicalProductOperation op) throws Exception {

    final TechnicalProductOperation read = runTX(new Callable<TechnicalProductOperation>() {

        @Override
        public TechnicalProductOperation call() throws Exception {
            TechnicalProductOperation tpo = mgr.getReference(
                    TechnicalProductOperation.class, op.getKey());
            tpo.setActionUrl("someOtherUlr");
            return mgr.getReference(TechnicalProductOperation.class,
                    tpo.getKey());
        }
    });
    Assert.assertEquals("ID", read.getOperationId());
    Assert.assertEquals("someOtherUlr", read.getActionUrl());
    return read;
}
 

/**
 * Test role definition creation.
 * 
 * @throws Exception
 */
@Test
public void testCreate() throws Exception {

    final BigDecimal pricePerUser = BigDecimal.valueOf(40L);
    final String roleID = "roleID";

    runTX(new Callable<Void>() {
        public Void call() throws Exception {
            final long key = doCreate(roleID, pricePerUser);

            PricedProductRole pricedRole = mgr.find(PricedProductRole.class,
                    key);

            Assert.assertEquals(key, pricedRole.getKey());
            Assert.assertEquals(pricePerUser, pricedRole.getPricePerUser());

            return null;
        }
    });
}
 

private static String extractLocalizedMessage(final Throwable t) {
    String msg = null;
    if (t instanceof Callable) {
        Object res = null;
        try {
            res = ((Callable) t).call();
        } catch (Exception ex) {
            LOG.log(Level.WARNING, null, t); // NOI18N
        }
        if (res instanceof LogRecord[]) {
            for (LogRecord r : (LogRecord[])res) {
                ResourceBundle b = r.getResourceBundle();
                if (b != null) {
                    msg = b.getString(r.getMessage());
                    break;
                }
            }
        }
    }
    return msg;
}
 

@Test(expected = InvalidUserSession.class)
public void testGetCurrentUserExistingButNoAdminClientCert()
        throws Exception {
    String dn = "dn=1";
    createOrgAndUserForWS(dn, false,
            OrganizationRoleType.TECHNOLOGY_PROVIDER);
    container.login(dn);
    PlatformUser user = runTX(new Callable<PlatformUser>() {
        @Override
        public PlatformUser call() throws Exception {
            return mgr.getCurrentUserIfPresent();
        }
    });
    Assert.assertNull("No valid user object expected", user);
    try {
        runTX(new Callable<PlatformUser>() {
            @Override
            public PlatformUser call() throws Exception {
                return mgr.getCurrentUser();
            }
        });
    } catch (EJBException e) {
        throw e.getCausedByException();
    }
}
 

/**
 * Tests fix for BUG#20453671 - CLOB.POSITION() API CALL WITH CLOB INPUT RETURNS EXCEPTION
 * 
 * @throws Exception
 *             if the test fails.
 */
public void testBug20453671() throws Exception {
    this.rs = this.stmt.executeQuery("select 'abcd', 'a', 'b', 'c', 'd', 'e'");
    this.rs.next();

    final Clob in = this.rs.getClob(1);
    final ResultSet locallyScopedRs = this.rs;
    assertThrows(SQLException.class, "Illegal starting position for search, '0'", new Callable<Void>() {
        public Void call() throws Exception {
            in.position(locallyScopedRs.getClob(2), 0);
            return null;
        }
    });
    assertThrows(SQLException.class, "Starting position for search is past end of CLOB", new Callable<Void>() {
        public Void call() throws Exception {
            in.position(locallyScopedRs.getClob(2), 10);
            return null;
        }
    });

    assertEquals(1, in.position(this.rs.getClob(2), 1));
    assertEquals(2, in.position(this.rs.getClob(3), 1));
    assertEquals(3, in.position(this.rs.getClob(4), 1));
    assertEquals(4, in.position(this.rs.getClob(5), 1));
    assertEquals(-1, in.position(this.rs.getClob(6), 1));
}
 

private ConversionResult runWorkers(List<? extends Callable<ConversionResult>> callables)
{
	Exception exception = null;
	ExecutorService service = Executors.newFixedThreadPool(config.getNumberOfTableWorkers());
	List<Future<ConversionResult>> futures = new ArrayList<>(callables.size());
	long startTime = System.currentTimeMillis();
	for (Callable<ConversionResult> callable : callables)
	{
		futures.add(service.submit(callable));
	}
	service.shutdown();
	try
	{
		service.awaitTermination(config.getTableWorkerMaxWaitInMinutes(), TimeUnit.MINUTES);
	}
	catch (InterruptedException e)
	{
		exception = e;
		service.shutdownNow();
		log.severe("Error while waiting for workers to finish: " + e.getMessage());
	}
	long endTime = System.currentTimeMillis();
	return ConversionResult.collect(futures, startTime, endTime, exception);
}
 

@Test
public void testTemplateExecutionTimeout() throws InterruptedException, ExecutionException {
    serviceBuilder.setMaxTemplateExecutionTime(200);
    
    // To avoid blocking the CI server forever without giving error:
    Future<FreeMarkerServiceResponse> future = Executors.newSingleThreadExecutor().submit(
            new Callable<FreeMarkerServiceResponse>() {
    
                @Override
                public FreeMarkerServiceResponse call() throws Exception {
                    return getService().calculateTemplateOutput(
                            "<#list 1.. as _></#list>", Collections.<String, Object>emptyMap(), null, null, null);
                }
                
            });
    FreeMarkerServiceResponse serviceResponse;
    try {
        serviceResponse = future.get(BLOCKING_TEST_TIMEOUT, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        throw new AssertionError("The template execution wasn't aborted (within the timeout).");
    }
    assertThat(serviceResponse.isSuccesful(), is(false));
    assertThat(serviceResponse.getFailureReason(), instanceOf(TimeoutException.class));
}
 

/**
 * Creates an initial payment result object for the given billing result
 * object with the given status.
 * 
 * @param br
 *            The billing result object the payment processing was based on.
 * @param status
 *            The status the payment result object should have.
 * @return Returns the initialized payment result.
 * @throws Exception
 */
private PaymentResult initPaymentResult(final BillingResult br,
        final PaymentProcessingStatus status) throws Exception {
    return runTX(new Callable<PaymentResult>() {
        @Override
        public PaymentResult call() throws Exception {
            PaymentResult pr = new PaymentResult();
            pr.setProcessingStatus(status);
            pr.setProcessingTime(TIMESTAMP);
            pr.setBillingResult(br);

            br.setPaymentResult(pr);

            mgr.persist(pr);
            return pr;
        }
    });
}
 

private void setNotification(final String address, final UDOOBLESensor udoobleSensor, final INotificationListener<byte[]> iNotificationListener) {
    if (isBluManagerReady) {
        addOperation(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                UUID servUuid = udoobleSensor.getService();
                UUID dataUuid = udoobleSensor.getData();
                BluetoothGattService serv = mUdooBluService.getService(address, servUuid);

                if (serv != null) {
                    BluetoothGattCharacteristic charac = serv.getCharacteristic(dataUuid);
                    mINotificationListenerMap.put(address + charac.getUuid().toString(), iNotificationListener);
                    mUdooBluService.setCharacteristicNotification(address, charac, true);
                    Log.i(TAG, "setNotification: ");
                } else if (iNotificationListener != null)
                    iNotificationListener.onError(new UdooBluException(UdooBluException.BLU_GATT_SERVICE_NOT_FOUND));
                return null;
            }
        });
    } else if (BuildConfig.DEBUG)
        Log.i(TAG, "BluManager not ready");
}
 

@Ignore
@Test
public void testAsyncCreateTimerInitFailure() throws Exception {
    final InstanceDescription descr = new InstanceDescription();
    descr.setInstanceId("appId123");
    descr.setBaseUrl("http://here/");
    when(
            controllerMock.createInstance(Matchers
                    .any(ProvisioningSettings.class))).thenReturn(descr);

    doThrow(new APPlatformException("TimerInitFailure")).when(timerService)
            .initTimers();
    final BaseResult result = runTX(new Callable<BaseResult>() {
        @Override
        public BaseResult call() {
            final InstanceRequest rq = basicInstanceRequest;
            rq.setOrganizationId("org123");
            rq.setSubscriptionId("sub123");
            rq.setDefaultLocale("de");
            rq.setLoginUrl("http://bes/");
            return proxy.asyncCreateInstance(rq, null);
        }
    });
    assertEquals(1, result.getRc());
    assertEquals("TimerInitFailure", result.getDesc());
}
 

@Override
public NotifyFuture<WriteAttributeResults> startWriteAttributes ( final Map<String, Variant> attributes, final OperationParameters operationParameters )
{
    final ScriptExecutor writeCommand = this.writeCommand;
    if ( writeCommand == null )
    {
        return new InstantErrorFuture<WriteAttributeResults> ( new OperationException ( "Not supported" ) );
    }

    final FutureTask<WriteAttributeResults> task = new FutureTask<WriteAttributeResults> ( new Callable<WriteAttributeResults> () {
        @Override
        public WriteAttributeResults call () throws Exception
        {
            return convertAttributeResult ( attributes, performWrite ( writeCommand, null, attributes, operationParameters ) );
        }
    } );
    this.executor.execute ( task );
    return task;
}
 

public void readDigital(final String address, final IReaderListener<byte[]> readerListener) {
    if (isBluManagerReady) {
        addOperation(new Callable<Void>() {
            @Override
            public Void call() throws Exception {
                UUID servUuid = UDOOBLE.UUID_IOPIN_SERV;
                UUID dataUuid = UDOOBLE.UUID_IOPIN_DIGITAL_DATA;
                BluetoothGattService serv = mUdooBluService.getService(address, servUuid);

                if (serv != null) {
                    BluetoothGattCharacteristic charac = serv.getCharacteristic(dataUuid);
                    mUdooBluService.readCharacteristic(address, charac);
                    mIReaderListenerMap.put(address + charac.getUuid().toString(), readerListener);
                } else {
                    if (readerListener != null)
                        readerListener.onError(new UdooBluException(UdooBluException.BLU_GATT_SERVICE_NOT_FOUND));
                }
                return null;
            }
        });
    } else {
        if (BuildConfig.DEBUG)
            Log.i(TAG, "BluManager not ready");

        if (readerListener != null)
            readerListener.onError(new UdooBluException(UdooBluException.BLU_SERVICE_NOT_READY));
    }
}
 

WindowBoundaryMainObserver(Observer<? super Observable<T>> actual, Callable<? extends ObservableSource<B>> other,
        int bufferSize) {
    super(actual, new MpscLinkedQueue<Object>());
    this.other = other;
    this.bufferSize = bufferSize;
    windows.lazySet(1);
}
 

/**
 * Sets a detail.
 *
 * @param key the key
 * @param value the value supplier
 * @return this category
 */
@Nonnull
default DetailedReportCategory detail(@Nonnull final String key, @Nonnull final Callable<String> value) {
  try {
    return this.detail(key, value.call());
  } catch(final Throwable t) {
    return this.detail(key, t);
  }
}
 

private List<ReportResultData> retrieveSubscriptionReportData(
        final String organizationId) throws Exception {
    return runTX(new Callable<List<ReportResultData>>() {
        @Override
        public List<ReportResultData> call() throws Exception {
            return dao.retrieveSubscriptionReportData(organizationId);
        }
    });
}
 

private CatalogEntry getCatalogEntryForProduct(final long productKey)
        throws Exception {
    return runTX(new Callable<CatalogEntry>() {
        @Override
        public CatalogEntry call() throws Exception {
            Product product = ds.getReference(Product.class, productKey);
            CatalogEntry catalogEntry = product.getCatalogEntries().get(0);
            catalogEntry.setBrokerPriceModel(unproxyEntity(catalogEntry.getBrokerPriceModel()));
            catalogEntry.setResellerPriceModel(unproxyEntity(catalogEntry.getResellerPriceModel()));
            return catalogEntry;
        }
    });
}
 

@Test
public void resetOrganizationSettings_orgPropertiesDefined_platformPropertiesDefined()
        throws Throwable {
    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            ldapSettingsMgmtSvc.resetOrganizationSettings(customerOrgId);
            return null;
        }
    });

    assertEquals(
            "Exactly one organization-specific properties must be defined",
            1, getOrganizationSettings(customerOrg, null).size());
    assertEquals(
            "Returned value must be empty (to bind it to platform property)",
            "",
            getOrganizationSettings(customerOrg,
                    SettingType.LDAP_CONTEXT_FACTORY).get(0)
                    .getSettingValue());
    // platform settings must be left unchanged
    assertEquals("Exactly one platform property must be defined", 1,
            getPlatformSettings(null).size());
    assertEquals(
            "Returned value must correspond to value set during setup",
            "myLdapContextFactory",
            getPlatformSettings(SettingType.LDAP_CONTEXT_FACTORY).get(0)
                    .getSettingValue());
}
 

public static void updateCover(final long albumId, final long coverPhotoId, final boolean isCoverVideo, final DatabaseCallback<Long> callback) {
    DatabaseHelper.getInstance().execute(new Runnable() {
        @Override
        public void run() {
            final RuntimeExceptionDao<MyAlbum, Long> dao = DatabaseHelper.getInstance().getCachedRuntimeExceptionDao(MyAlbum.class);
            dao.callBatchTasks(new Callable() {
                @Override
                public Void call() throws Exception {
                    try {
                        if (dao.idExists(albumId)) {
                            UpdateBuilder<MyAlbum, Long> ub = dao.updateBuilder();
                            ub.where().eq("id", albumId);
                            ub.updateColumnValue("coverPhotoId", coverPhotoId);
                            ub.updateColumnValue("isCoverVideo", isCoverVideo);
                            ub.update();
                        }
                    } catch (Exception e) {
                        Log.w(TAG, e.getMessage());
                    }
                    return null;
                }
            });

            List<Long> changed = new ArrayList<>();
            changed.add(albumId);

            callback.onCompleted(0, changed);
        }
    });
}
 

/**
 * timed invokeAll(,,null) throws NPE
 */
public void testTimedInvokeAllNullTimeUnit() throws Exception {
    final ExecutorService e = new ScheduledThreadPoolExecutor(2);
    try (PoolCleaner cleaner = cleaner(e)) {
        List<Callable<String>> l = new ArrayList<>();
        l.add(new StringTask());
        try {
            e.invokeAll(l, randomTimeout(), null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }
}
 

@SuppressWarnings("rawtypes")
private static void updateACLs(final HBaseTestingUtility util, Callable c) throws Exception {
  // Get the current mtimes for all access controllers
  final Map<AccessController,Long> oldMTimes = getAuthManagerMTimes(util.getHBaseCluster());

  // Run the update action
  c.call();

  // Wait until mtimes for all access controllers have incremented
  util.waitFor(WAIT_TIME, 100, new Predicate<IOException>() {
    @Override
    public boolean evaluate() throws IOException {
      Map<AccessController,Long> mtimes = getAuthManagerMTimes(util.getHBaseCluster());
      for (Map.Entry<AccessController,Long> e: mtimes.entrySet()) {
        if (!oldMTimes.containsKey(e.getKey())) {
          LOG.error("Snapshot of AccessController state does not include instance on region " +
            e.getKey().getRegion().getRegionInfo().getRegionNameAsString());
          // Error out the predicate, we will try again
          return false;
        }
        long old = oldMTimes.get(e.getKey());
        long now = e.getValue();
        if (now <= old) {
          LOG.info("AccessController on region " +
            e.getKey().getRegion().getRegionInfo().getRegionNameAsString() +
            " has not updated: mtime=" + now);
          return false;
        }
      }
      return true;
    }
  });
}
 

@Test
public void badRequest() {
    TestHelper.assertBadRequestReported(Flowable.generate(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                return 1;
            }
        }, new BiConsumer<Object, Emitter<Object>>() {
            @Override
            public void accept(Object s, Emitter<Object> e) throws Exception {
                e.onComplete();
            }
        }, Functions.emptyConsumer()));
}
 

BufferBoundaryObserver(Observer<? super U> actual,
        ObservableSource<? extends Open> bufferOpen,
        Function<? super Open, ? extends ObservableSource<? extends Close>> bufferClose,
                Callable<U> bufferSupplier) {
    super(actual, new MpscLinkedQueue<U>());
    this.bufferOpen = bufferOpen;
    this.bufferClose = bufferClose;
    this.bufferSupplier = bufferSupplier;
    this.buffers = new LinkedList<U>();
    this.resources = new CompositeDisposable();
}
 

/**
 * Rx version of {@link AbstractDaoSession#runInTx(Runnable)} returning an Observable.
 */
@Experimental
public Observable<Void> run(final Runnable runnable) {
    return wrap(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            daoSession.runInTx(runnable);
            return null;
        }
    });
}
 

@Test(expected = OperationNotPermittedException.class)
public void testUpdateAccountInformationDifferentUsersData()
        throws Exception {
    container.login(String.valueOf(supplier1User.getKey()));
    final VOUserDetails user = idManagement.getCurrentUserDetails();
    createCustomerAndUser(true);
    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            accountMgmt.updateAccountInformation(null, user, null, null);
            return null;
        }
    });
}
 

@Test
public void testLog_ModdateModUser() throws Throwable {
    runTX(new Callable<Void>() {
        public Void call() throws Exception {
            addSubscription(false, false);
            addUsageLicense();
            return null;
        }
    });
    final String initialUserId = user.getUserId();
    runTX(new Callable<Void>() {
        public Void call() throws Exception {
            user = (PlatformUser) mgr.find(user);
            user.setUserId("NewUserId");
            return null;
        }
    });
    new LogQueryRunner() {

        @Override
        protected void assertResult(List<?> result) {
            assertEquals(2, result.size());
            for (Object object : result) {
                Object[] usageLicense = (Object[]) object;
                assertEquals(
                        "Wrong PlatformUserHistory entry (for moduser)",
                        initialUserId, usageLicense[2]);
            }
            user = (PlatformUser) mgr.find(user);
            assertEquals("NewUserId", user.getUserId());
        }
    }.run();
}
 

/**
 * Test for ResultSet.updateObject(), non-updatable ResultSet behaviour.
 */
public void testNonUpdResultSetUpdateObject() throws Exception {
    this.rs = this.stmt.executeQuery("SELECT 'testResultSetUpdateObject' AS test");

    final ResultSet rsTmp = this.rs;
    assertThrows(NotUpdatable.class, "Result Set not updatable.*", new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            rsTmp.updateObject(1, rsTmp.toString(), JDBCType.VARCHAR);
            return null;
        }
    });
    assertThrows(NotUpdatable.class, "Result Set not updatable.*", new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            rsTmp.updateObject(1, rsTmp.toString(), JDBCType.VARCHAR, 10);
            return null;
        }
    });
    assertThrows(NotUpdatable.class, "Result Set not updatable.*", new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            rsTmp.updateObject("test", rsTmp.toString(), JDBCType.VARCHAR);
            return null;
        }
    });
    assertThrows(NotUpdatable.class, "Result Set not updatable.*", new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            rsTmp.updateObject("test", rsTmp.toString(), JDBCType.VARCHAR, 10);
            return null;
        }
    });
}
 

/**
 * Creates and persists a controller specific configuration setting.
 * 
 * @param controllerId
 * @param settingKey
 * @param value
 * @throws Exception
 */
private void createContorllerConfigSetting(final String controllerId,
        final String settingKey, final String value) throws Exception {
    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            ConfigurationSetting cs = new ConfigurationSetting();
            cs.setControllerId(controllerId);
            cs.setSettingKey(settingKey);
            cs.setSettingValue(value);
            em.persist(cs);
            return null;
        }
    });
}
 

@Test
public void customerEventReport_FallbackDefaultLocale() throws Exception {
    sessions.clear();

    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            PlatformUser uAdmin = mgr.find(testUsers
                    .get(testOrganizations.get("A").get(0)).get(1));
            uAdmin.setLocale("ja");
            mgr.persist(uAdmin);

            Session session = new Session();
            session.setPlatformUserKey(uAdmin.getKey());
            sessions.add(session);

            VOReportResult result = reporting.getReport(VALID_SESSION_ID,
                    "Event");

            assertEquals(3, result.getData().size());
            for (Object obj : result.getData()) {
                Element e = (Element) obj;
                assertEquals("en",
                        e.getLastChild().getFirstChild().getNodeValue());
            }

            return null;
        }
    });
}
 

/**
 * http GET请求获得jsapi_ticket（有效期7200秒，开发者必须在自己的服务全局缓存jsapi_ticket）
 *
 * @param jsApiType jsApi类型
 * @return JsTicket
 */
public static JsTicket getTicket(JsApiType jsApiType) {
    String access_token = AccessTokenApi.getAccessTokenStr();
    String appId = ApiConfigKit.getApiConfig().getAppId();
    String key = appId + ':' + jsApiType.name();
    final ParaMap pm = ParaMap.create("access_token", access_token).put("type", jsApiType.name());

    // 2016.07.21修改By L.cm 为了更加方便扩展
    String jsTicketJson = ApiConfigKit.getAccessTokenCache().get(key);
    JsTicket jsTicket = null;
    if (StrKit.notBlank(jsTicketJson)) {
        jsTicket = new JsTicket(jsTicketJson);
    }
    if (null == jsTicket || !jsTicket.isAvailable()) {
        // 最多三次请求
        jsTicket = RetryUtils.retryOnException(3, new Callable<JsTicket>() {

            @Override
            public JsTicket call() throws Exception {
                return new JsTicket(HttpUtils.get(apiUrl, pm.getData()));
            }

        });

        if (null != jsApiType) {
            ApiConfigKit.getAccessTokenCache().set(key, jsTicket.getCacheJson());
        }

    }
    return jsTicket;
}
 

private Future<Void> doAppend(final ClientWrapper client,
                              final ThriftFlumeEvent e) throws Exception {

  return callTimeoutPool.submit(new Callable<Void>() {
    @Override
    public Void call() throws Exception {
      Status status = client.client.append(e);
      if (status != Status.OK) {
        throw new EventDeliveryException("Failed to deliver events. Server " +
            "returned status : " + status.name());
      }
      return null;
    }
  });
}
 

@Before
public void setupData() throws Exception {
    runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            setupUserGroup();
            setupPlatformUser();
            return null;
        }
    });
}
 

public GitBranch updateTracking (final String localBranchName, final String remoteBranchName,
        final ProgressMonitor monitor) throws GitException {
    return new CommandInvoker().runMethod(new Callable<GitBranch>() {

        @Override
        public GitBranch call () throws Exception {
            return delegate.setUpstreamBranch(localBranchName, remoteBranchName, monitor);
        }
    }, "setUpstreamBranch"); //NOI18N
}
 

@SuppressWarnings("unchecked")
private void onMemberSelect(MemberInstance<?> member) {
	final int cMemberId = ++memberId;

	memberList.getItems().clear();

	if (member == null) return;
	if (member.getCls().getMatch() == null) return;

	Callable<List<? extends RankResult<? extends MemberInstance<?>>>> ranker;

	if (member instanceof MethodInstance) {
		ranker = () -> MethodClassifier.rank((MethodInstance) member, member.getCls().getMatch().getMethods(), gui.getMatcher().getAutoMatchLevel(), gui.getEnv());
	} else {
		ranker = () -> FieldClassifier.rank((FieldInstance) member, member.getCls().getMatch().getFields(), gui.getMatcher().getAutoMatchLevel(), gui.getEnv());
	}

	// update matches list
	Gui.runAsyncTask(ranker)
	.whenComplete((res, exc) -> {
		if (exc != null) {
			exc.printStackTrace();
		} else if (cMemberId == memberId) {
			memberList.getItems().setAll((List<RankResult<MemberInstance<?>>>) res);

			/*if (prevMatchSelection != null) { // reselect the previously selected entry
				for (int i = 0; i < memberList.getItems().size(); i++) {
					if (memberList.getItems().get(i).getSubject() == prevMatchSelection) {
						memberList.getSelectionModel().select(i);
						break;
					}
				}
			}*/

			if (memberList.getSelectionModel().isEmpty()) {
				memberList.getSelectionModel().selectFirst();
			}
		}
	});
}
 

private Product createCustomerSpecificCopiedProduct(
        final Organization customer, final Product product,
        final ServiceStatus status) throws Exception {
    return runTX(new Callable<Product>() {
        @Override
        public Product call() throws Exception {
            return Products.createCustomerSpecifcProduct(ds, customer,
                    product, status);
        }
    });
}
 

@Test
public void test_simple() {
    final WeightBarrier barrier = new WeightBarrier(10);
    try {
        barrier.await(10);// 可以成功通过
    } catch (InterruptedException e1) {
        want.fail();
    }

    try {
        final CountDownLatch count = new CountDownLatch(1);
        ExecutorService executor = Executors.newCachedThreadPool();

        executor.submit(new Callable() {

            public Object call() throws Exception {
                Thread.sleep(1000);
                barrier.single(11);
                count.countDown();
                return null;
            }
        });

        barrier.await(11);// 会被阻塞
        count.await();
        executor.shutdown();
    } catch (InterruptedException e) {
        want.fail();
    }
}
 

private static Future<Void> runAsync(RunnableWithException runnable) {
    Callable<Void> callable = () -> {
        runnable.run();
        return null;
    };
    return ForkJoinPool.commonPool().submit(callable);
}
 

private static List<Callable<String>> createTasks(int n) {
  List<Callable<String>> callables = Lists.newArrayList();
  for (int i = 0; i < n; i++) {
    callables.add(Callables.returning(RESULT_VALUE + i));
  }
  return callables;
}
 

@Override
public TaskInputFilePropertyBuilderInternal dir(final Object dirPath) {
    return taskMutator.mutate("TaskInputs.dir(Object)", new Callable<TaskInputFilePropertyBuilderInternal>() {
        @Override
        public TaskInputFilePropertyBuilderInternal call() {
            return addSpec(resolver.resolveFilesAsTree(dirPath));
        }
    });
}
 

public Future<Void> untagAllAsync(final String guid, EvernoteCallback<Void> callback) {
    return submitTask(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            untagAll(guid);
            return null;
        }
    }, callback);
}
 

public Future<Note> getNoteVersionAsync(final String noteGuid, final int updateSequenceNum, final boolean withResourcesData,
                                        final boolean withResourcesRecognition, final boolean withResourcesAlternateData, EvernoteCallback<Note> callback) {

    return submitTask(new Callable<Note>() {
        @Override
        public Note call() throws Exception {
            return getNoteVersion(noteGuid, updateSequenceNum, withResourcesData, withResourcesRecognition, withResourcesAlternateData);
        }
    }, callback);
}
 

private Void createUnitUserRoles() throws Exception {
    return runTX(new Callable<Void>() {
        @Override
        public Void call() throws Exception {
            UnitUserRoles.createSetupRoles(ds);
            return null;
        }
    });
}
 

/**
 * Sets the stub of FindMappingByKeyGlobalOperation.doGlobalExecuteAsync(IStoreTransactionScope ts)
 */
@Override
public Callable<StoreResults> doGlobalExecuteAsync(IStoreTransactionScope ts) {
    Func1Param<IStoreTransactionScope, Callable<StoreResults>> func1 = (IStoreTransactionScope arg) -> doGlobalExecuteAsyncIStoreTransactionScope
            .invoke(arg);
    if (doGlobalExecuteAsyncIStoreTransactionScope != null) {
        return func1.invoke(ts);
    }
    if (this.callBase) {
        return super.doGlobalExecuteAsync(ts);
    }
    return this.getInstanceBehavior().result(this, "doGlobalExecuteAsync");
}
 

@Test
public void testGetCurrentUserExisting() throws Exception {
    PlatformUser user = createOrgAndUser();
    PlatformUser currentUser = runTX(new Callable<PlatformUser>() {
        @Override
        public PlatformUser call() throws Exception {
            return mgr.getCurrentUser();
        }
    });
    Assert.assertEquals(user.getOrganization().getOrganizationId(),
            currentUser.getOrganization().getOrganizationId());
    Assert.assertEquals(user.getUserId(), currentUser.getUserId());
}
 

public BrowserEvaluate() {
    dependsOn(new Callable<TaskDependency>() {
        public TaskDependency call() throws Exception {
            return getProject().files(BrowserEvaluate.this.content).getBuildDependencies();
        }
    });
}
 

private Long[] prepareProducts(final ServiceStatus status,
        Organization supplier) throws Exception {
    final Organization supplier1 = supplier;

    Long[] productKeys = runTX(new Callable<Long[]>() {
        @Override
        public Long[] call() throws Exception {

            Organization provider = Organizations.createOrganization(mgr,
                    OrganizationRoleType.TECHNOLOGY_PROVIDER);

            TechnicalProduct tp = TechnicalProducts.createTechnicalProduct(
                    mgr, provider, "testTechProd", false,
                    ServiceAccessType.LOGIN);
            Product product1 = Products.createProduct(supplier1, tp, true,
                    "testProd1", null, mgr);

            PaymentType pt1 = findPaymentType(CREDIT_CARD, mgr);
            ProductToPaymentType prodToPt1 = new ProductToPaymentType(
                    product1, pt1);
            mgr.persist(prodToPt1);

            Product product2 = Products.createProduct(supplier1, tp, false,
                    "testProd2", null, mgr);
            if (status != null) {
                product2.setStatus(status);
            }
            PaymentType pt2 = findPaymentType(INVOICE, mgr);
            ProductToPaymentType prodToPt2 = new ProductToPaymentType(
                    product2, pt2);
            mgr.persist(prodToPt2);

            return new Long[] { Long.valueOf(product1.getKey()),
                    Long.valueOf(product2.getKey()) };
        }
    });
    return productKeys;
}
 

/**
 * Check whether this script object is sealed
 * @return true if sealed
 */
public boolean isSealed() {
    return inGlobal(new Callable<Boolean>() {
        @Override public Boolean call() {
            return sobj.isSealed();
        }
    });
}